从 ECMAScript 2016 开始，您可以使用 includes()

arr.includes(obj);

如果您想支持 IE 或其他旧浏览器：

function include(arr,obj) {
    return (arr.indexOf(obj) != -1);
}

编辑：虽然这在 IE6、7 或 8 上不起作用。如果它不存在，最好的解决方法是自己定义它：

1. Mozilla 的(ECMA-262) 版本：

      if (!Array.prototype.indexOf)
      {
   
           Array.prototype.indexOf = function(searchElement /*, fromIndex */)
   
        {
   
   
        "use strict";
   
        if (this === void 0 || 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 > 0)
        {
          n = Number(arguments[1]);
          if (n !== n)
            n = 0;
          else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0))
            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;
      };
   
    }
   

2. 丹尼尔詹姆斯的版本：

    if (!Array.prototype.indexOf) {
      Array.prototype.indexOf = function (obj, fromIndex) {
        if (fromIndex == null) {
            fromIndex = 0;
        } else if (fromIndex < 0) {
            fromIndex = Math.max(0, this.length + fromIndex);
        }
        for (var i = fromIndex, j = this.length; i < j; i++) {
            if (this[i] === obj)
                return i;
        }
        return -1;
      };
    }
   

3. roosteronacid的版本：

    Array.prototype.hasObject = (
      !Array.indexOf ? function (o)
      {
        var l = this.length + 1;
        while (l -= 1)
        {
            if (this[l - 1] === o)
            {
                return true;
            }
        }
        return false;
      } : function (o)
      {
        return (this.indexOf(o) !== -1);
      }
    );
   

如果您使用 jQuery：

$.inArray(5 + 5, [ "8", "9", "10", 10 + "" ]);

更多信息：http : //api.jquery.com/jQuery.inArray/

首先，indexOf在没有 JavaScript 的浏览器中实现它。例如，请参阅Erik Arvidsson 的 array extras（还有相关的博客文章）。然后您可以使用indexOf而无需担心浏览器支持。这是他的indexOf实现的稍微优化的版本：

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (obj, fromIndex) {
        if (fromIndex == null) {
            fromIndex = 0;
        } else if (fromIndex < 0) {
            fromIndex = Math.max(0, this.length + fromIndex);
        }
        for (var i = fromIndex, j = this.length; i < j; i++) {
            if (this[i] === obj)
                return i;
        }
        return -1;
    };
}

它已更改为存储长度，因此不需要每次迭代都查找它。但差别并不是很大。一个不太通用的函数可能会更快：

var include = Array.prototype.indexOf ?
    function(arr, obj) { return arr.indexOf(obj) !== -1; } :
    function(arr, obj) {
        for(var i = -1, j = arr.length; ++i < j;)
            if(arr[i] === obj) return true;
        return false;
    };

我更喜欢使用标准功能，并在真正需要时保留这种微优化。但是，如果您热衷于微优化，我会调整评论中与 roosteronacid 相关联的基准测试，以对数组中的搜索进行基准测试。虽然它们非常粗糙，但完整的调查将测试不同类型、不同长度的数组并查找出现在不同位置的对象。

如果数组未排序，则没有更好的方法（除了使用上面提到的 indexOf，我认为这与此相同）。如果数组已排序，则可以进行二进制搜索，其工作方式如下：

1. 选择数组的中间元素。
2. 您正在寻找的元素是否比您选择的元素大？如果是这样，您已经消除了阵列的下半部分。如果不是，您已经消除了上半部分。
3. 选择数组剩余一半的中间元素，并继续执行步骤 2，消除剩余数组的一半。最终你要么找到你的元素，要么没有数组可供查看。

二分搜索运行的时间与数组长度的对数成正比，因此它比查看每个单独的元素要快得多。

[ ].has(对象)

假设.indexOf()被执行

Object.defineProperty( Array.prototype,'has',
{
    value:function(o, flag){
    if (flag === undefined) {
        return this.indexOf(o) !== -1;
    } else {   // only for raw js object
        for(var v in this) {
            if( JSON.stringify(this[v]) === JSON.stringify(o)) return true;
        }
        return false;                       
    },
    // writable:false,
    // enumerable:false
})

！！！不要制作，Array.prototype.has=function(){...因为您将在每个数组中添加一个可枚举元素并且 js 已损坏。

//use like          
[22 ,'a', {prop:'x'}].has(12) // false
["a","b"].has("a") //  true

[1,{a:1}].has({a:1},1) // true
[1,{a:1}].has({a:1}) // false

使用第二个参数（标志）强制按值而不是引用进行比较

比较原始对象

[o1].has(o2,true) // true if every level value is same