0Pricing
Ruby Academy · Lekcja

Domknięcia i zakres

Przechwytywanie zmiennych

Domknięcia i zakres 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.

Przechwytywanie zmiennych

Domknięcie to funkcja, która pamięta zmienne z miejsca, w którym została zdefiniowana, nawet po zakończeniu wykonywania tego miejsca. Obiekty Proc i lambdy są domknięciami.

name = "Ada"
greeter = -> { puts "Hello, #{name}" }
greeter.call

Zmienna podąża za domknięciem

Domknięcie nie kopiuje wartości — zachowuje aktywne odwołanie do zmiennej. Jeśli zmienna zostanie później zmieniona, domknięcie zobaczy jej nową wartość.

count = 0
reader = -> { count }
count = 5
puts reader.call

Domknięcia mogą modyfikować zmienne

Ponieważ odwołanie pozostaje aktywne, domknięcie może również modyfikować przechwyconą zmienną.

total = 0
adder = ->(n) { total += n }
adder.call(3)
adder.call(7)
puts total

Przetrwanie metody otaczającej

Przechwycona zmienna istnieje tak długo jak domknięcie, nawet po zwróceniu wyniku przez metodę, która je utworzyła.

def counter
  n = 0
  -> { n += 1 }
end
c = counter
puts c.call
puts c.call
puts c.call

Niezależne stany

Każde wywołanie metody fabrykującej tworzy nową zmienną, dlatego osobne domknięcia zachowują niezależne stany.

def counter
  n = 0
  -> { n += 1 }
end
a = counter
b = counter
puts a.call
puts a.call
puts b.call

Parametry bloku są lokalne

Parametry zadeklarowane między pionowymi kreskami są lokalne dla bloku i nigdy nie wydostają się poza niego, nawet jeśli istnieje zmienna o tej samej nazwie.

x = 100
[1, 2, 3].each { |x| }
puts x  # still 100

Zmienne lokalne bloku

Po średniku w pionowych kreskach należy wymienić dodatkowe nazwy, aby wymusić ich lokalność względem bloku i ochronić zmienne zewnętrzne przed przypadkową zmianą.

y = "outer"
[1].each { |i; y| y = "inner" }
puts y  # unchanged

Budowanie konfigurowalnych funkcji

Domknięcia pozwalają jednorazowo wbudować konfigurację w funkcję i wielokrotnie jej używać.

def power_of(exp)
  ->(base) { base ** exp }
end
square = power_of(2)
cube = power_of(3)
puts square.call(5)
puts cube.call(2)

Domknięcia w iteracji

Częsta pułapka polega na tym, że domknięcie utworzone w pętli przechwytuje zmienną, a nie jej kopię z konkretnego momentu. Tworzenie domknięć osobno dla każdej iteracji pozwala przechwycić każdą wartość niezależnie.

funcs = [1, 2, 3].map { |i| -> { i } }
puts funcs.map(&:call).inspect

Hermetyzowanie stanu prywatnego

Domknięcia mogą ukrywać stan za funkcjami, stanowiąc wczesną formę obiektów. W tym przykładzie saldo jest niedostępne inaczej niż za pośrednictwem zwróconych lambd.

def make_account(start)
  balance = start
  deposit = ->(n) { balance += n }
  show = -> { balance }
  [deposit, show]
end
dep, show = make_account(100)
dep.call(50)
puts show.call

Składanie wszystkiego w całość

Domknięcia wiążą kod z miejscem jego utworzenia:

  • Przechwytują aktywne odwołania do otaczających zmiennych.
  • Stan zachowuje się po zakończeniu metody otaczającej.
  • Każde domknięcie przechowuje własne, niezależne zmienne.
def tagger(prefix)
  ->(text) { "[#{prefix}] #{text}" }
end
warn = tagger("WARN")
puts warn.call("low disk space")

Szybki test

Proszę sprawdzić swoją znajomość domknięć.

Podsumowanie

Omówiono domknięcia i zakres:

  • Obiekty Proc i lambdy przechwytują otaczające zmienne przez odwołanie.
  • Przechwycony stan istnieje dłużej niż metoda otaczająca.
  • Każde domknięcie przechowuje niezależny stan.
  • Parametry bloku pozostają lokalne; znaku ; należy używać do oznaczania zmiennych lokalnych bloku.
def stepper(by)
  pos = 0
  -> { pos += by }
end
s = stepper(5)
puts s.call
puts s.call

Często zadawane pytania

Czy lekcja „Domknięcia i zakres” jest bezpłatna?

Tak — pełny tekst „Domknięcia i zakres” 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 „Domknięcia i zakres”?

Przechwytywanie zmiennych Ć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 „Domknięcia i zakres”?

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

  1. Powtórka bloków
  2. Procki
  3. Lambdy
  4. Domknięcia i zakres
← Powrót do Ruby Academy