找出JavaScript数组是否包含值的最简洁有效的方法是什么？
这是我知道的唯一方法：
function contains(a, obj) {
for (var i = 0; i < a.length; i++) {
if (a[i] === obj) {
return true;
}
}
return false;
}
有没有更好、更简洁的方法来实现这一点？
这与堆栈溢出问题密切相关。在JavaScript数组中查找项目的最佳方法是什么？它解决了使用indexOf查找数组中的对象的问题。
当前回答
如果您正在重复检查数组中是否存在对象，您可能应该查看
通过在数组中执行插入排序（将新对象放在正确的位置），始终保持数组排序将更新对象设置为删除+排序插入操作和在contains（a，obj）中使用二进制搜索查找。
其他回答
Object.keys，用于获取对象的所有属性名称，并筛选与指定字符串完全或部分匹配的所有值。
函数filterByValue（数组，字符串）{返回array.filter（o=>Object.keys（o）.some（k=>o[k].toLowerCase（）.includes（string.toLoweCase（）））；}常量数组OfObject=[{name：“Paul”，country:'加拿大'，}, {name:'Lea'，国家：“意大利”，}, {name：“John”，country:'意大利'}];console.log（filterByValue（arrayOfObject，'lea'））；//〔｛名称：‘Lea’，国家：‘意大利’｝〕console.log（filterByValue（arrayOfObject，'ita'））；//[{名称：“Lea”，国家：“Italy”}，{名称“John”，国家“Italy'”}]
您还可以按特定关键字进行筛选，例如。
Object.keys(o).some(k => o.country.toLowerCase().includes(string.toLowerCase())));
现在，您可以在过滤后检查数组计数，以检查值是否包含。
希望这有帮助。
将唯一项目添加到其他列表
searchResults: [
{
name: 'Hello',
artist: 'Selana',
album: 'Riga',
id: 1,
},
{
name: 'Hello;s',
artist: 'Selana G',
album: 'Riga1',
id: 2,
},
{
name: 'Hello2',
artist: 'Selana',
album: 'Riga11',
id: 3,
}
],
playlistTracks: [
{
name: 'Hello',
artist: 'Mamunuus',
album: 'Riga',
id: 4,
},
{
name: 'Hello;s',
artist: 'Mamunuus G',
album: 'Riga1',
id: 2,
},
{
name: 'Hello2',
artist: 'Mamunuus New',
album: 'Riga11',
id: 3,
}
],
playlistName: "New PlayListTrack",
};
}
// Adding an unique track in the playList
addTrack = track => {
if(playlistTracks.find(savedTrack => savedTrack.id === track.id)) {
return;
}
playlistTracks.push(track);
this.setState({
playlistTracks
})
};
ECMAScript 7引入了Array.prototype.includes。
它可以这样使用：
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
它还接受来自Index的可选第二个参数：
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
与使用严格相等比较的indexOf不同，indexOf包括使用SameValueZero相等算法的比较。这意味着您可以检测阵列是否包含NaN：
[1, 2, NaN].includes(NaN); // true
与indexOf不同，includes不会跳过缺少的索引：
new Array(5).includes(undefined); // true
它可以是多填充的，以使其在所有浏览器上都可以使用。
Use:
Array.prototype.contains = function(x){
var retVal = -1;
// x is a primitive type
if(["string","number"].indexOf(typeof x)>=0 ){ retVal = this.indexOf(x);}
// x is a function
else if(typeof x =="function") for(var ix in this){
if((this[ix]+"")==(x+"")) retVal = ix;
}
//x is an object...
else {
var sx=JSON.stringify(x);
for(var ix in this){
if(typeof this[ix] =="object" && JSON.stringify(this[ix])==sx) retVal = ix;
}
}
//Return False if -1 else number if numeric otherwise string
return (retVal === -1)?false : ( isNaN(+retVal) ? retVal : +retVal);
}
我知道这不是最好的方法，但由于没有本机的IComparable方法来在对象之间进行交互，我想这是比较数组中两个实体所能做到的。此外，扩展Array对象可能不是明智的做法，但有时也可以（如果您意识到这一点和权衡）。
适用于所有现代浏览器的解决方案：
function contains(arr, obj) {
const stringifiedObj = JSON.stringify(obj); // Cache our object to not call `JSON.stringify` on every iteration
return arr.some(item => JSON.stringify(item) === stringifiedObj);
}
用法：
contains([{a: 1}, {a: 2}], {a: 1}); // true
IE6+解决方案：
function contains(arr, obj) {
var stringifiedObj = JSON.stringify(obj)
return arr.some(function (item) {
return JSON.stringify(item) === stringifiedObj;
});
}
// .some polyfill, not needed for IE9+
if (!('some' in Array.prototype)) {
Array.prototype.some = function (tester, that /*opt*/) {
for (var i = 0, n = this.length; i < n; i++) {
if (i in this && tester.call(that, this[i], i, this)) return true;
} return false;
};
}
用法：
contains([{a: 1}, {a: 2}], {a: 1}); // true
为什么使用JSON.stringify？
Array.indexOf和Array.includes（以及这里的大多数答案）只通过引用而不是通过值进行比较。
[{a: 1}, {a: 2}].includes({a: 1});
// false, because {a: 1} is a new object
奖金
未经优化的ES6单缸套：
[{a: 1}, {a: 2}].some(item => JSON.stringify(item) === JSON.stringify({a: 1));
// true
注：如果键的顺序相同，则按值比较对象的效果会更好，因此为了安全起见，您可以首先使用以下包对键进行排序：https://www.npmjs.com/package/sort-keys
使用性能优化更新了contains函数。谢谢你指出这一点。
