使用&；调用自定义方法：Ruby语法

所以基本上我在看这个简单的例子：

%w[A B C].map(&:downcase)

并对

&:

语法感兴趣。在阅读了一些文章之后，我想我明白了（或者至少我这么认为），所以我决定为

Integer

实现类似的功能，如下所示：

class Integer
  def my_multiplier
    puts "66"
  end
end

class Integer
  def double 
    self * 2
  end 

end

3.times.map(&:double) # => [0, 2, 4]

在这里，我可以利用

和：

语法，因为我可以这样做：

3.倍（&:my\u乘数）

当然，结果是数字的三倍

66

---

我的问题是如何重构我的方法，以便我可以实际使用

3.times..

？

不清楚您使用该方法的目的是什么，但当前整数将作为

self

提供。所以你可以这样做：

class Integer
  def my_multiplier
    puts "66"
  end
end

class Integer
  def double 
    self * 2
  end 

end

3.times.map(&:double) # => [0, 2, 4]

---

不清楚您使用该方法的目的是什么，但当前整数将作为

self

提供。所以你可以这样做：

class Integer
  def my_multiplier
    puts "66"
  end
end

class Integer
  def double 
    self * 2
  end 

end

3.times.map(&:double) # => [0, 2, 4]

---

首先，语法是

&object

，而不是

&:

<代码>&对象调用

。对对象执行_proc

现在，假设您希望乘法器简单地将整数乘以66，您可以将其写成：

class Integer
  def my_multiplier
    puts 66 * self
  end
end

这将导致

2.5.1 :006 > 3.times(&:my_multiplier)
0
66
132

这相当于打电话

3.times { |i| i.my_multiplier }

您还可以将您的

my_乘数

定义为proc或lambda

2.5.1 :001 > p = ->(i) { puts i * 66 }
 => #<Proc:0x00005582b3ae5638@(irb):1 (lambda)> 
2.5.1 :002 > 3.times(&p)
0
66
132

2.5.1:001>p=->（i）{put i*66}
=> # 
2.5.1:002>3.次（&p）
0
66
132

首先，语法是

&object

，而不是

&:

<代码>&对象调用

。对对象执行_proc

现在，假设您希望乘法器简单地将整数乘以66，您可以将其写成：

class Integer
  def my_multiplier
    puts 66 * self
  end
end

这将导致

2.5.1 :006 > 3.times(&:my_multiplier)
0
66
132

这相当于打电话

3.times { |i| i.my_multiplier }

您还可以将您的

my_乘数

定义为proc或lambda

2.5.1 :001 > p = ->(i) { puts i * 66 }
 => #<Proc:0x00005582b3ae5638@(irb):1 (lambda)> 
2.5.1 :002 > 3.times(&p)
0
66
132

2.5.1:001>p=->（i）{put i*66}
=> # 
2.5.1:002>3.次（&p）
0
66
132

尝试使用

return

而不是

put

。更改行为不称为重构。特别是，如果您的代码不工作，并且希望将其更改为工作状态，则这称为调试。请尝试使用

return

而不是

put

。更改行为不称为重构。特别是，如果您的代码不工作，并且您希望将其更改为工作，则这称为调试。当然，但是这个想法真的很难摆脱。我仍然认为这是“符号”。我不知道为什么。我理解，但在我看来这仍然很重要，特别是当你试图理解下面发生的事情时。我很困惑-

：

表示符号，

&

表示将块作为参数传递。如果这通常是正确的，

（&:my\u乘数）

实际上是。。嗯，我正要说

&Integer.to_proc

，但是obv.Integer是这里的类而不是对象。我很困惑。你能详细说明一下吗？当然，

&:my_multiplier

调用

到
：my_multiplier
上的\u proc

<代码>to_proc是在符号上定义的，用于简单地调用与符号同名的方法。调用

3.times（&:my_乘数）

相当于调用

3.times{i|i.my_乘数}

。我添加了一个示例，其中

my_multiplier

被定义为一个过程。“语法是&object，而不是&:”-是的。当然，但是这个想法真的很难摆脱。我仍然认为这是“符号”。我不知道为什么。我理解，但在我看来这仍然很重要，特别是当你试图理解下面发生的事情时。我很困惑-

：

表示符号，

&

表示将块作为参数传递。如果这通常是正确的，

（&:my\u乘数）

实际上是。。嗯，我正要说

&Integer.to_proc

，但是obv.Integer是这里的类而不是对象。我很困惑。你能详细说明一下吗？当然，

&:my_multiplier

调用

到
：my_multiplier
上的\u proc

<代码>to_proc是在符号上定义的，用于简单地调用与符号同名的方法。调用

3.times（&:my_乘数）

相当于调用

3.times{i|i.my_乘数}

。我添加了一个例子，其中

我的\u乘数

被定义为一个过程。你说得对。我想知道的是

self*2

。然而，你对另一个答案的评论让我更加困惑——为什么语法不是

&:

@Leron:看起来Marcin把解释钉在了那里。你说得对。我想知道的是

self*2

。然而，你对另一个答案的评论让我更加困惑——为什么语法不是

&:

@Leron:看起来Marcin在这里给出了解释。