J'ai également fait face à ce problème et j'ai écrit une réponse assez longue à cette question. Il y a déjà d'excellentes réponses à ce sujet, mais si vous cherchez plus de précisions, j'espère que ma réponse pourra vous aider.
Initialize, méthode
Initialize vous permet de définir des données sur une instance d'un objet lors de la création de l'instance plutôt que d'avoir à les définir sur une ligne distincte dans votre code chaque fois que vous créez une nouvelle instance de la classe.
class Person
def initialize(name)
@name = name
end
def greeting
"Hello #{@name}"
end
end
person = Person.new("Denis")
puts person.greeting
Dans le code ci-dessus, nous définissons le nom «Denis» en utilisant la méthode initialize en passant Dennis à travers le paramètre dans Initialize. Si nous voulions définir le nom sans la méthode initialize, nous pourrions le faire comme ceci:
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
Dans le code ci-dessus, nous définissons le nom en appelant la méthode setter attr_accessor à l'aide de person.name, plutôt que de définir les valeurs lors de l'initialisation de l'objet.
Les deux «méthodes» de faire ce travail, mais initialiser nous font gagner du temps et des lignes de code.
C'est le seul travail d'initialisation. Vous ne pouvez pas appeler initialize comme méthode. Pour obtenir réellement les valeurs d'un objet d'instance, vous devez utiliser des getters et setters (attr_reader (get), attr_writer (set) et attr_accessor (both)). Voir ci-dessous pour plus de détails à ce sujet.
Getters, Setters (attr_reader, attr_writer, attr_accessor)
Getters, attr_reader: Le but d'un getter est de renvoyer la valeur d'une variable d'instance particulière. Consultez l'exemple de code ci-dessous pour une ventilation à ce sujet.
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
Dans le code ci-dessus, vous appelez les méthodes "item_name" et "quantity" sur l'instance de Item "example". Les «met example.item_name» et «example.quantity» renverront (ou «obtiendront») la valeur des paramètres qui ont été passés dans «l'exemple» et les afficheront à l'écran.
Heureusement, dans Ruby, il existe une méthode inhérente qui nous permet d'écrire ce code plus succinctement; la méthode attr_reader. Voir le code ci-dessous;
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
Cette syntaxe fonctionne exactement de la même manière, sauf qu'elle nous permet d'économiser six lignes de code. Imaginez si vous aviez 5 autres états attribuables à la classe Item? Le code deviendrait rapidement long.
Setters, attr_writer: Ce qui m'a d'abord traversé avec les méthodes setter, c'est qu'à mes yeux, il semblait remplir une fonction identique à la méthode initialize. Ci-dessous, j'explique la différence en fonction de ma compréhension;
Comme indiqué précédemment, la méthode initialize vous permet de définir les valeurs d'une instance d'un objet lors de sa création.
Mais que se passe-t-il si vous souhaitez définir les valeurs ultérieurement, après la création de l'instance, ou les modifier après leur initialisation? Ce serait un scénario où vous utiliseriez une méthode de définition. C'EST LA DIFFÉRENCE. Vous n'avez pas à «définir» un état particulier lorsque vous utilisez initialement la méthode attr_writer.
Le code ci-dessous est un exemple d'utilisation d'une méthode de définition pour déclarer la valeur item_name pour cette instance de la classe Item. Notez que nous continuons à utiliser la méthode getter attr_reader afin que nous puissions obtenir les valeurs et les imprimer à l'écran, juste au cas où vous voudriez tester le code par vous-même.
class Item
attr_reader :item_name
def item_name=(str)
@item_name = (str)
end
end
Le code ci-dessous est un exemple d'utilisation de attr_writer pour raccourcir à nouveau notre code et nous faire gagner du temps.
class Item
attr_reader :item_name
attr_writer :item_name
end
item = Item.new
puts item.item_name = "TV"
Le code ci-dessous est une réitération de l'exemple d'initialisation ci-dessus où nous utilisons initialize pour définir la valeur des objets de nom_article lors de la création.
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: exécute les fonctions à la fois d'attr_reader et d'attr_writer, vous permettant d'économiser une ligne de code supplémentaire.