其实回字有7种写法...

来说说ruby里面定义类方法的区别：

class T
  def T.class_method1
    #第一种
  end
 class << self
   def class_method2
     #第二种
   end
  end
  def self.class_method3
    #第三种
  end
end


def T.class_method4
  #第四种
end


T.class_eval do
  def T.class_method5
    #第五种
  end
  def self.class_method6
    #第六种
  end
end
class Object
  # The hidden singleton lurks behind everyone
  def metaclass; class << self; self; end; end
  def meta_eval &blk; metaclass.instance_eval &blk; end
  # Adds methods to a metaclass
  def meta_def name, &blk
    meta_eval { define_method name, &blk }
  end
end
T.meta_def :class_method7 do 
  #第七种
end
p T.singleton_methods.sort#["class_method1", "class_method2", "class_method3", "class_method4", "class_method5", "class_method6", "class_method7", "yaml_tag_subclasses?"]

 

区别：个人感觉用元编程方式定义的更动态一些灵活一些（丫的，废话！不动态不灵活还算是元编程吗）

还有就是用第二种（class << self ）可以实现更多的功能

比如有人说类方法都是public的，还比如有人说类方法不能用别名...

其实用class << self 这种形式是可以实现的，下面看两个例子:

1.

 

class TT #很YD的类名...
  class << self
    private
    def private_class_method
      #这个有啥用？鬼知道有啥用！
    end
  end
end
TT.private_class_method# private method `private_class_method' called for TT:Class (NoMethodError)

 

 

2.

 

class TT#再YD一次..
  class <<self
    def class_m
      puts "class method"
    end
    alias alias_class_m class_m
  end
end
TT.alias_class_m#class method

 终上所述，如果要动态添加或改变class method的时候用元编程，正常情况下用class << self这种形式。。

 

 

 

评论

4 楼 night_stalker 2009-05-07  

ychael 写道

lambda{|x|
    lambda{|y|
        lambda{|z|
                  x+y+z
}}}

1.9 用：

-> z, y, x {x + y + z}.curry

3 楼 ychael 2009-05-07  

lambda{|x|
    lambda{|y|
        lambda{|z|
                  x+y+z
}}}

2 楼 Hooopo 2009-05-05  

引用

private 的类方法可以被 protected 和 public 类方法调用，也可以用 __send__ 调用，不能被子类的各种方法调用（可惜类的 meta class 无法子类化 -__-），所以还是有用的……

也可以被private的类方法调用，也可以被子类的类方法调用...看下面代码：

class TT 
  class << self
    private
    def private_class_method
      puts "private class method of TT"
    end
    def call_private_class_method
      private_class_method
    end
  end
end
class TTT < TT
  class << self
    def m
      private_class_method
    end
  end
end
TT.send(:call_private_class_method)#原来private method可以被send调用呀，有点晕+_+
#private class method of TT
TTT.m
#private class method of TT

引用

还有一种定义类方法的方法…… 误伤面积有点大……：

class Class
  def xxx
    #...
  end
end

额，Class的instance method变成了所有class的class method...

引用

btw，在方法里定义方法也是可以的，这样一来我们就可以实现一个流式契约：
假设要求调用 A.b 之前必须调用一次 A.a，调用 A.c 之前必须调用一次 A.b，那么可以这样写：

class A
  class << self
    def a
      def b
        def c
          'c'
        end
        'b'
      end
      'a'
    end
  end
end

如果调用不满足顺序要求，就会出现 'undefined method' 的 error

这个好神奇...

1 楼 night_stalker 2009-05-04  

private 的类方法可以被 protected 和 public 类方法调用，也可以用 __send__ 调用，不能被子类的各种方法调用（可惜类的 meta class 无法子类化 -__-），所以还是有用的……

还有一种定义类方法的方法…… 误伤面积有点大……：

class Class
  def xxx
    #...
  end
end

btw，在方法里定义方法也是可以的，这样一来我们就可以实现一个流式契约：
假设要求调用 A.b 之前必须调用一次 A.a，调用 A.c 之前必须调用一次 A.b，那么可以这样写：

class A
  class << self
    def a
      def b
        def c
          'c'
        end
        'b'
      end
      'a'
    end
  end
end

如果调用不满足顺序要求，就会出现 'undefined method' 的 error