如何基于多个条件从数组中删除对象？

Question

我有一个对象数组，我想根据这些规则对其进行筛选：

如果多个对象的团队和日是相同的，则删除级别最低的对象，但如果有多个具有相同最低级别的对象，则如果有多个能力最低的对象，则删除强度最低的对象。

考虑在每个条件之后创建一个新的数组，然后，也尝试着想出一种方法来处理所有的条件，而我对它非常迷茫，我不知道我在做什么。

我还尝试创建一个空数组，并将符合规则的对象推入其中，但最终不得不满足所有规则，而且仍然很复杂。

const players = [
  { Level: 1, team: 'green', strength: 2, ability: 2, day: 1 },
  { Level: 1, team: 'red', strength: 2, ability: 2, day: 2 },
  { Level: 1, team: 'red', strength: 2, ability: 2, day: 3 },
  { Level: 1, team: 'silver', strength: 2, ability: 2, day: 3 },
  { Level: 1, team: 'red', strength: 2, ability: 2, day: 4 },
  { Level: 1, team: 'silver', strength: 2, ability: 2, day: 4 },
  { Level: 1, team: 'red', strength: 2, ability: 2, day: 5 },
  { Level: 1, team: 'silver', strength: 2, ability: 2, day: 5 },
  { Level: 2, team: 'red', strength: 2, ability: 4, day: 4 },
  { Level: 2, team: 'red', strength: 2, ability: 4, day: 5 },
  { Level: 1, team: 'silver', strength: 2, ability: 2, day: 1 },
  { Level: 1, team: 'silver', strength: 2, ability: 2, day: 2 },
  { Level: 2, team: 'red', strength: 2, ability: 3, day: 1 },
  { Level: 2, team: 'silver', strength: 2, ability: 3, day: 1 },
  { Level: 2, team: 'red', strength: 2, ability: 3, day: 2 },
  { Level: 2, team: 'silver', strength: 2, ability: 3, day: 2 },
  { Level: 2, team: 'red', strength: 2, ability: 4, day: 1 },
  { Level: 3, team: 'red', strength: 3, ability: 4, day: 1 },
  { Level: 3, team: 'red', strength: 3, ability: 4, day: 2 },
  { Level: 3, team: 'red', strength: 3, ability: 4, day: 3 }
];

Answer 1

我所采取的办法是：

我遵循的一般方法是在两个候选人之间进行比较，而不是在多个候选人之间选择最好的候选人。这种方法对我来说似乎更容易推理。

这一进程确实：

1. 按键(team + day)对记录进行排序，因此相同的键记录是相邻的，很容易迭代。
2. 使用
3. 将当前元素与部分结果的最后一个元素进行比较，以查看哪个元素的优先级更高。当我们有更高的优先级时，我们更新结果的最后一个元素，否则我们会添加当前元素到结果中。如果对于相同的键，当前具有更高的优先级以满足您的要求，则
4. 更高的优先级是正确的。我喜欢在isCandidateHigherPriorytyThanResult函数中隔离和实现这个逻辑的方式。如果需要更改逻辑，就很容易适应。

​

const players=[{Level:1,team:"green",strength:2,ability:2,day:1},{Level:1,team:"red",strength:2,ability:2,day:2},{Level:1,team:"red",strength:2,ability:2,day:3},{Level:1,team:"silver",strength:2,ability:2,day:3},{Level:1,team:"red",strength:2,ability:2,day:4},{Level:1,team:"silver",strength:2,ability:2,day:4},{Level:1,team:"red",strength:2,ability:2,day:5},{Level:1,team:"silver",strength:2,ability:2,day:5},{Level:2,team:"red",strength:2,ability:4,day:4},{Level:2,team:"red",strength:2,ability:4,day:5},{Level:1,team:"silver",strength:2,ability:2,day:1},{Level:1,team:"silver",strength:2,ability:2,day:2},{Level:2,team:"red",strength:2,ability:3,day:1},{Level:2,team:"silver",strength:2,ability:3,day:1},{Level:2,team:"red",strength:2,ability:3,day:2},{Level:2,team:"silver",strength:2,ability:3,day:2},{Level:2,team:"red",strength:2,ability:4,day:1},{Level:3,team:"red",strength:3,ability:4,day:1},{Level:3,team:"red",strength:3,ability:4,day:2},{Level:3,team:"red",strength:3,ability:4,day:3}];

const key = (teamObj) =>{ 
  return teamObj.team + teamObj.day
}

const sortByKey =     
  (a,b)=>{
    if(key(a) > key(b)) return 1
    else
      if(key(a) < key(b)) return -1
      else return 0
  }

// return true if obj is {} otherwise is false
const isAnEmptyObject = (obj) => Object.keys(obj).length === 0 && obj.constructor === Object

const isCandidateHigherPriorytyThanResult = 
  (candidate, result) =>{
    if(key(result) !== key(candidate)) return false

    if(candidate.level > result.level) return true
    if(candidate.level < result.level) return false

    if(candidate.strength > result.strength) return true
    if(candidate.strength < result.strength) return false

    if(candidate.ability > result.ability) return true

    return false
  }

const reducer = (result, current) =>{
  const resultLast = result[result.length -1]

  // To accomodate for first iteration were result value is: {[]}
  if(isAnEmptyObject(resultLast))
  {
    result[result.length -1]= {...current}
    return result
  }

  if(isCandidateHigherPriorytyThanResult(current, resultLast))
  {
    result[result.length -1] = {...current}
    return result
  }else
  {
    return result.concat(current)
  }
  
}

const teamsResult = 
  players
    .sort(sortByKey) //?
    .reduce(reducer,[{}])

console.log(teamsResult)

​

Answer 2

由day

• Iterate和team对每个类别的

1. Group players：
   • 如果在该类别中只有一个玩家，则保留它为
   • Else，定义一组过滤策略来根据规则使用它--在此类别中level最低的玩家数量，如果只有一个玩家找到，则设置过滤条件以删除它H 214H 115否则，如果超过一个玩家发现的d16，则设置筛选条件以删除它。如果只有一个玩家在此结果集筛选条件中找到要删除它的them

• ，则设置过滤条件以删除strength中ability最低的玩家，则获取其中具有最低

• 的玩家的计数。

在每次迭代结束时，您将需要根据过滤条件过滤出参与者。最后，在一个列表中返回每个类别中的其余玩家。

​

const players = [
  { Level: 1, team: 'green', strength: 2, ability: 2, day: 1 },
  { Level: 1, team: 'red', strength: 2, ability: 2, day: 2 },
  { Level: 1, team: 'red', strength: 2, ability: 2, day: 3 },
  { Level: 1, team: 'silver', strength: 2, ability: 2, day: 3 },
  { Level: 1, team: 'red', strength: 2, ability: 2, day: 4 },
  { Level: 1, team: 'silver', strength: 2, ability: 2, day: 4 },
  { Level: 1, team: 'red', strength: 2, ability: 2, day: 5 },
  { Level: 1, team: 'silver', strength: 2, ability: 2, day: 5 },
  { Level: 2, team: 'red', strength: 2, ability: 4, day: 4 },
  { Level: 2, team: 'red', strength: 2, ability: 4, day: 5 },
  { Level: 1, team: 'silver', strength: 2, ability: 2, day: 1 },
  { Level: 1, team: 'silver', strength: 2, ability: 2, day: 2 },
  { Level: 2, team: 'red', strength: 2, ability: 3, day: 1 },
  { Level: 2, team: 'silver', strength: 2, ability: 3, day: 1 },
  { Level: 2, team: 'red', strength: 2, ability: 3, day: 2 },
  { Level: 2, team: 'silver', strength: 2, ability: 3, day: 2 },
  { Level: 2, team: 'red', strength: 2, ability: 4, day: 1 },
  { Level: 3, team: 'red', strength: 3, ability: 4, day: 1 },
  { Level: 3, team: 'red', strength: 3, ability: 4, day: 2 },
  { Level: 3, team: 'red', strength: 3, ability: 4, day: 3 }
];

const _groupPlayersByTeamAndDay = (players=[]) =>
  players.reduce((acc,item) => {
    const { team, day } = item;
    const key = `${team}${day}`;
    const prev = acc[key];
    if(!prev) acc[key] = [item];
    else acc[key].push(item);
    return acc;
  }, {});

const _getLowestValueOfAttr = (list=[], attr) =>
  list.reduce((acc,item) => 
    item[attr] < acc ? item[attr] : acc, Number.MAX_VALUE);

const _countItemsWithKeyValuePairs = (list=[], keys=[], values=[]) =>
  list.reduce((acc,item) => 
    keys.every((key,i) => item[key]===values[i]) ? acc+1 : acc, 0);
    
const _matchesFilterConditions = (filterConditions={}, player={}) =>
  Object.entries(filterConditions).every(([key,value]) => player[key]===value);

const _filterArrHelper = (teamDayPlayersMap={}) =>
  Object.values(teamDayPlayersMap).map(teamDayPlayersList => {
  
    let list = [...teamDayPlayersList];
    if(list.length <= 1) return list;
    let filterConditions = {};
    
    const lowestLevel = _getLowestValueOfAttr(list, 'Level');
    const playersWithLowestLevel = _countItemsWithKeyValuePairs(list, ['Level'], [lowestLevel]);
    
    if(playersWithLowestLevel <= 1) { 
      //remove the player with lowest Level
      filterConditions = { Level: lowestLevel };
    } else { 
      const lowestStrength = _getLowestValueOfAttr(list, 'strength');
      const playersWithLowestStrength = _countItemsWithKeyValuePairs(list, ['Level','strength'], [playersWithLowestLevel,lowestStrength]);
      
      if(playersWithLowestStrength <= 1){ 
        //remove the player with lowest strength
        filterConditions = { Level: lowestLevel, strength: lowestStrength };
      } else {
        //remove the players with the lowest ability
        const lowestAbility = _getLowestValueOfAttr(list, 'ability');
        filterConditions = { Level: lowestLevel, strength: lowestStrength, ability: lowestAbility };
      }
    }
    
    return list.filter(player => 
      !_matchesFilterConditions(filterConditions, player));
  }).flat();

const filterArr = (players=[]) => {
  const teamDayPlayersMap = _groupPlayersByTeamAndDay(players);
  return _filterArrHelper(teamDayPlayersMap);
}

console.log( filterArr(players) );

​