Ruby Academy · Lekcja

Literały wyrażeń regularnych

Podstawy wzorców

Literały wyrażeń regularnych to bezpłatna lekcja Ruby Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Ruby Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Ruby Academy zawiera 4 lekcji w sumie.

Czym jest wyrażenie regularne?

Wyrażenie regularne (regex) to wzorzec używany do dopasowywania tekstu. W języku Ruby regex jest obiektem pierwszej klasy klasy Regexp.

Wyrażeń regularnych używa się do wyszukiwania, walidowania i wyodrębniania fragmentów ciągów znaków.

Dopasowywanie słowa, cyfry lub symbolu
Sprawdzanie poprawności adresów e-mail i numerów telefonów
Wyodrębnianie fragmentów z nieuporządkowanego tekstu

pattern = /hello/
puts pattern.class
puts(pattern.match?('hello world'))

Literały wyrażeń regularnych z ukośnikami

Najczęściej wyrażenie regularne zapisuje się w języku Ruby między dwoma ukośnikami: /pattern/.

Nazywa się to literałem wyrażenia regularnego. Wszystko między ukośnikami jest wzorcem.

ruby = /ruby/
puts ruby.class
puts(ruby.match?('I love ruby'))
puts(ruby.match?('I love python'))

Operator dopasowania =~

Operator =~ sprawdza ciąg znaków względem wyrażenia regularnego. Zwraca indeks pierwszego dopasowania albo nil, jeśli nie znaleziono dopasowania.

puts('hello world' =~ /world/)
puts(('hello world' =~ /xyz/).inspect)

match? dla odpowiedzi logicznej

Gdy potrzebna jest tylko odpowiedź tak/nie, można użyć match?. Zwraca true albo false i działa szybciej, ponieważ nie tworzy obiektu MatchData.

puts(/\d/.match?('abc123'))
puts(/\d/.match?('abcdef'))

Klasy znaków

Klasa znaków w nawiasach kwadratowych dopasowuje dowolny pojedynczy znak z określonego zbioru.

[abc] dopasowuje a, b lub c
[a-z] dopasowuje dowolną małą literę
[0-9] dopasowuje dowolną cyfrę

puts(/[aeiou]/.match?('sky'))
puts(/[aeiou]/.match?('tree'))
puts(/[0-9]/.match?('room 7'))

Skrócone klasy znaków

Ruby udostępnia skrócone sekwencje specjalne dla często używanych klas znaków:

\d oznacza cyfrę, a \D znak niebędący cyfrą
\w oznacza znak słowa (litera, cyfra lub podkreślenie)
\s oznacza biały znak, a \S znak niebędący białym znakiem

puts(/\d\d/.match?('age 42'))
puts(/\w+/.match?('hello_99'))
puts(/\s/.match?('no_space'))

Kropka i kwantyfikatory

Kropka . dopasowuje dowolny pojedynczy znak (z wyjątkiem znaku nowej linii). Kwantyfikatory określają liczbę powtórzeń:

* zero lub więcej razy
+ jeden lub więcej razy
? zero lub jeden raz
{2,4} od 2 do 4 razy

puts(/ab+c/.match?('abbbc'))
puts(/colou?r/.match?('color'))
puts(/\d{3}/.match?('id 451'))

Alternatywa z użyciem pionowej kreski

Pionowa kreska | oznacza LUB. Wzorzec cat|dog dopasowuje jedno z tych słów.

Za pomocą nawiasów można zgrupować alternatywę wewnątrz większego wzorca.

pet = /cat|dog/
puts(pet.match?('I have a dog'))
puts(pet.match?('I have a fish'))
puts(/^(yes|no)$/.match?('yes'))

Flaga ignorowania wielkości liter

Dodanie flagi i po zamykającym ukośniku sprawia, że dopasowywanie nie uwzględnia wielkości liter.

Inne przydatne flagi to m (kropka dopasowuje znak nowej linii) oraz x (tryb rozszerzony, ignorowanie białych znaków).

puts(/ruby/i.match?('I love RUBY'))
puts(/ruby/.match?('I love RUBY'))

Tworzenie wyrażeń regularnych z ciągów znaków

Wyrażenie regularne można utworzyć w czasie działania programu za pomocą Regexp.new. Aby bezpiecznie uwzględnić dane wejściowe użytkownika, które mogą zawierać znaki specjalne, należy użyć Regexp.escape.

word = 'price'
pattern = Regexp.new(word)
puts(pattern.match?('the price is high'))
puts(Regexp.escape('a.b*c'))

Wprowadzenie do kotwic

Kotwice dopasowują pozycje, a nie znaki:

^ początek wiersza
$ koniec wiersza
\A początek ciągu znaków
\z koniec ciągu znaków

Dokładniej omówisz je w dalszej części.

puts(/^Hello/.match?('Hello there'))
puts(/world$/.match?('hello world'))

Szybkie sprawdzenie

Co zwraca operator =~, gdy wyrażenie regularne pasuje do ciągu znaków?

Podsumowanie: literały wyrażeń regularnych

Poznałeś podstawy wyrażeń regularnych w języku Ruby:

Literały wyrażeń regularnych zapisuje się między /slashes/
=~ zwraca indeks, a match? zwraca true/false
Klasy znaków [ ] i skrócone klasy \d \w \s
Kwantyfikatory * + ? {n,m} i alternatywa |
Flaga i sprawia, że dopasowywanie nie uwzględnia wielkości liter

W następnym kroku poznasz przechwytywanie dopasowanych fragmentów.

puts(/\w+@\w+\.\w+/i.match?('USER@Mail.com'))

Często zadawane pytania

Czy lekcja „Literały wyrażeń regularnych” jest bezpłatna?

Tak — pełny tekst „Literały wyrażeń regularnych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Ruby Academy, przejdź na CoddyKit PRO. Kurs Ruby Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Literały wyrażeń regularnych”?

Podstawy wzorców Ćwiczysz Ruby Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Ruby Academy?

Nie wymagamy żadnego doświadczenia. Ruby Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Literały wyrażeń regularnych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Ruby Academy?

Tak. Każda lekcja Ruby Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Ruby Academy