我们使用以下代码段（用于对象、数组和字符串）：

/*
 * @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

Javascript中查找数组是否包含值的最快方法是：

function existsInArrayForIgnoreDataType(arr, targetElem) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] == targetElem) return true
  }
  return false
 }

你可以在这里找到我做的完整研究。

2019年更新：这个答案来自2008年（11岁！），与现代JS用法无关。承诺的性能改进基于当时浏览器中的基准测试。它可能与现代JS执行上下文无关。如果您需要一个简单的解决方案，请寻找其他答案。如果您需要最佳的性能，请在相关的执行环境中进行基准测试。

正如其他人所说，通过数组迭代可能是最好的方法，但事实证明，递减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

复杂性O（n/2）

您可以使用任何库函数，但我使用的是核心JavaScript。如果返回true，我们首先搜索中间的元素，否则我们同时从左到中和从右到中搜索数组中的元素。因此，它将具有O（n/2）复杂性。并且它将返回true或false，指示它是否存在

let isExist = (arr, element)=> {
  let index = -1;
  if ((arr.length % 2 != 0) && arr[(arr.length-1)/2]===element) {
    index = 1;
    return true;
  }
  for(let i=0; i<Math.ceil(arr.length-1/2); i++){
    if (arr[i]===element || (arr[arr.length-i]===element)) {
      index = i;
      break;
    }
  }
  return (index<0)? false : true;
}



let array = ['apple', 'ball', 'cat', 'dog', 'egg']

console.log(isExist(array, 'yellow'));
//Result false because yellow doesn't exist in array
console.log(isExist(array, 'cat'));
//Result true because yellow exist in array

现代浏览器具有Array#includes，这正是做到这一点的，除IE外，所有人都广泛支持它：

console.log（['joe'，'jane'，'mary']includes（'jane]））//真的

您也可以使用Array#indexOf，它不那么直接，但对于过时的浏览器不需要polyfill。

console.log（['joe'，'jane'，'smary'].indexOf（'jane'）>=0）//真的

许多框架也提供类似的方法：

jQuery:$.inArray（value，array，[fromIndex]）Undercore.js:_.inclus（数组，值）（别名为_.include和_.includes）DojoToolkit:Dojo.indexOf（array，value，[fromIndex，findLast]）原型：array.indexOf（value）MooTools:array.indexOf（value）MochiKit：findValue（数组，值）MS Ajax:array.indexOf（值）Ext:Ext.Array.contains（数组，值）Lodash：_.includes（array，value，[from]）（是_.包含4.0.0之前的版本）Ramda:R.includes（值，数组）

请注意，一些框架将其作为函数实现，而另一些框架将该函数添加到数组原型中。

function inArray(elem,array)
{
    var len = array.length;
    for(var i = 0 ; i < len;i++)
    {
        if(array[i] == elem){return i;}
    }
    return -1;
} 

如果找到，则返回数组索引；如果找不到，则返回-1