Ruby 我明白这一点吗；方法“；方法对吗？

在开始第2级时，我看到：

class Calculator
  def add(a, b)
    return a + b
  end
end

addition_method = Calculator.new.method("add")
addition        = addition_method.to_proc

puts addition.call(5, 6)

我以前从未见过

方法

，所以我咨询了

我现在的理解是：

如果你想从一个类中窃取一个方法，并将它变成一个

proc

（

lambda

？），你可以将

方法

粘贴在你想要的类方法的名称之前，然后用引号括起来或作为符号写入

---

这是正确的思考方式吗？或者它至少是

对象#方法的主要用途

？

我认为你的想法是正确的。更一般地说，

方法

方法只是一种将Ruby方法表示为的方法，因为对象是有用的，所以这可能有很多原因

在那个示例代码中有一些无关的东西。下面是另一个例子：

def add(a)
  a + a
end

m = method(:add)  # => #<Method: Object#add>
m.call(4)         # => 8

---

我认为你的想法是对的。更一般地说，

方法

方法只是一种将Ruby方法表示为的方法，因为对象是有用的，所以这可能有很多原因

在那个示例代码中有一些无关的东西。下面是另一个例子：

def add(a)
  a + a
end

m = method(:add)  # => #<Method: Object#add>
m.call(4)         # => 8

---

基本上是的。

method

方法允许您将方法及其接收器“打包”到类

method

的单个对象中。接收器是您在上调用的

.method

对象。

方法

对象也称为“绑定”方法，因为它绑定（附加）到接收器

例如：

class Car
  attr_accessor :make, :model

  def initialize(make, model)
    @make, @model = make, model
  end

  def drive(speed)
    puts "#{@make}-#{@model} drove with speed #{speed}"
  end
end

创建一个实例：

car1 = Car.new('Toyota', 'Corolla')

抓取方法并调用它：

car1drive = car1.method(:drive)
# Outputs "Toyota-Corolla drove with speed 5"
car1drive.call(5)

请注意，我们如何不必将其转换为

proc

，就可以对其使用

call

接收器绑定

为了演示该方法如何仍然绑定到其接收器，我们修改了接收器。请注意，

方法

仍然取决于它来自的对象。也就是说，创建

方法

不会对接收方的状态进行快照，而是在每次调用时咨询接收方

car1.model = 'Rav4'
# Outputs "Toyota-Rav4 drove with speed 5"
car1drive.call(5)

我们还可以检索接收器：

car1drive.receiver == car1  # true

作为块使用

它可以通过使用

&

（隐式调用

到_proc

）来代替块。这很好地工作，因为

每个

都为块生成一个参数，而我们的

car1drive

方法也接受一个参数

# Outputs:
# Toyota-Rav4 drove with speed 1
# Toyota-Rav4 drove with speed 2
# Toyota-Rav4 drove with speed 3
[1,2,3].each(&car1drive)

未绑定方法

我们还可以获得一个未绑定的方法，并将其绑定到另一个

Car

解除绑定

返回一个全新的

解除绑定方法

；它不会改变绑定方法

# This gives us an UnboundMethod.
# It can't be called; it's like a disembodied spirit.
# This doesn't change car1drive at all.
unbound_drive = car1drive.unbind

car2 = Car.new('Chevy', 'Cruze')
car2drive = unbound_drive.bind(car2)
# Outputs "Chevy-Cruze drove with speed 5"
car2drive.call(5)

您还可以通过直接使用

Car

类获得与上述相同的

UnboundMethod

：

unbound_drive = Car.instance_method(:drive)

调用已在子类中重写的超类方法

这里有一个很好的技巧可以用来调用重写的方法。假设您有一个子类重写了一个方法：

class Jalopy < Car
  def drive(speed)
    puts "The ailing #{@make}-#{@model} drove with speed #{speed}"
  end
end

jal1 = Jalopy.new('Toyota', 'Corolla')
# Outputs "The ailing Toyota-Corolla drove with speed 5"
jal1.drive(5)

# I don't like the overridden output, give me the original instead!
unbound_car_drive = Car.instance_method(:drive)
car_drive_on_jal1 = unbound_car_drive.bind(jal1)

# Outputs "Toyota-Corolla drove with speed 5"
car_drive_on_jal1.call(5)

classjalopy

我们之所以能够这样做，是因为

jal1

是

Car

（

jal1.is_a？（Car）

是

真的

）

---

我不建议在实际的应用程序中使用上述方法，因为这会使代码很难管理，但有时它有助于排除故障。

基本上是这样。

method

方法允许您将方法及其接收器“打包”到类

method

的单个对象中。接收器是您在上调用的

.method

对象。

方法

对象也称为“绑定”方法，因为它绑定（附加）到接收器

例如：

class Car
  attr_accessor :make, :model

  def initialize(make, model)
    @make, @model = make, model
  end

  def drive(speed)
    puts "#{@make}-#{@model} drove with speed #{speed}"
  end
end

创建一个实例：

car1 = Car.new('Toyota', 'Corolla')

抓取方法并调用它：

car1drive = car1.method(:drive)
# Outputs "Toyota-Corolla drove with speed 5"
car1drive.call(5)

请注意，我们如何不必将其转换为

proc

，就可以对其使用

call

接收器绑定

为了演示该方法如何仍然绑定到其接收器，我们修改了接收器。请注意，

方法

仍然取决于它来自的对象。也就是说，创建

方法

不会对接收方的状态进行快照，而是在每次调用时咨询接收方

car1.model = 'Rav4'
# Outputs "Toyota-Rav4 drove with speed 5"
car1drive.call(5)

我们还可以检索接收器：

car1drive.receiver == car1  # true

作为块使用

它可以通过使用

&

（隐式调用

到_proc

）来代替块。这很好地工作，因为

每个

都为块生成一个参数，而我们的

car1drive

方法也接受一个参数

# Outputs:
# Toyota-Rav4 drove with speed 1
# Toyota-Rav4 drove with speed 2
# Toyota-Rav4 drove with speed 3
[1,2,3].each(&car1drive)

未绑定方法

我们还可以获得一个未绑定的方法，并将其绑定到另一个

Car

解除绑定

返回一个全新的

解除绑定方法

；它不会改变绑定方法

# This gives us an UnboundMethod.
# It can't be called; it's like a disembodied spirit.
# This doesn't change car1drive at all.
unbound_drive = car1drive.unbind

car2 = Car.new('Chevy', 'Cruze')
car2drive = unbound_drive.bind(car2)
# Outputs "Chevy-Cruze drove with speed 5"
car2drive.call(5)

您还可以通过直接使用

Car

类获得与上述相同的

UnboundMethod

：

unbound_drive = Car.instance_method(:drive)

调用已在子类中重写的超类方法

这里有一个很好的技巧可以用来调用重写的方法。假设您有一个子类重写了一个方法：

class Jalopy < Car
  def drive(speed)
    puts "The ailing #{@make}-#{@model} drove with speed #{speed}"
  end
end

jal1 = Jalopy.new('Toyota', 'Corolla')
# Outputs "The ailing Toyota-Corolla drove with speed 5"
jal1.drive(5)

# I don't like the overridden output, give me the original instead!
unbound_car_drive = Car.instance_method(:drive)
car_drive_on_jal1 = unbound_car_drive.bind(jal1)

# Outputs "Toyota-Corolla drove with speed 5"
car_drive_on_jal1.call(5)

classjalopy

我们只能这样做，因为

jal1

是<