Dacă aveți probleme la înțelegerea provocării Nesting For Loops a Routech, nu vă faceți griji. Ți-am luat spatele.

În această problemă trebuie să completați multiplyAll() funcție și ia o matrice multidimensională ca argument. Amintiți-vă că o matrice multidimensională, uneori numită matrice 2D, este doar o matrice de matrice, de exemplu, [[1,2], [3,4], [5,6]].

În editorul din dreapta, multiplyAll() este definit după cum urmează:

function multiplyAll(arr) {
  var product = 1;
  // Only change code below this line

  // Only change code above this line
  return product;
}

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

Trebuie să finalizați funcția, astfel încât să multiplice product variabilă după fiecare număr din sub-tablourile parametrului arr, care este o matrice multi-dimensională.

Există o mulțime de moduri diferite de a rezolva această problemă, dar ne vom concentra pe cea mai simplă metodă folosind for bucle.

Configurați-vă for bucle

pentru că arr este o matrice multi-dimensională, veți avea nevoie de două for bucle: una pentru a parcurge fiecare dintre matricele de sub-tablouri și alta pentru a trece prin elementele din fiecare sub-matrice.

Buclați prin matricile interioare

Pentru a face acest lucru, configurați un for bucla așa cum ați făcut în provocările anterioare:

function multiplyAll(arr) {
  let product = 1;
  // Only change code below this line
  for (let i = 0; i < arr.length; i++) {
    
  }
  // Only change code above this line
  return product;
}

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

Rețineți că folosim let in loc de var pentru buclă și pentru a declara product. În această provocare nu veți observa o diferență între cele două, dar, în general, este o bună practică să utilizați ES6 const și let oricând poți. Puteți citi mai multe despre de ce în acest articol.

Acum conectați fiecare consolă sub-matrice:

function multiplyAll(arr) {
  let product = 1;
  // Only change code below this line
  for (let i = 0; i < arr.length; i++) {
    console.log(arr[i]);
  }
  // Only change code above this line
  return product;
}

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

Pentru că sună multiplyAll() cu [[1,2],[3,4],[5,6,7]] în partea de jos, ar trebui să vedeți următoarele:

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

Buclați prin elementele din fiecare sub-matrice

Acum trebuie să parcurgeți fiecare număr din sub-tablourile pe care tocmai v-ați conectat la consolă.

Elimina console.log(arr[i]); și creează altul for bucla în interiorul celui pe care tocmai l-ați scris:

function multiplyAll(arr) {
  let product = 1;
  // Only change code below this line
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length; j++) {
      
    }
  }
  // Only change code above this line
  return product;
}

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

Amintiți-vă că, pentru bucla interioară, trebuie să verificăm .length de arr[i] de cand arr[i] este una dintre sub-matricile la care ne-am uitat mai devreme.

Acum jurnal arr[i][j] la consolă pentru a vedea fiecare dintre elementele individuale:

function multiplyAll(arr) {
  let product = 1;
  // Only change code below this line
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length; j++) {
      console.log(arr[i][j]);
    }
  }
  // Only change code above this line
  return product;
}

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

În cele din urmă, înmulțiți-vă product de fiecare element din fiecare dintre sub-tablouri:

function multiplyAll(arr) {
  let product = 1;
  // Only change code below this line
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length; j++) {
      product *= arr[i][j];
    }
  }
  // Only change code above this line
  return product;
}

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

Dacă vă logați product la consolă, veți vedea răspunsul corect pentru fiecare caz de testare:

function multiplyAll(arr) {
  let product = 1;
  // Only change code below this line
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length; j++) {
      product *= arr[i][j];
    }
  }
  // Only change code above this line
  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]]

O privire mai atentă

Dacă încă nu sunteți sigur de ce funcționează codul de mai sus, nu vă faceți griji – nu sunteți singur. Lucrul cu bucle imbricate este complicat și chiar și dezvoltatorii experimentați se pot confunda.

În astfel de cazuri, poate fi util să înregistrați ceva mai detaliat pe consolă. Reveniți la codul dvs. și jurnal `Sub-array ${i}: ${arr[i]}` către consolă chiar înainte de interior for buclă:

function multiplyAll(arr) {
  let product = 1;
  // Only change code below this line
  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];
    }
  }
  // Only change code above this line
  return product;
}

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

În exterior for buclă, fiecare iterație trece prin sub-tablourile din arr. Ar trebui să vedeți acest lucru în consolă:

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

Rețineți că folosim literale șablon de mai sus. `Sub-array ${i}: ${arr[i]}` este la fel ca 'Sub-array ' + i + ': ' + arr[i], doar mult mai ușor de scris.

Acum în interior for buclă, jurnal `Element ${j}: ${arr[i][j]}` la consolă:

function multiplyAll(arr) {
  let product = 1;
  // Only change code below this line
  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];
    }
  }
  // Only change code above this line
  return product;
}

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

Interiorul for bucla trece prin fiecare element din fiecare sub-matrice (arr[i]), deci ar trebui să vedeți acest lucru în consolă:

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

Prima iterație a i apucă primul sub-tablou, [1, 2]. Apoi prima iterație a j trece prin fiecare element din acea sub-matrice:

// 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

...

Acest exemplu este destul de simplu, dar arr[i][j] poate fi totuși dificil de înțeles fără a conecta mai multe lucruri la consolă.

O îmbunătățire rapidă pe care o putem face este declararea unui subArray variabilă în exterior for bucla și setarea ei egală cu arr[i]:

function multiplyAll(arr) {
  let product = 1;
  // Only change code below this line
  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];
    }
  }
  // Only change code above this line
  return product;
}

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

Apoi, faceți doar câteva modificări la cod pentru a utiliza noul subArray variabil în loc de arr[i]:

function multiplyAll(arr) {
  let product = 1;
  // Only change code below this line
  for (let i = 0; i < arr.length; i++) {
    const subArray = arr[i];
    for (let j = 0; j < subArray.length; j++) {
      product *= subArray[j];
    }
  }
  // Only change code above this line
  return product;
}

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

Acesta ar trebui să fie tot ce trebuie să știți despre matrici multi-dimensionale și cuibărite for bucle. Acum ieșiți acolo și iterați cu cei mai buni dintre ei!