如何在JavaScript中通过对象的属性获取对象的索引

由于排序部分已经得到回答。我只是想提出另一种优雅的方法来获得数组中属性的indexOf

你的例子是：

var Data = [
    {id_list:1, name:'Nick', token:'312312'},
    {id_list:2, name:'John', token:'123123'}
]

你可以做：

var index = Data.map(function(e) { return e.name; }).indexOf('Nick');

var Data = [{
    id_list: 1,
    name: 'Nick',
    token: '312312'
  },
  {
    id_list: 2,
    name: 'John',
    token: '123123'
  }
]
var index = Data.map(function(e) {
  return e.name;
}).indexOf('Nick');
console.log(index)

Array.prototype.map在Internet Explorer 7或Internet Explorer 8上不可用。ES5兼容性

这里有ES6和箭头语法，这更简单：

const index = Data.map(e => e.name).indexOf('Nick');

如果您能很好地使用ES6，那么数组现在就有了findIndex函数。这意味着你可以做这样的事情：

const index = Data.findIndex(item => item.name === 'John');

正如其他答案所表明的那样，在数组中循环可能是最好的方法。但我会把它放在自己的函数中，并让它变得更抽象：

function findWithAttr(array, attr, value) {
    for(var i = 0; i < array.length; i += 1) {
        if(array[i][attr] === value) {
            return i;
        }
    }
    return -1;
}
var Data = [
    {id_list: 2, name: 'John', token: '123123'},
    {id_list: 1, name: 'Nick', token: '312312'}
];

有了这个，你不仅可以找到哪个包含"John"，还可以找到哪个含有令牌"312312"：

findWithAttr(Data, 'name', 'John'); // returns 0
findWithAttr(Data, 'token', '312312'); // returns 1
findWithAttr(Data, 'id_list', '10'); // returns -1

找不到该函数时返回-1，因此它遵循与Array.prototype.indexOf((相同的构造。

如果您在使用Internet Explorer时遇到问题，可以使用9.0以后支持的map((函数：

var index = Data.map(item => item.name).indexOf("Nick");

我知道的唯一方法是循环遍历所有数组：

var index = -1;
for(var i=0; i<Data.length; i++)
  if(Data[i].name === "John") {
    index = i;
    break;
  }

或不区分大小写：

var index = -1;
for(var i=0; i<Data.length; i++)
  if(Data[i].name.toLowerCase() === "john") {
    index = i;
    break;
  }

在结果变量上，索引包含对象的索引，如果未找到，则为-1。

典型的方式

(function(){
  if (!Array.prototype.indexOfPropertyValue){
       Array.prototype.indexOfPropertyValue = function(prop, value){
      for (var index = 0; index < this.length; index++){
        if (this[index][prop]){
          if (this[index][prop] == value){
            return index;
          }
        }
       }
      return -1;
    }
  }
 })();
 // Usage:
 var Data = [
   {id_list:1, name:'Nick', token:'312312'}, {id_list:2, name:'John', token:'123123'}];
 Data.indexOfPropertyValue('name', 'John'); // Returns 1 (index of array);
 Data.indexOfPropertyValue('name', 'Invalid name') // Returns -1 (no result);
 var indexOfArray = Data.indexOfPropertyValue('name', 'John');
 Data[indexOfArray] // Returns the desired object.

您可以使用过滤方法

 const filteredData = data.filter(e => e.name !== 'john');

只需浏览您的数组并找到位置：

var i = 0;
for(var item in Data) {
    if(Data[item].name == 'John')
        break;
    i++;
}
alert(i);

let indexOf = -1;
let theProperty = "value"
let searchFor = "something";
theArray.every(function (element, index) {
    if (element[theProperty] === searchFor) {
        indexOf = index;
        return false;
    }
    return true;
});

collection.findIndex(item => item.value === 'smth') !== -1

您可以使用Array.sort，使用自定义函数作为参数来定义排序机制。

在你的例子中，它会给出：

var Data = [
    {id_list:1, name:'Nick',token:'312312'},{id_list:2,name:'John',token:'123123'}
]
Data.sort(function(a, b){
    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
});
alert("First name is : " + Data[0].name); // alerts 'John'
alert("Second name is : " + Data[1].name); // alerts 'Nick'

如果a应该在b之前，则排序函数必须返回-1，如果a在b之后，则返回1，如果两者相等，则返回0。这取决于您在排序函数中定义正确的逻辑来对数组进行排序。

错过了问题的最后一部分，你想知道索引。正如其他人所说，你必须循环遍历数组才能找到它。

这可能很有用：

function showProps(obj, objName) {
  var result = "";
  for (var i in obj)
    result += objName + "." + i + " = " + obj[i] + "'n";
  return result;
}

我从使用对象复制了这个。

使用一个小的变通方法：

创建一个以名称作为索引的新数组。之后，所有搜索都将使用索引。所以，只有一个循环。之后，您就不需要遍历所有元素了！

var Data = [
    {id_list:1, name:'Nick',token:'312312'},{id_list:2,name:'John',token:'123123'}
    ]
var searchArr = []
Data.forEach(function(one){
  searchArr[one.name]=one;
})
console.log(searchArr['Nick'])

http://jsbin.com/xibala/1/edit

活生生的例子。

我扩展了Chris Pickett的答案，因为在我的情况下，我需要搜索不止一个属性级别：

function findWithAttr(array, attr, value) {
  if (attr.indexOf('.') >= 0) {
    var split = attr.split('.');
    var attr1 = split[0];
    var attr2 = split[1];
    for(var i = 0; i < array.length; i += 1) {
      if(array[i][attr1][attr2] === value) {
        return i;
      }
    }
  } else {
    for(var i = 0; i < array.length; i += 1) {
      if(array[i][attr] === value) {
        return i;
      }
    }
  };
};

您可以将"attr1.attr2"传递到函数中。

使用此：

Data.indexOf(_.find(Data, function(element) {
  return element.name === 'John';
}));

假设您使用的是Lodash或Underscore.js.

var fields = {
  teste:
  {
    Acess:
    {
      Edit: true,
      View: false
    }
  },
  teste1:
  {
    Acess:
    {
      Edit: false,
      View: false
    }
  }
};
console.log(find(fields,'teste'));
function find(fields,field) {
  for(key in fields) {
    if(key == field) {
      return true;
    }
  }
  return false;
}

如果你有一个对象，里面有多个对象，如果你想知道某个对象是否包括在主对象上，只需使用find(MasterObject, 'Object to Search')。如果存在或不存在(TRUE或FALSE(，此函数将返回响应。我希望对此有所帮助——可以在JSFiddle上看到这个例子。

如果您想获得属性令牌的值，那么您也可以尝试以下操作：

    let data=[
      { id_list: 1, name: 'Nick', token: '312312' },
      { id_list: 2, name: 'John', token: '123123' },
    ]
    let resultingToken =  data[_.findKey(data,['name','John'])].token

其中_.findKey是一个Lodash函数。

您可以在Lodash库中使用findIndex。

示例：

var users = [
{ 'user': 'barney',  'active': false },
{ 'user': 'fred',    'active': false },
{ 'user': 'pebbles', 'active': true }
            ];
_.findIndex(users, function(o) { return o.user == 'barney'; });
// => 0
// The `_.matches` iteratee shorthand.
_.findIndex(users, { 'user': 'fred', 'active': false });
// => 1
// The `_.matchesProperty` iteratee shorthand.
_.findIndex(users, ['active', false]);
// => 0
// The `_.property` iteratee shorthand.
_.findIndex(users, 'active');
// => 2

除了德语Attanasio Ruiz的答案之外，您还可以使用Array.reduce((而不是Array.map((来消除第二个循环；

var Data = [
    { name: 'hypno7oad' }
]
var indexOfTarget = Data.reduce(function (indexOfTarget, element, currentIndex) {
    return (element.name === 'hypno7oad') ? currentIndex : indexOfTarget;
}, -1);

也许Object.keys、Object.entries和Object.values方法可能会有所帮助。

使用Undercore.js:

var index = _.indexOf(_.pluck(item , 'name'), 'Nick');