找出JavaScript数组是否包含对象的最简洁有效的方法是什么？
这是我所知道的唯一方法：
function contains(a, obj) {
for (var i = 0; i < a.length; i++) {
if (a[i] === obj) {
return true;
}
}
return false;
}
是否有更好，更简洁的方法来实现这一目标？
这与Stack Overflow问题 Best way to find an item in a JavaScript Array? 密切相关，后者使用indexOf解决了在数组中查找对象的问题。
答案 0 :(得分：4001)
目前的浏览器有Array#includes，完全，is widely supported，并且旧版浏览器有polyfill。
> ['joe', 'jane', 'mary'].includes('jane');
true
您也可以使用Array#indexOf，这不是直接的，但不要求Polyfills用于过时的浏览器。
jQuery提供$.inArray，其功能等同于Array#indexOf。
underscore.js是一个JavaScript实用程序库，提供_.contains(list, value)，别名_.include(list, value)，如果传递了JavaScript数组，它们都会在内部使用indexOf。
其他一些框架提供了类似的方法：
dojo.indexOf(array, value, [fromIndex, findLast]) array.indexOf(value) array.indexOf(value) findValue(array, value) array.indexOf(value) Ext.Array.contains(array, value) _.includes(array, value, [from])（_.contains之前的4.0.0）array.includes(value) 请注意，某些框架将此实现为函数，而其他框架则将该函数添加到数组原型中。
答案 1 :(得分：380)
更新：正如@orip在评论中提到的那样，链接的基准测试是在2008年完成的，因此结果可能与现代浏览器无关。但是，你可能还需要这个来支持非现代浏览器，因为它们可能还没有更新过。总是为自己测试。
正如其他人所说，通过数组的迭代可能是最好的方法，但has been proven减少while循环是在JavaScript中迭代的最快方法。因此，您可能需要按如下方式重写代码：
function contains(a, obj) {
var i = a.length;
while (i--) {
if (a[i] === obj) {
return true;
}
}
return false;
}
当然，您也可以扩展Array原型：
Array.prototype.contains = function(obj) {
var i = this.length;
while (i--) {
if (this[i] === obj) {
return true;
}
}
return false;
}
现在您只需使用以下内容：
alert([1, 2, 3].contains(2)); // => true
alert([1, 2, 3].contains('2')); // => false
答案 2 :(得分：177)
indexOf也许，但它是“ECMA-262标准的JavaScript扩展;因此它可能不会出现在标准的其他实现中。”
示例：
[1, 2, 3].indexOf(1) => 0
["foo", "bar", "baz"].indexOf("bar") => 1
[1, 2, 3].indexOf(4) => -1
AFAICS Microsoft does not offer some kind of alternative，但您可以在Internet Explorer（以及其他不支持indexOf的浏览器）中添加类似的功能，如果您愿意，可以quick Google search reveals （例如，this one）。
答案 3 :(得分：143)
ECMAScript 7介绍Array.prototype.includes。
可以像这样使用：
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
它还接受可选的第二个参数fromIndex：
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
与使用Strict Equality Comparison的indexOf不同，includes使用SameValueZero等式算法进行比较。这意味着您可以检测数组是否包含NaN：
[1, 2, NaN].includes(NaN); // true
与indexOf不同，includes不会跳过缺失的索引：
new Array(5).includes(undefined); // true
目前它仍然是草稿，但可以polyfilled使其适用于所有浏览器。
答案 4 :(得分：102)
b是值，a是数组。它会返回true或false：
function(a, b) {
return a.indexOf(b) != -1
}
答案 5 :(得分：74)
最佳答案假定基本类型，但如果您想知道数组是否包含具有某些特征的对象，Array.prototype.some()是一个非常优雅的解决方案：
const items = [ {a: '1'}, {a: '2'}, {a: '3'} ]
items.some(item => item.a === '3') // returns true
items.some(item => item.a === '4') // returns false
关于它的好处是，一旦找到元素就会中止迭代，从而保存不必要的迭代周期。
此外，它很适合if语句，因为它返回一个布尔值：
if (items.some(item => item.a === '3')) {
// do something
}
*正如jamess在评论中指出的那样，截至今天，即2018年9月，完全支持Array.prototype.some()：caniuse.com support table
答案 6 :(得分：71)
以下是Array.indexOf的{{3}}实现：
if (!Array.indexOf) {
Array.indexOf = [].indexOf ?
function(arr, obj, from) {
return arr.indexOf(obj, from);
} :
function(arr, obj, from) { // (for IE6)
var l = arr.length,
i = from ? parseInt((1 * from) + (from < 0 ? l : 0), 10) : 0;
i = i < 0 ? 0 : i;
for (; i < l; i++) {
if (i in arr && arr[i] === obj) {
return i;
}
}
return -1;
};
}
答案 7 :(得分：50)
使用：
function isInArray(array, search)
{
return array.indexOf(search) >= 0;
}
// Usage
if(isInArray(my_array, "my_value"))
{
//...
}
答案 8 :(得分：42)
扩展JavaScript Array对象是一个非常糟糕的主意，因为您将新属性（您的自定义方法）引入for-in循环，这可能会破坏现有脚本。几年前，Prototype库的作者不得不重新设计他们的库实现，以删除这种事情。
如果您不需要担心与页面上运行的其他JavaScript的兼容性，那就去吧，否则，我会推荐更笨拙但更安全的独立功能解决方案。
答案 9 :(得分：27)
开箱即用，如果你多次拨打这个电话，使用一个关联数组一个Map来使用哈希函数进行查找会更有效率。< / p>
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
答案 10 :(得分：24)
一衬垫：
function contains(arr, x) {
return arr.filter(function(elem) { return elem == x }).length > 0;
}
答案 11 :(得分：22)
我使用以下内容：
Array.prototype.contains = function (v) {
return this.indexOf(v) > -1;
}
var a = [ 'foo', 'bar' ];
a.contains('foo'); // true
a.contains('fox'); // false
答案 12 :(得分：19)
function contains(a, obj) {
return a.some(function(element){return element == obj;})
}
Array.prototype.some()已添加到第5版的ECMA-262标准中
答案 13 :(得分：14)
希望更快的双向indexOf / lastIndexOf替代
虽然新方法includes非常好，但现在支持基本上为零。
很长一段时间我一直想着替换慢的indexOf / lastIndexOf函数。
已找到一种高效的方式，查看最佳答案。从那些我选择@Damir Zekic发布的contains函数开始，这应该是最快的函数。但它也指出基准是从2008年开始的，因此已经过时了。
我也更喜欢while而不是for，但由于没有特殊原因，我结束了用for循环编写函数。也可以使用while --。
如果在执行此操作时检查数组的两侧，迭代速度要慢得多，我很好奇。显然不是，所以这个功能比最高投票的功能快两倍左右。显然它也比原生的更快。这在现实环境中，您永远不知道您正在搜索的值是在数组的开头还是结尾。
当你知道你刚推送一个带有值的数组时，使用lastIndexOf仍然可能是最好的解决方案，但是如果你必须通过大数组并且结果可能无处不在，这可能是一个可以让事情变得更快的可靠解决方案。
双向indexOf / lastIndexOf
function bidirectionalIndexOf(a, b, c, d, e){
for(c=a.length,d=c*1; c--; ){
if(a[c]==b) return c; //or this[c]===b
if(a[e=d-1-c]==b) return e; //or a[e=d-1-c]===b
}
return -1
}
//Usage
bidirectionalIndexOf(array,'value');
http://jsperf.com/bidirectionalindexof
作为测试，我创建了一个包含100k条目的数组。
三个问题：开头，中间和在数组的末尾。
我希望你也能发现这个有趣并测试表现。
注意：正如您所看到的，我稍微修改了contains函数以反映indexOf＆amp; lastIndexOf输出（基本上true包含index，false包含-1）。这不应该伤害它。
Object.defineProperty(Array.prototype,'bidirectionalIndexOf',{value:function(b,c,d,e){
for(c=this.length,d=c*1; c--; ){
if(this[c]==b) return c; //or this[c]===b
if(this[e=d-1-c] == b) return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false});
// Usage
array.bidirectionalIndexOf('value');
也可以轻松修改该函数以返回true或false，甚至是对象，字符串或其他任何内容。
以下是while变体：
function bidirectionalIndexOf(a, b, c, d){
c=a.length; d=c-1;
while(c--){
if(b===a[c]) return c;
if(b===a[d-c]) return d-c;
}
return c
}
// Usage
bidirectionalIndexOf(array,'value');
我认为在数组中获取反射索引的简单计算非常简单，它比实际循环迭代快两倍。
这是一个复杂的例子，每次迭代执行三次检查，但这只能通过更长的计算才能导致代码减速。
答案 14 :(得分：12)
function inArray(elem,array)
{
var len = array.length;
for(var i = 0 ; i < len;i++)
{
if(array[i] == elem){return i;}
}
return -1;
}
如果找到则返回数组索引，如果未找到则返回-1
答案 15 :(得分：12)
如果您使用的是JavaScript 1.6或更高版本（Firefox 1.5或更高版本），则可以使用Array.indexOf。否则，我认为你最终会得到类似于原始代码的东西。
答案 16 :(得分：12)
如果您反复检查数组中是否存在对象，您应该查看
contains(a, obj)。答案 17 :(得分：12)
我们使用此代码段（适用于对象，数组，字符串）：
/*
* @function
* @name Object.prototype.inArray
* @description Extend Object prototype within inArray function
*
* @param {mix} needle - Search-able needle
* @param {bool} searchInKey - Search needle in keys?
*
*/
Object.defineProperty(Object.prototype, 'inArray',{
value: function(needle, searchInKey){
var object = this;
if( Object.prototype.toString.call(needle) === '[object Object]' ||
Object.prototype.toString.call(needle) === '[object Array]'){
needle = JSON.stringify(needle);
}
return Object.keys(object).some(function(key){
var value = object[key];
if( Object.prototype.toString.call(value) === '[object Object]' ||
Object.prototype.toString.call(value) === '[object Array]'){
value = JSON.stringify(value);
}
if(searchInKey){
if(value === needle || key === needle){
return true;
}
}else{
if(value === needle){
return true;
}
}
});
},
writable: true,
configurable: true,
enumerable: false
});
<强>用法：
var a = {one: "first", two: "second", foo: {three: "third"}};
a.inArray("first"); //true
a.inArray("foo"); //false
a.inArray("foo", true); //true - search by keys
a.inArray({three: "third"}); //true
var b = ["one", "two", "three", "four", {foo: 'val'}];
b.inArray("one"); //true
b.inArray('foo'); //false
b.inArray({foo: 'val'}) //true
b.inArray("{foo: 'val'}") //false
var c = "String";
c.inArray("S"); //true
c.inArray("s"); //false
c.inArray("2", true); //true
c.inArray("20", true); //false
答案 18 :(得分：9)
适用于所有现代浏览器的解决方案：
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函数。感谢itinance将其指出。
答案 19 :(得分：9)
使用lodash＆＃39; some功能。
它简洁，准确，并且具有很好的跨平台支持。
接受的答案甚至不符合要求。
要求：建议最简洁有效的方法来确定JavaScript数组是否包含对象。
接受的答案：
$.inArray({'b': 2}, [{'a': 1}, {'b': 2}])
> -1
我的建议：
_.some([{'a': 1}, {'b': 2}], {'b': 2})
> true
注意：
$。inArray可以很好地确定标量数组中是否存在标量值......
$.inArray(2, [1,2])
> 1
...但问题明确要求确定一个对象是否包含在数组中的有效方法。
为了处理标量和对象，你可以这样做：
(_.isObject(item)) ? _.some(ary, item) : (_.indexOf(ary, item) > -1)
答案 20 :(得分：8)
虽然array.indexOf(x)!=-1是最简洁的方法（并且非Internet Explorer浏览器已经支持了十多年......），但它不是O（1），而是O（N） ，这太可怕了。如果您的数组不会更改，您可以将数组转换为哈希表，然后执行table[x]!==undefined或===undefined：
Array.prototype.toTable = function() {
var t = {};
this.forEach(function(x){t[x]=true});
return t;
}
演示：
var toRemove = [2,4].toTable();
[1,2,3,4,5].filter(function(x){return toRemove[x]===undefined})
（不幸的是，虽然你可以创建一个Array.prototype.contains来“冻结”一个数组并将this._cache中的哈希表存储在两行中，但是如果你以后选择编辑你的数组会产生错误的结果。没有足够的钩子让你保持这种状态，例如Python不同。）
答案 21 :(得分：7)
ECMAScript 6有一个关于find的优雅提议。
find方法为每个元素执行一次回调函数 出现在数组中，直到找到一个回调返回true的地方 值。如果找到这样的元素，find会立即返回该值 那个元素。否则，find返回undefined。回调是 仅为已分配值的数组的索引调用;它 不会为已删除或从不删除的索引调用 被赋予了价值。
查找功能就像这样。
function isPrime(element, index, array) {
var start = 2;
while (start <= Math.sqrt(element)) {
if (element % start++ < 1) return false;
}
return (element > 1);
}
console.log( [4, 6, 8, 12].find(isPrime) ); // Undefined, not found
console.log( [4, 5, 8, 12].find(isPrime) ); // 5
您可以通过defining the function在ECMAScript 5及更低版本中使用此功能。
if (!Array.prototype.find) {
Object.defineProperty(Array.prototype, 'find', {
enumerable: false,
configurable: true,
writable: true,
value: function(predicate) {
if (this == null) {
throw new TypeError('Array.prototype.find called on null or undefined');
}
if (typeof predicate !== 'function') {
throw new TypeError('predicate must be a function');
}
var list = Object(this);
var length = list.length >>> 0;
var thisArg = arguments[1];
var value;
for (var i = 0; i < length; i++) {
if (i in list) {
value = list[i];
if (predicate.call(thisArg, value, i, list)) {
return value;
}
}
}
return undefined;
}
});
}
答案 22 :(得分：6)
使用：
var myArray = ['yellow', 'orange', 'red'] ;
alert(!!~myArray.indexOf('red')); //true
要准确了解tilde ~此时的行为，请参阅此问题 What does a tilde do when it precedes an expression? 。
答案 23 :(得分：4)
好的，你可以优化代码来获得结果！
有很多方法可以做到更清洁，更好，但我只是希望得到你的模式并使用JSON.stringify来应用，只需在你的情况下做这样的事情：
function contains(a, obj) {
for (var i = 0; i < a.length; i++) {
if (JSON.stringify(a[i]) === JSON.stringify(obj)) {
return true;
}
}
return false;
}
答案 24 :(得分：4)
使用indexOf（）
可以使用indexOf（）方法检查数组中是否存在给定的值或元素。 indexOf（）方法返回找到的元素在数组中的索引，如果找不到，则返回-1。让我们看下面的示例：
var fruits = ["Apple", "Banana", "Mango", "Orange", "Papaya"];
var a = "Mango";
checkArray(a, fruits);
function checkArray(a, fruits) {
// Check if a value exists in the fruits array
if (fruits.indexOf(a) !== -1) {
return document.write("true");
} else {
return document.write("false");
}
}
使用include（）方法
ES6引入了include（）方法来非常轻松地执行此任务。但是，此方法仅返回true或false而不是索引号：
var fruits = ["Apple", "Banana", "Mango", "Orange", "Papaya"];
alert(fruits.includes("Banana")); // Outputs: true
alert(fruits.includes("Coconut")); // Outputs: false
alert(fruits.includes("Orange")); // Outputs: true
alert(fruits.includes("Cherry")); // Outputs: false
有关进一步的参考，结帐here
答案 25 :(得分：4)
/**
* Array#indexOf(item[, offset = 0]) -> Number
* - item (?): A value that may or may not be in the array.
* - offset (Number): The number of initial items to skip before beginning the
* search.
*
* Returns the position of the first occurrence of `item` within the array — or
* `-1` if `item` doesn't exist in the array.
**/
function indexOf(item, i) {
i || (i = 0);
var length = this.length;
if (i < 0) i = length + i;
for (; i < length; i++)
if (this[i] === item) return i;
return -1;
}
另请参阅here了解他们如何将其连接起来。
答案 26 :(得分：3)
可以使用具有“has（）”方法的Set：
function contains(arr, obj) {
var proxy = new Set(arr);
if (proxy.has(obj))
return true;
else
return false;
}
var arr = ['Happy', 'New', 'Year'];
console.log(contains(arr, 'Happy'));
答案 27 :(得分：3)
将唯一项目添加到另一个列表
class = 1答案 28 :(得分：3)
你也可以使用这个技巧：
var arrayContains = function(object) {
return (serverList.filter(function(currentObject) {
if (currentObject === object) {
return currentObject
}
else {
return false;
}
}).length > 0) ? true : false
}
答案 29 :(得分：3)
例如使用Array.prototype.includes：
const fruits = ['coconut', 'banana', 'apple']
const doesFruitsHaveCoconut = fruits.includes('coconut')// true
console.log(doesFruitsHaveCoconut)
也许可以通过MDN阅读此文档：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes
答案 30 :(得分：3)
使用：
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对象可能不是一件明智的事情，但有时它是可以的（如果你知道它和权衡）。
答案 31 :(得分：2)
绝不是最好的，但我只是在发挥创意并增加了曲目。
Object.defineProperty(Array.prototype, 'exists', {
value: function(element, index) {
var index = index || 0
return index === this.length ? -1 : this[index] === element ? index : this.exists(element, ++index)
}
})
// Outputs 1
console.log(['one', 'two'].exists('two'));
// Outputs -1
console.log(['one', 'two'].exists('three'));
console.log(['one', 'two', 'three', 'four'].exists('four'));
答案 32 :(得分：2)
正如其他人所提到的，您可以使用Array.indexOf，但并非所有浏览器都可以使用它。以下是https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf中的代码，使其在旧版浏览器中的工作方式相同。
indexOf是ECMA-262标准的最新成员;因此可能 不存在于所有浏览器中。您可以通过插入来解决此问题 脚本开头的以下代码，允许使用 indexOf在本身不支持它的实现中。这个 算法正好是ECMA-262第5版中规定的算法， 假设Object，TypeError，Number，Math.floor，Math.abs和Math.max 有其原始价值。
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
"use strict";
if (this == null) {
throw new TypeError();
}
var t = Object(this);
var len = t.length >>> 0;
if (len === 0) {
return -1;
}
var n = 0;
if (arguments.length > 1) {
n = Number(arguments[1]);
if (n != n) { // shortcut for verifying if it's NaN
n = 0;
} else if (n != 0 && n != Infinity && n != -Infinity) {
n = (n > 0 || -1) * Math.floor(Math.abs(n));
}
}
if (n >= len) {
return -1;
}
var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
for (; k < len; k++) {
if (k in t && t[k] === searchElement) {
return k;
}
}
return -1;
}
}
答案 33 :(得分：2)
Array.indexOf(Object)。 Array.includes(Object)。 使用ECMA 6，您可以使用Array.find(FunctionName)，其中FunctionName是用户
定义函数以搜索数组中的对象。
希望这有帮助！
答案 34 :(得分：2)
此要求的简单解决方案是使用find()
如果您有如下所示的对象数组，
var users = [{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "admin"},
{id: "105", name: "user"}];
然后您可以检查具有您的值的对象是否已经存在
let data = users.find(object => object['id'] === '104');
如果data为null，则没有admin，否则它将返回如下所示的现有对象。
{id: "104", name: "admin"}
然后，您可以在数组中找到该对象的索引，并使用以下代码替换该对象。
let indexToUpdate = users.indexOf(data);
let newObject = {id: "104", name: "customer"};
users[indexToUpdate] = newObject;//your new object
console.log(users);
您将获得如下所示的价值
[{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "customer"},
{id: "105", name: "user"}];
希望这会帮助任何人。
答案 35 :(得分：2)
对此问题感到惊讶的是，该问题仍未添加最新的语法，仅增加了2美分。
假设我们有对象数组arrObj，我们想在其中搜索obj。
Array.prototype。 indexOf ->（返回 index或-1 ）通常用于查找数组中元素的索引。 这也可以用于搜索对象，但仅当您将引用传递给同一对象时有效。
let obj = { name: 'Sumer', age: 36 };
let arrObj = [obj, { name: 'Kishor', age: 46 }, { name: 'Rupen', age: 26 }];
console.log(arrObj.indexOf(obj));// 0
console.log(arrObj.indexOf({ name: 'Sumer', age: 36 })); //-1
console.log([1, 3, 5, 2].indexOf(2)); //3
Array.prototype。包含->（返回 true 或 false ）
console.log(arrObj.includes(obj)); //true
console.log(arrObj.includes({ name: 'Sumer', age: 36 })); //false
console.log([1, 3, 5, 2].includes(2)); //true
Array.prototype。查找->（进行回调，返回第一个 value / object ，该值在CB中返回true）。
console.log(arrObj.find(e => e.age > 40)); //{ name: 'Kishor', age: 46 }
console.log(arrObj.find(e => e.age > 40)); //{ name: 'Kishor', age: 46 }
console.log([1, 3, 5, 2].find(e => e > 2)); //3
Array.prototype。 findIndex ->（进行回调，返回在CB中返回true的第一个值/对象的 index ）。
console.log(arrObj.findIndex(e => e.age > 40)); //1
console.log(arrObj.findIndex(e => e.age > 40)); //1
console.log([1, 3, 5, 2].findIndex(e => e > 2)); //1
由于find和findIndex进行了回调，因此可以通过创造性地设置true条件来从数组中获取任何对象（即使没有引用）。
答案 36 :(得分：1)
类似的事情：通过“搜索lambda”找到第一个元素：
Array.prototype.find = function(search_lambda) {
return this[this.map(search_lambda).indexOf(true)];
};
用法：
[1,3,4,5,8,3,5].find(function(item) { return item % 2 == 0 })
=> 4
相同的coffeescript：
Array.prototype.find = (search_lambda) -> @[@map(search_lambda).indexOf(true)]
答案 37 :(得分：1)
这可能是详细且简单的解决方案。
//plain array
var arr = ['a', 'b', 'c'];
var check = arr.includes('a');
console.log(check); //returns true
if (check)
{
// value exists in array
//write some codes
}
// array with objects
var arr = [
{x:'a', y:'b'},
{x:'p', y:'q'}
];
// if you want to check if x:'p' exists in arr
var check = arr.filter(function (elm){
if (elm.x == 'p')
{
return elm; // returns length = 1 (object exists in array)
}
});
// or y:'q' exists in arr
var check = arr.filter(function (elm){
if (elm.y == 'q')
{
return elm; // returns length = 1 (object exists in array)
}
});
// if you want to check, if the entire object {x:'p', y:'q'} exists in arr
var check = arr.filter(function (elm){
if (elm.x == 'p' && elm.y == 'q')
{
return elm; // returns length = 1 (object exists in array)
}
});
// in all cases
console.log(check.length); // returns 1
if (check.length > 0)
{
// returns true
// object exists in array
//write some codes
}
答案 38 :(得分：1)
Object.keys用于获取对象的所有属性名称，并过滤与指定字符串完全或部分匹配的所有值。
function filterByValue(array, string) {
return array.filter(o =>
Object.keys(o).some(k => o[k].toLowerCase().includes(string.toLowerCase())));
}
const arrayOfObject = [{ name: 'Paul', country: 'Canada', }, { name: 'Lea', country: 'Italy', }, { name: 'John', country: 'Italy' }];
console.log(filterByValue(arrayOfObject, 'lea')); // [{name: 'Lea', country: 'Italy'}]
console.log(filterByValue(arrayOfObject, 'ita')); // [{name: 'Lea', country: 'Italy'}, {name: 'John', country: 'Italy'}]
您还可以按特定键进行过滤，例如。
Object.keys(o).some(k => o.country.toLowerCase().includes(string.toLowerCase())));
现在，您只需过滤一下以检查是否包含值即可检查数组计数。
希望有帮助。
答案 39 :(得分：1)
我建议使用下划线库，因为它会返回值并支持所有浏览器。
var findValue = _.find(array, function(item) {
return item.id == obj.id;
});
答案 40 :(得分：1)
如果你正在使用ES6你可以使用一套：
function arrayHas( array, element ) {
const s = new Set(array);
return s.has(element)
}
这应该比任何其他方法更高效
答案 41 :(得分：1)
它有一个参数：对象的数组数。数组中的每个对象都有两个由x和y表示的整数属性。该函数必须返回数组中满足numbers.x == numbers.y
var numbers = [ { x: 1, y: 1 },
{ x: 2, y: 3 },
{ x: 3, y: 3 },
{ x: 3, y: 4 },
{ x: 4, y: 5 } ];
count = 0;
var n = numbers.length;
for (var i =0;i<n;i++)
{
if(numbers[i].x==numbers[i].y)
{count+=1;}
}
alert(count);
答案 42 :(得分：1)
我正在开发一个项目，我需要像python set这样的功能，删除所有重复值并返回一个新列表，所以我写这个函数对某人有用
function set(arr) {
var res = [];
for (var i = 0; i < arr.length; i++) {
if (res.indexOf(arr[i]) === -1) {
res.push(arr[i]);
}
}
return res;
}
答案 43 :(得分：1)
或者这个解决方案：
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<body>
<c:set var="solution" value="${path}"/>
<% System.out.println(PageContext.REQUEST); %>
<c:if test="${true}">
IF TRUE
</c:if>
<c:choose>
<c:when test="${true}">
TRUE
</c:when>
<c:otherwise>
FALSE
</c:otherwise>
</c:choose>
</body>
答案 44 :(得分：1)
我查看了提交的答案并得到了它们只有在您通过引用搜索对象时才适用。使用参考对象比较的简单线性搜索。
但是假设您没有对象的引用，您将如何在数组中找到正确的对象？您必须与每个对象进行线性和深度比较。想象一下，如果列表太大，并且其中的对象非常大，包含大块文本。性能随着数组中元素的数量和大小而急剧下降。
你可以对对象进行字符串化并将它们放在本机哈希表中，但是你会有数据冗余记住这些密钥导致JavaScript将它们保存为'for i in obj'，你只想检查对象是否存在，也就是说，你有钥匙。
我想了一段时间构建一个JSON Schema验证器，我设计了一个简单的本机哈希表包装器，类似于唯一的哈希表实现，有一些优化异常，我留给本机哈希表来处理用。它只需要性能基准测试...... 所有细节和代码都可以在我的博客上找到：http://stamat.wordpress.com/javascript-quickly-find-very-large-objects-in-a-large-array/ 我将很快发布基准测试结果。
完整的解决方案是这样的：
var a = {'a':1,
'b':{'c':[1,2,[3,45],4,5],
'd':{'q':1, 'b':{'q':1, 'b':8},'c':4},
'u':'lol'},
'e':2};
var b = {'a':1,
'b':{'c':[2,3,[1]],
'd':{'q':3,'b':{'b':3}}},
'e':2};
var c = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.";
var hc = new HashCache([{a:3, b:2, c:5}, {a:15, b:2, c:'foo'}]); //init
hc.put({a:1, b:1});
hc.put({b:1, a:1});
hc.put(true);
hc.put('true');
hc.put(a);
hc.put(c);
hc.put(d);
console.log(hc.exists('true'));
console.log(hc.exists(a));
console.log(hc.exists(c));
console.log(hc.exists({b:1, a:1}));
hc.remove(a);
console.log(hc.exists(c));
答案 45 :(得分：0)
除了其他人所说的之外，如果您没有要在数组中搜索的对象的引用，那么您可以执行类似的操作。
let array = [1, 2, 3, 4, {"key": "value"}];
array.some((element) => JSON.stringify(element) === JSON.stringify({"key": "value"})) // true
array.some((element) => JSON.stringify(element) === JSON.stringify({})) // true
Array.some如果有任何元素符合给定条件，则返回true；如果没有元素符合给定条件，则返回false。
答案 46 :(得分：0)
function countArray(originalArray) {
var compressed = [];
// make a copy of the input array
var copyArray = originalArray.slice(0);
// first loop goes over every element
for (var i = 0; i < originalArray.length; i++) {
var count = 0;
// loop over every element in the copy and see if it's the same
for (var w = 0; w < copyArray.length; w++) {
if (originalArray[i] == copyArray[w]) {
// increase amount of times duplicate is found
count++;
// sets item to undefined
delete copyArray[w];
}
}
if (count > 0) {
var a = new Object();
a.value = originalArray[i];
a.count = count;
compressed.push(a);
}
}
return compressed;
};
// It should go something like this:
var testArray = new Array("dog", "dog", "cat", "buffalo", "wolf", "cat", "tiger", "cat");
var newArray = countArray(testArray);
console.log(newArray);
答案 47 :(得分：0)
使用包括javascript内置功能
var optval = [];
optval.push('A');
optval.push('B');
optval.push('C');
我们可以在javascript数组中搜索字符串A：
optval.includes('A') // =====> return true
答案 48 :(得分：0)
使用idnexOf（）这是一个很好的解决方案，但你应该隐藏嵌入式实现indexOf（）函数，该函数使用〜运算符返回-1：
function include(arr,obj) {
return !!(~arr.indexOf(obj));
}
答案 49 :(得分：0)
您可以使用findIndex函数检查数组是否具有特定值。
arrObj.findIndex(obj => obj === comparedValue) !== -1;
如果arrObj包含compareedValue，则返回true，否则返回false。
答案 50 :(得分：0)
使用正则表达式：
console.log(new RegExp('26242').test(['23525', '26242', '25272'].join(''))) // true
答案 51 :(得分：-1)
简单的解决方案：ES6具有“ 包含”方法
let arr = [1, 2, 3, 2, 3, 2, 3, 4];
arr.includes(2) // true
arr.includes(93) // false
答案 52 :(得分：-6)
字面上：
（使用Firefox v3.6，如前所述，有for-in个警告
（但是，为了这个目的，下面的使用可能会认可for-in！也就是说，枚举通过属性索引实际存在的数组元素（特别是，数组length属性未枚举在{ {1}}属性列表！）。）。）
（拖放以下完整的URI以进行即时模式浏览器测试。）
for-in显示：
function ObjInRA(ra){var has=false; for(i in ra){has=true; break;} return has;}
function check(ra){
return ['There is ',ObjInRA(ra)?'an':'NO',' object in [',ra,'].'].join('')
}
alert([
check([{}]), check([]), check([,2,3]),
check(['']), '\t (a null string)', check([,,,])
].join('\n'));
皱纹：如果寻找“特定”对象，请考虑：
JavaScript：There is an object in [[object Object]].
There is NO object in [].
There is an object in [,2,3].
There is an object in [].
(a null string)
There is NO object in [,,].
因此：
alert({}!={}); alert({}!=={}); obj = {prop:"value"};
ra1 = [obj];
ra2 = [{prop:"value"}];
alert(ra1[0] == obj);
alert(ra2[0] == obj);
通常被视为“包含”ra2作为文字实体obj。
非常粗略，简陋，天真（如代码需要增强资格）解决方案：
{prop:"value"}答案 53 :(得分：-7)
只是另一种选择
// usage: if ( ['a','b','c','d'].contains('b') ) { ... }
Array.prototype.contains = function(value){
for (var key in this)
if (this[key] === value) return true;
return false;
}
要小心，因为使用自定义方法重载javascript数组对象可能会破坏其他javascripts的行为，从而导致意外行为。