对象数组中的indexOf方法?

2020/09/24 15:01 · javascript ·  · 0评论

获取包含对象的数组的索引的最佳方法是什么?

想象一下这种情况:

var hello = {
    hello: 'world',
    foo: 'bar'
};
var qaz = {
    hello: 'stevie',
    foo: 'baz'
}

var myArray = [];
myArray.push(hello,qaz);

现在,我想拥有indexOf对象对象,该对象的hello属性'stevie'在此示例中为1

我是JavaScript的新手,我不知道是否有一个简单的方法,或者是否应该构建自己的函数来做到这一点。

我认为您可以使用map函数在一行中解决它

pos = myArray.map(function(e) { return e.hello; }).indexOf('stevie');

除IE(非边缘)以外的所有浏览器均支持Array.prototype.findIndex但是提供polyfill很好。

var indexOfStevie = myArray.findIndex(i => i.hello === "stevie");

地图的解决方案是可以的。但是您每次搜索都会遍历整个数组。对于findIndex来说这只是最坏的情况,一旦找到匹配,它将停止迭代。


没有真正简洁的方法 (当开发人员不得不担心IE8时),但这是一个常见的解决方案:

var searchTerm = "stevie",
    index = -1;
for(var i = 0, len = myArray.length; i < len; i++) {
    if (myArray[i].hello === searchTerm) {
        index = i;
        break;
    }
}

或作为功能:

function arrayObjectIndexOf(myArray, searchTerm, property) {
    for(var i = 0, len = myArray.length; i < len; i++) {
        if (myArray[i][property] === searchTerm) return i;
    }
    return -1;
}
arrayObjectIndexOf(arr, "stevie", "hello"); // 1

只是一些注意事项:

  1. 不要用于数组循环中
  2. 找到“针”后,请务必打破循环或退出功能
  3. 注意对象相等

例如,

var a = {obj: 0};
var b = [a];
b.indexOf({obj: 0}); // -1 not found

在ES2015中,这非常简单:

myArray.map(x => x.hello).indexOf('stevie')

或者,对于较大的阵列,可能具有更好的性能:

myArray.findIndex(x => x.hello === 'stevie')
var idx = myArray.reduce( function( cur, val, index ){

    if( val.hello === "stevie" && cur === -1 ) {
        return index;
    }
    return cur;

}, -1 );

我喜欢Pablo的回答,但是Array#indexOf和Array#map并非在所有浏览器上都起作用。下划线将使用本机代码(如果可用),但也具有后备功能。另外,它具有可完全执行Pablo匿名地图方法所用的pluck方法。

var idx = _.chain(myArray).pluck("hello").indexOf("Stevie").value();

或原型:

Array.prototype.indexOfObject = function arrayObjectIndexOf(property, value) {
    for (var i = 0, len = this.length; i < len; i++) {
        if (this[i][property] === value) return i;
    }
    return -1;
}

myArr.indexOfObject("name", "stevie");

简要

myArray.indexOf('stevie','hello')

用例 :

  /*****NORMAL****/  
[2,4,5].indexOf(4) ;//OUTPUT 1
 /****COMPLEX*****/
 [{slm:2},{slm:4},{slm:5}].indexOf(4,'slm');//OUTPUT 1
 //OR
 [{slm:2},{slm:4},{slm:5}].indexOf(4,function(e,i){
   return e.slm;
});//OUTPUT 1
/***MORE Complex**/
[{slm:{salat:2}},{slm:{salat:4}},{slm:{salat:5}}].indexOf(4,function(e,i){
   return e.slm.salat;
});//OUTPUT 1

API:

    Array.prototype.indexOfOld=Array.prototype.indexOf

    Array.prototype.indexOf=function(e,fn){
      if(!fn){return this.indexOfOld(e)}
      else{ 
       if(typeof fn ==='string'){var att=fn;fn=function(e){return e[att];}}
        return this.map(fn).indexOfOld(e);
      }
    };

我在这里对各种答案进行了性能测试,任何人都可以自行运行它们:

https://jsperf.com/find-index-of-object-in-array-by-contents

根据我在Chrome中进行的初步测试,以下方法(使用原型内设置的for循环)是最快的:

Array.prototype.indexOfObject = function (property, value) {
    for (var i = 0, len = this.length; i < len; i++) {
        if (this[i][property] === value) return i;
    }
    return -1;
}

myArray.indexOfObject("hello", "stevie");

这段代码是Nathan Zaetta的答案的稍作修改的版本。

在性能基准测试中,我尝试将目标放置在1000个对象数组的中间(索引500)和末尾(索引999)中,即使我将目标放在数组的最后一个项目中(这也意味着它必须先遍历数组中的每个项目,然后才能以最快的速度结束。

该解决方案还具有成为重复执行最简洁的优点,因为只需要重复最后一行:

myArray.indexOfObject("hello", "stevie");

我比较了几种方法,并获得了解决该问题的最快方法的结果。这是一个for循环。它比任何其他方法快5倍以上。

这是测试的页面:https : //jsbench.me/9hjewv6a98

虽然,这里的大多数其他答案都是有效的。有时,最好只是在使用位置附近做一个简短的简单函数。

// indexOf wrapper for the list of objects
function indexOfbyKey(obj_list, key, value) {
    for (index in obj_list) {
        if (obj_list[index][key] === value) return index;
    }
    return -1;
}
// Find the string in the list (default -1)
var test1 = indexOfbyKey(object_list, 'name', 'Stevie');
var test2 = indexOfbyKey(object_list, 'last_name', 'some other name');

这取决于对您而言重要的内容。它可能节省代码行,并且非常聪明,因此可以使用单行代码,或者将通用解决方案放在涵盖各种边缘情况的地方。但是有时候,最好只是说:“在这里我是这样做的”,而不是让将来的开发人员进行额外的逆向工程工作。特别是如果您认为自己像问题中的“新手”。

array.filter(function(item, indx, arr){ return(item.hello === 'stevie'); })[0];

注意[0]

reduce如在Antonio Laguna的答案中使用是正确的。

简短的道歉...

如果您的对象与数组中使用的对象相同,则应该能够像获取字符串一样获取对象的索引。

var hello = {
    hello: 'world',
    foo: 'bar'
};
var qaz = {
    hello: 'stevie',
    foo: 'baz'
}

var qazCLONE = { // new object instance and same structure
    hello: 'stevie',
    foo: 'baz'
}

var myArray = [hello,qaz];

myArray.indexOf(qaz) // should return 1
myArray.indexOf(qazCLONE) // should return -1

试试这个:

console.log(Object.keys({foo:"_0_", bar:"_1_"}).indexOf("bar"));

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

简单:

myArray.indexOf(myArray.filter(function(item) {
    return item.hello == "stevie"
})[0])

如果您只想找到职位,请参阅@Pablo的答案

pos = myArray.map(function(e) { return e.hello; }).indexOf('stevie');

但是,如果您希望找到该元素(即,如果您正在考虑做这样的事情myArray[pos]),则可以使用一种更有效的单行方法来完成filter

element = myArray.filter((e) => e.hello === 'stevie')[0];

查看性能结果(〜+ 42%ops / sec):http :
//jsbench.github.io/#7fa01f89a5dc5cc3bee79abfde80cdb3

参见以下示例:http : //jsfiddle.net/89C54/

for (i = 0; i < myArray.length; i++) {
    if (myArray[i].hello === 'stevie') {
        alert('position: ' + i);
        return;
    }
}

它从零开始计数。

我已经做了一个通用的功能来检查下面的代码并适用于任何对象

function indexOfExt(list, item) {
    var len = list.length;

    for (var i = 0; i < len; i++) {
        var keys = Object.keys(list[i]);
        var flg = true;
        for (var j = 0; j < keys.length; j++) {
            var value = list[i][keys[j]];
            if (item[keys[j]] !== value) {
                flg = false;
            }
        }
        if (flg == true) {
            return i;
        }
    }
    return -1;
}

var items = [{ "hello": 'world', "foo": 'bar' }];
var selectedItem = { "hello": 'world', "foo": 'bar' };
alert(items.indexOf(selectedItem));
alert(indexOfExt(items, selectedItem));

第一个警报将返回-1(未找到匹配项),第二个警报将返回0(已找到匹配项)。

_.findIndexunderscore.js库中使用

这是例子
_.findIndex([{a:1},{a: 2,c:10},{a: 3}], {a:2,c:10}) //1

使用ES6 findIndex方法,无需使用lodash或任何其他库,您可以编写:

function deepIndexOf(arr, obj) {
  return arr.findIndex(function (cur) {
    return Object.keys(obj).every(function (key) {
      return obj[key] === cur[key];
    });
  });
}

这将比较对象的立即属性,但不会递归到属性中。

如果您的实现尚不提供findIndex(大多数情况不提供),则可以添加支持此搜索的轻型polyfill:

function deepIndexOf(arr, obj) {
  function findIndex = Array.prototype.findIndex || function (pred) {
    for (let i = 0; i < this.length; ++i) {
      if (pred.call(this, this[i], i)) {
        return i;
      }
    }

    return -1;
  }

  return findIndex.call(arr, function (cur) {
    return Object.keys(obj).every(function (key) {
      return obj[key] === cur[key];
    });
  });
}

(根据我对这个骗子的回答

Array.prototype.findIndex()基本上可以使用本机便捷的功能

如果数组中的元素满足提供的测试功能,则findIndex()方法将返回数组中的索引。否则返回-1。

请注意,Internet Explorer,Opera和Safari不支持它,但是您可以使用下面的链接中提供的Polyfill。

更多信息:

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

var hello = {
  hello: 'world',
  foo: 'bar'
};
var qaz = {
  hello: 'stevie',
  foo: 'baz'
}

var myArray = [];
myArray.push(hello, qaz);

var index = myArray.findIndex(function(element, index, array) {
  if (element.hello === 'stevie') {
    return true;
  }
});
alert('stevie is at index: ' + index);

Furthor的@Monika加尔格答,你可以使用findIndex()(有一种填充工具用于unsupprted浏览器)。

我看到人们不赞成这个答案,并且我希望他们这样做是因为语法错误,因为我认为这是最优雅的方法。

如果数组中的元素满足提供的测试功能,则findIndex()方法将返回数组中的索引。否则返回-1。

例如:

var hello = {
  hello: 'world',
  foo: 'bar'
};
var qaz = {
  hello: 'stevie',
  foo: 'baz'
}

var myArray = [];
myArray.push(hello,qaz);

var index = myArray.findIndex(function(element) {
  return element.hello == 'stevie';
});

alert(index);

这是在数组中查找对象索引的方法

    var myArray = [{  hello: 'world',
        foo: 'bar'
    },{
        hello: 'stevie',
        foo: 'baz'
    }];



    for (i = 0; i < myArray.length; i++) {
        if (myArray[i].hello === 'stevie') {
            alert('position: ' + i);
            return;
        }
    }

无需自定义代码即可使用

var arr, a, found;
arr = [{x: 1, y: 2}];
a = {x: 1, y: 2};
found = JSON.stringify(arr).indexOf(JSON.stringify(a)) > - 1;
// found === true

注意:这并没有给出实际的索引,它只是告诉您对象是否存在于当前数据结构中

您可以简单地使用

const someId = 2;
const array = [{id:1}, {id:2}, {id:3}];
const index = array.reduce((i, item, index) => item.id === someId ? index : i, -1);
alert('someId ' + someId + ' is at index ' + index);

没有下划线,没有,只是减少。

var hello = {hello: "world",  foo: "bar"};
var qaz = {hello: "stevie", foo: "baz"};
var myArray = [];
myArray.push(hello,qaz);

function indexOfObject( arr, key, value   ) {
    var j = -1;
    var result = arr.some(function(obj, i) { 
        j++;
        return obj[key] == value;
    })

    if (!result) {
        return -1;
    } else {
        return j;
    };
}

alert(indexOfObject(myArray,"hello","world"));

您可以创建自己的原型来执行此操作:

就像是:

Array.prototype.indexOfObject = function (object) {
    for (var i = 0; i < this.length; i++) {
        if (JSON.stringify(this[i]) === JSON.stringify(object))
            return i;
    }
}

我将更喜欢使用findIndex()方法:

 var index = myArray.findIndex('hello','stevie');

index 将为您提供索引号。

本文地址:http://javascript.askforanswer.com/duixiangshuzuzhongdeindexoffangfa.html
文章标签:
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

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

上一篇:
下一篇:

评论已关闭!