Klasse & lt; & lt; Selbst vs Selbst. Methode mit Ruby: Was ist besser?

Diese Ruby Style Guide sagt, dass ist besser mit self.method_name statt class method_name. Aber Warum?

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

Gibt es performance-Probleme?

InformationsquelleAutor der Frage Mich Dart | 2012-06-09

ruby

76

class << self ist gut beim halten Sie alle, Ihre Klasse zu Methoden in der gleichen block. Wenn Methoden hinzu kommen, in def self.method ab dann gibt es keine Garantie (außer übereinkommen und Wunschdenken), dass es nicht eine extra Methode der Klasse versteckt, die später in der Datei.

def self.method ist gut, die explizit besagt, dass eine Methode ist eine Methode der Klasse, in der Erwägung, dass mit class << self Sie haben zu gehen und finden Sie die container selbst.

Welche dieser ist mehr wichtig, Sie ist eine subjektive Entscheidung und hängt auch davon ab, wie viele andere Menschen sind an dem code und was Ihre Vorlieben sind.

InformationsquelleAutor der Antwort Gareth
28

Generell class << self verwendet wird, in metaprogramming um die Klasse als selbst für einen längeren Zeitraum. Wenn ich versuche zu schreiben, die 10 Methoden, ich würde es gerne so:
```
METHOD_APPENDICES = [1...10]
class << self
  METHOD_APPENDICES.each do |n|
    define_method("method#{n}") { n }
  end
end
```
Dies schaffen würde 10 Methoden (method1, method2, Methode3, etc.) das würde einfach nur wieder die Nummer. Ich würde class << self für Klarheit in diesem Fall, da in metaprogramming self ist entscheidend. Littering self. im inneren würde es tatsächlich machen Dinge weniger lesbar.

Wenn Sie nur die Definition der Klasse Methoden normalerweise, halten Sie sich an self.class_method_name weil mehr Menschen sind wahrscheinlich, um es zu verstehen. Keine Notwendigkeit zu bringen, die sich in meta-syntax, es sei denn, Sie erwarten, dass Ihr Publikum, um es zu verstehen.

InformationsquelleAutor der Antwort Chris
19

Wie oben erwähnt, beide Stile zu sein scheinen gleichwertig, aber mit class << self erlaubt es, die Marke-Klasse Methoden als private oder protected. Zum Beispiel:
```
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 betrifft nur Instanz-Methoden. Die Verwendung der singleton-Klasse, wir sind die Instanz-Methoden der Klasse, die wiederum in der Klasse Methoden der übergeordneten Klasse!

Können wir auch mark-Klasse Methoden als private mit 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
```
Aber wir können nicht markieren Sie als protected gibt es keine protected_class_method. (Da jedoch Klasse ist die einzige Instanz seiner singletonclass, private Methode der Klasse und der Klasse geschützt-Methoden sind fast die gleichen, außer Ihre Aufruf-syntax ist anders.)

Es ist auch weniger einfacher als mit class << self zu markieren private Klasse Methoden, da haben Sie, um eine Liste aller Methodennamen in private_class_method oder Präfix private_class_method um alle privaten Klasse-Methode-definition.

InformationsquelleAutor der Antwort Jonathan O'Connor
5

Ich gehe davon aus, dass Sie denken self.* ist besser, da können Sie sicher sagen, es ist eine Klasse oder eine Instanz-Methode, ohne scrollen nach oben und Suche von Inhalten dieser class << self string.

InformationsquelleAutor der Antwort Flexoid
3

Je nachdem, was Sie wollen. Beide sind sehr klar, was Sie tun. Aber ich denke, einige Empfehlungen für diese.

Wenn es nur die eine Klasse Methode, um zu definieren, Verwenden def self.xxx. Da für die Definition nur eine Methode, die zunehmend Einzug wahrscheinlich zu überladen.

Wenn es sind mehr als einer Klasse in der Methode zu definieren, Verwenden class << self. Weil das schreiben def self.xxxdef self.yyy und def self.zzz ist sicherlich die Wiederholung. Erstellen Sie einen Abschnitt für diese Methoden.

Wenn alle Methoden in einer Klasse werden-Klasse Methode, können Sie module mit module_function statt class. Diese ermöglichen die Definition von Modul-Funktionen nur verwenden def xxx.

InformationsquelleAutor der Antwort nonowarn
-1

Bisher die Frage und die Antworten nur diskutieren, diese zwei Optionen:
```
class MyClass
  def self.method_name
    ..
  end
end

class MyClass
  class << self
    def method_name
      ..
    end
  end
end
```
Aber hier ist eine andere option zu prüfen, für die Klasse Methoden /singleton-Methoden /statische Methoden Methoden, die auf der class-Ebene (oder was auch immer Sie wollen, Sie zu nennen):
```
class MyClass
  def MyClass.method_name
    ..
  end
end
```
Ich bevorzugen diese option, weil es mehr offensichtlich, was es tut. Die Methodendefinition sieht genauso aus, wie es heißen würde, in Ihrem code, und es ist klar, es funktioniert auf Klassenebene.

Ich komme auch aus einem Python-hintergrund, wo self verwendet wird, zum Beispiel Methoden, in der Erwägung, dass in Ruby self ist für Klassenmethoden. Diese oft verwirrt mich, so zu vermeiden, denken "ist ein self-Methode in Ruby, eine Klasse oder eine Instanz-Methode?" Ich benutze def ClassName.methodname.

InformationsquelleAutor der Antwort Dennis

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.