Go to English Blog

Entendendo a visibilidade de métodos do Ruby

Leia em 2 minutos

Uma dúvida muito comum de quem começa a programar em Ruby é em relação à visibilidade de métodos. Afinal de contas, qual a verdadeira diferença entre métodos públicos, privados e protegidos no Ruby?

No Ruby é possível usar três palavras-chave para definir a visibilidade dos métodos. Elas podem ser definidas por um contexto (meio que como uma annotation), como no exemplo abaixo.

class Report
  def render
    render_header
    render_body
    render_footer
  end

  private

  def render_header
    puts __method__
  end

  def render_body
    puts __method__
  end

  def render_footer
    puts __method__
  end
end

Por padrão, todo método definido já público, ou seja, pode ser invocado como uma interface pública. Este é o caso do método Report#render. Existe uma exceção aqui; trata-se do método BasicObject#initialize, que é sempre privado, mesmo sem precisarmos fazer esta indicação.

Alternativamente, você pode fazer a definição da visibilidade passando uma lista de nomes.

class Report
  def render
    render_header
    render_body
    render_footer
  end

  def render_header
    puts __method__
  end

  def render_body
    puts __method__
  end

  def render_footer
    puts __method__
  end

  private :render_header, :render_body, :render_footer
end

E à partir do Ruby 2.1 também é possível fazer a definição da visibilidade em uma única linha.

class Report
  def render
    render_header
    render_body
    render_footer
  end

  private def render_header
    puts __method__
  end

  private def render_body
    puts __method__
  end

  private def render_footer
    puts __method__
  end
end

Note que isso só é possível porque, à partir do Ruby 2.1, o def retorna o nome do método adicionado. Na prática, isso seria equivalente a fazer algo como o exemplo abaixo, mas sem a necessidade de duplicar o nome do método.

class Report
  def render
    render_header
    render_body
    render_footer
  end

  def render_header
    puts __method__
  end
  private :render_header

  def render_body
    puts __method__
  end
  private :render_body

  def render_footer
    puts __method__
  end
  private :render_footer
end

Qual modo você deve usar é uma escolha sua, mas acho que a definição por contexto e a chamada de private com uma lista de nomes parecem mais legíveis.

Mas qual a diferença entre private e protected? A única diferença está no modo como os métodos getters podem ser invocados. Os métodos privados não podem ser chamados através de um receiver; esta restrição não se aplica aos métodos protegidos.

class Sample
  def initialize
    some_private_method
    some_protected_method

    begin
      self.some_private_method
    rescue
      puts('Cannot invoke private methods through a receiver')
    end

    self.some_protected_method
  end

  private def some_private_method
    puts __method__
  end

  protected def some_protected_method
    puts __method__
  end
end

Sample.new
#=> some_private_method
#=> some_protected_method
#=> Cannot invoke private methods through a receiver
#=> some_protected_method

Um fato curioso que vale ser mencionado; essa restrição do receiver não se aplica aos métodos setters no contexto da instância (self).

class Sample
  attr_accessor :protected_attribute, :private_attribute
  protected :protected_attribute=
  private :protected_attribute=

  def initialize
    self.protected_attribute = 'some protected value'
    self.private_attribute = 'some private value'
  end
end

sample = Sample.new

sample.protected_attribute
#=> some protected value

sample.private_attribute
#=> some private value

Mas lembre-se que se você tentar fazer a atribuição externamente, uma exceção será lançada.

sample = Sample.new
sample.protected_attribute = 'another protected value'
#=> private method `protected_attribute=' called for #<Sample:0x007fdbfa91aef0> (NoMethodError)

Vale lembrar que o uso de herança não afeta o modo como a definição de visibilidade funciona.

class A
  attr_accessor :title, :description
  protected :title, :title=
  private :description, :description=
end

class B < A
  def initialize
    self.title = 'Some title'
    self.description = 'Some description'

    puts title
    puts self.title

    puts description

    begin
      puts self.description
    rescue
      puts 'Cannot call private methods through a receiver'
    end
  end
end

B.new
#=> Some title
#=> Some title
#=> Some description
#=> Cannot call private methods through a receiver

Finalizando

De um modo geral, use sempre private. Já que a diferença é inexistente para os métodos setters, o uso de private irá forçar com que a chamada de métodos getters seja feita sem o uso de um receiver (nesse caso o self), algo que você já deveria estar fazendo para começo de conversa.

Compartilhe: