Các phương thức mô-đun riêng trong Ruby

Tôi có một câu hỏi hai phần

Thực hành tốt nhất

• Tôi có một thuật toán thực hiện một số thao tác trên cấu trúc dữ liệu bằng giao diện công khai
• Nó hiện là một mô-đun có nhiều phương thức tĩnh, tất cả đều riêng tư ngoại trừ một phương thức giao diện công khai.
• Có một biến thể hiện cần được chia sẻ giữa tất cả các phương thức.

Đây là những tùy chọn tôi có thể thấy, tùy chọn nào tốt nhất ?:

• Mô-đun với phương thức tĩnh ('mô-đun' trong ruby)
• Lớp với các phương thức tĩnh
• Mô-đun Mixin để đưa vào cấu trúc dữ liệu
• Cấu trúc lại một phần của thuật toán sửa đổi cấu trúc dữ liệu đó (rất nhỏ) và tạo ra một mixin gọi các phương thức tĩnh của mô-đun thuật toán

Phần kỹ thuật

Có cách nào để tạo một phương thức Module riêng không?

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

Trong privateđó dường như không có bất kỳ tác dụng nào , tôi vẫn có thể gọi Thing.privmà không gặp sự cố.

Tôi nghĩ rằng cách tốt nhất (và chủ yếu là cách các lib hiện có được viết) để làm điều này là tạo một lớp bên trong mô-đun xử lý tất cả các logic và mô-đun chỉ cung cấp một phương thức thuận tiện, ví dụ:

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

Ngoài ra còn có Module.private_class_method, được cho là thể hiện nhiều ý định hơn.

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

Đối với mã trong câu hỏi:

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

Ruby 2.1 hoặc mới hơn:

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)

Bạn có thể sử dụng phương thức "bao gồm" để thực hiện những điều thú vị khi một mô-đun được trộn vào. Điều này thực hiện theo những gì bạn muốn Tôi nghĩ:

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

Thật không may, privatechỉ áp dụng cho các phương thức cá thể. Cách chung để nhận các phương thức "tĩnh" riêng tư trong một lớp là thực hiện một số việc như:

class << self
  private

  def foo()
   ....
  end
end

Phải thừa nhận rằng tôi chưa chơi với việc làm điều này trong các mô-đun.

Một cách tốt đẹp là như thế này

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

Còn về việc lưu trữ các phương thức dưới dạng lambdas bên trong các biến / hằng số của lớp thì sao?

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

Để thử nghiệm:
UPD: bản cập nhật lớn của mã này sau 6 năm cho thấy cách rõ ràng hơn để khai báo phương thức riêng tưd

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

Ở đây chúng ta thấy rằng:

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) @@Lkhông thể truy cập từ bên ngoài nhưng có thể truy cập từ hầu hết mọi nơi
2) class << self ; private ; deflàm cho phương thức dkhông thể truy cập thành công từ bên ngoài và từ bên trong self.nhưng không phải là không có nó - điều này thật kỳ lạ
3) private ; self.và private ; class << selfkhông đặt phương thức ở chế độ riêng tư - chúng đều có thể truy cập được có và không cóself.

Tạo một mô-đun hoặc lớp học riêng tư

Hằng số không bao giờ là riêng tư. Tuy nhiên, có thể tạo một mô-đun hoặc lớp mà không cần gán nó cho một hằng số.

Vì vậy, một giải pháp thay thế :private_class_methodlà tạo một mô-đun hoặc lớp riêng và xác định các phương thức công khai trên đó.

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

Sử dụng:

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

Xem tài liệu cho Module.new và Class.new .

Phương thức này sẽ không cho phép chia sẻ dữ liệu với các phương thức private trừ khi bạn chuyển dữ liệu một cách rõ ràng bằng các tham số phương thức.

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)