Ti ritrovi spesso a dover utilizzare le espressioni regolari, ma non sai assolutamente quello che fanno, come lo fanno e perché funzionano? Se anche tu perdi tempo a cercare quella giusta che faccia al caso tuo, forse è il caso di capirle una volta per tutte. Con questo corso.

Con questo corso imparerai a capire:

- Come funzionano le espressioni regolari
- A cosa servono le espressioni regolari
- Come fare espressioni regolari
- I caratteri speciali da utilizzare

Alla fine del corso sarai un campione delle regular expression e saprai scriverle e comprenderle. 

**Verranno pubblicate lezioni giornaliere durante il mese di agosto**

Non dimenticare di iscriverti al [canale di YouTube](https://www.youtube.com/channel/UCfDyxJKu5QmNmvjIciGAl7A?sub_confirmation=1) per non perderti nemmeno una lezione e se hai bisogno di supporto puoi sempre unirti alla [community su Discord](https://discord.gg/BWvku3eqXg) e chiedere supporto.

Manuel Ricci

316135391_10228434730003413_3440617797997573835_n.webp

In questa raccolta trovi i corsi base di informatica che possono aiutarti a comprendere meglio il tuo computer e gli strumenti che hai a disposizione.

Non trovi il corso che fa al caso tuo? Ti andrebbe di dirmi qual è? Così mi aiuterai ad alimentare il catalogo corsi e otterrai il corso che desideri. Per suggerirmi un corso puoi [compilare il modulo google che trovi qui](https://forms.gle/SLdYyE4B4JUiEcjU7).

Informatica di base

Vediamo come sono nate le espressioni regolari e perché sono così importanti ancora oggi.

Per spiegare le espressioni regolari penso sia corretto parlare un pochino della loro storia. Siamo nell’anno 1943, quando Warren McCulloch e Walter Pitts iniziano a sviluppare un modello che descrive come il sistema nervoso umano funzioni.

La ricerca si focalizzava principalmente sulla creazione di pattern complessi. Nel 1951 il matematico Stephen Kleene descrisse con un espressione matematica il modello McCulloch-Pitts usando quelle che hai tempi venivano chiamate regular sets.

Il nome espressione regolare e il loro impiego effettivo in un applicativo dovrà attendere ancora 15 anni. Infatti è nel 1966 che Ken Thompson estende l’editor QED, sviluppato originariamente da Lampson e Deutsch, influenzato dalla nozione di Kleen, affinché potesse comprendere le regular expression.

Ai più Ken Thompson non dice granché, ma è famoso per essere stato uno degli autori di Multics, antenato dei moderni sistemi operativi Unix-Like.

La storia e la carriera di Thompson si intreccia con altre persone illustri dell’informatica, in particolare Dennis Ritchie, noto per aver scritto insieme a Brian Kernighan, **il** libro più famoso dell’informatica, “The C Programming Language”.

## Le espressioni regolari oggi

Dal 1966 ad oggi di cose ne sono cambiate e considerano che l’informatica ogni 3 anni diventa obsoleta, pensare che le espressioni regolari sono in giro da quasi 60 fa pensare parecchio alla loro enorme utilità.

Oggi le espressioni regolari sono presenti in praticamente tutti i principali linguaggi di programmazione, come: Python, JavaScript, Java, Ruby, PHP, C, C++, C#, PERL, ecc.

Addirittura in HTML si possono usare le espressioni regolari, grazie all'attributo `pattern` dell’elemento `input`.

Ritornando un attimo nel mondo Unix, uno dei più noti comandi eseguibili da riga di comando (o terminale che dir si voglia) è `grep`, il quale è acronimo di “search Globally for line matching the Regular Expression, and Print them”.

A questo punto però viene naturale chiedersi

## A cosa servono le espressioni regolari?

Le espressioni regolari servono a cercare e sostituire qualcosa in una stringa.

Più nello specifico possiamo usare le espressioni regolari per comprendere se una stringa è stata scritta nel modo corretto, basti pensare ad esempio a:

- Codice fiscale
- CAP
- Date
- Indirizzo di posta elettronica
- Numeri di carta di credito

O per estrarre una sottostringa, come ad esempio:

- Le prime cifre della carta di credito per determinarne il circuito
- Verificare che nel testo sia presente una parola specifica

E proprio su quest’ultimo caso, voglio basare un primo esempio pratico.

## Esempio di regular expression

Supponiamo di avere la seguente frase:

_Il gatto nero saltò sul tavolo e iniziò a leccare la ciotola del cibo. Il cane abbaiò e corse verso il gatto, ma il gatto riuscì a scappare. Il cane si arrese e tornò a dormire sul pavimento._

Il nostro compito è quello di individuare la parola _nero_.

Proviamo prima a raggiungere l’obiettivo con le espressioni regolari.

Io qui di seguito utilizzo JavaScript, l’invito è ovviamente quello di provare prima per i fatti propri e poi confrontarsi e l’invito è ovviamente anche quello di declinare l’esempio nel vostro linguaggio di riferimento.

Prima di procedere tenete a mente tre cose:

1. La parola deve essere nero e non abanero o nerone, quindi attenzione ai caratteri che precedono e seguono la parola che state cercando
2. Chi ha scritto il testo potrebbe essere stato fantasioso e aver utilizzato lettere maiuscole e minuscole non solo all’inizio.
3. La parola può essere preceduta o seguita da spazi, punteggiatura o simboli di vario genere, senza contare che potrebbe trovarsi all’inizio o alla fine della frase stessa.

La situazione si è complicata un po’ dalla semplice ricerca della parola nero, ma niente di impossibile.

Qui vi invito a fermarvi e riflettere, provate ad implementare per i fatti vostri la soluzione e poi proseguite. La soluzione può essere più o meno completa, ma l’importante è che ci proviate.

Fatto? Bene, allora possiamo proseguire

### La soluzione in pseudocodice

Per essere i più agnostici possibili sul linguaggio da impiegare includerò sempre, anche in futuro, esempi in pseudocodice. 

```txt
ciclo: fai scorrere I per tutta la lunghezza di T
   se il carattere I è "n" o "N"
      se il carattere I+1 è "e" o "E"
         se il carattere I+2 è "r" o "R"
            se il carattere I+3 è "o" o "O"
               se il carattere I-1 è 0 o non è una lettera
                  se il carattere I+4 è maggiore di T o non contiene lettere
                     mostra I
```

Dove `I` sta per l’indice e `T` è il testo.

In JavaScript l’avrei scritta più o meno così

```js
const text = "Il gatto nero saltò sul tavolo e iniziò a leccare la ciotola del cibo. Il cane abbaiò e corse verso il gatto, ma il gatto riuscì a scappare. Il cane si arrese e tornò a dormire sul pavimento.";

for ( let i = 0; i < text.length; i++ ) {
	if ( text[i] === "n" || text[i] === "N" ) {
		if ( text[i + 1] === "e" || text[i + 1] === "E" ) {
			if ( text[i + 2] === "r" || text[i + 2] === "R" ) {
				if ( text[i + 3] === "o" || text[i + 3] === "O" ) {
					if ( i === 0 || text[i - 1] === " " ) {
						if ( i + 4 === text.length || text[i + 4] === " " ) {
							console.log( "Il testo contiene la parola 'nero'" );
							break;
						}
					}
				}
			}
		}
	}
}
```

Come detto prima, quello che sembrava un compito semplice, in realtà si è rivelato essere un bel lavoraccio, ma hey! Mica siamo nel 1965, abbiamo le espressioni regolari dalla nostra parte.

Per fare la stessa cosa con una regular espression possiamo scrivere semplicemente:

```txt
\bnero\b
```
Il gioco è fatto. Semplice vero?

Se vi state domandando cosa vogliono dire quei caratteri che ho scritto, `\b` è un terminatore di parola, la `b` sta per boundary e può essere qualunque carattere che non appartenga ad una parola come un punto, una virgola, delle virgolette o un punto di domanda.

## Dove testare le espressioni regolari

Durante le prossime lezioni userò [regex101.com](https://regex101.com/), un strumento estremamente comodo per costruire, testare e fare il debug delle espressioni regolari.

Delle alternative possono essere:

- [Regex Previewer per Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=chrmarti.regex)
- [RegEx Pal](https://www.regexpal.com/) (web)
- [Regexr](https://regexr.com/) (web)
- [RegexBuddy](https://www.regexbuddy.com/) (Windows a pagamento)

## Conclusioni

Questa è la storia e una primissima introduzione alle espressioni regolari, nella prossima lezione cerchiamo di capire meglio quel `\b` e andiamo alla scoperta di tutti i caratteri speciali che possono esserci in un espressione regolare.


Ti stai chiedendo a cosa servono le espressioni regolari? Servono a cercare e sostituire parti di stringhe e sono utili oggi come 57 anni fa.

A cosa servono le espressioni regolari?

In questa lezione diamo un significato ai simboli usati nelle regexp

Nella lezione precedente di [introduzione alle espressioni regolari](https://www.manuelricci.com/guida/a-cosa-servono-le-espressioni-regolari) ci siamo lasciati con la regex `\bnero\b`. Ripartiamo proprio da qui per poter approfondire ulteriormente i caratteri speciali che abbiamo a disposizione nelle regular expression, perché ce ne sono un bel po’, 32 per la precisione.

Ma come capiamo quando un carattere è speciale?

Osserviamo ancora una volta la regexp della lezione scorsa

```txt
\bnero\b
```

`nero` sappiamo essere la parola che stiamo cercando, ma le altre due lettere b, che cosa le accomuna? Ci siete arrivati? È il `\` (backslash).

## Caratteri speciali con backslash

Ci sono 20 caratteri speciali dove il backlash precede una lettera e sono:

- `\A` = inizio del testo
- `\a` = bell
- `\b` = bordo di una parola
- `\B` = tutto tranne \b
- `\c` = controllo
- `\d` = cifra
- `\D` = tutto tranne \d
- `\e` = escape
- `\f` = fine pagina
- `\n` = fine riga
- `\r` = carret return
- `\s` = spazio
- `\S` = tutto tranne \s
- `\t` = tabulazione
- `\uHHHH` = carattere unicode
- `\v` = tabulazione verticale
- `\w` = parola
- `\W` = tutto tranne \w
- `\xHH` = carattere ASCII
- `\Z` = fine testo

Non vi preoccupate, andremo nel dettaglio per la maggior parte di quelle presenti nella lista nelle prossime lezioni, per ora sappiate che questi sono i caratteri preceduti da \ che nelle espressioni regolari significano qualcosa di specifico.

## Cosa sarebbe successo se avessimo omesso \b?

Nelle [considerazione fatte nelle lezione precedente](https://www.manuelricci.com/guida/a-cosa-servono-le-espressioni-regolari#esempio-di-regular-expression) prima di fare l’esercizio pratico avevo detto che bisognava fare attenzione al fatto che la parola fosse nero, non abanero o nerone, ma nero.

Prendendo in considerazione le seguenti frasi:

- nerone incendiò Roma
- il peperoncino habanero è molto piccante
- il gatto nero è bellissimo

E se rimuovessimo `\b` dalla regular expression avremmo una corrispondenza in tutte e tre le frasi, ma con l’ausilio di \b solo la terza frase avrà una corrispondenza.

## Tornando al backslash

Come avrete già intuito il `\` è un carattere molto utile nelle espressioni regolari, tanto utile che ha due funzioni contrapposte:

1. Rende speciali i caratteri normali
2. Rende normali i caratteri speciali

Questo perché oltre ai caratteri speciali visti prima ce ne sono degli altri a cui non serve backslash, ma hanno un significato specifico.

## Caratteri speciali senza backslash

- `^` = inizio riga
- `$` = fine riga
- `*` = zero o più
- `+` = uno o più
- `?` = zero o uno
- `.` = qualsiasi carattere tranne \n
- `( )` = gruppo
- `{ }` = numero di ripetizioni
- `[ ]` = insieme di caratteri
- `|` = stringhe alternative
- `/` = anteposto ai modificatori
- `\` = lo conosciamo già bene

Questi altri caratteri sono quelli con la quale si tende maggiormente a litigare quando si creano le espressioni regolari, ma niente panico, piano piano li vedremo tutti all’opera. Alcuni già in questa lezione.

## Mettiamo in pratica

Supponiamo di avere questo testo:

Costa 100$ tasse escluse

1. Partiamo semplici: stiamo cercando 100$. Cosa scriviamo?
2. Aumentiamo un pochino la difficoltà: stiamo cercando una qualsiasi cifra seguita dal simbolo del dollaro o dell’euro

Provate e poi continuate a leggere.

Fatto?

Partiamo dal primo esercizio, il quale è abbastanza semplice, se lo compariamo al secondo. Partiamo subito con rispondere alla domanda, ci serve `\b`, no.  Possiamo scrivere anche solo `100$`, ma attenzione perché il simbolo del dollaro `$` è un carattere speciale e quindi va fatto l’escape (da speciale a normale) con l’aiuto del backslash, in questo modo `100\$`.

Questo permetterà di soddisfare la richiesta del primo esercizio.

Il secondo è un po’ più particolare, scomponiamo la richiesta:

- una qualsiasi cifra
- seguita dal simbolo del dollaro o dell’euro

Negli elenchi che ho riportato nei paragrafi precedenti abbiamo tutto il necessario.

La cifra viene indicata con il carattere speciale `\d`, ma questo prenderebbe solo in considerazione la singola cifra, abbiamo bisogno di un quantificatore che dica uno o più cifre e quello può farlo il `+` (uno o più). 

Quindi fin qui la nostra regexp sarà questa

```txt
\d+
```

Tutte le cifre sarebbero trovate, ma manca l’ultima parte. Questa cifra di uno o più cifre deve essere seguita dal simbolo del dollaro o dell’euro. Per definire un insieme di caratteri possiamo usare le parentesi quadre `[ ]` (insieme di caratteri) e possiamo separare le alternative con la pipe `|`.

Quindi la nostra espressione regolare sarà questa:

```txt
\d+[$|€]
```
Perché non serve il backslash davanti al simbolo del dollaro, perché ciò che c’è tra le parentesi quadre, al di là di qualche eccezione (vedi la pipe) è già considerato carattere normale.

Volendo essere ancora più pignoli, chi scrive i prezzi potrebbe aggiungere accidentalmente uno spazio tra la cifra e il simbolo della valuta. In quel caso possiamo avvalerci di `\s` (spazio) e del quantificatore `?` (zero o uno). Il risultato sarà questo:

```txt
\d+\s?[$|€]
```

## Conclusioni

Con questa lezione non solo abbiamo scoperto i caratteri speciali e l’importanza del backslash nelle regular expression, ma abbiamo anche scritto la nostra prima regexp un pochino più complessa.

Le regular expression sono ricche di caratteri speciali, 32 per l'esattezza e possono servire in svariate situazioni. Vediamole insieme in questa guida

Caratteri speciali nelle regular expression

Capiamo una volta per tutte \b e il suo gemello \B e altri due entità \w e \W.

Quello che abbiamo visto finora è stato abbastanza semplice e, spero, comprensibile. Le espressioni regolari sanno essere strumenti molto potenti, ma possiamo anche utilizzarle anche per cose semplicissime come cercare un carattere o una parola, infischiandocene magari di maiuscole o minuscole o se questa sia effettivamente la parola esatta o se fa parte di una parola più lunga. Un po’ come quando facciamo una ricerca all’interno di una pagina web, cerchiamo una parola e scorriamo le varie corrispondenze alla ricerca della parte che stiamo cercando.

La peculiarità delle regexp è che possono essere affinate per poter restringere il numero di risultati ad esattamente ciò che stiamo cercando e il potenziale è pressoché illimitato.

## Caratteri e bordi

Abbiamo già incontrato nelle lezioni precedenti il terminatore \b e sappiamo, grazie alla lezione precedente, che esiste anche \B e che il suo significato è tutto ciò che non è \b, che possiamo parafrasare in: il contrario di \b.

Mentre quindi \b individua il bordo di una parola (e poi chiariremo meglio questo aspetto), \w è l’identificatore del carattere e sempre dalla lezione precedente sappiamo anche che esiste il suo gemello contrario \W. Ormai avrete capito che quando un’entità ha una controparte maiuscola, quest’ultima è sempre contraria.

Ma andiamo con ordine…

## Bordi di parole con \b

Supponiamo di avere questa frase:

> Non mi piace la sabbia. È granulosa, ruvida, e irrita la pelle, e s’infila dappertutto.

Vogliamo individuare tutte le parole con 6 lettere, come facciamo? Usiamo un po’ la fantasia e attingiamo con logica dalle entità viste nella lezione precedente. Potremmo scrivere:

```txt
\s……\s
```
Potrebbe essere una soluzione se le parole fossero singole, ma, in questo caso, sabbia, ruvida e infila vengono escluse.

Il `.` (punto) è un carattere jolly che cerca qualsiasi carattere (escluso \n).

Proviamo quindi con:

```txt
\b……\b
```
Direi un po’ too much. Abbiamo selezionato le parole, ma le corrispondenze si estendono anche a parole che non c’entrano niente e che hanno spazi tra le lettere. Questo sempre per colpa dell’impiego del punto.

### \b e la dimensione zero

So che sembra un termine fantascientifico, ma la dimensione zero possiamo tradurla in ancoraggio.

`\b`, come `\B` è un ancoraggio e per ancoraggio si intende quelle istruzioni che ci ancorano la regular expression in una posizione specifica all’interno della stringa di testo.

Possiamo quindi affermare che un ancoraggio non individua i caratteri, ma bensì il punto di separazione.

Altri ancoraggi sono, ad esempio `$` e `^` che rispettivamente posizionano la regex alla fine e all’inizio della stringa.

Provando ad inserire `\b` in regex101.com vediamo che le linee tratteggiate viola si collocano esattamente tra la lettera e il carattere non lettera (spazio, punteggiature, ecc.)

![esempio bordo espressione regolare](https://storage.googleapis.com/iccm-bucket-prod/esempio_bordo_espressione_regolare_900b90f2f6/esempio_bordo_espressione_regolare_900b90f2f6.jpg)

Tornando alla nostra frase proviamo quindi un ulteriori soluzione:

```txt
\b[a-zAZ][a-zAZ][a-zAZ][a-zAZ][a-zAZ][a-zAZ]\b
```

A questo giro funziona, ma è a prova di tutto? Purtroppo no, modifichiamo leggermente la frase come segue:

> Non mi piace la sabbia. Perché granulosa, ruvida, e irrita la pelle, e s’infila dappertutto.

`Perché` è composto da 6 lettere, ma non ha corrispondenza, come mai? Perché ha una lettera accentata che non rientra nel set di caratteri `[a-zA-Z]` (che per inciso significa qualunque lettera maiuscola o minuscola).

La soluzione potrebbe essere quella di includere anche un set di caratteri per le lettere accentate, ma direi che possiamo percorrere strade meno caotiche.

## I caratteri di una parola

Proviamo a scrivere questa regexp

```txt
\b\w\w\w\w\w\w\b
```

Funziona! E siccome siete stati bravi fino a qui vi meritate un piccolo trucchetto. Possiamo semplificare la regexp in questo modo:

```txt
\b\w{6}\b

Vale anche per la precedente

\b[a-zAZ]{6}\b
```

### cosa fa esattamente `\w`?

Come già anticipato `\w` serve a trovare una corrispondenza con una parola, ma cosa significa? Vediamolo con questo testo:

```txt
!@#$%^&*()_+1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM[]{};’:”,./<>?
```

Le corrispondenze sono 63 una per ogni lettera maiuscola e minuscola, numero e underscore (quest’ultimo perché viene usato spesso per separare le parole).

`\W` invece individua tutti i caratteri che possono essere considerati bordo di una parola, quindi individua tutti i caratteri opposti a quelli di `\w`.

## In tutto questo \B che fa?

La differenza tra `\b` e `\B` è un pochino più particolare. Se `\b` ci posiziona nel punto di separazione tra un carattere di fine parole e la parola stessa, `\B` farà esattamente l’opposto prendendo lettere, numeri e underscore come caratteri di bordo.

## In pratica

Se il concetto che ho scritto nel paragrafo precedente allora l’esercizio di questa lezione sarà una passeggiata.
Prendiamo in considerazione il seguente testo:

```txt
p11p
l00l
b4d455
pq00pq
```

Come si individuano i numeri `00`?

Se usassimo `\w00\w` avremmo le due corrispondenze, ma verrebbero prese nelle selezione anche le due lettere limitrofe alla cifra che ci interessa.

Con `\b00\b` non avremmo nessun risultato perché `00` si colloca sempre tra due lettere e sappiamo che il bordo per `\b` è tra la lettera e il carattere non lettera, ma quindi questo significa che la situazione contraria fa proprio al caso nostro, quindi la soluzione all’esercizio è `\B00\B`.

## Conclusioni

Con questa lezione abbiamo visto più nel dettaglio le stringhe e abbiamo approfondito il già ben noto `\b` e il suo gemello contrario `\B`. Inoltre, abbiamo visto anche `\w` e `\W` che ci hanno aiutato a capire ancora meglio il funzionamento degli altri due.

In questa lezione vediamo ancoraggi, parole, lettere e bordi nelle espressioni regolari. Importanti nozioni per saperle usare efficacemente.

Caratteri e bordi nelle espressioni regolari

Matchiamo qualche data con le regular expression e le entità per i numeri.

Questa è una lezione pocket, molto breve, ma perché il grosso è stato già affrontato nella [lezione precedente su \b e \w](https://www.manuelricci.com/guida/caratteri-e-bordi-nelle-espressioni-regolari), quindi qui andiamo via abbastanza lisci.

Il tema della lezione sono le cifre e gli spazi. Abbiamo già avuto modo di incontrare `\s` e `\d` nelle lezioni precedenti, ma non abbiamo avuto ancora l’occasione di fare conoscenza con `\D` e `\S`.

Come già accennato nelle lezioni precedenti le entità con la lettera maiuscola fanno il contrario di ciò che fa l’entità con la lettera minuscola.

Quindi, considerando che `\s` seleziona gli spazi, la sua controparte `\S` seleziona tutto ciò che non è spazio.

Mentre per quanto riguarda `\d`, entità che ci permette di selezionare i numeri, la sua controparte `\D` seleziona tutto ciò che non è un numero come lettere, simboli, spazi, ecc.

Questo è tutto ciò che c’è da sapere su questo tipo di entità, ma non sarebbe una lezione di Imparare Coding con Manuel senza un piccolo esercizio.

## \d nelle espressioni regolari in pratica

Supponiamo di avere il seguente gruppo di date:

- 24-10-2022
- 4-8-2023
- 25-12-92
- 22-05-1993

Il vostro compito è quello di scrivere un’espressione regolare che individui queste date. Tutto ciò che vi serve è quasi stato tutto affrontato in questa lezione e in quelle precedenti. C’è un solo dettaglio che manca, ma è qui la sfida.

L’espressione regolare che si potrebbe usare è la seguente:

```txt
\d{1,2}-\d{1,2}-\d{2,4}
```

Quello che ho scritto lo possiamo interpretare così:

- `\d` sappiamo essere l’entità che individua i numeri
- `{1,2}` indica il numero di ripetizioni possibili, in questo caso specifico da 1 a 2
- `-` è solo un trattino
- `{2,4}` come prima, ma stavolta è da 2 a 4 (3 compreso)

Proviamo a complicare ulteriormente la faccenda.
Le date ora sono queste:

- 24/10/2022
- 4-8-2023
- 25/12/92
- 22-05-1993

Questa è cattiva… Oltre al trattino ora dobbiamo pensare che potrebbe esserci lo slash. Anche questo l’abbiamo visto in precedenza, ma anche qui c’è una peculiarità in più.

L’espressione regolare che si potrebbe scrivere è la seguente:

```txt
\d{1,2}[\/|-]\d{1,2}[\/|-]\d{2,4}
```

Molto simile a quella precedente, ma vediamo ciò che non sappiamo:

- `[...]` è il set di caratteri che vedremo nella prossima lezione
- `\/` nella data dobbiamo individuare lo slash, ma siccome lo slash è un carattere speciale, dobbiamo fare l’escape, annullare la sua specialità con il backslash che sappiamo avere la duplice funzione di rendere speciali i caratteri normali e normali i caratteri speciali
- `|` è il carattere speciale che indica un’alternativa
- `-` l’alternativa (rimane sempre e solo un trattino)

## Conclusioni

Questa lezione pocket è stata decisamente più pratica, ma ha aggiunto un tassello fondamentale per poter meglio comprendere le espressioni regolari. Nella prossima lezione vediamo i set di caratteri.

Impariamo a matchare le date con le regular expression in questa veloce guida. Impara ad usare le regular expression con imparare coding con Manuel

Cifre e spazi nelle espressioni regolari

Capiamo meglio come si usano le parentesi quadre.

Approfondiamo finalmente una coppia di caratteri speciali già visti nelle lezioni precedenti. La coppia di parentesi quadre `[` `]`. La sintassi viene usata per definire un set di caratteri ed è estremamente semplice da usare.

Ipotizziamo di avere una serie di file:

- file_1.txt
- file_2.txt
- file_3.txt
- file_a.txt
- file_b.txt
- file_c.txt

Qualora volessimo individuare tutti i file che hanno una lettera dopo l’underscore, potremmo scrivere:

```txt
file_[abc]\.txt
```

Semplice no?

Con lo stesso sistema possiamo individuare anche quelle parole che iniziano con una lettera maiuscola o minuscola:

```txt
\b[mM]\w+\b
```

L’avete capita al volo? Se sì, sono contento per voi. Se no, la spiego:

- `\b` l’abbiamo visto nelle [lezioni precedenti](https://www.manuelricci.com/guida/caratteri-e-bordi-nelle-espressioni-regolari) ed è un ancoraggio che indica il “bordo” di una parola
- `[mM]` è il nostro set di caratteri per individuare una lettera m maiuscola o minuscola all’inizio di un parola (essendo dopo `\b` può essere solo all’inizio)
- `\w` individua lettere, numeri e underscore (quindi le lettere successive alla lettera che ho indicato prima)
- `+` è il quantificatore che indica una o infine ricorrenze di `\w`

## La sequenza di caratteri

Se volessimo cercare una sequenza di caratteri possiamo avvalerci del `-`. Dall’esempio precedente al posto di `[mM]` possiamo scrivere `[a-zA-Z]` questo significa che individuerà tutte le lettere minuscole o maiuscole.

Se invece stessimo cercando dei numeri possiamo scrivere `[0-9]`.

### Occhio all’ordine

Attenzione però a non scrivere `[z-a]` o `[9-0]`, perché in quel caso si verificherà un errore dato che i caratteri prima e dopo il trattino devono essere in ordine crescere di codice ASCII.

Allora magari starete pensando perché non possiamo scrivere `[A-z]`? Perché se date un’occhiata alla [tabella ASCII](https://bytetool.web.app/en/ascii/) noterete che A-Z e a-z non sono contigui, dopo la Z ci sono dei simboli. Quindi verrebbero presi in considerazione anche loro nell’eventualità.

Altra piccola curiosità `[0-9]` è l’equivalente di `\d`, visto nelle lezioni precedenti e meglio discusso nella lezione sulle [cifre e gli spazi](https://www.manuelricci.com/guida/cifre-e-spazi-nelle-espressioni-regolari)

### Attenzione al trattino

Il trattino nei set possiamo definirlo quasi un carattere speciale. Nella lezione precedente quando abbiamo individuato le date, abbiamo usato senza problemi il trattino perché si trovava agli estremi del set (dopo o prima della parentesi quadra). Se steste cercando il trattino e lo collocaste in mezzo al set dovete ricordarvi di fare l’escape con il `\`.

## Escludere dei caratteri

Se volessimo escludere dei caratteri dal set possiamo usare subito dopo `[` l’apice `^` in questo modo:

```txt
[^abc]
[^123]
```

L’apice indica la negazione all’interno di un set e possiamo dichiarare piú negazioni separandole con la virgola in questo modo:

```txt
[^a-z, 0-9]
```

E se voleste trovare `^`, semplice… basta non metterlo all’inizio del set.

Se prendiamo in esame l’espressione regolare di prima `\b[mM]\w+\b` come potremmo modificarla affinché cerchi tutte le parole di una frase senza badare a quale sia la lettera iniziale, ma assicurandosi che non vengano presi in considerazioni simboli, spazi, numeri e underscore?

```txt
\b[^\W\s\d_]+\b
```
Spiego ciò che c’è di nuovo (tutto a parte `\b` e il quantificatore `+`:

- `[...]` set di caratteri
- `^` negazione, quindi tutto quello che segue non deve essere individuato
- `\W` tutti i simboli (contrario di `\w` che individua lettere, numeri e underscore)
- `\s` spazi
- `\d` numeri
- `_` undescore

Diventano sempre più difficili, ma anche più semplici da leggere.

## Un paio di esercizi sulle espressioni regolari

Dati questi numeri:
- 01001001 01000011 01000011 01001101
- 0x49 0x43 0x43 0x4d

- Individuare i valori binari con l’uso dei set di caratteri
- Individuare i valori esadecimali con l’uso dei set di caratteri
- Bonus: scoprire cosa significa il codice binario.

Per quanto riguarda i numeri binari è semplice possiamo scrivere:

```txt
[0-1]{8}
```

E il gioco è fatto

Per gli esadecimali:

```txt
0x[0-9a-f][0-9a-f]
```

Oppure

```txt
0x[0-9a-f]{2}
```

Il bonus lo lascio a voi :)

## Conclusioni

Abbiamo quindi approfondito il set di caratteri nella prossima lezione vedremo nel dettaglio un paio di ancoraggi `$` e `^`.

Se vogliamo selezionare una serie di caratteri con un'espressione regolare possiamo usare le parentesi quadre, ma ci sono un paio di regole da seguire.

Set di caratteri nelle espressioni regolari

Diamo un senso ad altri quattro ancoraggi che abbiamo a disposizione nelle regular expression

Quando lavoriamo con le espressioni regolari, lavoriamo principalmente con file di testo e quindi il ragionamento che dobbiamo fare è a livello di righe di testo.

Se l’interesse è quello di individuare righe specifiche perché magari sappiamo essere in un determinato formato o perché contengono informazioni essenziali all’inizio o alla fine, ancora una volta abbiamo bisogno degli ancoraggi.

Di ancoraggi ne abbiamo già ampiamente discusso nella lezione sui [caratteri e i bordi](https://www.manuelricci.com/guida/caratteri-e-bordi-nelle-espressioni-regolari) e giusto per fare un piccolo ripasso con quei caratteri speciali che collocano la nostra espressione regolare in uno specifico punto della stringa di testo.

Quando parliamo quindi di righe di testo abbiamo due ancoraggi che ci tornano utili: `$` e `^`, i quali rispettivamente indicano la fine e l’inizio di una riga.

L’esempio più semplice da fare, soprattutto per il file riga è quando abbiamo un elenco di file come il seguente:

- file_1.txt
- file_2.csv
- file.txt.pdf
- file_4.html
- doc_5.txt
- file_6.css

Ipotizziamo di voler individuare tutti i file che hanno estensione `txt`, abbastanza facile direte voi, basta scrivere:

```txt
\.txt
```

Purtroppo no, o meglio, troviamo i file con estensione `txt`, ma anche quello che in realtà ha estensione `.pdf`. Per poter quindi essere sicuri che si tratta solo della vera estensione dobbiamo avvalerci dell’ancoraggio `$` che ci posiziona alla fine della riga di testo. La nostra espressione regolare quindi diventerà:

```txt
\.txt$
```

Ricordate che il backslash prima del punto lo mettiamo perché il punto è un carattere speciale che significa “tutti i caratteri tranne `\n`”.

A questo punto quindi abbiamo individuato esclusivamente tutti i file con estensione `.txt`.

Mentre se volessimo individuare solo quelli che iniziano con `doc`? Qui il discorso è inverso, stiamo cercando qualcosa che si trova all’inizio di una riga e quindi possiamo usare `^`, in questo modo:

```txt
^doc
```

E se volessimo trovare il file che inizia con `file` e ha estensione `txt`? Possiamo usare entrambi gli ancoraggi in questo modo:

```txt
^file[_0-9]*\.txt$
```

- `^file` all’inizio della riga ci deve essere la parola `file`
- `[_0-9]*` seguita da zero o illimitati caratteri `_` e numeri da 0 a 9
- `\.txt$` alla fine della riga ci deve essere l’estensione `.txt`

## Posizionarsi all’inizio o alla fine di un file

Se l’esigenza invece è quella di posizionarsi all’inizio o alla fine di un file possiamo avvalerci del supporto di altri due ancoraggi: `\A` e `\Z`.

Questi due ancoraggi che rispettivamente si posizionano all’inizio e alla fine del documento ignorano la modalità multiriga (la `m` tra le flag impostate).

## In pratica

Ipotizzando di avere questo testo:

Io sono una persona.
Tu sei una persona?
Io? Sì tu.

Trovare la righe che terminano con un punto di domanda.

Questo esercizio è molto semplice, ma è solo una cortesia in vista delle prossime lezioni dove entreremo nel vivo delle espressioni regolari.

La soluzione è: `\?$`

Escape del punto di domanda perché carattere speciale e dollaro per indicare la fine della riga.

## Conclusioni

Abbiamo visto quindi questi nuovi ancoraggi che ci posizionano all’inizio e alla fine di una riga o di un documento. Nella prossima lezione daremo un’occhiata più da vicino ai quantificatori, già usati in passato, ma direi che è giunto il momento di capirci veramente qualcosa.

Per poterci posizionare all'inizio o alla fine di una riga o di un intero documento abbiamo bisogno di alcuni ancoraggi. In questa lezione vediamo quali.

Caratteri d'inizio e fine nelle regexp

Cosa vuol dire greediness e laziness e quali sono i quantificatori nelle regxp? Lo scopriamo qui

Nelle lezioni precedenti abbiamo già spiato i quantificatori, ne conosciamo vagamente il significato dalla seconda lezione del corso sui [caratteri speciali](https://www.manuelricci.com/guida/caratteri-speciali-nelle-regular-expression). È giunto il momento però di conoscerli più a fondo e di aggiungerli alle cose che capiamo delle espressioni regolari.

## Uno o più caratteri

Il carattere speciale `+` (più) significa “una o più occorrenze”.

Prendiamo come esempio questa espressione regolare, il cui impiego è abbastanza ovvio

```txt
\w+@\w+\.\w+
```

La chiocciola è lo spoiler. Avete indovinato? Si tratta di un’espressione regolare per individuare gli indirizzi email. Purtroppo però è ben lontana dall’essere perfetta, in questo momento individua correttamente degli indirizzi email come manuel@webtea.it, ma se dovessi scrivere manuel.ricci@webtea.it non la troverebbe.

Questo perché, da come abbiamo potuto vedere nella lezione sui [caratteri e bordi](https://www.manuelricci.com/guida/caratteri-e-bordi-nelle-espressioni-regolari) `\w` ignora i punti, ma prende in considerazione solo lettere, numeri e underscore.

Proviamo quindi con un [set di caratteri](https://www.manuelricci.com/guida/set-di-caratteri-nelle-espressioni-regolari)

```txt
[\w.]+@[\w.]+\.\w+
```

Ora entrambe le email sono state individuate, ma ancora non ci siamo. Se anteponiamo un punto davanti all’indirizzo email, la regex lo individua, punto compreso.

Come fare quindi? Forse abbiamo bisogno di un altro quantificatore.

## Zero o più caratteri

Per poter risolvere il problema dove ci siamo arenati abbiamo bisogno del quantificatore `*` (asterisco). Significa zero o più caratteri, è molto simile a `+`, ma con la differenza che l’espressione precedente può essere del tutto assente.

```txt
\w+[\w.]*@[\w.]+\.\w+
```
Con questa ulteriore modifica la nostra regex è già più completa ed esclude i problemi con i punti antecedenti. Non è ancora definitiva, ma è un primo esempio. Se siete curiosi una regular expression più indicata al match con un indirizzo email è simile a questa:

```txt
^(?=[A-Z0-9][A-Z0-9@._%+-]{5,253}+$)[A-Z0-9._%+-]{1,64}+@
(?:(?=[A-Z0-9-]{1,63}+\.)[A-Z0-9]++(?:-[A-Z0-9]++)*+\.){1,8}+[A-Z]{2,63}+$
```
Manca ancora qualche dettaglio per comprenderla tutta, ma ci siamo quasi.

Piccola curiosità: la specifica RFC822 stabilisce [questa](http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html) come regexp per validare gli indirizzi email.

## Zero o uno

Archiviate le email passiamo ad un altro quantificatore, il punto di domanda `?` il quale ci permette di verificare la presenza di un carattere per zero o una volta.

Il caso d’uso più frequente è quanto stai cercando di validare un URL, il protocollo HTTP, può avere un S alla fine che indica che la connessione è sicura. L’espressione regolare per individuare sia http che https è la seguente:

```txt
https?:\/\/
```

## Numero di ripetizioni

Anche questi visti in precedenza, la coppia di parentesi graffe `{ }` ci permette di definire un numero specifico di ripetizioni in tre modi:

1. Numero preciso `{2}`
2. Intervallo da a `{2,4}`
3. Intervallo da a indeterminato `{2,}`

## Greediness e laziness

Supponiamo di avere questa frase:

> I quantificatori nelle regular expression sono "avidi", ma possono essere anche "pigri".

e di voler individuare le parole tra virgolette. Naturalmente penseremmo a qualcosa di simile a questo:

```txt
“.+”
```

L’output che ci aspettiamo è che, per l’appunto, le parole tra virgolette vengano individuate. Purtroppo, come abbiamo già ampiamente appreso, la risposta è no.

Ma cosa sta succedendo esattamente?

- `”` cerca la virgolette doppie
- `.+` cerca qualsiasi carattere, l’engine procede fino alla fine della riga
- `”` l’engine torna indietro (in gergo backtrack) per soddisfare anche quest’ultima corrispondenza

In tutto questo non c’è nulla di anomalo. Si tratta dell’ingordigia o greediness dei quantificatori. Per poterla fermare ci sono tre modi. Vediamoli

- `”.+?”` questa prima soluzione, per quanto valida, non è ottimale. L’engine è costretto a fare comunque backtrack. Qui inoltre non c’è da confondere il significato del punto di domanda. Se segue un quantificatore (come in questo caso) tramuta la greediness in laziness, ma nel caso segua un’espressione ha il significato di zero o una volta come visto in precedenza.
- `/U` il flag ungreedy rende tutti i quantificatori pigri (lazy) senza usare il `?`
- `“[^”]+”` questa soluzione è più efficiente delle precedenti soluzioni perché evita il backtrack annullando [matchando tutti i caratteri ad esclusione dei doppi apici](https://www.manuelricci.com/guida/set-di-caratteri-nelle-espressioni-regolari#escludere-dei-caratteri).

## In pratica

Giunti a questo punto siete pronti a scrivere un'espressione regolare che potrebbe veramente servirvi nella vita da programmatore di tutti i giorni.

L’esercizio di questa lezione è quello di scrivere un’espressione regolare capace di individuare un codice fiscale (musica incalzante di sottofondo).

Fatto?

Andiamo con la soluzione.

Partiamo intanto con vedere com’è fatto un codice fiscale `RSSMRA80A01F205X`, abbiamo:

- 6 lettere maiuscole: consonanti (ma non sempre) del nome e del cognome
- 2 caratteri numerici: anno di nascita
- 1 carattere alfabetico: mese di nascita (A=gennaio, B=febbraio, ecc.)
- 2 caratteri numerici: cifre del giorno di nascita (+40 per le donne)
- 1 carattere alfabetico: prima parte che identifica il comune di nascita
- 3 carattere numerico: seconda parte che identifica il comune di nascita
- 1 carattere alfabetico: Carattere di controllo calcolato da un algoritmo specifico

Scrivere l’espressione regolare dovrebbe essere abbastanza semplice arrivati a questo punto:

```txt
^[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$
```

Gli ancoraggi di inizio e fine sono opzionali anche senza va benissimo, ma insomma ormai li abbiamo imparati, usiamoli.

## Conclusioni

Perfetto! Abbiamo visto i quantificatori e come usarli nelle nostre ormai meno spaventose regular expression. Nella prossima lezione andiamo ad analizzare i gruppi e le alternative, altro importantissimo tassello per scrivere espressioni regolari sempre più complesse.

I quantificatori sono molto utili quando si usano le regex. Ci permettono di individuare quante ripetizioni vogliamo delle espressioni. Vediamoli in azione

Quantificatori nelle regexp

Qui è dove le espressioni regolari cominciano a fare sul serio. Vediamo i gruppi di cattura, non cattura, le alternative e le backreference

Quando iniziammo il nostro percorso con le regular expression le descrissi come un qualcosa che serve a cercare e sostituire qualcosa nelle stringhe.

Con questa lezione iniziamo ad approfondire meglio il concetto di sostituzione grazie all’introduzione dei gruppi di cattura.

## I gruppi di cattura

Immaginiamo di avere una serie di carattere come quella che segue:

```txt
abcabcabcdefdefdefabcabcabc
```

Il nostro compito è quello di individuare le tre ripetizioni di def. Come fareste? Potremmo scrivere:

```txt
d+e+f+
```

Ma questo per quanto sembri funzionare, ci apre ad altri possibili scenari come `ddeff`, `deeff`, `ddeeeeffff` e così via.

Per fare in modo che venga quindi individuata la tripletta `def` per tre volte possiamo scrivere:

```txt
((def){3})
```

Tutte queste parentesi tonde sono necessarie per un motivo che spiego tra pochissimo, ma il gruppo di cattura è solitamente costituito da una coppia di parentesi tonde `( )`.

Con l’uso del gruppo di cattura possiamo aggregare più espressioni e ottenere risultati più complessi e altrimenti impossibili con le entità viste finora.

Il motivo per cui ho scritto così tante parentesi tonde sta nel fatto che un gruppo di cattura ripetuto (`{3}`) catturerà solo l'ultima iterazione. Per cui bisogna mettere un gruppo di cattura attorno al gruppo ripetuto per acquisire tutte le iterazioni.

Il nome gruppo di cattura dovrebbe farvi sorgere spontanea una domanda, cosa cattura esattamente? Scopriamolo.

## Cosa cattura il gruppo di cattura

L’uso dei gruppi ci apre il mondo delle backreference e al secondo scopo delle espressioni regolari, la sostituzione.
I gruppi di cattura ci permettono infatti di riutilizzare ciò che viene catturato in un secondo momento. Un esempio chiarirà definitivamente quanto affermo.

### Trovare una parola palindroma con le backreference

Un esempio molto basilare dell’uso delle backreference è quando stiamo cercando una o più parole palindrome, cioè quelle che si possono leggere sia da un verso che dall’altro e risultano uguali. Ipotizziamo quindi di avere le seguenti parole:

```txt
osso
esse
elle
emme
enne
alla
ebbe
```

L’espressione regolare da usare è la seguente: `\b(\w)(\w)\2\1\b`

Tradotta:

- `\b` è il bordo della parola
- `(\w)` primo gruppo dove cerchiamo una lettera
- `(\w)` secondo gruppo dove cerchiamo una lettera
- `\2` backreference al secondo gruppo
- `\1` backreference al primo gruppo

Perché prima il secondo e poi il primo? Perché le due lettere centrali di una palindroma a quattro lettere combaciano. È come spezzare una parola a metà e specchiare la metà rimasta.

Aumentiamo il tiro, che ne dite?

### Invertire le parole con le espressioni regolari

Un esempio più complesso è quando abbiamo a che fare con un elenco simile a questo:

```txt
ABAMONTI (Via)
ABANO (Via)
ABBA (Via)
ABBADESSE (Via)
ABBAZIA (Via)
ABBIATEGRASSO (Piazza)
ABBIATI (Via)
```
Ipotizziamo di voler invertire il nome con la via, per farlo ci serviranno ancora una volta i gruppi di cattura.

```txt
([A-Z]+)\s$([A-Za-z]+)$
```

Tradotto:
- `([A-Z]+)` primo gruppo dove cerco da una a indeterminate lettere dalla A alla Z maiuscole.
- `\s` spazio
- `$` escape della parentesi tonda per individuare il carattere che racchiude il tipo di via
- `([A-Za-z]+)` secondo gruppo, a differenza del primo stiamo attenti anche alla lettere minuscole
- `$` escape della parentesi tonda di chiusura per individuare il carattere che racchiude il tipo di via

Ho quindi due gruppi:

1. Il nome della via
2. Il tipo di via

 La nostra espressione di sostituzione sarà quindi:

```txt
$2 \L$1\E
```

Se ti stai domandando dove metterla in regex101.com nel menu di sinistra nella sezione function, troverai substitution. L’area di lavoro si arricchirà di una nuova barra chiamata, per l’appunto, substitution. Lì dovrai inserire questa espressione di sostituzione.

Ma cosa fa esattamente?

- `$2` secondo gruppo (il tipo di via)
- `\L` indica che da lì in poi i caratteri dovranno essere minuscoli
- `$1` primo gruppo (il nome della via)
- `\E` interrompe `\L`

Il risultato sarà quindi:

```txt
Via abamonti
Via abano
Via abba
Via abbadesse
Via abbazia
Piazza abbiategrasso
Via abbiati
```

## Dare un nome ai gruppi di cattura

Partiamo subito con il dire un gigantesco grazie a Python per aver introdotto per primo la possibilità di dare un nome ai gruppi di cattura.

Per dare un nome possiamo usare la seguente sintassi:

```txt
(?<nome>)
```

Quindi, la nostra espressione precedente può essere cambiata con

```txt
(?P<nome>[A-Z]+)\s$(?P<tipo>[A-Za-z]+)$
```

E la sostituzione di conseguenza

```txt
${tipo} \L${nome}\E
```

Comodo vero?

## La backreference ha un prezzo

Tutta questa comodità ha un costo. Il costo si calcola in termini di tempo e memoria utilizzata. Ci potrebbero essere situazioni dove non vogliamo memorizzare ciò che è stato trovato, come ad esempio nella nostra prima espressione regolare della lezione:

```txt
((def){3})
```

Con `$1` possiamo usare il gruppo, ma se non lo volessimo proprio, alleggerendo il lavoro dell’engine? Possiamo usare i non-capturing group o gruppo di non cattura, in questo modo:

```txt
(?:(?:def){3})
```

Facendo seguire alla parentesi tonda di apertura il `?:`.

## Alternative

Già esplorate in passato, le alternative sono l’equivalente di un OR. Prendendo sempre in esame la regex precedente:

```txt
(?:(?:def|abc){3})
```

Possiamo definire delle alternative andando a mettere una pipe `|` tra i valori che stiamo cercando. Così sia `def` che `abc` verranno individuate se ripetute per tre volte di seguito.

## In pratica

Dato un elenco di file come questo:

```txt
index.html
script.js
style.css
main.js
analytics.js
chi-sono.html
```

Individuare tutti i file `js` e `html` (non solo le estensioni, ma anche tutto il nome del file).

La soluzione al problema è la seguente:

```txt
^[^.]*\.(?:js|html)$
```

- `^` inizio riga
- `[^.]*`Tutti i caratteri ad esclusione di punto (per evitare il problema di ingordigia visto nella lezione precedente)
- `\.` escape del punto
- `(?:js|html)` gruppo di non cattura dove cerchiamo `js` o `html`
- `$` fine riga

## Conclusioni

Con questa lezione abbiamo visto come si usano i gruppo di cattura, come fare delle sostituzioni con le regular expression e come si usa la pipe. Nella prossima lezione vedremo i caratteri unicode e ASCII.

I gruppi di cattura possono essere usati per individuare, ma anche sostituire parti di testo. Vediamo come si usano e come ottimizzarle.

Gruppi, sostituizioni e alternative nelle regex

Ripercorriamo la storia di UNICODE e vediamo l'entità \x all'opera

Molti avranno sentito già parlare di UNICODE, ASCII e UTF-8, tutti questi termini sono legati da un unico filo. In questa lezione vediamo di ripercorrere la storia di UNICODE e dove siamo oggi.

## La storia di UNICODE

Il nome UNICODE deriva dai suoi tre principali obiettivi:

1. Universale: per rispondere alle esigenze delle lingue di tutto il mondo
2. Uniforme: lunghezza fissa per un accesso efficiente
3. Unico: la sequenza di bit è interpretabile in una sola maniera

La prima volta che si inizia a parlare di UNICODE, probabilmente ancora non con questo nome, è nel 1987, in seguito ad una discussione tra ingegneri Apple e Xerox: Joe Becker, Lee Collins e Mark Davis.

Nell’anno successivo a questo confronto, i tre indagarono a fondo sull’entità del progetto. Quali potevano essere le difficoltà, come usare due byte per poter rappresentare i caratteri e quantificare i caratteri da catalogare.

Nel 1988, Collins si mise al lavoro sulla costruzione del primo database UNICODE. L’anno successivo, nel 1989, si uniscono al progetto alcuni ingegneri della Sun Microsystem (acquistata da Oracle nel 2010 è stata la produttrice del linguaggio Java). Nel 1990 al team si uniscono anche IBM e Microsoft e sempre nello stesso anno viene distribuita la prima bozza e siccome si volevano raccogliere quanti più feedback possibili, Microsoft si fece carico dei costi di distribuzione, mentre NeXT Computer (quella fondata da Steve Jobs nel 1985 quando venne allontanato da Apple e acquistata da quest’ultima nel 1997) si mise al lavoro sul database per incorporare le future versioni dello standard.

Il 3 gennaio 1991 la Unicode Inc. viene incorporata nello stato della California e oggi la conosciamo come UNICODE Consortium.

I membri originali del board direttivo erano:

- Larry Tesler, Apple Computer, Inc.
- Robert Carr, GO Corporation
- Richard Holleman, IBM Corporation
- Charles Irby, Metaphor Computer Systems
- Paul Maritz, Microsoft Corporation
- Bud Tribble, NeXT Computer Inc.
- Jay Israel, Novell, Inc.
- David Richards, The Research Libraries Group.
- John Gage, Sun Microsystems Inc.

Il primo dell’elenco, Larry Tesler, è lo stesso che ha inventato il copia e incolla e della [legge di Tesler](https://lawsofux.com/teslers-law/), nota anche come legge di conservazione della complessità, afferma che per ogni sistema esiste una certa quantità di complessità che non può essere ridotta.

Per una storia più ricca di UNICODE potete consultare la cronologia sul [sito del consorzio](http://www.unicode.org/history/versionone.html).

## Cos’è UNICODE

Chiusa la parentesi storica, cerchiamo di rispondere alla domanda: cos’è UNICODE? 

UNICODE sta per Universal Character Set ed è uno schema di codifica i cui standard sono mantenuti dall’UNICODE Consortium.

Il più grande vantaggio di UNICODE è che possiamo definire in modo univoco ogni carattere in ogni lingua assegnando un numero diverso.

Attualmente lo standard è alla versione 15.0 e conta 149.186 caratteri. Per fare un confronto, la versione 1.0 ne contava circa 60.0000.

Concetto super importante legato a UNICODE è l’encoding. UNICODE stabilisce l’elenco dei grafemi (i caratteri), ma la vera e propria rappresentazione è stabilita dall’encoding.

ASCII è il più noto tra gli encoding. Per noi occidentali è altrettanto noto un altro encoding, UTF-8. Quest’ultimo è un tipo di encoding compatibile con ASCII, a differenza di UTF-16 che non lo è.

Per immaginare ancora meglio la relazione tra UNICODE e ASCII dovete immaginarli un po’ come TypeScript e JavaScript. UNICODE è un superset di ASCII.

## Venendo alle espressioni regolari

Le due entità `\u` e `\U` non sono disponibili in moltissimi engine di regular expression.
La loro funzione è quella di permetterci di individuare ogni carattere, usando il codice UNICODE.

La differenza in questo caso non sta nel fatto che il maiuscolo è il contrario del minuscolo (come visto per altre entità), ma nella forma del codice che possiamo usare.

```txt
\u0041 (UTF-8)
\U00000041 (UTF-32)
```

## Carattere ASCII

A differenza di \u e \U, `\x` è supportato dai vari engine e può essere utilizzato per individuare i caratteri.

```txt
\xc0 corrisponde a À
\x41 corrisponde ad A
\xa6 corrisponde a |
\x40 corrisponde a @
```

Il codice da far seguire alla x lo si può trovare [qui](https://bytetool.web.app/en/ascii/).
Una cosa buffa è che alcuni caratteri, per quanto vengano codificati diversamente in UNICODE (giustamente) sono rappresentati dai vari sistemi di encoding con glifi identici. Questo è il caso della punto e virgola e `;` e il punto di domanda greco `;`. Sono rappresentati in modo identico, ma se messi su regex101 vedremo che `\x3B` non selezionerà entrambi, gli apparenti punti e virgola, ma solo uno.

Idea per uno scherzo: sostituire tutti i punti e virgola nel codice di un amico/collega con un punto di domanda greco. Ci sarà da ridere.

Per un elenco ancora più esaustivo potete andare anche su [compart.com](https://www.compart.com/en/unicode/).

## Conclusioni

Con questa lezione più storica che altro abbiamo visto l’origine di UNICODE e le entità che possiamo usare per identificare univocamente uno specifico carattere. Nella prossima lezione vedremo i lookup, la possibilità di guardarci intorno nelle espressioni regolari.

UNICODE  è uno standard che cataloga un'elevata quantità di caratteri. Vediamo la sua storia e a che punto è oggi e vediamo come usare l'entità \x

I caratteri UNICODE nelle espressioni regolari

Guardamoci intorno per validare le corrispondenze prima che vengano effettivamente considerate.

Finora abbiamo visto vari modi per individuare delle sottostringhe in un testo grazie all’ausilio delle regular expression, ma nessuno di questi ci ha permesso di fare un controllo prima di restituirci la corrispondenza.

Per assolvere a questa funzione esistono i lookaround, più nello specifico lookahead e lookbehind. Vediamoli.

## Lookahead

Le istruzioni di lookahead sono due:

1. `(?=...)`: si chiama positive lookahead e controlla se l’espressione è seguita da ciò che viene definito dopo l’uguale.
2. `(?!...)`: si chiama negative lookahead e controlla se l'espressione è seguita da ciò che viene definito dopo il punto esclamativo.

Facciamo un esempio pratico supponendo di avere questo testo:

```txt
10€ 10$ 10£
```

Se volessimo individuare tutti i numeri seguiti dal simbolo del dollaro sappiamo che la regex sarà `\d+[$|€]`, ma se non volessimo la valuta, ma solo la cifra? Allora in quel caso un positive lookahead fa al caso nostro.

```txt
\d+(?=\s*[$|€])
```

In questo caso controllo anche la presenza di zero o più spazi per quelle cifre che potrebbero essere anche scritte `10 €`, ma il risultato è proprio quello che speravamo e cioè un match solo sui 10 sia che siano seguiti dal simbolo dell’euro che dal simbolo del dollaro.

Se invece avessi un testo come questo:

```txt
Articolo: 10 panini	10€
```

E fossi interessato ad individuare un numero seguito da uno spazio e che ad un certo punto dopo la corrispondenza ci sia il simbolo dell’euro possiamo scrivere:

```txt
\d+(?=\s)(?=.*€)
```

Per quanto inusuale come esempio è un modo per mostrarvi come i lookaround possono essere anche messi uno di seguito all’altro affinché tutto le condizioni vengano soddisfatte.

Oppure ancora:

```txt
lola
```

Se fossi interessati a selezionare tutto le lettere che non sono seguite da una o, possiamo scrivere:

```txt
[A-Za-z](?!o)
```

In questo caso ho usato un negative lookahead perché esclusivamente interessato alle lettere non seguite dalla `o`.

## Lookbehind

Per il lookbehind abbiamo due comandi molto simili a quelli già visti con lookahead:

1. `(?<=...)`: positive lookbehind che controlla se l’espressione è preceduta da ciò che viene definito dopo l’uguale.
2. `(?<!...)`: negative lookbehind che controlla se l’espressione non è preceduta da ciò che viene definito dopo l’uguale.

La differenza sostanziale oltre al fatto che c’è una parentesi angolare tra il `?` e `=` e tra il `?` e `!` sta nel fatto che rispetto al lookahead il lookbehind viene messo a sinistra dell’espressione regolare.

L’espressione regolare vista in precedenza con le valute, qualora volessimo controllare che dei numeri siano preceduti dal simbolo di valuta possiamo scrivere:

```txt
(?<=[$|€])\d+
```
### Limitazioni di lookbehind

I più attenti avranno notato che rispetto a prima ho rimosso il `\s*`, questo perché i lookbehind in alcuni engine hanno delle limitazioni. Le espressioni regolari poste al loro interno devono essere “finite”, cioè non ci possono essere quantificatori.

Questa scelta è legata alle performance. L’engine non saprebbe quanto andare indietro e quindi si è preferito rendere l’operazione non possibile.

Questo discorso però non è valido per tutti gli engine, alcuni come quelli di .NET e Java consentono il lookbehind indefinito.

## Lookaround e backreference

Avrete sicuramente notato che usiamo le parentesi tonde per definire un lookaround. Questo comporta quindi anche la creazione di una backreference? Risposta breve no.

Nonostante l’uso delle parentesi tonde, i comandi di lookaround non creano anche una backreference. Per poterlo fare dobbiamo usare un ulteriore coppia di parentesi tonde, in questo modo:

```txt
(?<=(\$|€))\d+
\d+(?=\s*(\$|€))
```

Le espressioni nei lookaround sono state incluse in una coppia di parentesi tonde e questo ci permetterà di accedere al gruppo attraverso la sintassi vista nella [lezione sui gruppi](https://www.manuelricci.com/guida/gruppi-di-sostituzione-regex).

## Condizioni

Sempre rimanendo in tema di gruppi e lookaround, abbiamo la possibilità anche di scrivere delle condizioni, molto simili a degli `if/else`.

Supponendo di avere questo testo:

```txt
Il tofu è buono o disgustoso
```

Possiamo scrivere una condizione in questo modo:

```txt
(?(?=\xE8)(è buono)|(disgustoso))
```

La prima coppia di parentesi tonde è la condizione, la coppia `(?=\xE8)` può avere match positivo o negativo. Nel caso di positivo verrà quindi selezionato `è buono`, altrimenti in caso di condizione falsa `disgustoso`.

Nota: `\xE8` è la `è` codificata in UTF-16

## In pratica

Supponendo di avere questa serie di numeri

```txt
100 -34 -12 43 23 -3
```

Individuare i numeri positivi.

### Soluzione

Subito si può pensare di scrivere un’espressione simile a questa:

```txt
(?<!-)\d+
```

Quello che però stiamo cercando è quindi un numero che non venga preceduto dal `-`, questo significa che il `4` e il `2` di `-34` e `-12` corrispondo. Dobbiamo affinare la regex con un ulteriore lookbehind:

```txt
(?<!-)(?<!\d)\d+
```

Questo farà sì che i numeri vengano matchati correttamente. Tra l’altro questa regex può essere semplificata così:

```txt
(?<![-\d])\d+
```

E rimane comunque valida.

## Conclusioni

Detto questo quindi anche questa lezione sui lookaround nelle espressioni regolari ce la portiamo a casa, nella prossima, penultima lezione, vedremo tutti quei caratteri rimasti fuori da tutto ciò che abbiamo visto finora, una panoramica generale per sapere che esistono.

Lookahead e lookbehind permettono di controllare cosa c'è prima o dopo un espressione regolare per validare se c'è un match oppure no. Vediamoli in azione

Lookbehind e lookahead nelle espressioni regolari

Qualche entità del passato e alcune ancora utili oggi, vediamo i caratteri meno noti delle regex

Nelle lezioni precedenti abbiamo visto le entità e i comandi più usati delle regular expression. In questa lezione vediamo invece gli esclusi, quelli che non ho trattato perché usati di meno o in quasi totale disuso. Alcuni di questi ovviamente possono essere ancora molto utili (come ad esempio quando in testo si va a capo), ma altri invece appartengono al passato e per completezza è giusto citarli.

## Il carattere BELL

BELL è un carattere di controllo che in passato veniva utilizzato per far emettere un suono ai videoterminali.

Con le espressioni regolari si può cercare questo carattere con `\a`.

Volendo si può anche provare a riprodurre il suono da terminale. Sui sistemi Unix basterà eseguire questo comando:

```bash
$ echo $’\a’
```

Mentre da Windows:

```bash
$ echo ^G
```

Dove `^G` lo potete ottenere digitando `CTRL + G`.

## Gli NPC

NPC in questo caso non sta per personaggio non giocante, ma per carattere non stampabile (Non-Printable Characters). Sono tutti caratteri di controllo simili a BELL. I più comuni:

- null
- bell
- backspace
- horizontal tab
- line feed
- vertical tab
- form feed
- carriage return
- Control-Z
- escape

In [questa tabella](https://www.utf8-chartable.de/unicode-utf8-table.pl?utf8=oct) possiamo “vedere” che i primi caratteri non sono visibili con a fianco scritto `<control>`, questi sono tutti caratteri di controllo che non hanno rappresentazione. Potreste trovare dei simboli che li rappresentano, ma come sempre dipende dalla codifica.
Nelle regex possiamo individuali con `\cX` dove `X` è il carattere usato per riconoscerlo.

## Escape

Il carattere `ESCAPE` usato in passato per interrompere il processo di stampa può essere individuato con `\e` o `\x1B` o `\c[`.

 ## Nuovo inizio

Questo è il mio preferito tra questi caratteri “esotici”. In pratica `\K` imposta la nuova posizione della regex ignorando tutto ciò che viene prima.

Questa regex `[\d]+\K[\d,]+` applicata a questo testo `123,456,789` individua tutto ciò che viene dopo la prima virgola, ma non `123`.

## Caratteri ottali

Sempre per individuare carattere attraverso la loro codifica possiamo usare `\ddd` dove `ddd` è il numero ottale del carattere codificato in UTF-8. Sempre nella [tabella di prima](https://www.utf8-chartable.de/unicode-utf8-table.pl?utf8=oct) possiamo vedere la colonna `UTF-8 (oct.)` il numero riportato in quella colonna corrisponde al carattere nella colonna precedente.

`\041` corrisponde a `!`.

## Form feed

Altra entità che serve ad individuare un carattere di controllo è `\f` che individua il carattere di controllo form feed. Questo carattere veniva usato per comunicare alla stampante di saltare alla pagina successive.

Lo stesso carattere può essere trovato con `\cL` o `\x0C`

## A capo

Qui c’è un po’ di casino per colpa di Microsoft. `\n` è il carattere di fine riga (line feed), ma su Windows per qualche strana ragione è `\n` insieme a `\r`.

Questo ha causato un po’ di problemi in passato, anche i software moderni che trattano file hanno sistemi di conversione automatica. Git ad esempio, durante la fase di [installazione su Windows](https://www.manuelricci.com/guida/come-installare-git) ci chiede come vogliamo trattare questa situazione.

`\n` equivale a `\xA` e `\cJ`, mentre `\r` equivale a `\x0D`.

## Tab verticali e orizzontali

`\v` oggi è un po’ meno noto di suo fratello `\t`. Il primo infatti veniva usato in passato per comandare la stampante di avanzare con la carta. `\t` è ancora in uso oggi dato che è quel carattere che otteniamo prendendo il pulsante `TAB` della nostra tastiera. Quello che usiamo per indentare il codice, tanto per intenderci.

## I commenti

Potevano mancare i commenti anche nelle regex? Siamo chiaro, difficilmente abbiamo a che fare con Regex tanto lunghe da dover avere bisogno di commenti al loro interno. Ma in fondo non è questo il senso dei commenti? Supporre sempre che non servano.

Comunque, il commento può essere fatto con questo comando `(?#...)` dove `...` è il commento.

Prendiamo in esame la regex che abbiamo scritto quando abbiamo visto i [quantificatori nelle regular expression](https://www.manuelricci.com/guida/quantificatori-nelle-regexp) relativa al codice fiscale.

```txt
^[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$
```

Con i commenti sarebbe così:

```txt
^(?#nome)[A-Z]{6}(?#anno)\d{2}(?#mese)[A-Z](?#giorno)\d{2}(?#comune)[A-Z]\d{3}(?#checksum)[A-Z]$
```

Personalmente reputo che il commento aggiunga ulteriore difficoltà nel leggere la regex ed è estremamente più probabile che commenti con i commenti offerti dal linguaggio in uso per far capire cosa fa esattamente l’espressione regolare.

## Conclusioni

Queste sono le entità e i comandi che reputo necessitino una menzione, sia per valenza storico che in generale eventuale utilità. Non sono ancora tutti però, ce ne sono tanti altri che possono essere scoperti anche nella quick reference di regex101.com. Molte di queste sono semplici scorciatoie o alias di altri comandi quindi inutili da menzionare, ma buttateci comunque un occhio.

Ci siamo quasi, siamo veramente agli sgoccioli. La prossima sarà l’ultima lezione di questo corso sulle regular expression. Arrivati a questo punto dovrebbe essere passata un po’ la paura delle regex e spero che siate riusciti a comprenderle meglio.

Ci sono una moltitudine di caratteri meno noti delle regex che comunque meritano di essere menzionati, anche solo come valenza storica. Vediamo quali

Entità e comandi meno noti nelle regex

Vediamo i modificatori all'opera per dire all'engine come comportarsi in determinati casi.

In chiusura di un'espressione regolare possiamo trovare delle lettere. Quelli sono modificatori, la cui funzione è quella di modificare il comportamento dell’engine. Questo cambio ovviamente dipende dal tipo di lettera usata, noi ne vediamo alcune, ce ne sono un po’ di più, ma poterle utilizzare dipende strettamente dal tipo di linguaggio e di conseguenza engine che si sta utilizzando.

## Modificatore globale

Il modificatore globale o `/g` fa in modo che l’engine non si fermi alla prima ricorrenza, ma che prosegua fino alla fine del testo.

## Modificatore multilinea

Il modificatore multilinea o `/m` fa si che gli ancoraggi `^` e `$` si ancorino all’inizio e alla fine della riga. Se non venisse specificato i due ancoraggi si comporterebbero esattamente con `\A` e `\Z`.

## Modificatore di sensibilità

Suona strano, ma non è altro che il modificatore che si usa per evitare che l’espressione regolare faccia distinzione tra lettere minuscole e maiuscole. Viene indicato con la lettera `/c`.

## Modalità prolissa

La mia modalità. Scherzi a parte è una modalità che possiamo specificare con la lettera `/x` e permette di ignorare testo e spazi dopo un `#` (cancelletto, hash, diesis, ma non hashtag).

## Modalità a singola linea

La modalità a singola linea o `/s` fa in modo che il testo venga trattato come se fosse un’unica riga. In questa modalità, il carattere `.` (punto) che conosciamo per individuare tutti i caratteri ad esclusione di `\n` (fine riga), individua anche quest’ultimo.

## Modalità UNICODE

Di default l’engine individua tutti i caratteri a 2 bytes, ma con la modalità UNICODE o `/u` estende la selezione anche a quelli da 4 bytes come simboli matematici ed emoji.

## Modalità ungreedy

Già vista in passato, quando abbiamo parlato dei [quantificatori nelle regular expression](https://www.manuelricci.com/guida/quantificatori-nelle-regexp#greediness-e-laziness) permette di rendere i quantificatori lazy/pigri (di default sono greedy/avari).

## Nomi di gruppi di cattura duplicati

Questo premetto che non funziona ovunque, ma in sostanza con l’uso di `/J` possiamo fare in modo che i gruppi di cattura abbiano nomi identici, ciò significa che occuperanno lo stesso spazio di memoria e potranno essere usati insieme in fase di sostituzione.

Questo flag è disponibile solo in PHP, Delphi e R; o più in generale i linguaggi che usano PCRE (Perl Compatible Regular Expression) come engine.

## Attivare e disattivare i modificatori delle regex

I modificatori solitamente si trovano alla fine di un’espressione regolare:

```txt
/…regex…/modificatori
```

Se voglio usarne più di uno basta far seguire le varie lettere, in questo modo:

```txt
/…regex…/gmi
```

Esiste però un altro modo per poter attivare e disattivare i modificatori e questo avviene nel bel mezzo dell’espressione stessa. La sintassi da usare è la seguente:

- `(?flag)` per attivare il modificatore
- `(?-flag)` per disattivare il modificatore

Ipotizziamo di volevo testare la stringa `test`, questa si può presentare in diverse forme, `Test`, `tEst`, ecc. 

Le uniche varianti valide sono quelle con `s` ed `t` (quella finale) minuscole. Tutte le altre sono ok. Quindi possiamo scrivere un’espressione del genere:

```txt
(?i)te(?-i)st
```

In questo modo soddisferemo la consegna. Anche in questa modalità possiamo usare più modificatori. Basterà far seguire, come al solito le varie lettere. Peculiarità però è che possiamo decidere di disattivarli in momenti diversi. Ad esempio `(?ism)...(?i-sm)` attiva in contemporanea insensitive, single line e multi line e disattiva solo quest’ultimi due, lasciando attivo insensitive.

## Conclusioni

Con questo si conclude un altro percorso formativo offerto da Imparare Coding con Manuel.

Arrivati a questo punto le espressioni regolari non dovrebbero più sembrarti un incantesimo di magia nera, tutt’altro. Spero che il corso ti sia piaciuto.

Se hai 2 minuti vorrei sapere la tua opinione per poter migliorare la qualità in futuro. Il feedback è anonimo e per inviarmelo puoi compilare questo [modulo Google](https://forms.gle/Xf8zKkhKPLkkdStx6). Grazie!

Al prossimo corso.

Possiamo modificare il modo in cui un engine di espressioni regolari si comporta utilizzando delle flag speciali alla fine, chiamati anche modificatori.

Impararare le espressioni regolari

Lezioni

Lezioni

I caratteri speciali

Caratteri e bordi

Cifre e spazi

Set di caratteri

Ancoraggi di inizio e fine

I quantificatori

Gruppi di cattura e backreference

UNICODE

Lookahead e lookbehind

Caratteri meno noti

Modificare il comportamento dell'engine