class << self vs self.method avec Ruby: quoi de mieux?

Question

Ce guide de style Ruby (https://github.com/styleguide/ruby) indique qu'il est préférable d'utiliser "self.method_name" au lieu de "class method_name". Mais pourquoi?

 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
 

Y a-t-il des problèmes de performance?

Answer 1

class << self est bon pour garder l'ensemble de vos méthodes de la classe dans le même bloc. Si les méthodes sont ajoutés en def self.method formulaire, puis il n'y a pas de garantie (autre que la convention et la pensée magique) qu'il n'y aura pas une méthode de la classe caché plus loin dans le fichier.

def self.method est bon en indiquant explicitement qu'une méthode est une méthode de classe, alors qu'avec class << self vous devez aller et de trouver le conteneur de vous-même.

Laquelle de ces est le plus important pour vous est une décision subjective, et dépend aussi des choses comme combien d'autres personnes travaillent sur le code et quelles sont leurs préférences.

Answer 2

Généralement, class << self est utilisé dans la métaprogrammation à l'ensemble de la classe en tant que soi-même pour une période de temps prolongée. Si je suis en train d'écrire 10 méthodes, je voudrais l'utiliser comme ceci:

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

Cela permettrait de créer 10 méthodes (method1, method2, method3, etc.) que serait-il suffit de retourner le nombre. Je voudrais utiliser class << self pour plus de clarté dans ce cas, parce que dans la métaprogrammation self est crucial. L'abandon de détritus self. à l'intérieur il y aurait réellement rendre les choses moins lisible.

Si vous êtes simplement à la définition des méthodes de la classe normalement, respectez - self.class_method_name parce que plus les gens sont susceptibles de la comprendre. Pas besoin de mettre dans les méta-syntaxe, sauf si vous vous attendez à ce que votre auditoire à comprendre.

Answer 3

Selon ce que vous voulez. Les deux sont très claires pour ce que vous faites. Mais je pense que certaines des recommandations à ce sujet.

Quand il y a une seule méthode de classe pour définir, Utiliser def self.xxx. Parce que pour la définition d'une seule méthode, en augmentant le niveau d'indentation probablement devenir de l'encombrer.

Quand il y a plus d'une méthode de classe pour définir, Utiliser class << self. Parce que l'écriture def self.xxx, def self.yyy et def self.zzz est certainement la répétition. Créer une section pour ces méthodes.

Lorsque toutes les méthodes dans une classe ou module de la méthode de classe et vous êtes à l'écriture d'un module, Vous pouvez utiliser extend self. Cela vous permet de définir les méthodes de la classe sans class << self ou def self.xxx mais il suffit d'utiliser def xxx.

Answer 4

Je suppose qu’ils pensent que self.* est meilleur parce que vous pouvez affirmer que c’est une méthode de classe ou d’instance, sans devoir faire défiler et rechercher cette chaîne class << self .