尝试以下操作

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

我认为最简单的方法是以下方法，但它在Internet Explorer 8（或更早版本）上不起作用：

var result = myArray.filter(function(v) {
    return v.id === '45'; // Filter out the appropriate one
})[0].foo; // Get result and access the foo property

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

如果你只是想要代码：

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
}

使用ECMAScript 5的Array方法也是一样的：

function getId(array, id) {
    var obj = array.filter(function (val) {
        return val.id === id;
    });

    // Filter returns an array, and we just want the matching item.
    return obj[0];
}

您可以使用map（）函数轻松实现这一点：

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

工作示例：http://jsfiddle.net/hunter/Pxaua/

使用jQuery的过滤方法：

 $(myArray).filter(function()
 {
     return this.id == desiredId;
 }).first();

这将返回具有指定Id的第一个元素。

它还具有良好的C#LINQ格式的优点。

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

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

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

如果需要进行多次查找，这一点尤其有趣。

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

由于您已经在使用jQuery，因此可以使用grep函数来搜索数组：

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');

你可以试试Sugarjshttp://sugarjs.com/.

它在Arrays上有一个非常好的方法，.find。所以你可以找到这样的元素：

array.find( {id: 75} );

您还可以向其传递具有更多财产的对象，以添加另一个“where-clause”。

请注意，Sugarjs扩展了本地对象，有些人认为这非常邪恶。。。

Undercore.js有一个很好的方法：

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

Use:

var retObj ={};
$.each(ArrayOfObjects, function (index, obj) {

        if (obj.id === '5') { // id.toString() if it is int

            retObj = obj;
            return false;
        }
    });
return retObj;

它应该按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）提供find（）数组上的方法：

var myArray=[｛id:1，name:“bob”｝，｛id:2，名称：“dan”｝，｛id:3，名称：“barb”｝，]//抓取与id“2”匹配的Array项var item=myArray.find（item=>item.id===2）；//打印console.log（item.name）；

它在没有外部库的情况下工作。但是，如果您想要更旧的浏览器支持，您可能需要包含此polyfill。

只要浏览器支持ECMA-262，第5版（2009年12月），这应该可以工作，几乎只有一行：

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

从aggaton的答案开始，这是一个实际返回所需元素（如果找不到则返回null）的函数，给定数组和一个回调函数，该函数返回“正确”元素的truthy值：

function findElement(array, callback) {
    var elem;
    return array.some(function(e) {
        if (callback(e)) {
            elem = e;
            return true;
        }
    }) ? elem : null;
});

请记住，这在IE8-上本就不起作用，因为它不支持某些功能。可以提供polyfill，或者总是有经典的for循环：

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

它实际上更快、更紧凑。但如果你不想重新发明轮子，我建议使用下划线或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");

我将其设置为$.grep，如果找到一个对象，函数将返回该对象，而不是数组。

基于公认的答案：

jQuery：

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

或CoffeeScript：

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

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

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

所以现在只需用“id”代替key，用“45”代替value，就会得到与id 45匹配的完整对象。那就是，

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

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

var索引器＝｛｝；对于（var i=0；i<array.length；i++）{索引器[array[i].id]=parseInt（i）；}//然后可以使用以下命令访问数组中的对象财产数组[索引器[id]].properties

最短，

var theAnswerObj = _.findWhere(array, {id : 42});

以下是我将如何在纯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'

考虑“axesOptions”是对象数组，对象格式为｛：字段类型=>2，：字段=>[1，3，4]｝

function getFieldOptions(axesOptions,choice){
  var fields=[]
  axesOptions.each(function(item){
    if(item.field_type == choice)
        fields= hashToArray(item.fields)
  });
  return fields;
}

myArray.filter(function(a){ return a.id == some_id_you_want })[0]

使用本机Array.reduce

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

如果找到，则返回object元素，否则为false

使用find（）方法：

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

来自MDN：

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

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

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

来自MDN：

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

如果要获取匹配元素的数组，请改用filter（）方法：

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

这将返回一个对象数组。如果要获取foo财产数组，可以使用map（）方法：

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

附带说明：旧浏览器（如IE）不支持find（）或filter（）和arrow函数等方法，因此如果您想支持这些浏览器，应该使用Babel（带有polyfill）来转换代码。

虽然这里有很多正确的答案，但很多答案都没有解决这样一个事实：如果不止一次，这是一个不必要的昂贵操作。在极端情况下，这可能是导致实际性能问题的原因。

在现实世界中，如果您正在处理大量项目，并且性能是一个问题，那么最初构建查找要快得多：

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

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

然后，您可以在固定时间内获得以下项目：

var bar = o[id];

您也可以考虑使用Map而不是对象作为查找：https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Map

查找数组索引的方法：

index = myArray.map((i) => i.id).indexOf(value_of_id);
item = myArray[index];

使用Array.prototype.filter（）函数。

演示：https://jsfiddle.net/sumitridhal/r0cz0w5o/4/

JSON

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

如果多次执行此操作，则可以设置映射（ES6）：

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

然后，您可以简单地执行O（1）查找：

map.get(27).foo

我们可以使用Jquery方法$.each（）/$.grep（）

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

or

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

使用ES6语法：

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

或使用Lodashhttps://lodash.com/docs/4.17.10#filter强调https://underscorejs.org/#filter

更通用和简短

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

在您的示例中，Ex.varelement=findFromArray（myArray，'id'，45），它将为您提供整个元素。

最近，我不得不面对同样的事情，我需要从一个巨大的数组中搜索字符串。

经过一番搜索，我发现用简单的代码就能轻松处理：

代码：

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

看见https://jsfiddle.net/maheshwaghmare/cfx3p40v/4/

正如其他人所指出的，.find（）是在数组中查找一个对象的方法。但是，如果无法使用此方法找到对象，则程序将崩溃：const myArray=[｛'id'：'73'，'o'：'bar'｝，｛'id'：'45'，'o'：'bar'｝]；const res=myArray.find（x=>x.id=='100'）.foo；//噢！/*错误：“Uncaught TypeError:无法读取未定义的属性'foo'”或在较新的chrome版本中：Uncaught TypeError:无法读取未定义的的财产（读取“foo”）*/

这可以通过在使用.foo之前检查.find（）的结果是否已定义来解决。Modern JS允许我们通过可选链接轻松完成这一点，如果找不到对象，则返回undefined，而不是崩溃代码：

const myArray=[｛'id'：'73'，'o'：'bar'｝，｛'id'：'45'，'o'：'bar'｝]；const res=myArray.find（x=>x.id=='100'）？。foo；//没有错误！console.log（res）；//找不到对象时未定义

动态缓存查找

在这个解决方案中，当我们搜索某个对象时，我们将其保存在缓存中。这是“始终搜索解决方案”和“为预先计算的每个对象创建哈希图”之间的中间点。

让cachedFind=（（）=>{let cache=new Map（）；return（arr，id，el=null）=>cache.get（id）||（el=arr.find（o=>o.id==id），cache.set（id，el），el）；})();// ---------//测试// ---------let myArray=[…Array（100000）].map（（x，i）=>（｛‘id‘：‘$｛i｝‘，‘foo‘：‘bar_$｛i｝‘｝））；//示例用法console.log（cachedFind（myArray，'1234'）.foo）；//基准让板凳=（id）=>{console.time（'time for'+id）；console.log（cachedFind（myArray，id）.foo）；//查找console.timeEnd（'time for'+id）；}console.log（'-----无缓存-----'）；工作台（50000）；工作台（79980）；工作台（99990）；console.log（'-----缓存-----'）；工作台（79980）；//高速缓存的工作台（99990）；//高速缓存的

表演

今天2020.06.20我在Chrome 81.0、Firefox 77.0和Safari 13.1上对MacOs High Sierra进行了测试，以获得所选的解决方案。

使用预先计算的解决方案的结论

具有预计算（K，L）的解决方案比其他解决方案（快得多），不会与它们进行比较-可能它们使用了一些特殊的内置浏览器优化

令人惊讶的是，基于Map（K）的Chrome和Safari解决方案比基于对象｛｝（L）的解决方案快得多令人惊讶的是，Safari上基于对象｛｝的小型阵列解决方案（L）比传统的（E）慢令人惊讶的是，Firefox上基于Map（K）的小阵列解决方案比传统的（E）慢

搜索对象始终存在时的结论

使用传统for（E）的解决方案对于小阵列最快，对于大阵列最快对于大型阵列，使用缓存（J）的解决方案是最快的，而对于小型阵列，则是中等速度基于find（A）和findIndex（B）的解决方案对于小阵列很快，对于大阵列则很快基于$.map（H）的解决方案在小型阵列上是最慢的基于reduce（D）的解决方案在大型阵列上最慢

搜索对象从不存在时的结论

基于传统for（E）的解决方案在小型和大型阵列上都是最快的（除了Chrome小型阵列，后者速度第二快）基于reduce（D）的解决方案在大型阵列上最慢使用缓存（J）的解决方案是中等速度的，但如果我们将具有空值的键也保存在缓存中，则可以加快速度（这里没有这样做，因为我们希望避免在搜索许多不存在的键时在缓存中无限制地消耗内存）

细节

对于解决方案

无需预先计算：ABCDEFGH我J（J解决方案使用“内部”缓存，其速度取决于搜索元素重复的频率）带有预先计算KL

我进行了四次测试。在测试中，我希望在10次循环迭代中找到5个对象（对象ID在迭代过程中不会改变）-所以我调用测试方法50次，但只有前5次具有唯一的ID值：

小数组（10个元素）和搜索对象始终存在-您可以在此处执行大数组（10k个元素）和搜索对象始终存在-您可以在此处执行小数组（10个元素）和搜索对象从不存在-您可以在此处执行大数组（10k个元素）和搜索对象从不存在-您可以在这里执行

测试代码如下

函数A（arr，id）{返回arr.find（o=>o.id==id）；}函数B（arr，id）{设idx=arr.findIndex（o=>o.id==id）；返回arr[idx]；}函数C（arr，id）{返回arr.filter（o=>o.id==id）[0]；}函数D（arr，id）{return arr.reduce（（a，b）=>（a.id==id&&a）||（b.id==id&&b））；}函数E（arr，id）{对于（var i=0；i<arr.length；i++）如果（arr[i].id==id）返回arr[i]；返回null；}函数F（arr，id）{var retObj={}；$.each（arr，（索引，obj）=>{如果（obj.id==id）｛retObj=对象；return false；}});返回retObj；}函数G（arr，id）{return$.grep（arr，e=>e.id==id）[0]；}函数H（arr，id）{return$.map（myArray，函数（val）{返回val.id==id？val：空；})[0];}函数I（arr，id）{return _.find（arr，o=>o.id==id）；}设J=（（）=>{let cache=new Map（）；返回函数J（arr，id，el=null）｛返回cache.get（id）||（el=arr.find（o=>o.id==id），cache.set（id，el），el）；}})();函数K（arr，id）{return mapK.get（id）}函数L（arr，id）{返回mapL[id]；}// -------------//测试// -------------console.log（'查找id=5'）；myArray=[…Array（10）].map（（x，i）=>（{'id'：`${i}`，'foo'：`bar_${i}`））；const mapK=新地图（myArray.Map（el=>[el.id，el]））；常量mapL={}；myArray.forEach（el=>mapL[el.id]=el）；[A，B，C，D，E，F，G，H，I，J，K，L].forEach（F=>console.log（`${F.name}:${JSON.stringify（F（myArray，'5'））}`））；console.log（'hole array'，JSON.stringify（myArray））；<script src=“https://cdnjs.cloudflare.com/ajax/libs/jquery/3.5.1/jquery.min.js“></script><script src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js“></script>此代码段仅显示经过测试的代码

搜索对象始终存在的小数组的Chrome测试结果示例

下面的代码将帮助您从数据中的嵌套对象中搜索值。

const updatedData = myArrayOfObjects.filter((obj: any) => Object.values(obj).some((val: any) => {
   if (typeof (val) == typeof ("str")) {
      return val.toString().includes(Search)
   } else {
      return Object.values(val).some((newval: any) => {
         if (newval !== null) {
            return newval.toString().includes(Search)
         }
      })
   }
}))