isNumber

Checks whether a value is of number type.

Basic Usage

import { isNumber } from 'radash'

console.log(isNumber(123))           // true
console.log(isNumber(3.14))          // true
console.log(isNumber('123'))         // false
console.log(isNumber(NaN))           // false
console.log(isNumber(Infinity))      // false

Syntax

function isNumber(value: any): value is number

Parameters

• value (any): The value to check

Return Value

Returns a boolean value indicating whether the value is a valid number type. This is a type guard function.

Examples

Basic Number Checking

import { isNumber } from 'radash'

// Integers
console.log(isNumber(0))             // true
console.log(isNumber(123))           // true
console.log(isNumber(-456))          // true
console.log(isNumber(Number.MAX_SAFE_INTEGER)) // true

// Floats
console.log(isNumber(3.14))          // true
console.log(isNumber(-2.5))          // true
console.log(isNumber(0.0))           // true
console.log(isNumber(1e10))          // true

Handling Special Number Values

import { isNumber } from 'radash'

// NaN is not a valid number
console.log(isNumber(NaN))           // false

// Infinity is not a valid number
console.log(isNumber(Infinity))      // false
console.log(isNumber(-Infinity))     // false

// Zero values
console.log(isNumber(0))             // true
console.log(isNumber(-0))            // true

Handling String Numbers

import { isNumber } from 'radash'

// Strings are not number types
console.log(isNumber('123'))         // false
console.log(isNumber('3.14'))        // false
console.log(isNumber('0'))           // false
console.log(isNumber(''))            // false
console.log(isNumber('hello'))       // false

Handling Other Types

import { isNumber } from 'radash'

// Booleans
console.log(isNumber(true))          // false
console.log(isNumber(false))         // false

// null and undefined
console.log(isNumber(null))          // false
console.log(isNumber(undefined))     // false

// Objects and arrays
console.log(isNumber({}))            // false
console.log(isNumber([]))            // false
console.log(isNumber({ value: 123 })) // false

// Functions
console.log(isNumber(() => {}))      // false
console.log(isNumber(function() {})) // false

// Symbol
console.log(isNumber(Symbol()))      // false

Type Guard Usage

import { isNumber } from 'radash'

function processValue(value: unknown) {
  if (isNumber(value)) {
    // TypeScript knows value is number type
    return value * 2
  }
  
  return 'Not a number'
}

console.log(processValue(5))         // 10
console.log(processValue('hello'))   // 'Not a number'
console.log(processValue(null))      // 'Not a number'

Array Filtering

import { isNumber } from 'radash'

const mixedArray = [1, 'hello', 3.14, true, 0, 'world', -5]

const numbers = mixedArray.filter(isNumber)
console.log(numbers) // [1, 3.14, 0, -5]

// Calculate sum of numbers
const sum = mixedArray
  .filter(isNumber)
  .reduce((acc, num) => acc + num, 0)

console.log(sum) // -0.86 (1 + 3.14 + 0 + (-5))

Form Validation

import { isNumber } from 'radash'

function validateFormData(data: Record<string, any>) {
  const errors: string[] = []
  
  if (!isNumber(data.age)) {
    errors.push('Age must be a number')
  }
  
  if (!isNumber(data.score)) {
    errors.push('Score must be a number')
  }
  
  if (isNumber(data.age) && data.age < 0) {
    errors.push('Age cannot be negative')
  }
  
  if (isNumber(data.score) && (data.score < 0 || data.score > 100)) {
    errors.push('Score must be between 0 and 100')
  }
  
  return errors
}

const formData = {
  name: 'Alice',
  age: '25', // string, not a number
  score: 85
}

const errors = validateFormData(formData)
console.log(errors) // ['Age must be a number']

API Response Processing

import { isNumber } from 'radash'

function processApiResponse(response: any) {
  const processed = {
    id: isNumber(response.id) ? response.id : 0,
    count: isNumber(response.count) ? response.count : 0,
    rating: isNumber(response.rating) ? response.rating : 0,
    price: isNumber(response.price) ? response.price : 0
  }
  
  return processed
}

const apiResponse = {
  id: '123', // string
  count: 45,
  rating: null,
  price: 99.99
}

const processed = processApiResponse(apiResponse)
console.log(processed) // { id: 0, count: 45, rating: 0, price: 99.99 }

Mathematical Calculations

import { isNumber } from 'radash'

function safeMathOperation(a: unknown, b: unknown, operation: 'add' | 'subtract' | 'multiply' | 'divide') {
  if (!isNumber(a) || !isNumber(b)) {
    throw new Error('Both operands must be numbers')
  }
  
  switch (operation) {
    case 'add':
      return a + b
    case 'subtract':
      return a - b
    case 'multiply':
      return a * b
    case 'divide':
      if (b === 0) {
        throw new Error('Division by zero')
      }
      return a / b
    default:
      throw new Error('Invalid operation')
  }
}

console.log(safeMathOperation(5, 3, 'add'))      // 8
console.log(safeMathOperation(10, 4, 'divide'))  // 2.5

try {
  safeMathOperation('5', 3, 'add')
} catch (error) {
  console.log(error.message) // 'Both operands must be numbers'
}

Configuration Validation

import { isNumber } from 'radash'

function validateConfig(config: any) {
  const errors: string[] = []
  
  const requiredNumbers = [
    { key: 'port', min: 1, max: 65535 },
    { key: 'timeout', min: 0, max: 300000 },
    { key: 'maxConnections', min: 1, max: 1000 }
  ]
  
  for (const { key, min, max } of requiredNumbers) {
    const value = config[key]
    
    if (!isNumber(value)) {
      errors.push(`${key} must be a number`)
    } else if (value < min || value > max) {
      errors.push(`${key} must be between ${min} and ${max}`)
    }
  }
  
  return errors
}

const config = {
  port: '3000', // string
  timeout: 5000,
  maxConnections: 100
}

const errors = validateConfig(config)
console.log(errors) // ['port must be a number']

Data Cleaning

import { isNumber } from 'radash'

function cleanNumericData(data: any[]) {
  return data
    .filter(isNumber)
    .filter(num => !isNaN(num) && isFinite(num))
}

const rawData = [1, 'hello', 3.14, NaN, Infinity, -5, 'world', 0, null]

const cleanData = cleanNumericData(rawData)
console.log(cleanData) // [1, 3.14, -5, 0]

Type-Safe Calculations

import { isNumber } from 'radash'

function calculateAverage(values: unknown[]): number {
  const numbers = values.filter(isNumber)
  
  if (numbers.length === 0) {
    return 0
  }
  
  const sum = numbers.reduce((acc, num) => acc + num, 0)
  return sum / numbers.length
}

const values = [1, 'hello', 3, 'world', 5, null, 7]

const average = calculateAverage(values)
console.log(average) // 4 (1 + 3 + 5 + 7 = 16, 16 / 4 = 4)

Parameter Validation

import { isNumber } from 'radash'

function createUser(name: string, age: unknown, score: unknown) {
  if (!isNumber(age) || age < 0 || age > 150) {
    throw new Error('Age must be a valid number between 0 and 150')
  }
  
  if (!isNumber(score) || score < 0 || score > 100) {
    throw new Error('Score must be a valid number between 0 and 100')
  }
  
  return {
    name,
    age,
    score,
    isAdult: age >= 18,
    grade: score >= 90 ? 'A' : score >= 80 ? 'B' : score >= 70 ? 'C' : 'D'
  }
}

try {
  const user = createUser('Alice', 25, 85)
  console.log(user) // { name: 'Alice', age: 25, score: 85, isAdult: true, grade: 'B' }
} catch (error) {
  console.log(error.message)
}

try {
  createUser('Bob', '30', 95) // age is string
} catch (error) {
  console.log(error.message) // 'Age must be a valid number between 0 and 150'
}

Notes

1. NaN Check: isNumber(NaN) returns false
2. Infinity Check: isNumber(Infinity) returns false
3. Type Guard: This is a TypeScript type guard function
4. Performance: Fast checking operation, suitable for frequent use
5. Strict Check: Only accepts true number types, not string numbers

Differences from Other Methods

• typeof value === 'number': Native check, but accepts NaN and Infinity
• Number.isFinite(value): Checks for finite numbers
• isNumber(): Strict number check provided by radash

Practical Application Scenarios

1. Form Validation: Validate user input number fields
2. API Processing: Validate number fields in API responses
3. Mathematical Calculations: Ensure type safety of calculation operands
4. Data Cleaning: Filter valid numbers from arrays
5. Configuration Validation: Validate numeric settings in configuration files