在JavaScript对象数组中按id查找对象

我有一个数组：

myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}, etc.]

var result = $.grep(myArray, function(e){ return e.id == id; });

我无法更改数组的结构。我被传递了一个id为

45

，我想获取数组中该对象的

'bar'

如何在JavaScript或使用jQuery中实现这一点？

尝试以下方法

function findById(source, id) {
  for (var i = 0; i < source.length; i++) {
    if (source[i].id === id) {
      return source[i];
    }
  }
  throw "Couldn't find object with id: " + id;
}

函数findById（源代码，id）{
对于（变量i=0；i

我认为最简单的方法是以下方法，但它不适用于InternetExplorer8（或更早版本）：

---

迭代数组中的任何项。对于您访问的每个项目，请检查该项目的id。如果匹配，请将其返回

如果您只是想了解codez：

function getId(array, id) {
    for (var i = 0, len = array.length; i < len; i++) {
        if (array[i].id === id) {
            return array[i];
        }
    }
    return null; // Nothing found
}

---

您可以使用以下功能轻松实现这一点：

myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];

var found = $.map(myArray, function(val) {
    return val.id == 45 ? val.foo : null;
});

//found[0] == "bar";

---

---

工作示例：

另一种解决方案是创建查找对象：

var lookup = {};
for (var i = 0, len = array.length; i < len; i++) {
    lookup[array[i].id] = array[i];
}

... now you can use lookup[id]...

var lookup={}；
对于（变量i=0，len=array.length；i

如果你需要做很多查找，这是特别有趣的

---

这不需要太多内存，因为ID和对象将被共享。

由于您已经在使用jQuery，您可以使用用于搜索数组的函数：

myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}, etc.]

var result = $.grep(myArray, function(e){ return e.id == id; });

结果是一个包含找到的项的数组。如果您知道对象始终存在并且只出现一次，则可以使用

result[0].foo

获取值。否则，您应该检查结果数组的长度。例如：

if (result.length === 0) {
  // no result found
} else if (result.length === 1) {
  // property found, access the foo property using result[0].foo
} else {
  // multiple items found
}

---

上述findById函数的通用和更灵活版本：

// array = [{key:value},{key:value}]
function objectFindByKey(array, key, value) {
    for (var i = 0; i < array.length; i++) {
        if (array[i][key] === value) {
            return array[i];
        }
    }
    return null;
}

var array = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];
var result_obj = objectFindByKey(array, 'id', '45');

//数组=[{key:value}，{key:value}]
函数objectFindByKey（数组、键、值）{
对于（var i=0；i

您可以从中试用Sugarjs

它在数组上有一个非常好的方法，

。find

。因此，您可以找到如下元素：

array.find( {id: 75} );

您还可以将具有更多属性的对象传递给它，以添加另一个“where子句”

注意到Sujjs扩展了原生对象，有些人认为这很邪恶…

有一个很好的方法：

myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'},etc.]
obj = _.find(myArray, function(obj) { return obj.id == '45' })

使用：

它应该按id返回对象。

您可以使用过滤器

  function getById(id, myArray) {
    return myArray.filter(function(obj) {
      if(obj.id == id) {
        return obj 
      }
    })[0]
  }

get_my_obj = getById(73, myArray);

ECMAScript 2015（JavaScript ES6）提供了 数组上的方法：

var myArray=[
{id:1，名称：“bob”}，
{id:2，名字：“dan”}，
{id:3，名称：“倒钩”}，
]
//获取与id“2”匹配的数组项
var item=myArray.find（item=>item.id==2）；
//印刷品
console.log（item.name）只要浏览器支持，第5版（2009年12月）应该可以使用，几乎只有一行代码：

var bFound = myArray.some(function (obj) {
    return obj.id === 45;
});

从开始，这是一个实际返回所需元素的函数（如果未找到，则返回
null
），给定
array
和一个
callback
函数，该函数返回“correct”元素的真实值：

请记住，这在IE8上本机不起作用，因为它不支持
some
。可以提供polyfill，也可以使用经典的
for
循环：

function findElement(array, callback) {
    for (var i = 0; i < array.length; i++)
        if (callback(array[i])) return array[i];
    return null;
});

函数findElement（数组、回调）{
对于（var i=0；i

它实际上更快更紧凑。但如果您不想重新发明轮子，我建议使用下划线或lodash之类的实用程序库。
此解决方案也可能有帮助：

Array.prototype.grep = function (key, value) {
    var that = this, ret = [];
    this.forEach(function (elem, index) {
        if (elem[key] === value) {
            ret.push(that[index]);
        }
    });
    return ret.length < 2 ? ret[0] : ret;
};
var bar = myArray.grep("id","45");

Array.prototype.grep=函数（键，值）{
var=this，ret=[]；
this.forEach（函数（元素，索引）{
if（元素[键]==值）{
返回推送（该[索引]）；
}
});
返回ret.length<2？ret[0]：ret；
};
var bar=myArray.grep（“id”，“45”）；

我做的就像
$.grep
一样，如果找到一个对象，函数将返回该对象，而不是一个数组。
基于接受的答案：

jQuery：

var foo = $.grep(myArray, function(e){ return e.id === foo_id})
myArray.pop(foo)

或咖啡脚本：

foo = $.grep myArray, (e) -> e.id == foo_id
myArray.pop foo

即使在纯JavaScript中，也可以通过使用内置的数组“过滤器”函数来实现这一点：

Array.prototype.filterObjects = function(key, value) {
    return this.filter(function(x) { return x[key] === value; })
}

现在只需传递“id”代替
键
，传递“45”代替
值
，就可以得到与id为45匹配的完整对象。那就是

myArr.filterObjects("id", "45");

我真的很喜欢Aaron Digulla提供的答案，但我需要保留我的对象数组，以便以后可以遍历它。所以我把它改成


var索引器={}；
对于（var i=0；iarray[indexer[id]].property
以下是我如何在纯JavaScript中使用它的，以我能想到的最简单的方式在ECMAScript 3或更高版本中使用。一旦找到匹配项，它就会返回

var getKeyValueById = function(array, key, id) {
    var testArray = array.slice(), test;
    while(test = testArray.pop()) {
        if (test.id === id) {
            return test[key];
        }
    }
    // return undefined if no matching id is found in array
    return;
}

var myArray = [{'id':'73', 'foo':'bar'}, {'id':'45', 'foo':'bar'}]
var result = getKeyValueById(myArray, 'foo', '45');

// result is 'bar', obtained from object with id of '45'

使用本机
如果找到，则返回对象元素，否则
false
使用
find（）
方法：

myArray.find(x => x.id === '45').foo;

发件人：

如果数组中的元素满足提供的测试函数，则
find（）
方法返回数组中的第一个值。否则将返回未定义的


如果要查找其索引，请使用
findIndex（）
：

发件人：

findIndex（）
方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1


如果要获取匹配元素的数组，请改用以下方法：

myArray.filter(x => x.id === '45');

这将返回一个对象数组。如果要获取
foo
属性的数组，可以使用以下方法：


旁注：像
find（）
或
filter（）
这样的方法不受旧浏览器（如IE）的支持，因此如果您想支持这些浏览器
myArray.filter(function(a){ return a.id == some_id_you_want })[0]

var array = [ {'id':'73' ,'foo':'bar'} , {'id':'45' ,'foo':'bar'} , ];
var id = 73;

var found = array.reduce(function(a, b){
    return (a.id==id && a) || (b.id == id && b)
});

myArray.find(x => x.id === '45').foo;

myArray.findIndex(x => x.id === '45');

myArray.filter(x => x.id === '45');

myArray.filter(x => x.id === '45').map(x => x.foo);

var items = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];

var lookup = items.reduce((o,i)=>o[i.id]=o,{});

var bar = o[id];

var jsonObj =[
 {
  "name": "Me",
  "info": {
   "age": "15",
   "favColor": "Green",
   "pets": true
  }
 },
 {
  "name": "Alex",
  "info": {
   "age": "16",
   "favColor": "orange",
   "pets": false
  }
 },
{
  "name": "Kyle",
  "info": {
   "age": "15",
   "favColor": "Blue",
   "pets": false
  }
 }
];

var getPerson = function(name){
    return jsonObj.filter(function(obj) {
      return obj.name === name;
    });
}

const map = new Map( myArray.map(el => [el.id, el]) );

map.get(27).foo

var data= [];
$.each(array,function(i){if(n !== 5 && i > 4){data.push(item)}}

var data = $.grep(array, function( n, i ) {
  return ( n !== 5 && i > 4 );
});

Array.find, Array.filter, Array.forEach, Array.map

function findFromArray(array,key,value) {
        return array.filter(function (element) {
            return element[key] == value;
        }).shift();
}

var items = mydata.filter(function(item){
    return item.word.toLowerCase().startsWith( 'gk );
})