繁体   English   中英

Ruby块采用数组或多个参数

[英]Ruby block taking array or multiple parameters

今天,我很惊讶地发现ruby自动找到作为块参数给出的数组的值。

例如:

foo = "foo"
bar = "bar"
p foo.chars.zip(bar.chars).map { |pair| pair }.first #=> ["f", "b"]
p foo.chars.zip(bar.chars).map { |a, b| "#{a},#{b}" }.first #=> "f,b"
p foo.chars.zip(bar.chars).map { |a, b,c| "#{a},#{b},#{c}" }.first #=> "f,b,"

我本以为最后两个示例会出现某种错误。

  1. 这是红宝石中更一般概念的示例吗?
  2. 我不认为我在问题开头的措辞是正确的,我怎么称呼这里发生的事情?

像这样的Ruby块是古怪的。

规则是这样的,如果一个块接受多个参数,并且产生一个响应to_ary对象,则该对象将被扩展。 对于带有两个或多个参数的块,这使得产生数组与产生元组的行为似乎相同。

yield [a,b]yield a,b的确有所不同,尽管当该块仅使用一个参数或当该块使用可变数量的参数时。

让我展示这两个

def yield_tuple
  yield 1, 2, 3
end

yield_tuple { |*a| p a }
yield_tuple { |a| p [a] }
yield_tuple { |a, b| p [a, b] }
yield_tuple { |a, b, c| p [a, b, c] }
yield_tuple { |a, b, c, d| p [a, b, c, d] } 

版画

[1, 2, 3]
[1] 
[1, 2]
[1, 2, 3]
[1, 2, 3, nil]

def yield_array
  yield [1,2,3]
end

yield_array { |*a| p a }
yield_array { |a| p [a] }
yield_array { |a, b| p [a, b] }
yield_array { |a, b, c| p [a, b, c] }
yield_array { |a, b, c, d| p [a, b, c, d] }

版画

[[1, 2, 3]]
[[1, 2, 3]] 
[1, 2] # array expansion makes it look like a tuple
[1, 2, 3] # array expansion makes it look like a tuple
[1, 2, 3, nil] # array expansion makes it look like a tuple

最后证明Ruby中的所有内容都使用鸭式输入法

class A
  def to_ary
    [1,2,3]
  end
end

def yield_arrayish
  yield A.new
end

yield_arrayish { |*a| p a }
yield_arrayish { |a| p [a] }
yield_arrayish { |a, b| p [a, b] }
yield_arrayish { |a, b, c| p [a, b, c] }
yield_arrayish { |a, b, c, d| p [a, b, c, d] }

版画

[#<A:0x007fc3c2969190>]
[#<A:0x007fc3c2969050>]
[1, 2] # array expansion makes it look like a tuple
[1, 2, 3] # array expansion makes it look like a tuple
[1, 2, 3, nil] # array expansion makes it look like a tuple

PS,相同的数组扩展行为适用于proc闭包,其行为类似于块,而lambda闭包的行为类似于方法。

Ruby的块机制对其有一个怪癖,也就是说,如果要遍历包含数组的内容,则可以将它们扩展为不同的变量:

[ %w[ a b ], %w[ c d ] ].each do |a, b|
  puts 'a=%s b=%s' % [ a, b ]
end

当使用Hash#each并想分解成对的keyvalue部分时,此模式非常有用: each { |k,v| ... } each { |k,v| ... }在Ruby代码中非常常见。

如果您的块接受多个参数, 并且要迭代的元素是一个数组,则它将切换如何解释参数。 您可以随时强制展开:

[ %w[ a b ], %w[ c d ] ].each do |(a, b)|
  puts 'a=%s b=%s' % [ a, b ]
end

这对于情况更复杂的情况很有用:

[ %w[ a b ], %w[ c d ] ].each_with_index do |(a, b), i|
  puts 'a=%s b=%s @ %d' % [ a, b, i ]
end

由于在这种情况下,它遍历数组附加的另一个元素,因此每一项实际上都是%w[ ab ], 0形式的元组%w[ ab ], 0内部为%w[ ab ], 0 ,如果您的块仅接受一个参数,则它将转换为数组。

这与定义变量时可以使用的原理大致相同:

a, b = %w[ a b ]
a
# => 'a'
b
# => 'b'

这实际上为ab分配了独立的值。 与:

a, b = [ %w[ a b ] ]
a
# => [ 'a', 'b' ]
b
# => nil

我本以为最后两个示例会出现某种错误。

实际上,如果您从方法中传递proc ,它确实会以这种方式工作。 产生这样的proc更为严格–它检查其Arity,并且不尝试将数组参数转换为参数列表:

def m(a, b)
  "#{a}-#{b}"
end

['a', 'b', 'c'].zip([0, 1, 2]).map(&method(:m))
#=> wrong number of arguments (given 1, expected 2) (ArgumentError)

这是因为zip创建(数组)数组,而map仅产生每个元素,即

yield ['a', 0]
yield ['b', 1]
yield ['c', 2]

另一方面, each_with_index起作用:

['a', 'b', 'c'].each_with_index.map(&method(:m))
#=> ["a-0", "b-1", "c-2"]

因为它会产生两个单独的值,即元素及其索引,即

yield 'a', 0
yield 'b', 1
yield 'c', 2

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM