概览
some、every、find、includes 都是数组的“判断/查找”方法：

  • some()：只要有一个满足条件就返回 true
  • every()：所有元素都满足条件才返回 true
  • find()：返回第一个满足条件的元素（找不到则 undefined）
  • includes()：判断是否包含指定值（返回 true/false）

语法

1
2
3
4
array.some((element, index, array) => boolean)
array.every((element, index, array) => boolean)
array.find((element, index, array) => boolean)
array.includes(searchElement, fromIndex?)

some() 常见模式

  • 判断是否存在符合条件的元素

    1
    2
    const nums = [1, 3, 5, 8]
    const hasEven = nums.some(n => n % 2 === 0)  // true

  • 对象数组中是否包含满足条件的项

    1
    2
    const users = [{id:1, role:'user'}, {id:2, role:'admin'}]
    const hasAdmin = users.some(u => u.role === 'admin') // true

every() 常见模式

  • 判断是否全部满足条件

    1
    2
    const scores = [80, 95, 88]
    const allPass = scores.every(s => s >= 60)   // true

  • 验证表单输入是否都非空

    1
    2
    const fields = ['张三', '13800000000', '上海']
    const allFilled = fields.every(Boolean)      // true

find() 常见模式

  • 查找第一个匹配的元素（对象）

    1
    2
    const list = [{id:1, name:'A'}, {id:2, name:'B'}]
    const item = list.find(x => x.id === 2)      // {id:2, name:'B'}

  • 使用索引（场景：找第一个超过阈值的元素）

    1
    2
    const arr = [5, 9, 12]
    const firstBig = arr.find((n, i) => n > 10 && i >= 1) // 12

includes() 常见模式

  • 判断是否包含某值

    1
    2
    const tags = ['js', '数组', 'ES6']
    const hasJs = tags.includes('js')             // true

  • 指定起始位置

    1
    2
    3
    4
    const arr = [1, 2, 3, 2]
    arr.includes(2)            // true
    arr.includes(2, 2)         // true（从索引2开始，包含2）
    arr.includes(2, 3)         // false（从索引3开始）

返回值与差异对比

1
2
3
4
5
6
const arr = [1, 2, 3, 4]

arr.some(n => n > 3)        // true
arr.every(n => n > 3)       // false
arr.find(n => n > 3)        // 4
arr.includes(3)             // true

容易踩坑（重点）

  1. some/every/find 回调必须 return 布尔值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    const nums = [1, 2, 3]

    // ❌ 忘记 return：回调返回 undefined，结果永远为 false / undefined
    nums.some(n => { n > 2 })   // false
    nums.find(n => { n > 2 })   // undefined

    // ✅ 正确：显式或隐式 return
    nums.some(n => n > 2)       // true
    nums.find(n => n > 2)       // 3

  2. find() 只返回“第一个匹配项”，不是所有匹配项

    1
    2
    3
    const arr = [1, 2, 3, 4]
    arr.find(n => n % 2 === 0)  // 2
    // 若需要所有匹配项，用 filter()

  3. includes() 与 indexOf() 的差异

  • includes() 能正确处理 NaN，indexOf() 不能
    1
    2
    3
    const arr = [1, NaN, 3]
    arr.includes(NaN)   // true
    arr.indexOf(NaN)    // -1

  1. includes() 判断对象是“引用相等”，不是内容相等

    1
    2
    3
    4
    5
    const list = [{id:1}]
    list.includes({id:1})        // false

    const same = list[0]
    list.includes(same)          // true

    如果需要深入判断内容（如对象字段是否匹配），使用 some() + 自定义条件：

    1
    2
    const list2 = [{id:1, name:'A'}, {id:2, name:'B'}]
    const hasId2 = list2.some(item => item.id === 2)  // true

  2. every() 在空数组上返回 true

    1
    [].every(x => x > 0)         // true（空集合“全部满足”）

    如果不希望这样，需先判断长度：arr.length > 0 && arr.every(...)

  3. some() 在空数组上返回 false

    1
    [].some(x => x > 0)          // false

  4. find() 找不到返回 undefined，别直接解构或调用属性

    1
    2
    3
    4
    5
    const users = [{id:1, name:'A'}]
    const u = users.find(x => x.id === 2) // undefined
    // ❌ u.name 会报错
    // ✅ 使用可选链或默认值
    const name = u?.name ?? '未知'

与 map/filter 的区别（快速对照）

1
2
3
4
5
6
7
const arr = [1, 2, 3]
arr.map(n => n * 2)           // [2, 4, 6]   转换
arr.filter(n => n > 1)        // [2, 3]      筛选
arr.some(n => n > 1)          // true        存在性判断
arr.every(n => n > 1)         // false       全部判断
arr.find(n => n > 1)          // 2           查找单个
arr.includes(2)               // true        是否包含

实用小技巧

  • 用 every(Boolean) 快速判断全为真值
  • 用 some() 替代手写循环的“是否存在”逻辑
  • find() + ?? 设置默认值：
    1
    const user = list.find(u => u.id === id) ?? { id, name: '未命名' }