JavaScriptincludes方法使用详解

JavaScript的`Array.prototype.includes`方法是检查数组中是否存在特定元素的利器，返回布尔值，提升代码可读性。其语法`arr.includes(value, fromIndex)`，value为待查找元素，fromIndex为可选的起始搜索索引。相较于`indexOf`，`includes`语义更清晰，且能正确处理`NaN`值的查找。然而，对于对象等复杂类型，`includes`比较的是引用而非内容，需结合`some`方法自定义比较逻辑。在大数组中频繁使用`includes`可能存在性能问题，时间复杂度为O(n)，此时可考虑使用`Set`，其`has`方法平均时间复杂度为O(1)，适用于查找频繁且数据相对稳定的场景。掌握`includes`的特性与适用场景，能编写出更高效、更健壮的JavaScript代码。

JavaScript 中 Array.prototype.includes 方法用于快速判断数组是否包含特定元素，返回布尔值。1. 语法为 arr.includes(searchElement[, fromIndex])，searchElement 是查找的元素，fromIndex 是可选的起始索引，默认从 0 开始；2. includes 方法直接返回 true 或 false，语义清晰且处理 NaN 更可靠，indexOf 则因返回索引需额外判断；3. 对于对象或数组等复杂数据类型，includes 使用严格相等（===）比较引用而非内容，需借助 some 方法结合自定义逻辑实现深度比较；4. 在大型数组中频繁使用 includes 性能较差，时间复杂度为 O(n)，可用 Set 替代，其 has 方法平均时间复杂度为 O(1)，适用于查找操作多、数据较稳定的场景。

Array.prototype.includes 方法是 JavaScript 中一个非常实用的工具，它能帮助我们快速判断一个数组是否包含某个特定的元素，并直接返回一个布尔值（true 或 false）。这比我们以前用 indexOf 然后判断是否等于 -1 要直观得多。

解决方案

使用 includes 方法非常直接。它的基本语法是 arr.includes(searchElement[, fromIndex])。

• searchElement：你想要在数组中查找的元素。
• fromIndex (可选)：从数组的哪个索引位置开始搜索。如果省略，默认从索引 0 开始。如果 fromIndex 大于或等于数组的长度，includes 会直接返回 false，不会进行搜索。如果 fromIndex 是负数，它会从 array.length + fromIndex 的位置开始搜索，但仍会搜索整个数组。

举几个例子可能更清晰：

const numbers = [1, 2, 3, 4, 5];

console.log(numbers.includes(3)); // true
console.log(numbers.includes(6)); // false

const fruits = ['apple', 'banana', 'cherry', 'apple'];

console.log(fruits.includes('banana')); // true
console.log(fruits.includes('grape')); // false

// 从特定索引开始搜索
console.log(fruits.includes('apple', 1)); // true (从索引1开始，找到了第二个'apple')
console.log(fruits.includes('apple', 2)); // true (从索引2开始，找到了第二个'apple')
console.log(fruits.includes('apple', 4)); // false (索引4超出数组范围，或者说没有元素了)

const mixed = [1, 'hello', null, undefined, NaN, 0];

console.log(mixed.includes(NaN)); // true (这一点很重要，后面会详细说)
console.log(mixed.includes(0)); // true
console.log(mixed.includes(null)); // true

includes() 和 indexOf() 有什么区别？为什么选择 includes()？

这真是个老生常谈的问题了，但每次讨论都很有意思。从功能上看，includes() 和 indexOf() 都能检查元素是否存在，但它们的侧重点和行为差异，尤其是处理 NaN 的方式，让我更倾向于在判断存在性时使用 includes()。

indexOf() 方法返回的是目标元素在数组中找到的第一个索引位置，如果没找到则返回 -1。所以，你通常会看到这样的代码：if (arr.indexOf(element) !== -1) 来判断元素是否存在。

而 includes() 则直接返回一个布尔值，这让代码意图更加明确：你就是想知道“有没有”，而不是“在哪里”。从语义上讲，arr.includes(element) 读起来更自然，也更符合直觉。

但真正的“杀手锏”区别在于它们对 NaN（Not a Number）的处理。在 JavaScript 中，NaN 是个很特殊的值，它不等于任何值，甚至不等于它自己 (NaN === NaN 是 false)。这导致了 indexOf() 在查找 NaN 时会“失灵”：

const weirdNumbers = [1, 2, NaN, 3];

console.log(weirdNumbers.indexOf(NaN)); // -1 (indexOf 找不到 NaN)
console.log(weirdNumbers.includes(NaN)); // true (includes 能找到 NaN)

这个细节在处理一些可能包含非数字数据或计算结果为 NaN 的数组时，显得尤为重要。我个人就遇到过因为 indexOf 无法识别 NaN 而导致逻辑出错的情况，后来改用 includes 就迎刃而解了。所以，如果你的目标只是判断元素是否存在，并且不关心它的具体位置，那么 includes() 绝对是更现代、更健壮的选择。

includes() 如何处理复杂数据类型（对象、数组）的相等性？

这是 includes() 使用中一个常见的“陷阱”，或者说，是 JavaScript 相等性判断的固有特性。includes() 在进行元素比较时，使用的是严格相等性比较（===）。这意味着，对于基本数据类型（如数字、字符串、布尔值），它会按值进行比较。但对于复杂数据类型（如对象、数组），它比较的是引用，而不是它们的内容。

举个例子：

const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];

const alice = { id: 1, name: 'Alice' };
const bob = users[1]; // 引用了数组中的第二个对象

console.log(users.includes(alice)); // false
// 尽管 alice 对象的内容和 users[0] 一模一样，但它们是两个不同的对象实例，内存地址不同。

console.log(users.includes(bob)); // true
// 因为 bob 变量直接引用了 users 数组中的第二个对象，它们指向同一个内存地址。

const nestedArrays = [[1, 2], [3, 4]];
const targetArray = [1, 2];

console.log(nestedArrays.includes(targetArray)); // false
// 同样，[1, 2] 即使内容相同，但作为不同的数组实例，引用也不同。
console.log(nestedArrays.includes(nestedArrays[0])); // true

所以，如果你想在数组中查找一个内容相同但引用不同的对象，includes() 是帮不上忙的。这种情况下，你需要采取其他策略，比如使用 Array.prototype.some() 方法，结合一个自定义的比较函数来遍历数组，手动比较每个对象的属性：

const products = [{ id: 'a1', name: 'Laptop' }, { id: 'b2', name: 'Mouse' }];
const searchProduct = { id: 'a1', name: 'Laptop' };

const foundProduct = products.some(product => product.id === searchProduct.id && product.name === searchProduct.name);
console.log(foundProduct); // true

这其实是 JavaScript 语言本身的一个设计选择，理解了这一点，就能避免很多不必要的困惑。

在大型数组中频繁使用 includes() 会有性能问题吗？有哪些替代方案？

是的，在处理大型数组时，频繁地调用 includes() 确实可能带来性能上的考量。includes() 方法在底层实现上，需要遍历数组中的每一个元素，直到找到目标元素或者遍历完整个数组。这意味着它的时间复杂度是 O(n)（线性时间复杂度），其中 n 是数组的长度。

对于小到中等规模的数组（比如几百、几千个元素），这种性能开销通常可以忽略不计。但如果你的数组包含成千上万甚至数十万个元素，并且你需要频繁地对这个数组进行 includes() 操作，那么每次 O(n) 的遍历累积起来，就会显著影响程序的响应速度。

想象一下，一个电商网站，你有一个包含百万商品ID的数组，每次用户搜索商品时，你都用 includes() 去检查某个ID是否存在，这显然不是一个高效的做法。

在这种情况下，我们可以考虑使用更适合快速查找的数据结构，最常见的替代方案是使用 JavaScript 的 Set 对象。

使用 Set 的替代方案：

Set 是一种允许你存储任何唯一值的集合。它的一个显著优势是，查找一个元素是否存在于 Set 中（使用 Set.prototype.has() 方法）的时间复杂度平均是 O(1)（常数时间复杂度），这比数组的 O(n) 要快得多。

当然，将数组转换为 Set 本身也需要时间，这个转换过程的时间复杂度是 O(n)。所以，这种优化适用于以下场景：

1. 查找操作远多于添加/删除操作：你只需要一次性将数组转换为 Set，然后进行多次查找。
2. 数组内容相对稳定：如果数组内容频繁变化，每次变化都重新构建 Set 可能反而更慢。

const largeArray = Array.from({ length: 100000 }, (_, i) => `item-${i}`);

// 转换为 Set (一次性开销)
const itemSet = new Set(largeArray);

// 查找操作 (O(1) 平均时间复杂度)
console.time('includes check');
console.log(largeArray.includes('item-99999')); // 假设这是最坏情况，遍历整个数组
console.timeEnd('includes check'); // 可能会显示几十毫秒甚至更久

console.time('Set has check');
console.log(itemSet.has('item-99999')); // 几乎瞬间完成
console.timeEnd('Set has check'); // 通常是零点几毫秒

console.time('another includes check');
console.log(largeArray.includes('non-existent-item'));
console.timeEnd('another includes check');

console.time('another Set has check');
console.log(itemSet.has('non-existent-item'));
console.timeEnd('another Set has check');

从上面的例子可以看到，对于大型数据集，Set.has() 在查找性能上有着压倒性的优势。因此，在设计需要高性能查找的系统时，考虑将数据存储在 Set 中，而不是单纯依赖数组的 includes()，是一个非常值得深思的优化方向。

终于介绍完啦！小伙伴们，这篇关于《JavaScriptincludes方法使用详解》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！