RegEx: 20 krótkich kroków do opanowania wyrażeń regularnych. Część 4

RegEx: 20 krótkich kroków do opanowania wyrażeń regularnych. Część 1 RegEx: 20 krótkich kroków do opanowania wyrażeń regularnych. Część 2 20 krótkich kroków do opanowania wyrażeń regularnych. Część 3 Ostatnia część pośrodku poruszy tematy używane głównie przez mistrzów wyrażeń regularnych. Ale materiał z poprzednich części był dla Ciebie łatwy, prawda? Oznacza to, że możesz posługiwać się tym materiałem z taką samą łatwością! Oryginał tutaj <h2>Krok 16: grupowanie bez przechwytywania (?:)</h2> W dwóch przykładach z poprzedniego kroku przechwytywaliśmy tekst, którego tak naprawdę nie potrzebowaliśmy. W zadaniu Rozmiary plików przechwyciliśmy spacje przed pierwszą cyfrą rozmiaru pliku, a w zadaniu CSV przechwyciliśmy przecinki między każdym tokenem. Nie musimy przechwytywać tych znaków, ale musimy ich użyć do ustrukturyzowania naszego wyrażenia regularnego. Są to idealne opcje korzystania z grupy bez przechwytywania plików (?:). Grupa nieprzechwytująca robi dokładnie to, na co wygląda — pozwala na grupowanie znaków i używanie ich w wyrażeniach regularnych, ale nie przechwytuje ich w ponumerowanej grupie:

wzór: (?:")([^"]+)(?:") 
string: Chcę tylko „tekst wewnątrz tych cudzysłowów” .
mecze:             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
grupa:                 1111111111111111111111111111    

( Przykład ) Wyrażenie regularne dopasowuje teraz cytowany tekst, a także same znaki cudzysłowu, ale grupa przechwytująca przechwyciła tylko cytowany tekst. Dlaczego powinniśmy to zrobić? Chodzi o to, że większość silników wyrażeń regularnych umożliwia odzyskiwanie tekstu z grup przechwytywania zdefiniowanych w wyrażeniach regularnych. Jeśli uda nam się przyciąć dodatkowe znaki, których nie potrzebujemy, bez uwzględniania ich w naszych grupach przechwytywania, ułatwi to późniejszą analizę i manipulowanie tekstem. Oto jak wyczyścić parser CSV z poprzedniego kroku:

wzór: (?:^|,)\s*(?:\"([^",]*)\"|([^", ]*)) 
ciąg:   a , " b ", " cd ", e , f , " gh ", dfgi ,, k , "", l 
mecze: ^ ^ ^^^ ^ ^ ^^^ ^^^^ ^ ^ 
grupa:    2 1 111 2 2 111 2222 2 2    

( Przykład ) Jest kilka rzeczy, na które <mark>zwróć uwagę:</mark> Po pierwsze, nie przechwytujemy już przecinków, ponieważ zmieniliśmy grupę przechwytującą (^|,)na grupę nie przechwytującą (?:^|,). Po drugie, zagnieżdżono grupę przechwytującą w grupie innej niż przechwytująca. Jest to przydatne, gdy na przykład chcesz, aby grupa znaków pojawiła się w określonej kolejności, ale interesuje Cię tylko podzbiór tych znaków. W naszym przypadku potrzebowaliśmy znaków niebędących cudzysłowami i przecinków[^",]* , aby pojawiały się w cudzysłowie, ale tak naprawdę nie potrzebowaliśmy samych znaków cudzysłowu, więc nie było potrzeby ich przechwytywania . Na koniec <mark>zauważ</mark>, że w powyższym przykładzie występuje również dopasowanie o zerowej długości pomiędzy znakami ki l. Cudzysłowy ""to przeszukiwany podciąg, ale między cudzysłowami nie ma żadnych znaków, więc pasujący podciąg nie zawiera żadnych znaków (długość zerowa). <h3>Czy utrwalimy naszą wiedzę? Oto dwa i pół zadania, które nam w tym pomogą:</h3> Używając grup nieprzechwytujących (i przechwytujących grupy, klasy znaków itp.), napisz wyrażenie regularne, które przechwytuje w linii tylko odpowiednio sformatowane rozmiary plików poniżej :

wzór:
ciąg:   6,6 KB 1..3 KB 12 KB 5G 3,3 MB KB .6,2 TB 9 MB .
mecze: ^^^^^ ^^^^^ ^^^^^^ ^^^^ 
grupa:    11111 1111 11111 111    

( Rozwiązanie ) Tagi otwierające HTML zaczynają się <i kończą na >. Tagi zamykające HTML zaczynają się od sekwencji znaków </i kończą znakiem >. Nazwa tagu jest zawarta pomiędzy tymi znakami. Czy możesz napisać wyrażenie regularne, aby przechwycić tylko nazwy w następujących tagach? (Być może uda się rozwiązać ten problem bez używania grup nieprzechwytujących. Spróbuj rozwiązać ten problem na dwa sposoby! Raz z grupami, raz bez.)

wzór:
string:   <p> </span> <div> </kbd> <link> 
dopasowania: ^^^ ^^^^^^ ^^^^^ ^^^^^^ ^^^^^^ 
grupa:    1 1111 111 111 1111    

( Rozwiązanie wykorzystujące grupy nieprzechwytujące ) ( Rozwiązanie bez użycia grup nieprzechwytujących ) <h2>Krok 17: Linki zwrotne \Ni nazwane grupy przechwytujące</h2> Chociaż ostrzegałem Cię we wstępie, że próby utworzenia parsera HTML przy użyciu wyrażeń regularnych zwykle prowadzi do bólu serca, ten ostatni przykład jest miłym przejściem do innej (czasami) przydatnej funkcji większości wyrażeń regularnych: odwołań wstecznych. Linki zwrotne działają jak powtarzające się grupy, w których możesz spróbować dwukrotnie przechwycić ten sam tekst. Różnią się jednak jednym istotnym aspektem – uchwycą tylko ten sam tekst, znak po znaku. Podczas gdy powtarzająca się grupa pozwoliłaby nam uchwycić coś takiego:

wzór: (he(?:[az])+) 
string:   heyabcdefg hey heyo heyellow heyyyyyyyyy 
dopasowania: ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^ 
grupa:    1111111111 111 1111 11111111 11111111111    

( Przykład ) ...wtedy link zwrotny będzie pasował tylko do tego:

wzór: (he([az])(\2+)) 
string: heyabcdefg hey heyo heyellow heyyyyyyyyyy 
dopasowania:                              ^^^^^^^^^^^^ 
grupa:                                 11233333333    

( Przykład ) Powtarzające się grupy przechwytywania są przydatne, gdy chcesz wielokrotnie dopasować ten sam wzorzec, natomiast linki zwrotne są dobre, gdy chcesz dopasować ten sam tekst. Na przykład możemy użyć linku zwrotnego, aby znaleźć pasujące otwierające i zamykające tagi HTML:

wzór: <(\w+)[^>]*>[^<]+<\/\1> 
ciąg:   <span style="color: red">hej</span> 
pasuje: ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
grupa:    1111    

( Przykład ) <mark>Proszę pamiętać</mark>, że jest to niezwykle uproszczony przykład i zdecydowanie odradzam próby pisania parsera HTML opartego na wyrażeniach regularnych. Jest to bardzo złożona składnia i najprawdopodobniej spowoduje chorobę. Nazwane grupy przechwytywania są bardzo podobne do linków zwrotnych, więc omówię je tutaj pokrótce. Jedyna różnica między odniesieniami wstecznymi a nazwaną grupą przechwytywania polega na tym, że... nazwana grupa przechwytywania ma nazwę:

wzór: <(?<tag>\w+)[^>]*>[^<]+<\/(?P=tag)></tag> 
string:   <span style="color: red">hej< /span> 
dopasowania: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
grupa:    1111    

( Przykład ) Możesz utworzyć nazwaną grupę przechwytywania, używając składni (?<nazwa>...) lub (?'nazwa'...) (wyrażenie regularne zgodne z .NET) lub tej składni (?P<nazwa>. ..) lub (?P'name'...) (wyrażenie regularne kompatybilne z Pythonem). Ponieważ używamy języka PCRE (wyrażenie regularne zgodne z Perl), które obsługuje obie wersje, możemy tutaj użyć dowolnej z nich. (Java 7 skopiowała składnię .NET, ale tylko wersję z nawiasami ostrymi. Uwaga tłumacza) Aby później powtórzyć nazwaną grupę przechwytującą w wyrażeniu regularnym, używamy \<kname> lub \k'name' (.NET) lub (? P= nazwa) (Python). Ponownie PCRE obsługuje wszystkie te różne opcje. Możesz przeczytać więcej o nazwanych grupach przechwytujących tutaj , ale to była większość tego, co naprawdę musisz o nich wiedzieć. <h3>Zadanie, aby nam pomóc:</h3> Użyj linków zwrotnych, aby pomóc mi zapamiętać… hmmm… imię tej osoby.

wzór:
ciąg znaków: „Cześć, nazywam się Joe.” [później] „Jak ten facet ma na imię? Joe ?”
mecze:        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
grupa:                  111    

( Rozwiązanie ) <h2>Krok 18: spojrzenie w przyszłość i spojrzenie w tył</h2> Teraz zajmiemy się niektórymi zaawansowanymi funkcjami wyrażeń regularnych. Używam wszystkiego aż do kroku 16 dość często. Ale tych kilka ostatnich kroków jest przeznaczonych tylko dla osób, które bardzo poważnie używają wyrażeń regularnych do dopasowywania bardzo złożonych wyrażeń. Inaczej mówiąc, mistrzowie wyrażeń regularnych. „Patrząc w przyszłość” i „Patrząc wstecz” mogą wydawać się dość skomplikowane, ale w rzeczywistości nie są zbyt skomplikowane. Pozwalają zrobić coś podobnego do tego, co zrobiliśmy wcześniej z grupami nieprzechwytującymi - sprawdź, czy bezpośrednio przed lub bezpośrednio po tekście, który chcemy dopasować, znajduje się jakiś tekst. Załóżmy na przykład, że chcemy dopasować tylko nazwy rzeczy, które ludzie lubią, ale tylko wtedy, gdy są do tego entuzjastycznie nastawieni (tylko jeśli kończą zdanie wykrzyknikiem). Moglibyśmy zrobić coś takiego:

wzór: (\w+)(?=!) 
string: Lubię biurko. Doceniam zszywacz. Kocham lampę !
mecze:                                           ^^^^ 
grupa:                                              1111    

( Przykład ) Możesz zobaczyć, jak powyższa grupa przechwytywania (\w+), która zwykle dopasowuje dowolne słowa we fragmencie, pasuje tylko do słowa lampa. Pozytywne przewidywanie (?=!)oznacza, że ​​możemy dopasowywać tylko sekwencje zakończone na !, ale w rzeczywistości nie dopasowujemy samego znaku wykrzyknika. Jest to ważne rozróżnienie, ponieważ w przypadku grup nie przechwytujących dopasowujemy postać, ale jej nie przechwytujemy. W przypadku lookahead i lookbehind używamy znaku do zbudowania wyrażenia regularnego, ale wtedy nawet nie dopasowujemy go do niego samego. Możemy dopasować go później w naszym wyrażeniu regularnym. Istnieją cztery typy lookahead i lookbehind: pozytywne lookahead (?=...), negatywne lookahead (?!...), pozytywne lookahead (?<=...) i negatywne lookahead (?<!...) . Robią to, na co wyglądają — pozytywne spojrzenie w przyszłość i spojrzenie w tył pozwalają silnikowi wyrażeń regularnych na dalsze dopasowywanie tylko wtedy, gdy tekst zawarty w mechanizmie lookahead/lookbehind faktycznie pasuje. Negatywne lookahead i lookbehind działają odwrotnie - pozwalają na dopasowanie wyrażenia regularnego tylko wtedy, gdy tekst zawarty w lookahead/lookbehind nie pasuje. Na przykład chcemy dopasować nazwy metod tylko do łańcucha sekwencji metod, a nie do obiektu, na którym działają. W takim przypadku każda nazwa metody musi być poprzedzona znakiem .. Pomocne może być tutaj wyrażenie regularne wykorzystujące proste spojrzenie wstecz:

wzór: (?<=\.)(\w+) 
ciąg: myArray. flatMap.aggregate.summarise.print !
mecze:         ^^^^^^^ ^^^^^^^^^ ^^^^^^^^^ ^^^^^ 
grupa:            1111111 111111111 111111111 11111    

( Przykład ) W powyższym tekście dopasowujemy dowolny ciąg znaków słowa \w+, ale tylko wtedy, gdy są one poprzedzone znakiem .. Moglibyśmy osiągnąć coś podobnego, używając grup nieprzechwytujących, ale wynik jest trochę bardziej chaotyczny:

wzór: (?:\.)(\w+) 
ciąg: myArray .flatMap.aggregate.summarise.print !
mecze:        ^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^ ^^^^^ 
grupa:            1111111 111111111 111111111 11111    

( Przykład ) Mimo że jest krótszy, dopasowuje znaki, których nie potrzebujemy. Chociaż ten przykład może wydawać się trywialny, spojrzenia w przód i w tył mogą naprawdę pomóc nam w uporządkowaniu wyrażeń regularnych. <h3>Do mety pozostało bardzo niewiele! Poniższe 2 zadania przybliżą nas o krok do tego celu:</h3> Negatywne spojrzenie w tył (?<!...) pozwala silnikowi wyrażeń regularnych na kontynuowanie prób znalezienia dopasowania tylko wtedy, gdy tekst zawarty w negatywnym spojrzeniu w tył nie jest wyświetlane aż do końca tekstu, z którym należy znaleźć dopasowanie. Na przykład moglibyśmy użyć wyrażenia regularnego, aby dopasować tylko nazwiska kobiet uczestniczących w konferencji. W tym celu chcielibyśmy się upewnić, że nazwisko danej osoby nie jest poprzedzone rozszerzeniem Mr.. Czy możesz napisać na to wyrażenie regularne? (Przyjmuje się, że nazwiska mają długość co najmniej czterech znaków.)

wzór:
ciąg: pan. Browna, pani Smith , pani. Jones , panna Daisy , pan. Zielony
mecze:                ^^^^^ ^^^^^ ^^^^^ 
grupa:                   11111 11111 11111    

( Rozwiązanie ) Załóżmy, że czyścimy bazę danych i mamy kolumnę zawierającą informacje przedstawiające wartości procentowe. Niestety, niektórzy zapisali liczby jako wartości dziesiętne z zakresu [0,0, 1,0], inni zapisali procenty z zakresu [0,0%, 100,0%], a jeszcze inni zapisali wartości procentowe, ale zapomnieli o dosłownym znaku procentu %. Czy używając negatywnego lookahead (?!...) możesz zaznaczyć tylko te wartości, które powinny być procentami, ale brakuje im cyfr %? Muszą to być wartości ściśle większe niż 1,00, ale bez końcowego %. (Żadna liczba nie może zawierać więcej niż dwie cyfry przed lub po przecinku.) <mark>Pamiętaj</mark>, że to rozwiązanie jest niezwykle trudne . Jeśli potrafisz rozwiązać ten problem bez patrzenia na moją odpowiedź, oznacza to, że masz już ogromne umiejętności w zakresie wyrażeń regularnych!

wzór:
ciąg: 0,32 100,00 5,6 0,27 98% 12,2% 1,01 0,99% 0,99 13,13 1,10 
mecze:      ^^^^^^ ^^^ ^^^^ ^^^^^ ^^^^ 
grupa:         111111 111 1111 11111 1111    

( Rozwiązanie ) <h2>Krok 19: Warunki w wyrażeniach regularnych</h2> Doszliśmy do punktu, w którym większość ludzi nie będzie już używać wyrażeń regularnych. Omówiliśmy prawdopodobnie 95% przypadków użycia prostych wyrażeń regularnych, a wszystko, co zostało wykonane w krokach 19 i 20, jest zwykle wykonywane za pomocą bardziej funkcjonalnego języka manipulacji tekstem, takiego jak awk lub sed (lub język programowania ogólnego przeznaczenia). To powiedziawszy, przejdźmy dalej, abyś wiedział, co naprawdę potrafi wyrażenie regularne. Chociaż wyrażenia regularne nie są kompletne w języku Turinga , niektóre silniki wyrażeń regularnych oferują funkcje bardzo podobne do kompletnego języka programowania. Jedną z takich funkcji jest „stan”. Warunki warunkowe wyrażeń regularnych umożliwiają stosowanie instrukcji if-then-else, w których wybrana gałąź jest określana albo poprzez „spojrzenie w przyszłość”, albo „spojrzenie wstecz”, o czym dowiedzieliśmy się w poprzednim kroku. Na przykład możesz chcieć dopasować tylko prawidłowe wpisy na liście dat:

wzór: (?<=Feb )([1-2][0-9])|(?<=Mar )([1-2][0-9]|3[0-1]) 
string: Przepracowane daty : 28 lutego , 29 lutego , 30 lutego, 30 marca , 31 marca  
mecze:                   ^^ ^^ ^^ ^^ 
grupa:                      11 11 22 22    

( Przykład ) <mark>Pamiętaj</mark>, że powyższe grupy są również indeksowane według miesięcy. Moglibyśmy napisać wyrażenie regularne dla wszystkich 12 miesięcy i uchwycić tylko prawidłowe daty, które następnie zostałyby połączone w grupy indeksowane według miesiąca roku. Powyższe wykorzystuje strukturę przypominającą if, która będzie szukać dopasowań w pierwszej grupie tylko wtedy, gdy „Feb” poprzedza liczbę (i podobnie w drugiej grupie). Ale co by było, gdybyśmy chcieli zastosować specjalne przetwarzanie tylko w lutym? Coś w stylu „jeśli numer jest poprzedzony słowem „luty”, zrób to, w przeciwnym razie wykonaj inną rzecz”. Oto jak robią to warunki warunkowe:

wzór: (?(?<=Feb )([1-2][0-9])|([1-2][0-9]|3[0-1])) 
string: Daty przepracowania: 28 lutego , 29 lutego , 30 lutego , 30 marca , 31 marca  
mecze:                   ^^ ^^ ^^ ^^ 
grupa:                      11 11 22 22    

( Przykład ) Struktura if-then-else wygląda następująco (?(If)then|else), gdzie (if) zostaje zastąpione przez „spojrzenie w przyszłość” lub „spójrz wstecz”. W powyższym przykładzie (if) jest zapisane jako (?<=Feb). Widać, że dopasowaliśmy daty większe niż 29, ale tylko wtedy, gdy nie następowały one po „lutym”. Używanie lookbehind w wyrażeniach warunkowych jest przydatne, jeśli chcesz mieć pewność, że dopasowanie będzie poprzedzone jakimś tekstem. Pozytywne warunki warunkowe z wyprzedzeniem mogą być mylące, ponieważ sam warunek nie pasuje do żadnego tekstu. Jeśli więc chcesz, aby warunek if zawsze miał wartość, musi on być porównywalny z warunkiem przewidywania, jak poniżej:

wzór: (?(?=dokładny)dokładny|else)wo 
ciąg: dokładnie inny dokładniedwa inne  
dopasowania:            ^^^^^^^ ^^^^^^

( Przykład ) Oznacza to, że pozytywne warunki warunkowe z wyprzedzeniem są bezużyteczne. Sprawdzasz, czy ten tekst znajduje się z przodu, a następnie podajesz pasujący wzór, który należy zastosować, gdy tak się stanie. Wyrażenie warunkowe w ogóle nam tutaj nie pomaga. Możesz także po prostu zastąpić powyższe prostszym wyrażeniem regularnym:

wzór: (?:dokładny|else)wo 
ciąg: dokładnie inaczej dokładniedwa inne  
dopasowania:            ^^^^^^^ ^^^^^^

( Przykład ) Zatem ogólna zasada dotycząca wyrażeń warunkowych brzmi: test, test i jeszcze raz test. W przeciwnym razie rozwiązania, które uważasz za oczywiste, zawiodą w najbardziej ekscytujący i nieoczekiwany sposób :) <h3>Tutaj dochodzimy do ostatniego bloku zadań, który oddziela nas od ostatniego, 20. kroku:</h3> Napisz wyrażenie regularne, które używa wyrażenia warunkowego z negatywnym wyprzedzeniem, aby sprawdzić, czy następne słowo zaczyna się od dużej litery. Jeśli tak, chwyć tylko jedną wielką literę, a następnie małe litery. Jeśli tak nie jest, chwyć dowolne znaki wyrazu.

wzór:
string:   Jones Smith 9sfjn Hobbes 23r4tgr9h CSV Csv vVv 
mecze: ^^^^^ ^^^^^ ^^^^^ ^^^^^^ ^^^^^^^^^ ^^^ ^^^ 
grupa:    22222 22222 11111 222222 111111111 222 111    

( Rozwiązanie ) Napisz negatywne wyrażenie warunkowe typu lookbehind, które przechwytuje tekst ownstylko wtedy, gdy nie jest poprzedzony tekstem cl, i które przechwytuje tekst oudstylko wtedy, gdy jest poprzedzony tekstem cl. (Trochę wymyślony przykład, ale co możesz zrobić...)

wzór:
string: Ci klauni mają trochę chmur . oudy.
mecze:              ^^^^ ^^^^   

( Rozwiązanie ) <h2>Krok 20: Rekurencja i dalsze badania</h2> Tak naprawdę wiele można zawrzeć w 20-etapowym wprowadzeniu na dowolny temat, a wyrażenia regularne nie są tutaj wyjątkiem. W Internecie można znaleźć wiele różnych implementacji i standardów wyrażeń regularnych . Jeśli chcesz dowiedzieć się więcej, sugeruję sprawdzenie wspaniałej strony regularexpressions.info . To fantastyczne źródło informacji, z którego na pewno wiele się nauczyłem o wyrażeniach regularnych. Gorąco polecam tę stronę, a także regex101.com do testowania i publikowania swoich dzieł. W tym ostatnim kroku przekażę ci trochę więcej wiedzy na temat wyrażeń regularnych, a mianowicie, jak pisać wyrażenia rekurencyjne. Proste rekurencje są dość proste, ale zastanówmy się, co to oznacza w kontekście wyrażenia regularnego. Składnia prostej rekurencji w wyrażeniu regularnym jest zapisana w następujący sposób: (?R)?. Ale oczywiście ta składnia musi pojawić się w samym wyrażeniu. To, co zrobimy, to zagnieżdżenie wyrażenia w sobie, dowolną liczbę razy. Na przykład:

wzór: (hej(?R)?oh) 
string:   heyoh heyyoh heyheyohoh hey oh heyhey hey heyheyohoh  
mecze: ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^ 
grupa:    11111 1111111111 1111111111    

( Przykład ) Ponieważ wyrażenie zagnieżdżone jest opcjonalne ( (?R)po nim następuje ?), najprostszym dopasowaniem jest po prostu całkowite zignorowanie rekurencji. Zatem , heya następnie ohdopasowania ( heyoh). Aby dopasować bardziej złożone wyrażenie, musimy znaleźć pasujący podciąg zagnieżdżony w sobie w miejscu wyrażenia, w którym wstawiliśmy (?R)sekwencję. Innymi słowy, moglibyśmy znaleźć heyheyohoh lub heyheyheyohohoh i tak dalej. Jedną z największych zalet tych zagnieżdżonych wyrażeń jest to, że w przeciwieństwie do odniesień wstecznych i nazwanych grup przechwytywania, nie ograniczają one Cię do dokładnie tego samego tekstu, który dopasowałeś wcześniej, znak po znaku. Na przykład:

wzór: ([Hh][Ee][Yy](?R)?oh) 
string:   heyoh heyyoh hEyHeYohoh hey oh heyhey hEyHeYHEyohohoh  
dopasowania: ^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^ 
grupa:    11111 1111111111 111111111111111    

( Przykład ) Możesz sobie wyobrazić, że silnik wyrażeń regularnych dosłownie kopiuje i wkleja Twoje wyrażenie regularne w sobie dowolną liczbę razy. Oczywiście oznacza to, że czasami może nie działać zgodnie z oczekiwaniami:

wzór: ((?:\(\*)[^*)]*(?R)?(?:\*\))) 
string: (* komentarz (* zagnieżdżony *) nie *)
mecze:            ^^^^^^^^^^^^ 
grupa:               111111111111    

( Przykład ) Czy możesz powiedzieć, dlaczego to wyrażenie regularne przechwyciło tylko komentarz zagnieżdżony, a nie komentarz zewnętrzny? Jedno jest pewne: pisząc złożone wyrażenia regularne, zawsze je testuj, aby upewnić się, że działają tak, jak myślisz. Ten szybki rajd drogami wyrażeń regularnych dobiegł końca. Mam nadzieję, że podobała ci się ta podróż. No i na koniec zostawię tutaj, jak obiecałem na początku, kilka przydatnych linków do głębszego przestudiowania materiału:

• Wyrażenia regularne w Javie (artykuł autorstwa Alexa)
• Wyrażenia regularne w Javie (Tłumaczenie artykułu Jeffa Friesena z Elleanor Kerry)
• Przykłady wyrażeń regularnych w języku Java (z wygodną tabelą składni)
• Chciwe i leniwe kwantyfikatory (przykłady JavaScript)
• 25 najczęściej używanych wyrażeń regularnych w Javie
• RegexOne (Zadania ze sprawdzaniem)
• Nie bój się wyrażeń regularnych. Regex w 20 minut! (dla tych, którzy wolą tutoriale wideo)