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)); // trueconsole.log(numbers.includes(6)); // falseconst fruits = ['apple', 'banana', 'cherry', 'apple'];console.log(fruits.includes('banana')); // trueconsole.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)); // trueconsole.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)。所以，这种优化适用于以下场景：
查找操作远多于添加/删除操作：你只需要一次性将数组转换为 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()，是一个非常值得深思的优化方向。
以上就是JavaScript的Array.prototype.includes方法是什么？怎么用？的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1510321.html
微信扫一扫 
支付宝扫一扫 
