Question

今天我很惊讶地发现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,"

我原本预计最后两个例子会出现某种错误。

这是ruby中更一般概念的一个例子吗？
我不认为我的问题开头的措词是正确的，我怎么称呼这里发生的事情？

Answer 1

Ruby的块函数对它们有一个怪癖，就是如果你在包含数组的东西上进行迭代，你可以将它们扩展为不同的变量：

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

使用Hash#each时，此模式非常有用，并且您希望突破该对的key和value部分：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[ a b ], 0的元组，它将被转换为数组如果你的块只接受一个参数。

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

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

这实际上为a和b分配了独立的值。对比：

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

Answer 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中的所有内容都使用了duck-typing

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闭包的行为类似于方法。

Answer 3

我原本预计最后两个例子会出现某种错误。

如果从方法中传递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

Ruby块采用数组或多个参数

3 个答案: