Last updated: Fri, 18 Jul 2008

Modificatori di criterio (Pattern Modifiers)

(No version information available, might be only in CVS)

Modificatori di criterio (Pattern Modifiers) — Questo capitolo descrive i possibili modificatori applicabili ad una espressione regolare

Descrizione

Di seguito saranno elencati i valori attualmente previsti. I nomi posti tra parentesi si riferiscono ai corrispettivi nomi usati internamente da PCRE.

i (PCRE_CASELESS)
Se si attiva questo modificatore, l'espressione regolare viene riconosciuta senza distinguere tra le lettere maiuscole e minuscole.

m (PCRE_MULTILINE)
Per default, PCRE tratta il testo su cui fare la ricerca come una "singola linea" di caratteri (anche se in realtà può contenere diversi "a capo" (newline)). Il carattere di "inizio riga" (^) indica solamente l'inizio del testo passato. Analogamente il carattere di "fine riga" ($) indica la fine del testo o prima se vi sono dei caratteri di "a capo" (a meno che non sia attivato il modificatore D). In questo modo si comporta anche Perl. Invece quando viene indicato questo modificatore, "inizio riga" e "fine riga" vengono identificati in base ai caratteri di "a capo" presenti nel testo (rispettivamente subito dopo e subito prima di questo carattere). Questo comportamento è equivalente al modificatore /m di Perl. Se nel testo passato non vi sono caratteri di "a capo" o non vi sono occorrenze dei caratteri ^ o $ nell'espressione regolare, l'uso di questo modificatore non ha effetto.

s (PCRE_DOTALL)
Se si attiva questo modificatore, il carattere . usato nell'espressione regolare indica tutti i possibili caratteri compreso il carattere di "a capo" (newline). Senza questo modificatore il carattere "a capo" viene escluso. Questo modificare è equivalente a /s di Perl. Una espressione regolare contenente una forma negativa, come [^a], riconosce sempre un "a capo" a prescindere da questo modificatore.

x (PCRE_EXTENDED)
Se si attiva questo modificatore, verranno ignorati gli spazi presenti nell'espressione regolare, tranne quelli preceduti dal carattere di escape (\) o posti all'interno di una classe di caratteri. Saranno, inoltre, ignorati i caratteri posti tra il simbolo # (se non è preceduto dall'escape, ed è posto al di fuori di una classe di caratteri) ed il successivo carattere di "a capo" (newline). Questo comportamento equivale al flag /x di Perl e consente di inserire dei commenti all'interno di espressioni regolari complesse. Gli spazi bianchi non devono mai comparire all'interno di sequenze speciali di caratteri, come, ad esempio, la sequenza (?( che introduce ad un criterio condizionale.

e
Se viene specificato questo modificatore, la funzione preg_replace() valuta la stringa di sostituzione come codice PHP, quindi utilizza il risultato come testo da sostituire alle stringhe cercate. Gli apici singoli e doppi sono preceduti dal backslash nei riferimenti sostituiti.
Soltanto preg_replace() utilizza questo modificatore; le altre funzioni di PCRE lo ignorano.
Nota: Questo modificatore non è disponibile in PHP 3.

A (PCRE_ANCHORED)
Se si specifica questo modificatore, si forza un 'ancoraggio' del criterio di ricerca. In pratica questo viene costretto a riconoscere il testo su cui si fa la ricerca solo dall'inizio. Questo effetto può essere ottenuto anche con particolari costruzioni dell'espressione regolare, che rappresentano gli unici modi utilizzabili in Perl per ottenere il medesimo scopo.

D (PCRE_DOLLAR_ENDONLY)
L'uso di questo modificatore forza il carattere $ dell'espressione regolare a indicare la fine della stringa oggetto della ricerca. Senza questo modificatore il carattere $ indica la posizione subito prima dell'ultimo carattere se questo è un "a capo" (ma comunque non prima di ogni altro "a capo"). Questo modificatore viene ignorato se è attivato il modificatore m. Non vi sono flag equivalenti in Perl.

S
Quando una espressione regolare è destinata ad essere utilizzata diverse volte, vale la pena dedicare del tempo ad ottimizzare la velocità di riconoscimento. L'uso di questo modificatore permette questa analisi. Al momento lo studio della velocità è significativo per i criteri di ricerca "non ancorati", cioè espressioni che non hanno un carattere di partenza fisso.

U (PCRE_UNGREEDY)
Questo modificatore inverte la "voracità" delle occorrenze, in modo da non essere voraci per default, ma lo tornano ad essere se seguiti da "?". Questo flag non è compatibile con Perl. Questo comportamento può anche essere settato dalla sequenza (?U) settaggio dei modificatori all'interno del criterio di ricerca

X (PCRE_EXTRA)
Questo modificatore attiva funzionalità addizionali di PCRE che sono incompatibili con Perl. Ogni backslash (\) posto nell'espressione regolare che non sia seguito da una lettera con significato speciale causa un errore, ciò per riservare queste sequenze a future espansioni. Per default, Perl considera il backslash (\) seguito da una lettera priva di significato speciale come un qualsiasi testo. Al momento non vi sono altre caratteristiche gestite tramite questo modificatore.

u (PCRE_UTF8)
Questo modificatore attiva funzionalità di PCRE che sono incompatibili con Perl. Le stringhe di ricerca sono considerate come UTF-8. Questo modificatore è disponibile dalla versione 4.1.0 di PHP di Unix e dalla versione 4.2.3 sulla piattaforma win32.

Sintassi delle espressioni regolari

PCRE Patterns

Last updated: Fri, 18 Jul 2008

add a note User Contributed Notes
Modificatori di criterio (Pattern Modifiers)

ebarnard at marathonmultimedia dot com
06-Feb-2007 02:35


When adding comments with the /x modifier, don't use the pattern delimiter in the comments. It may not be ignored in the comments area. Example:



<?php

$target = 'some text';

if(preg_match('/

                e # Comments here

               /x',$target)) {

    print "Target 1 hit.\n";

}

if(preg_match('/

                e # /Comments here with slash

               /x',$target)) {

    print "Target 1 hit.\n";

}

?>



prints "Target 1 hit." but then generates a PHP warning message for the second preg_match():



Warning:  preg_match() [function.preg-match]: Unknown modifier 'C' in /ebarnard/x-modifier.php on line 11

varrah NO_GARBAGE_OR_SPAM AT mail DOT ru
03-Nov-2005 04:12


Spent a few days, trying to understand how to create a pattern for Unicode chars, using the hex codes. Finally made it, after reading several manuals, that weren't giving any practical PHP-valid examples. So here's one of them:



For example we would like to search for Japanese-standard circled numbers 1-9 (Unicode codes are 0x2460-0x2468) in order to make it through the hex-codes the following call should be used:

preg_match('/[\x{2460}-\x{2468}]/u', $str);



Here $str is a haystack string

\x{hex} - is an UTF-8 hex char-code

and /u is used for identifying the class as a class of Unicode chars.



Hope, it'll be useful.

hfuecks at nospam dot org
15-Jul-2005 07:14


Regarding the validity of a UTF-8 string when using the /u pattern modifier, some things to be aware of;



1. If the pattern itself contains an invalid UTF-8 character, you get an error (as mentioned in the docs above - "UTF-8 validity of the pattern is checked since PHP 4.3.5"



2. When the subject string contains invalid UTF-8 sequences / codepoints, it basically result in a "quiet death" for the preg_* functions, where nothing is matched but without indication that the string is invalid UTF-8



3. PCRE regards five and six octet UTF-8 character sequences as valid (both in patterns and the subject string) but these are not supported in Unicode ( see section 5.9 "Character Encoding" of the "Secure Programming for Linux and Unix HOWTO" - can be found at http://www.tldp.org/ and other places )



4. For an example algorithm in PHP which tests the validity of a UTF-8 string (and discards five / six octet sequences) head to: http://hsivonen.iki.fi/php-utf8/



The following script should give you an idea of what works and what doesn't;



<?php

$examples = array(

    'Valid ASCII' => "a",

    'Valid 2 Octet Sequence' => "\xc3\xb1",

    'Invalid 2 Octet Sequence' => "\xc3\x28",

    'Invalid Sequence Identifier' => "\xa0\xa1",

    'Valid 3 Octet Sequence' => "\xe2\x82\xa1",

    'Invalid 3 Octet Sequence (in 2nd Octet)' => "\xe2\x28\xa1",

    'Invalid 3 Octet Sequence (in 3rd Octet)' => "\xe2\x82\x28",



    'Valid 4 Octet Sequence' => "\xf0\x90\x8c\xbc",

    'Invalid 4 Octet Sequence (in 2nd Octet)' => "\xf0\x28\x8c\xbc",

    'Invalid 4 Octet Sequence (in 3rd Octet)' => "\xf0\x90\x28\xbc",

    'Invalid 4 Octet Sequence (in 4th Octet)' => "\xf0\x28\x8c\x28",

    'Valid 5 Octet Sequence (but not Unicode!)' => "\xf8\xa1\xa1\xa1\xa1",

    'Valid 6 Octet Sequence (but not Unicode!)' => "\xfc\xa1\xa1\xa1\xa1\xa1",

);



echo "++Invalid UTF-8 in pattern\n";

foreach ( $examples as $name => $str ) {

    echo "$name\n";

    preg_match("/".$str."/u",'Testing');

}



echo "++ preg_match() examples\n";

foreach ( $examples as $name => $str ) {

    

    preg_match("/\xf8\xa1\xa1\xa1\xa1/u", $str, $ar);

    echo "$name: ";



    if ( count($ar) == 0 ) {

        echo "Matched nothing!\n";

    } else {

        echo "Matched {$ar[0]}\n";

    }

    

}



echo "++ preg_match_all() examples\n";

foreach ( $examples as $name => $str ) {

    preg_match_all('/./u', $str, $ar);

    echo "$name: ";

    

    $num_utf8_chars = count($ar[0]);

    if ( $num_utf8_chars == 0 ) {

        echo "Matched nothing!\n";

    } else {

        echo "Matched $num_utf8_chars character\n";

    }

    

}

?>

csaba at alum dot mit dot edu
08-Apr-2005 05:40


Extracting lines of text:



You might want to grab a line of text within a multiline piece of text.  For example, suppose you want to replace the first and last lines within the <body> portion of a web $page with your own $lineFirst and $lineLast.  Here's one possible way:



<?php

$lineFirst = "This is a new first line<br>\r\n";

$lineLast  = "This is a new last line<br>\r\n";

$page = <<<EOD

<html><head>

<title>This is a test page</title>

</head><body>

This is the first line<br>

Hi Fred<br>

Hi Bill<br>

This is the last line<br>

</body>

</html>

EOD;

$re = "/<body>.*^(.+)(^.*?^)(.+)(^<\\/body>.*?)/smU";

if (preg_match($re, $page, $aMatch, PREG_OFFSET_CAPTURE))

$newPage = substr($text, 0, $aMatch[1][1]) .

           $lineFirst . $aMatch[2][0] .

           $lineLast . $aMatch[4][0];

print $newPage;

?>



The two (.+) are supposed to match the first and last lines within the <body> tag.  The /s option (dot all) is needed so the .* can also match newlines.  The /m option (multiline) is needed so that the ^ can match newlines.  The /U option (ungreedy) is needed so that the .* and .+ will only gobble up the minimum number of characters necessary to get to the character following the * or +.  The exception to this, however, is that the .*? temporarily overrides the /U setting on .* turning it from non greedy to greedy.  In the middle, this ensures that all the lines except the first and last (within the <body> tag) are put into $aMatch[2].  At the end, it ensures that all the remaining characters in the string are gobbled up, which could also have been achieved by .*)\\z/ instead of .*?)/



Csaba Gabor from Vienna

add a note

Sintassi delle espressioni regolari

PCRE Patterns

Last updated: Fri, 18 Jul 2008