À propos de Ruby Block

Aperçu

Je pense que beaucoup de gens savent qu'ils utilisent une fin en quelque sorte, Je pense que beaucoup de gens ne l'ont pas compris parce que les obstacles augmenteraient un peu lorsque proc sortait. Par conséquent, en plus de réorganiser mes connaissances Nous l'avons compilé pour que de nombreuses personnes puissent bien comprendre la grammaire de ruby et coder efficacement.

Qu'est-ce qu'un bloc

--ruby vous permet de passer une série de procédures à une méthode --block est décrit par do end ou {} -L'argument est|x|comme|Écrivez-le de la même manière qu'une méthode normale

[*1..3].each do |i|
  p i
end
# => 1
# => 2
# => 3

3.times { |i| p i }
# => 0
# => 1
# => 2

Comment créer une méthode qui utilise le bloc

--Utiliser yield ** pour exécuter le bloc ** ou ** Utiliser & bloquer (voir ci-dessous) **

• Si vous utilisez un argument formel pour block, vous pouvez l'utiliser en passant un argument à yield.
• Le rendement peut être utilisé plusieurs fois --yield entraînera une erreur s'il est utilisé si aucun bloc n'est passé

def three_times
  3.times { yield }
end
three_times { p 'a' }
# => "a"
# => "a"
# => "a"

def three_times
  3.times { |j| yield(j) }
end
three_times { |i| p i }
# => 0
# => 1
# => 2

def calculate
  p yield(1, 2)
  p yield(2, 3)
end

calculate { |a, b| a + b }
# => 3
# => 5
calculate { |a, b| a * b }
# => 2
# => 6

def three_times(&block)
  3.times { yield } rescue p $!
end
three_times
# => #<LocalJumpError: no block given (yield)>

Déterminer si le bloc a été passé

--Utilisez block_given?

def three_times
  p block_given?
end

three_times
# => false
three_times { p 'y' }
# => true

Je veux traiter un bloc comme une instance

--block peut être converti vers et depuis l'objet Proc en utilisant &

• Vous pouvez le passer comme un bloc en faisant & proc_object comme argument de méthode.
• En définissant & block comme argument formel de la méthode, ** le bloc peut être reçu en tant qu'objet Proc ** --Si vous recevez un bloc simple sans utiliser & comme argument, ce sera proc au lieu de lambda (la différence entre proc et lambda sera décrite plus tard). --Si vous passez lambda comme argument avec &, recevez-le comme lambda

proc_object = Proc.new do |a|
  p a
end
3.times(&proc_object)
# => 0
# => 1
# => 2

def three_times(&block)
  3.times { |j| block.call(j) }
end
three_times { |i| i }
# => 0
# => 1
# => 2

proc et lambda

• Les objets Proc ont «Proc» et «Proc (lambda)» (appelés respectivement proc et lambda).
• Les deux sont des classes «Proc» -proc estProc.new { |x| }Ouproc { |x| }Écrire -lambda estlambda { |x| }Ou->(x) { }Écrire

p Proc.new {}
# => #<Proc:0x00007f3e59459978@/tmp/nvimaASrm8/2:1>
p Proc.new {}.instance_of?(Proc)
# => true
p lambda {}
# => #<Proc:0x00007f3e59459838@/tmp/nvimaASrm8/2:2 (lambda)>
p lambda {}.instance_of?(Proc)
# => true

Différence entre proc et lambda

Traitement des arguments

--Lorsque l'argument est extra --proc: à travers --lambda: une erreur se produit --S'il n'y a pas assez d'arguments --proc: devient nul --lambda: une erreur se produit

x = proc { |a, b| p [a,b] }
x.call(:a, :b, :c)
# => [:a, :b]

x = lambda { |a, b| p [a,b] }
x.call(:a, :b, :c) rescue p $!
# => #<ArgumentError: wrong number of arguments (given 3, expected 2)>

x = proc { |a, b| p [a,b] }
x.call(:a)
# => [:a, nil]

x = lambda { |a, b| p [a,b] }
x.call(:a) rescue p $!
# => #<ArgumentError: wrong number of arguments (given 1, expected 2)>

rupture, comportement de retour

--Lorsqu'il est exécuté dans la méthode qui définit Proc

• return --proc: donne une méthode entourant Proc --lambda: résultat dans Proc
• break --proc: LocalJumpError --lambda: résultat dans Proc --Lorsqu'il est exécuté en dehors de la méthode qui définit Proc
• return --proc: LocalJumpError --lambda: résultat dans Proc
• break --proc: LocalJumpError --lambda: résultat dans Proc

** Si vous voulez renvoyer le résultat de la procédure, utilisez next à la fois dans lambda et proc! **

def hoge
  x = proc { return 2 }.call
  p "x: #{x}"
  return 1
end
p "method: #{hoge}"
# => "method: 2"

def hoge
  x = lambda { return 2 }.call
  p "x: #{x}"
  return 1
end
p "method: #{hoge}"
# => "x: 2"
# => "method: 1"

def hoge
  x = proc { break 2 }.call
  p "x: #{x}"
  return 1
end
p "method: #{hoge}" rescue p $!
# => #<LocalJumpError: break from proc-closure>

def hoge
  x = lambda { break 2 }.call
  p "x: #{x}"
  return 1
end
p "method: #{hoge}"
# => "x: 2"
# => "method: 1"

def hoge(x)
  p "x: #{x.call}"
  return 1
end
x = proc { break 2 }
p "method: #{hoge(x)}" rescue p $!
# => #<LocalJumpError: break from proc-closure>

x = lambda { break 2 }
p "method: #{hoge(x)}"
# => "x: 2"
# => "method: 1"