Question

我必须编写一个函数，该函数在对象数组中搜索查询并返回与查询匹配的第一个对象。例如，数组将如下所示：

 const HEROES = [
{ id: 1, name: 'Captain America', squad: 'Avengers' },
{ id: 2, name: 'Iron Man', squad: 'Avengers' },
{ id: 3, name: 'Spiderman', squad: 'Avengers' },
 ];

对该函数的调用将类似于

 findOne(HEROES, {id :1 }) => id:1, name: 'Captain America', squad: 'Avengers' }

我已经尝试过进行for循环，检查每种情况下query.id是否等于arr [i] .id等，但是我无法使其工作，因此如果输入为两个查询，例如id：4和小队：'Justice League'，我不会得到正确的结果。有些是对的，但有些是错的。 Idk有点难以解释。

function findOne(arr, query){
  let i = 0;
   while (i<arr.length){
   if (Object.values(query) in Object.values(arr[i])){  
    return arr[i];
  }
  i++;
}
}

现在，我试图使代码更简单，但是遇到了一些困难。似乎第一个测试用例有效，但其他所有用例都没有。例如， findOne（HEROES，{id：2，name：'Aquaman' 应该返回null，

Answer 1

const HEROES = [
    { id: 1, name: 'Captain America', squad: 'Avengers' },
    { id: 2, name: 'Iron Man', squad: 'Avengers' },
    { id: 3, name: 'Spiderman', squad: 'Avengers' },
];


function findOne(arr, query) {

    let i = 0;
    let result = "Not Found";
    while (i < arr.length) {
         flag =0;
            for(key in query) {
                     if(query[key]!=arr[i][key]){
                         flag = 1;
                        
                     }    
            }
            if(flag == 0) {
                result = arr[i];  
                break; 
            }
        i++;
    }

    return result;

}

let result = findOne(HEROES, {id:2,name:'Iron Man'});
console.log(result);

此逻辑将起作用

Answer 2

所以，这里的问题是查询在字段中发生了变化，例如，您不知道在查询对象中获得了哪些字段（如果我对的话）。

使用Object.values(query)并不是最好的主意，因为类似这样的查询也可以通过测试并返回第一英雄：{ id: 'Avengers', name: 1 }。

改为使用Object.keys：

function findOne(arr, query){
  let keys = Object.keys(query);
  while(i<arr.length){
     let equalKeyCounter = 0;
     for( key in keys ){
        if(query[key] === arr[i][key])
          equalKeyCounter++;
     }
     if( equalKeyCounter == keys.length )
        return arr[i];
  }
   return "not found"; // or null , undefined, any other default value
}

Answer 3

var prs = [
{ id: 1, name: 'Captain America', squad: 'Avengers' },
{ id: 2, name: 'Iron Man', squad: 'Avengers' },
{ id: 3, name: 'Spiderman', squad: 'Avengers' },
];
var finalValue ;
var promiseGot = callFunction(prs);
var final = promiseGot.then(function(val){
    this.finalValue = val;
    console.log("Your Answer" , this.finalValue);
});


function callFunction(prs) {
    return new Promise( function(resolve,reject){
            // loop through all promises
            prs.forEach( function(pr){
                // normalize the value
                if(pr.id == 1 && pr.name == 'Captain America' && pr.squad == 'Avengers'){
                    resolve( pr );
                }

                // whichever one fulfills first wins, and
                // gets to resolve the main promise

            } );
        } );
};

Answer 4

只需添加ES6答案即可。

ES6中的代码如下：

const result = HEROES.find(hero => 
  Object.entries(query).every(([key,value]) => key in hero && hero[key] === value))

这基本上返回HEROES数组中与给定query对象中的props相匹配的第一项。如果要创建函数，可以这样：

const find = (items, query) => items.find(item => 
  Object.entries(query).every(([key,value]) => key in item && item[key] === value))

通过简单的方法更改，您还可以使用一个函数来返回与查询匹配的所有项目，而不仅仅是第一个：

const findAll = (items, query) => items.filters(item => 
  Object.entries(query).every(([key,value]) => key in item && item[key] === value))

这总是返回一个新数组-如果没有任何项目与query的道具匹配，则为空。例如，使用您的数据：

   console.log(find(HEROES, {squad: 'Avengers'}));
   // { id: 1, name: 'Captain America', squad: 'Avengers' } 

   console.log(find(HEROES, {squad: 'Avengers'}));
   // [
   //   { id: 1, name: 'Captain America', squad: 'Avengers' },
   //   { id: 2, name: 'Iron Man', squad: 'Avengers' },
   //   { id: 3, name: 'Spiderman', squad: 'Avengers' },
   // ]

相同的查询，但是由于第二个函数返回所有匹配项，因此您有多个结果。

希望有帮助！在这里您可以找到有关所使用方法的更多信息：Object.entries，Array#every，Array#find。

函数findOne，它将数组和查询作为输入，并在包含查询的数组中找到一个对象

4 个答案: