class << self vs self.method with Ruby: qué hay mejor?

Question

Esto Ruby Style Guide dice que es mejor usar self.method_name en lugar de class method_name. ¿Pero por qué?

class TestClass 
    # bad 
    class << self 
    def first_method 
     # body omitted 
    end 

    def second_method_etc 
     # body omitted 
    end 
    end 

    # good 
    def self.first_method 
    # body omitted 
    end 

    def self.second_method_etc 
    # body omitted 
    end 
end 

¿Hay problemas de rendimiento?

Answer 1

class << self es bueno para mantener todos los métodos de su clase en el mismo bloque. Si se agregan métodos en def self.method a partir de entonces, no hay garantía (aparte de la convención y las ilusiones) de que no habrá un método de clase adicional guardado más adelante en el archivo.

def self.method es bueno para indicar explícitamente que un método es un método de clase, mientras que con class << self tiene que ir y buscar el contenedor usted mismo.

Cuál de estos es más importante para usted es una decisión subjetiva, y también depende de cosas como cuántas personas están trabajando en el código y cuáles son sus preferencias.

Answer 2

Supongo que piensan que self.* es mejor porque se puede decir con certeza, es un método de clase o instancia, sin tener que desplazarse hacia arriba y buscar esta cadena class << self.

Answer 3

En general, class << self se utiliza en la metaprogramación para establecer la clase como propia por un período de tiempo prolongado. Si estoy tratando de escribir 10 métodos, lo usaría así:

METHOD_APPENDICES = [1...10] 
class << self 
    METHOD_APPENDICES.each do |n| 
    define_method("method#{n}") { n } 
    end 
end 

Esto crearía 10 métodos (metodo1, metodo2, metodo3, etc.) que acaba de devolver el número. Yo usaría class << self para mayor claridad en este caso porque en la metaprogramación self es crucial. Tirar basura en self. dentro realmente haría que las cosas menos legibles.

Si solo está definiendo los métodos de clase normalmente, adhiérase a self.class_method_name porque es probable que más personas lo entiendan. No es necesario incluir meta-sintaxis a menos que espere que su audiencia lo entienda.

Answer 4

Cualquiera que usted quiera. Ambos son muy claros para lo que haces. Pero pienso en algunas recomendaciones para esto.

Cuando solo hay un método de clase para definir, Utilice def self.xxx. Porque para definir solo un método, aumentar el nivel de sangría probablemente se vuelva abigarrado.

Cuando hay más de un método de clase para definir, Use class << self. Porque escribir def self.xxx, def self.yyy y def self.zzz es sin duda la repetición. Crea una sección para estos métodos.

Cuando todos los métodos en una clase son método de clase, puede utilizar module con module_function en lugar de class. Esto le permite definir las funciones del módulo simplemente use def xxx.

Answer 5

Como se señaló anteriormente, ambos estilos parecen ser equivalentes, sin embargo, usar class << self permite marcar los métodos de clase como private o protected.Por ejemplo:

class UsingDefSelf 
    def self.a; 'public class method'; end 
    private 
    def self.b; 'public class method!'; end 
end 

class UsingSingletonClass 
    class << self 
    def a; 'public class method'; end 
    private 
    def b; 'private class method'; end 
    end 
end 

private solo afecta a los métodos de instancia. Usando la clase singleton, estamos definiendo métodos de instancia de esa clase, que se convierten en métodos de clase de la clase contenedora.

También puede marcar los métodos de clase como private con def self:

class UsingDefSelf 
    def self.a; 'private class method'; end 
    def self.b; 'private class method!'; end 
    private_class_method :a, :b 
    # In Ruby 2.1 there is an alternative syntax 
    private_class_method def self.c; 'private class method!'; end 
end 

, pero no podemos marcarlos como protected, no hay protected_class_method. (Sin embargo, ya que la clase es el único caso de su SingletonClass, método de clase privada y métodos de clases protegidas son casi los mismos, excepto su llamado sintaxis es diferente.)

También es menos fácil que usar class << self para marcar private métodos de clase, ya que tiene que enumerar todos los nombres de métodos en private_class_method o prefijo private_class_method a cada definición de método de clase privada.

Answer 6

Hasta ahora, la pregunta y las respuestas sólo se discuten estas dos opciones:

class MyClass 
    def self.method_name 
    .. 
    end 
end 

class MyClass 
    class << self 
    def method_name 
     .. 
    end 
    end 
end 

Pero aquí hay otra opción a considerar para los métodos de la clase/métodos simples/métodos estáticos/métodos que operan en el nivel de clase (o cualquier otra cosa al que desea llamar ellos):

class MyClass 
    def MyClass.method_name 
    .. 
    end 
end 

prefiero esta opción porque es más evidente lo que hace. La definición del método se asemeja a cómo se llamaría en su código, y está claro que opera en el nivel de clase.

También provengo de un fondo de Python donde self se usa por ejemplo en métodos, mientras que en Ruby, self se usa para métodos de clase. Esto a menudo me confunde, así que para evitar pensar "¿es un método propio en Ruby una clase o método de instancia?" Yo uso def ClassName.methodname.