Ruby Academy · Lekcja

Praktyczne zastosowania

Parsowanie danych strukturalnych

Praktyczne zastosowania to bezpłatna lekcja Ruby Academy na CoddyKit. To lekcja 4 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.

Dlaczego dopasowywanie wzorców jest tak przydatne

Dopasowywanie wzorców najlepiej sprawdza się podczas obsługi ustrukturyzowanych danych: odpowiedzi API, drzew konfiguracji i przeanalizowanych plików. Zastępuje zagnieżdżone sprawdzenia if/dig jednym czytelnym wyrażeniem.

require 'json'
resp = JSON.parse('{"ok":true,"data":42}', symbolize_names: true)
case resp
in { ok: true, data: }
  puts(data)
end

Obsługa powodzenia i błędu API

Można dopasować różne kształty odpowiedzi w osobnych gałęziach, wyodrębniając odpowiednie pola dla każdej z nich.

def handle(resp)
  case resp
  in { status: 'ok', result: }
    "got #{result}"
  in { status: 'error', message: }
    "error: #{message}"
  end
end
puts(handle({ status: 'error', message: 'bad input' }))

Analizowanie argumentów polecenia

Można dopasować tablicę argumentów, aby przejrzyście rozdzielać polecenia.

def run(args)
  case args
  in ['add', a, b]
    a.to_i + b.to_i
  in ['echo', *rest]
    rest.join(' ')
  end
end
puts(run(['add', '3', '4']))
puts(run(['echo', 'hi', 'there']))

Sprawdzanie kształtu rekordu

Należy użyć wzorca, aby przed przetwarzaniem potwierdzić, że rekord zawiera wymagane pola i typy.

def valid?(rec)
  case rec
  in { name: String, age: Integer => a } if a >= 0
    true
  else
    false
  end
end
puts(valid?({ name: 'Ada', age: 36 }))
puts(valid?({ name: 'X', age: -1 }))

Dekonstrukcja zagnieżdżonej konfiguracji

Głębokie wartości konfiguracji można wyodrębnić w jednym dopasowaniu zamiast wykonywać łańcuchowe wyszukiwania.

cfg = { server: { host: 'localhost', port: 8081 } }
case cfg
in { server: { host:, port: } }
  puts("#{host}:#{port}")
end

Unie z tagiem

Częsty wzorzec funkcyjny: dane są oznaczone typem, a ich obsługa jest wybierana na podstawie tego tagu.

def area(shape)
  case shape
  in { type: 'circle', r: }
    (3.14 * r * r).round(2)
  in { type: 'rect', w:, h: }
    w * h
  end
end
puts(area({ type: 'rect', w: 3, h: 4 }))

Dopasowywanie za pomocą deconstruct

Obiekty niestandardowe można dopasowywać, jeśli definiują deconstruct (dla wzorców tablic). Struct robi to automatycznie.

Point = Struct.new(:x, :y)
case Point.new(1, 2)
in [x, y]
  puts("#{x},#{y}")
end

Dopasowywanie za pomocą deconstruct_keys

Należy zdefiniować deconstruct_keys, aby obsługiwać wzorce hashy. Struct również udostępnia tę metodę, umożliwiając dopasowywanie po nazwach.

Point = Struct.new(:x, :y)
case Point.new(3, 4)
in { x:, y: }
  puts("x=#{x} y=#{y}")
end

Klasa ze wzorcem

Można połączyć wzorzec typu ze wzorcem hasha, aby dopasować konkretną klasę i jej pola.

User = Struct.new(:name, :admin, keyword_init: true)
case User.new(name: 'Ada', admin: true)
in User(admin: true, name:)
  puts("#{name} is an admin")
end

Bezpieczne przypadki domyślne

Zawsze należy podawać else, gdy dane wejściowe mogą nie pasować, zamieniając wyjątek w kontrolowaną obsługę.

def parse(data)
  case data
  in { id: Integer => id }
    "id #{id}"
  else
    'unrecognized'
  end
end
puts(parse({ name: 'x' }))

Złożenie wszystkiego

Realistyczny przebieg wygląda tak: przeanalizować JSON, dopasować jego kształt, zweryfikować go za pomocą warunku ochronnego i wykonać działanie — wszystko w jednym przejrzystym wyrażeniu.

require 'json'
event = JSON.parse('{"kind":"purchase","amount":150}', symbolize_names: true)
case event
in { kind: 'purchase', amount: Integer => amt } if amt > 100
  puts("big purchase: #{amt}")
in { kind: 'purchase', amount: }
  puts("purchase: #{amount}")
end

Szybkie sprawdzenie

Jaką metodę musi zdefiniować niestandardowa klasa, aby obsługiwać dopasowywanie wzorców hashy, takie jak in { x:, y: }?

Podsumowanie: praktyczne zastosowania

Wykorzystali już Państwo dopasowywanie wzorców w rzeczywistych problemach:

Rozdzielanie odpowiedzi API i poleceń
Sprawdzanie kształtu rekordów za pomocą warunków ochronnych
Dekonstrukcja zagnieżdżonej konfiguracji i unii z tagiem
deconstruct / deconstruct_keys dla obiektów niestandardowych
Zawsze należy dodawać else jako bezpieczny przypadek domyślny

Ukończyli już Państwo kurs dopasowywania wzorców w Ruby.

case { type: 'circle', r: 2 }
in { type: 'circle', r: } then puts(3.14 * r * r)
end

Często zadawane pytania

Czy lekcja „Praktyczne zastosowania” jest bezpłatna?

Tak — pełny tekst „Praktyczne zastosowania” 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 „Praktyczne zastosowania”?

Parsowanie danych strukturalnych Ć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 4 z 4.

Ile czasu zajmuje lekcja „Praktyczne zastosowania”?

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