How to get the array in reduce?

You can also make the function itself _minreturn all the information.

In this example it _minreturns an object with the value of the product, the array itself and the index of the array:

function _min (arr){
  return arr.reduce(
    (prev, item, index) => {
      var prod = item.reduce((p, c) => p * c);
      return prev == null || prev.value > prod
        ? { value: prod, arr: item, index: index }
        : prev;
    }, null);
}

console.log(_min([[4,3,5],[5,2,5]]));

In the internal array it is used reduceto calculate the product (as you did in the example). pThe and parameters ccorrespond to the "previous" and "current" elements in each iteration. By not giving an initial value to the "previous" value in the first iteration p, it will match the first element of the array and cthe second. From the second iteration it phas the value calculated so far and cthe current element.

The reduceexternal applies to the entire array (the array of arrays) and goes through each element to keep the one with the smallest product. In this case the "previous" value is initialized with nullso that in the first iteration it prevhas a value of null, item("current" element) corresponds to the first array and indexwill be 0 (index of the first element).

To fully understand the example, you need to understand how the reduceobject method works Array. I will try to clarify it with some examples.

The methodreduce

The first problem when it comes to understanding the behavior of the method reduceusually comes from the name that is usually given to the first two parameters that the function passes to the method receives: "previous" and "current". These names can give the impression that they are elements of the same type (such as the previous and current element of the array) when they are not.

"previous" refers to the value returned by the previous iteration: the result obtained so far.

"current" refers to the current element of the array being iterated over.

To try to avoid this confusion from now on I will refer to that first ("previous") parameter as "result" or "calculated result".

The other source of confusion is usually the two modes of behavior that the method has depending on whether a value is provided with which to initialize the "result" or not.

The normal mode of behavior of the method reduceis that it is passed the function to be executed in each iteration and a value with which to initialize the "result". In this way the method executes the function for each element of the array. In the first iteration the "calculated result" parameter contains the initialization value, in the following iterations this parameter contains the value returned by the previous iteration. In this way (following the example above) to calculate the product of all the elements of the array we would do:

var arr = [4,3,5];

var final = arr.reduce(function(result, current, index){
  console.log('***** Iteración ' + index + '\n',
    'Resultado anterior: ' + result,
    'Valor actual: ' + current,
    'Valor a devolver: ' + result * current);
  return result * current;
}, 1);

console.log('**** Resultado final: ' + final);

The second method of operation is used when the result of the first iteration is always the first element of the array. In the above case, for example, in the first iteration the first element is always returned by the seed value (which is 1), that is, the first element.

In these cases the initialization value for the "result" can be omitted. The method reducethen starts iterating through the second element of the array, passing the first element as the "computed result":

var arr = [4,3,5];

var final = arr.reduce(function(result, current, index){
  console.log('***** Iteración ' + index + '\n',
    'Resultado anterior: ' + result,
    'Valor actual: ' + current,
    'Valor a devolver: ' + result * current);
  return result * current;
});

console.log('**** Resultado final: ' + final);

As you can see the first "current element" is the 3(second element of the array) and the "previous result" passed to that first iteration is the 4first element.

Although the result obtained is the same, a couple of differences must be taken into account:

1. One fewer iteration is performed, so any additional processing done in the function will not be done for the first element. In our example the console output is different. In a real case if, for example, in the function we take advantage to validate the elements of the array, that validation will not be performed for the first element.

2. If the array is empty and no initialization value is provided for the result, the method fails reduce:

var arr = [];

var final = arr.reduce(function(result, current, index){
  console.log('***** Iteración ' + index + '\n',
    'Resultado anterior: ' + result,
    'Valor actual: ' + current,
    'Valor a devolver: ' + result * current);
  return result * current;
}, 1);

console.log('**** Resultado final: ' + final);

final = arr.reduce(function(result, current, index){
  console.log('***** Iteración ' + index + '\n',
    'Resultado anterior: ' + result,
    'Valor actual: ' + current,
    'Valor a devolver: ' + result * current);
  return result * current;
});

console.log('**** Resultado final: ' + final);

We can use the same system to, for example, obtain minimum and maximum values ​​of an array:

var arr = [4, 18, 21, 5, 3, 17, 25, 1, 3, 18, 2];

// Calcular valor mínimo
var final = arr.reduce(function(result, current, index){
  console.log('***** Iteración ' + index + '\n',
    'Resultado anterior: ' + result,
    'Valor actual: ' + current,
    'Valor a devolver: ' + Math.min(result==null? current : result, current));
  return Math.min(result==null? current : result, current);  
}, null);

console.log('**** Resultado final: ' + final);

final = arr.reduce(function(result, current, index){
  console.log('***** Iteración ' + index + '\n',
    'Resultado anterior: ' + result,
    'Valor actual: ' + current,
    'Valor a devolver: ' + Math.min(result, current));
  return Math.min(result, current);  
});

console.log('**** Resultado final: ' + final);

We could also make the "result" be, for example, the two smallest numbers. For this the result should be an object with two properties: "minor" and "second". In this case the first value of the array does not serve us as "previous result" for the second iteration so we should use the mode with seed value.

What I will do is give an initialization value with an object with the two properties with value Infinityin this way all the elements of the array will be less than those values:

var arr = [4, 18, 21, 5, 3, 17, 25, 1, 3, 18, 2];

// Esta función es simplemente para convertir a string el resultado
// y poder mostrarlo en consola
function serialize(resultObject){
  return '{ minor: ' + resultObject.minor
    + ' second: ' + resultObject.second + ' }';
}

// Calcular los dos valores menores
var final = arr.reduce(function(result, current, index){
  console.log('***** Iteración ' + index + '\n',
    'Resultado anterior: ' + serialize(result),
    'Valor actual: ' + current);
  if (current < result.minor){
    // El actual es menor: el menor actual pasa a segundo menor
    result.second = result.minor;
    result.minor = current;
  }
  else if(current < result.second){
    // El actual es menor que el segundo menor
    result.second = current;
  }
  console.log('Valor a devolver: ' + serialize(result));
  return result;  
}, {minor: Infinity, second: Infinity});

console.log('**** Resultado final: ' + serialize(final));

From returnyour code...

Here you return the result of the Array that has the minimum result:

return Math.min(..._reduced);                         // => 50

Here you return the position of the Array that has the minimum result:

return _reduced.indexOf(Math.min(..._reduced));       // => 1

Here you return the Array that has the minimum result:

return arr[_reduced.indexOf(Math.min(..._reduced))];  // => [5, 2, 5]

Explanation of the procedure of your code: (For your question in the comment of this answer)

Problem: I want to obtain the array with the smallest result when multiplying all its terms.

Your code is:

function _min (arr){
 var _reduced = arr.map(cur => {
   return cur.reduce((c,i)=> {
   return c * i;
   });
 });
 // return de acuerdo a lo que quieres.
}

The first thing you are doing inside this function ( _min), is to generate a new array (with map) from another (from arr), and save that new resulting array in a variable ( _reduced).

arr.map(
  cur => cur.reduce(
    (c,i) => c * i
  )
);

Note: I rearranged your code to make the presentation clearer, but it's exactly the same code.

1. In detail; if the input is [ [4,3,5], [5,2,5] ], see that it is an array containing two arrays , then first step:

   [ [4,3,5], [5,2,5] ].map(cur => "cuerpo de la funcion")

The mapmeans that for each element of the array , you are going to apply the function that you put inside the parentheses. The array that receives the map is the one that has a as its first element and a [4,3,5]as its second element[5,2,5] . Do not confuse.

Your variable curis the temporary name that each of the elements will have. Since there are only 2, then you will have 2 iterations. In the first iteration cur = [4,3,5] and in the second iteration cur = [5,2,5] .

2. Second step, the function that you are going to apply to each array is this:

   cur => cur.reduce("otra funcion")

To each array , now you perform reduce. What it does is convert an array to a single value . Your code would look like this:

[4, 3, 5].reduce((c, i) => "cuerpo de la otra función")
[5, 2, 5].reduce((c, i) => "cuerpo de la otra función")

For this, for each element of each array , it executes a function. This function has two parameters. The first is c, that during the first iteration it will take the value of the first element, during the following ones, it will take the value of the previous result. The second parameter is i, which during the first iteration will take the value of the second element, and in the following ones the next element among the remaining ones...

If you did not understand the above, I explain with the example to make it clearer. Then you can reread the previous paragraph when you understand the example:

[4, 3, 5].reduce((c, i) => c * i)

// Primera iteración: c = 4  (primer elemento), i = 3 (segundo elemento). 
  // c * i es entonces 4 * 3 = 12. Este es el primer resultado.
// Segunda iteración: c = 12 (tu primer resultado), i = 5 (tercer elemento).
  // c * i es entonces 12 * 5 = 60
// No quedan más elementos en el array, así que devuelve el último resultado: 60.

The same happens with the other array of [5, 2, 5]:

[5, 2, 5].reduce((c, i) => c * i)

// Primera iteración: c = 5, i = 2. 
  // 5 * 2 = 10. 
// Segunda iteración: c = 10, i = 5
  // 10 * 5 = 50
// No quedan más elementos en el array, así que devuelve el último resultado: 50.

Once you understand the above, you have to remember where it all came from:

[4,3,5].reduce((c, i) => c * i) // => 60
[5,2,5].reduce((c, i) => c * i) // => 50

Which in turn, was a function that came inside a map:

let _reduced = arr.map(cur => cur.reduce((c, i) => c * i)) // => [60, 50]

So in your variable _reducedyou have your new array , which is [60, 50]. This new array is parallel to the input array, arr.

[[4,3,5],[5,2,5]]  // Array de entrada arr
[  60   ,   50  ]  // Array en _reduced

Therefore, the index of one of the arrays corresponds to the index of the other. 60corresponds to [4,3,5], and 50corresponds to [5,2,5].

Finally, what is the solution you want to return? Before what you returned was:

return Math.min(..._reduced);

Which is resolved as:

return Math.min(...[60, 50]); // Continuando a:
return Math.min(60, 50);      // Y el mínimo acá, es el 50 que devolvías.

Your question in this regard is why indexOf of 50 returns 1, which is the position of the array you were looking for? Now it is clearer, but if not... The development of how it would be interpreted:

return _reduced.indexOf(Math.min(..._reduced)); // indexOf de _reduced, no de arr.      
return [60, 50].indexOf(Math.min(...[60, 50]));
return [60, 50].indexOf(Math.min(60, 50));
return [60, 50].indexOf(50); // En qué posición está el 50? => 1

Finally, if you want to get the array that contains the minimum result. Since both arrays _reducedand arr are parallel , then:

return arr[_reduced.indexOf(Math.min(..._reduced))];
return arr[[60, 50].indexOf(Math.min(60, 50))];       
return arr[1];                   // arr es [[4,3,5],[5,2,5]], por lo tanto:
return [ [4,3,5], [5,2,5] ] [1]; // En la posición 1, está [5,2,5]
return [5,2,5];

You can perform the same development for any input you pass. And I recommend that if you are learning, try to execute the code in each step you do, so you can see this development in a more fun and clear way :)

I want to get the array with the smallest result by multiplying all its terms.

So you could do the following:

• We create an object against which we are going to compare all the values ​​of the array ( eg: {v: Infinity, a: null})

• For each value of the array:

  • Calculamos su producto (eg: item.reduce((v, n) => {return v * n})
  • Creamos un objeto donde guardamos el producto y el arreglo (eg: let next = {a: item, v: item.reduce...)
  • Y lo comparamos contra el del objeto inicial y conservamos el que sea menor (eg: return next.v < prev.v ? next : prev;)

• Al finalizar devolvemos el arreglo del objeto cuyo valor sea menor al de todos (eg: return arr.reduce(...).a;).

Demo

function _min(arr) {
  return arr.reduce((prev, item) => {
    let next = {a: item, v: item.reduce((v, n) => {return v * n})};
    return next.v < prev.v ? next : prev;
  }, {v: Infinity, a: null}).a;
}

console.log(_min([
  [4, 3, 5],
  [5, 2, 5]
]));