类定义中的方法调用? [英] Method invocation in class definition?

问题描述

class Person < ActiveRecord::Base
  validates :terms_of_service, :acceptance => true
end

在上面，从 Ruby 的角度来看，validates 是什么?它不是方法定义，也不是数据定义或声明.所以，显然它是一个方法调用，就在类的主体中.我从未见过直接在类中调用这样的方法(即在方法定义之外)，即使在我现在正在阅读的 Ruby 编程教程中也没有:http://ruby-doc.org/docs/ProgrammingRuby/.

In the above, what is validates from a Ruby standpoint? It's not a method definition, it's not a data definition or declaration. So, evidently it's a method invocation, right there in the body of the class. I have never seen a method invoked like that directly in a class (i.e. outside of a method definition), not even in the Ruby programming tutorial I'm going through now: http://ruby-doc.org/docs/ProgrammingRuby/.

那么，如果它是一个方法调用，它是在什么时候被调用的?我尝试了以下测试:

So, if it's a method invocation, at what point is it being invoked? I tried the following as a test:

class Person   

  print "cat"
    
end

#p = Person.new
#q = Person.new

print "cat" 只执行一次，不管是否声明了任何实际的 Person 对象，所以很明显，在解析类定义时，Ruby 看到方法 print 并说，好的，我现在就继续执行这个"；但再也不会这样做了.

print "cat" is being executed exactly once, regardless if any actual Person objects are being declared or not, so evidently just when parsing the class definition, Ruby sees the method print and says, "OK I will just go ahead and execute this now" but never does so again.

那么，可以帮助我了解上述 validates 发生了什么的 Ruby 文档在哪里?

So, where is the Ruby documentation that will help me understand what is going on with validates above?

推荐答案

在 Ruby 中，类声明只是按顺序执行的代码块.

In Ruby, class declarations are just chunks of code, executed in order.

重要的是要记住，在类定义中，self 指向类本身.validates 是ActiveRecord 的一个类方法.在定义类时，会执行定义中的代码.validates 方法解析为ActiveRecord 的类方法，因此在类定义期间被调用.

It's important to remember that inside a class definition, self points to the class itself. validates is a class method of ActiveRecord. As the class is being defined, code in the definition is executed. The validates method resolves to a class method of ActiveRecord, so is called during class definition.

在您的 Person 示例中，它只会打印一次，因为您只定义了一次类.

In your Person example, it will only print once, because you only define the class once.

考虑以下事项:

class Foo
  def self.validates_nothing(sym)
    (@@syms ||= []) << sym
    puts "!!! Here there be logic"
  end

  def validate
    @@syms.each { |s| puts s }
  end
end

这定义了一个具有类方法 validates_nothing 和实例方法 validate 的类.validates_nothing 只是收集给它的任何参数，validate 只是将它们转储出来.

This defines a class with a class method validates_nothing, and an instance method, validate. validates_nothing just gathers whatever arguments are given it, validate just dumps them out.

class Bar < Foo
  validates_nothing :anything
  validates_nothing :at_all
end

这定义了一个子类.请注意，当调用类方法 validates_nothing 时，它会打印:

This defines a subclass. Note that when the class method validates_nothing is called, it prints:

Here there be logic
Here there be logic

如果我们创建一个新的 bar 并调用 validate，我们会得到预期的输出:

If we create a new bar and call validate, we get the expected output:

> Bar.new.validate
!!!anything
!!!at_all

这篇关于类定义中的方法调用?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！