Kiedy stosować lambda, kiedy stosować Proc.nowy?
W Ruby 1.8 istnieją subtelne różnice między proc / lambda z jednej strony, a Proc.new
z drugiej.
- Jakie są te różnice? Czy możesz podać wskazówki, jak zdecydować, który z nich wybrać?
- w Ruby 1.9, proc i lambda są różne. O co chodzi?
14 answers
Kolejną ważną, ale subtelną różnicą między procami utworzonymi za pomocą lambda
i procami utworzonymi za pomocą Proc.new
jest sposób postępowania z return
stwierdzeniem:
- w
lambda
-utworzonym proc, Instrukcjareturn
zwraca tylko z samego proc - w
Proc.new
-stworzonym proc, deklaracjareturn
jest nieco bardziej zaskakująca: zwraca kontrolę nie tylko z proc, , ale także z metody załączającej proc!
Oto lambda
- utworzone proc ' s return
w akcja. Zachowuje się w sposób, którego prawdopodobnie oczekujesz:
def whowouldwin
mylambda = lambda {return "Freddy"}
mylambda.call
# mylambda gets called and returns "Freddy", and execution
# continues on the next line
return "Jason"
end
whowouldwin
#=> "Jason"
Oto Proc.new
-utworzone proc ' s return
robiące to samo. Wkrótce zobaczysz jeden z tych przypadków, w których Ruby łamie bardzo wychwalaną zasadę najmniejszego zaskoczenia: {]}
def whowouldwin2
myproc = Proc.new {return "Freddy"}
myproc.call
# myproc gets called and returns "Freddy",
# but also returns control from whowhouldwin2!
# The line below *never* gets executed.
return "Jason"
end
whowouldwin2
#=> "Freddy"
Dzięki temu zaskakującemu zachowaniu (jak również mniej pisania), preferuję używanie lambda
nad Proc.new
podczas tworzenia proc.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-12-30 06:28:30
W celu zapewnienia dalszych wyjaśnień:
Joey mówi, że zachowanie powrotuProc.new
jest zaskakujące. Jednak jeśli wziąć pod uwagę, że Proc.new zachowuje się jak blok nie jest to zaskakujące, ponieważ tak właśnie zachowują się bloki. Lamby z drugiej strony zachowują się bardziej jak metody.
To wyjaśnia, dlaczego proc są elastyczne, jeśli chodzi o arytmetykę (liczbę argumentów), podczas gdy lambda nie. Bloki nie wymagają podania wszystkich argumentów, ale metody tak (chyba że domyślnie podano). Chociaż podanie domyślnego argumentu lambda nie jest opcją w Rubim 1.8, jest teraz obsługiwane w Rubim 1.9 z alternatywną składnią lambda (jak zauważył webmat):
concat = ->(a, b=2){ "#{a}#{b}" }
concat.call(4,5) # => "45"
concat.call(1) # => "12"
I Michiel de Mare (op) jest niepoprawny co do Procs i lambda zachowujących się tak samo z arytmetyką w Ruby 1.9. Zweryfikowałem, że nadal zachowują zachowanie od 1.8, jak określono powyżej.
break
wypowiedzi nie mają sensu ani w Procach, ani w lambdach. W Procs, break zwróci Ci Proc.nowy, który został już ukończony. I nie ma sensu odrywać się od lambdy, ponieważ jest to zasadniczo metoda, a nigdy nie odrywałbyś się od najwyższego poziomu metody.
next
, redo
, i raise
zachowują się tak samo zarówno w Procs, jak i Lambda. Podczas gdy retry
nie jest dozwolone w żadnym z nich i spowoduje wyjątek.
I wreszcie, metoda proc
nie powinna być nigdy używana, ponieważ jest niespójna i ma nieoczekiwane zachowanie. W Ruby 1.8 it rzeczywiście zwraca lambda! W Rubim 1.9 zostało to naprawione i zwraca Proc. Jeśli chcesz utworzyć Proc, trzymaj się Proc.new
.
Aby uzyskać więcej informacji, Gorąco polecam O 'Reilly' s język programowania Ruby, który jest moim źródłem większości tych informacji.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2009-10-04 05:23:22
Znalazłem tę stronę, która pokazuje, jaka jest różnica między Proc.new
i lambda
. Zgodnie ze stroną, jedyną różnicą jest to, że lambda jest ścisła co do liczby akceptowanych argumentów, podczas gdy Proc.new
zamienia brakujące argumenty na nil
. Oto przykładowa sesja IRB ilustrująca różnicę:
irb(main):001:0> l = lambda { |x, y| x + y } => #<Proc:0x00007fc605ec0748@(irb):1> irb(main):002:0> p = Proc.new { |x, y| x + y } => #<Proc:0x00007fc605ea8698@(irb):2> irb(main):003:0> l.call "hello", "world" => "helloworld" irb(main):004:0> p.call "hello", "world" => "helloworld" irb(main):005:0> l.call "hello" ArgumentError: wrong number of arguments (1 for 2) from (irb):1 from (irb):5:in `call' from (irb):5 from :0 irb(main):006:0> p.call "hello" TypeError: can't convert nil into String from (irb):2:in `+' from (irb):2 from (irb):6:in `call' from (irb):6 from :0
Strona zaleca również używanie lambda, chyba że chcesz zachować tolerancję błędu. Zgadzam się z tym sentymentem. Używanie lambdy wydaje się nieco bardziej zwięzłe, a przy tak nieznacznej różnicy wydaje się lepszym wyborem w średniej sytuacji.
Jeśli chodzi o Ruby 1.9, przepraszam, nie zajrzałem jeszcze do 1.9, ale nie wyobrażam sobie, żeby tak bardzo to zmienili(nie wierz mi jednak na słowo, wygląda na to, że słyszałeś o pewnych zmianach, więc prawdopodobnie się mylę).
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-10-21 18:36:33
Proc jest starszy, ale semantyka powrotu jest dla mnie wysoce przeciwstawna (przynajmniej gdy uczyłem się języka), ponieważ:
- Jeśli używasz proc, najprawdopodobniej używasz jakiegoś paradygmatu funkcjonalnego.
- Proc może powrócić z zakresu załączającego (patrz poprzednie odpowiedzi), który jest w zasadzie goto i wysoce niefunkcjonalny z natury.
Lambda jest funkcjonalnie bezpieczniejsza i łatwiejsza do rozumowania - zawsze używam jej zamiast proc.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2013-04-04 18:39:59
Niewiele mogę powiedzieć o subtelnych różnicach. Mogę jednak zauważyć, że Ruby 1.9 umożliwia teraz opcjonalne parametry dla Lambda i bloków.
Oto nowa składnia stabby lambda pod 1.9:
stabby = ->(msg='inside the stabby lambda') { puts msg }
Ruby 1.8 nie miał takiej składni. Podobnie jak konwencjonalny sposób deklarowania bloków/lambda nie obsługuje opcjonalnych args:
# under 1.8
l = lambda { |msg = 'inside the stabby lambda'| puts msg }
SyntaxError: compile error
(irb):1: syntax error, unexpected '=', expecting tCOLON2 or '[' or '.'
l = lambda { |msg = 'inside the stabby lambda'| puts msg }
Ruby 1.9 obsługuje jednak opcjonalne argumenty nawet ze starą składnią:
l = lambda { |msg = 'inside the regular lambda'| puts msg }
#=> #<Proc:0x0e5dbc@(irb):1 (lambda)>
l.call
#=> inside the regular lambda
l.call('jeez')
#=> jeez
Jeśli chcesz zbudować Ruby1. 9 dla Leoparda lub Linuksa, sprawdź ten artykuł (bezwstydna autopromocja).Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2008-11-19 21:28:28
Krótka odpowiedź: liczy się to, co return
robi: lambda zwraca z siebie, a proc zwraca z siebie i funkcji, która go wywołała.
Mniej jasne jest, dlaczego chcesz użyć każdego. lambda jest tym, czego oczekujemy w sensie programowania funkcyjnego. Jest to w zasadzie anonimowa metoda z bieżącym zakresem automatycznie powiązanym. Z tych dwóch, lambda jest tym, którego prawdopodobnie powinieneś używać.
Proc, Z drugiej strony, jest naprawdę przydatny do implementacji sam język. Na przykład można za ich pomocą zaimplementować polecenia "if" lub pętle "for". Każdy zwrot znaleziony w proc zwróci się z metody, która go wywołała, a nie tylko z polecenia "if". Tak działają języki, jak działają wyrażenia "jeśli", więc domyślam się, że Ruby używa tego pod okładkami i po prostu ujawnili to, ponieważ wydawało się potężne.
Będzie to potrzebne tylko wtedy, gdy tworzysz nowe konstrukcje językowe, takie jak pętle, konstrukcje if-else itp.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2014-11-11 21:54:05
Dobrym sposobem na to jest to, że lambda są wykonywane we własnym zakresie (tak jakby były wywołaniem metody), podczas gdy Procs mogą być postrzegane jako wykonywane w linii z wywołaniem metody, przynajmniej jest to dobry sposób na podjęcie decyzji, którego użyć w każdym przypadku.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2008-12-09 14:17:51
Nie zauważyłem żadnych komentarzy na temat trzeciej metody w questonie, "proc", która jest przestarzała, ale inaczej traktowana w 1.8 i 1.9.
Oto dość szczegółowy przykład, który ułatwia dostrzeżenie różnic między trzema podobnymi wywołaniami:
def meth1
puts "method start"
pr = lambda { return }
pr.call
puts "method end"
end
def meth2
puts "method start"
pr = Proc.new { return }
pr.call
puts "method end"
end
def meth3
puts "method start"
pr = proc { return }
pr.call
puts "method end"
end
puts "Using lambda"
meth1
puts "--------"
puts "using Proc.new"
meth2
puts "--------"
puts "using proc"
meth3
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2009-06-25 11:22:32
Closures in Ruby to dobry przegląd tego, jak bloki, lambda i proc działają w Rubim, z Rubim.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2018-08-08 06:19:51
Understanding Ruby Blocks, Procs and Lambdas autorstwa Roberta Sosińskiego jasno wyjaśnia te koncepcje programowania i wzmacnia wyjaśnienia za pomocą przykładowego kodu. Obiekty metody są również powiązane i pokryte.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2014-12-03 19:32:14
Lambda działa zgodnie z oczekiwaniami, podobnie jak w innych językach.
[[11]}the wiredProc.new
jest zaskakujący i mylący.
Polecenie return
W proc utworzone przez Proc.new
zwróci nie tylko kontrolę samą w sobie, ale także z otaczającej ją metody .
def some_method
myproc = Proc.new {return "End."}
myproc.call
# Any code below will not get executed!
# ...
end
Można argumentować, że Proc.new
wstawia kod do metody enclosing, tak jak block.
Jednak Proc.new
tworzy obiekt, podczas gdy block jest częścią obiektu.
I jest jeszcze jedna różnica pomiędzy lambda i Proc.new
, co jest ich obsługą (błędnych) argumentów.
lambda narzeka na to, podczas gdy Proc.new
ignoruje dodatkowe argumenty lub uważa brak argumentów za zero.
irb(main):021:0> l = -> (x) { x.to_s }
=> #<Proc:0x8b63750@(irb):21 (lambda)>
irb(main):022:0> p = Proc.new { |x| x.to_s}
=> #<Proc:0x8b59494@(irb):22>
irb(main):025:0> l.call
ArgumentError: wrong number of arguments (0 for 1)
from (irb):21:in `block in irb_binding'
from (irb):25:in `call'
from (irb):25
from /usr/bin/irb:11:in `<main>'
irb(main):026:0> p.call
=> ""
irb(main):049:0> l.call 1, 2
ArgumentError: wrong number of arguments (2 for 1)
from (irb):47:in `block in irb_binding'
from (irb):49:in `call'
from (irb):49
from /usr/bin/irb:11:in `<main>'
irb(main):050:0> p.call 1, 2
=> "1"
BTW, proc
W Rubim 1.8 tworzy lambda, podczas gdy w Rubim 1.9+ zachowuje się jak Proc.new
, co jest naprawdę mylące.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2014-11-21 14:40:45
Aby rozwinąć odpowiedź akordeonu:
Zauważ, że Proc.new
tworzy proc poprzez przekazanie bloku. Wierzę, że lambda {...}
jest parsowane jako rodzaj dosłownego, a nie wywołania metody, które przekazuje blok. return
ing z wewnątrz bloku dołączonego do wywołania metody powróci z metody, a nie z bloku, a przypadek Proc.new
jest tego przykładem w grze.
(to jest 1.8. Nie wiem jak to się przekłada na 1.9.)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2008-09-07 02:31:40
Jestem trochę spóźniony, ale jest jedna wielka, ale mało znana rzecz o Proc.new
w ogóle nie wspominana w komentarzach. As by documentation :
Proc::new
może być wywołany bez bloku tylko w ramach metody z dołączonym blokiem, w którym to przypadku blok jest konwertowany doProc
obiekt.
To powiedziawszy, Proc.new
lets to chain yielding methods:
def m1
yield 'Finally!' if block_given?
end
def m2
m1 &Proc.new
end
m2 { |e| puts e }
#⇒ Finally!
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2015-04-28 13:15:25
Różnica w zachowaniu z {[0] } jest IMHO najważniejszą różnicą między 2. Ja też wolę lambdę, bo mniej pisze niż Proc.Nowe: -)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2008-08-11 02:09:46