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

IT技术 javascript arrays
2021-01-17 17:09:42

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

这是我所知道的最好的方法:

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

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

6个回答

从 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);
       }
     );
    
我很好奇为什么您的 Mozilla 功能版本与您链接的网站如此不同。你自己修改过还是只是旧版本之类的?
2021-03-12 17:09:42
嗯,这就是我的答案哈哈。我无法通过查看 mozilla 网站来判断是否有旧版本,所以我不确定。不重要,只是好奇而已。无论如何,这仍然有帮助,所以你会得到一个赞成;)
2021-03-13 17:09:42
@Vinko Vrsalovic 是的,这是一个很好的解决方案,但是您应该隐藏使用 ~ 运算符返回 -1 的嵌入式实现 indexOf() 函数: function include(arr,obj) { return !!(~arr.indexOf(obj)) ; }
2021-03-15 17:09:42
@Shenjoku:“08 年 9 月 27 日 15:45 回答”
2021-04-02 17:09:42
但是,因为 indexOf 何时与 IE 兼容,因为我发现它与 IE 兼容w3schools.com/jsref/jsref_indexof.asp
2021-04-08 17:09:42

如果您使用 jQuery:

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

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

有帮助,但我认为这不是一个合适的答案。在我看来,这个问题被标记为“javascript”,表示“vanilla”。:)
2021-03-20 17:09:42
请注意,“inArray”用词不当,因为它不返回布尔值 - 它返回找到的第一个元素的索引。因此,如果您要检查元素是否存在,则应使用if (-1 != $.inArray(...)) ....
2021-04-02 17:09:42

首先,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 相关联基准测试,以对数组中的搜索进行基准测试虽然它们非常粗糙,但完整的调查将测试不同类型、不同长度的数组并查找出现在不同位置的对象。

2021-03-11 17:09:42
看看这些基准测试:blogs.sun.com/greimer/resource/loop-test.htm For 循环很慢。但我想基准测试中使用的数组非常大:)
2021-03-19 17:09:42
我同意。我也很务实。但是在优化语言的基础知识的情况下,我认为实现尽可能高效的功能是很好的设计。
2021-03-28 17:09:42
您链接到的代码示例在大型数组上运行缓慢。请参阅我的 hasItem() 函数实现示例中的注释。
2021-04-09 17:09:42

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

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

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

这在 O(lg n) 中运行,而不是 O(n),后者更具可扩展性
2021-03-12 17:09:42
@vidstige:他的意思是它可以很好地扩展,但对于小输入来说不一定是最快的。
2021-03-23 17:09:42
您可能应该提到这种方法在大型排序数组上比小型数组更快。
2021-03-26 17:09:42
为什么这在较小的阵列上会更慢?
2021-04-07 17:09:42

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