Private Modulmethoden in Ruby

Ich habe eine zweiteilige Frage

Beste Übung

• Ich habe einen Algorithmus, der eine Operation an einer Datenstruktur unter Verwendung der öffentlichen Schnittstelle ausführt
• Derzeit handelt es sich um ein Modul mit zahlreichen statischen Methoden, die bis auf die eine öffentliche Schnittstellenmethode alle privat sind.
• Es gibt eine Instanzvariable, die von allen Methoden gemeinsam genutzt werden muss.

Dies sind die Optionen, die ich sehen kann, welche sind die besten?:

• Modul mit statischen Methoden ('Modul' in Ruby)
• Klasse mit statischen Methoden
• Mixin- Modul zur Aufnahme in die Datenstruktur
• Refaktorieren Sie den Teil des Algorithmus, der diese Datenstruktur ändert (sehr klein), und machen Sie daraus ein Mixin, das die statischen Methoden des Algorithmusmoduls aufruft

Technischer Bereich

Gibt es eine Möglichkeit, eine private Modulmethode zu erstellen ?

module Thing
  def self.pub; puts "Public method"; end
  private
  def self.priv; puts "Private method"; end
end

Das privatedrin scheint keine Wirkung zu haben , ich kann trotzdem Thing.privohne Probleme anrufen .

Ich denke, der beste Weg (und vor allem, wie vorhandene Bibliotheken geschrieben werden), dies zu tun, besteht darin, eine Klasse innerhalb des Moduls zu erstellen, die sich mit der gesamten Logik befasst, und das Modul bietet nur eine bequeme Methode, z

module GTranslate
  class Translator
    def perform( text ); translate( text ); end

    private

    def translate( text )
      # do some private stuff here
    end
  end

  def self.translate( text )
    t = Translator.new
    t.perform( text )
  end
end

Es gibt auch Module.private_class_method, was wohl mehr Absicht ausdrückt.

module Foo
  def self.included(base)
    base.instance_eval do
      def method_name
        # ...
      end
      private_class_method :method_name
    end
  end
end

Für den Code in der Frage:

module Thing
  def self.pub; puts "Public method"; end
  def self.priv; puts "Private method"; end
  private_class_method :priv
end

Ruby 2.1 oder neuer:

module Thing
  def self.pub; puts "Public method"; end
  private_class_method def self.priv; puts "Private method"; end
end

module Writer
  class << self
    def output(s)
      puts upcase(s)
    end

    private

    def upcase(s)
      s.upcase
    end
  end
end

Writer.output "Hello World"
# -> HELLO WORLD

Writer.upcase "Hello World"
# -> so.rb:16:in `<main>': private method `upcase' called for Writer:Module (NoMethodError)

Sie können die "eingeschlossene" Methode verwenden, um ausgefallene Dinge zu tun, wenn ein Modul eingemischt wird. Dies bewirkt, was Sie wollen, denke ich:

module Foo
  def self.included(base)
    class << base 
      def public_method
        puts "public method"
      end
      def call_private
        private_method
      end
      private
      def private_method
        puts "private"
      end
    end
  end
end

class Bar
  include Foo
end

Bar.public_method

begin
  Bar.private_method
rescue
  puts "couldn't call private method"
end

Bar.call_private

privateGilt leider nur für Instanzmethoden. Der allgemeine Weg, um private "statische" Methoden in einer Klasse zu erhalten, besteht darin, Folgendes zu tun:

class << self
  private

  def foo()
   ....
  end
end

Zugegeben, ich habe damit nicht in Modulen gespielt.

Ein schöner Weg ist so

module MyModule
  class << self
    def public_method
      # you may call the private method here
      tmp = private_method
      :public
    end

    private def private_method
      :private
    end
  end
end

# calling from outside the module
puts MyModule::public_method

Was ist mit dem Speichern von Methoden als Lambdas in Klassenvariablen / Konstanten?

module MyModule
  @@my_secret_method = lambda {
    # ...
  }
  # ...
end

Zum Test:
UPD: Eine große Aktualisierung dieses Codes nach 6 Jahren zeigt eine sauberere Möglichkeit, eine private Methode zu deklarierend

module A
  @@L = lambda{ "@@L" }
  def self.a ; @@L[] ; end
  def self.b ; a ; end

  class << self
    def c ; @@L[] ; end
    private
    def d ; @@L[] ; end
  end
  def self.e ; c ; end
  def self.f ; self.c ; end
  def self.g ; d ; end
  def self.h ; self.d ; end

  private
  def self.i ; @@L[] ; end
  class << self
    def j ; @@L[] ; end
  end

  public
  def self.k ; i ; end
  def self.l ; self.i ; end
  def self.m ; j ; end
  def self.n ; self.j ; end
end

for expr in %w{ A.a A.b A.c A.d A.e A.f A.g A.h A.i A.j A.k A.l A.m A.n }
  puts "#{expr} => #{begin ; eval expr ; rescue => e ; e ; end}"
end

Hier sehen wir das:

A.a => @@L
A.b => @@L
A.c => @@L
A.d => private method `d' called for A:Module
A.e => @@L
A.f => @@L
A.g => @@L
A.h => private method `d' called for A:Module
A.i => @@L
A.j => @@L
A.k => @@L
A.l => @@L
A.m => @@L
A.n => @@L

1) @@Lkann nicht von außen aufgerufen werden, ist aber von fast überall zugänglich
2) class << self ; private ; defmacht die Methode dvon außen und von innen erfolgreich unzugänglich mit - self.aber nicht ohne - das ist seltsam
3) private ; self.und private ; class << selfmacht Methoden nicht privat - sie sind beide zugänglich mit und ohneself.

Erstellen Sie ein privates Modul oder eine Klasse

Konstanten sind niemals privat. Es ist jedoch möglich, ein Modul oder eine Klasse zu erstellen, ohne sie einer Konstanten zuzuweisen.

Eine Alternative dazu :private_class_methodbesteht darin, ein privates Modul oder eine Klasse zu erstellen und öffentliche Methoden darauf zu definieren.

module PublicModule
  def self.do_stuff(input)
    @private_implementation.do_stuff(input)
  end

  @private_implementation = Module.new do
    def self.do_stuff(input)
      input.upcase # or call other methods on module
    end
  end
end

Verwendung:

PublicModule.do_stuff("whatever") # => "WHATEVER"

Siehe die Dokumente für Module.new und Class.new .

Diese Methode erlaubt keine gemeinsame Nutzung von Daten mit den privaten Methoden, es sei denn, Sie übergeben die Daten explizit an Methodenparameter.

module Thing
  extend self

  def pub
    puts priv(123)
  end

  private
  
  def priv(value)
    puts "Private method with value #{value}"
  end
end

Thing.pub
# "Private method with value 123"

Thing.priv
# NoMethodError (private method `priv' called for Thing:Module)