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的位置开始搜索，但仍会搜索整个数组。
举几个例子可能更清晰：
立即学习“Java免费学习笔记（深入）”；
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)); // trueincludes() 和 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)。所以，这种优化适用于以下场景：
-
查找操作远多于添加/删除操作：你只需要一次性将数组转换为
Set，然后进行多次查找。 -
数组内容相对稳定：如果数组内容频繁变化，每次变化都重新构建
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()，是一个非常值得深思的优化方向。
