类 & lt;< Ruby 中的自成语

class << self在 Ruby 中做什么?

答案

首先, class << foo语法打开foo的单例类(eigenclass)。这使您可以专门化在该特定对象上调用的方法的行为。

a = 'foo'
class << a
  def inspect
    '"bar"'
  end
end
a.inspect   # => "bar"

a = 'foo'   # new object, new singleton class
a.inspect   # => "foo"

现在,回答问题: class << self打开self的 singleton 类,以便可以为当前self对象(在类或模块体内的类或模块本身 )重新定义方法。通常,这用于定义类 / 模块(“静态”)方法:

class String
  class << self
    def value_of obj
      obj.to_s
    end
  end
end

String.value_of 42   # => "42"

这也可以写为速记:

class String
  def self.value_of obj
    obj.to_s
  end
end

甚至更短:

def String.value_of obj
  obj.to_s
end

在函数定义中, self指的是调用函数的对象。在这种情况下, class << self为该对象打开单例类;一种用途是实现穷人的状态机:

class StateMachineExample
  def process obj
    process_hook obj
  end

private
  def process_state_1 obj
    # ...
    class << self
      alias process_hook process_state_2
    end
  end

  def process_state_2 obj
    # ...
    class << self
      alias process_hook process_state_1
    end
  end

  # Set up initial state
  alias process_hook process_state_1
end

因此,在上面的示例中,每个StateMachineExample实例都将process_hook别名为process_state_1 ,但请注意,在后者中,它如何将process_hook (仅用于self ,不影响其他StateMachineExample实例)重新定义为process_state_2 。因此,每次调用者调用process方法(调用可重定义的process_hook )时,行为都会根据其所处的状态而变化。

我找到了关于class << selfEigenclass和不同类型的方法的超级简单的解释。

在 Ruby 中,可以将三种类型的方法应用于类:

  1. 实例方法
  2. 单例方法
  3. 类方法

实例方法和类方法几乎与其他编程语言中的同名方法相似。

class Foo  
  def an_instance_method  
    puts "I am an instance method"  
  end  
  def self.a_class_method  
    puts "I am a class method"  
  end  
end

foo = Foo.new

def foo.a_singleton_method
  puts "I am a singletone method"
end

访问Eigenclass (包括单例方法)的另一种方法是使用以下语法( class << ):

foo = Foo.new

class << foo
  def a_singleton_method
    puts "I am a singleton method"
  end
end

现在,您可以为self定义单例方法,在这种情况下,它是类Foo本身:

class Foo
  class << self
    def a_singleton_and_class_method
      puts "I am a singleton method for self and a class method for Foo"
    end
  end
end

通常,实例方法是全局方法。这意味着它们在定义它们的类的所有实例中都可用。相反,单例方法是在单个对象上实现的。

Ruby 将方法存储在类中,并且所有方法都必须与一个类相关联。定义单例方法的对象不是类(它是类的实例)。如果只有类可以存储方法,那么对象如何存储单例方法?创建单例方法时,Ruby 会自动创建一个匿名类来存储该方法。这些匿名类称为元类,也称为单例类或本征类。单例方法与元类相关联,而该元类又与在其上定义了单例方法的对象相关联。

如果在单个对象中定义了多个单例方法,则它们都将存储在同一元类中。

class Zen
end

z1 = Zen.new
z2 = Zen.new

class << z1
  def say_hello
    puts "Hello!"
  end
end

z1.say_hello    # Output: Hello!
z2.say_hello    # Output: NoMethodError: undefined method `say_hello'…

在上面的示例中,类 << z1 将当前自身更改为指向 z1 对象的元类;然后,它在元类中定义 say_hello 方法。

类也是对象(称为 Class 的内置类的实例)。类方法只不过是与类对象关联的单例方法。

class Zabuton
  class << self
    def stuff
      puts "Stuffing zabuton…"
    end
  end
end

所有对象都可以具有元类。这意味着类也可以具有元类。在上面的示例中,类 << self 修改 self,因此它指向 Zabuton 类的元类。如果在没有显式接收方的情况下定义方法(将在其上定义方法的类 / 对象),则会在当前范围(即 self 的当前值)内隐式定义该方法。因此,填充方法在 Zabuton 类的元类中定义。上面的示例只是定义类方法的另一种方法。恕我直言,最好使用 def self.my_new_clas_method 语法定义类方法,因为它使代码更易于理解。包括了上面的示例,因此我们了解了遇到类 << self 语法时发生的情况。

这篇关于 Ruby Classes 的文章中可以找到更多信息。

什么类 << 事情做什么:

class Hi
  self #=> Hi
  class << self #same as 'class << Hi'
    self #=> #<Class:Hi>
    self == Hi.singleton_class #=> true
  end
end

[ 在其块的上下文 self == thing.singleton_class ]


什么是 thing.singleton_class?

hi = String.new
def hi.a
end

hi.class.instance_methods.include? :a #=> false
hi.singleton_class.instance_methods.include? :a #=> true

hi对象从#singleton_class.instance_methods继承其#methods ,然后从其#class.instance_methods
在这里,我们给出了hi单例类实例方法:a 。可以用类 << hi代替。
hi#singleton_class具有所有实例方法hi#class具有,并且可能还有更多的实例方法( :a在这里)。

[事物的 #class #singleton_class 实例方法 可以直接应用于事物。当 ruby 看到 thing.a 时,首先在 thing.singleton_class.instance_methods 中然后在 thing.class.instance_methods 中寻找方法定义]


顺便说一句 - 他们称呼对象的单例类 == 元类 == 本

singleton 方法是仅针对单个对象定义的方法。

例:

class SomeClass
  class << self
    def test
    end
  end
end

test_obj = SomeClass.new

def test_obj.test_2
end

class << test_obj
  def test_3
  end
end

puts "Singleton's methods of SomeClass"
puts SomeClass.singleton_methods
puts '------------------------------------------'
puts "Singleton's methods of test_obj"
puts test_obj.singleton_methods

SomeClass 的 Singleton 方法

测试


Singleton 的 test_obj 方法

测试_2

test_3

实际上,如果您为 Ruby 项目编写任何 C 扩展,则实际上只有一种定义 Module 方法的方法。

rb_define_singleton_method

我知道这种自我交易只会带来其他各种问题,因此您可以通过搜索每个部分来做得更好。

首先对象。

foo = Object.new

我可以为 foo 创建方法吗?

当然

def foo.hello
 'hello'
end

我该怎么办?

foo.hello
 ==>"hello"

只是另一个对象。

foo.methods

您将获得所有 Object 方法以及新方法。

def foo.self
 self
end

foo.self

只是 foo 对象。

尝试看看如果从其他对象(如类和模块)中创建 foo 会发生什么。来自所有答案的示例都很好玩,但是您必须使用不同的想法或概念才能真正理解代码编写方式所发生的事情。因此,现在您有很多术语需要研究。

出现了 Singleton,Class,Module,self,Object 和 Eigenclass,但是 Ruby 并没有这样命名对象模型。它更像元类。理查德(Richard)或__为什么在这里展示您的想法。 http://viewsourcecode.org/why/hacking/seeingMetaclassesClearly.html如果让您大吃一惊,请尝试在搜索中查找 Ruby Object Model。我在 YouTube 上知道的两个视频是 Dave Thomas 和 Peter Cooper。他们也试图解释这个概念。戴夫花了很长时间才得到它,所以不用担心。我也还在努力。我为什么还要在这里?感谢您的提问。还要看一下标准库。与 FYI 一样,它具有一个 Singleton 模块。

很好https://www.youtube.com/watch?v=i4uiyWA8eFk