isArray

Checks whether a value is of array type.

Syntax

isArray(value: any): value is any[]

Parameters

• value (any): The value to check

Return Value

• value is any[]: Type predicate, returns true if the value is an array

Examples

Basic Usage

import { isArray } from 'radash'

isArray([1, 2, 3]) // true
isArray([]) // true
isArray('hello') // false
isArray(123) // false
isArray({}) // false
isArray(null) // false
isArray(undefined) // false

Type Safety

import { isArray } from 'radash'

const value: unknown = [1, 2, 3]

if (isArray(value)) {
  // TypeScript now knows value is an array
  value.push(4) // Type safe
  console.log(value.length) // Can access array properties
}

Handling Different Value Types

import { isArray } from 'radash'

// Arrays
isArray([1, 2, 3]) // true
isArray(['a', 'b', 'c']) // true
isArray([{ id: 1 }, { id: 2 }]) // true
isArray([]) // true

// Non-arrays
isArray('string') // false
isArray(42) // false
isArray(true) // false
isArray(false) // false
isArray(null) // false
isArray(undefined) // false
isArray({}) // false
isArray(() => {}) // false

Handling Array-like Objects

import { isArray } from 'radash'

// Array-like objects
isArray({ length: 3, 0: 'a', 1: 'b', 2: 'c' }) // false
isArray(document.querySelectorAll('div')) // false
isArray(new Set([1, 2, 3])) // false
isArray(new Map([['a', 1], ['b', 2]])) // false

// Real arrays
isArray([1, 2, 3]) // true
isArray(Array.from({ length: 3 })) // true
isArray(new Array(3)) // true

Handling Nested Arrays

import { isArray } from 'radash'

isArray([[1, 2], [3, 4]]) // true
isArray([[[1]], [[2]]]) // true
isArray([[], []]) // true
isArray([{ items: [1, 2, 3] }]) // true

Handling Nullish Values

import { isArray } from 'radash'

isArray(null) // false
isArray(undefined) // false
isArray('') // false
isArray(0) // false
isArray(false) // false
isArray(NaN) // false

Handling Function Parameters

import { isArray } from 'radash'

function processData(data: unknown) {
  if (isArray(data)) {
    // Handle array
    return data.map(item => item.toString())
  } else {
    // Handle non-array
    return [data?.toString() || '']
  }
}

processData([1, 2, 3]) // ['1', '2', '3']
processData('hello') // ['hello']
processData(null) // ['']

Handling API Responses

import { isArray } from 'radash'

async function fetchUsers() {
  const response = await fetch('/api/users')
  const data = await response.json()
  
  if (isArray(data)) {
    return data.map(user => ({
      id: user.id,
      name: user.name
    }))
  } else {
    throw new Error('Expected array of users')
  }
}

Handling Form Data

import { isArray } from 'radash'

function validateFormData(data: unknown) {
  if (!isArray(data)) {
    throw new Error('Form data must be an array')
  }
  
  return data.filter(item => 
    item && typeof item === 'object' && 'name' in item
  )
}

const formData = [
  { name: 'firstName', value: 'Alice' },
  { name: 'lastName', value: 'Smith' }
]

const validData = validateFormData(formData)
// [{ name: 'firstName', value: 'Alice' }, { name: 'lastName', value: 'Smith' }]

Handling Config Objects

import { isArray } from 'radash'

interface Config {
  features?: unknown
  users?: unknown
}

function processConfig(config: Config) {
  const features = isArray(config.features) ? config.features : []
  const users = isArray(config.users) ? config.users : []
  
  return {
    features: features.map(f => f.toString()),
    users: users.map(u => ({ ...u, id: u.id || Date.now() }))
  }
}

const config = {
  features: ['search', 'filter'],
  users: [{ name: 'Alice' }, { name: 'Bob' }]
}

const processed = processConfig(config)
// { features: ['search', 'filter'], users: [{ name: 'Alice', id: 1234567890 }, { name: 'Bob', id: 1234567891 }] }

Handling Recursive Checks

import { isArray } from 'radash'

function flattenArray(arr: unknown[]): unknown[] {
  const result: unknown[] = []
  
  for (const item of arr) {
    if (isArray(item)) {
      result.push(...flattenArray(item))
    } else {
      result.push(item)
    }
  }
  
  return result
}

const nested = [1, [2, 3], [4, [5, 6]]]
const flattened = flattenArray(nested)
// [1, 2, 3, 4, 5, 6]

Handling Type Guards

import { isArray } from 'radash'

function isStringArray(value: unknown): value is string[] {
  return isArray(value) && value.every(item => typeof item === 'string')
}

function isNumberArray(value: unknown): value is number[] {
  return isArray(value) && value.every(item => typeof item === 'number')
}

const stringArray = ['a', 'b', 'c']
const numberArray = [1, 2, 3]
const mixedArray = [1, 'a', true]

isStringArray(stringArray) // true
isNumberArray(numberArray) // true
isStringArray(numberArray) // false
isNumberArray(mixedArray) // false

Notes

1. Type Safety: Provides TypeScript type predicate
2. Performance: More reliable than instanceof Array
3. Cross-realm: Works correctly across different iframes
4. Nullish Values: Correctly handles null and undefined

Differences from Other Functions

• isArray: Checks if value is an array
• Array.isArray: Native method, same functionality
• instanceof Array: May fail across different iframes
• typeof: Cannot distinguish between arrays and objects

Performance

• Time Complexity: O(1)
• Space Complexity: O(1)
• Use Cases: Type checking, data validation