Ruby Class Methods vs. Methods in Eigenclasses

前端 未结 4 957
伪装坚强ぢ
伪装坚强ぢ 2021-02-19 08:17

Are class methods and methods in the eigenclass (or metaclass) of that class just two ways to define one thing?

Otherwise, what are the differences?

cla         


        
相关标签:
4条回答
  • 2021-02-19 08:21

    In Ruby there really are no such things as class methods. Since everything is an object in Ruby (including classes), when you say def self.class_method, you are just really defining a singleton method on the instance of the class Class. So to answer your question, saying

    class X
      def self.a
        puts "Hi"
      end
    
      class << self
        def b
          puts "there"
        end
      end
    end
    
    X.a # => Hi
    X.b # => there
    

    is two ways of saying the same thing. Both these methods are just singeton (eigen, meta, ghost, or whatever you want to call them) methods defined in the instance of your Class object, which in your example was X. This topic is part of metaprogramming, which is a fun topic, that if you have been using Ruby for a while, you should check out. The Pragmatic Programmers have a great book on metaprogramming that you should definitely take a look at if you interested in the topic.

    0 讨论(0)
  • 2021-02-19 08:27

    The two methods are equivalent. The 'eigenclass' version is helpful for using the attr_* methods, for example:

    class Foo
      @instances = []
      class << self;
        attr_reader :instances
      end
      def initialize
        self.class.instances << self
      end
    end
    
    2.times{ Foo.new }
    p Foo.instances
    #=> [#<Foo:0x2a3f020>, #<Foo:0x2a1a5c0>]
    

    You can also use define_singleton_method to create methods on the class:

    Foo.define_singleton_method :bim do "bam!" end
    
    0 讨论(0)
  • 2021-02-19 08:38

    Yet another necromancer here to unearth this old question... One thing you might not be aware of is that marking a class method as private (using the private keyword instead of :private_class_method) is different than marking an eigenclass method as such. :

    class Foo
      class << self
        def baz
          puts "Eigenclass public method."
        end
    
        private
        def qux
          puts "Private method on eigenclass."
        end
      end
      private
      def self.bar
        puts "Private class method."
      end
    end
    
    Foo.bar
    #=> Private class method.
    Foo.baz
    #=> Eigenclass public method.
    Foo.qux
    #=> NoMethodError: private method `qux' called for Foo:Class
    #   from (irb)
    

    The following example will work how the previous one intends:

    class Foo
      class << self
        def baz
          puts "Eigen class public method."
        end
    
        private
        def qux
          puts "Private method on eigenclass."
        end
      end
      def bar
        puts "Private class method."
      end
      private_class_method :bar
    end
    Foo.bar
    #=> NoMethodError: private method `bar' called for Foo:Class
    #     from (irb)
    Foo.baz
    #=> Eigen class public method.
    Foo.qux
    #=> NoMethodError: private method `qux' called for Foo:Class
    #     from (irb)
    
    0 讨论(0)
  • 2021-02-19 08:43

    Most instance methods used in Ruby are global methods. That means they are available in all instances of the class on which they were defined. In contrast, a singleton method is implemented on a single object.

    There is an apparent contradiction. Ruby stores methods in classes and all methods must be associated with a class. The object on which a singleton method is defined is not a class (it is an instance of a class). If only classes can store methods, how can an object store a singleton method? When a singleton method is created, Ruby automatically creates an anonymous class to store that method. These anonymous classes are called metaclasses, also known as singleton classes or eigenclasses. The singleton method is associated with the metaclass which, in turn, is associated with the object on which the singleton method was defined.

    If multiple singleton methods are defined within a single object, they are all stored in the same metaclass.

    class Zen
    end
    
    z1 = Zen.new
    z2 = Zen.new
    
    def z1.say_hello  # Notice that the method name is prefixed with the object name
      puts "Hello!"
    end
    
    z1.say_hello    # Output: Hello!
    z2.say_hello    # Output: NoMethodError: undefined method `say_hello'…
    

    In the above example, the say_hello method was defined within the z1 instance of the Zen class but not the z2 instance.

    The following example shows a different way to define a singleton method, with the same result.

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

    In the above example, class << z1 changes the current self to point to the metaclass of the z1 object; then, it defines the say_hello method within the metaclass.

    Both of the above examples serve to illustrate how singleton methods work. There is, however, an easier way to define a singleton method: using a built-in method called define_singleton_method.

    class Zen
    end
    
    z1 = Zen.new
    z2 = Zen.new
    
    z1.define_singleton_method(:say_hello) { puts "Hello!" }
    
    z1.say_hello    # Output: Hello!
    z2.say_hello    # Output: NoMethodError: undefined method `say_hello'…
    

    We learned earlier that classes are also objects (instances of the built-in class called Class). We also learned about class methods. Class methods are nothing more than singleton methods associated with a class object.

    One more example:

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

    All objects may have metaclasses. That means classes can also have metaclasses. In the above example, class << self modifies self so it points to the metaclass of the Zabuton class. When a method is defined without an explicit receiver (the class/object on which the method will be defined), it is implicitly defined within the current scope, that is, the current value of self. Hence, the stuff method is defined within the metaclass of the Zabuton class. The above example is just another way to define a class method.

    Read more at this post about Ruby Classes.

    0 讨论(0)
提交回复
热议问题