Javascript 确定数组是否包含值

我需要确定数组中是否存在值

我正在使用以下功能：

Array.prototype.contains = function(obj) {
    var i = this.length;
    while (i--) {
        if (this[i] == obj) {
            return true;
        }
    }
    return false;
}

---

上述函数总是返回false

数组值和函数调用如下所示：

arrValues = ["Sam","Great", "Sample", "High"]
alert(arrValues.contains("Sam"));

---

这通常就是indexOf（）方法的用途。你会说：

return arrValues.indexOf('Sam') > -1

---

考虑到IE的indexOf实现（如所述）：

具有此功能的实用程序功能：

$.inArray(value, array)

返回

数组中
值的索引。如果
数组
不包含
值
，则返回
-1

另请参见
提供的答案不适合我，但它给了我一个想法：

Array.prototype.contains = function(obj)
    {
        return (this.join(',')).indexOf(obj) > -1;
    }

这并不完美，因为在分组之外相同的项目最终可能会匹配。比如我的例子

var c=[];
var d=[];
function a()
{
    var e = '1';
    var f = '2';
    c[0] = ['1','1'];
    c[1] = ['2','2'];
    c[2] = ['3','3'];
    d[0] = [document.getElementById('g').value,document.getElementById('h').value];

    document.getElementById('i').value = c.join(',');
    document.getElementById('j').value = d.join(',');
    document.getElementById('b').value = c.contains(d);
}

当我使用分别包含1和2的“g”和“h”字段调用此函数时，它仍然会找到它，因为从联接得到的字符串是：1,1,2,2,3,3

因为在我的情况下，我会遇到这种情况是值得怀疑的，所以我使用这个。我想我会分享，以防其他人也无法让所选答案起作用。
tl；dr

function includes(k) {
  for(var i=0; i < this.length; i++){
    if( this[i] === k || ( this[i] !== this[i] && k !== k ) ){
      return true;
    }
  }
  return false;
}


您可以使用，或者如果不想在应用程序中包含整个underline.js库，您可以查看并提取必要的代码

    _.indexOf = function(array, item, isSorted) {
    if (array == null) return -1;
    var i = 0, l = array.length;
    if (isSorted) {
      if (typeof isSorted == 'number') {
        i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
      } else {
        i = _.sortedIndex(array, item);
        return array[i] === item ? i : -1;
      }
    }
    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
    for (; i < l; i++) if (array[i] === item) return i;
    return -1;
  };

\uuxof.indexOf=函数（数组、项、isSorted）{
if（array==null）返回-1；
变量i=0，l=array.length；
如果（已排序）{
if（typeof isSorted=='number'）{
i=（isSorted<0？数学最大值（0，l+isSorted）：isSorted）；
}否则{
i=uu.sortedIndex（数组，项）；
返回数组[i]==项目？i:-1；
}
}
if（nativeIndexOf&&array.indexOf==nativeIndexOf）返回array.indexOf（item，isSorted）；
对于（；i
我的小小贡献：

function isInArray(array, search)
{
    return array.indexOf(search) >= 0;
}

//usage
if(isInArray(my_array, "my_value"))
{
    //...
}

使用像这样的库几乎总是更安全的，因为存在跨浏览器兼容性和效率方面的所有问题

效率，因为您可以保证在任何给定的时间，一个非常流行的库（如下划线）将有最有效的方法来实现这样的实用函数

_.includes([1, 2, 3], 3); // returns true

如果您担心通过包含整个库而添加到应用程序中的批量，请知道您可以单独包含功能：

var includes = require('lodash/collections/includes');


注意：对于旧版本的lodash，这是
.contains（）
而不是
.includes（）
 我更喜欢简洁：

var days = [1, 2, 3, 4, 5];
if ( 2 in days ) {console.log('weekday');}

函数setFound（）{
var l=arr.length，textBox1=document.getElementById（“text1”）；
对于（var i=0；i另一个选项是使用
Array。一些
（）采用以下方式：

Array.prototype.contains = function(obj) {
  return this.some( function(e){ return e === obj } );
}

传递给
数组的匿名函数。当且仅当数组中存在与
obj
相同的元素时，一些
将返回
true
。如果没有这样的元素，函数将不会为数组的任何元素返回
true
，因此
数组。一些
将返回
false
，正如我们所说的ll.
Array.prototype.includes（）
在ES2016中，有两种情况

includes（）
方法确定数组是否包含特定元素，并根据需要返回
true
或
false

例子
[“Sam”、“Great”、“Sample”、“High”]。包括（“Sam”）；//正确

支持
根据和，支持以下平台：


铬47
边缘14
火狐43
歌剧34
狩猎9
节点6

可以使用（使用
babel polyfill
）或扩展支持。MDN还提供：

if（！[]包括）{
Array.prototype.includes=函数（searchElement/*，fromIndex*/）{
"严格使用",；
var O=对象（此）；
var len=parseInt（O.length）| 0；
如果（len==0）{
返回false；
}
var n=parseInt（参数[1]）| | 0；
var-k；
如果（n>=0）{
k=n；
}否则{
k=len+n；
如果（k<0）{k=0；}
}
无功电流元件；
while（k
使用array.map函数为数组中的每个值执行函数对我来说似乎是最干净的

参考：

对于简单数组和需要查看对象数组中是否存在键/值的对象数组，此方法都可以很好地工作

function inArray(myArray,myValue){
    var inArray = false;
    myArray.map(function(key){
        if (key === myValue){
            inArray=true;
        }
    });
    return inArray;
};

var anArray = [2,4,6,8]
console.log(inArray(anArray, 8)); // returns true
console.log(inArray(anArray, 1)); // returns false

function inArrayOfObjects(myArray,myValue,objElement){
    var inArray = false;
    myArray.map(function(arrayObj){
        if (arrayObj[objElement] === myValue) {
            inArray=true;
        }
    });
    return inArray;
};

var objArray = [{id:4,value:'foo'},{id:5,value:'bar'}]
console.log(inArrayOfObjects(objArray, 4, 'id')); // returns true
console.log(inArrayOfObjects(objArray, 'bar', 'value')); // returns true
console.log(inArrayOfObjects(objArray, 1, 'id')); // returns false

如果您可以访问ECMA 5，您可以使用some方法


如果您有权访问ECMA 6，则可以使用包含方法


自ECMAScript 6以来，可以使用：

var myArray=['A'，'B'，'C']；
var mySet=新集合（myArray）；
var hasB=mySet.has（'B'）；//true
var hasZ=mySet.has（'Z'）；//false
对于包含
函数的
最简单的解决方案是这样一个函数：

var contains = function (haystack, needle) {
    return !!~haystack.indexOf(needle);
}

理想情况下，您不会将其作为独立函数，而是帮助程序库的一部分：

var helper = {};

helper.array = {
    contains : function (haystack, needle) {
        return !!~haystack.indexOf(needle);
    }, 
    ...
};

现在，如果你碰巧是那些仍然需要支持IE的不幸的人之一，那么这个问题有很多很好的答案

我没有看到采用
reduce
方法的方法，因此我将添加它：

var searchForValue = 'pig';

var valueIsInArray = ['horse', 'cat', 'dog'].reduce(function(previous, current){
    return previous || searchForValue === current ? true : false;
}, false);

console.log('The value "' + searchForValue + '" is in the array: ' + valueIsInArray);

.
注意数组上的indexOf没有在IE中实现，但是你可以自己定义它。你应该使用一个类型化比较，与
==
兼容以与本机实现修复比较并添加缺少的
返回-1
；请注意，根据ES5规范，此方法的行为将不同于e本机一在有符号的零和N的情况下（见15.4.4.14和9.12对11.9.6），这个答案指的是什么版本的IE？注意
if (![].includes) {
  Array.prototype.includes = function(searchElement /*, fromIndex*/ ) {
    'use strict';
    var O = Object(this);
    var len = parseInt(O.length) || 0;
    if (len === 0) {
      return false;
    }
    var n = parseInt(arguments[1]) || 0;
    var k;
    if (n >= 0) {
      k = n;
    } else {
      k = len + n;
      if (k < 0) {k = 0;}
    }
    var currentElement;
    while (k < len) {
      currentElement = O[k];
      if (searchElement === currentElement ||
         (searchElement !== searchElement && currentElement !== currentElement)) {
        return true;
      }
      k++;
    }
    return false;
  };
}

function inArray(myArray,myValue){
    var inArray = false;
    myArray.map(function(key){
        if (key === myValue){
            inArray=true;
        }
    });
    return inArray;
};

var anArray = [2,4,6,8]
console.log(inArray(anArray, 8)); // returns true
console.log(inArray(anArray, 1)); // returns false

function inArrayOfObjects(myArray,myValue,objElement){
    var inArray = false;
    myArray.map(function(arrayObj){
        if (arrayObj[objElement] === myValue) {
            inArray=true;
        }
    });
    return inArray;
};

var objArray = [{id:4,value:'foo'},{id:5,value:'bar'}]
console.log(inArrayOfObjects(objArray, 4, 'id')); // returns true
console.log(inArrayOfObjects(objArray, 'bar', 'value')); // returns true
console.log(inArrayOfObjects(objArray, 1, 'id')); // returns false

arrValues = ["Sam","Great", "Sample", "High"];

function namePresent(name){
  return name === this.toString();
}
// Note:
// namePresent requires .toString() method to coerce primitive value
// i.e. String {0: "S", 1: "a", 2: "m", length: 3, [[PrimitiveValue]]: "Sam"}
// into
// "Sam"

arrValues.some(namePresent, 'Sam');
=> true;

arrValues = ["Sam","Great", "Sample", "High"];

arrValues.includes('Sam');
=> true;

var contains = function (haystack, needle) {
    return !!~haystack.indexOf(needle);
}

var helper = {};

helper.array = {
    contains : function (haystack, needle) {
        return !!~haystack.indexOf(needle);
    }, 
    ...
};

if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function(searchElement, fromIndex) {
    var k;
    if (this == null) {
      throw new TypeError('"this" is null or not defined');
    }
    var o = Object(this);
    var len = o.length >>> 0;
    if (len === 0) {
      return -1;
    }
    var n = +fromIndex || 0;

    if (Math.abs(n) === Infinity) {
      n = 0;
    }
    if (n >= len) {
      return -1;
    }
    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
    while (k < len) {
      if (k in o && o[k] === searchElement) {
        return k;
      }
      k++;
    }
    return -1;
  };
}

var searchForValue = 'pig';

var valueIsInArray = ['horse', 'cat', 'dog'].reduce(function(previous, current){
    return previous || searchForValue === current ? true : false;
}, false);

console.log('The value "' + searchForValue + '" is in the array: ' + valueIsInArray);