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

我在将数组转换为对象时尝试了reduce（）和find（），反之亦然，但是还没有运气。
我想应该在普通香草JS ES6或ES7中采用更优雅的方式执行这样的简单任务。理想情况是单线。请不要大惊小怪。

这里的所有其他问题都以我的接触更深一层为目标时的元素搜索。

Answer 1

您可以尝试使用javascript filter function：类似的东西

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 2

当然，这是一个班轮：

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

这使用includes来检查el.key是否为数字之一，然后将布尔值转换为一元加一进制的数字（true-> 1，false-> 0），并且添加到每个元素的计数中，得出总数。

Answer 3

您可以使用.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 4

尝试使用

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

count将具有相同键的对象数

Answer 5

请勿在键上循环创建新数组，一行一行以减少循环迭代。

减少工作：

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',
]));

循环和计数数组

5 个答案: