Lingide pesitsemine JavaScriptis

Kui teil on probleeme freeCodeCampi väljaande Nesting For Loops mõistmisega, ärge muretsege. Saime su tagasi.

Selles multiplyAll()ülesandes peate täitma funktsiooni ja võtma argumendiks mitmemõõtmelise massiivi. Pidage meeles, et mitmemõõtmeline massiiv, mida mõnikord nimetatakse ka 2D-massiiviks, on lihtsalt näiteks massiivide massiiv [[1,2], [3,4], [5,6]].

Parempoolses redaktoris multiplyAll()määratletakse järgmiselt:

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

Peate funktsiooni lõpule viima, nii et see korrutab productmuutuja iga arvuga parameetri alammassiivides arr, milleks on mitmemõõtmeline massiiv.

Selle probleemi lahendamiseks on palju erinevaid viise, kuid me keskendume forsilmuste abil lihtsaimale meetodile .

Pange oma forsilmused paika

Kuna tegemist arron mitmemõõtmelise massiiviga, vajate kahte forsilmuset: ühte, mis aheldab läbi iga alammassiivi massiivi, ja teist, et silmus läbi iga alammassiivi elemente.

Loop läbi sisemised massiivid

Selleks seadistage forsilmus, nagu olete teinud eelmistes väljakutsetes:

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

Pange tähele, et me kasutame tsükli letasemel varja deklareerimiseks product. Selles väljakutses te ei märka nende kahe erinevust, kuid üldiselt on hea tava kasutada ES6-sid constja letalati, kui saate. Miks sellest lähemalt, sellest saate lugeda sellest artiklist.

Nüüd logige kõik alammassiivid konsooli:

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

Kuna olete helistaja multiplyAll()koos [[1,2],[3,4],[5,6,7]]allosas, siis peaks näha järgmist:

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

Tutvuge iga alammassiivi elementidega

Nüüd peate konsooli äsja sisse logitud alammassiividest iga numbri läbi vaatama.

Eemaldage console.log(arr[i]);ja looge foräsja kirjutatud silmusest teine silmus:

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

Pidage meeles, et sisemise silmuse jaoks peame kontrollima .length, arr[i]kuna see arr[i]on üks alammassiividest, mida me varem vaatasime.

Nüüd logige arr[i][j]konsooli, et näha iga üksikut elementi:

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

Lõpuks korrutage productiga alammassiivi iga elemendiga:

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

Kui logite productkonsooli, näete iga testjuhtumi kohta õiget vastust:

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

Lähemalt

Kui te pole ikka veel kindel, miks ülaltoodud kood töötab, ärge muretsege - te pole üksi. Pesastatud silmustega töötamine on keeruline ja isegi kogenud arendajad võivad segadusse sattuda.

Sellistel juhtudel võib olla kasulik midagi üksikasjalikumat konsooli sisse logida. Minge tagasi oma koodi juurde ja logige `Sub-array ${i}: ${arr[i]}`konsooli vahetult enne sisemist forsilmust:

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

Välises forsilmus läbib iga iteratsioon läbi alammassiivide arr. Seda peaksite konsoolis nägema:

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

Pange tähele, et me kasutame ülaltoodud malli literaale. `Sub-array ${i}: ${arr[i]}`on sama 'Sub-array ' + i + ': ' + arr[i], lihtsalt palju lihtsam kirjutada.

Nüüd sisemisse foraasasse logige `Element ${j}: ${arr[i][j]}`konsooli:

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

Sisemine forsilmus läbib iga alammassiivi ( arr[i]) iga elemendi , nii et peaksite seda nägema konsoolis:

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

Esimene iteratsioon ihaarab esimese alammassiivi [1, 2]. Seejärel jläbib esimene kordus selle alammassiivi iga elemendi:

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

See näide on üsna lihtne, kuid sellest arr[i][j]võib siiski olla keeruline aru saada, kui logite konsooli mitu asja.

Üks kiire parandus, mida saame teha, on subArraymuutuja deklareerimine välimises forsilmus ja selle võrdseks määramine 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]]); 

Seejärel tehke koodile lihtsalt mõned muudatused, et kasutada uut subArraymuutujat 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]]); 

See peaks olema kõik, mida peate teadma mitmemõõtmeliste massiivide ja pesastatud forsilmuste kohta. Minge nüüd välja ja kordage parimatega!