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/regular-expressions/check-for-all-or-none.md

@@ -0,0 +1,77 @@
+---
+id: 587d7dba367417b2b2512ba8
+title: Riconoscere tutto o niente
+challengeType: 1
+forumTopicId: 301338
+dashedName: check-for-all-or-none
+---
+
+# --description--
+
+A volte i pattern che vuoi cercare possono avere parti che possono esistere o meno. Del resto può essere importante verificarle comunque.
+
+È possibile specificare la possibile esistenza di un elemento con un punto interrogativo, `?`. Questo controlla la presenza di zero o di uno dell'elemento precedente. Puoi pensare a questo simbolo come a un modo per dire che l'elemento precedente è opzionale.
+
+Ad esempio, ci sono lievi differenze in inglese americano e britannico e si può utilizzare il punto interrogativo per trovare entrambe le ortografie.
+
+```js
+let american = "color";
+let british = "colour";
+let rainbowRegex= /colou?r/;
+rainbowRegex.test(american);
+rainbowRegex.test(british);
+```
+
+Entrambi gli usi del metodo `test` restituiranno `true`.
+
+# --instructions--
+
+Cambia l'espressione regolare `favRegex` in modo da riconoscere sia la versione inglese Americana (`favorite`) che quella Britannica (`favourite`) della parola.
+
+# --hints--
+
+La tua espressione regolare dovrebbe usare il simbolo opzionale `?`.
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.source.match(/\?/).length > 0);
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `favorite`
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.test('favorite'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `favourite`
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.test('favourite'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `fav`
+
+```js
+favRegex.lastIndex = 0;
+assert(!favRegex.test('fav'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let favWord = "favorite";
+let favRegex = /change/; // Change this line
+let result = favRegex.test(favWord);
+```
+
+# --solutions--
+
+```js
+let favWord = "favorite";
+let favRegex = /favou?r/;
+let result = favRegex.test(favWord);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-mixed-grouping-of-characters.md

@@ -0,0 +1,90 @@
+---
+id: 5c3dda8b4d8df89bea71600f
+title: Riconoscere gruppi misti di caratteri
+challengeType: 1
+forumTopicId: 301339
+dashedName: check-for-mixed-grouping-of-characters
+---
+
+# --description--
+
+A volte vogliamo controllare la presenza di gruppi di caratteri usando un'espressione regolare e per farlo usiamo le parentesi `()`.
+
+Se vuoi trovare `Penguin` o `Pumpkin` in una stringa, puoi utilizzare la seguente espressione regolare: `/P(engu|umpk)in/g`
+
+Quindi controllare se i gruppi di stringhe desiderati sono nella stringa di test utilizzando il metodo `test()`.
+
+```js
+let testStr = "Pumpkin";
+let testRegex = /P(engu|umpk)in/;
+testRegex.test(testStr);
+```
+
+Il metodo `test` qui restituirà `true`.
+
+# --instructions--
+
+Sistema l'espressione regolare in modo che riconosca i nomi di `Franklin Roosevelt` o `Eleanor Roosevelt` facendo distinzione tra maiuscole e minuscole e permetta i secondi nomi.
+
+Quindi correggi il codice in modo che l'espressione regolare sia usata su `myString` e venga restituito `true` o `false` a seconda della corrispondenza della regex.
+
+# --hints--
+
+La tua espressione regolare `myRegex` dovrebbe restituire `true` per la stringa `Franklin D. Roosevelt`
+
+```js
+myRegex.lastIndex = 0;
+assert(myRegex.test('Franklin D. Roosevelt'));
+```
+
+La tua espressione regolare `myRegex` dovrebbe restituire `true` per la stringa `Eleanor Roosevelt`
+
+```js
+myRegex.lastIndex = 0;
+assert(myRegex.test('Eleanor Roosevelt'));
+```
+
+La tua espressione regolare `myRegex` dovrebbe restituire `false` per la stringa `Franklin Rosevelt`
+
+```js
+myRegex.lastIndex = 0;
+assert(!myRegex.test('Franklin Rosevelt'));
+```
+
+La tua espressione regolare `myRegex` dovrebbe restituire `false` per la stringa `Frank Roosevelt`
+
+```js
+myRegex.lastIndex = 0;
+assert(!myRegex.test('Frank Roosevelt'));
+```
+
+Dovresti usare `.test()` per testare l'espressione regolare.
+
+```js
+assert(code.match(/myRegex.test\(\s*myString\s*\)/));
+```
+
+Il tuo risultato dovrebbe restituire `true`.
+
+```js
+assert(result === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "Eleanor Roosevelt";
+let myRegex = /False/; // Change this line
+let result = false; // Change this line
+// After passing the challenge experiment with myString and see how the grouping works
+```
+
+# --solutions--
+
+```js
+let myString = "Eleanor Roosevelt";
+let myRegex = /(Franklin|Eleanor).*Roosevelt/;
+let result = myRegex.test(myString);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/extract-matches.md

@@ -0,0 +1,73 @@
+---
+id: 587d7db4367417b2b2512b92
+title: Estrarre le corrispondenze
+challengeType: 1
+forumTopicId: 301340
+dashedName: extract-matches
+---
+
+# --description--
+
+Finora, hai solo verificato se un pattern esiste o meno all'interno di una stringa. Puoi anche estrarre le corrispondenze che hai trovato con il metodo `.match()`.
+
+Per usare il metodo `.match()`, applica il metodo su una stringa e passa l'espressione regolare tra parentesi.
+
+Ecco un esempio:
+
+```js
+"Hello, World!".match(/Hello/);
+let ourStr = "Regular expressions";
+let ourRegex = /expressions/;
+ourStr.match(ourRegex);
+```
+
+Qui la prima corrispondenza (`match`) restituirà `["Hello"]` e la seconda restituirà `["expressions"]`.
+
+Nota che la sintassi di `.match` è il "contrario" del metodo `.test` che hai utilizzato finora:
+
+```js
+'string'.match(/regex/);
+/regex/.test('string');
+```
+
+# --instructions--
+
+Applica il metodo `.match()` per estrarre la stringa `coding`.
+
+# --hints--
+
+Il risultato (`result`) dovrebbe contenere la stringa `coding`
+
+```js
+assert(result.join() === 'coding');
+```
+
+La tua espressione regolare `codingRegex` dovrebbe cercare la stringa `coding`
+
+```js
+assert(codingRegex.source === 'coding');
+```
+
+Dovresti usare il metodo `.match()`.
+
+```js
+assert(code.match(/\.match\(.*\)/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let extractStr = "Extract the word 'coding' from this string.";
+let codingRegex = /change/; // Change this line
+let result = extractStr; // Change this line
+```
+
+# --solutions--
+
+```js
+let extractStr = "Extract the word 'coding' from this string.";
+let codingRegex = /coding/; // Change this line
+let result = extractStr.match(codingRegex); // Change this line
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching.md

@@ -0,0 +1,61 @@
+---
+id: 587d7db6367417b2b2512b9b
+title: Trovare caratteri con la corrispondenza lazy
+challengeType: 1
+forumTopicId: 301341
+dashedName: find-characters-with-lazy-matching
+---
+
+# --description--
+
+Nelle espressioni regolari, una corrispondenza <dfn>greedy</dfn> (avida) trova la parte più lunga possibile di una stringa che si adatta al pattern dell'espressione regolare e la restituisce. L'alternativa è chiamata corrispondenza <dfn>lazy</dfn> (pigra), che trova la parte più piccola possibile della stringa che soddisfa il modello dell'espressione regolare.
+
+Puoi applicare l'espressione regolare `/t[a-z]*i/` alla stringa `"titanic"`. Questa espressione regolare è fondamentalmente un pattern che inizia con `t`, termina con `i`e ha alcune lettere nel mezzo.
+
+Le espressioni regolari sono di default greedy, quindi la corrispondenza restituirà `["titani"]`. Trova la sotto-stringa più grande possibile che si adatti al pattern.
+
+Puoi usare il carattere `?` per passare alla corrispondenza lazy. `"titanic"` passato attraverso l'espressione regolare modificata di `/t[a-z]*?i/` restituisce `["ti"]`.
+
+**Nota:** L'analisi dell'HTML con le espressioni regolari dovrebbe essere evitata, ma il pattern che corrisponde a una stringa HTML con le espressioni regolari va del tutto bene.
+
+# --instructions--
+
+Correggi l'espressione regolare `/<.*>/` in modo che restituisca il tag HTML `<h1>` e non il testo `"<h1>Winter is coming</h1>"`. Ricorda che il carattere jolly `.` in un'espressione regolare corrisponde a qualsiasi carattere.
+
+# --hints--
+
+La variabile `result` dovrebbe essere un array con `<h1>` al suo interno
+
+```js
+assert(result[0] == '<h1>');
+```
+
+`myRegex` dovrebbe usare la corrispondenza lazy
+
+```js
+assert(/\?/g.test(myRegex));
+```
+
+`myRegex` non dovrebbe includere la stringa `h1`
+
+```js
+assert(!myRegex.source.match('h1'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let text = "<h1>Winter is coming</h1>";
+let myRegex = /<.*>/; // Change this line
+let result = text.match(myRegex);
+```
+
+# --solutions--
+
+```js
+let text = "<h1>Winter is coming</h1>";
+let myRegex = /<.*?>/; // Change this line
+let result = text.match(myRegex);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match.md

@@ -0,0 +1,85 @@
+---
+id: 587d7db4367417b2b2512b93
+title: Trovare altre corrispondenze oltre alla prima
+challengeType: 1
+forumTopicId: 301342
+dashedName: find-more-than-the-first-match
+---
+
+# --description--
+
+Finora, sei stato in grado di estrarre o cercare un pattern una volta sola.
+
+```js
+let testStr = "Repeat, Repeat, Repeat";
+let ourRegex = /Repeat/;
+testStr.match(ourRegex);
+```
+
+Qui `match` restituirà `["Repeat"]`.
+
+Per cercare o estrarre un pattern più di una volta, è possibile utilizzare il flag `g`.
+
+```js
+let repeatRegex = /Repeat/g;
+testStr.match(repeatRegex);
+```
+
+E qui `match` restituisce il valore `["Repeat", "Repeat", "Repeat"]`
+
+# --instructions--
+
+Utilizzando l'espressione regolare `starRegex`, trova ed estrai entrambe le parole `Twinkle` dalla stringa `twinkleStar`.
+
+**Nota**  
+Puoi avere più flag nella tua espressione regolare, come ad esempio in `/search/gi`
+
+# --hints--
+
+La tua espressione regolare `starRegex` dovrebbe utilizzare il flag globale `g`
+
+```js
+assert(starRegex.flags.match(/g/).length == 1);
+```
+
+La tua espressione regolare `starRegex` dovrebbe utilizzare il flag per l'indifferenza a maiuscole e minuscole `i`
+
+```js
+assert(starRegex.flags.match(/i/).length == 1);
+```
+
+La tua corrispondenza dovrebbe riconoscere entrambe le occorrenze della parola `Twinkle`
+
+```js
+assert(
+  result.sort().join() ==
+    twinkleStar
+      .match(/twinkle/gi)
+      .sort()
+      .join()
+);
+```
+
+La tua corrispondenza `result` dovrebbe avere due elementi in essa.
+
+```js
+assert(result.length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let twinkleStar = "Twinkle, twinkle, little star";
+let starRegex = /change/; // Change this line
+let result = twinkleStar; // Change this line
+```
+
+# --solutions--
+
+```js
+let twinkleStar = "Twinkle, twinkle, little star";
+let starRegex = /twinkle/gi;
+let result = twinkleStar.match(starRegex);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md

@@ -0,0 +1,106 @@
+---
+id: 587d7db7367417b2b2512b9c
+title: Trovare uno o più criminali in una caccia
+challengeType: 1
+forumTopicId: 301343
+dashedName: find-one-or-more-criminals-in-a-hunt
+---
+
+# --description--
+
+È ora di fare un po' di pausa e testare le tue nuove abilità di scrittura di espressioni regolari. Un gruppo di criminali è evaso dalla prigione ed è scappato via, ma non sai quanti. Tuttavia, sai che stanno vicini quando sono in mezzo ad altre persone. Tu sei responsabile della ricerca di tutti i criminali contemporaneamente.
+
+Ecco un esempio per rivedere come farlo:
+
+L'espressione regolare `/z+/` riconosce la lettera `z` quando appare una o più volte in una riga. Troverà corrispondenze in tutte le seguenti stringhe:
+
+```js
+"z"
+"zzzzzz"
+"ABCzzzz"
+"zzzzABC"
+"abczzzzzzzzzzzzzzzzzzzzzabc"
+```
+
+Ma non trova corrispondenze nelle seguenti stringhe poiché non ci sono caratteri `z`:
+
+```js
+""
+"ABC"
+"abcabc"
+```
+
+# --instructions--
+
+Scrivi un'espressione regolare greedy che trovi uno o più criminali all'interno di un gruppo di altre persone. Un criminale è rappresentato dalla lettera maiuscola `C`.
+
+# --hints--
+
+La tua espressione regolare dovrebbe riconoscere un criminale (`C`) nella stringa `C`
+
+```js
+assert('C'.match(reCriminals) && 'C'.match(reCriminals)[0] == 'C');
+```
+
+La tua espressione regolare dovrebbe riconoscere due criminali (`CC`) nella stringa `CC`
+
+```js
+assert('CC'.match(reCriminals) && 'CC'.match(reCriminals)[0] == 'CC');
+```
+
+La tua espressione regolare dovrebbe riconoscere tre criminali (`CCC`) nella stringa `P1P5P4CCCcP2P6P3`.
+
+```js
+assert(
+  'P1P5P4CCCcP2P6P3'.match(reCriminals) &&
+    'P1P5P4CCCcP2P6P3'.match(reCriminals)[0] == 'CCC'
+);
+```
+
+La tua espressione regolare dovrebbe riconoscere cinque criminali (`CCCCC`) nella stringa `P6P2P7P4P5CCCCCP3P1`
+
+```js
+assert(
+  'P6P2P7P4P5CCCCCP3P1'.match(reCriminals) &&
+    'P6P2P7P4P5CCCCCP3P1'.match(reCriminals)[0] == 'CCCCC'
+);
+```
+
+La tua espressione regolare non dovrebbe riconoscere nessun criminale nella stringa vuota `""`
+
+```js
+assert(!reCriminals.test(''));
+```
+
+La tua espressione regolare non dovrebbe riconoscere nessun criminale nella stringa `P1P2P3`
+
+```js
+assert(!reCriminals.test('P1P2P3'));
+```
+
+La tua espressione regolare dovrebbe riconoscere cinquanta criminali (`CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC`) nella stringa `P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3`.
+
+```js
+assert(
+  'P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3'.match(
+    reCriminals
+  ) &&
+    'P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3'.match(
+      reCriminals
+    )[0] == 'CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let reCriminals = /./; // Change this line
+```
+
+# --solutions--
+
+```js
+let reCriminals = /C+/; // Change this line
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching.md

@@ -0,0 +1,99 @@
+---
+id: 587d7db4367417b2b2512b91
+title: Ignorare le maiuscole nelle corrispondenze
+challengeType: 1
+forumTopicId: 301344
+dashedName: ignore-case-while-matching
+---
+
+# --description--
+
+Fino ad ora, hai guardato alle espressioni regolari per fare dei riconoscimenti letterali di stringhe. Ma a volte, potresti voler trovare corrispondenze senza tener conto delle differenze tra maiuscole e minuscole.
+
+In inglese "case" (o a volte "letter case") è la differenza tra lettere maiuscole e lettere minuscole. Esempi di maiuscole sono `A`, `B`e `C`. Esempi di minuscole sono `a`, `b`e `c`.
+
+È possibile riconoscere entrambi i casi utilizzando quello che è chiamato un flag. Ci sono altri flag, ma qui ti concentrerai sul flag che ignora la differenza tra maiuscole e minuscole - il flag `i`. Puoi usarlo aggiungendolo all'espressione regolare. Un esempio di utilizzo di questo flag è `/ignorecase/i`. Questa espressione regolare può riconoscere le stringhe `ignorecase`, `igNoreCase`, e `IgnoreCase`.
+
+# --instructions--
+
+Scrivi un'espressione regolare `fccRegex` per riconoscere `freeCodeCamp`, indipendentemente dalle maiuscole. La tua espressione regolare non dovrebbe riconoscere alcuna abbreviazione o variazione con gli spazi.
+
+# --hints--
+
+La tua espressione regolare dovrebbe riconoscere la stringa `freeCodeCamp`
+
+```js
+assert(fccRegex.test('freeCodeCamp'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `FreeCodeCamp`
+
+```js
+assert(fccRegex.test('FreeCodeCamp'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `FreecodeCamp`
+
+```js
+assert(fccRegex.test('FreecodeCamp'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `FreeCodecamp`
+
+```js
+assert(fccRegex.test('FreeCodecamp'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `Free Code Camp`
+
+```js
+assert(!fccRegex.test('Free Code Camp'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `FreeCOdeCamp`
+
+```js
+assert(fccRegex.test('FreeCOdeCamp'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `FCC`
+
+```js
+assert(!fccRegex.test('FCC'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `FrEeCoDeCamp`
+
+```js
+assert(fccRegex.test('FrEeCoDeCamp'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `FrEeCodECamp`
+
+```js
+assert(fccRegex.test('FrEeCodECamp'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `FReeCodeCAmp`
+
+```js
+assert(fccRegex.test('FReeCodeCAmp'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "freeCodeCamp";
+let fccRegex = /change/; // Change this line
+let result = fccRegex.test(myString);
+```
+
+# --solutions--
+
+```js
+let myString = "freeCodeCamp";
+let fccRegex = /freecodecamp/i; // Change this line
+let result = fccRegex.test(myString);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities.md

@@ -0,0 +1,83 @@
+---
+id: 587d7db4367417b2b2512b90
+title: Riconoscere una stringa letterale con diverse possibilità
+challengeType: 1
+forumTopicId: 301345
+dashedName: match-a-literal-string-with-different-possibilities
+---
+
+# --description--
+
+Utilizzando espressioni regolari come `/coding/`, puoi cercare il pattern `coding` in un'altra stringa.
+
+Questo è utile per cercare singole stringhe, ma è limitato a un solo pattern. È possibile cercare più pattern utilizzando l'operatore `alternation` o `OR`: `|`.
+
+Questo operatore riconosce sia il pattern prima che quello dopo di esso. Ad esempio, se vuoi riconoscere le stringhe `yes` o `no`, l'espressione regolare che ti serve è `/yes|no/`.
+
+Puoi anche cercare più di due pattern. Puoi farlo aggiungendo altri pattern con più operatori `OR` che li separano, come `/yes|no|maybe/`.
+
+# --instructions--
+
+Completa l'espressione regolare `petRegex` per riconoscere gli animali domestici `dog`, `cat`, `bird` o `fish`.
+
+# --hints--
+
+La tua espressione regolare `petRegex` dovrebbe restituire `true` per la stringa `John has a pet dog.`
+
+```js
+assert(petRegex.test('John has a pet dog.'));
+```
+
+La tua espressione regolare `petRegex` dovrebbe restituire `false` per la stringa `Emma has a pet rock.`
+
+```js
+assert(!petRegex.test('Emma has a pet rock.'));
+```
+
+La tua espressione regolare `petRegex` dovrebbe restituire `true` per la stringa `Emma has a pet bird.`
+
+```js
+assert(petRegex.test('Emma has a pet bird.'));
+```
+
+La tua espressione regolare `petRegex` dovrebbe restituire `true` per la stringa `Liz has a pet cat.`
+
+```js
+assert(petRegex.test('Liz has a pet cat.'));
+```
+
+La tua espressione regolare `petRegex` dovrebbe restituire `false` per la stringa `Kara has a pet dolphin.`
+
+```js
+assert(!petRegex.test('Kara has a pet dolphin.'));
+```
+
+La tua espressione regolare `petRegex` dovrebbe restituire `true` per la stringa `Alice has a pet fish.`
+
+```js
+assert(petRegex.test('Alice has a pet fish.'));
+```
+
+La tua espressione regolare `petRegex` dovrebbe restituire `false` per la stringa `Jimmy has a pet computer.`
+
+```js
+assert(!petRegex.test('Jimmy has a pet computer.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let petString = "James has a pet cat.";
+let petRegex = /change/; // Change this line
+let result = petRegex.test(petString);
+```
+
+# --solutions--
+
+```js
+let petString = "James has a pet cat.";
+let petRegex = /dog|cat|bird|fish/; // Change this line
+let result = petRegex.test(petString);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers.md

@@ -0,0 +1,98 @@
+---
+id: 587d7db7367417b2b2512b9f
+title: Riconoscere tutte le lettere e i numeri
+challengeType: 1
+forumTopicId: 301346
+dashedName: match-all-letters-and-numbers
+---
+
+# --description--
+
+Usando le classi carattere, sei stato in grado di cercare tutte le lettere dell'alfabeto con `[a-z]`. Questo tipo di classe di caratteri è così comune da avere una scorciatoia, anche se riconosce alcuni caratteri in più.
+
+La classe di caratteri più vicina al riconoscimento dell'alfabeto in JavaScript è `\w`. Questa scorciatoia è uguale a `[A-Za-z0-9_]`. Questa classe di caratteri riconosce le lettere maiuscole e minuscole più i numeri. Nota che questa classe di caratteri include anche il carattere underscore (`_`).
+
+```js
+let longHand = /[A-Za-z0-9_]+/;
+let shortHand = /\w+/;
+let numbers = "42";
+let varNames = "important_var";
+longHand.test(numbers);
+shortHand.test(numbers);
+longHand.test(varNames);
+shortHand.test(varNames);
+```
+
+Tutte e quattro queste chiamate di `test` restituiranno `true`.
+
+Queste scorciatoie di classi di caratteri sono note anche come <dfn>classi di caratteri abbreviate</dfn>.
+
+# --instructions--
+
+Usa la classe di caratteri abbreviata `\w` per contare il numero di caratteri alfanumerici in varie citazioni e stringhe.
+
+# --hints--
+
+La tua espressione regolare dovrebbe usare il flag global.
+
+```js
+assert(alphabetRegexV2.global);
+```
+
+La tua espressione regolare dovrebbe usare la scorciatoia di carattere `\w` per riconoscere tutti i caratteri alfanumerici.
+
+```js
+assert(/\\w/.test(alphabetRegexV2.source));
+```
+
+La tua espressione regolare dovrebbe trovare 31 caratteri alfanumerici nella stringa `The five boxing wizards jump quickly.`
+
+```js
+assert(
+  'The five boxing wizards jump quickly.'.match(alphabetRegexV2).length === 31
+);
+```
+
+La tua espressione regolare dovrebbe trovare 32 caratteri alfanumerici nella stringa `Pack my box with five dozen liquor jugs.`
+
+```js
+assert(
+  'Pack my box with five dozen liquor jugs.'.match(alphabetRegexV2).length ===
+    32
+);
+```
+
+La tua espressione regolare dovrebbe trovare 30 caratteri alfanumerici nella stringa `How vexingly quick daft zebras jump!`
+
+```js
+assert(
+  'How vexingly quick daft zebras jump!'.match(alphabetRegexV2).length === 30
+);
+```
+
+La tua espressione regolare dovrebbe trovare 36 caratteri alfanumerici nella stringa `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
+
+```js
+assert(
+  '123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.'.match(alphabetRegexV2)
+    .length === 36
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let alphabetRegexV2 = /change/; // Change this line
+let result = quoteSample.match(alphabetRegexV2).length;
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let alphabetRegexV2 = /\w/g; // Change this line
+let result = quoteSample.match(alphabetRegexV2).length;
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.md

@@ -0,0 +1,85 @@
+---
+id: 587d7db8367417b2b2512ba1
+title: Riconoscere tutti i caratteri non numerici
+challengeType: 1
+forumTopicId: 301347
+dashedName: match-all-non-numbers
+---
+
+# --description--
+
+L'ultima sfida ha mostrato come cercare cifre usando la scorciatoia `\d` con una `d` minuscola. Puoi anche cercare dei caratteri non numerici usando una scorciatoia simile che usa invece una `D` maiuscola.
+
+La scorciatoia per cercare caratteri non numerici è `\D`. Questa corrisponde alla classe di caratteri `[^0-9]`, che cerca un singolo carattere che non sia un numero compreso tra zero e nove.
+
+# --instructions--
+
+Usa la classe di caratteri abbreviata `\D` per contare quanti caratteri non numerici sono presenti nei titoli dei film.
+
+# --hints--
+
+La tua espressione regolare dovrebbe usare il carattere scorciatoia per riconoscere caratteri non numerici
+
+```js
+assert(/\\D/.test(noNumRegex.source));
+```
+
+La tua espressione regolare dovrebbe usare il flag global.
+
+```js
+assert(noNumRegex.global);
+```
+
+La tua espressione regolare non dovrebbe trovare caratteri non numerici nella stringa `9`.
+
+```js
+assert('9'.match(noNumRegex) == null);
+```
+
+La tua espressione regolare dovrebbe trovare 6 caratteri non numerici nella stringa `Catch 22`.
+
+```js
+assert('Catch 22'.match(noNumRegex).length == 6);
+```
+
+La tua espressione regolare dovrebbe trovare 11 caratteri non numerici nella stringa `101 Dalmatians`.
+
+```js
+assert('101 Dalmatians'.match(noNumRegex).length == 11);
+```
+
+La tua espressione regolare dovrebbe trovare 15 caratteri non numerici nella stringa `One, Two, Three`.
+
+```js
+assert('One, Two, Three'.match(noNumRegex).length == 15);
+```
+
+La tua espressione regolare dovrebbe trovare 12 caratteri non numerici nella stringa `21 Jump Street`.
+
+```js
+assert('21 Jump Street'.match(noNumRegex).length == 12);
+```
+
+La tua espressione regolare dovrebbe trovare 17 caratteri non numerici nella stringa `2001: A Space Odyssey`.
+
+```js
+assert('2001: A Space Odyssey'.match(noNumRegex).length == 17);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let noNumRegex = /change/; // Change this line
+let result = movieName.match(noNumRegex).length;
+```
+
+# --solutions--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let noNumRegex = /\D/g; // Change this line
+let result = movieName.match(noNumRegex).length;
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers.md

@@ -0,0 +1,85 @@
+---
+id: 5d712346c441eddfaeb5bdef
+title: Riconoscere tutti i numeri
+challengeType: 1
+forumTopicId: 18181
+dashedName: match-all-numbers
+---
+
+# --description--
+
+Hai imparato le scorciatoie per i pattern di stringhe comuni, come quello per i caratteri alfanumerici. Un altro pattern comune cerca solo cifre o numeri.
+
+La scorciatoia per cercare caratteri numerici è `\d`, con una `d` minuscola. Questo corrisponde alla classe di caratteri `[0-9]`, che cerca un singolo carattere di qualsiasi numero tra zero e nove.
+
+# --instructions--
+
+Usa la classe di caratteri abbreviata `\d` per contare quante cifre ci sono nei titoli dei film. I numeri scritti ("six" invece di 6) non contano.
+
+# --hints--
+
+La tua espressione regolare dovrebbe usare il carattere scorciatoia per riconoscere le cifre
+
+```js
+assert(/\\d/.test(numRegex.source));
+```
+
+La tua espressione regolare dovrebbe usare il flag global.
+
+```js
+assert(numRegex.global);
+```
+
+La tua espressione regolare dovrebbe trovare una cifra nella stringa `9`.
+
+```js
+assert('9'.match(numRegex).length == 1);
+```
+
+La tua espressione regolare dovrebbe trovare 2 cifre nella stringa `Catch 22`.
+
+```js
+assert('Catch 22'.match(numRegex).length == 2);
+```
+
+La tua espressione regolare dovrebbe trovare 3 cifre nella stringa `101 Dalmatians`.
+
+```js
+assert('101 Dalmatians'.match(numRegex).length == 3);
+```
+
+La tua espressione regolare non dovrebbe trovare cifre nella stringa `One, Two, Three`.
+
+```js
+assert('One, Two, Three'.match(numRegex) == null);
+```
+
+La tua espressione regolare dovrebbe trovare 2 cifre nella stringa `21 Jump Street`.
+
+```js
+assert('21 Jump Street'.match(numRegex).length == 2);
+```
+
+La tua espressione regolare dovrebbe trovare 4 cifre nella stringa `2001: A Space Odyssey`.
+
+```js
+assert('2001: A Space Odyssey'.match(numRegex).length == 4);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let numRegex = /change/; // Change this line
+let result = movieName.match(numRegex).length;
+```
+
+# --solutions--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let numRegex = /\d/g; // Change this line
+let result = movieName.match(numRegex).length;
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period.md

@@ -0,0 +1,119 @@
+---
+id: 587d7db5367417b2b2512b94
+title: Riconoscere qualunque cosa con la wildcard punto
+challengeType: 1
+forumTopicId: 301348
+dashedName: match-anything-with-wildcard-period
+---
+
+# --description--
+
+A volte non conoscerai (o non ne avrai bisogno) i caratteri esatti nei tuoi pattern. Pensare a tutte le parole che riconoscono - diciamo - un errore di ortografia, richiederebbe molto tempo. Per fortuna, puoi risparmiare tempo usando il carattere jolly: `.`
+
+Il carattere jolly `.` riconoscerà qualsiasi carattere. Il carattere jolly è anche chiamato `dot` e `period`. È possibile utilizzare il carattere jolly proprio come qualsiasi altro carattere nell'espressione regolare. Ad esempio, se volessi riconoscere `hug`, `huh`, `hut`, e `hum`, potresti utilizzare l'espressione regolare `/hu./` per far corrispondere tutte e quattro le parole.
+
+```js
+let humStr = "I'll hum a song";
+let hugStr = "Bear hug";
+let huRegex = /hu./;
+huRegex.test(humStr);
+huRegex.test(hugStr);
+```
+
+Entrambe queste chiamate a `test` restituiranno `true`.
+
+# --instructions--
+
+Completa l'espressione regolare `unRegex` in modo che corrisponda alle stringhe `run`, `sun`, `fun`, `pun`, `nun`e `bun`. La tua espressione regolare dovrebbe usare il carattere jolly.
+
+# --hints--
+
+Dovresti usare il metodo `.test()`.
+
+```js
+assert(code.match(/\.test\(.*\)/));
+```
+
+Dovresti usare il carattere jolly nella tua espressione regolare `unRegex`
+
+```js
+assert(/\./.test(unRegex.source));
+```
+
+La tua espressione regolare `unRegex` dovrebbe riconoscere `run` nella stringa `Let us go on a run.`
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Let us go on a run.'));
+```
+
+La tua espressione regolare `unRegex` dovrebbe riconoscere `sun` nella stringa `The sun is out today.`
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('The sun is out today.'));
+```
+
+La tua espressione regolare `unRegex` dovrebbe riconoscere `fun` nella stringa `Coding is a lot of fun.`
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Coding is a lot of fun.'));
+```
+
+La tua espressione regolare `unRegex` dovrebbe riconoscere `pun` nella stringa `Seven days without a pun makes one weak.`
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Seven days without a pun makes one weak.'));
+```
+
+La tua espressione regolare `unRegex` dovrebbe riconoscere `nun` nella stringa `One takes a vow to be a nun.`
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('One takes a vow to be a nun.'));
+```
+
+La tua espressione regolare `unRegex` dovrebbe riconoscere `bun` nella stringa `She got fired from the hot dog stand for putting her hair in a bun.`
+
+```js
+unRegex.lastIndex = 0;
+assert(
+  unRegex.test(
+    'She got fired from the hot dog stand for putting her hair in a bun.'
+  )
+);
+```
+
+La tua espressione regolare `unRegex` non dovrebbe riconoscere la stringa `There is a bug in my code.`
+
+```js
+unRegex.lastIndex = 0;
+assert(!unRegex.test('There is a bug in my code.'));
+```
+
+La tua espressione regolare `unRegex` non dovrebbe riconoscere la stringa `Catch me if you can.`
+
+```js
+unRegex.lastIndex = 0;
+assert(!unRegex.test('Catch me if you can.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let exampleStr = "Let's have fun with regular expressions!";
+let unRegex = /change/; // Change this line
+let result = unRegex.test(exampleStr);
+```
+
+# --solutions--
+
+```js
+let exampleStr = "Let's have fun with regular expressions!";
+let unRegex = /.un/; // Change this line
+let result = unRegex.test(exampleStr);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns.md

@@ -0,0 +1,71 @@
+---
+id: 587d7db7367417b2b2512b9d
+title: Riconoscere i pattern di inizio stringa
+challengeType: 1
+forumTopicId: 301349
+dashedName: match-beginning-string-patterns
+---
+
+# --description--
+
+Le sfide precedenti hanno mostrato che le espressioni regolari possono essere usate per cercare un certo numero di corrispondenze. Sono anche utilizzati per cercare pattern in posizioni specifiche delle stringhe.
+
+In una sfida precedente, hai usato il carattere del cursore (`^`) all'interno di un set di caratteri per creare un set di caratteri negati nella forma `[^thingsThatWillNotBeMatched]`. Al di fuori di un set di caratteri, il cursore viene usato per cercare pattern all'inizio delle stringhe.
+
+```js
+let firstString = "Ricky is first and can be found.";
+let firstRegex = /^Ricky/;
+firstRegex.test(firstString);
+let notFirst = "You can't find Ricky now.";
+firstRegex.test(notFirst);
+```
+
+La prima chiamata a `test` restituirà `true`, mentre la seconda restituirà `false`.
+
+# --instructions--
+
+Usa il carattere cursore in un'espressione regolare per trovare `Cal` solo all'inizio della stringa `rickyAndCal`.
+
+# --hints--
+
+La tua espressione regolare dovrebbe cercare la stringa `Cal` con una lettera maiuscola.
+
+```js
+assert(calRegex.source == '^Cal');
+```
+
+La tua espressione regolare non dovrebbe usare alcun flag.
+
+```js
+assert(calRegex.flags == '');
+```
+
+La tua espressione regolare dovrebbe riconoscere `Cal` all'inizio della stringa.
+
+```js
+assert(calRegex.test('Cal and Ricky both like racing.'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere `Cal` nel mezzo di una stringa.
+
+```js
+assert(!calRegex.test('Ricky and Cal both like racing.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let rickyAndCal = "Cal and Ricky both like racing.";
+let calRegex = /change/; // Change this line
+let result = calRegex.test(rickyAndCal);
+```
+
+# --solutions--
+
+```js
+let rickyAndCal = "Cal and Ricky both like racing.";
+let calRegex = /^Cal/; // Change this line
+let result = calRegex.test(rickyAndCal);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md

@@ -0,0 +1,59 @@
+---
+id: 587d7db6367417b2b2512b99
+title: Riconoscere i caratteri che compaiono una o più volte
+challengeType: 1
+forumTopicId: 301350
+dashedName: match-characters-that-occur-one-or-more-times
+---
+
+# --description--
+
+A volte, è necessario riconoscere un carattere (o un gruppo di caratteri) che appare una o più volte in una riga. Questo significa che esso comprare almeno una volta, e può essere ripetuto.
+
+Puoi usare il carattere `+` per verificare se è così. Ricorda, il carattere o il pattern deve essere presente consecutivamente. Cioè, il carattere deve ripetersi uno dopo l'altro.
+
+Ad esempio, `/a+/g` troverà una corrispondenza in `abc` e restituirà `["a"]`. A causa del `+`, troverà anche una singola corrispondenza in `aabc` e restituirà `["aa"]`.
+
+Se invece controllasse la stringa `abab`, troverebbe due corrispondenze e restituirebbe `["a", "a"]` perché i caratteri `a` non sono in fila - c'è una `b` tra di essi. Infine, dato che non c'è `a` nella stringa `bcd`, qui non troverà una corrispondenza.
+
+# --instructions--
+
+Desideri trovare le corrispondenze in cui la lettera `s` compare una o più volte in `Mississippi`. Scrivi un'espressione regolare che utilizza il segno `+`.
+
+# --hints--
+
+La tua espressione regolare `myRegex` dovrebbe utilizzare il segno `+` per riconoscere uno o più caratteri `s`.
+
+```js
+assert(/\+/.test(myRegex.source));
+```
+
+La tua espressione regolare `myRegex` dovrebbe riconoscere 2 elementi.
+
+```js
+assert(result.length == 2);
+```
+
+La variabile `result` dovrebbe essere un array con due corrispondenze di `ss`
+
+```js
+assert(result[0] == 'ss' && result[1] == 'ss');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let difficultSpelling = "Mississippi";
+let myRegex = /change/; // Change this line
+let result = difficultSpelling.match(myRegex);
+```
+
+# --solutions--
+
+```js
+let difficultSpelling = "Mississippi";
+let myRegex = /s+/g; // Change this line
+let result = difficultSpelling.match(myRegex);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md

@@ -0,0 +1,96 @@
+---
+id: 587d7db6367417b2b2512b9a
+title: Riconoscere i caratteri che compaiono zero o più volte
+challengeType: 1
+forumTopicId: 301351
+dashedName: match-characters-that-occur-zero-or-more-times
+---
+
+# --description--
+
+L'ultima sfida ha usato il segno più `+` per cercare caratteri che compaiono una o più volte. C'è anche un'opzione che riconosce i caratteri che si verificano zero o più volte.
+
+Il simbolo per farlo è l'asterisco: `*`.
+
+```js
+let soccerWord = "gooooooooal!";
+let gPhrase = "gut feeling";
+let oPhrase = "over the moon";
+let goRegex = /go*/;
+soccerWord.match(goRegex);
+gPhrase.match(goRegex);
+oPhrase.match(goRegex);
+```
+
+In ordine, le tre chiamate a `match` restituiranno i valori `["goooooooo"]`, `["g"]`, e `null`.
+
+# --instructions--
+
+Per questa sfida, `chewieQuote` è stato inizializzato con la stringa `Aaaaaaaaaaaaaaaarrrgh!` dietro le quinte. Crea un'espressione regolare `chewieRegex` che utilizza il carattere `*` per riconoscere un carattere `A` immediatamente seguito da zero o più caratteri `a` minuscola in `chewieQuote`. La tua espressione regolare non avrà bisogno di flag o classi di caratteri, e non dovrebbe riconoscere nessuna delle altre frasi.
+
+# --hints--
+
+La tua espressione regolare `chewieRegex` dovrebbe usare il carattere `*` per riconoscere zero o più caratteri `a`.
+
+```js
+assert(/\*/.test(chewieRegex.source));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `A` in `chewieQuote`.
+
+```js
+assert(result[0][0] === 'A');
+```
+
+La tua espressione regolare dovrebbe riconoscdre la stringa `Aaaaaaaaaaaaaaaa` in `chewieQuote`.
+
+```js
+assert(result[0] === 'Aaaaaaaaaaaaaaaa');
+```
+
+La tua espressione regolare `chewieRegex` dovrebbe riconoscere 16 caratteri in `chewieQuote`.
+
+```js
+assert(result[0].length === 16);
+```
+
+La tua espressione regolare non dovrebbe riconoscere nessun carattere nella stringa `He made a fair move. Screaming about it can't help you.`
+
+```js
+assert(
+  !"He made a fair move. Screaming about it can't help you.".match(chewieRegex)
+);
+```
+
+La tua espressione regolare non dovrebbe riconoscere nessun carattere nella stringa `Let him have it. It's not wise to upset a Wookiee.`
+
+```js
+assert(
+  !"Let him have it. It's not wise to upset a Wookiee.".match(chewieRegex)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+const chewieQuote = "Aaaaaaaaaaaaaaaarrrgh!";
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+let chewieRegex = /change/; // Change this line
+// Only change code above this line
+
+let result = chewieQuote.match(chewieRegex);
+```
+
+# --solutions--
+
+```js
+  let chewieRegex = /Aa*/;
+  let result = chewieQuote.match(chewieRegex);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns.md

@@ -0,0 +1,65 @@
+---
+id: 587d7db7367417b2b2512b9e
+title: Riconoscere i pattern di fine stringa
+challengeType: 1
+forumTopicId: 301352
+dashedName: match-ending-string-patterns
+---
+
+# --description--
+
+Nell'ultima sfida, hai imparato a usare il carattere del cursore per cercare pattern all'inizio delle stringhe. C'è anche un modo per cercare i pattern alla fine delle stringhe.
+
+È possibile cercare la fine delle stringhe utilizzando il carattere dollaro `$` alla fine dell'espressione regolare.
+
+```js
+let theEnding = "This is a never ending story";
+let storyRegex = /story$/;
+storyRegex.test(theEnding);
+let noEnding = "Sometimes a story will have to end";
+storyRegex.test(noEnding);
+```
+
+La prima chiamata a `test` restituirà `true`, mentre la seconda restituirà `false`.
+
+# --instructions--
+
+Utilizza il carattere di ancoraggio (`$`) per riconoscere la stringa `caboose` alla fine della stringa `caboose`.
+
+# --hints--
+
+Dovresti cercare `caboose` con l'ancora dollaro `$` nella tua espressione regolare.
+
+```js
+assert(lastRegex.source == 'caboose$');
+```
+
+La tua espressione regolare non dovrebbe usare alcun flag.
+
+```js
+assert(lastRegex.flags == '');
+```
+
+Dovresti riconoscere `caboose` alla fine della stringa `The last car on a train is the caboose`
+
+```js
+assert(lastRegex.test('The last car on a train is the caboose'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let caboose = "The last car on a train is the caboose";
+let lastRegex = /change/; // Change this line
+let result = lastRegex.test(caboose);
+```
+
+# --solutions--
+
+```js
+let caboose = "The last car on a train is the caboose";
+let lastRegex = /caboose$/; // Change this line
+let result = lastRegex.test(caboose);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.md

@@ -0,0 +1,92 @@
+---
+id: 587d7db8367417b2b2512ba0
+title: Riconoscere tutto tranne le lettere e i numeri
+challengeType: 1
+forumTopicId: 301353
+dashedName: match-everything-but-letters-and-numbers
+---
+
+# --description--
+
+Hai imparato che puoi usare una scorciatoia per riconoscere i caratteri alfanumerici `[A-Za-z0-9_]` usando `\w`. Un pattern naturale che potresti voler cercare è l'opposto degli alfanumerici.
+
+Puoi cercare l'opposto di `\w` con `\W`. Nota che il modello opposto utilizza una lettera maiuscola. Questa scorciatoia è la stessa di `[^A-Za-z0-9_]`.
+
+```js
+let shortHand = /\W/;
+let numbers = "42%";
+let sentence = "Coding!";
+numbers.match(shortHand);
+sentence.match(shortHand);
+```
+
+La prima chiamata a `match` restituirà il valore `["%"]` e la seconda restituirà `["!"]`.
+
+# --instructions--
+
+Usa la scorciatoia per la classe di caratteri `\W` per contare il numero di caratteri non alfanumerici in varie frasi e stringhe.
+
+# --hints--
+
+La tua espressione regolare dovrebbe usare il flag global.
+
+```js
+assert(nonAlphabetRegex.global);
+```
+
+La tua espressione regolare dovrebbe trovare 6 caratteri non alfanumerici nella stringa `The five boxing wizards jump quickly.`.
+
+```js
+assert(
+  'The five boxing wizards jump quickly.'.match(nonAlphabetRegex).length == 6
+);
+```
+
+La tua espressione regolare dovrebbe usare il carattere abbreviato per riconoscere caratteri non alfanumerici.
+
+```js
+assert(/\\W/.test(nonAlphabetRegex.source));
+```
+
+La tua espressione regolare dovrebbe trovare 8 caratteri non alfanumerici nella stringa `Pack my box with five dozen liquor jugs.`
+
+```js
+assert(
+  'Pack my box with five dozen liquor jugs.'.match(nonAlphabetRegex).length == 8
+);
+```
+
+La tua espressione regolare dovrebbe trovare 6 caratteri non alfanumerici nella stringa `How vexingly quick daft zebras jump!`
+
+```js
+assert(
+  'How vexingly quick daft zebras jump!'.match(nonAlphabetRegex).length == 6
+);
+```
+
+La tua espressione regolare dovrebbe trovare 12 caratteri non alfanumerici nella stringa `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.`
+
+```js
+assert(
+  '123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.'.match(nonAlphabetRegex)
+    .length == 12
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let nonAlphabetRegex = /change/; // Change this line
+let result = quoteSample.match(nonAlphabetRegex).length;
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The five boxing wizards_jump quickly.";
+let nonAlphabetRegex = /\W/g; // Change this line
+let result = quoteSample.match(nonAlphabetRegex).length;
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet.md

@@ -0,0 +1,71 @@
+---
+id: 587d7db5367417b2b2512b96
+title: Riconoscere le lettere dell'alfabeto
+challengeType: 1
+forumTopicId: 301354
+dashedName: match-letters-of-the-alphabet
+---
+
+# --description--
+
+Hai visto come è possibile utilizzare dei <dfn>set di caratteri</dfn> per specificare un gruppo di caratteri da riconoscere, ma dovresti digitare un sacco per abbinare una vasta gamma di caratteri (ad esempio, ogni lettera dell'alfabeto). Fortunatamente, c'è una caratteristica integrata che rende questa operazione molto semplice.
+
+All'interno di un set di caratteri, è possibile definire un intervallo di caratteri da abbinare utilizzando un carattere trattino: `-`.
+
+Ad esempio, per riconoscere le lettere minuscole da `a` a `e` userai `[a-e]`.
+
+```js
+let catStr = "cat";
+let batStr = "bat";
+let matStr = "mat";
+let bgRegex = /[a-e]at/;
+catStr.match(bgRegex);
+batStr.match(bgRegex);
+matStr.match(bgRegex);
+```
+
+In ordine, le tre chiamate `match` restituiranno i valori `["cat"]`, `["bat"]`, e `null`.
+
+# --instructions--
+
+Riconosci tutte le lettere nella stringa `quoteSample`.
+
+**Nota**: Assicurati di abbinare sia lettere maiuscole che minuscole.
+
+# --hints--
+
+La tua espressione regolare `alphabetRegex` dovrebbe riconoscere 35 elementi.
+
+```js
+assert(result.length == 35);
+```
+
+La tua espressione regolare `alphabetRegex` dovrebbe usare il flag global.
+
+```js
+assert(alphabetRegex.flags.match(/g/).length == 1);
+```
+
+La tua espressione regolare `alphabetRegex` dovrebbe usare il flag insensibile alle maiuscole e minuscole.
+
+```js
+assert(alphabetRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The quick brown fox jumps over the lazy dog.";
+let alphabetRegex = /change/; // Change this line
+let result = alphabetRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The quick brown fox jumps over the lazy dog.";
+let alphabetRegex = /[a-z]/gi; // Change this line
+let result = quoteSample.match(alphabetRegex); // Change this line
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings.md

@@ -0,0 +1,72 @@
+---
+id: 587d7db3367417b2b2512b8f
+title: Riconoscere le stringhe letterali
+challengeType: 1
+forumTopicId: 301355
+dashedName: match-literal-strings
+---
+
+# --description--
+
+Nell'ultima sfida, hai cercato la parola `Hello` usando l'espressione regolare `/Hello/`. Quell'espressione regolare ha cercato una corrispondenza letterale della stringa `Hello`. Ecco un altro esempio di ricerca di una corrispondenza letterale della stringa `Kevin`:
+
+```js
+let testStr = "Hello, my name is Kevin.";
+let testRegex = /Kevin/;
+testRegex.test(testStr);
+```
+
+Questa chiamata a `test` restituirà `true`.
+
+Qualsiasi altra forma di `Kevin` non corrisponderà. Ad esempio, l'espressione regolare `/Kevin/` non corrisponderà a `kevin` o `KEVIN`.
+
+```js
+let wrongRegex = /kevin/;
+wrongRegex.test(testStr);
+```
+
+Questa chiamata a `test` restituirà `false`.
+
+Una sfida futura mostrerà come riconoscere anche queste altre forme.
+
+# --instructions--
+
+Completa l'espressione regolare `waldoRegex` per trovare `"Waldo"` nella stringa `waldoIsHiding` con una corrispondenza letterale.
+
+# --hints--
+
+La tua espressione regolare `waldoRegex` dovrebbe trovare la stringa `Waldo`
+
+```js
+assert(waldoRegex.test(waldoIsHiding));
+```
+
+La tua espressione regolare `waldoRegex` non dovrebbe cercare altro.
+
+```js
+assert(!waldoRegex.test('Somewhere is hiding in this text.'));
+```
+
+Dovresti cercare la corrispondenza di una stringa letterale con la tua espressione regolare.
+
+```js
+assert(!/\/.*\/i/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
+let waldoRegex = /search/; // Change this line
+let result = waldoRegex.test(waldoIsHiding);
+```
+
+# --solutions--
+
+```js
+let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
+let waldoRegex = /Waldo/; // Change this line
+let result = waldoRegex.test(waldoIsHiding);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters.md

@@ -0,0 +1,78 @@
+---
+id: 587d7db9367417b2b2512ba4
+title: Riconoscere i caratteri diversi dagli spazi
+challengeType: 1
+forumTopicId: 18210
+dashedName: match-non-whitespace-characters
+---
+
+# --description--
+
+Hai imparato come cercare spazi bianchi usando `\s`, con una `s` minuscola. Puoi anche cercare tutto tranne gli spazi bianchi.
+
+Cerca caratteri non bianchi usando `\S`, che è una `s` maiuscola. Questo pattern non riconoscerà lo spazio bianco, i ritorni a capo, le tabulazioni, i caratteri di avanzamento carrello e di nuova linea. Puoi pensare che sia simile alla classe di caratteri `[^ \r\t\f\n\v]`.
+
+```js
+let whiteSpace = "Whitespace. Whitespace everywhere!"
+let nonSpaceRegex = /\S/g;
+whiteSpace.match(nonSpaceRegex).length;
+```
+
+Il valore restituito dal metodo `.length` sarà `32`.
+
+# --instructions--
+
+Cambia l'espressione regolare `countNonWhiteSpace` in modo che cerchi caratteri non bianchi multipli in una stringa.
+
+# --hints--
+
+La tua espressione regolare dovrebbe usare il flag global.
+
+```js
+assert(countNonWhiteSpace.global);
+```
+
+La tua espressione regolare dovrebbe usare il carattere abbreviato `\S` per riconoscere tutti i caratteri non bianchi.
+
+```js
+assert(/\\S/.test(countNonWhiteSpace.source));
+```
+
+La tua espressione regolare dovrebbe trovare 35 non-spazi nella stringa `Men are from Mars and women are from Venus.`
+
+```js
+assert(
+  'Men are from Mars and women are from Venus.'.match(countNonWhiteSpace)
+    .length == 35
+);
+```
+
+La tua espressione regolare dovrebbe trovare 23 non-spazi nella stringa `Space: the final frontier.`
+
+```js
+assert('Space: the final frontier.'.match(countNonWhiteSpace).length == 23);
+```
+
+La tua espressione regolare dovrebbe trovare 21 non-spazi nella stringa `MindYourPersonalSpace`
+
+```js
+assert('MindYourPersonalSpace'.match(countNonWhiteSpace).length == 21);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countNonWhiteSpace = /change/; // Change this line
+let result = sample.match(countNonWhiteSpace);
+```
+
+# --solutions--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countNonWhiteSpace = /\S/g; // Change this line
+let result = sample.match(countNonWhiteSpace);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet.md

@@ -0,0 +1,63 @@
+---
+id: 587d7db5367417b2b2512b97
+title: Riconoscere numeri e lettere dell'alfabeto
+challengeType: 1
+forumTopicId: 301356
+dashedName: match-numbers-and-letters-of-the-alphabet
+---
+
+# --description--
+
+L'uso del trattino (`-`) per riconoscere un intervallo di caratteri non è limitato alle lettere. Funziona anche per riconoscere un intervallo di numeri.
+
+Ad esempio, `/[0-5]/` corrisponde a qualsiasi numero tra `0` e `5`, inclusi `0` e `5`.
+
+Inoltre, è possibile combinare un intervallo di lettere e numeri in un unico set di caratteri.
+
+```js
+let jennyStr = "Jenny8675309";
+let myRegex = /[a-z0-9]/ig;
+jennyStr.match(myRegex);
+```
+
+# --instructions--
+
+Crea una singola espressione regolare che riconosca un intervallo di lettere tra `h` e `s`, e un intervallo di numeri tra `2` e `6`. Ricordati di includere i flag appropriati nell'espressione regolare.
+
+# --hints--
+
+La tua espressione regolare `myRegex` dovrebbe riconoscere 17 elementi.
+
+```js
+assert(result.length == 17);
+```
+
+La tua espressione regolare `myRegex` dovrebbe usare il flag global.
+
+```js
+assert(myRegex.flags.match(/g/).length == 1);
+```
+
+La tua espressione regolare `myRegex` dovrebbe usare il flag insensibile alle maiuscole e minuscole.
+
+```js
+assert(myRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "Blueberry 3.141592653s are delicious.";
+let myRegex = /change/; // Change this line
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "Blueberry 3.141592653s are delicious.";
+let myRegex = /[h-s2-6]/gi; // Change this line
+let result = quoteSample.match(myRegex); // Change this line
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities.md

@@ -0,0 +1,85 @@
+---
+id: 587d7db5367417b2b2512b95
+title: Riconoscere singoli caratteri con diverse possibilità
+challengeType: 1
+forumTopicId: 301357
+dashedName: match-single-character-with-multiple-possibilities
+---
+
+# --description--
+
+Hai imparato come riconosce i pattern letterali (`/literal/`) e i caratteri jolly (`/./`). Questi sono i due estremi delle espressioni regolari, dove uno trova corrispondenze esatte, e l'altro corrispondono a qualunque carattere. Ci sono opzioni che sono un equilibrio tra i due estremi.
+
+È possibile cercare un pattern letterale con una certa flessibilità con le <dfn>classi di caratteri</dfn>. Le classi di caratteri consentono di definire un gruppo di caratteri che si desidera riconoscere posizionandoli all'interno di parentesi quadre (`[` e `]`).
+
+Ad esempio, se volessi riconoscere `bag`, `big`e `bug` ma non `bog`... Potresti creare l'espressione regolare `/b[aiu]g/` per farlo. `[aiu]` è la classe di caratteri che corrisponde solo ai caratteri `a`, `i`, o `u`.
+
+```js
+let bigStr = "big";
+let bagStr = "bag";
+let bugStr = "bug";
+let bogStr = "bog";
+let bgRegex = /b[aiu]g/;
+bigStr.match(bgRegex);
+bagStr.match(bgRegex);
+bugStr.match(bgRegex);
+bogStr.match(bgRegex);
+```
+
+Nell'ordine, le quattro chiamate a `match` restituiranno i valori `["big"]`, `["bag"]`, `["bug"]`e `null`.
+
+# --instructions--
+
+Usa una classe di caratteri con vocali (`a`, `e`, `i`, `o`, `u`) nella tua espressione regolare `vowelRegex` per trovare tutte le vocali nella stringa `quoteSample`.
+
+**Nota:** Assicurati di riconoscere sia le vocali maiuscole che quelle minuscole.
+
+# --hints--
+
+Dovresti trovare tutte le 25 vocali.
+
+```js
+assert(result.length == 25);
+```
+
+La tua espressione regolare `vowelRegex` dovrebbe usare una classe di caratteri.
+
+```js
+assert(/\[.*\]/.test(vowelRegex.source));
+```
+
+La tua espressione regolare `vowelRegex` dovrebbe usare il flag global.
+
+```js
+assert(vowelRegex.flags.match(/g/).length == 1);
+```
+
+La tua espressione regolare `vowelRegex` dovrebbe usare il flag insensibile alle maiuscole e minuscole.
+
+```js
+assert(vowelRegex.flags.match(/i/).length == 1);
+```
+
+La tua espressione regolare non dovrebbe riconoscere nessuna consonante.
+
+```js
+assert(!/[b-df-hj-np-tv-z]/gi.test(result.join()));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
+let vowelRegex = /change/; // Change this line
+let result = vowelRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
+let vowelRegex = /[aeiou]/gi; // Change this line
+let result = quoteSample.match(vowelRegex); // Change this line
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified.md

@@ -0,0 +1,57 @@
+---
+id: 587d7db6367417b2b2512b98
+title: Riconoscere singoli caratteri non specificati
+challengeType: 1
+forumTopicId: 301358
+dashedName: match-single-characters-not-specified
+---
+
+# --description--
+
+Finora, hai creato un insieme di caratteri che vuoi riconoscere, ma è anche possibile creare un insieme di caratteri che non vuoi riconoscere. Questi tipi di set di caratteri sono chiamati <dfn>set di caratteri negati</dfn>.
+
+Per creare un set di caratteri negati, devi posizionare un carattere di cursore (`^`) dopo la parentesi di apertura e prima dei caratteri che non desideri riconoscere.
+
+Ad esempio, `/[^aeiou]/gi` corrisponde a tutti i caratteri che non sono vocali. Nota che caratteri come `.`, `!`, `[`, `@`, `/` e lo spazio bianco sono riconosciuti - il set di caratteri vocale negato esclude solo i caratteri vocali.
+
+# --instructions--
+
+Crea una singola espressione regolare che riconosca tutti i caratteri che non sono un numero o una vocale. Ricordati di includere i flag appropriati nell'espressione regolare.
+
+# --hints--
+
+La tua espressione regolare `myRegex` dovrebbe riconoscere 9 elementi.
+
+```js
+assert(result.length == 9);
+```
+
+La tua espressione regolare `myRegex` dovrebbe usare il flag global.
+
+```js
+assert(myRegex.flags.match(/g/).length == 1);
+```
+
+La tua espressione regolare `myRegex` dovrebbe usare il flag insensibile alle maiuscole e minuscole.
+
+```js
+assert(myRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "3 blind mice.";
+let myRegex = /change/; // Change this line
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "3 blind mice.";
+let myRegex = /[^0-9aeiou]/gi; // Change this line
+let result = quoteSample.match(myRegex); // Change this line
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/match-whitespace.md

@@ -0,0 +1,77 @@
+---
+id: 587d7db8367417b2b2512ba3
+title: Riconoscere gli spazi bianchi
+challengeType: 1
+forumTopicId: 301359
+dashedName: match-whitespace
+---
+
+# --description--
+
+Le sfide finora hanno riguardato il riconoscimento delle lettere dell'alfabeto e dei numeri. Puoi anche riconoscere lo spazio bianco o gli spazi tra le lettere.
+
+Puoi cercare spazi bianchi usando `\s`, che è una `s` minuscola. Questo pattern non coincide solo con lo spazio bianco, ma anche con il ritorno a capo, la tabulazione, il ritorno carrello e i caratteri di nuova riga. Potresti pensarlo simile alla classe di caratteri `[ \r\t\f\n\v]`.
+
+```js
+let whiteSpace = "Whitespace. Whitespace everywhere!"
+let spaceRegex = /\s/g;
+whiteSpace.match(spaceRegex);
+```
+
+Questa chiamata a `match` restituirà `[" ", " "]`.
+# --instructions--
+
+Cambia l'espressione regolare `countWhiteSpace` in modo da cercare spazi bianchi multipli in una stringa.
+
+# --hints--
+
+La tua espressione regolare dovrebbe usare il flag global.
+
+```js
+assert(countWhiteSpace.global);
+```
+
+La tua espressione regolare dovrebbe usare il carattere abbreviato `\s` per abbinare tutti i caratteri di spazio bianco.
+
+```js
+assert(/\\s/.test(countWhiteSpace.source));
+```
+
+La tua espressione regolare dovrebbe trovare otto spazi nella stringa `Men are from Mars and women are from Venus.`
+
+```js
+assert(
+  'Men are from Mars and women are from Venus.'.match(countWhiteSpace).length ==
+    8
+);
+```
+
+La tua espressione regolare dovrebbe trovare tre spazi nella stringa `Space: the final frontier.`
+
+```js
+assert('Space: the final frontier.'.match(countWhiteSpace).length == 3);
+```
+
+La tua espressione finale non dovrebbe trovare spazi nella stringa `MindYourPersonalSpace`
+
+```js
+assert('MindYourPersonalSpace'.match(countWhiteSpace) == null);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countWhiteSpace = /change/; // Change this line
+let result = sample.match(countWhiteSpace);
+```
+
+# --solutions--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countWhiteSpace = /\s/g;
+let result = sample.match(countWhiteSpace);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead.md

@@ -0,0 +1,114 @@
+---
+id: 587d7dba367417b2b2512ba9
+title: Lookahead positivi e negativi
+challengeType: 1
+forumTopicId: 301360
+dashedName: positive-and-negative-lookahead
+---
+
+# --description--
+
+I <dfn>Lookahead</dfn> sono pattern che dicono a JavaScript di guardare avanti nella tua stringa per controllare i pattern successivi. Questo può essere utile quando desideri cercare più pattern sulla stessa stringa.
+
+Ci sono due tipi di lookahead: <dfn>lookahead positivi</dfn> e <dfn>lookahead negativi</dfn>.
+
+Un lookahead positivo guarderà per assicurarsi che l'elemento nel pattern di ricerca sia presente, ma in realtà non lo riconoscerà. Un lookahead positivo è usato come `(?=...)` dove `...` è la parte richiesta sulla quale non viene fatto il matching.
+
+Dall'altra parte, un lookahead negativo guarderà per assicurarsi che l'elemento nel pattern di ricerca non sia presente. Un lookahead negativo è usato come `(?!...)` dove `...` è il pattern che non deve essere presente. Il resto del pattern è restituito se la parte di lookahead negativo non è presente.
+
+I lookahead possono confondere un po' ma alcuni esempi aiuteranno.
+
+```js
+let quit = "qu";
+let noquit = "qt";
+let quRegex= /q(?=u)/;
+let qRegex = /q(?!u)/;
+quit.match(quRegex);
+noquit.match(qRegex);
+```
+
+Entrambe queste chiamate a `match` restituiranno `["q"]`.
+
+Un uso più pratico dei lookaheads è quello di controllare due o più pattern in una stringa. Ecco un validatore di password (ingenuamente) semplice che richiede tra i 3 e i 6 caratteri e almeno un numero:
+
+```js
+let password = "abc123";
+let checkPass = /(?=\w{3,6})(?=\D*\d)/;
+checkPass.test(password);
+```
+
+# --instructions--
+
+Usa i lookahead nell'espressione regolare `pwRegex` per riconoscere le password che sono lunghe più di 5 caratteri e hanno due cifre consecutive.
+
+# --hints--
+
+La tua espressione regolare dovrebbe usare due `lookaheads` positivi.
+
+```js
+assert(pwRegex.source.match(/\(\?=.*?\)\(\?=.*?\)/) !== null);
+```
+
+La tua espressione regolare non dovrebbe corrispondere alla stringa `astronaut`
+
+```js
+assert(!pwRegex.test('astronaut'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `banan1`
+
+```js
+assert(!pwRegex.test('banan1'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `bana12`
+
+```js
+assert(pwRegex.test('bana12'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `abc123`
+
+```js
+assert(pwRegex.test('abc123'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `12345`
+
+```js
+assert(!pwRegex.test('12345'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `8pass99`
+
+```js
+assert(pwRegex.test('8pass99'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `1a2bcde`
+
+```js
+assert(!pwRegex.test('1a2bcde'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `astr1on11aut`
+
+```js
+assert(pwRegex.test('astr1on11aut'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sampleWord = "astronaut";
+let pwRegex = /change/; // Change this line
+let result = pwRegex.test(sampleWord);
+```
+
+# --solutions--
+
+```js
+let pwRegex =  /(?=\w{6})(?=\w*\d{2})/;
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.md

@@ -0,0 +1,55 @@
+---
+id: 587d7dbb367417b2b2512bac
+title: Rimuovere gli spazi iniziali e finali
+challengeType: 1
+forumTopicId: 301362
+dashedName: remove-whitespace-from-start-and-end
+---
+
+# --description--
+
+A volte gli spazi bianchi intorno alle stringhe non sono desiderati, ma ci sono. Un'elaborazione tipica delle stringhe è quella di rimuovere lo spazio bianco all'inizio e alla fine di esse.
+
+# --instructions--
+
+Scrivi un'espressione regolare e usa i metodi stringa appropriati per rimuovere gli spazi bianchi all'inizio e alla fine delle stringhe.
+
+**Nota:** Il metodo `String.prototype.trim()` funzionerebbe, ma dovrai completare questa sfida usando le espressioni regolari.
+
+# --hints--
+
+`result` dovrebbe essere uguale alla stringa `Hello, World!`
+
+```js
+assert(result === 'Hello, World!');
+```
+
+La tua soluzione non dovrebbe usare il metodo `String.prototype.trim()`.
+
+```js
+assert(!code.match(/\.?[\s\S]*?trim/));
+```
+
+La variabile `result` non dovrebbe essere impostata direttamente con una stringa
+
+```js
+assert(!code.match(/result\s*=\s*["'`].*?["'`]/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let hello = "   Hello, World!  ";
+let wsRegex = /change/; // Change this line
+let result = hello; // Change this line
+```
+
+# --solutions--
+
+```js
+let hello = "   Hello, World!  ";
+let wsRegex = /^(\s+)(.+[^\s])(\s+)$/;
+let result = hello.replace(wsRegex, '$2');
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames.md

@@ -0,0 +1,123 @@
+---
+id: 587d7db8367417b2b2512ba2
+title: Restringere gli username possibili
+challengeType: 1
+forumTopicId: 301363
+dashedName: restrict-possible-usernames
+---
+
+# --description--
+
+I nomi utente sono utilizzati ovunque su Internet. Sono ciò che danno agli utenti un'identità unica sui loro siti preferiti.
+
+È necessario controllare tutti i nomi utente in un database. Ecco alcune semplici regole che gli utenti devono seguire durante la creazione del loro nome utente.
+
+1) I nomi utente possono usare solo caratteri alfanumerici.
+
+2) Gli unici numeri nel nome utente devono essere alla fine. Ce ne possono essere zero o più alla fine. Il nome utente non può iniziare con un numero.
+
+3) Le lettere del nome utente possono essere minuscole e maiuscole.
+
+4) I nomi utente devono essere lunghi almeno due caratteri. Un nome utente di due caratteri può usare solo lettere alfabetiche come caratteri.
+
+# --instructions--
+
+Cambia l'espressione regolare `userCheck` in modo che corrisponda ai vincoli elencati sopra.
+
+# --hints--
+
+La tua espressione regolare dovrebbe riconoscere la stringa `JACK`
+
+```js
+assert(userCheck.test('JACK'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `J`
+
+```js
+assert(!userCheck.test('J'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Jo`
+
+```js
+assert(userCheck.test('Jo'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Oceans11`
+
+```js
+assert(userCheck.test('Oceans11'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `RegexGuru`
+
+```js
+assert(userCheck.test('RegexGuru'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `007`
+
+```js
+assert(!userCheck.test('007'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `9`
+
+```js
+assert(!userCheck.test('9'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `A1`
+
+```js
+assert(!userCheck.test('A1'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `BadUs3rnam3`
+
+```js
+assert(!userCheck.test('BadUs3rnam3'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Z97`
+
+```js
+assert(userCheck.test('Z97'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `c57bT3`
+
+```js
+assert(!userCheck.test('c57bT3'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `AB1`
+
+```js
+assert(userCheck.test('AB1'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `J%4`
+
+```js
+assert(!userCheck.test('J%4'))
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let username = "JackOfAllTrades";
+let userCheck = /change/; // Change this line
+let result = userCheck.test(username);
+```
+
+# --solutions--
+
+```js
+let username = "JackOfAllTrades";
+const userCheck = /^[a-z]([0-9]{2,}|[a-z]+\d*)$/i;
+let result = userCheck.test(username);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md

@@ -0,0 +1,106 @@
+---
+id: 587d7dbb367417b2b2512baa
+title: Riutilizzare i pattern usando i gruppi di cattura
+challengeType: 1
+forumTopicId: 301364
+dashedName: reuse-patterns-using-capture-groups
+---
+
+# --description--
+
+Alcuni pattern che cerchi si verificheranno più volte in una stringa. È una perdita di tempo ripetere manualmente quell'espressione regolare. C'è un modo migliore per specificare quando si hanno più sottostringhe ripetute nella stringa.
+
+È possibile cercare sottostringhe ripetute utilizzando i <dfn>gruppi di cattura</dfn>. Le parentesi, `(` e `)`, sono usate per trovare sottostringhe ripetute. Metti tra le parentesi l'espressione regolare del pattern che si ripeterà.
+
+Per specificare dove apparirà quella stringa ripetuta, si utilizza una barra rovesciata (`\`) e quindi un numero. Questo numero inizia da 1 e aumenta con ogni gruppo di cattura aggiuntivo che utilizzi. Un esempio potrebbe essere `\1` per abbinare il primo gruppo.
+
+L'esempio sottostante riconosce qualsiasi parola che compare due volte separata da uno spazio:
+
+```js
+let repeatStr = "regex regex";
+let repeatRegex = /(\w+)\s\1/;
+repeatRegex.test(repeatStr);
+repeatStr.match(repeatRegex);
+```
+
+La chiamata a `test` restituirà `true` e la chiamata a `match` restituirà `["regex regex", "regex"]`.
+
+Usando il metodo `.match()` su una stringa esso restituirà un array con la stringa che corrisponde, insieme al suo gruppo di cattura.
+
+# --instructions--
+
+Usa i gruppi di cattura in `reRegex` per riconoscere una stringa che consiste solo dello stesso numero ripetuto esattamente tre volte separato da spazi singoli.
+
+# --hints--
+
+La tua espressione regolare dovrebbe usare la classe scorciatoria di carattere per le cifre.
+
+```js
+assert(reRegex.source.match(/\\d/));
+```
+
+La tua espressione regolare dovrebbe riutilizzare un gruppo di cattura due volte.
+
+```js
+assert(reRegex.source.match(/\\1|\\2/g).length >= 2);
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `42 42 42`.
+
+```js
+assert(reRegex.test('42 42 42'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `100 100 100`.
+
+```js
+assert(reRegex.test('100 100 100'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `42 42 42 42`.
+
+```js
+assert.equal('42 42 42 42'.match(reRegex.source), null);
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `42 42`.
+
+```js
+assert.equal('42 42'.match(reRegex.source), null);
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `101 102 103`.
+
+```js
+assert(!reRegex.test('101 102 103'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `1 2 3`.
+
+```js
+assert(!reRegex.test('1 2 3'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `10 10 10`.
+
+```js
+assert(reRegex.test('10 10 10'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let repeatNum = "42 42 42";
+let reRegex = /change/; // Change this line
+let result = reRegex.test(repeatNum);
+```
+
+# --solutions--
+
+```js
+let repeatNum = "42 42 42";
+let reRegex = /^(\d+)\s\1\s\1$/;
+let result = reRegex.test(repeatNum);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches.md

@@ -0,0 +1,92 @@
+---
+id: 587d7db9367417b2b2512ba7
+title: Specificare il numero esatto di corrispondenze
+challengeType: 1
+forumTopicId: 301365
+dashedName: specify-exact-number-of-matches
+---
+
+# --description--
+
+È possibile specificare un numero inferiore e superiore di pattern con gli specificatori di quantità utilizzando le parentesi graffe. A volte vuoi che ci sia un numero specifico di corrispondenze.
+
+Per specificare un certo numero di pattern, basta mettere quel numero tra le parentesi graffe.
+
+Ad esempio, per riconoscere solo la parola `hah` con la lettera `a` `3` volte, la tua espressione regolare sarebbe `/ha{3}h/`.
+
+```js
+let A4 = "haaaah";
+let A3 = "haaah";
+let A100 = "h" + "a".repeat(100) + "h";
+let multipleHA = /ha{3}h/;
+multipleHA.test(A4);
+multipleHA.test(A3);
+multipleHA.test(A100);
+```
+
+Nell'ordine, le tre chiamate a `test` restituiranno `false`, `true`, e `false`.
+
+# --instructions--
+
+Cambia l'espressione regolare `timRegex` per riconoscere la parola `Timber` solo quando ha quattro lettere `m`.
+
+# --hints--
+
+L'espressione regolare dovrebbe usare parentesi graffe.
+
+```js
+assert(timRegex.source.match(/{.*?}/).length > 0);
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `Timber`
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timber'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `Timmber`
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timmber'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `Timmmber`
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timmmber'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Timmmmber`
+
+```js
+timRegex.lastIndex = 0;
+assert(timRegex.test('Timmmmber'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `Timber` con 30 `m` in essa.
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Ti' + 'm'.repeat(30) + 'ber'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let timStr = "Timmmmber";
+let timRegex = /change/; // Change this line
+let result = timRegex.test(timStr);
+```
+
+# --solutions--
+
+```js
+let timStr = "Timmmmber";
+let timRegex = /Tim{4}ber/; // Change this line
+let result = timRegex.test(timStr);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches.md

@@ -0,0 +1,93 @@
+---
+id: 587d7db9367417b2b2512ba6
+title: Specificare solo il numero inferiore di corrispondenze
+challengeType: 1
+forumTopicId: 301366
+dashedName: specify-only-the-lower-number-of-matches
+---
+
+# --description--
+
+È possibile specificare il numero inferiore e superiore di corrispondenze con gli specificatori di quantità utilizzando le parentesi graffe. A volte si desidera specificare solo il numero inferiore di pattern senza un limite superiore.
+
+Per specificare solo il numero inferiore di pattern, manteni il primo numero seguito da una virgola.
+
+Ad esempio, per abbinare solo la stringa `hah` con la lettera `a` che appare almeno `3` volte, la tua espressione regolare sarebbe `/ha{3,}h/`.
+
+```js
+let A4 = "haaaah";
+let A2 = "haah";
+let A100 = "h" + "a".repeat(100) + "h";
+let multipleA = /ha{3,}h/;
+multipleA.test(A4);
+multipleA.test(A2);
+multipleA.test(A100);
+```
+
+In ordine, le tre chiamate a `test` restituiranno `true`, `false`e `true`.
+
+# --instructions--
+
+Cambia l'espressione regolare `haRegex` per riconoscere la parola `Hazzah` solo quando ha quattro o più lettere `z`.
+
+# --hints--
+
+L'espressione regolare dovrebbe usare parentesi graffe.
+
+```js
+assert(haRegex.source.match(/{.*?}/).length > 0);
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `Hazzah`
+
+```js
+assert(!haRegex.test('Hazzah'));
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `Hazzzah`
+
+```js
+assert(!haRegex.test('Hazzzah'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Hazzzzah`
+
+```js
+assert('Hazzzzah'.match(haRegex)[0].length === 8);
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Hazzzzzah`
+
+```js
+assert('Hazzzzzah'.match(haRegex)[0].length === 9);
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Hazzzzzzah`
+
+```js
+assert('Hazzzzzzah'.match(haRegex)[0].length === 10);
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Hazzah` con 30 `z` in essa.
+
+```js
+assert('Hazzzzzzzzzzzzzzzzzzzzzzzzzzzzzzah'.match(haRegex)[0].length === 34);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let haStr = "Hazzzzah";
+let haRegex = /change/; // Change this line
+let result = haRegex.test(haStr);
+```
+
+# --solutions--
+
+```js
+let haStr = "Hazzzzah";
+let haRegex = /Haz{4,}ah/; // Change this line
+let result = haRegex.test(haStr);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches.md

@@ -0,0 +1,91 @@
+---
+id: 587d7db9367417b2b2512ba5
+title: Specificare il numero superiore e inferiore di corrispondenze
+challengeType: 1
+forumTopicId: 301367
+dashedName: specify-upper-and-lower-number-of-matches
+---
+
+# --description--
+
+Ricorda che puoi usare il segno più `+` per cercare uno o più caratteri e l'asterisco `*` per cercare zero o più caratteri. Questi sono utili, ma a volte si desidera riconoscere una certa gamma di pattern.
+
+È possibile specificare il numero inferiore e superiore di pattern con gli <dfn>specificatori di quantità</dfn>. Gli specificatori di quantità sono utilizzati con le parentesi graffe (`{` e `}`). Metterai due numeri tra le parentesi graffe - per il numero inferiore e superiore di pattern.
+
+Ad esempio, per riconoscere solo la lettera `a` che appare tra `3` e `5` volte nella stringa `ah`, la tua espressione regolare sarà `/a{3,5}h/`.
+
+```js
+let A4 = "aaaah";
+let A2 = "aah";
+let multipleA = /a{3,5}h/;
+multipleA.test(A4);
+multipleA.test(A2);
+```
+
+La prima chiamata a `test` restituirà `true`, mentre la seconda restituirà `false`.
+
+# --instructions--
+
+Cambiare l'espressione regolare `ohRegex` in modo da riconoscere l'intera frase `Oh no` solo quando ha da `3` a `6` lettere `h`.
+
+# --hints--
+
+La tua espressione regolare dovrebbe usare le parentesi graffe.
+
+```js
+assert(ohRegex.source.match(/{.*?}/).length > 0);
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `Ohh no`
+
+```js
+assert(!ohRegex.test('Ohh no'));
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Ohhh no`
+
+```js
+assert('Ohhh no'.match(ohRegex)[0].length === 7);
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Ohhhh no`
+
+```js
+assert('Ohhhh no'.match(ohRegex)[0].length === 8);
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Ohhhhh no`
+
+```js
+assert('Ohhhhh no'.match(ohRegex)[0].length === 9);
+```
+
+La tua espressione regolare dovrebbe riconoscere la stringa `Ohhhhhh no`
+
+```js
+assert('Ohhhhhh no'.match(ohRegex)[0].length === 10);
+```
+
+La tua espressione regolare non dovrebbe riconoscere la stringa `Ohhhhhhh no`
+
+```js
+assert(!ohRegex.test('Ohhhhhhh no'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let ohStr = "Ohhh no";
+let ohRegex = /change/; // Change this line
+let result = ohRegex.test(ohStr);
+```
+
+# --solutions--
+
+```js
+let ohStr = "Ohhh no";
+let ohRegex = /Oh{3,6} no/; // Change this line
+let result = ohRegex.test(ohStr);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace.md

@@ -0,0 +1,88 @@
+---
+id: 587d7dbb367417b2b2512bab
+title: Usare i gruppi di cattura per cercare e sostituire
+challengeType: 1
+forumTopicId: 301368
+dashedName: use-capture-groups-to-search-and-replace
+---
+
+# --description--
+
+La ricerca è utile. Tuttavia, puoi rendere la ricerca ancora più potente facendole anche cambiare (o sostituire) il testo che corrisponde al pattern.
+
+È possibile cercare e sostituire il testo in una stringa usando `.replace()` su una stringa. Il primo parametro per `.replace()` è il pattern che si desidera cercare, sotto forma di espressione regolare. Il secondo parametro è la stringa con cui sostituire la corrispondenza o una funzione per fare qualcosa.
+
+```js
+let wrongText = "The sky is silver.";
+let silverRegex = /silver/;
+wrongText.replace(silverRegex, "blue");
+```
+
+La chiamata `replace` restituirà la stringa `The sky is blue.`.
+
+Puoi anche accedere ai gruppi di cattura nella stringa di sostituzione con i segni di dollaro (`$`).
+
+```js
+"Code Camp".replace(/(\w+)\s(\w+)/, '$2 $1');
+```
+
+La chiamata a `replace` restituirà la stringa `Camp Code`.
+
+# --instructions--
+
+Scrivi un'espressione regolare `fixRegex` utilizzando tre gruppi di cattura che cercheranno ogni parola nella stringa `one two three`. Quindi aggiorna la variabile `replaceText` per sostituire `one two three` con la stringa `three two one` e assegnare il risultato alla variabile `result`. Assicurati di utilizzare i gruppi di cattura nella stringa di sostituzione utilizzando la sintassi del segno del dollaro (`$`).
+
+# --hints--
+
+Dovresti usare `.replace()` per cercare e sostituire.
+
+```js
+assert(code.match(/\.replace\(.*\)/));
+```
+
+La tua espressione regolare dovrebbe sostituire la stringa `one two three` con la stringa `three two one`
+
+```js
+assert(result === 'three two one');
+```
+
+Non dovresti cambiare l'ultima riga.
+
+```js
+assert(code.match(/result\s*=\s*str\.replace\(.*?\)/));
+```
+
+`fixRegex` dovrebbe usare almeno tre gruppi di cattura.
+
+```js
+assert(new RegExp(fixRegex.source + '|').exec('').length - 1 >= 3);
+```
+
+`replaceText` dovrebbe usare stringhe di sotto-corrispondenza tra parentesi (cioè l'ennesima stringa sotto-corrispondente, $n, corrisponde all'ennesimo gruppo di acquisizione).
+
+```js
+{
+  const re = /(\$\d{1,2})+(?:[\D]|\b)/g;
+  assert(replaceText.match(re).length >= 3);
+}
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let str = "one two three";
+let fixRegex = /change/; // Change this line
+let replaceText = ""; // Change this line
+let result = str.replace(fixRegex, replaceText);
+```
+
+# --solutions--
+
+```js
+let str = "one two three";
+let fixRegex = /(\w+) (\w+) (\w+)/g; // Change this line
+let replaceText = "$3 $2 $1"; // Change this line
+let result = str.replace(fixRegex, replaceText);
+```

curriculum/challenges/italian/02-javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method.md

@@ -0,0 +1,59 @@
+---
+id: 587d7db3367417b2b2512b8e
+title: Usare il metodo test
+challengeType: 1
+forumTopicId: 301369
+dashedName: using-the-test-method
+---
+
+# --description--
+
+Le espressioni regolari sono usate nei linguaggi di programmazione per riconoscere parti di stringhe. Creerai dei "pattern" (cioè degli schemi, dei modelli) per aiutarti a trovare queste corrispondenze (match).
+
+Se vuoi trovare la parola `the` nella stringa `The dog chased the cat`, puoi utilizzare la seguente espressione regolare: `/the/`. Nota che le virgolette non sono richieste all'interno dell'espressione regolare.
+
+JavaScript ha diversi modi per utilizzare le espressioni regolari. Un modo per testare un'espressione regolare è usare il metodo `.test()`. Il metodo `.test()` prende l'espressione regolare, la applica a una stringa (che è messa dentro le parentesi), e restituisce `true` o `false` se il tuo pattern trova qualcosa o meno.
+
+```js
+let testStr = "freeCodeCamp";
+let testRegex = /Code/;
+testRegex.test(testStr);
+```
+
+Il metodo `test` qui restituirà `true`.
+
+# --instructions--
+
+Applica l'espressione regolare `myRegex` alla stringa `myString` usando il metodo `.test()`.
+
+# --hints--
+
+Dovresti usare `.test()` per testare l'espressione regolare.
+
+```js
+assert(code.match(/myRegex.test\(\s*myString\s*\)/));
+```
+
+Il tuo risultato dovrebbe restituire `true`.
+
+```js
+assert(result === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "Hello, World!";
+let myRegex = /Hello/;
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let myString = "Hello, World!";
+let myRegex = /Hello/;
+let result = myRegex.test(myString); // Change this line
+```