Perl - wyrażenia regularne

Wyrażenie regularne to ciąg znaków definiujący wyświetlany wzorzec lub wzorce. Składnia wyrażeń regularnych w Perlu jest bardzo podobna do tego, co znajdziesz w innych programach obsługujących wyrażenia regularne, takich jaksed, grep, i awk.

Podstawową metodą stosowania wyrażenia regularnego jest użycie operatorów wiązania wzorca = ~ i !~. Pierwszy operator to operator testu i przypisania.

W Perlu są trzy operatory wyrażeń regularnych.

• Dopasuj wyrażenie regularne - m //
• Zastąpienie wyrażenia regularnego - s ///
• Transliteracja wyrażenia regularnego - tr ///

W każdym przypadku ukośniki działają jak ograniczniki wyrażenia regularnego (regex), które określasz. Jeśli czujesz się komfortowo z jakimkolwiek innym separatorem, możesz użyć zamiast ukośnika.

Operator dopasowania

Operator dopasowania, m //, służy do dopasowania ciągu lub instrukcji do wyrażenia regularnego. Na przykład, aby dopasować sekwencję znaków „foo” do skalarnego bara $ bar, możesz użyć takiego oświadczenia -

#!/usr/bin/perl

$bar = "This is foo and again foo";
if ($bar =~ /foo/) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo";
if ($bar =~ /foo/) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Wykonanie powyższego programu daje następujący wynik -

First time is matching
Second time is matching

M // faktycznie działa w taki sam sposób, jak seria operatorów q //. Możesz użyć dowolnej kombinacji naturalnie pasujących znaków, aby działać jako ograniczniki wyrażenia. Na przykład m {}, m () i m> <są prawidłowe. Tak więc powyższy przykład można przepisać w następujący sposób -

#!/usr/bin/perl

$bar = "This is foo and again foo";
if ($bar =~ m[foo]) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo";
if ($bar =~ m{foo}) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Możesz pominąć m z m //, jeśli separatory są ukośnikami, ale dla wszystkich innych separatorów musisz użyć przedrostka m.

Zauważ, że całe wyrażenie dopasowujące, czyli wyrażenie po lewej stronie = ~ lub! ~ Oraz operator dopasowania, zwraca wartość true (w kontekście skalarnym), jeśli wyrażenie pasuje. Dlatego oświadczenie -

$true = ($foo =~ m/foo/);

ustawi $ true na 1, jeśli $ foo pasuje do wyrażenia regularnego, lub na 0, jeśli dopasowanie się nie powiedzie. W kontekście listowym dopasowanie zwraca zawartość wszystkich zgrupowanych wyrażeń. Na przykład podczas wyodrębniania godzin, minut i sekund z ciągu czasu możemy użyć -

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Dopasuj modyfikatory operatorów

Operator dopasowania obsługuje własny zestaw modyfikatorów. Modyfikator / g umożliwia dopasowanie globalne. Modyfikator / i sprawi, że w dopasowaniu wielkość liter będzie niewrażliwa. Oto pełna lista modyfikatorów

Sr.No.	Modyfikator i opis
1	i Sprawia, że ​​wielkość liter w dopasowaniu jest niewrażliwa.
2	m Określa, że ​​jeśli ciąg ma znaki nowej linii lub powrotu karetki, operatory ^ i $ będą teraz dopasowywać się do granicy nowej linii, a nie do granicy ciągu.
3	o Oblicza wyrażenie tylko raz.
4	s Umożliwia korzystanie z. aby dopasować znak nowej linii.
5	x Umożliwia użycie spacji w wyrażeniu w celu zwiększenia przejrzystości.
6	g Globalnie znajduje wszystkie dopasowania.
7	cg Umożliwia kontynuowanie wyszukiwania nawet po niepowodzeniu globalnego dopasowania.

Dopasowanie tylko raz

Istnieje również prostsza wersja operatora dopasowania -? WZÓR? operator. Jest to w zasadzie identyczne z operatorem m //, z wyjątkiem tego, że pasuje tylko raz w ciągu szukanym między każdym wywołaniem resetowania.

Na przykład możesz użyć tego, aby uzyskać pierwszy i ostatni element listy -

#!/usr/bin/perl

@list = qw/food foosball subeo footnote terfoot canic footbrdige/;

foreach (@list) {
   $first = $1 if /(foo.*?)/;
   $last = $1 if /(foo.*)/;
}
print "First: $first, Last: $last\n";

Wykonanie powyższego programu daje następujący wynik -

First: foo, Last: footbrdige

Zmienne wyrażeń regularnych

Zmienne wyrażeń regularnych obejmują $, który zawiera ostatnie dopasowane dopasowanie grupujące; $&, który zawiera cały dopasowany ciąg; $`, który zawiera wszystko przed dopasowanym ciągiem; i$', który zawiera wszystko po dopasowanym ciągu. Poniższy kod demonstruje wynik -

#!/usr/bin/perl

$string = "The food is in the salad bar";
$string =~ m/foo/;
print "Before: $`\n";
print "Matched: $&\n";
print "After: $'\n";

Wykonanie powyższego programu daje następujący wynik -

Before: The
Matched: foo
After: d is in the salad bar

Operator podstawienia

Operator podstawiania, s ///, jest tak naprawdę tylko rozszerzeniem operatora dopasowania, które umożliwia zastąpienie dopasowanego tekstu jakimś nowym tekstem. Podstawowa forma operatora to -

s/PATTERN/REPLACEMENT/;

WZÓR to wyrażenie regularne dla szukanego tekstu. REPLACEMENT to specyfikacja tekstu lub wyrażenia regularnego, którego chcemy użyć do zastąpienia znalezionego tekstu. Na przykład możemy zastąpić wszystkie wystąpieniadog z cat używając następującego wyrażenia regularnego -

#/user/bin/perl

$string = "The cat sat on the mat";
$string =~ s/cat/dog/;

print "$string\n";

Wykonanie powyższego programu daje następujący wynik -

The dog sat on the mat

Modyfikatory operatorów substytucji

Oto lista wszystkich modyfikatorów używanych z operatorem podstawienia.

Sr.No.	Modyfikator i opis
1	i Sprawia, że ​​wielkość liter w dopasowaniu jest niewrażliwa.
2	m Określa, że ​​jeśli ciąg ma znaki nowej linii lub powrotu karetki, operatory ^ i $ będą teraz dopasowywać się do granicy nowej linii, a nie do granicy ciągu.
3	o Oblicza wyrażenie tylko raz.
4	s Umożliwia korzystanie z. aby dopasować znak nowej linii.
5	x Umożliwia użycie spacji w wyrażeniu w celu zwiększenia przejrzystości.
6	g Zamienia wszystkie wystąpienia znalezionego wyrażenia na tekst zastępczy.
7	e Ocenia zamianę tak, jakby była instrukcją Perla i używa jej wartości zwracanej jako tekstu zastępczego.

Operator tłumaczenia

Tłumaczenie jest podobne, ale nie identyczne, do zasad podstawiania, ale w przeciwieństwie do podstawiania tłumaczenie (lub transliteracja) nie wykorzystuje wyrażeń regularnych do wyszukiwania wartości zastępczych. Operatorami tłumaczenia są -

tr/SEARCHLIST/REPLACEMENTLIST/cds
y/SEARCHLIST/REPLACEMENTLIST/cds

Tłumaczenie zastępuje wszystkie wystąpienia znaków w SEARCHLIST odpowiednimi znakami w REPLACEMENTLIST. Na przykład za pomocą polecenia „Kot siedział na macie”. ciąg, którego używaliśmy w tym rozdziale -

#/user/bin/perl

$string = 'The cat sat on the mat';
$string =~ tr/a/o/;

print "$string\n";

Wykonanie powyższego programu daje następujący wynik -

The cot sot on the mot.

Można również użyć standardowych zakresów Perla, co pozwala określić zakresy znaków według litery lub wartości liczbowej. Aby zmienić wielkość liter w ciągu, możesz użyć następującej składni zamiastuc funkcjonować.

$string =~ tr/a-z/A-Z/;

Modyfikatory operatora tłumaczenia

Poniżej znajduje się lista operatorów związanych z tłumaczeniem.

Sr.No.	Modyfikator i opis
1	c Uzupełnia SEARCHLIST.
2	d Usuwa znalezione, ale niezastąpione znaki.
3	s Zgniata zduplikowane zastąpione znaki.

Modyfikator / d usuwa znaki pasujące do LISTY WYSZUKIWANIA, które nie mają odpowiedniego wpisu w LISTA ZAMIENNIKÓW. Na przykład -

#!/usr/bin/perl 

$string = 'the cat sat on the mat.';
$string =~ tr/a-z/b/d;

print "$string\n";

Wykonanie powyższego programu daje następujący wynik -

b b   b.

Ostatni modyfikator / s usuwa zduplikowane sekwencje znaków, które zostały zastąpione, więc -

#!/usr/bin/perl

$string = 'food';
$string = 'food';
$string =~ tr/a-z/a-z/s;

print "$string\n";

Wykonanie powyższego programu daje następujący wynik -

fod

Bardziej złożone wyrażenia regularne

Nie musisz tylko dopasowywać się do ustalonych łańcuchów. W rzeczywistości możesz dopasować prawie wszystko, o czym możesz marzyć, używając bardziej złożonych wyrażeń regularnych. Oto krótka ściągawka -

Poniższa tabela zawiera listę składni wyrażeń regularnych, które są dostępne w Pythonie.

Sr.No.	Wzór i opis
1	^ Dopasowuje początek wiersza.
2	$ Pasuje do końca linii.
3	. Dopasowuje dowolny pojedynczy znak z wyjątkiem nowej linii. Użycie opcji m pozwala dopasować również znak nowej linii.
4	[...] Dopasowuje dowolny pojedynczy znak w nawiasach.
5	[^...] Dopasowuje dowolny pojedynczy znak nie w nawiasach.
6	* Dopasowuje 0 lub więcej wystąpień poprzedniego wyrażenia.
7	+ Dopasowuje 1 lub więcej wystąpień poprzedniego wyrażenia.
8	? Dopasowuje 0 lub 1 wystąpienie poprzedniego wyrażenia.
9	{ n} Dopasowuje dokładnie n liczbę wystąpień poprzedniego wyrażenia.
10	{ n,} Dopasowuje n lub więcej wystąpień poprzedniego wyrażenia.
11	{ n, m} Dopasowuje co najmniej n i co najwyżej m wystąpień poprzedniego wyrażenia.
12	a| b Pasuje do a lub b.
13	\w Dopasowuje znaki słowne.
14	\W Dopasowuje znaki inne niż słowa.
15	\s Dopasowuje spacje. Odpowiednik [\ t \ n \ r \ f].
16	\S Dopasowuje bez białych znaków.
17	\d Dopasowuje cyfry. Odpowiednik [0-9].
18	\D Dopasowuje niecyfry.
19	\A Dopasowuje początek łańcucha.
20	\Z Dopasowuje koniec łańcucha. Jeśli istnieje nowa linia, pasuje ona tuż przed nową linią.
21	\z Dopasowuje koniec łańcucha.
22	\G Mecze to miejsce, w którym zakończył się ostatni mecz.
23	\b Dopasowuje granice wyrazów poza nawiasami. Dopasowuje znak Backspace (0x08) wewnątrz nawiasów.
24	\B Dopasowuje granice bez słów.
25	\n, \t, etc. Dopasowuje znaki nowej linii, powroty karetki, tabulatory itp.
26	\1...\9 Pasuje do n-tego zgrupowanego wyrażenia podrzędnego.
27	\10 Pasuje do n-tego zgrupowanego wyrażenia podrzędnego, jeśli zostało już dopasowane. W przeciwnym razie odnosi się do ósemkowej reprezentacji kodu znaku.
28	[aeiou] Dopasowuje pojedynczy znak w podanym zestawie
29	[^aeiou] Dopasowuje pojedynczy znak poza podanym zestawem

Metaznak ^ pasuje do początku ciągu, a metasymbol $ do końca ciągu. Oto kilka krótkich przykładów.

# nothing in the string (start and end are adjacent)
/^$/   

# a three digits, each followed by a whitespace
# character (eg "3 4 5 ")
/(\d\s) {3}/  

# matches a string in which every
# odd-numbered letter is a (eg "abacadaf")
/(a.)+/  

# string starts with one or more digits
/^\d+/

# string that ends with one or more digits
/\d+$/

Spójrzmy na inny przykład.

#!/usr/bin/perl

$string = "Cats go Catatonic\nWhen given Catnip";
($start) = ($string =~ /\A(.*?) /);
@lines = $string =~ /^(.*?) /gm;
print "First word: $start\n","Line starts: @lines\n";

Wykonanie powyższego programu daje następujący wynik -

First word: Cats
Line starts: Cats When

Dopasowywanie granic

Plik \bdopasowuje na dowolnej granicy słowa, zgodnie z różnicą między klasą \ w a klasą \ W. Ponieważ \ w zawiera znaki słowa, a \ W odwrotnie, zwykle oznacza to zakończenie słowa. Plik\Basercja pasuje do każdej pozycji, która nie jest granicą słowa. Na przykład -

/\bcat\b/ # Matches 'the cat sat' but not 'cat on the mat'
/\Bcat\B/ # Matches 'verification' but not 'the cat on the mat'
/\bcat\B/ # Matches 'catatonic' but not 'polecat'
/\Bcat\b/ # Matches 'polecat' but not 'catatonic'

Wybór alternatyw

| znak jest taki sam, jak standardowy lub bitowy OR w Perlu. Określa alternatywne dopasowania w obrębie wyrażenia regularnego lub grupy. Na przykład, aby dopasować wyrażenie „kot” lub „pies”, możesz użyć tego -

if ($string =~ /cat|dog/)

Możesz grupować poszczególne elementy wyrażenia razem, aby obsługiwać złożone dopasowania. Wyszukiwanie nazwisk dwóch osób można przeprowadzić za pomocą dwóch oddzielnych testów, takich jak ten -

if (($string =~ /Martin Brown/) ||  ($string =~ /Sharon Brown/))

This could be written as follows

if ($string =~ /(Martin|Sharon) Brown/)

Dopasowywanie grupowe

Z punktu widzenia wyrażeń regularnych nie ma różnicy między nimi, chyba że to pierwsze jest nieco jaśniejsze.

$string =~ /(\S+)\s+(\S+)/;

and 

$string =~ /\S+\s+\S+/;

Jednak zaletą grupowania jest to, że pozwala nam wyodrębnić sekwencję z wyrażenia regularnego. Grupy są zwracane jako lista w kolejności, w jakiej występują w oryginale. Na przykład w poniższym fragmencie wyciągnęliśmy godziny, minuty i sekundy z łańcucha.

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Oprócz tej bezpośredniej metody, dopasowane grupy są również dostępne w ramach specjalnych zmiennych $ x, gdzie x jest numerem grupy w wyrażeniu regularnym. Moglibyśmy zatem przepisać poprzedni przykład w następujący sposób -

#!/usr/bin/perl

$time = "12:05:30";

$time =~ m/(\d+):(\d+):(\d+)/;
my ($hours, $minutes, $seconds) = ($1, $2, $3);

print "Hours : $hours, Minutes: $minutes, Second: $seconds\n";

Wykonanie powyższego programu daje następujący wynik -

Hours : 12, Minutes: 05, Second: 30

Gdy grupy są używane w wyrażeniach podstawiania, w tekście zastępczym można użyć składni $ x. W ten sposób możemy ponownie sformatować ciąg daty, używając tego -

#!/usr/bin/perl

$date = '03/26/1999';
$date =~ s#(\d+)/(\d+)/(\d+)#$3/$1/$2#;

print "$date\n";

Wykonanie powyższego programu daje następujący wynik -

1999/03/26

Asercja \ G

Asercja \ G umożliwia kontynuowanie wyszukiwania od miejsca, w którym wystąpiło ostatnie dopasowanie. Na przykład w poniższym kodzie użyliśmy \ G, abyśmy mogli wyszukać właściwą pozycję, a następnie wyodrębnić niektóre informacje, bez konieczności tworzenia bardziej złożonego, pojedynczego wyrażenia regularnego -

#!/usr/bin/perl

$string = "The time is: 12:31:02 on 4/12/00";

$string =~ /:\s+/g;
($time) = ($string =~ /\G(\d+:\d+:\d+)/);
$string =~ /.+\s+/g;
($date) = ($string =~ m{\G(\d+/\d+/\d+)});

print "Time: $time, Date: $date\n";

Wykonanie powyższego programu daje następujący wynik -

Time: 12:31:02, Date: 4/12/00

Asercja \ G jest właściwie metasymbolowym odpowiednikiem funkcji pos, więc między wywołaniami wyrażeń regularnych można nadal używać pos, a nawet modyfikować wartość pos (a tym samym \ G), używając pos jako podprogramu lvalue.

Przykłady wyrażeń regularnych

Znaki dosłowne

Sr.No.	Przykład i opis
1	Perl Dopasuj „Perl”.

Klasy postaci

Sr.No.	Przykład i opis
1	[Pp]ython Pasuje do „Python” lub „python”
2	rub[ye] Dopasowuje „ruby” lub „rube”
3	[aeiou] Dopasowuje dowolną małą samogłoskę
4	[0-9] Dopasowuje dowolną cyfrę; tak samo jak [0123456789]
5	[a-z] Dopasowuje każdą małą literę ASCII
6	[A-Z] Dopasowuje dowolną wielką literę ASCII
7	[a-zA-Z0-9] Pasuje do dowolnego z powyższych
8	[^aeiou] Dopasowuje wszystko inne niż mała samogłoska
9	[^0-9] Dopasowuje wszystko inne niż cyfra

Specjalne klasy postaci

Sr.No.	Przykład i opis
1	. Dopasowuje dowolny znak z wyjątkiem nowej linii
2	\d Dopasowuje cyfrę: [0–9]
3	\D Odpowiada cyfrze: [^ 0-9]
4	\s Dopasowuje biały znak: [\ t \ r \ n \ f]
5	\S Dopasowuje bez białych znaków: [^ \ t \ r \ n \ f]
6	\w Dopasowuje pojedynczy znak słowa: [A-Za-z0-9_]
7	\W Dopasowuje znak niebędący słowem: [^ A-Za-z0-9_]

Przypadki powtórzeń

Sr.No.	Przykład i opis
1	ruby? Dopasowuje „rub” lub „ruby”: y jest opcjonalne
2	ruby* Dopasowuje „rub” plus 0 lub więcej lat
3	ruby+ Dopasowuje „rub” plus 1 lub więcej lat
4	\d{3} Dopasowuje dokładnie 3 cyfry
5	\d{3,} Dopasowuje 3 lub więcej cyfr
6.	\d{3,5} Dopasowuje 3, 4 lub 5 cyfr

Nongreedy Repetition

To pasuje do najmniejszej liczby powtórzeń -

Sr.No.	Przykład i opis
1	<.*> Chciwe powtórzenie: dopasowuje „<python> perl>”
2	<.*?> Nongreedy: dopasowuje „<python>” do „<python> perl>”

Grupowanie z nawiasami

Sr.No.	Przykład i opis
1	\D\d+ Brak grupy: + powtarza \ d
2	(\D\d)+ Zgrupowane: + powtórzenia \ D \ d para
3	([Pp]ython(, )?)+ Dopasuj „Python”, „Python, python, python” itp.

Backreferences

To ponownie pasuje do poprzednio dopasowanej grupy -

Sr.No.	Przykład i opis
1	([Pp])ython&\1ails Pasuje do Python & Pails lub Python & Pails
2	(['"])[^\1]*\1 Ciąg w pojedynczym lub podwójnym cudzysłowie. \ 1 pasuje do dopasowanej pierwszej grupy. \ 2 pasuje do dopasowanej 2. grupy itp.

Alternatywy

Sr.No.	Przykład i opis
1	python|perl Pasuje do „python” lub „perl”
2	rub(y|le)) Dopasowuje „rubin” lub „rubel”
3	Python(!+|\?) „Python”, po którym następuje jeden lub więcej! czy jeden?

Kotwice

Ta potrzeba określenia pozycji dopasowania.

Sr.No.	Przykład i opis
1	^Python Dopasowuje „Python” na początku łańcucha lub linii wewnętrznej
2	Python$ Dopasowuje „Python” na końcu ciągu lub linii
3	\APython Dopasowuje „Python” na początku łańcucha
4	Python\Z Dopasowuje „Python” na końcu ciągu
5	\bPython\b Dopasowuje „Python” na granicy słowa
6	\brub\B \ B nie jest granicą słów: dopasuj „rub” w „rube” i „ruby”, ale nie samodzielnie
7	Python(?=!) Odpowiada wyrażeniu „Python”, jeśli następuje po nim wykrzyknik
8	Python(?!!) Dopasowuje „Python”, jeśli nie następuje po nim wykrzyknik

Specjalna składnia z nawiasami

Sr.No.	Przykład i opis
1	R(?#comment) Pasuje do „R”. Cała reszta to komentarz
2	R(?i)uby Podczas dopasowywania „uby” bez rozróżniania wielkości liter
3	R(?i:uby) Tak samo jak powyżej
4	rub(?:y|le)) Grupuj tylko bez tworzenia \ 1 odwołania wstecznego