按属性值从对象数组中获取JavaScript对象

假设我有一个由四个对象组成的数组：

var jsObjects = [
   {a: 1, b: 2}, 
   {a: 3, b: 4}, 
   {a: 5, b: 6}, 
   {a: 7, b: 8}
];

---

是否有一种方法可以通过属性

b

的值获取第三个对象（

{a:5，b:6}

），例如，不使用

for…in

循环？

过滤器

对象数组，哪个属性匹配值，返回数组：

var result = jsObjects.filter(obj => {
  return obj.b === 6
})

见

const jsObjects=[
{a:1，b:2}，
{a:3，b:4}，
{a:5，b:6}，
{a:7，b:8}
]
让result=jsObjects.filter（obj=>{
返回对象b==6
})
console.log（result）

如果我理解正确，您希望在数组中找到

b

属性为

6

的对象吗

var found;
jsObjects.some(function (obj) {
  if (obj.b === 6) {
    found = obj;
    return true;
  }
});

或者，如果您使用下划线：

var found = _.select(jsObjects, function (obj) {
  return obj.b === 6;
});

---

我不知道你为什么反对for循环（大概你指的是

for循环

，而不是特别指

for..in

），它们既快又容易阅读。无论如何，这里有一些选择

For循环：

var filterObj = jsObjects.filter(function(e) {
  return e.b == 6;
});

for (var i in jsObjects) {
  if (jsObjects[i].b == 6) {
    console.log(jsObjects[i]); // {a: 5, b: 6}
  }
}

.forEach

另一方面，如果您确实是指..in，并且希望找到具有任何属性且值为6的对象，则必须使用..in，除非您将名称传递给检查

示例

function getByValue4(arr, value) {
  var o;

  for (var i=0, iLen=arr.length; i<iLen; i++) {
    o = arr[i];

    for (var p in o) {
      if (o.hasOwnProperty(p) && o[p] == value) {
        return o;
      }
    }
  }
}

函数getByValue4（arr，值）{ var o；

---

对于（var i=0，iLen=arr.length；i来说，在ECMAScript 6方案中似乎有

Array

方法

find（）

和

findIndex（）

。MDN还提供了polyfills，您可以将其包括在内，以便在所有浏览器中获得这些方法的功能

:

函数isPrime（元素、索引、数组）{
var启动=2；
while（启动1）；
}
console.log（[4,6,8,12].find（isPrime））；//未定义，未找到
console.log（[4,5,8,12].find（isPrime））；//5

:

函数isPrime（元素、索引、数组）{
var启动=2；
while（启动1）；
}
console.log（[4,6,8,12].findIndex（isPrime））；/-1，未找到
console.log（[4,6,7,12].findIndex（isPrime））；//2

要访问第三个对象，请使用：

jsObjects[2]；

要访问第三个对象b值，请使用：

jsObjects[2].b；

使用下划线.js：

var foundObject = _.findWhere(jsObjects, {b: 6});

---

如果您想要的是单个结果，而不是数组，我可以建议减少吗

下面是一个纯“ole javascript”解决方案，如果存在匹配对象，则返回匹配对象；如果不存在，则返回null

var result = arr.reduce(function(prev, curr) { return (curr.b === 6) ? curr : prev; }, null);

来自MDN：

如果数组中的元素满足提供的测试函数，则该方法返回数组中的值。否则返回

未定义的


旁注：较旧的浏览器（如IE）不支持
find（）
和arrow函数等方法，因此，如果要支持这些浏览器，应使用来传输代码。
要通过特定属性值从对象数组中获取第一个对象：


函数getObjectFromObjectsArrayByPropertyValue（objectsArray，propertyName，propertyValue）{
返回objectsArray.find（函数（objectsArray元素）{
返回objectsArrayElement[propertyName]==propertyValue；
});
}
函数findObject（）{
var arrayOfObjectsString=document.getElementById（“arrayOfObjects”）.value，
阵列对象，
propertyName=document.getElementById（“propertyName”）.value，
propertyValue=document.getElementById（“propertyValue”）.value，
预览=document.getElementById（“预览”），
搜索对象；
arrayOfObjects=JSON.parse（arrayOfObjectsString）；
控制台调试（arrayOfObjects）；
if（arrayOfObjects&&propertyName&&propertyValue）{
searchingObject=getObjectFromObjectsArrayByPropertyValue（ArrayOfoObjects，propertyName，propertyValue）；
如果（搜索对象）{
preview.innerHTML=JSON.stringify（searchingObject，false，2）；
}否则{
preview.innerHTML=“在对象数组中没有属性为“+propertyName+”=“+propertyValue+”的对象”；
}
}
}
pre{
填充物：5px；
边界半径：4px；
背景#f3f2f2；
}
文本区，按钮{
宽度：100%
}

输入数据：
将您的对象数组放在这里
[
{“a”：1，“b”：2}，
{“a”：3，“b”：4}，
{“a”：5，“b”：6}，
{“a”：7，“b”：8，“c”：157}
]

物业名称：
属性值：

在数组中查找对象！

搜索结果：
单击查找
尝试使用
属性过滤
对象数组的方法

var jsObjects = [
   {a: 1, b: 2}, 
   {a: 3, b: 4}, 
   {a: 5, b: 6}, 
   {a: 7, b: 8}
];

使用数组筛选方法：

var filterObj = jsObjects.filter(function(e) {
  return e.b == 6;
});

for (var i in jsObjects) {
  if (jsObjects[i].b == 6) {
    console.log(jsObjects[i]); // {a: 5, b: 6}
  }
}

用于循环中：

var filterObj = jsObjects.filter(function(e) {
  return e.b == 6;
});

for (var i in jsObjects) {
  if (jsObjects[i].b == 6) {
    console.log(jsObjects[i]); // {a: 5, b: 6}
  }
}

工作fiddle:
使用的
.find（collection，[predicate=.identity]，[fromIndex=0]）
从对象数组中按对象属性值获取对象。您可以执行以下操作：

var o = _.find(jsObjects, {'b': 6});

论据：

collection (Array|Object): The collection to inspect.
[predicate=_.identity] (Function): The function invoked per iteration.
[fromIndex=0] (number): The index to search from.

返回

(*): Returns the matched element (in your case, {a: 5, b: 6}), else undefined.

在性能方面，＞.FIN（）/代码>更快，因为它只使用属性“代码< { B”：6 }拉第一个对象，另一方面，如果假设您的数组包含多个具有匹配属性集（Key：value）的对象，则应该考虑使用<代码>
方法。因此，在您的情况下，由于数组中只有一个具有此属性的对象，我将使用
.find（）
使用find with bind将特定的键值传递给回调函数

   function byValue(o) { 
       return o.a === this.a && o.b === this.b; 
   };   

   var result = jsObjects.find(byValue.bind({ a: 5, b: 6 }));

请参阅此文档

示例：

var filterObj = jsObjects.filter(function(e) {
  return e.b == 6;
});

for (var i in jsObjects) {
  if (jsObjects[i].b == 6) {
    console.log(jsObjects[i]); // {a: 5, b: 6}
  }
}

您可以将其与箭头功能一起使用，如下所示：

var demoArray = [
   {name: 'apples', quantity: 2},
   {name: 'bananas', quantity: 0},
   {name: 'cherries', quantity: 5}
];

var result = demoArray.filter( obj => obj.name === 'apples')[0];
console.log(result);
// {name: 'apples', quantity: 2}

将更好，使用返回过滤器有时您无法获得结果（我不知道为什么）
使最佳/最快的部分更加可重用和清晰：

function getElByPropVal(myArray, prop, val){
    for (var i = 0, length = myArray.length; i < length; i++) {
        if (myArray[i][prop] == val){
            return myArray[i];
        }
    }
}

函数getElByPropVal（myArray，prop，val）{
for（var i=0，length=myArray.length；i
好的，实现这一点的方法很少，但是让我们从最简单也是最新的方法开始，这个函数叫做
find（）

你和我们在一起的时候要小心
function getElByPropVal(myArray, prop, val){
    for (var i = 0, length = myArray.length; i < length; i++) {
        if (myArray[i][prop] == val){
            return myArray[i];
        }
    }
}

var jsObjects = [
   {a: 1, b: 2}, 
   {a: 3, b: 4}, 
   {a: 5, b: 6}, 
   {a: 7, b: 8}
];

function filterValue(obj, key, value) {
  return obj.find(function(v){ return v[key] === value});
}

filterValue(jsObjects, "b", 6); //{a: 5, b: 6}

const filterValue = (obj, key, value)=> obj.find(v => v[key] === value);

const filterValue = (obj, key, value)=> obj.filter(v => v[key] === value);

function filteredArray(arr, key, value) {
  const newArray = [];
  for(i=0, l=arr.length; i<l; i++) {
    if(arr[i][key] === value) {
      newArray.push(arr[i]);
    }
  }
 return newArray;
}

filteredArray(jsObjects, "b", 6); //[{a: 5, b: 6}]