sift

Filter out falsy values from an array and return a new array.

Basic Usage

import { sift } from 'radash'

const mixedArray = [0, 1, false, 2, '', 3, null, 4, undefined, 5, NaN]

const filtered = sift(mixedArray)
// [1, 2, 3, 4, 5]

Syntax

function sift<T>(array: readonly T[]): NonNullable<T>[]

Parameters

• array (readonly T[]): The array to filter

Return Value

Returns a new array containing all non-falsy elements.

Examples

Filter Basic Falsy Values

import { sift } from 'radash'

const array = [0, 1, false, 2, '', 3, null, 4, undefined, 5, NaN]

const filtered = sift(array)
// [1, 2, 3, 4, 5]

Filter String Arrays

import { sift } from 'radash'

const strings = ['hello', '', 'world', '   ', 'javascript', null, 'typescript']

const filtered = sift(strings)
// ['hello', 'world', 'javascript', 'typescript']

Filter Number Arrays

import { sift } from 'radash'

const numbers = [0, 1, 2, 3, 4, 5, NaN, 6, 7, 8, 9, 10]

const filtered = sift(numbers)
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] (removed 0 and NaN)

Filter Object Arrays

import { sift } from 'radash'

const users = [
  { id: 1, name: 'Alice' },
  null,
  { id: 2, name: 'Bob' },
  undefined,
  { id: 3, name: 'Charlie' },
  false
]

const filtered = sift(users)
// [
//   { id: 1, name: 'Alice' },
//   { id: 2, name: 'Bob' },
//   { id: 3, name: 'Charlie' }
// ]

Filter Mixed Type Arrays

import { sift } from 'radash'

const mixed = [
  'hello',
  0,
  { key: 'value' },
  false,
  [1, 2, 3],
  '',
  null,
  undefined,
  NaN,
  true
]

const filtered = sift(mixed)
// [
//   'hello',
//   { key: 'value' },
//   [1, 2, 3],
//   true
// ]

Handle Nested Arrays

import { sift } from 'radash'

const nested = [
  [1, 2, 3],
  null,
  [4, 5, 6],
  undefined,
  [7, 8, 9]
]

const filtered = sift(nested)
// [
//   [1, 2, 3],
//   [4, 5, 6],
//   [7, 8, 9]
// ]

Handle Function Arrays

import { sift } from 'radash'

const functions = [
  () => 'hello',
  null,
  (x: number) => x * 2,
  undefined,
  () => 'world'
]

const filtered = sift(functions)
// [
//   () => 'hello',
//   (x: number) => x * 2,
//   () => 'world'
// ]

Using in API Response Processing

import { sift } from 'radash'

interface ApiResponse {
  data: (User | null)[]
  total: number
}

interface User {
  id: number
  name: string
  email: string
}

function processApiResponse(response: ApiResponse) {
  const validUsers = sift(response.data)
  
  return {
    users: validUsers,
    total: validUsers.length
  }
}

const response: ApiResponse = {
  data: [
    { id: 1, name: 'Alice', email: 'alice@example.com' },
    null,
    { id: 2, name: 'Bob', email: 'bob@example.com' },
    undefined,
    { id: 3, name: 'Charlie', email: 'charlie@example.com' }
  ],
  total: 5
}

const processed = processApiResponse(response)
console.log(processed.users.length) // 3 (removed null and undefined)

Processing Form Data

import { sift } from 'radash'

function processFormData(formData: Record<string, any>) {
  const values = Object.values(formData)
  const validValues = sift(values)
  
  return validValues.length > 0 ? validValues : ['No valid data']
}

const formData = {
  name: 'John',
  email: '',
  age: 25,
  phone: null,
  address: '   ',
  city: 'New York'
}

const validData = processFormData(formData)
console.log(validData) // ['John', 25, 'New York']

Processing Configuration Objects

import { sift } from 'radash'

function mergeConfigs(...configs: Record<string, any>[]) {
  const allValues = configs.flatMap(config => Object.values(config))
  const validValues = sift(allValues)
  
  return validValues
}

const config1 = { theme: 'dark', language: null, notifications: true }
const config2 = { theme: undefined, language: 'en', sound: false }

const merged = mergeConfigs(config1, config2)
console.log(merged) // ['dark', true, 'en', false]

Processing Event Listeners

import { sift } from 'radash'

class EventEmitter {
  private listeners: Record<string, (Function | null)[]> = {}

  on(event: string, listener: Function) {
    if (!this.listeners[event]) {
      this.listeners[event] = []
    }
    this.listeners[event].push(listener)
  }

  off(event: string, listener: Function) {
    if (this.listeners[event]) {
      const index = this.listeners[event].indexOf(listener)
      if (index > -1) {
        this.listeners[event][index] = null
      }
    }
  }

  emit(event: string, ...args: any[]) {
    if (this.listeners[event]) {
      const validListeners = sift(this.listeners[event])
      validListeners.forEach(listener => listener(...args))
    }
  }
}

const emitter = new EventEmitter()
const listener1 = (data: any) => console.log('Listener 1:', data)
const listener2 = (data: any) => console.log('Listener 2:', data)

emitter.on('test', listener1)
emitter.on('test', listener2)
emitter.off('test', listener1)

emitter.emit('test', 'Hello') // Only outputs: Listener 2: Hello

Processing Database Query Results

import { sift } from 'radash'

interface DatabaseResult {
  id: number
  name: string
  value: number | null
}

function processDatabaseResults(results: DatabaseResult[]) {
  const validResults = sift(results)
  
  return {
    total: validResults.length,
    average: validResults.reduce((sum, result) => sum + result.value, 0) / validResults.length
  }
}

const results: DatabaseResult[] = [
  { id: 1, name: 'Item 1', value: 10 },
  { id: 2, name: 'Item 2', value: null },
  { id: 3, name: 'Item 3', value: 20 },
  { id: 4, name: 'Item 4', value: 30 }
]

const processed = processDatabaseResults(results)
console.log(processed) // { total: 3, average: 20 }

Notes

1. Falsy value filtering: Removes all falsy values (false, 0, '', null, undefined, NaN)
2. Keep original array unchanged: sift does not modify the original array, but returns a new array
3. Type safety: The returned array type is NonNullable<T>[]
4. Performance: Time complexity is O(n), where n is the array length
5. Empty arrays: If the original array is empty or contains only falsy values, returns an empty array

Differences from Other Methods

• filter(): Requires providing a filter function, sift automatically filters falsy values
• compact(): Similar functionality, but sift is more concise
• Array.prototype.filter(Boolean): Same functionality, but sift is more intuitive

Practical Application Scenarios

1. Data cleaning: Clean invalid data from API responses
2. Form validation: Filter empty values from forms
3. Configuration processing: Filter invalid values when merging configurations
4. Event handling: Clean event listener arrays
5. Database queries: Process query results that may contain null values