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

我所知道的唯一方法是遍历所有数组:

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。

可以使用自定义函数作为参数来使用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。由您在排序函数中定义正确的逻辑对数组进行排序。

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

只需要遍历数组并找到位置:

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

正如其他答案所表明的那样，遍历数组可能是最好的方法。但我会把它放在自己的函数里，让它更抽象一点:

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 ()相同的构造。

这可能很有用:

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

我从与对象一起工作复制了这个。

一个典型的方法

(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.

因为排序部分已经回答了。我将提出另一种优雅的方法来获取数组中属性的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');

除了德国人阿塔纳西奥·鲁伊斯的回答之外，你还可以使用Array.reduce ()代替Array.map ()来消除第二个循环;

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

使用一个小的变通方法:

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

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

生活的例子。

我扩展了克里斯·皮克特的回答，因为在我的例子中，我需要搜索比一个属性级别更深的地方:

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 '加入到函数中。

如果你可以使用ES6，数组现在有findIndex函数。这意味着你可以这样做:

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

用这个:

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

var index = Data.findIndex(item => item.name == "John")

这是一个简化版:

var index = Data.findIndex(function(item){ return item.name == "John"})

从mozilla.org:

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

如果你在使用Internet Explorer时遇到问题，你可以使用map()函数，该函数从9.0开始支持:

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

如果你想获取属性令牌的值，那么你也可以尝试这样做:

    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函数。

使用Underscore.js:

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

你可以在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

可以使用过滤法

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

也许是物体。钥匙,对象。条目和对象。Values方法可能会有所帮助。