Цикл и рассчитывать на массивы

Question

У меня есть массив объектов с известными ключами. И я хочу посчитать, сколько объектов имеют определенный ключ с определенным значением. В настоящее время я сделал это с этим:

counter = () => {
        if (Array) {
            let a = 0;
            for (let i = 0; i < Array.length; i++) {
                if (Array[i].key === '1' || Array[i].key === '2' || Array[i].key === '3' || Array[i].key === '4' || Array[i].key === '5' || Array[i].key === '6' || Array[i].key === '7') {
                    a++;
                }
            }
            return a;
        }
    }

Я пытался уменьшить () и найти () при преобразовании массивов в объекты и наоборот, но пока безуспешно.
Я предполагаю, что должен быть более элегантный способ выполнить такую ​​простую задачу в простом ванильном JS ES6 или ES7. В идеале, лайнер. Не жалейте, пожалуйста.

Все остальные вопросы здесь нацелены на поиск элементов, когда мой касается одного уровня глубже.

Answer 1

Попробуйте использовать

var count = b.filter(element => {return element.key == requiredKey;}).length;

count будет иметь количество объектов с одинаковым ключом

Answer 2

Не создавайте новый массив, одну строку, цикл по ключам, чтобы уменьшить итерации цикла.

Уменьшить работу как:

array.reduce((accumulator, oneArrayValue) => {
  // Function where treatment are done
  return theAccumulatorValueForNextLoopIteration;
}, initialValueOfTheAccumulator);

function counter(obj, keys) {
  // void 0 equals undefined
  // So it's equivalent to typeof x !== 'undefined'

  // tmp is the accumulator, it's value is setted up at 0
  // then it becomes what you return after every loop
  return keys.reduce((tmp, x) => obj[x] !== void 0 ? tmp + 1 : tmp, 0);
}

console.log(counter({
  1: 'hey',
  2: 'how',
  8: 'you',
  12: 'doing',
  15: 'baguette',
}, [
  '1',
  '2',
  '3',
  '4',
  '5',
  '6',
  '7',
]));

Answer 3

Вы можете попробовать использовать функцию фильтра JavaScript : что-то вроде:

var count = array.filter(function(e){
                  return (e.key === '1' || e.key === '2' || e.key === '3' || e.key === '4' || e.key === '5' || e.key === '6' || e.key === '7')

}).length;

По сути, это фильтр вашего массива объектов по ключам, которые вы хотите, в конце он вычисляет длину массива.

Answer 4

Вы можете сделать это с помощью .filter() довольно легко, например, так:

Идея состоит в том, что вы хотите отфильтровать только те объекты, которые соответствуют, а затем использовать .length, чтобы получить счетчик вконец.Мы можем узнать, совпадает ли элемент, проверив, включено ли значение свойства объекта key в список ключей, которые вы ищете.

var test = [
{ key: '1' },
{ key: '3' },
{ key: '2' },
{ key: '7' },
{ key: '5' },
{ key: '8' },
]
var keysToSearch = ['1', '2', '3', '4', '5', '6', '7'];

function counter (objs, searchKeys) {
  return objs.filter(obj => searchKeys.includes(obj.key)).length;
}

console.log(counter(test, keysToSearch));

РЕДАКТИРОВАТЬ

Вот решение, которое делает то же самое, что и выше, но не создает новый массив с .filter().

var test = [
{ key: '1' },
{ key: '3' },
{ key: '2' },
{ key: '7' },
{ key: '5' },
{ key: '8' },
]
var keysToSearch = ['1', '2', '3', '4', '5', '6', '7'];

function counter (objs, searchKeys) {
  var count = 0;
  for (var obj of objs) {
    if (searchKeys.includes(obj.key)) { count++; }
  }
  return count;
}

console.log(counter(test, keysToSearch));

Answer 5

Конечно, вот тот самый лайнер:

 array.reduce((count, el) => count + +["1", "2", "3", "4", "5", "6", "7"].includes(el.key), 0)

При этом используется includes для проверки, является ли el.key одним из чисел, затем полученное логическое значение превращается в число с унарным плюсом (true -> 1, false -> 0) и добавляется к рассчитывать для каждого элемента, в результате чего общее количество.