Home / Questions / 317891
Accepted
V0LT3RR4
Asked: 2020-12-23 17:51:06 +0800 CST 2020-12-23 17:51:06 +0800 CST

Can I do a double reduce in Javascript?

  • 772

I have an array of arrays (with boolean elements), say,

const array = [[false, false], [false, true], [true, true]];

And I want to use a reduce()to count how many true there are, this is what I try:

const check = (array) => {
    const numNotAnsweredQuestion = array.reduce((acc, elem1) => {
      return (
        acc +
        elem1.reduce((acc2, elem2) => {
          return elem2 ? acc2 + 1 : acc2;
        }, 0)
      );
    }, 0);
    return numNotAnsweredQuestion;
  };

That is, I accumulate twice, or not?

The browser returns the function:

enter image description here

javascript

4 Answers

  1. Best Answer

    Your function works. It gives me the idea that you only need to invoke it. But ... it's bad practice to shadow variables/parameters. Better to use, inside the function, variables that are not called the same as those outside.

    That said, the approach:

    const array_original = [
  [false, false],
  [false, true],
  [true, true]
];

const check = (array_cualquiera) => {
  const numNotAnsweredQuestion = array_cualquiera.reduce((acc, elem1) => {
    return (
      acc +
      elem1.reduce((acc2, elem2) => {
        return elem2 ? acc2 + 1 : acc2;
      }, 0)
    );
  }, 0);
  return numNotAnsweredQuestion;
};

// Imprime 3
console.log(check(array_original));

    It's perfect. However you are operating on an array that you know and your implementation is a particular solution.

    If instead you had an array that you only know has elements in nesting levels of depth N, and you wanted to count

    • how many are truthy(non-empty strings, true, non-zero numbers, objects) or
    • how many are falsy(empty strings, null, undefined, 0, false, NaN)

    You can use recursion to call the function countTruthyover any nested element that is an array, and map truthyto 1 and falsy0 otherwise:

    const countTruthy = (array_cualquiera) => {
  return array_cualquiera.reduce((acc, elem1) => {
      return acc + 
      ((Array.isArray(elem1) && countTruthy(elem1))  // recursión
      || (elem1 ? 1 : 0)); //mapeo
      
   }, 0);
};

const array_original = [
  [false, false],
  [false, true],
  [true, true]
];
// Sigue siendo 3
console.log(countTruthy(array_original));

const array_muy_anidado = [
  [true, 1, 0],
  [undefined, false, NaN, window, Infinity],
  [
    [null, true], ''
  ],
  ['yes', [-1, 0, [{}, new Map(), function() {}]]]
];

// Imprime 10
console.log(countTruthy(array_muy_anidado));

    This approach works on your example array and in general on any array whose elements you can coerce to a boolean

    • 3

  2. I think the following should be considered:

    • You have a data matrix (this detail is important because you must first access the contained values)
    • You must first iterate at least 2 times to get the values ​​of each vector contained in the array
    • When you get the values ​​of each array vector, then you can add them to an empty vector (step )
    • Once you have the new vector with all the values ​​extracted from the array, then you can apply the methodreduce
    • I do not see why to use 2 since the intention of this is to reduce a vectorreduce to an element but not a matrix , given that it does not seem to me the correct way to want to implement it

    sample code

        const array = [[false, false], [false, true], [true, true]]
    let nuevoArray = []
    
    for (elemento of array) {
      for(valor of elemento) {
        nuevoArray.push(valor)
      }
    }
    
    let sumaEnteros = nuevoArray.reduce((previo, actual) => previo + actual)
    console.log(sumaEnteros)

    • 1

  3. Passing it the function that checks if the value is true and in that case adding one to the accumulator should suffice:

    const array = [[false, false], [false, true], [true, true]];

console.log(array.reduce((a,b)=>b?a+1:a, 0));

    However, you can do it in a simpler way using flat and filter:

    const array = [[false, false], [false, true], [true, true]];

console.log(array.flat().filter(v => v).length)

    • 1

  4. I understand that the shortest and most efficient way is to do .flatand then .reduce:

    const array = [[false, false], [false, true], [true, true]];

const res = array.flat().reduce((p,c)=>p+c);

console.log(res);

    The falsewill be 0 and the true1. This is valid only if the values ​​are trueor false.

    • 1