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

2020/09/20 22:01 · javascript ·  · 0评论

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

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

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

从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. 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;
        }
        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/

First, implement indexOf in JavaScript for browsers that don't already have it. For example, see Erik Arvidsson's array extras (also, the associated blog post). And then you can use indexOf without worrying about browser support. Here's a slightly optimised version of his indexOf implementation:

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

It's changed to store the length so that it doesn't need to look it up every iteration. But the difference isn't huge. A less general purpose function might be faster:

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

我更喜欢使用标准函数,并在真正需要时保留这种微优化。但是,如果您热衷于微优化,则可以将雄激素酸在注释中链接基准调整为数组中的基准搜索不过,它们非常粗糙,全面的研究会测试具有不同类型,不同长度的数组,并查找出现在不同位置的对象。

如果数组未排序,则实际上没有更好的方法(除了使用上述indexOf之外,我认为这是同一件事)。如果数组已排序,则可以执行二进制搜索,其工作方式如下:

  1. 选择数组的中间元素。
  2. 您要寻找的元素是否大于您选择的元素?如果是这样,您就消除了阵列的下半部分。如果不是,那么您已经淘汰了上半部分。
  3. 选取阵列剩余一半的中间元素,然后按照步骤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

使用第二个arg(标志)强制按值而不是引用进行比较

比较原始对象

[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;在例程结束时执行一个操作,以返回真正的布尔值...

这是为您提供的一些元知识-如果您想知道可以使用Array做什么,请查看文档-这是Mozilla的Array页面

https://developer.mozilla.org/zh-CN/docs/JavaScript/Reference/Global_Objects/Array

在那里,您将看到对Javascript 1.6中添加的indexOf的引用

这里详细介绍了一种可靠的方法来检查对象是否为javascript中的数组:

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

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;
}
本文地址:http://javascript.askforanswer.com/chazhaoxiangmushifouzaijavascriptshuzuzhongdezuijiafangfazhongfu.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!