查找项目是否在 JavaScript 数组中的最佳方法？ [复制]

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

arr.includes(obj);

如果要支持 IE 或其他旧版浏览器：

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

编辑：但这不适用于 IE6、7 或 8。如果它不存在，最好的解决方法是自己定义它：

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 = 对象（这个）； var len = t.length >>> 0;如果（len === 0）返回-1；变量 n = 0; if (arguments.length > 0) { n = Number(arguments[1]);如果 (n !== n) n = 0;否则 if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) n = (n > 0 || -1) * Math.floor(Math.abs( n));如果 (n >= len) 返回 -1;变量 k = n >= 0 ？ n : Math.max(len - Math.abs(n), 0); for (; k < len; k++) { if (k in t && t[k] === searchElement) 返回 k; } 返回 -1; }; } Daniel James 的版本： 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; } 返回 -1; }; } 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/

---

首先，在 JavaScript 中为还没有它的浏览器实现 indexOf。例如，请参阅 Erik Arvidsson's array extras（也称为 associated blog post）。然后您可以使用 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;
    };

我更喜欢使用标准功能，并在真正需要时保留这种微优化。但是，如果您热衷于微优化，我将评论中与 roosterononacid 相关的 benchmarks 调整为 benchmark searching in arrays。虽然它们非常粗糙，但完整的调查将测试具有不同类型、不同长度的数组并找到出现在不同位置的对象。

---

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

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

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

---

[].has(obj)

假设 .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

---

这取决于你的目的。如果您为 Web 编程，请避免使用 indexOf，Internet Explorer 6 不支持它（其中很多仍在使用！），或者有条件地使用：

if (yourArray.indexOf !== undefined) result = yourArray.indexOf(target);
else result = customSlowerSearch(yourArray, target);

indexOf 可能是用本机代码编码的，因此它比您在 JavaScript 中可以执行的任何操作都快（如果数组合适，二进制搜索/二分法除外）。注意：这是一个品味问题，但我会在您的例程结束时执行 return false;，以返回一个真正的布尔值......

---

这是给你的一些元知识 - 如果你想知道你可以用数组做什么，请查看文档 - 这是 Mozilla 的数组页面

https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array

在那里你会看到对 indexOf 的引用，它是在 Javascript 1.6 中添加的

---

此处详细介绍了一种检查对象是否为 javascript 中的数组的可靠方法：

以下是我附加到 utils = {}“容器”的 xa.js 框架中的两个函数。这些应该可以帮助您正确检测阵列。

var utils = {};

/**
 * utils.isArray
 *
 * Best guess if object is an array.
 */
utils.isArray = function(obj) {
     // do an instanceof check first
     if (obj instanceof Array) {
         return true;
     }
     // then check for obvious falses
     if (typeof obj !== 'object') {
         return false;
     }
     if (utils.type(obj) === 'array') {
         return true;
     }
     return false;
 };

/**
 * utils.type
 *
 * Attempt to ascertain actual object type.
 */
utils.type = function(obj) {
    if (obj === null || typeof obj === 'undefined') {
        return String (obj);
    }
    return Object.prototype.toString.call(obj)
        .replace(/\[object ([a-zA-Z]+)\]/, '$1').toLowerCase();
};

如果您想检查一个对象是否在数组中，我还将包含以下代码：

/**
 * Adding hasOwnProperty method if needed.
 */
if (typeof Object.prototype.hasOwnProperty !== 'function') {
    Object.prototype.hasOwnProperty = function (prop) {
        var type = utils.type(this);
        type = type.charAt(0).toUpperCase() + type.substr(1);
        return this[prop] !== undefined
            && this[prop] !== window[type].prototype[prop];
    };
}

最后是这个 in_array 函数：

function in_array (needle, haystack, strict) {
    var key;

    if (strict) {
        for (key in haystack) {
            if (!haystack.hasOwnProperty[key]) continue;

            if (haystack[key] === needle) {
                return true;
            }
        }
    } else {
        for (key in haystack) {
            if (!haystack.hasOwnProperty[key]) continue;

            if (haystack[key] == needle) {
                return true;
            }
        }
    }

    return false;
}

---