Ruby 在类中的方法中调用Proc时遇到问题

我正在努力调试我的问题；我试图在一个方法中使用Proc，所有这些都在一个类中。当我不输入“类”详细信息时，我的程序编译得很好；但是，当我指定类名时，会出现各种不同的错误

注意：我在CodeReview.StackExchange.com上发布了这个问题，但它偏离了主题；mods（？）建议我在这里提问

背景。以下是我收到的提示，直接取自：

祖父钟。编写一个方法，该方法接受一个块，并在今天每过一小时调用一次。那样的话，如果我在街区里通过的话，就把“叮！”最后，它会（有点）像一个外祖父的钟一样发出钟声。用几个不同的块（包括我刚才给你的块）测试你的方法。提示：您可以使用

Time.now.hour

获取当前小时。但是，这将返回一个介于0和23之间的数字，因此您必须更改这些数字才能获得普通的时钟面数字（1到12）

有效的代码：

def hourlyRing ring
    time = Time.now.hour%12;
    hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
    (hour_set[time].to_i).times do 
        ring.call
    end
end

ring = Proc.new do 
    puts 'DING!'
end 

hourlyRing ring

class GrandfatherClock  

    def hourlyRing ring
        time = Time.now.hour%12;
        hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
        (hour_set[time].to_i).times do 
            ring.call
        end
    end

    ring = Proc.new do 
        puts 'DING!'
    end 
end

# Here's where I try to call it:
ringtime = GrandfatherClock.new
ringtime.hourlyRing ring

它产生以下输出（正确，因为这里是下午4点）：

不起作用的代码：

def hourlyRing ring
    time = Time.now.hour%12;
    hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
    (hour_set[time].to_i).times do 
        ring.call
    end
end

ring = Proc.new do 
    puts 'DING!'
end 

hourlyRing ring

class GrandfatherClock  

    def hourlyRing ring
        time = Time.now.hour%12;
        hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
        (hour_set[time].to_i).times do 
            ring.call
        end
    end

    ring = Proc.new do 
        puts 'DING!'
    end 
end

# Here's where I try to call it:
ringtime = GrandfatherClock.new
ringtime.hourlyRing ring

---

有人能看到我代码中的错误吗？依我的拙见，这是一段足够短的代码，但我无法理解它为什么不能编译。也许我从根本上误解了一些关于Procs的事情，但我不明白到底是什么。提前谢谢。

这是关于上下文的。
在第二个示例中，您将ring proc放在类中，因此当您实际调用

ringtime.hourlyRing ring

时，该范围中没有定义ring

您可以将代码更改为：

class GrandfatherClock  

    def hourlyRing ring
        time = Time.now.hour%12;
        hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
        (hour_set[time].to_i).times do 
            ring.call
        end
    end
end

ring = Proc.new do 
   puts 'DING!'
end 

# Here's where I try to call it:
ringtime = GrandfatherClock.new
ringtime.hourlyRing ring

此外，问题陈述明确地询问您关于块的问题， 因此，小时数应该大致如下：

def hourlyRing
    time = Time.now.hour%12;
    hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
    (hour_set[time].to_i).times do 
        yield
    end
end

你可以这样称呼它：

hourlyRing { puts 'RING'}

或

---

这是关于上下文的。
在第二个示例中，您将ring proc放在类中，因此当您实际调用

ringtime.hourlyRing ring

时，该范围中没有定义ring

您可以将代码更改为：

class GrandfatherClock  

    def hourlyRing ring
        time = Time.now.hour%12;
        hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
        (hour_set[time].to_i).times do 
            ring.call
        end
    end
end

ring = Proc.new do 
   puts 'DING!'
end 

# Here's where I try to call it:
ringtime = GrandfatherClock.new
ringtime.hourlyRing ring

此外，问题陈述明确地询问您关于块的问题， 因此，小时数应该大致如下：

def hourlyRing
    time = Time.now.hour%12;
    hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
    (hour_set[time].to_i).times do 
        yield
    end
end

你可以这样称呼它：

hourlyRing { puts 'RING'}

或

---

这是关于上下文的。
在第二个示例中，您将ring proc放在类中，因此当您实际调用

ringtime.hourlyRing ring

时，该范围中没有定义ring

您可以将代码更改为：

class GrandfatherClock  

    def hourlyRing ring
        time = Time.now.hour%12;
        hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
        (hour_set[time].to_i).times do 
            ring.call
        end
    end
end

ring = Proc.new do 
   puts 'DING!'
end 

# Here's where I try to call it:
ringtime = GrandfatherClock.new
ringtime.hourlyRing ring

此外，问题陈述明确地询问您关于块的问题， 因此，小时数应该大致如下：

def hourlyRing
    time = Time.now.hour%12;
    hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
    (hour_set[time].to_i).times do 
        yield
    end
end

你可以这样称呼它：

hourlyRing { puts 'RING'}

或

---

这是关于上下文的。
在第二个示例中，您将ring proc放在类中，因此当您实际调用

ringtime.hourlyRing ring

时，该范围中没有定义ring

您可以将代码更改为：

class GrandfatherClock  

    def hourlyRing ring
        time = Time.now.hour%12;
        hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
        (hour_set[time].to_i).times do 
            ring.call
        end
    end
end

ring = Proc.new do 
   puts 'DING!'
end 

# Here's where I try to call it:
ringtime = GrandfatherClock.new
ringtime.hourlyRing ring

此外，问题陈述明确地询问您关于块的问题， 因此，小时数应该大致如下：

def hourlyRing
    time = Time.now.hour%12;
    hour_set =[12, 1, 2, 3, 4, 5, 6, 7, 8 , 9 , 10, 11];
    (hour_set[time].to_i).times do 
        yield
    end
end

你可以这样称呼它：

hourlyRing { puts 'RING'}

或

---

在第一个示例中，您已将proc分配给类外的变量

ring

，因此当您引用该变量时，该变量

ring

在范围内（即可见）

在第二个示例中，尽管仍将proc分配给名为

环的变量

，但该变量现在在

祖父时钟

类内声明，因此在该类外不再可见

您可以创建一个返回proc的函数，而不是将proc分配给变量：

class GrandfatherClock
    def hourlyRing ring
        time = Time.now.hour % 12
        hour_set = [12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
        (hour_set[time].to_i).times do
            ring.call
        end
    end

    def ring
        Proc.new do
            puts 'DING!'
        end
    end
end

# Here's where I try to call it:
ringtime = GrandfatherClock.new
ringtime.hourlyRing ringtime.ring

请注意，现在必须通过类的

ringtime

实例引用

ring

然而，这并不是问题描述真正想要的（我只是用它来说明发生了什么）。为了更符合问题描述，您需要在

hourlyRing

函数中使用

yield

来代替

ring.call

，然后在方法调用中传递一个块：

ringtime.hourlyRing do
    puts 'DING!'
end

---

在第一个示例中，您已将proc分配给类外的变量

ring

，因此当您引用该变量时，该变量

ring

在范围内（即可见）

在第二个示例中，尽管仍将proc分配给名为

环的变量

，但该变量现在在

祖父时钟

类内声明，因此在该类外不再可见

您可以创建一个返回proc的函数，而不是将proc分配给变量：

class GrandfatherClock
    def hourlyRing ring
        time = Time.now.hour % 12
        hour_set = [12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
        (hour_set[time].to_i).times do
            ring.call
        end
    end

    def ring
        Proc.new do
            puts 'DING!'
        end
    end
end

# Here's where I try to call it:
ringtime = GrandfatherClock.new
ringtime.hourlyRing ringtime.ring

请注意，现在必须通过类的

ringtime

实例引用

ring

然而，这并不是问题描述真正想要的（我只是用它来说明发生了什么）。为了更符合问题描述，您需要在

hourlyRing

函数中使用

yield

来代替

ring.call

，然后在方法调用中传递一个块：

ringtime.hourlyRing do
    puts 'DING!'
end

---

在第一个示例中，您已将proc分配给类外的变量

ring

，因此当您引用该变量时，该变量

ring

在范围内（即可见）

在第二个示例中，尽管仍将proc分配给名为

环的变量

，但该变量现在在

祖父时钟

类内声明，因此在该类外不再可见

您可以创建一个返回proc的函数，而不是将proc分配给变量：

class GrandfatherClock
    def hourlyRing ring
        time = Time.now.hour % 12
        hour_set = [12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
        (hour_set[time].to_i).times do
            ring.call
        end
    end

    def ring
        Proc.new do
            puts 'DING!'
        end
    end
end

# Here's where I try to call it:
ringtime = GrandfatherClock.new
ringtime.hourlyRing ringtime.ring

请注意，现在必须通过类的

ringtime

实例引用

ring

然而，这并不是问题描述真正想要的（我只是用它来说明发生了什么）。更符合问题描述