También enfrenté este problema y escribí una respuesta algo larga a esta pregunta. Ya hay algunas respuestas geniales sobre esto, pero cualquiera que busque más aclaraciones, espero que mi respuesta pueda ayudar
Método de inicialización
Initialize le permite establecer datos en una instancia de un objeto al crear la instancia en lugar de tener que establecerlos en una línea separada en su código cada vez que crea una nueva instancia de la clase.
class Person
def initialize(name)
@name = name
end
def greeting
"Hello #{@name}"
end
end
person = Person.new("Denis")
puts person.greeting
En el código anterior, estamos configurando el nombre "Denis" utilizando el método initialize pasando a Dennis a través del parámetro en Initialize. Si quisiéramos establecer el nombre sin el método de inicialización, podríamos hacerlo así:
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
En el código anterior, establecemos el nombre llamando al método setter attr_accessor usando person.name, en lugar de establecer los valores al inicializar el objeto.
Ambos "métodos" de hacer este trabajo, pero inicializar nos ahorran tiempo y líneas de código.
Este es el único trabajo de inicialización. No puede llamar a initialize como método. Para obtener realmente los valores de un objeto de instancia, debe usar getters y setters (attr_reader (get), attr_writer (set) y attr_accessor (ambos)). Consulte a continuación para obtener más detalles al respecto.
Getters, Setters (attr_reader, attr_writer, attr_accessor)
Getters, attr_reader: El propósito completo de un getter es devolver el valor de una variable de instancia particular. Visite el código de muestra a continuación para obtener un desglose de esto.
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
En el código anterior, llama a los métodos "nombre_elemento" y "cantidad" en la instancia del elemento "ejemplo". El "pone example.item_name" y "example.quantity" devolverá (u "obtendrá") el valor de los parámetros que se pasaron al "ejemplo" y los mostrará en la pantalla.
Afortunadamente, en Ruby hay un método inherente que nos permite escribir este código de manera más sucinta; El método attr_reader. Vea el código a continuación;
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
Esta sintaxis funciona exactamente de la misma manera, solo que nos ahorra seis líneas de código. ¿Imagínese si tuviera 5 estados más atribuibles a la clase Item? El código se alargaría rápidamente.
Setters, attr_writer: Lo que me sorprendió al principio con los métodos setter es que, a mis ojos, parecía realizar una función idéntica al método de inicialización. A continuación explico la diferencia basada en mi comprensión;
Como se indicó anteriormente, el método de inicialización le permite establecer los valores para una instancia de un objeto tras la creación del objeto.
Pero, ¿qué sucede si desea establecer los valores más tarde, después de crear la instancia, o cambiarlos después de que se hayan inicializado? Este sería un escenario en el que usaría un método de establecimiento. Esa es la diferencia. No tiene que "establecer" un estado particular cuando está utilizando el método attr_writer inicialmente.
El siguiente código es un ejemplo del uso de un método setter para declarar el valor item_name para esta instancia de la clase Item. Tenga en cuenta que seguimos utilizando el método getter attr_reader para que podamos obtener los valores e imprimirlos en la pantalla, en caso de que desee probar el código por su cuenta.
class Item
attr_reader :item_name
def item_name=(str)
@item_name = (str)
end
end
El siguiente código es un ejemplo del uso de attr_writer para acortar nuevamente nuestro código y ahorrarnos tiempo.
class Item
attr_reader :item_name
attr_writer :item_name
end
item = Item.new
puts item.item_name = "TV"
El siguiente código es una reiteración del ejemplo de inicialización anterior de dónde estamos utilizando initialize para establecer el valor de objetos de item_name en la creación.
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: realiza las funciones de attr_reader y attr_writer, ahorrándote una línea más de código.