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

Question

查找对象是否在数组中的最佳方法是什么？

这是我所知道的最佳方式:

function include(arr, obj) {
    for(var i=0; i<arr.length; i++) {
        if (arr[i] == obj) return true;
    }
}

include([1,2,3,4], 3); // true
include([1,2,3,4], 6); // undefined

Answer 1

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

Answer 2

如果你使用jQuery:

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

有关更多信息,请访问:http://api.jquery.com/jQuery.inArray/

Answer 3

首先,indexOf在JavaScript中实现尚未拥有它的浏览器.例如,请参阅Erik Arvidsson的阵列附加内容(也是相关的博客文章).然后您可以使用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链接的基准,以便在数组中进行基准搜索.它们非常粗糙,完整的调查将测试具有不同类型,不同长度和发现在不同位置发生的对象的阵列.

Answer 4

如果数组未排序,那么实际上并没有更好的方法(除了使用上面提到的indexOf,我认为这相同的事情).如果数组已排序,您可以进行二进制搜索,其工作方式如下:

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

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

Answer 5

[] .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

使用第二个arg(旗帜)强制按价值而不是参照进行比较

比较原始对象

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

Answer 6

这取决于你的目的.如果您为Web编程,请避免indexOf,Internet Explorer 6不支持它(其中许多仍然使用!),或者有条件使用:

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

indexOf可能是用本机代码编写的,因此它比你在JavaScript中可以做的任何事情都快(除了二进制搜索/二分法,如果数组是合适的).注意:这是一个品味问题,但我会return false;在你的例程结束时做一个真正的布尔...

Answer 7

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

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

在那里你会看到indexOf的引用,在Javascript 1.6中添加

Answer 8

这里详细介绍了在 JavaScript 中检查对象是否为数组的可靠方法：

\n\n

以下是xa.js框架中的两个函数，我将它们附加到utils = {}\xe2\x80\x98container\xe2\x80\x99。这些应该可以帮助您正确检测阵列。

\n\n

var utils = {};\n\n/**\n * utils.isArray\n *\n * Best guess if object is an array.\n */\nutils.isArray = function(obj) {\n     // do an instanceof check first\n     if (obj instanceof Array) {\n         return true;\n     }\n     // then check for obvious falses\n     if (typeof obj !== \'object\') {\n         return false;\n     }\n     if (utils.type(obj) === \'array\') {\n         return true;\n     }\n     return false;\n };\n\n/**\n * utils.type\n *\n * Attempt to ascertain actual object type.\n */\nutils.type = function(obj) {\n    if (obj === null || typeof obj === \'undefined\') {\n        return String (obj);\n    }\n    return Object.prototype.toString.call(obj)\n        .replace(/\\[object ([a-zA-Z]+)\\]/, \'$1\').toLowerCase();\n};\n

\n\n

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

\n\n

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

\n\n

最后是这个 in_array 函数：

\n\n

function in_array (needle, haystack, strict) {\n    var key;\n\n    if (strict) {\n        for (key in haystack) {\n            if (!haystack.hasOwnProperty[key]) continue;\n\n            if (haystack[key] === needle) {\n                return true;\n            }\n        }\n    } else {\n        for (key in haystack) {\n            if (!haystack.hasOwnProperty[key]) continue;\n\n            if (haystack[key] == needle) {\n                return true;\n            }\n        }\n    }\n\n    return false;\n}\n

\n