Nämä ovat kolme tapaa, joilla Ruby käsittelee koodinjaksoja datana. Blokki välitetään metodille (ei objekti); Proc ja lambda ovat objekteja, jotka käärivät blokkin (kutsuttava, tallennettava). Proc-objektit ja lambdat eroavat hienovaraisesti argumenttien tarkistuksessa ja return-käyttäytymisessä.
[1, 2, 3].each { |n| puts n } # the { } is a block — passed to each
# a block is NOT an object; it's part of the method call, can't be stored in a variable directly
Blokki on koodi, joka välitetään metodille (muodossa { } tai do...end) — se ei ole itsenäinen objekti, jonka voit tallentaa; se on sidottu metodin kutsua.
# a Proc — a block turned into an object you can store and call
square = Proc.new { |x| x * x }
square.call(5) # 25
square.(5) # 25 (alternate call syntax)
# a lambda — also a callable object (a "stricter" Proc)
double = lambda { |x| x * 2 }
double = ->(x) { x * 2 } # the -> "stabby lambda" syntax
double.call(5) # 10
Proc-objektit ja lambdat käärivät blokkin objektiksi, jonka voit määrittää muuttujille, välittää ympärille ja kutsua myöhemmin (.call) — hyödyllinen uudelleenkäytettävän käyttäytymisen tallentamiseen.
1. ARGUMENT CHECKING:
lambda → STRICT: errors if wrong number of arguments (like a method)
proc → LENIENT: ignores extra args, fills missing with nil
2. RETURN behavior:
lambda → `return` returns from the LAMBDA (like a normal method)
proc → `return` returns from the ENCLOSING METHOD (can surprise you!)
def test_proc
p = Proc.new { return 10 }
p.call # returns from test_proc ENTIRELY → 10
return 20 # never reached!
end
def test_lambda
l = lambda { return 10 }
l.call # returns from the LAMBDA only → 10
return 20 # reached → test_lambda returns 20
end
Tärkein ero: lambda käyttäytyy kuin metodi (tiukat argumentit, return poistuu vain lambdasta), kun taas proc on sallivampi (jättää huomiotta argumenttien epäsuhdan, ja return poistuu sulkevasta metodista — mikä voi aiheuttaa yllätyksiä). Lambdoja suositaan yleensä niiden metodinomaiselle, ennustettavalle käyttäytymiselle.
Blokkien, Proc-objektien ja lambdoiden ymmärtäminen — ja erityisesti niiden erot — on tärkeää Ruby-tietoa, joka heijastaa syvempää ymmärrystä siitä, kuinka Ruby käsittelee koodia datana. Blokit ovat yleisimmät (välitetään metodeille iteraatiolle ja takaisinkutsuille — Rubyn tunnusomaisuus), kun taas Proc-objektit ja lambdat muuttavat blokit tallennettuiksi, uudelleenkäytettäviksi objekteiksi, jotka voit määrittää muuttujille, välittää ympärille ja kutsua myöhemmin (hyödyllinen käyttäytymisen tallentamiseen, funktionaalisten mallien rakentamiseen ja takaisinkutsujen välittämiseen arvoina).
Proc-objektien ja lambdoiden keskeiset erot ovat hienovaraisia, mutta tärkeitä ja usein käsiteltävät haastattelijoiden aiheita: argumenttien tarkistus (lambdat ovat tiukkoja kuten metodit, Proc-objektit sallivampia) ja erityisesti return-käyttäytyminen (lambdan return poistuu vain lambdasta, kun taas Proc-objektin return poistuu sulkevasta metodista — mikä voi aiheuttaa yllätyksiä ja vaikeasti määritettävää käyttäytymistä).
Näiden erojen ymmärtäminen — että lambda käyttäytyy kuin metodi (tiukka, ennustettava, lokalisoitu return) kun taas Proc-objekti on sallivampi yllättävällä return-semantiikalla — on tärkeää niiden oikean käytön kannalta ja hyvin yleiselle suositukselle suosia lambdoja niiden ennustettavalle, metodinomaiselle käyttäytymiselle.
Vaikka blokit ovat jokapäiväistä Rubyä ja Proc-objektit/lambdat käytetään tallennettuihin takaisinkutsuihin ja funktionaalisiin malleihin, kaikkien kolmen ymmärtäminen (erityisesti Proc-objektin ja lambdan return- ja argumenttierot) heijastaa vahvaa Ruby-tietämystä, auttaa sinua välttämään Proc-objektin return-sudenkuopan, ja on klassinen haastattelu-aihe, joka erottaa kehittäjät, jotka todella ymmärtävät Rubyn koodin käsittelyä objekteina.