Javascript 搜索对象的更好方法

通常，我会发现自己必须从一个对象或对象数组中访问一个特定的对象，该对象或对象数组由任意索引索引，但我需要的对象是一个密钥与特定值匹配的对象

例如：

var cars = [
    { id:23, make:'honda', color: 'green' },
    { id:36, make:'acura', color:'silver' },
    { id:18, make:'ford', color:'blue' },
    { id:62, make:'ford', color:'green' }, 
];

假设我需要其中一个条目，并且我知道这个条目是唯一的；例如，id=18的那个

现在，我用以下方式做这件事：

function select(key,val,arr){

    for(var i in arr){
        if(arr[i][key]==val) return(arr[i]);
    }
    return(null); // object not present in arr
}


var id = 18;
var car = select('id', id, cars);

// car = { id:18, make:'ford', color:'blue' }

但这看起来很麻烦，而且由于性能的不同，扩展性也很差。如果一个大型数据集的值接近数组的开头，那么它可能会很快返回，或者在最坏的情况下，将需要与条目相同的迭代次数。 如果该值根本不存在，那么这看起来也是非常浪费的，因为您只是对所有对象进行了迭代，以得到一个空结果

---

当搜索条件与主题的键不是同一参数时，有没有更优雅的方法来搜索数组或对象的值？

创建一个对象，该对象的键是您希望能够搜索的属性：

var cars_by_id = {};
cars.forEach(c => cars_by_id[c.id] = c);

现在您可以使用

cars\u by\u id[id]

来获得您想要的汽车

---

无论何时按下

cars

，您都需要通过id添加到

cars\u。您可能需要定义一个自动执行此操作的类。
创建一个对象，该对象的键是您希望能够通过其进行搜索的属性：

var cars_by_id = {};
cars.forEach(c => cars_by_id[c.id] = c);

现在您可以使用
cars\u by\u id[id]
来获得您想要的汽车

无论何时按下
cars
，您都需要通过id添加到
cars\u。您可能需要定义一个自动执行此操作的类。
构造一个对象，其中每个键都是汽车对象的id，值是汽车对象本身：

var cars = {
    23: { id:23, make:'honda', color: 'green' },
    36: { id:36, make:'acura', color:'silver' },
    18: { id:18, make:'ford', color:'blue' },
    62: { id:62, make:'ford', color:'green' }, 
};

这样可以更快地访问：

console.log(cars[18].make);

构造一个对象，其中每个关键点是汽车对象的id，值是汽车对象本身：

var cars = {
    23: { id:23, make:'honda', color: 'green' },
    36: { id:36, make:'acura', color:'silver' },
    18: { id:18, make:'ford', color:'blue' },
    62: { id:62, make:'ford', color:'green' }, 
};

这样可以更快地访问：

console.log(cars[18].make);

您可以使用
Array.prototype.map（）
创建阴影数组，这将帮助您更快地搜索，或者您还可以创建一个
索引
对象，如下图所示，它将直接返回您需要的索引

var cars = [
    { id:23, make:'honda', color: 'green' },
    { id:36, make:'acura', color:'silver' },
    { id:18, make:'ford', color:'blue' },
    { id:62, make:'ford', color:'green' }, 
];
let cars_s = cars.map(function(x) {
    return x.id;
});
let i = cars_s.indexOf(18);
console.log(i); // 2
console.log(cars[i]); // { id:18, make:'ford', color:'blue' }

let index = {};
for (let i = 0; i < cars_s.length; i++) {
    index[cars_s[i]] = i;
}
console.log(index[18]); // 2

var-cars=[
{id:23，品牌：'honda'，颜色：'green'}，
{id:36，品牌：'acura'，颜色：'silver'}，
{id:18，品牌：'ford'，颜色：'blue'}，
{id:62，品牌：'ford'，颜色：'green'}，
];
let cars\u s=cars.map（函数（x）{
返回x.id；
});
设i=cars\u.indexOf（18）；
console.log（i）；//2.
控制台日志（cars[i]）；//{id:18，品牌：'ford'，颜色：'blue'}
设索引={}；
对于（设i=0；i
您可以使用
数组.prototype.map（）
创建阴影数组，这将帮助您更快地搜索，或者您还可以创建一个
索引
对象，如下所示，它将直接返回您需要的索引

var cars = [
    { id:23, make:'honda', color: 'green' },
    { id:36, make:'acura', color:'silver' },
    { id:18, make:'ford', color:'blue' },
    { id:62, make:'ford', color:'green' }, 
];
let cars_s = cars.map(function(x) {
    return x.id;
});
let i = cars_s.indexOf(18);
console.log(i); // 2
console.log(cars[i]); // { id:18, make:'ford', color:'blue' }

let index = {};
for (let i = 0; i < cars_s.length; i++) {
    index[cars_s[i]] = i;
}
console.log(index[18]); // 2

var-cars=[
{id:23，品牌：'honda'，颜色：'green'}，
{id:36，品牌：'acura'，颜色：'silver'}，
{id:18，品牌：'ford'，颜色：'blue'}，
{id:62，品牌：'ford'，颜色：'green'}，
];
let cars\u s=cars.map（函数（x）{
返回x.id；
});
设i=cars\u.indexOf（18）；
console.log（i）；//2.
控制台日志（cars[i]）；//{id:18，品牌：'ford'，颜色：'blue'}
设索引={}；
对于（设i=0；i
不要将
用于。。。在
数组上的
中，不要将
用于。。。在
阵列上的
中，你以2秒的优势击败了我。：）但这不就是将处理任务转移到另一种形式吗？显然，使用
cars.forEach（c=>cars\u by_id[c.id]=c）在整个对象上迭代一次”比在搜索时反复搜索要好得多，但如果主题数组计数为百万，这仍然会成为一个巨大的性能负载，这取决于您需要搜索内容的频率。如果你把它隐藏在一个类中，你永远不需要做这个循环，你只需要在创建对象和数组的时候保持它们的同步。你比我快了2秒。：）但这不就是将处理任务转移到另一种形式吗？显然，使用
cars.forEach（c=>cars\u by_id[c.id]=c）在整个对象上迭代一次”比在搜索时反复搜索要好得多，但如果主题数组计数为百万，这仍然会成为一个巨大的性能负载，这取决于您需要搜索内容的频率。如果将其隐藏在类中，则无需进行循环，只需在创建对象和数组时保持对象和数组的同步。这很理想，但有时不可行，因为数据可能来自我无法控制的源。即使在一个简单的情况下，MySQL db调用也不会以这种格式返回数据，当接收到数据时，重新格式化会将计算难题传递到任务链上。这是理想的，但有时不可行，因为数据可能来自我无法控制的源。即使在一个简单的情况下，MySQL db调用也不会以这种格式返回数据，并且在接收到数据时重新格式化只会将计算难题传递给任务链