Corso Regex

Le fondamenta delle regex: pattern letterali, classi di carattere base, jolly `.` ed escape dei meta-caratteri.

1. 1.1Pattern letteraliCaratteri normali, sensibilità al case e prima esecuzione: match e indice.~8 min
2. 1.2Classi base: \d \w \sLe classi predefinite per cifre, caratteri di parola e spazi (e le loro versioni negate).~10 min
3. 1.3Il jolly: il punto `.`Il carattere `.` matcha quasi tutto: cosa include, cosa no, e perché serve la flag `s`.~8 min
4. 1.4Escape dei meta-caratteriI 12 meta-caratteri da escapare con `\`, quando serve il doppio backslash e perché.~10 min

Quanto ripetere: `*`, `+`, `?`, intervalli `{n,m}` e differenza greedy vs lazy.

1. 2.1`*`, `+`, `?`Zero o più, uno o più, opzionale: i tre quantificatori base.~10 min
2. 2.2Quantità esatte `{n,m}`Esattamente `n`, da `n` a `m`, almeno `n`: il quantificatore numerico.~10 min
3. 2.3Greedy vs lazyPer default i quantificatori sono avidi (`.*`); aggiungi `?` per la versione pigra (`.*?`).~10 min
4. 2.4Backtracking: cenniCosa fa l’engine quando un quantificatore avido fallisce, e perché può costare caro.~12 min

Posizione, non carattere: ancorare a inizio/fine stringa, ai confini di parola, e all’inizio/fine di ogni riga con la flag `m`.

1. 3.1Inizio e fine: `^` e `$`Ancorare un pattern al primo o all’ultimo carattere della stringa.~8 min
2. 3.2Confini di parola: `\b` `\B`La transizione fra carattere di parola e non-parola; trovare parole intere.~10 min
3. 3.3Flag `m`: multilineCon la flag `m`, `^` e `$` si ancorano a inizio/fine di ogni riga.~10 min
4. 3.4Righe vuote e trimPattern utili: matchare righe vuote, fare trim degli spazi a inizio/fine di una riga.~10 min

Raggruppare con `()`, scegliere fra alternative con `|`, evitare la cattura con `(?:...)`, dare nomi ai gruppi con `(?<nome>...)` e riferirsi a una cattura precedente con i backreference.

1. 4.1Gruppi di cattura: `(...)`Parentesi tonde per raggruppare e catturare; accesso ai gruppi 1, 2, 3… nei match.~10 min
2. 4.2Alternative: `|`La pipe scegliere fra due o più sotto-pattern; precedenza e parentesi.~10 min
3. 4.3Gruppi non-cattura: `(?:...)`Raggruppare senza creare una cattura: utile per quantificare o alternare.~10 min
4. 4.4Gruppi nominati e backreference`(?<nome>...)` per dare un nome; `\1` `\k<nome>` per riferirsi alla cattura.~12 min

Definire insiemi custom con `[...]`, usare i range, negare con `[^...]` e attingere alle property Unicode con `\p{...}` e la flag `u`.

1. 5.1Set di caratteri: `[abc]`Quadre per definire un insieme di caratteri ammessi in una posizione.~8 min
2. 5.2Range nelle classi: `[a-z0-9]`Intervalli con il trattino; combinare range e caratteri singoli.~8 min
3. 5.3Negazione: `[^...]`Una classe negata matcha qualunque cosa **tranne** i caratteri elencati.~8 min
4. 5.4Unicode property escapes`\p{L}`, `\p{N}`, `\p{Script=...}` con flag `u`: classi semantiche Unicode.~12 min

Asserzioni a larghezza zero: guardare avanti o indietro nella stringa senza consumare caratteri. Lookahead `(?=)` `(?!)`, lookbehind `(?<=)` `(?<!)`.

1. 6.1Lookahead positivo: `(?=...)`Verifica che dopo la posizione corrente segua un certo pattern, senza consumarlo.~10 min
2. 6.2Lookahead negativo: `(?!...)`Verifica che dopo la posizione corrente NON segua un certo pattern.~10 min
3. 6.3Lookbehind: `(?<=...)` `(?<!...)`Le versioni "guardare indietro" dei lookaround; supporto ES2018+.~12 min
4. 6.4Lookaround in praticaEstrarre un valore senza includere il contesto, validare password, parse di numeri delimitati.~12 min

Tutti i flag (incl. `d`, `v`), `String.prototype.replace`/`replaceAll`/`split` con regex, riferimenti `$1`/`$<nome>` nella stringa di sostituzione e replace callback.

1. 7.1Tutti i flag in dettaglio`g i m s u v y d`: cosa fa ognuno e come si combinano.~12 min
2. 7.2Replace base e `$1`Sostituire match con stringa fissa o con backreference `$1` / `$<nome>`.~10 min
3. 7.3Replace con callbackFunzione di sostituzione: trasformare ogni match con codice JS arbitrario, accesso ai gruppi.~12 min
4. 7.4Split con regexSeparare una stringa su un pattern (CSV permissivo, tokenizer minimal).~10 min

Mettere insieme tutto su problemi reali: validare email, parsare log, estrarre URL/IP, scrivere pattern resistenti al ReDoS.

1. 8.1Validare un’emailUn pattern "abbastanza buono" per email, con i compromessi spiegati.~12 min
2. 8.2Parser di log ApacheEstrarre IP, metodo, path e status code da una riga di log con named groups.~12 min
3. 8.3Estrarre URL e IPRiconoscere URL http(s) e indirizzi IPv4 in mezzo a testo libero.~12 min
4. 8.4Scrivere pattern ReDoS-safeRiconoscere i pattern catastrofici (`(a+)+b`), rifattorizzarli, usare quantificatori atomici-like.~14 min