isEmpty

Checks whether a value is empty (null, undefined, empty string, empty array, empty object, etc.).

Syntax

isEmpty(value: any): boolean

Parameters

• value (any): The value to check

Return Value

• boolean: Returns true if the value is empty, false otherwise

Examples

Basic Usage

import { isEmpty } from 'radash'

isEmpty(null) // true
isEmpty(undefined) // true
isEmpty('') // true
isEmpty([]) // true
isEmpty({}) // true
isEmpty(0) // false
isEmpty('hello') // false
isEmpty([1, 2, 3]) // false
isEmpty({ key: 'value' }) // false

Handling Strings

import { isEmpty } from 'radash'

isEmpty('') // true
isEmpty('   ') // true (only contains spaces)
isEmpty('hello') // false
isEmpty('0') // false
isEmpty('false') // false

Handling Arrays

import { isEmpty } from 'radash'

isEmpty([]) // true
isEmpty([null]) // false
isEmpty([undefined]) // false
isEmpty([1, 2, 3]) // false
isEmpty(['']) // false

Handling Objects

import { isEmpty } from 'radash'

isEmpty({}) // true
isEmpty({ key: 'value' }) // false
isEmpty({ null: null }) // false
isEmpty({ undefined: undefined }) // false

Handling Numbers

import { isEmpty } from 'radash'

isEmpty(0) // false
isEmpty(1) // false
isEmpty(-1) // false
isEmpty(NaN) // false
isEmpty(Infinity) // false

Handling Booleans

import { isEmpty } from 'radash'

isEmpty(true) // false
isEmpty(false) // false

Handling Functions

import { isEmpty } from 'radash'

isEmpty(() => {}) // false
isEmpty(function() {}) // false
isEmpty(async () => {}) // false

Handling Dates

import { isEmpty } from 'radash'

isEmpty(new Date()) // false
isEmpty(new Date('invalid')) // false

Handling Map and Set

import { isEmpty } from 'radash'

isEmpty(new Map()) // true
isEmpty(new Map([['key', 'value']])) // false
isEmpty(new Set()) // true
isEmpty(new Set([1, 2, 3])) // false

Handling Regular Expressions

import { isEmpty } from 'radash'

isEmpty(/pattern/) // false
isEmpty(new RegExp('pattern')) // false

Handling Symbol

import { isEmpty } from 'radash'

isEmpty(Symbol()) // false
isEmpty(Symbol('description')) // false

Handling Class Instances

import { isEmpty } from 'radash'

class Example {
  constructor() {
    this.value = 'test'
  }
}

isEmpty(new Example()) // false
isEmpty(new Date()) // false
isEmpty(new Array()) // true
isEmpty(new Object()) // true

Form Validation

import { isEmpty } from 'radash'

function validateForm(data: any) {
  const errors: string[] = []
  
  if (isEmpty(data.name)) {
    errors.push('Name cannot be empty')
  }
  
  if (isEmpty(data.email)) {
    errors.push('Email cannot be empty')
  }
  
  if (isEmpty(data.hobbies)) {
    errors.push('Hobbies cannot be empty')
  }
  
  return errors
}

const formData = {
  name: '',
  email: 'alice@example.com',
  hobbies: []
}

const errors = validateForm(formData)
// ['Name cannot be empty', 'Hobbies cannot be empty']

API Response Processing

import { isEmpty } from 'radash'

async function fetchData() {
  const response = await fetch('/api/users')
  const data = await response.json()
  
  if (isEmpty(data)) {
    throw new Error('No data returned')
  }
  
  return data
}

try {
  const users = await fetchData()
  console.log('User data:', users)
} catch (error) {
  console.error('Failed to fetch data:', error.message)
}

Configuration Validation

import { isEmpty } from 'radash'

function validateConfig(config: any) {
  const requiredFields = ['apiKey', 'baseUrl', 'timeout']
  const missingFields = []
  
  for (const field of requiredFields) {
    if (isEmpty(config[field])) {
      missingFields.push(field)
    }
  }
  
  if (missingFields.length > 0) {
    throw new Error(`Missing required configuration: ${missingFields.join(', ')}`)
  }
  
  return config
}

const config = {
  apiKey: '',
  baseUrl: 'https://api.example.com',
  timeout: 5000
}

try {
  validateConfig(config)
} catch (error) {
  console.error('Configuration validation failed:', error.message)
  // Output: Configuration validation failed: Missing required configuration: apiKey
}

Data Cleaning

import { isEmpty } from 'radash'

function cleanData(data: any) {
  const cleaned: any = {}
  
  for (const [key, value] of Object.entries(data)) {
    if (!isEmpty(value)) {
      cleaned[key] = value
    }
  }
  
  return cleaned
}

const rawData = {
  name: 'Alice',
  email: '',
  phone: null,
  address: undefined,
  hobbies: [],
  notes: '   '
}

const cleanedData = cleanData(rawData)
// { name: 'Alice', notes: '   ' }

Conditional Rendering

import { isEmpty } from 'radash'

function renderUserProfile(user: any) {
  if (isEmpty(user)) {
    return '<div>User does not exist</div>'
  }
  
  if (isEmpty(user.avatar)) {
    return `
      <div>
        <h1>${user.name}</h1>
        <p>Default avatar</p>
      </div>
    `
  }
  
  return `
    <div>
      <h1>${user.name}</h1>
      <img src="${user.avatar}" alt="Avatar" />
    </div>
  `
}

Recursive Checking

import { isEmpty } from 'radash'

function deepIsEmpty(obj: any): boolean {
  if (isEmpty(obj)) {
    return true
  }
  
  if (Array.isArray(obj)) {
    return obj.every(item => deepIsEmpty(item))
  }
  
  if (typeof obj === 'object' && obj !== null) {
    return Object.values(obj).every(value => deepIsEmpty(value))
  }
  
  return false
}

const nestedData = {
  level1: {
    level2: {
      level3: []
    }
  }
}

deepIsEmpty(nestedData) // true

Notes

1. Empty Value Check: Checks for null, undefined, empty string, empty array, empty object
2. Whitespace Strings: Strings containing only spaces are considered empty
3. Numbers: 0 is not considered empty
4. Booleans: false is not considered empty

Differences from Other Functions

• isEmpty: Checks if value is empty
• isNull: Only checks for null
• isUndefined: Only checks for undefined
• isString: Checks if value is a string

Performance

• Time Complexity: O(1)
• Space Complexity: O(1)
• Use Cases: Data validation, form processing, API response checking