Tekst źródłowy

Z DooBLER wiki

Nie masz uprawnień do tego działania z następującej przyczyny:
Wykonywanie tej operacji zostało ograniczone do użytkowników w grupie user.
Tekst źródłowy strony można w dalszym ciągu podejrzeć i skopiować.
{{Spis treści}}

== Wstęp ==

Ta strona przedstawia podstawy tworzenia i używania wyrażeń regularnych Perla.


W PHP następujące funkcje używają wyrażen PCRE:
* '''preg_filter''' — Perform a regular expression search and replace
* '''preg_grep''' — Zwraca elementy tablicy pasujące do wyrażenia
* '''preg_last_error''' — Zwraca kod błędu dla ostatnio użytego wyrażenia PCRE
* '''preg_match_all''' — Perform a global regular expression match
* '''preg_match''' — Perform a regular expression match
* '''preg_quote''' — Quote regular expression characters
* '''preg_replace_callback''' — Perform a regular expression search and replace using a callback
* '''preg_replace''' — Perform a regular expression search and replace
* '''preg_split''' — Split string by a regular expression

== Poradnik ==


=== Proste dopasowanie słów ===
Najprostszym wyrażeniem regularnym jest po prosty słowo, lub bardziej dokłanie zbiór znaków. Wyrażenie regularne zostanie dopasowane poprawnie do każdego tekstu zawierającego to słowo:
<source lang="perl" line>
"Hello World" =~ /World/;  # matches
</source>


{{Oryginał|In this statement, <code>World</code> is a regex and the <code>//</code> enclosing <code>/World/</code> tells perl to search a string for a match. The operator <code><nowiki>=~</nowiki></code> associates the string with the regex match and produces a true value if the regex matched, or false if the regex did not match. In our case, <code>World</code> matches the second word in <code>"Hello World"</code> , so the expression is true. This idea has several variations.}}

Wyrażenia takie jak to są przydatne przy tworzeniu warunków:
<source lang="perl" line>
print "It matches\n" if "Hello World" =~ /World/;
</source>


Wynik wyrażenia może zostać odwrócony przez operator <code>!~</code>:
<source lang="perl" line>
print "It doesn't match\n" if "Hello World" !~ /World/;
</source>


Tekst w wyrażeniu regularnym może zostać zamieniony na zmienną:
<source lang="perl" line>
$greeting = "World";
print "It matches\n" if "Hello World" =~ /$greeting/;
</source>


Jeśli porównujesz do <code>$_</code> , część <code>$_ =~</code> może zostać pominięta:
<source lang="perl" line>
$_ = "Hello World";
print "It matches\n" if /World/;
</source>


Dodatkowo, domyślne ograniczniki dopasowania <code>//</code> mogą zostać zmienione na dowolne inne przez dodanie <code>m</code> na początku:
<source lang="perl" line>
"Hello World" =~ m!World!;   # pasuje, ograniczane przez '!'
"Hello World" =~ m{World};   # pasuje, ograniczane przez '{}'
"/usr/bin/perl" =~ m"/perl"; # pasuje po '/usr/bin',
                             # '/' staje się zwykłym znakiem
</source>


Wyrażenie regularne musi pasować do tekstu dokładnie w takiej postaci jak zostało zapisane:
<source lang="perl" line>
"Hello World" =~ /world/;  # nie pasuje, ze względu na wielkość znaków
"Hello World" =~ /o W/;    # pasuje, spacja ' ' jest zwykłym znakiem
"Hello World" =~ /World /; # nie pasuje, brak spacji ' ' na końcu tekstu
</source>


Wyrażenie zawsze jest dopasowywane do najwcześniejszego wystąpienia w przetwarzanym tekście:
<source lang="perl" line>
"Hello World" =~ /o/;       # dopasowane zostało 'o' w 'Hello'
"That hat is red" =~ /hat/; # dopasowane zostało 'hat' w 'That'
</source>


Nie wszystkie znaki mogą zostać użyte "jak są" w wyrażeniu regularnym. Niektóre znaki nazywane '''metaznakami''' są zarezerwowane jako znaki spełniające określone funkcje w wyrażeniu. Te znaki to: 
 {}[]()^$.|*+?\


Metaznaki mogą zostać dopasowane jak zwykłe znaki przez dodanie przed nimi backslash'a <code>\</code>:
<source lang="perl" line>
"2+2=4" =~ /2+2/;    # nie pasuje, +  jest metaznakiem
"2+2=4" =~ /2\+2/;   # pasuje, \+ jest traktowane jak zwykłu symbol +
'C:\WIN32' =~ /C:\\WIN/;               # pasuje
"/usr/bin/perl" =~ /\/usr\/bin\/perl/; # pasuje
</source>
W ostatnim wyrażeniu backslasch został również dodany do zwykłego slash'a <code>/</code> ponieważ jest on w tym przypadku ogranicznikiem dopasowania.


Nie wyświetlane znaki ASCII powinny być reprezentowane przez '''sekwencje specjalne'''. Dobre przykłady takich znaków to <code>\t</code> dla TAB, <code>\n</code> dla znaku nowej linii, <code>\r</code> dla tzw. powrotu karetki. Inne znaki mogą być reprezentowane przez sekwencje specjalne ósemkowe <code>\033</code> lub szesnastkowe <code>\x1B</code>:
<source lang="perl" line>
"1000\t2000" =~ m(0\t2)        # pasuje
"cat"        =~ /\143\x61\x74/ # pasuje, ale jest to dziwny sposób by napisać cat
</source>


Wyrażenia regularne są traktowane zazwyczaj jak cudzysłowy <code>"</code> więc działa bezpośrednie wstawianie zmiennych:
<source lang="perl" line>
$foo = 'house';
'cathouse' =~ /cat$foo/;   # pasuje
'housecat' =~ /${foo}cat/; # pasuje
</source>


We wszystkich powyższych przykładach jeśli wyrażenie pasuje gdziekolwiek w tekście jest to rozpoznawane jako dopasowanie poprawne. Aby sprecyzować, w którym miejscu wyrażenie powinno pasować można użyć metaznaków kotwicznych (anchor) <code>^</code> i <code>$</code>. Znak <code>^</code> dopasowuje na początku tekstu, a znak <code>$</code> na końcu lub przed znakiem nowej linii na końcu tekstu. Kilka przykładów:
<source lang="perl" line>
$foo = 'house';
"housekeeper" =~ /keeper/;         # pasuje
"housekeeper" =~ /^keeper/;        # nie pasuje
"housekeeper" =~ /keeper$/;        # pasuje
"housekeeper\n" =~ /keeper$/;      # pasuje
"housekeeper" =~ /^housekeeper$/;  # pasuje
</source>


===Używanie klas znakowych===

Użycie klas znakowych umożliwia ustawienie grupy możliwych znaków do dopasowania zamiast jednego konretnego znaku w określonym miejscu wyrażenia regularnego. Klasy znaków są wyznaczane przez nawiasy kwadratowe <code>[...]</code> z grupą znaków między nimi. Kilka przykładów:
<source lang="perl" line>
/cat/;            # pasuje 'cat'
/[bcr]at/;        # pasuje 'bat', 'cat', lub 'rat'
"abc" =~ /[cab]/; # pasuje 'a'
</source>
W ostatnim przykładzie - nawet jeśli <code>c</code> jest pierwszą literą w klasie znaków, to najwcześniejszym miejscem do którego pasuje wyrażenie regularne jest <code>a</code> w tekście.

<source lang="perl" line>
/[yY][eE][sS]/; # pasuje 'yes' bez uwzględniania wielkości liter
                # 'yEs', 'Yes', 'YES', itp.
/yes/i;         # także dopasuje 'yes' bez uwzględniania wielkości liter
</source>
Ostatni przykład pokazuje użycie operatora <code>i</code>, który sprawia, że wielkość liter nie ma znaczenia przy dopasowaniu.


Klasy znaków również posiadają zbiór znaków o specjalnym znaczeniu (metaznaki). Jednak metaznaki wewnąrz klasy znaków są inne niż na zewnątrz. Te znaki specjalne to <code>-]\^$</code> jeśli mają zostać dopasowane należy dodać przed nimi backslash <code>\</code> jak przy zwykłych metaznakach:
<source lang="perl" line>
/[\]c]def/; # pasuje ']def' lub 'cdef'
$x = 'bcr';
/[$x]at/;   # pasuje 'bat, 'cat', lub 'rat'
/[\$x]at/;  # pasuje '$at' lub 'xat'
/[\\$x]at/; # pasuje '\at', 'bat, 'cat', lub 'rat'
</source>


Metaznak <code>-</code> jest operatorem zakresu dzięki temo możemy skrócić zapis w postaci <code>[0123456789]</code> lub <code>[abc...xyz]</code> na ospowiednio <code>[0-9]</code> i <code>[a-z]</code>
<source lang="perl" line>
/item[0-9]/;  # pasuje 'item0' lub 'item1' lub ... lub 'item9'
/[0-9a-fA-F]/;  # pasują cyfry w systemie szesnastkowym
</source>
Jeśli <code>-</code> jest pierwszym lub ostatnim znakiem w klasie znaków jest on traktowany jak zwykły znak minus/pauza.


Jeśli znak specjalny <code>^</code> znajduje się na pierwszej pozycji w klasie znaków wtedy tworzy on zaprzeczenie tej klasy, która zostanie dopasaowana do wszystkich znaków poza tymi, które się w niej znajdują. Oba warianty <code>[...]</code> lub <code>[^...]</code> muszą zostać spełnione w wyrażeniu regularnym aby zostało ono dopasowane.
<source lang="perl" line>
/[^a]at/;  # nie pasuje 'aat' lub 'at', ale pasują
           # wszystkie pozostałe 'bat', 'cat, '0at', '%at', itp.
/[^0-9]/;  # pasują wszystkie znaki nie będące cyframi
/[a^]at/;  # pasuje 'aat' lub '^at'; tutaj '^' jest traktowane jak 
           # zwykły znak bo nie jest na początku klasy znaków
</source>


Perl posiada kilka skrótów dla często używanych klas znaków.
* \d reprezentuje cyfry, odpowiada mu:<br /> <code>[0-9]</code>
* \s reprezentuje tzw. białe znaki, odpowiada mu:<br /> <code>[\ \t\r\n\f]</code>
* \w reprezentuje znaki alfanumeryczne i znak <code>_</code>, odpowiada mu:<br /> <code>[0-9a-zA-Z_]</code>
* \D jest zaprzeczeniem \d,reprezentuje wszystkie znaki poza cyframi , odpowiada mu:<br /> <code>[^0-9]</code>
* \S jest zaprzeczeniem \s, odpowiada mu:<br /> <code>[^\s]</code>
* \W jest zaprzeczeniem \w, odpowiada mu:<br /> <code>[^\w]</code>
* Dodatkowo kropka <code>.</code> pasuje do dowolnego znaku poza <code>\n</code>


Wszystkie skróty <code>\d\s\w\D\S\W</code> mogą być używane zarówno wewnątrz jak i na zewnątrz klas znaków. Poniżej kilka przykładów.
<source lang="perl" line>
/\d\d:\d\d:\d\d/; # pasuje do hh:mm:ss format czasu
/[\d\s]/;         # pasuje do dowolnej cyfry lub białego znaku
/\w\W\w/;         # pasuje do znaku alfanumerycznego, po którym jest
                  # znak nie alfanumeryczny, po którym jest znak alfanumeryczny
/..rt/;           # pasują dowolne dwa znaki, po których jest 'rt'
/end\./;          # pasuje 'end.'
/end[.]/;         # tak samo, pasuje 'end.'
</source>


Znak kotwiczny \b pasuje do granicy pomiędzy znakami alfanumerycznym i nie alfanumerycznym <code>\w\W</code> lub <code>\W\w</code>:
<source lang="perl" line>
$x = "Housecat catenates house and cat";
$x =~ /\bcat/;   # pasuje cat w słowie 'catenates'
$x =~ /cat\b/;   # pasuje cat w słowie 'housecat'
$x =~ /\bcat\b/; # pasuje 'cat' na końcu tekstu
</source>
W ostatnim przykładzie koniec tekstu jest rozpoznany jako granica znaków.


===Dopasowanie tego lub tamtego===

Przy pomocy metaznaku alternatywy <code>|</code> możliwe jest dopasowywanie na raz kilku róznych grup znaków do tekstu. Żeby dopasować <code>dog</code> lub <code>cat</code> utworzymy wyrażenie regularne w postaci <code>dog|cat</code>. Jak poprzednio perl spróbuje dopasować wyrażenie do tekstu jak najwcześniej. Na każdej pozycji zaczynając od początku tekstu perl sprubuje najpierw dopasować pierwszą alternatywę <code>dog</code> jeśli nie będzie pasować, perl sprawdzi na zaczynając od tego samego miejsca kolejną alternatywę <code>cat</code>. Jeśli <code>cat</code> także nie będzie pasować, wyrażenei regularne nie zostanie dopasowane więc perl przejdzie na kolejną pozycję i cała sytuacja dopasowywania się powtórzy. Przykłady:
<source lang="perl" line>
"cats and dogs" =~ /cat|dog|bird/;  # pasuje "cat"
"cats and dogs" =~ /dog|cat|bird/;  # pasuje "cat"
</source>
nawet jeśli <code>dog</code> jest pierwszą alternatywą w drugim przykładzie, <code>cat</code> został dopasowany bo występuje wcześniej w tekście.


<source lang="perl" line>
"cats"  =~ /c|ca|cat|cats/; # pasuje "c"
"cats"  =~ /cats|cat|ca|c/; # pasuje "cats"
</source>
W powyższym przykładzie widać, że jeśli wszystkie alternatywy pasują na tej samej pozycji w tekście, to zostanie dopasowana ta alternatywa, która zapisana jest jako pierwsza.


===Grupowanie i dopasowania hierarchiczne===

Metaznaki '''grupowania''' <code>()</code> pozwalają traktować część wyrażenia regularnego jak jedność. Część wyrażenia jest grupowana przez zamknięcie jej w nawiasach. Wyrażenie regularne <code>house(cat|keeper)</code> zostanie dopasowane w przypadku wystąpienia wyrazu <code>house</code> z przyrostkiem <code>cat</code> lub <code>keeper</code>. Kilka przykładów:

<source lang="perl" line>
/(a|b)b/;    # pasuje 'ab' lub 'bb'
/(^a|b)c/;   # pasuje 'ac' na początku tekstu 'bc' gdziekolwiek
</source>


<source lang="perl" line>
/house(cat|)/;      # pasuje 'housecat' lub 'house'
/house(cat(s|)|)/;  # pasuje 'housecats' lub 'housecat' lub
                    # 'house'.  Zwróć uwagę, że grupy mogą być zagnieżdżone.
</source>


<source lang="perl" line>
"20" =~ /(19|20|)\d\d/;  # pasuje pusta alternatywa '()\d\d',
                         # ponieważ '20\d\d' nie mogło zostać dopasowane
</source>


===Wyciąganie dopasowanych===
'''/Extracting matches'''


Metaznaki grupowania <code>()</code> pozwalają także na wyciągnięcie kawałka tekstu pasującego do grupy. Każda dopasowana grupa jest zapisywana w osobnej zmiennej, <code>$1</code>, <code>$1</code> itd. Mogą być one używane jak wszystkie inne normalne zmienne:
<source lang="perl" line>
$czas =~ /(\d\d):(\d\d):(\d\d)/;  # pasuje godzina zapisana w formacie hh:mm:ss
$godziny = $1;
$minuty = $2;
$seundy = $3;
</source>

W kontekście listy, dopasowanie <code>/wyrażenia/</code> zawierającego grupy zwróci listę dopasowanych wartości <code>($1,$2,...)</code>. Dlatego powyższy przykład można zapisać jako:
<source lang="perl" line>
($godziny, $minuty, $seundy) = ($czas =~ /(\d\d):(\d\d):(\d\d)/);
</source>


Jeśli grupy w wyrażeniu regularnym są zagnieżdżone <code>$1</code> przyjmie wartość dopasowaną do grypy zaczynającej się najwcześniejszym od lewej strony nawiasem otwierającym, <code>$2</code> wartość grupy zaczynającej się kolejnym nawiasem otwierającym itd. Poniższy przykład prezentuje skomplikowane wyrażenie regularne, w linii 2 napisane są numery zmiennych otrzymujących wartości:
<source lang="perl" line>
/(ab(cd|ef)((gi)|j))/;
 1  2      34
</source>


Jeśli w wyrażeniu regularnym do zmiennych <code>$1</code>, <code>$2</code> zostały przypisane wartości mogą one zostać użyte w tym samym wyrażeniu przez zapis <code>\1</code>, <code>\2</code>.
Na przykład:
<source lang="perl" line>
/(\w\w\w)\s\1/; # znajduje w tekście ciągi znaków jak 'the the', 'nie nie' itp.
</source>
Zapis <code>$1</code>, <code>$2</code>, ... powinny być używane jedynie poza wyrażeniem regularnym, natomiast <code>\1</code>, <code>\2</code>, ... jedynie wewnątrz wyrażeń.


===Powtórzenia===

Metaznaki '''kwantyfikatorów''' <code>?</code>, <code>*</code>, <code>+</code>, i <code>{}</code> pozwalają określić ilość powtórzeń części wyrażenia regularnego. Kwantyfikatory umieszcza się zaraz po znaku, klasie znakowej lub grupie, której chcemy ustalić ilość powtórzeń. Kwantyfikatory mają następujące znaczenia:
* <code>a?</code> = dopasuj gdy 'a' występuje 1 lub 0 razy
* <code>a*</code> = dopasuj gdy 'a' występuje 0 lub więcej razy, czyli dowolna ilość powtórzeń
* <code>a+</code> = dopasuj gdy 'a' występuje 1 lub więcej razy, czyli przynajmniej raz
* <code>a{n,m}</code> = dopasuj gdy 'a' występuje nie mniej niż 'n' razy i nie więcej niż 'm' razy
* <code>a{n,}</code> = dopasuj gdy 'a' nie mniej niż 'n' razy
* <code>a{n}</code> = dopasuj gdy 'a' występuje dokładnie 'n' razy

Poniżej kilka przykładów:
<source lang="perl" line>
/[a-z]+\s+\d*/;  # pasuje dowolne słowo zapisane małymi literami, po którym występuje 
                 # przynajmniej jeden biały znak, po którym jest dowolny ciąg cyfr
/(\w+)\s+\1/;    # pasuje każdy zdublowany alfanumeryczny ciąg znaków rozdzielony białym znakiem
$rok =~ /\d{2,4}/;     # pasuje gdy rok składa się z przynajmniej 2 cyfr, ale nie więcej niż z 4
$rok =~ /\d{4}|\d{2}/; # pasuje rok zapisany  w postaci 2 lub 4 cyfrowej
</source>


Kwantyfikatory próbują dopasować do siebie tyle tekstu ile się da aby wyrażenie regularne było spełnione:
<source lang="perl" line>
$x = 'the cat in the hat';
$x =~ /^(.*)(at)(.*)$/; # pasuje,
                        # $1 = 'the cat in the h'
                        # $2 = 'at'
                        # $3 = ''   (nic nie jest dopasowane)
</source>
Pierwszy kwantyfikator <code>.*</code> "zabiera" maksymalną ilość tekstu pozostawiając tylko tyle aby wyrażenie było nadal spełnione. Kolejna grupa w tym przypadku dopasowuje pozostałą część, dlatego ostatnia z nich <code>(.*)</code> zostaje dopasowana 0 razy (co jest zgodne z kwantyfikatorem) i nie zwraca ona wartości.

===More matching===
'''/Więcej dopasowań'''


===Search and replace===
'''/Znajdź i zmień'''


===The split operator===
'''/Operator podziału'''


==AUTHOR AND COPYRIGHT==

Copyright (c) 2000 Mark Kvale All rights reserved.

This document may be distributed under the same terms as Perl itself.

== inne ==
{{Zalążek}}
Jest to nieoficjalne tłumaczenie oficjalnej dokumentacji dostępnej na stronie http://perldoc.perl.org/perlrequick.html
[[Kategoria:PHP|PCRE wyrażenia regularne]]
Szablony użyte na tej stronie:
Wróć do strony PCRE wyrażenia regularne.
Źródło: "http://wiki.doobler.net/PCRE_wyra%C5%BCenia_regularne"
Tekst źródłowy

Z DooBLER wiki

Widok

Osobiste

Nawigacja

Kategorie główne

Reklamy

Zaprzyjaźnione strony

Szukaj

Narzędzia
