Original article: Nesting For Loops in JavaScript

Si tienes problemas para entender el desafío Anida bucles "for" de freeCodeCamp, no te preocupes. Te cubrimos las espaldas.

En este problema tienes que completar la función multiplyAll(), y toma un arreglo multidimensional como argumento. Recuerda que un arreglo multidimensional, a veces llamado arreglo 2D, no es más que un arreglo de arreglos, por ejemplo, [[1,2], [3,4], [5,6]].

En el editor de la derecha, multiplyAll() se define como sigue:

function multiplyAll(arr) {
  var product = 1;
  // Sólo cambie el código inferior a esta línea

  // Cambia sólo el código antes de esta línea
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);

Tienes que completar la función para que multiplique la variable product por cada número de los sub arreglos del parámetro arr, que es un arreglo multidimensional.

Hay muchas formas diferentes de resolver este problema, pero nos centraremos en el método más sencillo utilizando bucles for.

Configura tus bucles for

Como arr es un arreglo multidimensional, necesitarás dos bucles for: uno para recorrer cada uno de los sub arreglos, y otro para recorrer los elementos de cada sub arreglo.

Recorrer los arreglos internos

Para ello, configura un bucle for como has hecho en retos anteriores.

function multiplyAll(arr) {
  let product = 1;
  // Sólo cambie el código inferior a esta línea
  for (let i = 0; i < arr.length; i++) {
    
  }
  // Cambia sólo el código antes de esta línea
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);

Tenga en cuenta que estamos utilizando let en lugar de var para el bucle y para declarar el product. En este reto no notarás la diferencia entre ambos, pero en general es una buena práctica usar const y let de ES6 siempre que puedas. Puedes leer más sobre por qué en este artículo.

Ahora registra cada uno de los sub arreglos en la consola:

function multiplyAll(arr) {
  let product = 1;
  // Sólo cambie el código inferior a esta línea
  for (let i = 0; i < arr.length; i++) {
    console.log(arr[i]);
  }
  // Cambia sólo el código antes de esta línea
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);

Como estás llamando a multiplyAll() con [[1,2],[3,4],[5,6,7]] en la parte inferior debe ver lo siguiente:

[ 1, 2 ]
[ 3, 4 ]
[ 5, 6, 7 ]

Recorrer en bucle los elementos de cada sub arreglo

Ahora tienes que recorrer cada número de los sub arreglos que acabas de registrar en la consola.

Elimina console.log(arr[i]); y crea otro bucle for dentro del que acabas de escribir:

function multiplyAll(arr) {
  let product = 1;
  // Sólo cambie el código inferior a esta línea
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length; j++) {
      
    }
  }
  // Cambia sólo el código antes de esta línea
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);

Recuerda que, para el bucle interno, necesitamos comprobar la .length de arr[i], ya que arr[i] es uno de los sub arreglos que vimos antes.

Ahora registra arr[i][j] en la consola para ver cada uno de los elementos individuales:

function multiplyAll(arr) {
  let product = 1;
  // Sólo cambie el código inferior a esta línea
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length; j++) {
      console.log(arr[i][j]);
    }
  }
  // Cambia sólo el código antes de esta línea
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);

1
2
3
4
5
6
7

Por último, multiplica el product por cada elemento de cada uno de los sub arreglos:

function multiplyAll(arr) {
  let product = 1;
  // Sólo cambie el código inferior a esta línea
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length; j++) {
      product *= arr[i][j];
    }
  }
  // Cambia sólo el código antes de esta línea
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);

Si registras el product en la consola, verás la respuesta correcta para cada caso de prueba:

function multiplyAll(arr) {
  let product = 1;
  // Sólo cambie el código inferior a esta línea
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length; j++) {
      product *= arr[i][j];
    }
  }
  // Cambia sólo el código antes de esta línea
  console.log(product);
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);
6  // [[1], [2], [3]]
5040  // [[1, 2], [3, 4], [5, 6, 7]]
54  // [[5, 1], [0.2, 4, 0.5], [3, 9]]

Un vistazo más de cerca

Si todavía no estás seguro de por qué funciona el código anterior, no te preocupes: no estás solo. Trabajar con bucles anidados es complicado, e incluso los desarrolladores experimentados pueden confundirse.

En casos como este, puede ser útil registrar algo más detallado en la consola. Vuelve a tu código y registra `Sub-array ${i}: ${arr[i]}` en la consola justo antes del bucle for interno:

function multiplyAll(arr) {
  let product = 1;
  // Sólo cambie el código inferior a esta línea
  for (let i = 0; i < arr.length; i++) {
    console.log(`Sub-array ${i}: ${arr[i]}`);
    for (let j = 0; j < arr[i].length; j++) {
      product *= arr[i][j];
    }
  }
  // Cambia sólo el código antes de esta línea
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);

En el bucle for exterior, cada iteración recorre las submatrices de arr. Deberías ver esto en la consola:

Sub-array 0: 1,2
Sub-array 1: 3,4
Sub-array 2: 5,6,7

Ten en cuenta que estamos utilizando literales de plantilla arriba. `Sub-array ${i}: ${arr[i]}` es lo mismo que `Sub-array ' + i + ': ' + arr[i], solo que mucho más fácil de escribir.

Ahora, en el bucle for interno, registra `Element ${j}: ${arr[i][j]}` en la consola:

function multiplyAll(arr) {
  let product = 1;
  // Sólo cambie el código inferior a esta línea
  for (let i = 0; i < arr.length; i++) {
    console.log(`Sub-array ${i}: ${arr[i]}`);
    for (let j = 0; j < arr[i].length; j++) {
      console.log(`Element ${j}: ${arr[i][j]}`);
      product *= arr[i][j];
    }
  }
  // Cambia sólo el código antes de esta línea
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);

El bucle for interno recorre cada elemento de cada sub arreglo (arr[i]), por lo que deberías ver esto en la consola:

Sub-array 0: 1,2
Element 0: 1
Element 1: 2
Sub-array 1: 3,4
Element 0: 3
Element 1: 4
Sub-array 2: 5,6,7
Element 0: 5
Element 1: 6
Element 2: 7

La primera iteración de i toma el primer sub arreglo, [1, 2]. Y después, la primera iteración de j recorre cada elemento de ese sub arreglo:

// i is 0
arr[0] // [1, 2];

// j is 0
arr[0][0] // 1
// j is 1
arr[0][1] // 2

-----

// i is 1
arr[1] // [3, 4]

// j is 0
arr[1][0] // 3
// j is 1
arr[1][1] // 4

...

Este ejemplo es bastante simple, pero arr[i][j] todavía puede ser difícil de entender sin registrar varias cosas en la consola.

Una mejora rápida que podemos hacer es declarar una variable subArray en el bucle for externo y hacerla igual a arr[i]:

function multiplyAll(arr) {
  let product = 1;
  // Sólo cambie el código inferior a esta línea
  for (let i = 0; i < arr.length; i++) {
    const subArray = arr[i];
    for (let j = 0; j < arr[i].length; j++) {
      product *= arr[i][j];
    }
  }
  // Cambia sólo el código antes de esta línea
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);

Luego, solo tienes que hacer algunos ajustes en el código para utilizar la nueva variable subArray en lugar de arr[i]:

function multiplyAll(arr) {
  let product = 1;
  // Sólo cambie el código inferior a esta línea
  for (let i = 0; i < arr.length; i++) {
    const subArray = arr[i];
    for (let j = 0; j < subArray.length; j++) {
      product *= subArray[j];
    }
  }
  // Cambia sólo el código antes de esta línea
  return product;
}

multiplyAll([[1,2],[3,4],[5,6,7]]);

Esto debería ser todo lo que necesitas saber sobre arreglos multidimensionales y bucles for anidados. Ahora, ¡vete a hacer iteraciones como los mejores!