给定IE的indexOf实现(由eyelidlessness描述):

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

var contains = function(needle) {
    // Per spec, the way to identify NaN is that it is not equal to itself
    var findNaN = needle !== needle;
    var indexOf;

    if(!findNaN && typeof Array.prototype.indexOf === 'function') {
        indexOf = Array.prototype.indexOf;
    } else {
        indexOf = function(needle) {
            var i = -1, index = -1;

            for(i = 0; i < this.length; i++) {
                var item = this[i];

                if((findNaN && item !== item) || item === needle) {
                    index = i;
                    break;
                }
            }

            return index;
        };
    }

    return indexOf.call(this, needle) > -1;
};

你可以这样使用它:

var myArray = [0,1,2],
    needle = 1,
    index = contains.call(myArray, needle); // true

CodePen验证/使用

博士tl;

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;
}

例子

函数包含(k) { (var = 0;I < this.length;我+ +){ 如果(这[我]= = = k | |(这[我]! = =这[我]& & k ! = = k)) { 返回true; ｝ ｝ 返回错误; ｝ 函数日志(味精){ $(“#”)。追加('<div>' + MSG + '</div>'); ｝ var arr = [1， "2"， NaN, true]; 加勒比海盗。Includes =包含; log('var arr = [1， "2"， NaN, true];'); 日志(“< br / >”); Log ('arr.includes(1): ' + arr.includes(1)); Log ('arr.includes(2): ' + arr.includes(2)); Log ('arr.includes("2"): ' + arr.includes("2")); log('arr.includes(NaN): ' + arr.includes(NaN)); Log ('arr.includes(true): ' + arr.includes(true)); Log ('arr.includes(false): ' + arr.includes(false)); #出{ 字体类型:等宽字体; ｝ < script src = " https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js " > < /脚本> < div id =了> < / div >

再回答

我知道这个问题实际上不是关于是否扩展内置对象，但是OP的尝试和对这个答案的评论突出了这个争论。我13年2月12日的评论引用了一篇文章，很好地概述了这场辩论，但是那个链接坏了，我无法编辑原始评论，因为时间过得太久了，所以我把它放在这里。

如果您希望使用contains方法扩展内置Array对象，那么最好且最负责任的方法可能是使用MDN中的这个polyfill。(另请参阅MDN文章中关于原型继承的部分，其中解释了“扩展内置原型的唯一好理由是向后移植新JavaScript引擎的特性;例如Array。forEach等。”)

if (!Array.prototype.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 includes(k, strict) {
  strict = strict !== false; // default is true
  // strict = !!strict; // default is false
  for(var i=0; i < this.length; i++){
    if( (this[i] === k && strict) || 
        (this[i] == k && !strict) ||
        (this[i] !== this[i] && k !== k)
    ) {
      return true;
    }
  }
  return false;
}

我的小小贡献:

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

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

哇，这个问题有很多很好的答案。

我没有看到一个采用减法的方法，所以我将添加它:

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);

这是它的演奏。

我更喜欢简单:

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