PHP preg_match(): espressioni regolari con esempi

preg_match($pattern, $subject, $matches) verifica se una stringa corrisponde a un'espressione regolare. Restituisce 1 se corrisponde e 0 altrimenti, e riempie $matches con ciò che ha trovato: preg_match('/\d+/', 'Order 4521 shipped', $m) restituisce 1 e imposta $m[0] a "4521".

<?php
$text = 'Order 4521 shipped on 2026-03-14';

if (preg_match('/\d+/', $text, $m)) {
    echo "First number: {$m[0]}\n";
}

var_dump(preg_match('/shipped/', $text));   // found
var_dump(preg_match('/cancelled/', $text)); // not found
var_dump(preg_match('/SHIPPED/i', $text));  // i = case-insensitive

Lo schema è una stringa racchiusa tra delimitatori, di solito /.../, seguita da modificatori come i. Scrivi gli schemi tra apici singoli: tra virgolette doppie PHP espande prima $name e sequenze di escape come \x41 o \101, quindi il motore delle regex può ricevere uno schema diverso da quello che hai scritto.

Gruppi di cattura

Le parentesi in uno schema catturano la parte della stringa a cui corrispondono. $m[0] è l'intera corrispondenza, $m[1] il primo gruppo, $m[2] il secondo, contati per parentesi aperta da sinistra.

<?php
$text = 'Shipped on 2026-03-14 at 09:30';

if (preg_match('/(\d{4})-(\d{2})-(\d{2})/', $text, $m)) {
    print_r($m);
    [, $year, $month, $day] = $m;
    echo "Day $day, month $month, year $year\n";
}

// (?: ) groups without capturing
preg_match('/(?:at|on) (\d{2}:\d{2})/', $text, $t);
print_r($t);

Gruppi con nome

(?<name>...) dà un nome a un gruppo. Il valore viene salvato sotto il nome e sotto il suo numero, così il codice che legge il risultato non si rompe quando qualcuno aggiunge un gruppo prima nello schema.

<?php
$log = '[2026-03-14 09:30:12] ERROR: Disk almost full';

$pattern = '/^\[(?<date>[\d-]+) (?<time>[\d:]+)\] (?<level>\w+): (?<message>.+)$/';

if (preg_match($pattern, $log, $m)) {
    echo $m['level'], "\n";
    echo $m['message'], "\n";
    echo $m['date'], ' ', $m['time'], "\n";
}

// Keep only the named keys
print_r(array_filter($m, 'is_string', ARRAY_FILTER_USE_KEY));

Trovare ogni corrispondenza con preg_match_all

preg_match_all() continua a cercare dopo la prima corrispondenza e restituisce il numero di corrispondenze. Di default $m[0] contiene tutte le corrispondenze complete e $m[1] tutti i valori del primo gruppo. Con PREG_SET_ORDER ottieni invece un array per corrispondenza, più facile da scorrere con un ciclo.

<?php
$text = 'Contact ana@example.com or bo@test.org, not support@';

$count = preg_match_all('/(\w+)@(\w+\.\w+)/', $text, $m);
echo "Found $count addresses\n";
print_r($m[0]);   // full matches
print_r($m[2]);   // domains

preg_match_all('/(\w+)@(\w+\.\w+)/', $text, $sets, PREG_SET_ORDER);
foreach ($sets as $s) {
    echo "user {$s[1]} at {$s[2]}\n";
}

// Every number in a string
preg_match_all('/\d+/', 'a1 b22 c333', $nums);
print_r($nums[0]);

Validare l'input: ancore, numeri di telefono, codici postali

Per la validazione lo schema deve corrispondere all'intera stringa, quindi inizialo con ^ e terminalo con $. Una trappola: $ corrisponde anche prima di un a capo finale, quindi '/^\d+$/' accetta "123\n". Aggiungi il modificatore D, oppure usa \z, che corrisponde solo alla fine vera e propria.

<?php
$tests = ['123', '12a', "123\n", ''];

foreach ($tests as $t) {
    printf("%-8s plain:%d  with D:%d\n",
        json_encode($t),
        preg_match('/^\d+$/', $t),
        preg_match('/^\d+$/D', $t)
    );
}

// Japanese postal code: 123-4567
var_dump(preg_match('/^\d{3}-\d{4}$/D', '150-0002'));

// US phone: (555) 123-4567 or 555-123-4567 or 5551234567
$phone = '/^(\(\d{3}\) ?|\d{3}-?)\d{3}-?\d{4}$/D';
foreach (['(555) 123-4567', '555-123-4567', '5551234567', '55-1234'] as $p) {
    echo $p, ' => ', preg_match($phone, $p), "\n";
}

Per gli indirizzi email, una regex o rifiuta indirizzi validi o ne accetta di non validi. Usa invece filter_var($email, FILTER_VALIDATE_EMAIL) (vedi filter_var()).

Il modificatore u per UTF-8 e testo giapponese

Senza il modificatore u, uno schema lavora sui byte. Un carattere giapponese in UTF-8 occupa tre byte, quindi . corrisponde a un terzo di carattere e le lunghezze risultano sbagliate. Con u, lo schema lavora sui caratteri e puoi usare le classi di proprietà Unicode.

<?php
$word = '日本語';

var_dump(preg_match('/^.{3}$/', $word));   // bytes: 9, no match
var_dump(preg_match('/^.{3}$/u', $word));  // characters: 3, match

$text = 'PHPで正規表現を使う';
preg_match_all('/\p{Han}+/u', $text, $kanji);
preg_match_all('/\p{Katakana}+/u', 'コーヒーとカフェラテ', $kata);
print_r($kanji[0]);
print_r($kata[0]);

// Only hiragana (and the long vowel mark)?
var_dump(preg_match('/^[\p{Hiragana}ー]+$/uD', 'ひらがな'));

u valida anche la stringa: se non è UTF-8 valido, preg_match() restituisce false invece di cercare corrispondenze.

Applicare l'escape all'input dell'utente con preg_quote

Caratteri come ., +, ?, ( e / hanno significati speciali in uno schema. Se una parte dello schema arriva da una variabile, come un termine di ricerca, passala a preg_quote() con il delimitatore come secondo argomento, altrimenti 1+1 corrisponderà a 11 e una / senza escape rompe lo schema.

<?php
$search = '1+1';
$text = 'Is 11 the answer? No, 1+1 is 2.';

// Wrong: + means "one or more"
preg_match('/' . $search . '/', $text, $bad);
echo "Unescaped matched: {$bad[0]}\n";

// Right
$pattern = '/' . preg_quote($search, '/') . '/';
echo "Pattern: $pattern\n";
preg_match($pattern, $text, $good);
echo "Escaped matched: {$good[0]}\n";

Uno schema non valido non lancia eccezioni. PHP stampa un warning e preg_match() restituisce false:

Warning: preg_match(): No ending delimiter '/' found in /path/to/index.php on line 3

Quindi verifica === false (o preg_last_error_msg()) quando lo schema viene costruito a runtime. Per un semplice controllo di sottostringa senza alcuno schema, str_contains() è più veloce e più chiara. Per modificare il testo trovato, usa preg_replace().