sift

过滤数组中的假值（falsy values），返回一个新数组。

基础用法

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]

语法

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

参数

• array (readonly T[]): 要过滤的数组

返回值

返回一个新数组，包含所有非假值元素。

示例

过滤基本假值

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]

过滤字符串数组

import { sift } from 'radash'

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

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

过滤数字数组

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] (移除了0和NaN)

过滤对象数组

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' }
// ]

过滤混合类型数组

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
// ]

处理嵌套数组

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]
// ]

处理函数数组

import { sift } from 'radash'

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

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

在API响应处理中使用

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 (移除了null和undefined)

处理表单数据

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']

处理配置对象

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]

处理事件监听器

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') // 只输出: Listener 2: Hello

处理数据库查询结果

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 }

注意事项

1. 假值过滤: 移除所有假值（false, 0, '', null, undefined, NaN）
2. 保持原数组不变: sift 不会修改原数组，而是返回新的数组
3. 类型安全: 返回的数组类型是 NonNullable<T>[]
4. 性能: 时间复杂度为 O(n)，其中 n 是数组长度
5. 空数组: 如果原数组为空或只包含假值，返回空数组

与其他方法的区别

• filter(): 需要提供过滤函数，sift 自动过滤假值
• compact(): 类似功能，但 sift 更简洁
• Array.prototype.filter(Boolean): 功能相同，但 sift 更直观

实际应用场景

1. 数据清理: 清理API响应中的无效数据
2. 表单验证: 过滤表单中的空值
3. 配置处理: 合并配置时过滤无效值
4. 事件处理: 清理事件监听器数组
5. 数据库查询: 处理可能包含null的查询结果