São métodos Ruby que geram automaticamente métodos getter e/ou setter para variáveis de instância — eliminando boilerplate. Como variáveis de instância (@name) são privadas e não diretamente acessíveis de fora, você precisa de métodos acessadores para ler/escrever nelas, e attr_* gera estes de forma concisa.
()
= name
()
= value
class Person
attr_reader :name # generates a GETTER only (read-only): person.name
attr_writer :email # generates a SETTER only (write-only): person.email = ...
attr_accessor :age # generates BOTH getter and setter: person.age / person.age = ...
def initialize(name, age)
@name = name
@age = age
end
end
person = Person.new("Ann", 30)
person.name # "Ann" — reader
person.age = 31 # writer
person.age # 31 — reader
person.name = "X" # ❌ NoMethodError — name is read-only (attr_reader, no setter)
attr_reader → getter apenas (acesso somente leitura).attr_writer → setter apenas (acesso somente escrita).attr_accessor → ambos getter e setter (acesso leitura-escrita).Cada um recebe símbolos nomeando as variáveis de instância e gera os métodos correspondentes automaticamente — uma linha substitui várias definições manuais de métodos.
class BankAccount
attr_reader :balance # ✅ balance is readable but NOT directly settable (protect it)
def initialize
@balance = 0
end
def deposit(amount) # changes go through a controlled method, not a raw setter
@balance += amount if amount > 0
end
end
Escolher attr_reader (vs attr_accessor) para campos que não devem ser definidos arbitrariamente de fora é bom encapsulamento — expondo apenas o acesso que você pretende.
Entender attr_accessor/attr_reader/attr_writer é conhecimento fundamental e diário em Ruby, pois aparecem em quase toda classe Ruby.
A razão central de existirem: variáveis de instância (@name) são privadas e não diretamente acessíveis de fora de um objeto, então você precisa de métodos acessadores para ler ou escrever nelas — e escrever manualmente esses getters/setters para cada atributo é boilerplate tedioso.
Estos métodos geram os acessadores automaticamente (attr_reader para somente leitura, attr_writer para somente escrita, attr_accessor para ambos), substituindo várias definições de métodos com uma única linha concisa — um traço característico da elegância e concisão do Ruby.
Entender o que cada um gera e escolher o apropriado também é uma questão de bom encapsulamento: usar attr_reader (somente leitura) para campos que não devem ser arbitrariamente modificados de fora, e attr_accessor apenas onde o acesso leitura-escrita é genuinamente pretendido, controla como o estado de um objeto é exposto (p.ex. tornando um saldo bancário legível mas modificável apenas através de métodos controlados).
Como estes acessadores são onipresentes em classes Ruby (e modelos Rails), saber como funcionam, o que cada um gera, e como escolher para encapsulamento apropriado é essencial, conhecimento obrigatório para escrever e ler classes Ruby — é uma das primeiras coisas que você encontra ao definir classes Ruby e reflete a abordagem concisa e expressiva da linguagem para uma necessidade comum (acesso controlado ao estado do objeto).