/ciao/         // matcha "ciao"
/Ciao/i        // case-insensitive
/^abc/         // ancorato a inizio stringa

. ^ $ * + ? ( ) [ ] { } | \

/a.c/    // a + qualunque + c
/a.c/s   // . include anche \n (flag s)

\d    cifra [0-9]
\D    non cifra
\w    parola [A-Za-z0-9_]
\W    non parola
\s    whitespace
\S    non whitespace

[abc]      uno tra a, b, c
[a-z]      range a..z
[A-Za-z0-9_]   come \w
[^abc]     NEGATA: tutto tranne a,b,c
[.,;:]     punteggiatura letterale

\p{L}             qualunque Lettera
\p{N}             Numero
\p{S}             Simbolo
\p{Script=Latin}  alfabeto latino
\P{L}             non-lettera

a*       0 o piu' a
a+       1 o piu' a
a?       0 o 1 a (opzionale)
a{3}     esattamente 3
a{2,5}   da 2 a 5
a{2,}    almeno 2

.+       greedy: il piu' possibile
.+?      lazy: il meno possibile
.*?      lazy zero-or-more
a{2,5}?  versione lazy

^        inizio stringa (o riga con flag m)
$        fine stringa (o riga con flag m)
\b       confine di parola
\B       NON confine di parola
\A \z    inizio/fine assoluti (non in JS)

/^abc/      stringa che inizia con abc
/abc$/      stringa che finisce con abc
/\bword\b/  parola intera
/^\s*$/m    riga vuota (con flag m)

(abc)             cattura, accessibile come $1
(?:abc)           non-cattura
(?<nome>abc)      named: groups.nome / $<nome>
a|b|c             alternative (a oppure b oppure c)

(\w+)\s+\1        parola duplicata consecutiva
(?<a>\w)\k<a>     backref nominato
String.replace(/(\w+) (\w+)/, '$2 $1')

(?=...)    positivo: deve seguire ...
(?!...)    negativo: NON deve seguire ...
\d+(?= euro)   cifre solo se seguite da " euro"

(?<=...)   positivo: deve precedere ...
(?<!...)   negativo: NON deve precedere ...
(?<=\$)\d+   cifre solo se precedute da $

g    global (tutti i match)
i    ignore case
m    multiline (^ e $ per riga)
s    dot all (. matcha \n)
u    Unicode (abilita \p{...})
v    Unicode v-mode (set operations)
y    sticky (solo da lastIndex)
d    has indices

gi      "trova tutto, no case"
gm      righe in testo multilinea
gs      blocchi su piu' righe
gu      testi reali con accenti / emoji

'foo bar'.replace(/o/g, '0')          // 'f00 bar'
'Mario Rossi'.replace(/(\w+) (\w+)/, '$2 $1')
// '2024-03-15' -> '15/03/2024'
data.replace(/(\d{4})-(\d{2})-(\d{2})/, '$3/$2/$1');

str.replace(/\d+/g, (m) => Number(m) * 2);
str.replace(/(\d{4})-(\d{2})/, (_, a, m) => `$\{m\}/$\{a\}`);

'a, b ,c,  d'.split(/\s*,\s*/)
// ['a','b','c','d']
'a=1; b=2'.split(/\s*;\s*/)
// ['a=1', 'b=2']

$1 $2 ...   gruppo numerato
$<nome>     gruppo nominato
$&          intero match
$`          testo prima del match
$'          testo dopo il match
$$          un $ letterale

/[\w.+-]+@[\w-]+(?:\.[\w-]+)+/

/\b(?:\d{1,3}\.){3}\d{1,3}\b/

/https?:\/\/[\w.-]+(?::\d+)?(?:\/[^\s]*)?/

/-?\d+(?:\.\d+)?/

s.replace(/^\s+|\s+$/g, '')

(a+)+b           NIDIFICATO -> esplode
(a|a)*           ALTERNATIVE sovrapposte
(\w+\s+)+        gruppo greedy ripetuto

^(\w+\s+)+$       pericoloso
^(?:\w+\s+)*\w+$  sicuro
.*?,.*?,.*?,       limita backtracking con lazy