chore(i18n,curriculum): update translations (#42487)

* chore(i18n,curriculum): update translations

* chore: Italian to italian

Co-authored-by: Nicholas Carrigan <nhcarrigan@gmail.com>

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.md

@@ -0,0 +1,57 @@
+---
+id: 587d7b85367417b2b2512b3a
+title: Scovare argomenti passati nell'ordine sbagliato quando si chiama una funzione
+challengeType: 1
+forumTopicId: 301184
+dashedName: catch-arguments-passed-in-the-wrong-order-when-calling-a-function
+---
+
+# --description--
+
+Continuando la discussione sulle chiamate di funzioni, il prossimo bug a cui fare attenzione è quando gli argomenti di una funzione vengono forniti in ordine errato. Se gli argomenti sono di tipo diverso, come una funzione che si aspetta un array e un numero intero, probabilmente verrà generato un errore di runtime. Se gli argomenti sono dello stesso tipo (tutti interi, ad esempio), allora la logica del codice non avrà senso. Assicurati di fornire tutti gli argomenti richiesti nell'ordine giusto per evitare questi problemi.
+
+# --instructions--
+
+La funzione `raiseToPower` eleva una base ad un esponente. Purtroppo, non è chiamata correttamente - correggi il codice in modo che il valore di `power` sia 8 come previsto.
+
+# --hints--
+
+Il tuo codice dovrebbe correggere la variabile `power` in modo che sia uguale a 2 elevato alla terza potenza, non 3 elevato alla seconda potenza.
+
+```js
+assert(power == 8);
+```
+
+Il tuo codice dovrebbe utilizzare l'ordine corretto degli argomenti per la chiamata della funzione `raiseToPower`.
+
+```js
+assert(code.match(/raiseToPower\(\s*?base\s*?,\s*?exp\s*?\);/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function raiseToPower(b, e) {
+  return Math.pow(b, e);
+}
+
+let base = 2;
+let exp = 3;
+let power = raiseToPower(exp, base);
+console.log(power);
+```
+
+# --solutions--
+
+```js
+function raiseToPower(b, e) {
+ return Math.pow(b, e);
+}
+
+let base = 2;
+let exp = 3;
+let power = raiseToPower(base, exp);
+console.log(power);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/catch-missing-open-and-closing-parenthesis-after-a-function-call.md

@@ -0,0 +1,69 @@
+---
+id: 587d7b85367417b2b2512b39
+title: Scoprire la mancanza di parentesi aperte o chiuse dopo la chiamata di una funzione
+challengeType: 1
+forumTopicId: 301185
+dashedName: catch-missing-open-and-closing-parenthesis-after-a-function-call
+---
+
+# --description--
+
+Quando una funzione o un metodo non prende alcun argomento, potresti dimenticare di includere le parentesi (vuote) di apertura e chiusura quando la chiami. Spesso il risultato di una chiamata di funzione viene salvato in una variabile per altri utilizzi nel tuo codice. Questo errore può essere rilevato scrivendo sulla console i valori delle variabili (o i loro tipi) e vedendo che uno è impostato su un riferimento a una funzione, invece che sul valore che ci aspettiamo vanga restituito dalla funzione.
+
+Le variabili nell'esempio seguente sono diverse:
+
+```js
+function myFunction() {
+  return "You rock!";
+}
+let varOne = myFunction;
+let varTwo = myFunction();
+```
+
+Qui `varOne` è la funzione `myFunction` e `varTwo` è la stringa `You rock!`.
+
+# --instructions--
+
+Correggi il codice in modo che la variabile `result` sia impostata al valore restituito dalla funzione `getNine`.
+
+# --hints--
+
+Il tuo codice dovrebbe correggere la variabile `result` in modo da impostarla sul numero che la funzione `getNine` restituisce.
+
+```js
+assert(result == 9);
+```
+
+Il tuo codice dovrebbe chiamare la funzione `getNine`.
+
+```js
+assert(code.match(/getNine\(\)/g).length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getNine() {
+  let x = 6;
+  let y = 3;
+  return x + y;
+}
+
+let result = getNine;
+console.log(result);
+```
+
+# --solutions--
+
+```js
+function getNine() {
+ let x = 6;
+ let y = 3;
+ return x + y;
+}
+
+let result = getNine();
+console.log(result);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.md

@@ -0,0 +1,69 @@
+---
+id: 587d7b84367417b2b2512b35
+title: Scovare i nomi di funzioni e variabili scritti male
+challengeType: 1
+forumTopicId: 301186
+dashedName: catch-misspelled-variable-and-function-names
+---
+
+# --description--
+
+I metodi `console.log()` e `typeof` sono i due modi principali per controllare i valori intermedi e i tipi degli output del programma. Ora è il momento di approfondire le forme più comuni di bug. Un problema di sintassi di cui si rammaricano i digitatori veloci è il semplice errore di ortografia.
+
+Caratteri spostati, mancanti, o con maiuscole errate nel nome di una variabile o di una funzione costringeranno il browser a cercare un oggetto che non esiste - e a lamentarsi tramite un errore di riferimento. In JavaScript, le variabili e i nomi di funzione sono sensibili alle maiuscole.
+
+# --instructions--
+
+Correggi i due errori di ortografia nel codice in modo che il calcolo di `netWorkingCapital` funzioni.
+
+# --hints--
+
+Controlla l'ortografia delle due variabili utilizzate nel calcolo di netWorkingCapital, l'output della console dovrebbe mostrare che "Net working capital is: 2".
+
+```js
+assert(netWorkingCapital === 2);
+```
+
+Non ci dovrebbero essere casi di variabili scritte male nel codice.
+
+```js
+assert(!code.match(/recievables/g));
+```
+
+La variabile `receivables` dovrebbe essere dichiarata e utilizzata correttamente nel codice.
+
+```js
+assert(code.match(/receivables/g).length == 2);
+```
+
+Non ci dovrebbero essere casi di variabili scritte male nel codice.
+
+```js
+assert(!code.match(/payable;/g));
+```
+
+La variabile `payables` dovrebbe essere dichiarata e utilizzata correttamente nel codice.
+
+```js
+assert(code.match(/payables/g).length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let receivables = 10;
+let payables = 8;
+let netWorkingCapital = recievables - payable;
+console.log(`Net working capital is: ${netWorkingCapital}`);
+```
+
+# --solutions--
+
+```js
+let receivables = 10;
+let payables = 8;
+let netWorkingCapital = receivables - payables;
+console.log(`Net working capital is: ${netWorkingCapital}`);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.md

@@ -0,0 +1,63 @@
+---
+id: 587d7b84367417b2b2512b37
+title: Scovare l'uso misto di virgolette singole e doppie
+challengeType: 1
+forumTopicId: 301188
+dashedName: catch-mixed-usage-of-single-and-double-quotes
+---
+
+# --description--
+
+JavaScript consente l'uso dell'apostrofo (`'`) e delle virgolette (`"`) per dichiarare una stringa. Decidere quale utilizzare generalmente è una questione di gusti personali, con alcune eccezioni.
+
+Avere due scelte è ottimo quando una stringa ha all'interno contrazioni o un altro pezzo di testo citato. Basta stare attenti a non chiudere la stringa troppo presto, perché provocherebbe un errore di sintassi.
+
+Ecco alcuni esempi di virgolette miste:
+
+```js
+const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";
+const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";
+const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';
+```
+
+I primi due sono corretti, ma il terzo è sbagliato.
+
+Naturalmente, va bene usare solo uno stile di virgolette. Puoi fare l'escaping delle virgolette all'interno della stringa usando il carattere di escape backslash (`\`):
+
+```js
+const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';
+```
+
+# --instructions--
+
+Correggi la stringa in modo da usare virgolette diverse per il valore `href` o fai l'escaping di quelle esistenti. Mantieni le virgolette doppie intorno all'intera stringa.
+
+# --hints--
+
+Il tuo codice dovrebbe correggere le virgolette intorno al valore `href` `#Home` cambiandole o facendone l'escaping.
+
+```js
+assert(code.match(/<a href=\s*?('|\\")#Home\1\s*?>/g));
+```
+
+Il tuo codice dovrebbe mantenere le virgolette doppie intorno all'intera stringa.
+
+```js
+assert(code.match(/"<p>.*?<\/p>";/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let innerHtml = "<p>Click here to <a href="#Home">return home</a></p>";
+console.log(innerHtml);
+```
+
+# --solutions--
+
+```js
+let innerHtml = "<p>Click here to <a href=\"#Home\">return home</a></p>";
+console.log(innerHtml);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md

@@ -0,0 +1,93 @@
+---
+id: 587d7b86367417b2b2512b3b
+title: Trovare gli errori "fuori di uno" nell'indicizzazione
+challengeType: 1
+forumTopicId: 301189
+dashedName: catch-off-by-one-errors-when-using-indexing
+---
+
+# --description--
+
+Gli errori <dfn>fuori di uno</dfn> (talvolta chiamati OBOE, "Off by one errors") si presentano quando si sta tentando di puntare ad un indice specifico di una stringa o di un array (per tagliare o accedere a un segmento), o quando si itera sui loro indici. L'indicizzazione JavaScript inizia da zero, non da uno, il che significa che l'ultimo indice è sempre inferiore di uno rispetto alla posizione dell'elemento. Se si tenta di accedere a un indice pari alla lunghezza, il programma potrebbe lanciare un errore di riferimento "index out of range" (indice fuori campo) o scrivere `undefined`.
+
+Quando si utilizzano metodi di stringa o di array che prendono intervalli di indici come argomenti, è utile leggerne la documentazione e capire se sono inclusivi (l'elemento all'indice dato fa parte di ciò che è restituito) o no. Ecco alcuni esempi di errori fuori di uno:
+
+```js
+let alphabet = "abcdefghijklmnopqrstuvwxyz";
+let len = alphabet.length;
+for (let i = 0; i <= len; i++) {
+  console.log(alphabet[i]);
+}
+for (let j = 1; j < len; j++) {
+  console.log(alphabet[j]);
+}
+for (let k = 0; k < len; k++) {
+  console.log(alphabet[k]);
+}
+```
+
+Qui il primo esempio itera una volta di troppo, e il secondo itera una volta troppo poco (mancando il primo indice, 0). Il terzo esempio è corretto.
+
+# --instructions--
+
+Correggi i due errori di indicizzazione nella funzione seguente così che tutti i numeri da 1 a 5 vengano visualizzati nella console.
+
+# --hints--
+
+Il tuo codice dovrebbe impostare la condizione iniziale del ciclo in modo che inizi al primo indice.
+
+```js
+assert(code.match(/i\s*?=\s*?0\s*?;/g).length == 1);
+```
+
+Il tuo codice dovrebbe aggiustare la condizione iniziale del ciclo in modo che l'indice inizi da 0.
+
+```js
+assert(!code.match(/i\s?=\s*?1\s*?;/g));
+```
+
+Il tuo codice dovrebbe impostare la condizione di chiusura del ciclo in modo che si interrompa all'ultimo indice.
+
+```js
+assert(code.match(/i\s*?<\s*?len\s*?;/g).length == 1);
+```
+
+Il tuo codice dovrebbe fissare la condizione di chiusura del ciclo in modo che si fermi a un passo dalla lunghezza.
+
+```js
+assert(!code.match(/i\s*?<=\s*?len;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function countToFive() {
+  let firstFive = "12345";
+  let len = firstFive.length;
+  // Only change code below this line
+  for (let i = 1; i <= len; i++) {
+  // Only change code above this line
+    console.log(firstFive[i]);
+  }
+}
+
+countToFive();
+```
+
+# --solutions--
+
+```js
+function countToFive() {
+ let firstFive = "12345";
+ let len = firstFive.length;
+ // Only change code below this line
+ for (let i = 0; i < len; i++) {
+ // Only change code above this line
+   console.log(firstFive[i]);
+ }
+}
+
+countToFive();
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md

@@ -0,0 +1,49 @@
+---
+id: 587d7b84367417b2b2512b36
+title: 'Scovare parentesi tonde, quadre, graffe e virgolette rimaste aperte'
+challengeType: 1
+forumTopicId: 301190
+dashedName: catch-unclosed-parentheses-brackets-braces-and-quotes
+---
+
+# --description--
+
+Un altro errore di sintassi a cui bisogna stare attenti è che ogni apertura di parentesi tonde, quadre, graffe e virgolette richiede una chiusura. Dimenticarne una parte tende a succedere quando si sta modificando il codice esistente per inserire elementi che hanno una di queste coppie. Inoltre, presta attenzione quando annidi un blocco di codice dentro a un altro, ad esempio per aggiungere una funzione di callback come argomento a un metodo.
+
+Un modo per evitare questo errore è, non appena viene digitato il carattere di apertura, inserire immediatamente la chiusura corrispondente, quindi spostare il cursore indietro tra di esse e continuare a scrivere. Fortunatamente, la maggior parte degli editor di codice moderni generano automaticamente la seconda metà della coppia.
+
+# --instructions--
+
+Correggi gli errori delle due coppie nel codice.
+
+# --hints--
+
+Il tuo codice dovrebbe aggiungere la parte mancante dell'array.
+
+```js
+assert(code.match(/myArray\s*?=\s*?\[\s*?1\s*?,\s*?2\s*?,\s*?3\s*?\];/g));
+```
+
+Il tuo codice dovrebbe correggere la parte mancante del metodo `.reduce()`. L'output su console dovrebbe mostrare che `Sum of array values is: 6`.
+
+```js
+assert(arraySum === 6);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myArray = [1, 2, 3;
+let arraySum = myArray.reduce((previous, current =>  previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```
+
+# --solutions--
+
+```js
+let myArray = [1, 2, 3];
+let arraySum = myArray.reduce((previous, current) =>  previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md

@@ -0,0 +1,81 @@
+---
+id: 587d7b85367417b2b2512b38
+title: Intercettare l'uso dell'operatore di assegnazione anziché dell'operatore di uguaglianza
+challengeType: 1
+forumTopicId: 301191
+dashedName: catch-use-of-assignment-operator-instead-of-equality-operator
+---
+
+# --description--
+
+In JavaScript, programmi con ramificazioni, ad esempio quelli che fanno cose diverse se certi presupposti sono rispettati, si basano sulle condizioni `if`, `else if`, e `else`. La condizione a volte consiste nel verificare se un risultato è uguale a un valore.
+
+Questa logica si può esprimere (in inglese e italiano, almeno) come "se x è uguale a y, allora ..." che può letteralmente tradursi in codice utilizzando l'`=` o operatore di assegnazione. Questo porta a un controllo del flusso inatteso nel tuo programma.
+
+Come indicato nelle sfide precedenti, l'operatore di assegnazione (`=`) in JavaScript assegna un valore al nome di una variabile. E gli operatori `==` e `===` controllano l'uguaglianza (il triplo `===` controlla l'uguaglianza stretta, cioè sia il valore che il tipo devono essere uguali).
+
+Il codice qui sotto assegna a `x` il valore 2, che viene valutato come `true`. Quasi ogni valore da solo in JavaScript viene considerato `true`, eccetto quelli che sono conosciuti come i valori "falsy": `false`, `0`, `""` (una stringa vuota), `NaN`, `undefined` e `null`.
+
+```js
+let x = 1;
+let y = 2;
+if (x = y) {
+
+} else {
+
+}
+```
+
+In questo esempio, il blocco di codice all'interno dell'istruzione `if` verrà eseguito per qualsiasi valore di `y`, a meno che `y` non sia falsy. Il blocco `else`, che ci aspettiamo venga eseguito qui, non sarà effettivamente eseguito.
+
+# --instructions--
+
+Correggi la condizione in modo che il programma esegua il ramo giusto e il valore appropriato venga assegnato a `result`.
+
+# --hints--
+
+Il tuo codice dovrebbe aggiustare la condizione in modo che controlli l'uguaglianza invece di utilizzare l'assegnazione.
+
+```js
+assert(result == 'Not equal!');
+```
+
+La condizione dovrebbe usare `==` o `===` per verificare l'uguaglianza.
+
+```js
+assert(code.match(/x\s*?===?\s*?y/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x = y) {
+  result = "Equal!";
+} else {
+  result = "Not equal!";
+}
+
+console.log(result);
+```
+
+# --solutions--
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x === y) {
+ result = "Equal!";
+} else {
+ result = "Not equal!";
+}
+
+console.log(result);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md

@@ -0,0 +1,63 @@
+---
+id: 587d7b86367417b2b2512b3d
+title: Impedire cicli infiniti con una condizione di chiusura valida
+challengeType: 1
+forumTopicId: 301192
+dashedName: prevent-infinite-loops-with-a-valid-terminal-condition
+---
+
+# --description--
+
+L'ultimo argomento è il temuto ciclo infinito. I cicli sono ottimi strumenti quando hai bisogno che il tuo programma esegua un blocco di codice un certo numero di volte o fino a quando una condizione è soddisfatta, ma hanno bisogno di una condizione di chiusura che termini le iterazioni. È probabile che i cicli infiniti facciano congelare o crashare il browser, e che causino un caos generale nell'esecuzione del programma, cosa che nessuno vuole.
+
+C'era l'esempio di un ciclo infinito nell'introduzione di questa sezione - non aveva alcuna condizione di chiusura per uscire dal ciclo `while` dentro `loopy()`. NON chiamare questa funzione!
+
+```js
+function loopy() {
+  while(true) {
+    console.log("Hello, world!");
+  }
+}
+```
+
+È compito del programmatore garantire che la condizione di uscita, che dice al programma quando uscire dal ciclo, venga raggiunta. Un errore sta nell'incrementare o decrementare una variabile contatore nella direzione sbagliata rispetto alla condizione di uscita. Un altro è il ripristino accidentale di una variabile contatore o indice all'interno del codice del ciclo, invece di incrementarla o diminuirla.
+
+# --instructions--
+
+La funzione `myFunc()` contiene un ciclo infinito perché la condizione terminale `i != 4` non sarà mai valutata come `false` (interrompendo così il ciclo) - `i` incrementerà di 2 ad ogni passo, e salterà al di là di 4, dal momento che `i` parte con un numero dispari. Correggi l'operatore di confronto nella condizione di uscita in modo che il ciclo funzioni solo per `i` minore o uguale a 4.
+
+# --hints--
+
+Il tuo codice dovrebbe cambiare l'operatore di confronto nella condizione di chiusura (la parte centrale) del ciclo `for`.
+
+```js
+assert(code.match(/i\s*?<=\s*?4;/g).length == 1);
+```
+
+Il tuo codice dovrebbe aggiustare l'operatore di confronto nella condizione di chiusura del ciclo.
+
+```js
+assert(!code.match(/i\s*?!=\s*?4;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myFunc() {
+  for (let i = 1; i != 4; i += 2) {
+    console.log("Still going!");
+  }
+}
+```
+
+# --solutions--
+
+```js
+function myFunc() {
+ for (let i = 1; i <= 4; i += 2) {
+   console.log("Still going!");
+ }
+}
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md

@@ -0,0 +1,73 @@
+---
+id: 587d7b83367417b2b2512b37
+title: Comprendere le differenze tra la console di freeCodeCamp e quella del Browser
+challengeType: 1
+forumTopicId: 301193
+dashedName: understanding-the-differences-between-the-freecodecamp-and-browser-console
+---
+
+# --description--
+
+Potresti aver notato che alcune sfide JavaScript di freeCodeCamp includono la propria console. Questa console si comporta in modo leggermente diverso rispetto alla console del browser utilizzata nell'ultima sfida.
+
+La seguente sfida è destinata a evidenziare la differenza principale tra la console di freeCodeCamp e la console del browser.
+
+Quando eseguirai del JavaScript ordinario, la console del browser ti farà visualizzare i comandi `console.log()` per il numero esatto di volte che li hai chiamati.
+
+La console freeCodeCamp ti farà visualizzare i comandi `console.log()` poco tempo dopo che l'editor rileva un cambiamento nello script, così come durante i test.
+
+La console freeCodeCamp viene cancellata prima che i test vengano eseguiti e, per evitare spam, visualizza i log solo durante il primo test (cfr. la nota sottostante per le eccezioni).
+
+Se desideri vedere ogni log per ogni test, esegui i test e apri la console del browser. Se preferisci usare la console del browser, e vuoi che imiti la console di freeCodeCamp, posiziona il comando `console.clear()` prima di qualsiasi altra chiamata `console`, per pulire la console del browser.
+
+**Nota:** le chiamate `console.log` all'interno delle funzioni vengono visualizzate sulla console di freeCodeCamp ogni volta che queste funzioni vengono chiamate. Questo può aiutare a fare il debug delle funzioni che vengono chiamate nel test.
+
+# --instructions--
+
+Innanzitutto, usa `console.log` per visualizzare la variabile `output`. Quindi, utilizza `console.clear` per pulire la console del browser.
+
+# --hints--
+
+Dovresti usare `console.clear()` per cancellare la console del browser.
+
+```js
+assert(
+  __helpers
+    .removeWhiteSpace(code)
+    .match(/console.clear\(\)/)
+);
+```
+
+Dovresti usare `console.log()` per visualizzare la variabile `output`.
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/console\.log\(output\)/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Open your browser console.
+let output = "Get this to log once in the freeCodeCamp console and twice in the browser console";
+// Use console.log() to print the output variable.
+
+// Run the tests to see the difference between the two consoles.
+
+// Now, add console.clear() before your console.log() to clear the browser console, and pass the tests.
+```
+
+# --solutions--
+
+```js
+// Open your browser console.
+let output = "Get this to log once in the freeCodeCamp console and twice in the browser console";
+// Use console.log() to print the output variable.
+console.clear();
+console.log(output);
+
+// Run the tests to see the difference between the two consoles.
+
+// Now, add console.clear() before your console.log() to clear the browser console, and pass the tests.
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md

@@ -0,0 +1,89 @@
+---
+id: 587d7b86367417b2b2512b3c
+title: Usare cautela quando reinizializzi delle variabili all'interno di un ciclo
+challengeType: 1
+forumTopicId: 301194
+dashedName: use-caution-when-reinitializing-variables-inside-a-loop
+---
+
+# --description--
+
+A volte è necessario salvare le informazioni, i contatori degli incrementi o reimpostare le variabili all'interno di un ciclo. Un potenziale problema è quando le variabili o devono essere reinizializzate e non lo sono, o viceversa. Questo è particolarmente pericoloso se si ripristina accidentalmente la variabile utilizzata per la condizione di uscita, causando un ciclo infinito.
+
+Stampare i valori delle variabili ad ogni passo del tuo ciclo utilizzando `console.log()` può scovare un'azione buggata relativa al ripristino, o al mancato ripristino di una variabile.
+
+# --instructions--
+
+La seguente funzione dovrebbe creare un array bidimensionale con `m` righe e `n` colonne di zeri. Purtroppo, non produce l'output previsto perché la variabile `row` non viene reinizializzata (impostata nuovamente a un array vuoto) nel loop esterno. Aggiusta il codice in modo che restituisca l'array 3x2 di zeri corretto, che appare come `[[0, 0], [0, 0], [0, 0]]`.
+
+# --hints--
+
+Il tuo codice dovrebbe impostare la variabile `matrix` su un array contenente 3 righe di 2 colonne di zeri ciascuna.
+
+```js
+assert(JSON.stringify(matrix) == '[[0,0],[0,0],[0,0]]');
+```
+
+La variabile `matrix` dovrebbe avere 3 righe.
+
+```js
+assert(matrix.length == 3);
+```
+
+La variabile `matrix` dovrebbe avere 2 colonne in ogni riga.
+
+```js
+assert(
+  matrix[0].length == 2 && matrix[1].length === 2 && matrix[2].length === 2
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function zeroArray(m, n) {
+  // Creates a 2-D array with m rows and n columns of zeroes
+  let newArray = [];
+  let row = [];
+  for (let i = 0; i < m; i++) {
+    // Adds the m-th row into newArray
+
+    for (let j = 0; j < n; j++) {
+      // Pushes n zeroes into the current row to create the columns
+      row.push(0);
+    }
+    // Pushes the current row, which now has n zeroes in it, to the array
+    newArray.push(row);
+  }
+  return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+```
+
+# --solutions--
+
+```js
+function zeroArray(m, n) {
+ // Creates a 2-D array with m rows and n columns of zeroes
+ let newArray = [];
+ for (let i = 0; i < m; i++) {
+   let row = [];
+   // Adds the m-th row into newArray
+
+   for (let j = 0; j < n; j++) {
+     // Pushes n zeroes into the current row to create the columns
+     row.push(0);
+   }
+   // Pushes the current row, which now has n zeroes in it, to the array
+   newArray.push(row);
+ }
+ return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md

@@ -0,0 +1,54 @@
+---
+id: 587d7b83367417b2b2512b33
+title: Usare la console JavaScript per controllare il valore di una variabile
+challengeType: 1
+forumTopicId: 18372
+dashedName: use-the-javascript-console-to-check-the-value-of-a-variable
+---
+
+# --description--
+
+Sia Chrome che Firefox hanno ottime console JavaScript, note anche come DevTools (strumenti per sviluppatori), per effettuare il debugging del tuo JavaScript.
+
+Puoi trovare gli Strumenti per sviluppatori nel menu di Chrome o la Web Console nel menu di Firefox. Se stai utilizzando un browser diverso, o un telefono cellulare, ti consigliamo vivamente di passare a Firefox o Chrome su desktop.
+
+Il metodo `console.log()`, che "stampa" sulla console l'output di quello che c'è all'interno delle sue parentesi, sarà probabilmente lo strumento di debugging più utile. Posizionarlo in punti strategici nel codice può mostrarti i valori intermedi delle variabili. È buona pratica avere un'idea di cosa dovrebbe essere l'output prima di guardare quello che è. Avere punti di controllo per vedere lo stato dei tuoi calcoli lungo i passaggi del codice ti aiuterà a individuare il problema.
+
+Ecco un esempio per stampare la stringa `Hello world!` sulla console:
+
+```js
+console.log('Hello world!');
+```
+
+# --instructions--
+
+Utilizza il metodo `console.log()` per visualizzare il valore della variabile `a` dove annotato nel codice.
+
+# --hints--
+
+Il tuo codice dovrebbe utilizzare `console.log()` per controllare il valore della variabile `a`.
+
+```js
+assert(code.match(/console\.log\(a\)/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let a = 5;
+let b = 1;
+a++;
+// Only change code below this line
+
+
+let sumAB = a + b;
+console.log(sumAB);
+```
+
+# --solutions--
+
+```js
+var a = 5; console.log(a);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md

@@ -0,0 +1,66 @@
+---
+id: 587d7b84367417b2b2512b34
+title: Usare typeof per controllare il tipo di una variabile
+challengeType: 1
+forumTopicId: 18374
+dashedName: use-typeof-to-check-the-type-of-a-variable
+---
+
+# --description--
+
+È possibile utilizzare `typeof` per controllare la struttura dei dati, o il tipo, di una variabile. Questo è utile nel debugging quando si lavora con più tipi di dati. Se pensi di sommare due numeri, ma uno è in realtà una stringa, i risultati possono essere inaspettati. Gli errori relativi al tipo possono nascondersi nei calcoli o nelle chiamate di funzione. Fai attenzione soprattutto quando accedi e lavori con dati esterni sotto forma di oggetto JavaScript Object Notation (JSON).
+
+Ecco alcuni esempi che usano `typeof`:
+
+```js
+console.log(typeof "");
+console.log(typeof 0);
+console.log(typeof []);
+console.log(typeof {});
+```
+
+Nell'ordine, la console visualizzerà le stringhe `string`, `number`, `object`, e `object`.
+
+JavaScript riconosce sei tipi di dati primitivi (immutabili): `Boolean`, `Null`, `Undefined`, `Number`, `String`, e `Symbol` (introdotto con ES6) e un tipo per gli oggetti mutabili: `Object`. Nota che in JavaScript, gli array sono tecnicamente un tipo di oggetto.
+
+# --instructions--
+
+Aggiungi due istruzioni `console.log()` per controllare il `typeof` di ciascuna delle due variabili `seven` e `three` nel codice.
+
+# --hints--
+
+Il tuo codice dovrebbe utilizzare `typeof` in due istruzioni `console.log()` per controllare il tipo delle variabili.
+
+```js
+assert(code.match(/console\.log\(typeof[\( ].*\)?\)/g).length == 2);
+```
+
+Il tuo codice dovrebbe utilizzare `typeof` per controllare il tipo della variabile `seven`.
+
+```js
+assert(code.match(/typeof[\( ]seven\)?/g));
+```
+
+Il tuo codice dovrebbe utilizzare `typeof` per controllare il tipo della variabile `three`.
+
+```js
+assert(code.match(/typeof[\( ]three\)?/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let seven = 7;
+let three = "3";
+console.log(seven + three);
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let seven = 7;let three = "3";console.log(typeof seven);
+console.log(typeof three);
+```