Update 9-regular-expressions\10-regexp-greedy-and-lazy\article.md

Author: marcellosurdi

9-regular-expressions/10-regexp-greedy-and-lazy/article.md

@@ -8,7 +8,7 @@ Prendiamo ad esempio la seguente esercitazione.
 
 Abbiamo bisogno di rimpiazzare tutti i doppi apici `"..."` in un testo con le virgolette basse: `«...»`, che sono preferite nella tipografia di molti paesi.
 
-Ad esempio: `"Hello, world"` dovrebbe diventare `«Hello, world»`. Esistono altre virgolette, come `„Witam, świat!”` (in Polonia) o `「你好，世界」` (in Cina), in questo caso, tuttavia, scegliamo `«...»`.
+Ad esempio: `"Hello, world"` dovrebbe diventare `«Hello, world»`. Esistono altre virgolette, come `„Witam, świat!”` in Polonia o `「你好，世界」` in Cina, in questo caso, tuttavia, scegliamo `«...»`.
 
 Innanzitutto dobbiamo individuare le stringhe tra doppi apici per poi sostituirli.
 
@@ -24,15 +24,15 @@ let str = 'a "witch" and her "broom" is one';
 alert( str.match(regexp) ); // "witch" and her "broom"
 ```
 
-...Non funziona come desideravamo!
+Non funziona come desideravamo!
 
 Invece di trovare i due riscontri `match:"witch"` e `match:"broom"`, ne trova solo uno: `match:"witch" and her "broom"`.
 
 Questo fenomeno può essere descritto così: "l'avidità è la causa di tutti i mali".
 
 ## La ricerca in modalità greedy (avida)
 
-Per trovare un riscontro, il motore dell'espressione regolare usa il seguente algoritmo:
+Per trovare un riscontro, l'interprete dell'espressione regolare usa il seguente algoritmo:
 
 - Per ogni posizione nella stringa
     - Prova a trovare un riscontro del pattern in quella posizione.
@@ -42,27 +42,27 @@ Questa procedura generica non ci spiega con evidenza perché l'espressione regol
 
 1. Il primo carattere del pattern è un doppio apice `pattern:"`.
 
-    Il motore dell'espressione regolare prova a trovarlo nella posizione zero della stringa `subject:a "witch" and her "broom" is one`, ma in quel punto trova `subject:a`, pertanto non c'è immediata corrispondenza.
+    L'interprete dell'espressione regolare prova a trovarlo nella posizione zero della stringa `subject:a "witch" and her "broom" is one`, ma in quel punto trova `subject:a`, pertanto non c'è immediata corrispondenza.
 
     Quindi procede: passa alle successive posizioni nella stringa sorgente e prova a trovare lì il primo carattere del pattern, prima fallisce nuovamente, e poi trova finalmente il doppio apice nella terza posizione:
 
     ![](witch_greedy1.svg)
 
-2. Rilevato il doppio apice, il motore tenta di trovare riscontro per il resto del pattern. Verifica se il resto della stringa sia conforme a `pattern:.+"`.
+2. Rilevato il doppio apice, tenta di trovare riscontro per il resto del pattern. Verifica se il resto della stringa sia conforme a `pattern:.+"`.
 
     Nel nostro esempio il successivo carattere del pattern è `pattern:.` (un punto) che indica "qualsiasi carattere tranne una nuova riga". Trova pertanto corrispondenza nel carattere successivo della stringa `match:'w'`:
 
     ![](witch_greedy2.svg)
 
-3. Successivamente il punto trova ulteriori riscontri per via del quantificatore `pattern:.+`. Il motore dell'espressione regolare aggiunge un carattere dopo l'altro.
+3. Successivamente il punto trova ulteriori riscontri per via del quantificatore `pattern:.+`. L'interprete dell'espressione regolare aggiunge un carattere dopo l'altro.
 
-    ...Fino a quando? Tutti i caratteri corrispondono al punto, quindi si ferma solo quando raggiunge la fine della stringa:
+    Fino a quando? Tutti i caratteri corrispondono al punto, quindi si ferma solo quando raggiunge la fine della stringa:
 
     ![](witch_greedy3.svg)
 
-4. A questo punto il motore cessa di ripetere `pattern:.+` e prova a trovare il prossimo carattere del pattern. Si tratta del doppio apice `pattern:"`. C'è un problema però: la stringa è finita, non ci sono più caratteri!
+4. A questo punto cessa di ripetere `pattern:.+` e prova a trovare il prossimo carattere del pattern. Si tratta del doppio apice `pattern:"`. C'è un problema però: la stringa è finita, non ci sono più caratteri!
 
-    Il motore dell'espressione regolare capisce di aver preso troppi caratteri per `pattern:.+` e comincia a *retrocedere*.
+    L'interprete dell'espressione regolare capisce di aver preso troppi caratteri per `pattern:.+` e comincia a *retrocedere*.
 
     In altre parole accorcia di un carattere la corrispondenza per il quantificatore:
 
@@ -72,13 +72,13 @@ Questa procedura generica non ci spiega con evidenza perché l'espressione regol
 
     Se ci fosse stato un doppio apice, la ricerca sarebbe terminata, ma l'ultima carattere è una `subject:'e'`, nessun riscontro quindi.
 
-5. ...Allora il motore diminuisce di un ulteriore carattere il numero delle ripetizioni di `pattern:.+`:
+5. Allora l'interprete diminuisce di un ulteriore carattere il numero delle ripetizioni di `pattern:.+`:
 
     ![](witch_greedy5.svg)
 
     Anche il carattere `subject:'n'` non soddisfa la ricerca di `pattern:'"'`.
 
-6. Il motore continua a retrocedere: diminuisce le ripetizioni per `pattern:'.'` finché il resto del pattern (nel nostro caso `pattern:'"'`) non trova riscontro:
+6. L'interprete continua a retrocedere: diminuisce le ripetizioni per `pattern:'.'` finché il resto del pattern (nel nostro caso `pattern:'"'`) non trova riscontro:
 
     ![](witch_greedy6.svg)
 
@@ -90,7 +90,7 @@ Probabilmente non è quello che ci aspettavamo, ma funziona così.
 
 **In modalità greedy (quella predefinita) un quantificatore viene ripetuto quante più volte possibile.**
 
-Il motore della regexp aggiunge quanti più caratteri possibili alla corrispondenza con `pattern:.+`, successivamente retrocede di un carattere alla volta se il resto del pattern non trova riscontro.
+L'interprete della regexp aggiunge quanti più caratteri possibili alla corrispondenza con `pattern:.+`, successivamente retrocede di un carattere alla volta se il resto del pattern non trova riscontro.
 
 L'obiettivo della nostra esercitazione non è questo, proprio in questi casi viene in soccorso la modalità lazy.
 
@@ -118,16 +118,16 @@ Per comprendere distintamente cosa sia cambiato, seguiamo la ricerca passo dopo
 
     ![](witch_greedy1.svg)
 
-2. Anche il secondo step è simile: il motore trova una corrispondenza per il punto `pattern:'.'`:
+2. Anche il secondo step è simile: l'interprete trova una corrispondenza per il punto `pattern:'.'`:
 
     ![](witch_greedy2.svg)
 
-3. Da questo punto la ricerca procede in modo differente. Dal momento che il quantificatore è in modalità lazy `pattern:+?`, il motore non prova a cercare il punto più di una volta, si ferma e cerca subito la corrispondenza con il resto del pattern  `pattern:'"'`:
+3. Da questo punto la ricerca procede in modo differente. Dal momento che il quantificatore è in modalità lazy `pattern:+?`, l'interprete non prova a cercare il punto più di una volta, si ferma e cerca subito la corrispondenza con il resto del pattern  `pattern:'"'`:
 
     ![](witch_lazy3.svg)
 
     Se ci fosse un doppio apice a questo punto la ricerca sarebbe già terminata, ma c'è una `'i'` e quindi nessuna corrispondenza.
-4. Il motore della regexp allora aumenta il numero delle ripetizioni per il punto e riprova:
+4. L'interprete della regexp allora aumenta il numero delle ripetizioni per il punto e riprova:
 
     ![](witch_lazy4.svg)
 
@@ -140,7 +140,7 @@ Per comprendere distintamente cosa sia cambiato, seguiamo la ricerca passo dopo
 
     ![](witch_lazy6.svg)
 
-In questo esempio abbiamo visto come funziona la modalità lazy per `pattern:+?`. I quantificatori `pattern:*?` e `pattern:??` operano in modo simile: il motore della regexp aumenta il numero delle ripetizioni solo se il resto del pattern non ha corrispondenza in una data posizione.
+In questo esempio abbiamo visto come funziona la modalità lazy per `pattern:+?`. I quantificatori `pattern:*?` e `pattern:??` operano in modo simile: aumentano il numero delle ripetizioni solo se il resto del pattern non ha corrispondenza in una data posizione.
 
 **La modalità lazy è abilitata unicamente per il quantificatore seguito da `?`.**
 
@@ -156,7 +156,7 @@ alert( "123 456".match(/\d+ \d+?/) ); // 123 4
 2. Segue la corrispondenza dello spazio nel pattern.
 3. A questo punto c'è `pattern:\d+?`. Il quantificatore è modalità lazy, perciò trova solo una cifra `match:4` e prova a verificare se il resto del pattern è soddisfatto.
 
-    ...Nel pattern, tuttavia, non c'è niente dopo `pattern:\d+?`.
+    Nel pattern, tuttavia, non c'è niente dopo `pattern:\d+?`.
 
     La modalità lazy non ripete nulla se non c'è un motivo. Il pattern è finito e conclude la ricerca. La nostra corrispondenza è `match:123 4`.
 
@@ -168,11 +168,11 @@ Ma per comprendere come funzionino le espressioni regolari e come implementarle
 Del resto è difficile ottimizzare le espressioni regolari complesse, pertanto la ricerca potrebbe anche funzionare esattamente come indicato.
 ```
 
-## Approccio alternativo
+## Un approccio alternativo
 
-With regexps, there's often more than one way to do the same thing.
+Con le espressioni regolari, spesso c'è più di un modo di ottenere lo stesso risultato.
 
-In our case we can find quoted strings without lazy mode using the regexp `pattern:"[^"]+"`:
+Nel nostro caso potremmo trovare le stringhe tra doppi apici senza la modalità lazy, usando la regexp `pattern:"[^"]+"`:
 
 ```js run
 let regexp = /"[^"]+"/g;
@@ -182,120 +182,120 @@ let str = 'a "witch" and her "broom" is one';
 alert( str.match(regexp) ); // "witch", "broom"
 ```
 
-The regexp `pattern:"[^"]+"` gives correct results, because it looks for a quote `pattern:'"'` followed by one or more non-quotes `pattern:[^"]`, and then the closing quote.
+La regexp `pattern:"[^"]+"` dà il risultato corretto, perché cerca un doppio apice `pattern:'"'`, seguito da uno o più caratteri che non siano doppi apici `pattern:[^"]` e successivamente un doppio apice di chiusura.
 
-When the regexp engine looks for `pattern:[^"]+` it stops the repetitions when it meets the closing quote, and we're done.
+Quando l'interprete della regexp cerca `pattern:[^"]+` si arresta quando incontra il doppio apice di chiusura e termina il suo lavoro.
 
-Please note, that this logic does not replace lazy quantifiers!
+Si noti che questa logica non rimpiazza i quantificatori lazy!
 
-It is just different. There are times when we need one or another.
+Sono due approcci differenti. Talvolta ci serve uno, a volte l'altro.
 
-**Let's see an example where lazy quantifiers fail and this variant works right.**
+**Guardiamo un esempio in cui i quantificatori lazy falliscono e questa variante funziona a dovere.**
 
-For instance, we want to find links of the form `<a href="..." class="doc">`, with any `href`.
+Se volessimo, per esempio, trovare dei link di questo tipo `<a href="..." class="doc">`, con qualsiasi contenuto per `href`.
 
-Which regular expression to use?
+Quale espressione regolare dovremmo usare?
 
-The first idea might be: `pattern:/<a href=".*" class="doc">/g`.
+La prima idea potrebbe essere: `pattern:/<a href=".*" class="doc">/g`.
 
-Let's check it:
+Proviamo:
 ```js run
 let str = '...<a href="link" class="doc">...';
 let regexp = /<a href=".*" class="doc">/g;
 
-// Works!
+// Funziona!
 alert( str.match(regexp) ); // <a href="link" class="doc">
 ```
 
-It worked. But let's see what happens if there are many links in the text?
+Ha funzionato. Ma vediamo, cosa succede se ci sono più link nel testo?
 
 ```js run
 let str = '...<a href="link1" class="doc">... <a href="link2" class="doc">...';
 let regexp = /<a href=".*" class="doc">/g;
 
-// Whoops! Two links in one match!
+// Ops! Due link in una sola corrispondenza!
 alert( str.match(regexp) ); // <a href="link1" class="doc">... <a href="link2" class="doc">
 ```
 
-Now the result is wrong for the same reason as our "witches" example. The quantifier `pattern:.*` took too many characters.
+Il risultato adesso è errato per lo stesso motivo dell'esempio di prima con "witches". Il quantificatore `pattern:.*` ha preso troppi caratteri.
 
-The match looks like this:
+Possiamo spiegare la corrispondenza in questo modo:
 
 ```html
 <a href="....................................." class="doc">
 <a href="link1" class="doc">... <a href="link2" class="doc">
 ```
 
-Let's modify the pattern by making the quantifier `pattern:.*?` lazy:
+Modifichiamo allora il pattern rendendo lazy il quantificatore `pattern:.*?`:
 
 ```js run
 let str = '...<a href="link1" class="doc">... <a href="link2" class="doc">...';
 let regexp = /<a href=".*?" class="doc">/g;
 
-// Works!
+// Funziona!
 alert( str.match(regexp) ); // <a href="link1" class="doc">, <a href="link2" class="doc">
 ```
 
-Now it seems to work, there are two matches:
+Ora sembra sembra funzionare, ci sono due riscontri:
 
 ```html
 <a href="....." class="doc">    <a href="....." class="doc">
 <a href="link1" class="doc">... <a href="link2" class="doc">
 ```
 
-...But let's test it on one more text input:
+Ma proviamo ancora su un altro testo:
 
 ```js run
 let str = '...<a href="link1" class="wrong">... <p style="" class="doc">...';
 let regexp = /<a href=".*?" class="doc">/g;
 
-// Wrong match!
+// Corrispondenza errata!
 alert( str.match(regexp) ); // <a href="link1" class="wrong">... <p style="" class="doc">
 ```
 
-Now it fails. The match includes not just a link, but also a lot of text after it, including `<p...>`.
+Ora fallisce. La corrispondenza include non solo il link, ma anche molto altro testo dopo di esso, incluso `<p...>`.
 
-Why?
+Perché?
 
-That's what's going on:
+Ecco quello che sta succedendo:
 
-1. First the regexp finds a link start `match:<a href="`.
-2. Then it looks for `pattern:.*?`: takes one character (lazily!), check if there's a match for `pattern:" class="doc">` (none).
-3. Then takes another character into `pattern:.*?`, and so on... until it finally reaches `match:" class="doc">`.
+1. Per prima cosa la regexp trova la prima parte del link `match:<a href="`.
+2. Dopo cerca `pattern:.*?`: considera un solo carattere (in modalità lazy!), verifica se c'è riscontro con `pattern:" class="doc">` (nessuna).
+3. Successivamente prende un altro carattere per `pattern:.*?`, e così via...fino al raggiungimento di `match:" class="doc">`.
 
-But the problem is: that's already beyond the link `<a...>`, in another tag `<p>`. Not what we want.
+Ma il problema è: quella parte è già al di fuori del link `<a...>`, in un altro tag `<p>`. Non è quello che desideriamo.
 
-Here's the picture of the match aligned with the text:
+Ecco la rappresentazione della corrispondenza con il testo allineato:
 
 ```html
 <a href="..................................." class="doc">
 <a href="link1" class="wrong">... <p style="" class="doc">
 ```
 
-So, we need the pattern to look for `<a href="...something..." class="doc">`, but both greedy and lazy variants have problems.
+Ricapitoliamo, abbiamo bisogno del pattern per cercare `<a href="...something..." class="doc">`, ma entrambe le varianti greedy e lazy danno problemi.
 
-The correct variant can be: `pattern:href="[^"]*"`. It will take all characters inside the `href` attribute till the nearest quote, just what we need.
+Un'alternativa corretta potrebbe essere: `pattern:href="[^"]*"`. Essa prenderà tutti i caratteri dentro l'attributo `href` fino al doppio apice più vicino. Proprio quello di cui abbiamo bisogno!
 
-A working example:
+Ecco un esempio funzionante:
 
 ```js run
 let str1 = '...<a href="link1" class="wrong">... <p style="" class="doc">...';
 let str2 = '...<a href="link1" class="doc">... <a href="link2" class="doc">...';
 let regexp = /<a href="[^"]*" class="doc">/g;
 
-// Works!
-alert( str1.match(regexp) ); // null, no matches, that's correct
+// Funziona!
+alert( str1.match(regexp) ); // null, è corretto che non ci sia alcun riscontro
 alert( str2.match(regexp) ); // <a href="link1" class="doc">, <a href="link2" class="doc">
 ```
 
 ## Riepilogo
 
-Quantifiers have two modes of work:
+I quantificatori possono funzionare in due modalità differenti:
 
 Greedy
-: By default the regular expression engine tries to repeat the quantified character as many times as possible. For instance, `pattern:\d+` consumes all possible digits. When it becomes impossible to consume more (no more digits or string end), then it continues to match the rest of the pattern. If there's no match then it decreases the number of repetitions (backtracks) and tries again.
+: L'interprete delle espressioni regolari, in via predefinita, prova a ripetere un quantificatore quante più volte possibile. Per esempio, `pattern:\d+` considera tutte le cifre disponibili. Quando diventa impossibile trovarne ancora (non ci sono più cifre o è finita la stringa), allora continua a cercare la corrispondenza con il resto del pattern. Se non trova riscontro allora retrocede, diminuisce il numero di ripetizioni e prova ancora.
 
 Lazy
-: Enabled by the question mark `pattern:?` after the quantifier. The regexp engine tries to match the rest of the pattern before each repetition of the quantified character.
+: Abilitata dal punto interrogativo `pattern:?` dopo il quantificatore. L'interprete delle regexp prova la corrispondenza del resto del pattern prima di ogni ripetizione di un carattere quantificato.
 
-As we've seen, the lazy mode is not a "panacea" from the greedy search. An alternative is a "fine-tuned" greedy search, with exclusions, as in the pattern `pattern:"[^"]+"`.
+Come abbiamo visto, la modalità lazy non è una "panacea" per i problemi della ricerca greedy. Un'alternativa può essere una ricerca greedy "calibrata", avvalendoci di esclusioni come nel pattern `pattern:"[^"]+"`.