[RUBY] Über Rubinblock

Überblick

Ich denke, viele Leute wissen, dass sie irgendwie enden, Ich denke, dass viele Leute es nicht verstanden haben, weil die Hürden ein wenig steigen würden, wenn Proc herauskommt. Daher zusammen mit der Neuorganisation meines Wissens Wir haben es so zusammengestellt, dass viele Leute Rubys Grammatik gut verstehen und effizient codieren können.

Was ist ein Block?

Mit --ruby können Sie eine Reihe von Prozeduren an eine Methode übergeben --block wird durch do end oder {} beschrieben -Das Argument ist|x|mögen|Schreiben Sie es wie eine normale Methode

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

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

So erstellen Sie eine Methode, die Block verwendet

• Verwenden Sie Yield **, um Block ** oder ** Block & auszuführen (siehe unten) ** auszuführen
• Wenn Sie ein formales Argument für block verwenden, können Sie es verwenden, indem Sie ein Argument übergeben, um zu ergeben.
• Der Ertrag kann mehrfach verwendet werden --yield führt zu einem Fehler, wenn es verwendet wird, wenn kein Block übergeben wird

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)>

Stellen Sie fest, ob der Block übergeben wurde

• Block_given verwenden?

def three_times
  p block_given?
end

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

Ich möchte einen Block als Instanz behandeln

--block kann mit & zum und vom Proc-Objekt konvertiert werden

• Sie können es als Block übergeben, indem Sie "& proc_object" als Methodenargument verwenden.
• Durch Verwendung von & block als formales Argument der Methode ** kann der Block als Proc-Objekt empfangen werden **
• Wenn Sie einen einfachen Block erhalten, ohne & als Argument zu verwenden, wird er anstelle von Lambda verwendet (der Unterschied zwischen proc und Lambda wird später beschrieben).
• Wenn Sie Lambda als Argument mit "&" übergeben, erhalten Sie es als 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 und Lambda

--Proc-Objekte haben "Proc" und "Proc (Lambda)" (als proc bzw. Lambda bezeichnet).

• Beide sind Proc-Klassen -proc istProc.new { |x| }Oderproc { |x| }Schreiben -Lambda istlambda { |x| }Oder->(x) { }Schreiben

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

Unterschied zwischen Proc und Lambda

Umgang mit Argumenten

--Wenn das Argument extra ist --proc: Durch --lambda: Fehler tritt auf

• Wenn es nicht genug Argumente gibt --proc: wird null --lambda: Fehler tritt auf

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)>

brechen, Verhalten zurückgeben

--Wenn in der Methode ausgeführt, die Proc definiert

• return --proc: führt zu einer Methode, die Proc umgibt --lambda: Ergebnis in Proc
• break --proc: LocalJumpError --lambda: Ergebnis in Proc --Wenn außerhalb der Methode ausgeführt, die Proc definiert
• return --proc: LocalJumpError --lambda: Ergebnis in Proc
• break --proc: LocalJumpError --lambda: Ergebnis in Proc

** Wenn Sie das Ergebnis der Prozedur zurückgeben möchten, verwenden Sie "next" sowohl in Lambda als auch in 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"