From 576f997e5ee18f94508b4a201539f6d091a8160f Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Wed, 21 Apr 2021 00:49:40 +0200
Subject: [PATCH 01/29] Prima stesura traduzione

---
 .../1-find-range-1/solution.md                |   6 +-
 .../1-find-range-1/task.md                    |   4 +-
 .../2-find-time-2-formats/solution.md         |   4 +-
 .../2-find-time-2-formats/task.md             |   8 +-
 .../article.md                                | 172 +++++++++---------
 5 files changed, 97 insertions(+), 97 deletions(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
index 85c7748f7..a221f0e38 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
@@ -1,11 +1,11 @@
-Answers: **no, yes**.
+Risposte: **no, sì**.
 
-- In the script `subject:Java` it doesn't match anything, because `pattern:[^script]` means "any character except given ones". So the regexp looks for `"Java"` followed by one such symbol, but there's a string end, no symbols after it.
+- Nello script `subject:Java` non corrisponde nulla, dato che per `pattern:[^script]` si intende "qualunque carattere eccetto quelli dati". Quindi la regexp cerca per `"Java"` seguito da uno di questi simboli, ma c'è una stringa alla fine, non ci sono symboli dopo di esso.
 
     ```js run
     alert( "Java".match(/Java[^script]/) ); // null
     ```
-- Yes, because the `pattern:[^script]` part matches the character `"S"`. It's not one of `pattern:script`. As the regexp is case-sensitive (no `pattern:i` flag), it treats `"S"` as a different character from `"s"`.
+- Sì, poiché la parte `pattern:[^script]` al carattere `"S"`. Non è uno di `pattern:script`. Poiché la regexp fa distinzione tra maiuscole e minuscole (non c'è il flag `pattern:i`), tratta `"S"` come un carattere differente da `"s"`.
 
     ```js run
     alert( "JavaScript".match(/Java[^script]/) ); // "JavaS"
diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md
index 5a48e01e7..4bfbc8ec1 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md
@@ -1,5 +1,5 @@
 # Java[^script]
 
-We have a regexp `pattern:/Java[^script]/`.
+Abbiamo una regexp `pattern:/Java[^script]/`.
 
-Does it match anything in the string `subject:Java`? In the string `subject:JavaScript`?
+Corrisponde a qualcosa nella stringa `subject:Java`? E nella stringa `subject:JavaScript`?
diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
index 69ade1b19..07c6a495a 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
@@ -1,8 +1,8 @@
-Answer: `pattern:\d\d[-:]\d\d`.
+Risposta: `pattern:\d\d[-:]\d\d`.
 
 ```js run
 let regexp = /\d\d[-:]\d\d/g;
 alert( "Breakfast at 09:00. Dinner at 21-30".match(regexp) ); // 09:00, 21-30
 ```
 
-Please note that the dash `pattern:'-'` has a special meaning in square brackets, but only between other characters, not when it's in the beginning or at the end, so we don't need to escape it.
+Perfavore notate che il trattino `pattern:'-'` ha un significato speciale tra le parentesi quadre, ma solo tra gli altri caratteri, non quando è all'inizio o alla fine, quindi non c'è bisogno dell'escape.
diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
index c8441caf4..09ac7f54a 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
@@ -1,12 +1,12 @@
-# Find the time as hh:mm or hh-mm
+# Trova l'orario come hh:mm o hh-mm
 
-The time can be in the format `hours:minutes` or `hours-minutes`. Both hours and minutes have 2 digits:  `09:00` or `21-30`.
+L'orario può essere nel formato `ore:minuti` o `ore-minuti`. Entrambi ore e minuti hanno 2 numeri:  `09:00` o `21-30`.
 
-Write a regexp to find time:
+Scrivi una regexp per trovare l'orario:
 
 ```js
 let regexp = /your regexp/g;
 alert( "Breakfast at 09:00. Dinner at 21-30".match(regexp) ); // 09:00, 21-30
 ```
 
-P.S. In this task we assume that the time is always correct, there's no need to filter out bad strings like "45:67". Later we'll deal with that too.
+P.S. In questo esercizio che l'orario è sempre corretto, non c'è necessità di filtrare stringhe come "45:67". Più tardi ci occuperemo anche di questo.
diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index a1b8f896d..439bcef1f 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -1,169 +1,169 @@
-# Sets and ranges [...]
+# Insiemi e intervalli [...]
 
-Several characters or character classes inside square brackets `[…]` mean to "search for any character among given".
+Diversi caratteri o classi di caratteri all'interno di parantesi quadre `[…]` significao "cercare qualsiasi carattere tra quelli dati".
 
-## Sets
+## Insiemi
 
-For instance, `pattern:[eao]` means any of the 3 characters: `'a'`, `'e'`, or `'o'`.
+Per esempio, `pattern:[eao]` significa qualunque dei 3 caratteri: `'a'`, `'e'`, o `'o'`.
 
-That's called a *set*. Sets can be used in a regexp along with regular characters:
+Questo è chiamato un *insieme* (set). Gli insiemi posso essere usati in una regexp insieme ai caratteri normali:
 
 ```js run
-// find [t or m], and then "op"
+// trova [t o m], e quindi "op"
 alert( "Mop top".match(/[tm]op/gi) ); // "Mop", "top"
 ```
 
-Please note that although there are multiple characters in the set, they correspond to exactly one character in the match.
+Si noti che sebbene ci siano più caratteri nel set, corrispondono esattamente a un carattere nel match.
 
-So the example below gives no matches:
+Quindi il seguente esempio non da alcuna corrispondenza:
 
 ```js run
-// find "V", then [o or i], then "la"
-alert( "Voila".match(/V[oi]la/) ); // null, no matches
+// trova "V", poi [o o i], quindi "la"
+alert( "Voila".match(/V[oi]la/) ); // null, nessuna corrispondenza
 ```
 
-The pattern searches for:
+Il modello di ricerca risulta quindi:
 
 - `pattern:V`,
-- then *one* of the letters `pattern:[oi]`,
-- then `pattern:la`.
+- poi *una* di queste lettere `pattern:[oi]`,
+- quindi `pattern:la`.
 
-So there would be a match for `match:Vola` or `match:Vila`.
+Significa che ci dovrebbe essere una corrispondenza per `match:Vola` o `match:Vila`.
 
-## Ranges
+## Intervalli
 
-Square brackets may also contain *character ranges*.
+Le parentesi quadre possono contenere anche *intervalli di caratteri*.
 
-For instance, `pattern:[a-z]` is a character in range from `a` to `z`, and `pattern:[0-5]` is a digit from `0` to `5`.
+Per esempio, `pattern:[a-z]` indica un carattere nell'intervallo che va da `a` a `z`, e `pattern:[0-5]` indica un numero tra `0` e `5`.
 
-In the example below we're searching for `"x"` followed by two digits or letters from `A` to `F`:
+Nell'esempio seguente cercheremo una `"x"` seguita da due numeri o lettere da `A` a `F`:
 
 ```js run
 alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF
 ```
 
-Here `pattern:[0-9A-F]` has two ranges: it searches for a character that is either a digit from `0` to `9` or a letter from `A` to `F`.
+Il modello `pattern:[0-9A-F]` ha due intervalli: cerca un carattere che sia una cifra da `0` a `9` o una lettera da `A` a `F`.
 
-If we'd like to look for lowercase letters as well, we can add the range `a-f`: `pattern:[0-9A-Fa-f]`. Or add the flag `pattern:i`.
+Se vorremo cercare anche lettere minuscole, possiamo aggiungere l'intervallo `a-f`: `pattern:[0-9A-Fa-f]`. O aggiungere il flagr `pattern:i`.
 
-We can also use character classes inside `[…]`.
+Possiamo anche usare la classe di caratteri `[…]`.
 
-For instance, if we'd like to look for a wordly character `pattern:\w` or a hyphen `pattern:-`, then the set is `pattern:[\w-]`.
+Per esempio, se vorremmo cercare qualunque carattere `pattern:\w` o un trattino `pattern:-`, allora l'insieme sarà `pattern:[\w-]`.
 
-Combining multiple classes is also possible, e.g. `pattern:[\s\d]` means "a space character or a digit".
+È anche possibile combinare diverse classi, a.e. `pattern:[\s\d]` significa "uno spazio o un numero".
 
-```smart header="Character classes are shorthands for certain character sets"
-For instance:
+```smart header="Le classi di caratteri sono abbreviazioni per determinati set di caratteri"
+Per esempio:
 
-- **\d** -- is the same as `pattern:[0-9]`,
-- **\w** -- is the same as `pattern:[a-zA-Z0-9_]`,
-- **\s** -- is the same as `pattern:[\t\n\v\f\r ]`, plus few other rare Unicode space characters.
+- **\d** -- è la stessa cosa di `pattern:[0-9]`,
+- **\w** -- è la stessa cosa di `pattern:[a-zA-Z0-9_]`,
+- **\s** -- è la stessa cosa di `pattern:[\t\n\v\f\r ]`, pochi altri rari caratteri Unicode.
 ```
 
-### Example: multi-language \w
+### Esempio: multi lingua \w
 
-As the character class `pattern:\w` is a shorthand for `pattern:[a-zA-Z0-9_]`, it can't find Chinese hieroglyphs, Cyrillic letters, etc.
+La classe di caratteri `pattern:\w` è una scorciatoia per `pattern:[a-zA-Z0-9_]`, non può trovare geroglifici Cinesi, lettere Cirilliche, ecc.
 
-We can write a more universal pattern, that looks for wordly characters in any language. That's easy with Unicode properties: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`.
+Possiamo allora scrivere un modello più universale, che può trovare qualunque carattere in qualunque lingua. È facile con le proprietà Unicode: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`.
 
-Let's decipher it. Similar to `pattern:\w`, we're making a set of our own that includes characters with following Unicode properties:
+Decifriamolo. Similarmente a `pattern:\w`, stiamo creando un nostro insieme che include i caratteri con le seguenti proprietà Unicode:
 
-- `Alphabetic` (`Alpha`) - for letters,
-- `Mark` (`M`) - for accents,
-- `Decimal_Number` (`Nd`) - for digits,
-- `Connector_Punctuation` (`Pc`) - for the underscore `'_'` and similar characters,
-- `Join_Control` (`Join_C`) - two special codes `200c` and `200d`, used in ligatures, e.g. in Arabic.
+- `Alphabetic` (`Alpha`) - per le lettere,
+- `Mark` (`M`) - per gli accenti,
+- `Decimal_Number` (`Nd`) - per i numeri,
+- `Connector_Punctuation` (`Pc`) - per il trattino basso `'_'` e caratteri simili,
+- `Join_Control` (`Join_C`) - due codici specialis `200c` e `200d`, usati nelle legature, a.e. in Arabo.
 
-An example of use:
+Un esempio di utilizzo:
 
 ```js run
 let regexp = /[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]/gu;
 
 let str = `Hi 你好 12`;
 
-// finds all letters and digits:
+// Cerca tutte le lettere e i numeri:
 alert( str.match(regexp) ); // H,i,你,好,1,2
 ```
 
-Of course, we can edit this pattern: add Unicode properties or remove them. Unicode properties are covered in more details in the article <info:regexp-unicode>.
+Naturalmente, possiamo modificare questo modello: aggiungere proprietà Unicode o rimuoverle. Le proprietà Unicode sono descritte meglio nell'articolo <info:regexp-unicode>.
 
-```warn header="Unicode properties aren't supported in IE"
-Unicode properties `pattern:p{…}` are not implemented in IE. If we really need them, we can use library [XRegExp](http://xregexp.com/).
+```warn header="Le proprietà Unicode non sono supportate da IE"
+Le proprietà Unicode `pattern:p{…}` non sono implementate in IE. Se ci necessitano veramente, possiamo utilizzare la libreria [XRegExp](http://xregexp.com/).
 
-Or just use ranges of characters in a language that interests us, e.g.  `pattern:[а-я]` for Cyrillic letters.
+O giusto utilizzare un intervallo di caratteri nella lingua che ci interessa, a.e.  `pattern:[а-я]` per le lettere Cirilliche.
 ```
 
-## Excluding ranges
+## Esclusione di intervalli
 
-Besides normal ranges, there are "excluding" ranges that look like `pattern:[^…]`.
+Oltre ai normali intervalli, è possibile creare dei modelli di "esclusione"come `pattern:[^…]`.
 
-They are denoted by a caret character `^` at the start and match any character *except the given ones*.
+Vengono indicati da un accento circonflesso `^` all'inizio e indicano qualunque carattere *tranne quelli forniti*.
 
-For instance:
+Per esempio:
 
-- `pattern:[^aeyo]` -- any character except  `'a'`, `'e'`, `'y'` or `'o'`.
-- `pattern:[^0-9]` -- any character except a digit, the same as `pattern:\D`.
-- `pattern:[^\s]` -- any non-space character, same as `\S`.
+- `pattern:[^aeyo]` -- qualunque carattere tranne  `'a'`, `'e'`, `'y'` o `'o'`.
+- `pattern:[^0-9]` -- qualunque carattere tranne un numero, come `pattern:\D`.
+- `pattern:[^\s]` -- qualunque carattere che non sia uno spazio, come `\S`.
 
-The example below looks for any characters except letters, digits and spaces:
+L'esempio seguente cerca per qualunque carattere eccetto lettere, numeri e spazi:
 
 ```js run
-alert( "alice15@gmail.com".match(/[^\d\sA-Z]/gi) ); // @ and .
+alert( "alice15@gmail.com".match(/[^\d\sA-Z]/gi) ); // @ e .
 ```
 
 ## Escaping in […]
 
-Usually when we want to find exactly a special character, we need to escape it like `pattern:\.`. And if we need a backslash, then we use `pattern:\\`, and so on.
+In genere quando vogliamo trovare esattamente un carattere speciale, dobbiamo effettuarne l'escape come `pattern:\.`. E se abbiamo bisogno di un backslash, allora dobbiamo usare `pattern:\\`, e così via.
 
-In square brackets we can use the vast majority of special characters without escaping:
+Dentro le parentesi quadre, possiamo usare la stragrande maggioranza di caratteri speciali senza la necessità di effettuarne l'escaping:
 
-- Symbols `pattern:. + ( )` never need escaping.
-- A hyphen `pattern:-` is not escaped in the beginning or the end (where it does not define a range).
-- A caret `pattern:^` is only escaped in the beginning (where it means exclusion).
-- The closing square bracket `pattern:]` is always escaped (if we need to look for that symbol).
+- I simboli `pattern:. + ( )` non necessitano mai di escaping.
+- Il trattino `pattern:-` non è preceduto da caratteri di escape all'inizio o alla fine (dove non definisce un intervallo).
+- Un accento circonflesso `pattern:^` è soggeto ad escape solo all'inizio (dove significa esclusione).
+- La parentesi quadra di chiusura `pattern:]` dev'essere sempre soggetta ad escape (se abbiamo bisogno di cercare questo simbolo).
 
-In other words, all special characters are allowed without escaping, except when they mean something for square brackets.
+In altre parole, tutti i caratteri speciali sono permessi senza necessita di escape, eccetto quando servono a qualcosa nelle parentesi quadre.
 
-A dot `.` inside square brackets means just a dot. The pattern `pattern:[.,]` would look for one of characters: either a dot or a comma.
+Un punto `.` all'interno delle parentesi quadre significa giusto un punto. Il modello `pattern:[.,]` cercherebbe per uno dei caratteri: o un punto o una virgola.
 
-In the example below the regexp `pattern:[-().^+]` looks for one of the characters `-().^+`:
+Nell'esempio seguente la regexp `pattern:[-().^+]` effettua la ricerca per uno dei caratteri `-().^+`:
 
 ```js run
-// No need to escape
+// Non necessita di escape
 let regexp = /[-().^+]/g;
 
-alert( "1 + 2 - 3".match(regexp) ); // Matches +, -
+alert( "1 + 2 - 3".match(regexp) ); // Corrispondono +, -
 ```
 
-...But if you decide to escape them "just in case", then there would be no harm:
+...Ma se decidi di effettuarne l'escape "giusto per non sbagliare", il risultato non cambierebbe:
 
 ```js run
-// Escaped everything
+// Escape tutto
 let regexp = /[\-\(\)\.\^\+]/g;
 
-alert( "1 + 2 - 3".match(regexp) ); // also works: +, -
+alert( "1 + 2 - 3".match(regexp) ); // funziona ugualmente: +, -
 ```
 
-## Ranges and flag "u"
+## Intervalli e flag "u"
 
-If there are surrogate pairs in the set, flag `pattern:u` is required for them to work correctly.
+Se ci sono coppie surrogate nel set, il flag `pattern:u` è necessario affinché funzionino correttamente.
 
-For instance, let's look for `pattern:[𝒳𝒴]` in the string `subject:𝒳`:
+Per esempio, cerchiamo `pattern:[𝒳𝒴]` nella stringa `subject:𝒳`:
 
 ```js run
-alert( '𝒳'.match(/[𝒳𝒴]/) ); // shows a strange character, like [?]
-// (the search was performed incorrectly, half-character returned)
+alert( '𝒳'.match(/[𝒳𝒴]/) ); // mostra uno strano carattere, come [?]
+// (la ricerca è stata eseguita in modo errato, mezzo-carattere restituito)
 ```
 
-The result is incorrect, because by default regular expressions "don't know" about surrogate pairs.
+Il risultato non è corretto, perché di base la regular expressions "non sa nulla" riguardo le coppie surrogate.
 
-The regular expression engine thinks that `[𝒳𝒴]` -- are not two, but four characters:
-1. left half of `𝒳` `(1)`,
-2. right half of `𝒳` `(2)`,
-3. left half of `𝒴` `(3)`,
-4. right half of `𝒴` `(4)`.
+Il motore delle regular expression pensa che `[𝒳𝒴]` -- non sono due, ma quattro caratteri:
+1. metà alla sinistra di `𝒳` `(1)`,
+2. metà alla destra di `𝒳` `(2)`,
+3. metà alla sinistra di `𝒴` `(3)`,
+4. metà alla destra di `𝒴` `(4)`.
 
-We can see their codes like this:
+Possiamo vedere il suo codice in questo modo:
 
 ```js run
 for(let i=0; i<'𝒳𝒴'.length; i++) {
@@ -171,27 +171,27 @@ for(let i=0; i<'𝒳𝒴'.length; i++) {
 };
 ```
 
-So, the example above finds and shows the left half of `𝒳`.
+Quini, l'esempio qui sopra trova e visualizza la metà alla sinistra di `𝒳`.
 
-If we add flag `pattern:u`, then the behavior will be correct:
+Se aggiungiamo il flag `pattern:u`, allora il comportamento sarà corretto:
 
 ```js run
 alert( '𝒳'.match(/[𝒳𝒴]/u) ); // 𝒳
 ```
 
-The similar situation occurs when looking for a range, such as `[𝒳-𝒴]`.
+Una situazione simile si verifica quando si cerca un intervallo, come `[𝒳-𝒴]`.
 
-If we forget to add flag `pattern:u`, there will be an error:
+Se dimentichiamo di aggiungere il flag `pattern:u`, ci sarà un errore:
 
 ```js run
-'𝒳'.match(/[𝒳-𝒴]/); // Error: Invalid regular expression
+'𝒳'.match(/[𝒳-𝒴]/); // Errore: Invalid regular expression
 ```
 
-The reason is that without flag `pattern:u` surrogate pairs are perceived as two characters, so `[𝒳-𝒴]` is interpreted as `[<55349><56499>-<55349><56500>]` (every surrogate pair is replaced with its codes). Now it's easy to see that the range `56499-55349` is invalid: its starting code `56499` is greater than the end `55349`. That's the formal reason for the error.
+La ragione è che senza il flag `pattern:u` le coppie surrogate sono percepite come due caratteri, quindi `[𝒳-𝒴]` è interpretato come `[<55349><56499>-<55349><56500>]` (ogni coppia di surrogato è sostituito con il suo codice). Ora è facile vedere che l'intervallo `56499-55349` non è valido: esso inizia con il codice `56499` che è inferiore che finisce con `55349`. Questa è la ragione formale dell'errore.
 
-With the flag `pattern:u` the pattern works correctly:
+Con il flag `pattern:u` il modello funziona correttamente:
 
 ```js run
-// look for characters from 𝒳 to 𝒵
+// cerca per i caratteri da 𝒳 a 𝒵
 alert( '𝒴'.match(/[𝒳-𝒵]/u) ); // 𝒴
 ```

From cceb0f7f3958b3023176b411e5c9e217c7f3decb Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Wed, 21 Apr 2021 16:29:15 +0200
Subject: [PATCH 02/29] Revisione testo

---
 .../1-find-range-1/solution.md                |  3 ++-
 .../2-find-time-2-formats/task.md             |  2 +-
 .../article.md                                | 20 +++++++++----------
 3 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
index a221f0e38..a43c0c8a6 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
@@ -5,8 +5,9 @@ Risposte: **no, sì**.
     ```js run
     alert( "Java".match(/Java[^script]/) ); // null
     ```
-- Sì, poiché la parte `pattern:[^script]` al carattere `"S"`. Non è uno di `pattern:script`. Poiché la regexp fa distinzione tra maiuscole e minuscole (non c'è il flag `pattern:i`), tratta `"S"` come un carattere differente da `"s"`.
+- Sì, poiché la parte `pattern:[^script]` al carattere `"S"`, non è uno di `pattern:script`. Poiché la regexp fa distinzione tra maiuscole e minuscole (non c'è il flag `pattern:i`), tratta `"S"` come un carattere differente da `"s"`.
 
     ```js run
     alert( "JavaScript".match(/Java[^script]/) ); // "JavaS"
     ```
+    
\ No newline at end of file
diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
index 09ac7f54a..04ab43560 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
@@ -9,4 +9,4 @@ let regexp = /your regexp/g;
 alert( "Breakfast at 09:00. Dinner at 21-30".match(regexp) ); // 09:00, 21-30
 ```
 
-P.S. In questo esercizio che l'orario è sempre corretto, non c'è necessità di filtrare stringhe come "45:67". Più tardi ci occuperemo anche di questo.
+P.S. In questo esercizio considereremo che l'orario è sempre corretto, non c'è necessità di filtrare stringhe come "45:67". Più tardi ci occuperemo anche di questo tipo di problema.
diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 439bcef1f..fae3215d8 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -1,12 +1,12 @@
 # Insiemi e intervalli [...]
 
-Diversi caratteri o classi di caratteri all'interno di parantesi quadre `[…]` significao "cercare qualsiasi carattere tra quelli dati".
+Diversi caratteri o classi di caratteri inseriti all'interno di parantesi quadre `[…]` significano "cercare qualsiasi carattere tra quelli forniti".
 
 ## Insiemi
 
-Per esempio, `pattern:[eao]` significa qualunque dei 3 caratteri: `'a'`, `'e'`, o `'o'`.
+Per esempio, `pattern:[eao]` significa qualunque dei 3 caratteri: `'a'`, `'e'`, od `'o'`.
 
-Questo è chiamato un *insieme* (set). Gli insiemi posso essere usati in una regexp insieme ai caratteri normali:
+Questo è chiamato un *insieme* o *set*. I sets posso essere usati in una regexp insieme ad altri caratteri:
 
 ```js run
 // trova [t o m], e quindi "op"
@@ -18,7 +18,7 @@ Si noti che sebbene ci siano più caratteri nel set, corrispondono esattamente a
 Quindi il seguente esempio non da alcuna corrispondenza:
 
 ```js run
-// trova "V", poi [o o i], quindi "la"
+// trova "V", poi ['o' o 'i'], quindi "la"
 alert( "Voila".match(/V[oi]la/) ); // null, nessuna corrispondenza
 ```
 
@@ -62,9 +62,9 @@ Per esempio:
 
 ### Esempio: multi lingua \w
 
-La classe di caratteri `pattern:\w` è una scorciatoia per `pattern:[a-zA-Z0-9_]`, non può trovare geroglifici Cinesi, lettere Cirilliche, ecc.
+La classe di caratteri `pattern:\w` è una scorciatoia per `pattern:[a-zA-Z0-9_]`, che tuttavia non può trovare geroglifici Cinesi, lettere Cirilliche, ecc.
 
-Possiamo allora scrivere un modello più universale, che può trovare qualunque carattere in qualunque lingua. È facile con le proprietà Unicode: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`.
+Possiamo allora scrivere un modello più universale, che può trovare qualunque carattere in qualunque lingua. Questo è reso facile dalle proprietà Unicode: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`.
 
 Decifriamolo. Similarmente a `pattern:\w`, stiamo creando un nostro insieme che include i caratteri con le seguenti proprietà Unicode:
 
@@ -95,7 +95,7 @@ O giusto utilizzare un intervallo di caratteri nella lingua che ci interessa, a.
 
 ## Esclusione di intervalli
 
-Oltre ai normali intervalli, è possibile creare dei modelli di "esclusione"come `pattern:[^…]`.
+Oltre ai normali intervalli, è possibile creare dei modelli di "esclusione", come `pattern:[^…]`.
 
 Vengono indicati da un accento circonflesso `^` all'inizio e indicano qualunque carattere *tranne quelli forniti*.
 
@@ -122,7 +122,7 @@ Dentro le parentesi quadre, possiamo usare la stragrande maggioranza di caratter
 - Un accento circonflesso `pattern:^` è soggeto ad escape solo all'inizio (dove significa esclusione).
 - La parentesi quadra di chiusura `pattern:]` dev'essere sempre soggetta ad escape (se abbiamo bisogno di cercare questo simbolo).
 
-In altre parole, tutti i caratteri speciali sono permessi senza necessita di escape, eccetto quando servono a qualcosa nelle parentesi quadre.
+In altre parole, tutti i caratteri speciali sono permessi senza necessita di escape, eccetto quando servono a qualcosa all'interno delle parentesi quadre.
 
 Un punto `.` all'interno delle parentesi quadre significa giusto un punto. Il modello `pattern:[.,]` cercherebbe per uno dei caratteri: o un punto o una virgola.
 
@@ -135,7 +135,7 @@ let regexp = /[-().^+]/g;
 alert( "1 + 2 - 3".match(regexp) ); // Corrispondono +, -
 ```
 
-...Ma se decidi di effettuarne l'escape "giusto per non sbagliare", il risultato non cambierebbe:
+...Ma se decidiamo di effettuarne l'escape "giusto per non sbagliare", il risultato non cambierebbe:
 
 ```js run
 // Escape tutto
@@ -146,7 +146,7 @@ alert( "1 + 2 - 3".match(regexp) ); // funziona ugualmente: +, -
 
 ## Intervalli e flag "u"
 
-Se ci sono coppie surrogate nel set, il flag `pattern:u` è necessario affinché funzionino correttamente.
+Se ci sono coppie surrogate nel set, il flag `pattern:u` è necessario affinché la ricerca funzioni correttamente.
 
 Per esempio, cerchiamo `pattern:[𝒳𝒴]` nella stringa `subject:𝒳`:
 

From bef4fa0f0baa9635c42312321490e066d85a3fa1 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:29:55 +0200
Subject: [PATCH 03/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index fae3215d8..fa91a6939 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -1,6 +1,6 @@
 # Insiemi e intervalli [...]
 
-Diversi caratteri o classi di caratteri inseriti all'interno di parantesi quadre `[…]` significano "cercare qualsiasi carattere tra quelli forniti".
+Alcuni caratteri o classi di caratteri inseriti all'interno di parantesi quadre `[…]` significano "cerca qualsiasi carattere tra quelli forniti".
 
 ## Insiemi
 

From 1de52139e7fc644be3b24df4da27873cb76a4f0e Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:30:23 +0200
Subject: [PATCH 04/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index fa91a6939..ee1d0ff6d 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -4,7 +4,7 @@ Alcuni caratteri o classi di caratteri inseriti all'interno di parantesi quadre
 
 ## Insiemi
 
-Per esempio, `pattern:[eao]` significa qualunque dei 3 caratteri: `'a'`, `'e'`, od `'o'`.
+Per esempio, `pattern:[eao]` significa uno qualunque dei 3 caratteri: `'a'`, `'e'`, od `'o'`.
 
 Questo è chiamato un *insieme* o *set*. I sets posso essere usati in una regexp insieme ad altri caratteri:
 

From 81318029177187dd839648de38c48a3cf0019679 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:32:13 +0200
Subject: [PATCH 05/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index ee1d0ff6d..5155299c2 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -6,7 +6,7 @@ Alcuni caratteri o classi di caratteri inseriti all'interno di parantesi quadre
 
 Per esempio, `pattern:[eao]` significa uno qualunque dei 3 caratteri: `'a'`, `'e'`, od `'o'`.
 
-Questo è chiamato un *insieme* o *set*. I sets posso essere usati in una regexp insieme ad altri caratteri:
+Questo è chiamato un *insieme* o *set*. I set posso essere usati in una regexp insieme ad altri caratteri:
 
 ```js run
 // trova [t o m], e quindi "op"

From dea64d7e98087a5218a502f8bb7a3333a3df078f Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:32:35 +0200
Subject: [PATCH 06/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 5155299c2..f7da10b8b 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -13,7 +13,7 @@ Questo è chiamato un *insieme* o *set*. I set posso essere usati in una regexp
 alert( "Mop top".match(/[tm]op/gi) ); // "Mop", "top"
 ```
 
-Si noti che sebbene ci siano più caratteri nel set, corrispondono esattamente a un carattere nel match.
+Si noti che sebbene ci siano più caratteri nel set, questi corrispondano esattamente a un carattere nel match.
 
 Quindi il seguente esempio non da alcuna corrispondenza:
 

From 8d9ee2a4d66b5cc5d6b30297824f5476dab89c85 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:32:53 +0200
Subject: [PATCH 07/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index f7da10b8b..45d8802d4 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -15,7 +15,7 @@ alert( "Mop top".match(/[tm]op/gi) ); // "Mop", "top"
 
 Si noti che sebbene ci siano più caratteri nel set, questi corrispondano esattamente a un carattere nel match.
 
-Quindi il seguente esempio non da alcuna corrispondenza:
+Quindi il seguente esempio non dà alcuna corrispondenza:
 
 ```js run
 // trova "V", poi ['o' o 'i'], quindi "la"

From dc42eb45162de680516c6c23312d8113d218ba5d Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:33:11 +0200
Subject: [PATCH 08/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../1-find-range-1/solution.md                                | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
index a43c0c8a6..5b90edf4a 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
@@ -1,6 +1,6 @@
 Risposte: **no, sì**.
 
-- Nello script `subject:Java` non corrisponde nulla, dato che per `pattern:[^script]` si intende "qualunque carattere eccetto quelli dati". Quindi la regexp cerca per `"Java"` seguito da uno di questi simboli, ma c'è una stringa alla fine, non ci sono symboli dopo di esso.
+- Nello script `subject:Java` non c'è corrispondenza, dato che per `pattern:[^script]` si intende "qualunque carattere eccetto quelli dati". Quindi la regexp cerca `"Java"` seguito da uno di tali caratteri, ma c'è la fine della stringa, non ci sono caratteri dopo di esso.
 
     ```js run
     alert( "Java".match(/Java[^script]/) ); // null
@@ -10,4 +10,4 @@ Risposte: **no, sì**.
     ```js run
     alert( "JavaScript".match(/Java[^script]/) ); // "JavaS"
     ```
-    
\ No newline at end of file
+    

From d6ca49a5192ea4746735cd853cc27938ba7898f5 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:33:27 +0200
Subject: [PATCH 09/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../1-find-range-1/solution.md                                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
index 5b90edf4a..8bc605e39 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/solution.md
@@ -5,7 +5,7 @@ Risposte: **no, sì**.
     ```js run
     alert( "Java".match(/Java[^script]/) ); // null
     ```
-- Sì, poiché la parte `pattern:[^script]` al carattere `"S"`, non è uno di `pattern:script`. Poiché la regexp fa distinzione tra maiuscole e minuscole (non c'è il flag `pattern:i`), tratta `"S"` come un carattere differente da `"s"`.
+- Sì, poiché `pattern:[^script]` trova il carattere `"S"` che non è uno di `pattern:script`. Considerato che la regexp fa distinzione tra maiuscole e minuscole (non c'è il flag `pattern:i`), tratta `"S"` come un carattere differente da `"s"`.
 
     ```js run
     alert( "JavaScript".match(/Java[^script]/) ); // "JavaS"

From 68f6fa6f72260fc2323334cce59feb77b7b6c4fc Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:33:40 +0200
Subject: [PATCH 10/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../2-find-time-2-formats/task.md                               | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
index 04ab43560..4258922aa 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
@@ -1,6 +1,6 @@
 # Trova l'orario come hh:mm o hh-mm
 
-L'orario può essere nel formato `ore:minuti` o `ore-minuti`. Entrambi ore e minuti hanno 2 numeri:  `09:00` o `21-30`.
+L'orario può essere nel formato `ore:minuti` o `ore-minuti`. Entrambi, ore e minuti, hanno 2 numeri:  `09:00` o `21-30`.
 
 Scrivi una regexp per trovare l'orario:
 

From 80a33e45f246beee4e2c1f63de1fefdde84bf801 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:34:25 +0200
Subject: [PATCH 11/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../2-find-time-2-formats/task.md                               | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
index 4258922aa..c127c008e 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md
@@ -2,7 +2,7 @@
 
 L'orario può essere nel formato `ore:minuti` o `ore-minuti`. Entrambi, ore e minuti, hanno 2 numeri:  `09:00` o `21-30`.
 
-Scrivi una regexp per trovare l'orario:
+Scrivete una regexp per trovare l'orario:
 
 ```js
 let regexp = /your regexp/g;

From 98b551265cbfd3d5ecc8a8ee86761027c1c331c4 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:34:33 +0200
Subject: [PATCH 12/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../2-find-time-2-formats/solution.md                           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
index 07c6a495a..242668464 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md
@@ -5,4 +5,4 @@ let regexp = /\d\d[-:]\d\d/g;
 alert( "Breakfast at 09:00. Dinner at 21-30".match(regexp) ); // 09:00, 21-30
 ```
 
-Perfavore notate che il trattino `pattern:'-'` ha un significato speciale tra le parentesi quadre, ma solo tra gli altri caratteri, non quando è all'inizio o alla fine, quindi non c'è bisogno dell'escape.
+Fate attenzione al fatto che il trattino `pattern:'-'` ha un significato speciale tra le parentesi quadre, ma solo tra gli altri caratteri, non quando è all'inizio o alla fine, quindi non c'è bisogno dell'escape.

From bb6228530a42d0f70cd0e58fad681cb8baab059c Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:34:51 +0200
Subject: [PATCH 13/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 45d8802d4..fd12d6733 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -44,7 +44,7 @@ alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF
 
 Il modello `pattern:[0-9A-F]` ha due intervalli: cerca un carattere che sia una cifra da `0` a `9` o una lettera da `A` a `F`.
 
-Se vorremo cercare anche lettere minuscole, possiamo aggiungere l'intervallo `a-f`: `pattern:[0-9A-Fa-f]`. O aggiungere il flagr `pattern:i`.
+Se volessimo cercare anche lettere minuscole, possiamo aggiungere l'intervallo `a-f`: `pattern:[0-9A-Fa-f]`, o aggiungere il flag `pattern:i`.
 
 Possiamo anche usare la classe di caratteri `[…]`.
 

From e54846f61401b524459b57fa3619ef965d5fd457 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:35:04 +0200
Subject: [PATCH 14/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index fd12d6733..caa3f081f 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -46,7 +46,7 @@ Il modello `pattern:[0-9A-F]` ha due intervalli: cerca un carattere che sia una
 
 Se volessimo cercare anche lettere minuscole, possiamo aggiungere l'intervallo `a-f`: `pattern:[0-9A-Fa-f]`, o aggiungere il flag `pattern:i`.
 
-Possiamo anche usare la classe di caratteri `[…]`.
+Possiamo anche usare classi di caratteri dentro `[…]`.
 
 Per esempio, se vorremmo cercare qualunque carattere `pattern:\w` o un trattino `pattern:-`, allora l'insieme sarà `pattern:[\w-]`.
 

From 38f74e35e68e3bde4d81826048be4be85cdfd773 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:35:18 +0200
Subject: [PATCH 15/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index caa3f081f..eb32c360f 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -48,7 +48,7 @@ Se volessimo cercare anche lettere minuscole, possiamo aggiungere l'intervallo `
 
 Possiamo anche usare classi di caratteri dentro `[…]`.
 
-Per esempio, se vorremmo cercare qualunque carattere `pattern:\w` o un trattino `pattern:-`, allora l'insieme sarà `pattern:[\w-]`.
+Per esempio, se volessimo cercare un carattere di parola `pattern:\w` o un trattino `pattern:-`, allora l'insieme sarà `pattern:[\w-]`.
 
 È anche possibile combinare diverse classi, a.e. `pattern:[\s\d]` significa "uno spazio o un numero".
 

From f3dbd62626dd5a3afd94371eac6f4975dddfc756 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:35:34 +0200
Subject: [PATCH 16/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index eb32c360f..faa4e8d78 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -50,7 +50,7 @@ Possiamo anche usare classi di caratteri dentro `[…]`.
 
 Per esempio, se volessimo cercare un carattere di parola `pattern:\w` o un trattino `pattern:-`, allora l'insieme sarà `pattern:[\w-]`.
 
-È anche possibile combinare diverse classi, a.e. `pattern:[\s\d]` significa "uno spazio o un numero".
+È anche possibile combinare diverse classi, es `pattern:[\s\d]` significa "uno spazio o un numero".
 
 ```smart header="Le classi di caratteri sono abbreviazioni per determinati set di caratteri"
 Per esempio:

From 3525c1e355639aec1ba7863f29deb090dabf6d4a Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:35:55 +0200
Subject: [PATCH 17/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index faa4e8d78..8b5f1a154 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -57,7 +57,7 @@ Per esempio:
 
 - **\d** -- è la stessa cosa di `pattern:[0-9]`,
 - **\w** -- è la stessa cosa di `pattern:[a-zA-Z0-9_]`,
-- **\s** -- è la stessa cosa di `pattern:[\t\n\v\f\r ]`, pochi altri rari caratteri Unicode.
+- **\s** -- è la stessa cosa di `pattern:[\t\n\v\f\r ]` e pochi altri rari caratteri Unicode.
 ```
 
 ### Esempio: multi lingua \w

From ba8a2ba1dd5bb520b5fabbdceb7dad724ff212f2 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:36:43 +0200
Subject: [PATCH 18/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 8b5f1a154..82b3c3216 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -62,7 +62,7 @@ Per esempio:
 
 ### Esempio: multi lingua \w
 
-La classe di caratteri `pattern:\w` è una scorciatoia per `pattern:[a-zA-Z0-9_]`, che tuttavia non può trovare geroglifici Cinesi, lettere Cirilliche, ecc.
+Dal momento che la classe di caratteri `pattern:\w` è una scorciatoia per `pattern:[a-zA-Z0-9_]`, non può trovare geroglifici cinesi, lettere cirilliche, ecc.
 
 Possiamo allora scrivere un modello più universale, che può trovare qualunque carattere in qualunque lingua. Questo è reso facile dalle proprietà Unicode: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`.
 

From 48ca78baaeaff26fe45e811839653f1be0a7bccf Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:36:59 +0200
Subject: [PATCH 19/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 82b3c3216..e097e138d 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -64,7 +64,7 @@ Per esempio:
 
 Dal momento che la classe di caratteri `pattern:\w` è una scorciatoia per `pattern:[a-zA-Z0-9_]`, non può trovare geroglifici cinesi, lettere cirilliche, ecc.
 
-Possiamo allora scrivere un modello più universale, che può trovare qualunque carattere in qualunque lingua. Questo è reso facile dalle proprietà Unicode: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`.
+Possiamo allora scrivere un modello più universale, che cerca un carattere di parola in qualunque lingua. Questo è reso facile dalle proprietà Unicode: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`.
 
 Decifriamolo. Similarmente a `pattern:\w`, stiamo creando un nostro insieme che include i caratteri con le seguenti proprietà Unicode:
 

From 170ed294714f13eef1429ed4bee4b0789d69b6b6 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:37:34 +0200
Subject: [PATCH 20/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index e097e138d..830a71c10 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -81,7 +81,7 @@ let regexp = /[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]/gu;
 
 let str = `Hi 你好 12`;
 
-// Cerca tutte le lettere e i numeri:
+// Trova tutte le lettere e i numeri:
 alert( str.match(regexp) ); // H,i,你,好,1,2
 ```
 

From d81514af649dc08eca4275b789f15567dddf41a1 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:37:55 +0200
Subject: [PATCH 21/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 830a71c10..3d1a62e3e 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -85,7 +85,7 @@ let str = `Hi 你好 12`;
 alert( str.match(regexp) ); // H,i,你,好,1,2
 ```
 
-Naturalmente, possiamo modificare questo modello: aggiungere proprietà Unicode o rimuoverle. Le proprietà Unicode sono descritte meglio nell'articolo <info:regexp-unicode>.
+Naturalmente possiamo modificare questo modello: aggiungere proprietà Unicode o rimuoverle. Le proprietà Unicode sono descritte meglio nell'articolo <info:regexp-unicode>.
 
 ```warn header="Le proprietà Unicode non sono supportate da IE"
 Le proprietà Unicode `pattern:p{…}` non sono implementate in IE. Se ci necessitano veramente, possiamo utilizzare la libreria [XRegExp](http://xregexp.com/).

From cf66dbd96b9554f1e8b7157252da4ccaed2105ca Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:38:10 +0200
Subject: [PATCH 22/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 3d1a62e3e..883daee8f 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -88,7 +88,7 @@ alert( str.match(regexp) ); // H,i,你,好,1,2
 Naturalmente possiamo modificare questo modello: aggiungere proprietà Unicode o rimuoverle. Le proprietà Unicode sono descritte meglio nell'articolo <info:regexp-unicode>.
 
 ```warn header="Le proprietà Unicode non sono supportate da IE"
-Le proprietà Unicode `pattern:p{…}` non sono implementate in IE. Se ci necessitano veramente, possiamo utilizzare la libreria [XRegExp](http://xregexp.com/).
+Le proprietà Unicode `pattern:p{…}` non sono implementate in IE. Se ne abbiamo davvero bisogno possiamo utilizzare la libreria [XRegExp](http://xregexp.com/).
 
 O giusto utilizzare un intervallo di caratteri nella lingua che ci interessa, a.e.  `pattern:[а-я]` per le lettere Cirilliche.
 ```

From 3af0f823bdb8aa10902a8b4b7ccef19d49e72fb3 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:40:34 +0200
Subject: [PATCH 23/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 883daee8f..5479c05e7 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -90,7 +90,7 @@ Naturalmente possiamo modificare questo modello: aggiungere proprietà Unicode o
 ```warn header="Le proprietà Unicode non sono supportate da IE"
 Le proprietà Unicode `pattern:p{…}` non sono implementate in IE. Se ne abbiamo davvero bisogno possiamo utilizzare la libreria [XRegExp](http://xregexp.com/).
 
-O giusto utilizzare un intervallo di caratteri nella lingua che ci interessa, a.e.  `pattern:[а-я]` per le lettere Cirilliche.
+In alternativa possiamo utilizzare soltanto un intervallo di caratteri nella lingua che ci interessa, a.e.  `pattern:[а-я]` per le lettere cirilliche.
 ```
 
 ## Esclusione di intervalli

From bee28f89f9d3fd1ea8fe93b76917f95bbe53f5d9 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:40:48 +0200
Subject: [PATCH 24/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 5479c05e7..72f269eb9 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -97,7 +97,7 @@ In alternativa possiamo utilizzare soltanto un intervallo di caratteri nella lin
 
 Oltre ai normali intervalli, è possibile creare dei modelli di "esclusione", come `pattern:[^…]`.
 
-Vengono indicati da un accento circonflesso `^` all'inizio e indicano qualunque carattere *tranne quelli forniti*.
+Sono contraddistinti da un accento circonflesso `^` all'inizio e trovano corrispondenza in qualunque carattere *tranne quelli indicati*.
 
 Per esempio:
 

From c6f55bd892d4e110936543b67e96dbdfac1967cf Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:41:00 +0200
Subject: [PATCH 25/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index 72f269eb9..dce2db876 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -105,7 +105,7 @@ Per esempio:
 - `pattern:[^0-9]` -- qualunque carattere tranne un numero, come `pattern:\D`.
 - `pattern:[^\s]` -- qualunque carattere che non sia uno spazio, come `\S`.
 
-L'esempio seguente cerca per qualunque carattere eccetto lettere, numeri e spazi:
+L'esempio seguente cerca qualunque carattere eccetto lettere, numeri e spazi:
 
 ```js run
 alert( "alice15@gmail.com".match(/[^\d\sA-Z]/gi) ); // @ e .

From 9eacb150a42e9c4b838585bf51dc601c8693f064 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:44:01 +0200
Subject: [PATCH 26/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index dce2db876..efcf8536e 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -111,7 +111,7 @@ L'esempio seguente cerca qualunque carattere eccetto lettere, numeri e spazi:
 alert( "alice15@gmail.com".match(/[^\d\sA-Z]/gi) ); // @ e .
 ```
 
-## Escaping in […]
+## L'escape dentro […]
 
 In genere quando vogliamo trovare esattamente un carattere speciale, dobbiamo effettuarne l'escape come `pattern:\.`. E se abbiamo bisogno di un backslash, allora dobbiamo usare `pattern:\\`, e così via.
 

From 8bb29177fb4bf845a1f186c451333d3145e5c497 Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:47:55 +0200
Subject: [PATCH 27/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../08-regexp-character-sets-and-ranges/1-find-range-1/task.md  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md
index 4bfbc8ec1..1b454b004 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/1-find-range-1/task.md
@@ -2,4 +2,4 @@
 
 Abbiamo una regexp `pattern:/Java[^script]/`.
 
-Corrisponde a qualcosa nella stringa `subject:Java`? E nella stringa `subject:JavaScript`?
+Cosa corrisponde nella stringa `subject:Java`? E nella stringa `subject:JavaScript`?

From 012210b0403c35155b4b5c827d45fa7a5730f63a Mon Sep 17 00:00:00 2001
From: Mario Ravalli <mario@raval.li>
Date: Thu, 22 Apr 2021 11:59:53 +0200
Subject: [PATCH 28/29] Apply suggestions from code review

Grazie per le correzioni!

Co-authored-by: marcellosurdi <42266628+marcellosurdi@users.noreply.github.com>
---
 .../article.md                                | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index efcf8536e..be3920e44 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -113,18 +113,18 @@ alert( "alice15@gmail.com".match(/[^\d\sA-Z]/gi) ); // @ e .
 
 ## L'escape dentro […]
 
-In genere quando vogliamo trovare esattamente un carattere speciale, dobbiamo effettuarne l'escape come `pattern:\.`. E se abbiamo bisogno di un backslash, allora dobbiamo usare `pattern:\\`, e così via.
+In genere quando vogliamo trovare esattamente un carattere speciale, dobbiamo effettuarne l'escape: `pattern:\.`. Se abbiamo bisogno di un backslash, allora dobbiamo usare `pattern:\\`, e così via.
 
-Dentro le parentesi quadre, possiamo usare la stragrande maggioranza di caratteri speciali senza la necessità di effettuarne l'escaping:
+Dentro le parentesi quadre, possiamo usare la stragrande maggioranza di caratteri speciali senza la necessità di effettuarne l'escape:
 
 - I simboli `pattern:. + ( )` non necessitano mai di escaping.
 - Il trattino `pattern:-` non è preceduto da caratteri di escape all'inizio o alla fine (dove non definisce un intervallo).
-- Un accento circonflesso `pattern:^` è soggeto ad escape solo all'inizio (dove significa esclusione).
+- Un accento circonflesso `pattern:^` è soggetto ad escape solo all'inizio (dove significa esclusione).
 - La parentesi quadra di chiusura `pattern:]` dev'essere sempre soggetta ad escape (se abbiamo bisogno di cercare questo simbolo).
 
-In altre parole, tutti i caratteri speciali sono permessi senza necessita di escape, eccetto quando servono a qualcosa all'interno delle parentesi quadre.
+In altre parole, tutti i caratteri speciali sono consentiti senza necessità di escape, eccetto quando significano qualcosa all'interno delle parentesi quadre.
 
-Un punto `.` all'interno delle parentesi quadre significa giusto un punto. Il modello `pattern:[.,]` cercherebbe per uno dei caratteri: o un punto o una virgola.
+Un punto `.` all'interno delle parentesi quadre significa soltanto un punto. Il modello `pattern:[.,]` cercherebbe uno dei caratteri: o un punto o una virgola.
 
 Nell'esempio seguente la regexp `pattern:[-().^+]` effettua la ricerca per uno dei caratteri `-().^+`:
 
@@ -135,10 +135,10 @@ let regexp = /[-().^+]/g;
 alert( "1 + 2 - 3".match(regexp) ); // Corrispondono +, -
 ```
 
-...Ma se decidiamo di effettuarne l'escape "giusto per non sbagliare", il risultato non cambierebbe:
+...Ma se decidete di effettuare l'escape "per ogni evenienza", il risultato non cambierebbe:
 
 ```js run
-// Escape tutto
+// Escape di ogni carattere
 let regexp = /[\-\(\)\.\^\+]/g;
 
 alert( "1 + 2 - 3".match(regexp) ); // funziona ugualmente: +, -
@@ -152,12 +152,12 @@ Per esempio, cerchiamo `pattern:[𝒳𝒴]` nella stringa `subject:𝒳`:
 
 ```js run
 alert( '𝒳'.match(/[𝒳𝒴]/) ); // mostra uno strano carattere, come [?]
-// (la ricerca è stata eseguita in modo errato, mezzo-carattere restituito)
+// (la ricerca è stata eseguita in modo errato, viene restituito mezzo-carattere)
 ```
 
-Il risultato non è corretto, perché di base la regular expressions "non sa nulla" riguardo le coppie surrogate.
+Il risultato non è corretto, perché di base le espressioni regolari "non sanno nulla" riguardo le coppie surrogate.
 
-Il motore delle regular expression pensa che `[𝒳𝒴]` -- non sono due, ma quattro caratteri:
+Il motore delle espressioni regolari pensa che `[𝒳𝒴]` -- non sono due, ma quattro caratteri:
 1. metà alla sinistra di `𝒳` `(1)`,
 2. metà alla destra di `𝒳` `(2)`,
 3. metà alla sinistra di `𝒴` `(3)`,
@@ -187,11 +187,11 @@ Se dimentichiamo di aggiungere il flag `pattern:u`, ci sarà un errore:
 '𝒳'.match(/[𝒳-𝒴]/); // Errore: Invalid regular expression
 ```
 
-La ragione è che senza il flag `pattern:u` le coppie surrogate sono percepite come due caratteri, quindi `[𝒳-𝒴]` è interpretato come `[<55349><56499>-<55349><56500>]` (ogni coppia di surrogato è sostituito con il suo codice). Ora è facile vedere che l'intervallo `56499-55349` non è valido: esso inizia con il codice `56499` che è inferiore che finisce con `55349`. Questa è la ragione formale dell'errore.
+La ragione è che senza il flag `pattern:u` le coppie surrogate sono percepite come due caratteri, quindi `[𝒳-𝒴]` è interpretato come `[<55349><56499>-<55349><56500>]` (ogni coppia surrogata è sostituita con i suoi codici). Ora è facile osservare che l'intervallo `56499-55349` non è valido: il suo codice iniziale `56499` è maggiore di quello finale `55349`. Questa è la ragione formale dell'errore.
 
 Con il flag `pattern:u` il modello funziona correttamente:
 
 ```js run
-// cerca per i caratteri da 𝒳 a 𝒵
+// cerca i caratteri da 𝒳 a 𝒵
 alert( '𝒴'.match(/[𝒳-𝒵]/u) ); // 𝒴
 ```

From 94932f8753ae58d2ab1ff19d2458d1f1f34da8ff Mon Sep 17 00:00:00 2001
From: Andrea <45577511+longo-andrea@users.noreply.github.com>
Date: Sat, 24 Apr 2021 17:54:26 +0200
Subject: [PATCH 29/29] Update
 9-regular-expressions/08-regexp-character-sets-and-ranges/article.md

---
 .../08-regexp-character-sets-and-ranges/article.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
index be3920e44..18d896ae2 100644
--- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
+++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md
@@ -72,7 +72,7 @@ Decifriamolo. Similarmente a `pattern:\w`, stiamo creando un nostro insieme che
 - `Mark` (`M`) - per gli accenti,
 - `Decimal_Number` (`Nd`) - per i numeri,
 - `Connector_Punctuation` (`Pc`) - per il trattino basso `'_'` e caratteri simili,
-- `Join_Control` (`Join_C`) - due codici specialis `200c` e `200d`, usati nelle legature, a.e. in Arabo.
+- `Join_Control` (`Join_C`) - due codici speciali `200c` e `200d`, usati nelle legature, a.e. in Arabo.
 
 Un esempio di utilizzo: