chore(i18n,learn): processed translations (#45271)

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md

@@ -25,14 +25,12 @@ function equalityTest(myVal) {
 Se `myVal` è uguale a `10`, l'operatore di uguaglianza restituisce `true`, quindi il codice tra le parentesi graffe sarà eseguito, e la funzione restituirà `Equal`. In caso contrario, la funzione restituirà `Not Equal`. Affinché JavaScript possa confrontare due differenti <dfn>tipi di dato</dfn> (per esempio `numbers` e `strings`), deve convertire un tipo in un altro. Questa operazione è nota come conversione implicita. Dopo che è stata fatta, è possibile confrontare i termini come segue:
 
 ```js
-1   ==  1
-1   ==  2
-1   == '1'
-"3" ==  3
+1   ==  1  // true
+1   ==  2  // false
+1   == '1' // true
+"3" ==  3  // true
 ```
 
-Nell'ordine, queste espressioni saranno valutate come `true`, `false`, `true`, e `true`.
-
 # --instructions--
 
 Aggiungi l'operatore di uguaglianza alla riga indicata in modo che la funzione restituisca la stringa `Equal` quando `val` è equivalente a `12`.

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md

@@ -16,17 +16,15 @@ Come l'operatore di uguaglianza, l'operatore di maggioranza convertirà i tipi d
 **Esempi**
 
 ```js
-5   >  3
-7   > '3'
-2   >  3
-'1' >  9
+5   >  3  // true
+7   > '3' // true
+2   >  3  // false
+'1' >  9  // false
 ```
 
-Nell'ordine, queste espressioni saranno valutate come `true`, `true`, `false`, e `false`.
-
 # --instructions--
 
-Aggiungi l'operatore di maggioranza alle linee indicate in modo che istruzioni return abbiano senso.
+Aggiungi l'operatore di maggioranza alle linee indicate in modo che le istruzioni return abbiano senso.
 
 # --hints--
 
@@ -54,7 +52,7 @@ assert(testGreaterThan(11) === 'Over 10');
 assert(testGreaterThan(99) === 'Over 10');
 ```
 
-`testGreaterThan(100)` deve restituire la stringa `Over 10`
+`testGreaterThan(100)` dovrebbe restituire la stringa `Over 10`
 
 ```js
 assert(testGreaterThan(100) === 'Over 10');

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md

@@ -16,27 +16,25 @@ Come l'operatore di uguaglianza, l'operatore di maggioranza o uguaglianza conver
 **Esempi**
 
 ```js
-6   >=  6
-7   >= '3'
-2   >=  3
-'7' >=  9
+6   >=  6  // true
+7   >= '3' // true
+2   >=  3  // false
+'7' >=  9  // false
 ```
 
-Nell'ordine, queste espressioni saranno valutate `true`, `true`, `false`, e `false`.
-
 # --instructions--
 
 Aggiungi l'operatore di maggioranza o uguaglianza alle linee indicate in modo che le istruzioni return abbiano senso.
 
 # --hints--
 
-`testGreaterOrEqual(0)` dovrebbe restituire la stringa `less than10`
+`testGreaterOrEqual(0)` dovrebbe restituire la stringa `Less than 10`
 
 ```js
 assert(testGreaterOrEqual(0) === 'Less than 10');
 ```
 
-`testGreaterOrEqual(9)` dovrebbe restituire la stringa `less than 10`
+`testGreaterOrEqual(9)` dovrebbe restituire la stringa `Less than 10`
 
 ```js
 assert(testGreaterOrEqual(9) === 'Less than 10');

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md

@@ -14,18 +14,16 @@ L'operatore di disuguaglianza (`!=`) è l'opposto dell'operatore di uguaglianza.
 **Esempi**
 
 ```js
-1 !=  2
-1 != "1"
-1 != '1'
-1 != true
-0 != false
+1 !=  2    // true
+1 != "1"   // false
+1 != '1'   // false
+1 != true  // false
+0 != false // false
 ```
 
-Nell'ordine, queste espressioni saranno valutate `true`, `false`, `false`, `false` e `false`.
-
 # --instructions--
 
-Aggiungi l'operatore di disuguaglianza `!=` nella condizione dell' `if` in modo che la funzione restituisca la stringa `Not Equal` quando `val` non equivale a `99`.
+Aggiungi l'operatore di disuguaglianza `!=` nella condizione dell'`if` in modo che la funzione restituisca la stringa `Not Equal` quando `val` non è equivalente a `99`.
 
 # --hints--
 

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md

@@ -14,15 +14,13 @@ L'operatore di minoranza (`<`) confronta i valori di due numeri. Se il numero a
 **Esempi**
 
 ```js
-2   < 5
-'3' < 7
-5   < 5
-3   < 2
-'8' < 4
+2   < 5 // true
+'3' < 7 // true
+5   < 5 // false
+3   < 2 // false
+'8' < 4 // false
 ```
 
-Nell'ordine, queste espressioni saranno valutate `true`, `true`, `false`, `false`, e `false`.
-
 # --instructions--
 
 Aggiungi l'operatore di minoranza alle linee indicate in modo che le istruzioni return abbiano senso.

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md

@@ -14,15 +14,13 @@ L'operatore di minoranza o uguaglianza (`<=`) confronta i valori di due numeri.
 **Esempi**
 
 ```js
-4   <= 5
-'7' <= 7
-5   <= 5
-3   <= 2
-'8' <= 4
+4   <= 5 // true
+'7' <= 7 // true
+5   <= 5 // true
+3   <= 2 // false
+'8' <= 4 // false
 ```
 
-Nell'ordine, queste espressioni saranno valutate `true`, `true`, `true`, `false` e `false`.
-
 # --instructions--
 
 Aggiungi l'operatore di minoranza o uguaglianza alle linee indicate in modo che le dichiarazioni return abbiano senso.
@@ -59,7 +57,7 @@ assert(testLessOrEqual(23) === 'Smaller Than or Equal to 24');
 assert(testLessOrEqual(24) === 'Smaller Than or Equal to 24');
 ```
 
-`testLessOrEqual(25)` dovrebbe restituire la stringa `more than 24`
+`testLessOrEqual(25)` dovrebbe restituire la stringa `More Than 24`
 
 ```js
 assert(testLessOrEqual(25) === 'More Than 24');

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md

@@ -16,12 +16,10 @@ Se i valori confrontati hanno tipi diversi, sono considerati ineguali, e l'opera
 **Esempi**
 
 ```js
-3 ===  3
-3 === '3'
+3 ===  3  // true
+3 === '3' // false
 ```
 
-Queste condizioni restituiranno rispettivamente `true` e `false`.
-
 Nel secondo esempio, `3` è un tipo `Number` e `'3'` è un tipo `String`.
 
 # --instructions--
@@ -48,7 +46,7 @@ assert(testStrict(7) === 'Equal');
 assert(testStrict('7') === 'Not Equal');
 ```
 
-È necessario utilizzare l'operatore `===`
+Dovresti usare l'operatore `===`
 
 ```js
 assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md

@@ -14,13 +14,11 @@ L'operatore di disuguaglianza stretta (`!==`) è l'opposto logico dell'operatore
 **Esempi**
 
 ```js
-3 !==  3
-3 !== '3'
-4 !==  3
+3 !==  3  // false
+3 !== '3' // true
+4 !==  3  // true
 ```
 
-Nell'ordine, queste espressioni restituiscono `false`,`true` e `true`.
-
 # --instructions--
 
 Aggiungi l'operatore di disuguaglianza stretta all'istruzione `if` in modo che la funzione restituisca la stringa `Not Equal` quando `val` non è strettamente uguale a `17`

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md

@@ -25,7 +25,7 @@ Esempio:
 const ourStr = "I come first. " + "I come second.";
 ```
 
-La stringa `I come first. I come second.` sarebbe visualizzata nella console.
+La stringa `I come first. I come second.` sarà mostrata nella console.
 # --instructions--
 
 Costruisci `myStr` dalle stringhe `This is the start.` e `This is the end.` usando l'operatore `+`. Assicurati di includere uno spazio tra le due stringhe.