Ruby Academy · Aula

include e extend

Inclua comportamentos.

include e extend é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 2 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.

Misturando comportamento

O verdadeiro poder dos módulos está na mistura: compartilhar métodos entre classes sem herança. As duas ferramentas principais são include e extend.

module Walkable
  def walk
    "#{name} is walking"
  end
end
class Person
  include Walkable
  attr_reader :name
  def initialize(name)
    @name = name
  end
end
puts Person.new("Ada").walk

include adiciona métodos de instância

include mistura os métodos de um módulo como métodos de instância. Todos os objetos da classe passam a tê-los.

module Sayable
  def say(msg)
    "#{msg}!"
  end
end
class Dog
  include Sayable
end
puts Dog.new.say("Woof")

Reutilizando entre classes

Um módulo pode ser incluído por várias classes sem relação entre si, compartilhando comportamento sem um ancestral comum.

module Timestamped
  def stamp
    "created"
  end
end
class Post; include Timestamped; end
class Comment; include Timestamped; end
puts Post.new.stamp
puts Comment.new.stamp

extend adiciona métodos de classe

extend mistura os métodos de um módulo como métodos de classe, isto é, métodos do próprio objeto que representa a classe.

module Findable
  def find(id)
    "Finding record #{id}"
  end
end
class User
  extend Findable
end
puts User.find(42)

extend em um objeto

Você pode usar extend em um único objeto, para que somente ele receba os métodos, sem alterar os outros.

module Admin
  def privileges
    "all access"
  end
end
user = Object.new
user.extend(Admin)
puts user.privileges

include versus extend

Lembre-se da diferença:

include => os métodos se tornam métodos de instância.
extend => os métodos se tornam métodos de classe/objeto.

module Helper
  def help; "helping"; end
end
class A; include Helper; end
class B; extend Helper; end
puts A.new.help
puts B.help

Os módulos veem os métodos do objeto anfitrião

Um método misturado é executado no contexto do objeto anfitrião, portanto pode chamar os próprios métodos do anfitrião e acessar seus dados.

module Describable
  def describe
    "I am #{role}"
  end
end
class Worker
  include Describable
  def role; "a worker"; end
end
puts Worker.new.describe

O gancho included

Defina self.included(base) para executar código automaticamente quando um módulo for incluído. Um padrão clássico adiciona métodos de classe ao mesmo tempo.

module Trackable
  def self.included(base)
    puts "Trackable added to #{base}"
  end
end
class Order
  include Trackable
end

Verificando o pertencimento

is_a? e ancestors mostram que um módulo incluído se torna parte da cadeia de tipos do objeto.

module Flyable; end
class Bird; include Flyable; end
b = Bird.new
puts b.is_a?(Flyable)
p Bird.ancestors

Combinando várias misturas

Uma classe pode incluir vários módulos, compondo comportamento a partir de muitas partes pequenas e focadas.

module Swimmable; def swim; "swimming"; end; end
module Runnable; def run; "running"; end; end
class Athlete
  include Swimmable
  include Runnable
end
a = Athlete.new
puts a.swim
puts a.run

Juntando tudo

As misturas compartilham comportamento com flexibilidade:

include para métodos de instância.
extend para métodos de classe ou de um único objeto.
Os métodos misturados são executados no contexto do anfitrião.
Combine vários módulos pequenos.

module Greet
  def hi; "hi from #{self.class}"; end
end
class Cat; include Greet; end
puts Cat.new.hi

Verificação rápida

Teste sua compreensão sobre include e extend.

Recapitulação

Você aprendeu sobre misturas:

include => métodos de instância.
extend => métodos de classe ou de um único objeto.
Os métodos misturados são executados no contexto do anfitrião.
O gancho included é acionado durante a inclusão.

module Loud
  def shout(s); s.upcase; end
end
class Speaker; include Loud; end
puts Speaker.new.shout("hello")

Perguntas Frequentes

A aula “include e extend” é grátis?

Sim — o texto completo de “include e extend” é 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 “include e extend”?

Inclua comportamentos. 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 2 de 4.

Quanto tempo leva a aula “include e extend”?

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