Ruby Academy · Aula

Definindo módulos

Namespaces e métodos.

Definindo módulos é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Ruby Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Ruby Academy inclui 4 aulas no total.

Espaços de nomes e métodos

Um módulo é um contêiner para métodos e constantes. Diferentemente de uma classe, você não pode criar uma instância de um módulo. Os módulos têm duas funções: agrupar código, organizando-o em espaços de nomes, e compartilhar comportamento por meio de misturas.

module Greeter
  def self.hello
    "Hello from the module"
  end
end
puts Greeter.hello

Métodos de módulo

Defina um método com self. para chamá-lo diretamente no módulo, como uma função utilitária. Eles costumam ser chamados de funções de módulo.

module MathTools
  def self.square(x)
    x * x
  end
end
puts MathTools.square(7)

Constantes de módulo

Os módulos também armazenam constantes. Acesse-as com o operador de escopo ::.

module Physics
  GRAVITY = 9.81
end
puts Physics::GRAVITY

Organizando classes em espaços de nomes

Coloque classes dentro de um módulo para evitar conflitos de nomes. O nome completo usa ::.

module Store
  class Item
    def initialize(name)
      @name = name
    end
    def to_s
      @name
    end
  end
end
puts Store::Item.new("Book")

Por que os espaços de nomes são importantes

Duas bibliotecas podem definir um Logger. A organização em espaços de nomes as mantém separadas: Audio::Logger e Network::Logger nunca entram em conflito.

module Audio
  class Logger
    def name; "audio logger"; end
  end
end
module Network
  class Logger
    def name; "network logger"; end
  end
end
puts Audio::Logger.new.name
puts Network::Logger.new.name

module_function

module_function torna os métodos seguintes chamáveis tanto no módulo quanto como métodos de instância privados quando o módulo é incluído. Isso evita repetir self..

module Calc
  module_function
  def add(a, b)
    a + b
  end
end
puts Calc.add(2, 3)

Agrupando constantes relacionadas

Os módulos são excelentes para organizar valores de configuração relacionados sob um único nome claro.

module Color
  RED = "#FF0000"
  GREEN = "#00FF00"
  BLUE = "#0000FF"
end
puts Color::GREEN

Módulos aninhados

Os módulos podem ser aninhados dentro de outros módulos para uma organização mais detalhada.

module App
  module Config
    VERSION = "1.0"
  end
end
puts App::Config::VERSION

Listando o conteúdo de um módulo

Os métodos de reflexão permitem inspecionar as constantes e os métodos de um módulo durante a execução.

module Settings
  WIDTH = 80
  HEIGHT = 24
end
p Settings.constants

Módulos não podem ser instanciados

Tentar usar Module.new no estilo de um módulo nomeado falha porque um módulo não tem um construtor para instâncias. Ele é um espaço de nomes e um contêiner de comportamento, não um modelo para objetos.

module Tools
end
begin
  Tools.new
rescue NoMethodError => e
  puts "Cannot instantiate: #{e.message}"
end

Juntando tudo

Os módulos organizam e compartilham código:

Use self.method para criar funções de módulo chamáveis.
Armazene constantes acessadas com ::.
Organize classes em espaços de nomes para evitar conflitos.
Você não pode instanciar um módulo.

module Geometry
  PI = 3.14159
  def self.circle_area(r)
    PI * r * r
  end
end
puts Geometry.circle_area(2)

Verificação rápida

Teste sua compreensão sobre módulos.

Recapitulação

Você aprendeu a definir módulos:

Os módulos agrupam métodos e constantes.
self.method define funções de módulo chamáveis.
:: acessa constantes e classes aninhadas.
A organização em espaços de nomes evita conflitos de nomes.

module Util
  def self.shout(s)
    s.upcase + "!"
  end
end
puts Util.shout("ruby")

Perguntas Frequentes

A aula “Definindo módulos” é grátis?

Sim — o texto completo de “Definindo módulos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Ruby Academy, atualize para CoddyKit PRO. O curso de Ruby Academy inclui 4 aulas no total.

O que vou aprender em “Definindo módulos”?

Namespaces e métodos. Você pratica Ruby Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Ruby Academy?

Nenhuma experiência prévia é necessária. Ruby Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Definindo módulos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Ruby Academy?

Sim. Cada aula de Ruby Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Ruby Academy