Também enfrentei esse problema e escrevi uma resposta um tanto demorada para essa pergunta. Já existem ótimas respostas sobre isso, mas quem procura mais esclarecimentos, espero que minha resposta possa ajudar
Método de inicialização
Initialize permite que você defina dados para uma instância de um objeto após a criação da instância, em vez de precisar defini-los em uma linha separada no seu código toda vez que você cria uma nova instância da classe.
class Person
def initialize(name)
@name = name
end
def greeting
"Hello #{@name}"
end
end
person = Person.new("Denis")
puts person.greeting
No código acima, estamos definindo o nome “Denis” usando o método initialize passando Dennis pelo parâmetro em Initialize. Se quiséssemos definir o nome sem o método initialize, poderíamos fazer o seguinte:
class Person
attr_accessor :name
# def initialize(name)
# @name = name
# end
def greeting
"Hello #{name}"
end
end
person = Person.new
person.name = "Dennis"
puts person.greeting
No código acima, definimos o nome chamando o método attr_accessor setter usando person.name, em vez de definir os valores na inicialização do objeto.
Os dois "métodos" de fazer esse trabalho, mas inicializar, economizam tempo e linhas de código.
Este é o único trabalho de inicialização. Você não pode chamar a inicialização como um método. Para realmente obter os valores de um objeto de instância, você precisa usar getters e setters (attr_reader (get), attr_writer (set) e attr_accessor (ambos)). Veja abaixo mais detalhes sobre esses.
Getters, Setters (attr_reader, attr_writer, attr_accessor)
Getters, attr_reader: O objetivo inteiro de um getter é retornar o valor de uma variável de instância específica. Visite o código de exemplo abaixo para obter detalhes sobre isso.
class Item
def initialize(item_name, quantity)
@item_name = item_name
@quantity = quantity
end
def item_name
@item_name
end
def quantity
@quantity
end
end
example = Item.new("TV",2)
puts example.item_name
puts example.quantity
No código acima, você está chamando os métodos "item_name" e "quantidade" na instância do item "exemplo". O “puts example.item_name” e “example.quantity” retornarão (ou “obterão”) o valor dos parâmetros que foram passados para o “exemplo” e os exibirão na tela.
Felizmente, em Ruby, existe um método inerente que nos permite escrever esse código de forma mais sucinta; o método attr_reader. Veja o código abaixo;
class Item
attr_reader :item_name, :quantity
def initialize(item_name, quantity)
@item_name = item_name
@quantity = quantity
end
end
item = Item.new("TV",2)
puts item.item_name
puts item.quantity
Essa sintaxe funciona exatamente da mesma maneira, mas nos salva seis linhas de código. Imagine se você tivesse mais 5 estados atribuíveis à classe Item? O código iria demorar muito rapidamente.
Setters, attr_writer: O que me impressionou no início com os métodos setter é que, aos meus olhos, parecia desempenhar uma função idêntica ao método inicializar. Abaixo, explico a diferença com base no meu entendimento;
Como mencionado anteriormente, o método initialize permite definir os valores para uma instância de um objeto na criação do objeto.
Mas e se você quiser definir os valores posteriormente, após a instância ter sido criada, ou alterá-los após a inicialização? Este seria um cenário em que você usaria um método setter. Essa é a diferença. Você não precisa "definir" um estado específico quando estiver usando o método attr_writer inicialmente.
O código abaixo é um exemplo de uso de um método setter para declarar o valor item_name para esta instância da classe Item. Observe que continuamos a usar o método getter attr_reader para que possamos obter os valores e imprimi-los na tela, caso você queira testar o código por conta própria.
class Item
attr_reader :item_name
def item_name=(str)
@item_name = (str)
end
end
O código abaixo é um exemplo de uso do attr_writer para encurtar novamente nosso código e economizar tempo.
class Item
attr_reader :item_name
attr_writer :item_name
end
item = Item.new
puts item.item_name = "TV"
O código abaixo é uma reiteração do exemplo de inicialização acima de onde estamos usando initialize para definir o valor dos objetos item_name na criação.
class Item
attr_reader :item_name
def initialize(item_name)
@item_name = item_name
end
end
item = Item.new("TV")
puts item.item_name
attr_accessor: Executa as funções de attr_reader e attr_writer, economizando mais uma linha de código.