类<< Ruby 中的自我习语

Question

class << 是什么意思？ self 在 Ruby 中做什么？

Answer 1

首先，类<< 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 的单例类，以便可以为当前 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）时，行为都会根据其所处的状态而变化。

Answer 2

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

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

1. 实例方法
2. Singleton 方法
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

Answer 3

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

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'…

在上面的例子中，class << z1 改变当前的 self 指向 z1 对象的元类；然后，它在元类中定义 say_hello 方法。

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

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

所有对象都可能有元类。这意味着类也可以有元类。在上面的例子中，class << self 修改 self，使其指向 Zabuton 类的元类。当一个方法在没有显式接收者（将在其上定义该方法的类/对象）的情况下定义时，它会在当前范围内隐式定义，即 self 的当前值。因此，stuff 方法是在 Zabuton 类的元类中定义的。上面的示例只是定义类方法的另一种方式。恕我直言，最好使用 def self.my_new_clas_method 语法来定义类方法，因为它使代码更容易理解。包含上面的示例是为了让我们了解当我们遇到类 << 时会发生什么。自我语法。

其他信息可以在这篇关于 Ruby 类的文章中找到。

Answer 4

什么类<< thing 的作用是：

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 继承。< br>
这里我们给出了hi的单例类实例方法:a。这可以通过 class << 来完成。嗨。
hi 的 #singleton_class 具有 hi 的 #class 具有的所有实例方法，可能还有更多 (<代码>：a此处）。

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

---

顺便说一下 - 他们调用对象的单例类 == 元类 == 特征类。

Answer 5

单例方法是仅为单个对象定义的方法。

示例：

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 方法

test

---

test_obj 的 Singleton 方法

test_2

test_3 >

Answer 6

事实上，如果您为 Ruby 项目编写任何 C 扩展，那么实际上只有一种方法来定义 Module 方法。

rb_define_singleton_method

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

先有对象。

foo = Object.new

我可以为 foo 创建一个方法吗？

当然

def foo.hello
 'hello'
end

我该怎么办？

foo.hello
 ==>"hello"

只是另一个对象。

foo.methods

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

def foo.self
 self
end

foo.self

只是 foo 对象。

尝试看看如果您从其他对象（例如类和模块）创建 foo 会发生什么。所有答案中的示例都很好用，但您必须使用不同的想法或概念才能真正理解代码的编写方式发生了什么。现在您有很多术语需要查看。

单例，
班级，
模块，
自己，
目的，
Eigenclass 被提出，但 Ruby 并没有这样命名对象模型。它更像是元类。
理查德或 __why 在这里向您展示这个想法。
http://viewsourcecode.org/why/hacking/seeingMetaclassesClearly.html
如果这让您大吃一惊，请尝试在搜索中查找 Ruby 对象模型。
我在 YouTube 上知道的两个视频是 Dave Thomas 和 Peter Cooper。他们也试图解释这个概念。戴夫花了很长时间才拿到它，所以不用担心。
我也在努力。不然我为什么会在这里？
谢谢你的提问。
另请查看标准库。它有一个单例模块（仅供参考）。

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