Uczenie się i zrozumienie wyrażeń regularnych może nie być tak proste jak nauka polecenia LS. Jednak uczenie się wyrażeń regularnych i skuteczne wdrażanie ich w codziennej pracy bez wątpienia nagrodzi twoje wysiłki naukowe poprzez większą wydajność pracy i oszczędności czasu. Wyrażenia regularne to temat, który może łatwo wypełnić całą 1000 stron długości. W tym artykule staramy się wyjaśnić podstawy wyrażeń regularnych w zwięzły, nie-geekowy i przykładowy sposób. Dlatego jeśli kiedykolwiek chciałeś nauczyć się podstawowych podstaw ekspresji.

Intencją tego samouczka polega na pokryciu podstawowego rdzenia podstawowych wyrażeń regularnych i rozszerzonych wyrażeń regularnych. W tym celu użyjemy jednego narzędzia, a to będzie polecenie GNU GREP. System operacyjny GNU/Linux i jego polecenie GREP rozpoznają trzy różne typy wyrażeń regularnych:

• Podstawowe wyrażenia regularne (BRE)
• Rozszerzone wyrażenia regularne (ERE)
• Wyrażenia regularne Perl (PRCE)

Różnica między podstawowymi wyrażeniami regularnymi a rozszerzonymi wyrażeniami regularnymi dobrze wyjaśniono chwilowo.

Co to jest wyrażenie regularne

Wyrażenie regularne zapewnia możliwość dopasowania „ciąg tekstu” w bardzo elastyczny i zwięzły sposób. Gdzie „ciąg tekstu” można dalej zdefiniować jako pojedynczy znak, słowo, zdanie lub określony wzór znaków. Dobrze znane skróty „Wyrażenie regularne” obejmują Regex i RegexP.

Prosty przykład wyrażenia regularnego

Najprostszym elementem konstrukcyjnym dowolnego wyrażenia regularnego jest znak. Możemy użyć GREP do wyszukiwania dowolnego konkretnego znaku z tekstu dowolnego podanego pliku nie-binarnego. Na przykład tutaj jest treść naszego Regex.Plik próbki TXT:

$ cat Regex.TXT GREP oznacza: globalny wydruk wyrażenia regularnego 

Teraz możemy użyć GREP do wyszukiwania dowolnej postaci, zapewniając jej wyrażenie regularne. Użyjmy GREP do wyszukiwania postaci „E”:

$ grep e regex.TXT GREP oznacza: wyrażenie regularne 

Jak widać z powyższego przykładu, Grep wydrukował wszystkie linie składające się z co najmniej jednego postaci „E”. Możemy teraz połączyć wiele znaków, aby utworzyć ciąg „RegU” i użyć GREP do wyszukiwania ciągu w tekście:

$ grep regu regex.TXT Regular 

Aby uwolnić prawdziwą moc wyrażeń regularnych, musimy utworzyć wyrażenie regularne z znaków niealfabetycznych (meta-znaków) lub z kombinacji znaków alfabetycznych i niealfabetycznych. Na przykład, co jeśli chcesz przeszukać wszystkie wiersze, które zaczynają się od postaci „G”? W tym celu możemy użyć symbolu Caret „^”:

$ grep ^g regex.TXT GREP oznacza: globalny 

To był tylko fundamentalny przykład bardziej wyrafinowanego wyrażenia regularnego. W tym artykule wyjaśnimy bardziej techniki wyrażeń regularnych jako powyższe, bardziej szczegółowo.

Powiązanie

Jak widać na naszym poprzednim przykładzie, najprostsze wyrażenie regularne może składać się z indywidualnej postaci. Stąd wyrażenie regularne składające się z pojedynczego niestabilnego znaku będzie pasować do dowolnego ciągu zawierającego ten znak. Charakter wyrażeń regularnych zezwoleń na połączenie wielu innych wyrażeń regularnych. Co oznacza, że ​​zestaw znaków takich jak „Press” będzie pasował do dowolnego ciągu zawierającego podłoże utworzone przez połączenie kilku wyrażeń regularnych „P”, „R”, „E”, „S” i „S”.

$ cat Regex.TXT GREP oznacza: Global Regular Expression Print $ GREP Press Regex.wyrażenie txt 

Podstawowe vs rozszerzone wyrażenia regularne

GNU Grep rozumie zarówno podstawowe, jak i rozszerzone wyrażenia regularne. Najważniejszą różnicą jest to, że w podstawowych wyrażeniach regularnych meta-właściciele: ?, +, , |, (i) tracić swoje szczególne znaczenie. Aby dać meta-właściciele specjalne znaczenie, należy je uciekać z postacią. Zastanów się nad następującym przykładem:

Nasz Regex.Plik TXT zawiera teraz następujące:

$ cat Regex.TXT Global | Regularny | Wyrażenie | Drukuj globalny wydruk wyrażenia regularnego 

Polecenie GREP przyjmuje podstawowe wyrażenie regularne jako domyślne. Dlatego następujące polecenie Linux wydrukuje wyłącznie pierwszy wiersz tylko biorąc pod uwagę, że zawiera pod substring „N | P”:

$ grep "n | p" Regex.TXT Global | Zwykle | Wyrażenie | Drukuj 

„|” Operator zmian ma swoje własne specjalne znaczenie, a to jest logiczne lub. Jednak to szczególne znaczenie zostało stłumione w poprzednim przykładzie, ponieważ GREP domyślnie zagroże. Aby GREP odczytał rozszerzone wyrażenia regularne, musimy użyć opcji -e lub po prostu użyć egrep zamiast GREP.

$ grep -e "n | p".TXT Global | Regularny | Wyrażenie | Wydrukuj globalny wydruk wyrażenia regularnego lub $ egrep "n | p" Regex.TXT Global | Regularny | Wyrażenie | Drukuj globalny wydruk wyrażenia regularnego 

W poprzednim przykładzie użyliśmy GREP z rozszerzonym wyrażeniem regularnym, a zatem wyświetla oba linie, które zawierają znak N lub P. Jak wspomniano wcześniej, meta-właściciele straciły swoje szczególne znaczenie, gdy są wyrażone jako podstawowe wyrażenia regularne, chyba że uciekają z postacią „\”. Ponownie wykorzystajmy nasz pierwszy przykład, ale tym razem uciekamy „|” postać:

$ grep "n \ | p".TXT Global | Regularny | Wyrażenie | Drukuj globalny wydruk wyrażenia regularnego 

W tym przypadku operator zmian „|” zachowuje swoje szczególne znaczenie i działa jako logiczne lub nawet jeśli nie użyliśmy opcji -e ani egrep.

Powiedzieliśmy również, że podczas korzystania z opcji eGrep lub -e Grep uważa, że ​​jest karmiony przedłużonymi wyrażeniami regularnymi. Z tego powodu, jeśli uciekniesz z metalu w rozszerzonym kontekście wyrażenia regularnego, straci swoje szczególne znaczenie i zachowa się jako dosłowna postać „|”. Jeśli śledzisz tutaj, zauważysz, że jest to znowu dokładne przeciwieństwo podstawowych wyrażeń regularnych.

Przykład:

$ egrep "n \ | p".TXT Global | Zwykle | Wyrażenie | Drukuj 

Wyrażenia wspornika

Teraz, że jesteśmy zaznajomieni z podstawami wyrażeń regularnych, możemy zaangażować naszą eksplorację w silniejszą i jeszcze bardziej złożoną naturę wyrażeń regularnych. Pierwszym przystankiem będzie użycie „[” i „]” znanego jako „wyrażenia wspornika”. Historia „wyrażeń oddziału” polega na tym, że każde postacie zamknięte przez „[” i „]” będą pasować do dowolnej pojedynczej postaci na tej liście. Owinąć literę „E” z „[]” i zobaczmy, co się stanie:

$ cat Regex.txt global | regularne | wyrażenie | Drukuj globalny wyrażenie regularne wydruku $ grep [e] xpression Regex.TXT Global | Zwykle | Wyrażenie | Drukuj 

Jak widać nic niezwykłego. Nasze obecne wyrażenie regularne jedynie dopasowało słowo kluczowe „wyrażenie” i GREP, a zatem wydrukowano odpowiednią linię. Na tym terenie następujące wyrażenie regularne również zrobi tę samą sztuczkę:

$ grep wyrażenia wyrażenia.TXT Global | Zwykle | Wyrażenie | Drukuj 

Moc wyrażenia wspornika pojawia się, gdy chcesz dopasować na przykład pojedynczy znak na liście „[]”. Pokazano to w poniższym przykładzie:

$ grep [ee] Xpression Regex.TXT Global | Regularny | Wyrażenie | Drukuj globalny wydruk wyrażenia regularnego 

Czy możesz wymyślić sposób, w jaki sformułować alternatywę wyrażenia regularnego dla powyższego przykładu bez użycia „[]”? Taka technika została już wcześniej pokazana!

Za pomocą wyrażenia wspornika można również wyrażać logiczne nie. W tym celu możemy użyć symbolu Caret „^”. W poniższym przykładzie używamy wyrażenia regularnego, aby wyodrębnić wszystkie linie zawierające dowolne znaki z wykluczeniem postaci „A” i „C”.

$ cat Regex.txt a b c d $ grep [^ac] Regex.txt b d 

Zakres ekspresji

Wyrażenie wspornika pozwala również określić zakres wyrażeń. Zakres ekspresji obejmuje minimum dwie postacie oddzielone łącznikiem. Oznacza to, że zamiast [0123456789] możemy po prostu użyć [0-9] lub zamiast [ABC] możemy użyć [a-c]. Ilustruje to w poniższym przykładzie Regex:

$ cat Regex.txt a b c d $ grep [^a-c] Regex.txt d 

Zajęcia postaci

Poniżej znajdują się wstępnie zdefiniowane klasy, których możesz użyć w wyrażeniach nawigacyjnych.

W poniższym przykładzie wyrażenia regularnego użyjemy [: Lower:] i [: Space:] do drukowania tylko linii, które zawierają litery (-y) lub przestrzeń do niższej liczby:

Cat Regex.tekst
1
2
3
A
B
C
,
<-- space
$ grep [[: dolne:] [: Space:]] Regex.tekst
B
C
<-- space

Zakotwiczenie

Zakotwiczenie jest techniką wyrażenia regularnego, która angażuje symbol Caret ^ i znak dolara $ jako meta-właściciela, aby dopasować pusty ciąg od samego początku, a na końcu linii.

Znajdźmy wszystkie wiersze w pliku /etc /usługi, które zaczynają się od ciągu „ftp”:

$ grep ^ftp/etc/usługi ftp-data 20/tcp ftp 21/tcp ftps-data 989/tcp # ftp przez SSL (dane) ftps 990/tcp 

Jako przeciwny przykład możemy użyć zakotwiczenia regularnego, aby znaleźć wszystkie linie kończące się FTP:

$ grep ftp $/etc/usługi ZOPE-FTP 8021/TCP 

UWAGA: Nie myl znaczenia Caret z symbolem Careta używanego w wyrażeniu wsporników, ponieważ mają one dość wyraźne znaczenie w odpowiednim kontekście.

Charakter odwrotny i specjalne wyrażenia

Istnieje wiele narzędzi systemowych, w tym GREP, które obsługują „specjalne wyrażenia” znane również jako granice słów. Oto kilka specjalnych symboli wyrażeń obsługiwanych przez GREP i wiele innych narzędzi systemowych:

• \< - Dopasuj pusty ciąg na początku słowa
• \> - Dopasuj pusty ciąg na końcu słowa
• \B - Dopasuj pusty ciąg na początku i na końcu słowa
• \B - dopasowanie, z wyjątkiem początku lub na końcu słowa

Zacznijmy \< which will match empty string from the beginning of the word. Here is our tester file:

$ cat Regex.TXT Regularexpressions Regularne wyrażenia regularne 

Poniższe wyrażenie regularne będzie pasować do obu wierszy, ponieważ na każdym wierszu jest pusty ciąg, zanim słowo „regularne”:

$ grep "\RegularnyWyrażenia
Regularny Wyrażenia regulowane ekspresji

Następny przykład wyświetli tylko drugi wiersz, biorąc pod uwagę, że używamy \>, aby dopasować pusty ciąg również na końcu słowa:

$ grep „\” Regex.tekst
Regularny Wyrażenia regulowane ekspresji

Znaczenie \ b jest podobne, ale będzie pasować do obu, pustych ciągów od początku i końca słowa:

$ grep "\ bexpressions \ b".tekst
Wyrażenia regularne Wyrażenia

Podczas gdy \ b będzie pasować tylko wtedy, gdy nie na początku lub na końcu słowa:

$ grep "\ bexpressions \ b".tekst
Regularny WyrażeniaWyrażenia regularne

Aby uzyskać kompletność tej sekcji, tutaj są inne specjalne wyrażenia dostępne dla GREP. Należy pamiętać, że następujące symbole są po prostu skrótem wyżej wymienionych klas znaków:

• \S - Dopasuj dowolne znaki Whitespace (przestrzeń, zakładka itp.). alias [: Space:]
• \S - Dopasuj dowolną postać, ale Whitespace (przestrzeń, karta itp.). alias [^[: Space:]]
• \ w - Dopasuj dowolny znak w zakresie 0–9, a - z i a - z pseudonim [: alnum:]
• \ W - Dopasuj dowolny znak, ale zakres 0 - 9, a - z i a - z alias [^[: alnum:]]

Oto kilka przykładów klas postaci Skróty:

$ cat Regex.TXT ABCD 1234 " 

Karta mecz:

$ grep „\ s” Regex.tekst 

Dopasuj wszystko oprócz białej przestrzeni:

$ grep „\ s” Regex.TXT ABCD 1234 " 

Dopasuj wszystkie postacie alfanumeryczne:

$ grep „\ w” Regex.TXT ABCD 1234 

Dopasuj wszystkie znaki niealfanumeryczne (obejmują białe listy):

$ grep „\ w” Regex.tekst " 

Powtórzenie

Po wyrażeniu regularnym może nastąpić jeden lub kilka kwantyfikatorów powtórzeń. Zanim przejdziesz do tej sekcji, spójrz na poniższą tabelę:

Zacznijmy od utworzenia naszego przykładowego wyrażenia regularnego.tekst:

$ cat Regex.wyrażenia wyrażające wyrażanie wyrażania wyrażania ekspresji ekspresji ekspresji 

Pierwszy przykład powtórzeń będzie użył „?”:

$ grep -e "expres?jony „Regex.EXPRECJE EXPRESIONS TXT 

Jak opisano w powyższej tabeli, użycie „?„Kwantyfikator ma być dopasowany co najwyżej raz, czyli najwyżej raz lub uczynić poprzedni element opcjonalny. Poprzedni element w naszym przypadku jest postać „S”. Dlatego GREP dopasowało tylko struny z brakiem lub pojedynczym znakiem „S”, a następnie smyczkowane „jony”. Następny kwantyfikator, na który przyjrzymy się „*”, który z definicji będzie pasował do poprzedniego elementu zero lub więcej razy.

$ grep -e „expres*jony”.wyrażenia wyrażające wyrażanie wyrażania wyrażania ekspresji ekspresji ekspresji 

Jak pokazano powyżej, kwantyfikator „*” będzie pasował do wszystkich ciągów w naszym pliku testowym. Jeśli zastanawiasz się, dlaczego pasowało to również do „EXCREIONS”, pamiętaj, że kwantyfikator „*” czyni poprzedni element opcjonalny, w przeciwieństwie do kwantyfikatora „+”, który musi pasować do poprzedniego elementu przynajmniej raz lub więcej razy:

$ grep -e „expres+jony”.wyrażenia wyrażające wyrażanie wyrażania wyrażania wyrażania ekspresji 

Za pomocą kwantyfikatora „n” możesz dokładnie określić, ile razy poprzedni element zostanie dopasowany. Na przykład nasze:

$ grep -e "expres 3 jony".wyrażenia TXT 

Polecenie dopasuje ciąg, który zaczyna się od „Expre”, a następnie 3 x „s”, a następnie „jony”. Aby rozciągnąć nasze poprzednie wyrażenie regularne „n,”, możemy określić minimalną wartość tego, ile razy poprzedni element zostanie dopasowany. W rezultacie powtórzenie „3,” pasowało do 3 lub więcej razy:

$ grep -e "expres 3, jony".Wyrażanie wyrażania TXTSSSSSSSSSISSS 

Aby jeszcze bardziej rozszerzyć powyższe wyrażenie regularne, możemy określić zakres. Dlatego zastępujemy „3,” na „1,3”, a następujący Regex pasowałby:

$ grep -e "expres 1,3 jony".wyrażenia wyrażenia wyrażania wyrażeń 

Ponieważ poprzedni element „S” jest dopasowany co najmniej raz, ale nie więcej niż trzy razy.

Alternacja

Możesz pomyśleć o alternacji Regex jako logicznej lub operacji, w której wyrażenia regularne mogą połączyć jedno lub więcej „|” Operatorzy zmian. W rezultacie to wyrażenie regularne będzie zgodne z dowolnym ciągiem odpowiadającym albo alternatywnego wyrażenia regularnego.

$ cat Regex.TXT GREP oznacza: globalny wyrażenie regularne $ grep -e "^r |^e" Regex.Wyrażenie regularne TXT 

Precedens

Podczas tworzenia wyrażeń istnieje inna właściwość regularnych exppreezonów do rozważenia, a to jest pierwszeństwo. Podobne w obliczeniach arytmetycznych, wyrażenia regularne są zgodne z predefiniowanym pierwszeństwo. Najwyższe pierwszeństwo wymaga „powtórzenia”, a następnie „połączenia”, a najniższe pierwszeństwo należy do „naprzemienności”. Rozważ następujący przykład:

$ cat Regex.TXT Regex Regexxx $ grep -e "Regex 3".TXT Regexxx 

W wyżej wymienionym wyrażeniu regularnym możemy zobaczyć jednocześnie, „Regex”, jak i powtórzenie „X 3”. Ponieważ powtórzenie ma wyższe pierwszeństwo, powyższe wyrażenie regularne będzie pasować do „Regexxx”, ale nie „Regex”.
Innym przykładem, w którym należy wziąć pod uwagę pierwszeństwo, jest użycie operatora zmian „|” który ma najniższe pierwszeństwo ze wszystkich wyrażeń regularnych. Rozważ następujący przykład:

$ cat Regex.TXT Regularne Wyrażenia Wyrażenia $ grep -e "^regularne | wyrażenia $" Regex.wyrażenia regularne wyrażenia regularne TXT 

Ponieważ operator zmian „|” ma najniższe pierwszeństwo Powyższe wyrażenie regularne będzie pasować do dowolnego połączenia wyrażenia. W naszym przypadku będzie to „regularne” z kotwicą „^” i „Wyrażenia” z końcem linii kotwicy „$”. Aby zapewnić dowolny operator regex wyższe pierwszeństwo, musimy użyć „()”. W poniższym przykładzie użyjemy „()”, aby zastąpić pierwszeństwo operatora zmian do wyższego priorytetu, co robi zauważalną różnicę:

$ grep -e "^(regularne | wyrażenia) $" Regex.Wyrażenia regularne TXT 

W tym przykładzie operator zmian jest oceniany jako najpierw, ponieważ tworzy prostą podekspresję za pomocą „()”. Dlatego w rezultacie powyższe wyrażenie regularne dopasuje tylko linie, które zawierają „^regularne $” lub „^wyrażenia $”.

Odniesienia do tyłu i podekspresje

Każde podłoże złożone przez „()” utworzy podekspresję, która może być używana jako odniesienie tylne w kolejnej ekspresji regularnej. Ilustruje to następujący przykład:

$ cat Regex.TXT Regularne wyrażenia $ grep -e "(re) gular exp \ 1sssions" Regex.Wyrażenia regularne TXT 

Podekspresja połączonego wyrażenia regularnego „RE” jest używana jako odniesienie tylne później podczas tworzenia wyrażenia regularnego za pomocą \ 1 cyfry. Zamówienie zastosowane do utworzenia podekspresji „N” musi być spójne z odniesieniem z tyłu „\ n”:

$ grep -e "(r) (e) gular \ 2xp \ 1 \ 2sSsions".Wyrażenia regularne TXT 

Wniosek

Wyrażenia regularne są bardzo potężnym narzędziem w rękach dowolnego administratora systemu, programisty (Bash, Php, C#, Java i wiele innych. W tym artykule próbowano opisać w jakiś prosty, spójny i prosty angielski sposób podstaw regularnych wyrażeń, na których możesz dalej rozwinąć swoje wyrażenia regularne, a tym samym uratować się przed żmudną pracą, którą przetwarzanie tekstu może czasami oferować.

Przykłady wyrażeń regularnych

grep -e '^([0-9] 4 [-]?) 3 [0-9] 4 $ '' Credit-card.tekst

grep '^[: space:]]*$' Regex.tekst

grep -e '\' regex.tekst

grep -e '^\ $ [0-9]+\.[0-9] [0-9] $ 'Regex.tekst

df | grep -e "(([6-9] [0-9]) | (100))%"

grep -e -o "\ b [a-za-z0-9.-]+@[a-za-z0-9.-]+\.[A-ZA-Z0-9.-]+\ b ”e -maile.tekst

grep -o '[0-9] \ 1,3 \ \.[0-9] \ 1,3 \ \.[0-9] \ 1,3 \ \.[0-9] \ 1,3 \ ips.tekst

grep -oie '\ b (https?): // [-[: alnum:]+&@#/%?= ~ _ |!:,.;]*[[: alnum:]+
&@#/%= ~ _ |] '.HTM

Powiązane samouczki Linux:

• Advanced Bash Regex z przykładami
• Wprowadzenie do automatyzacji, narzędzi i technik Linuksa
• Bash Regexps dla początkujących z przykładami
• Mastering Bash Script Loops
• Rzeczy do zainstalowania na Ubuntu 20.04
• Wyrażenia regularne Pythona z przykładami
• Mint 20: Lepsze niż Ubuntu i Microsoft Windows?
• Zagnieżdżone pętle w skryptach Bash
• Rzeczy do zrobienia po zainstalowaniu Ubuntu 20.04 Focal Fossa Linux
• Manipulacja Big Data dla zabawy i zysku Część 3