« Hé, qu’est-ce que cela ||= signifie dans votre code ruby? »

Dans mon premier article de blog en tant que programmeur, j’ai pensé qu’il serait approprié d’expliquer l’une des questions qu’on m’a posées lors de ma première journée à l’École Flatiron. C’est une question que j’avais posée il y a environ un mois et qui m’a conduit dans un trou de lapin de forums ruby et de publications reddit (je vais vous éviter les ennuis et lier quelques-unes des meilleures sources au bas de ce post).

La controverse derrière « double-pipe equals » est centrée sur la façon dont l’opérateur doit être traduit, mais j’aimerais concentrer cet article sur les applications que j’ai trouvées pour cela. Alors, que fait exactement ||=? Ma propre définition est que « double-pipe equals » est un opérateur qui attribue une valeur, un peu comme = ou notre opérateur d’affectation classique, mais ne terminera l’affectation que si le côté gauche de notre opération renvoie false ou nil.

Permettez-moi de démontrer.

a = nil
b = 4
a = b #=> 4
a #=> 4

Avec a défini sur nil, il est facile de voir que définir un « égal » à b en utilisant l’opérateur d’affectation classique renverrait a avec la valeur de b avec la valeur de b4. Mais que se passe-t-il si nous utilisions « double-pipe equals » à la place?

a = nil
b = 4
a ||= b #=> 4
a #=> 4

Dans ce cas, nous obtenons le même résultat. Lorsque a est défini sur nil (ou tout ce qui est évalué à false), l’opérateur ||= fonctionne de la même manière que = serait. Regardons un exemple où a reçoit une valeur « véridique ».

a = 2
b = 4
a ||= b #=> 2
a #=> 2

Dans l’exemple ci-dessus, a conserve sa valeur d’origine même s’il a été exploité via nos « égaux à double tuyau ». Cela se produit parce que || agit comme un « circuit » dans cette méthode. Comme l’explique Peter Cooper,

Si le côté gauche de la comparaison est vrai, il n’est pas nécessaire de vérifier le côté droit.

Lorsque ruby a vu que a était déjà affecté à la valeur de 2, il a cessé d’exécuter notre code.

Là où j’ai trouvé ce type d’affectation conditionnelle le plus utile, c’est en itération. Parcourons un tableau de fruits populaires, en utilisant notre méthode ||= pour affecter chacune des chaînes à a.

a = nil
array = 
array.each do |fruit|
a ||= fruit
end #=> a #=> "apple"

Nous pouvons voir qu’après notre itération, a est affecté à la première chaîne de notre tableau, "apple”. Après que a devienne "apple”, notre « double-pipe égale » ne laissera rien à sa droite réaffecter notre variable.

Alors que ruby a des méthodes qui peuvent renvoyer le premier élément d’un tableau sans itération, il peut parfois être utile de contrôler si une variable a été assignée ou non avec une valeur « vraie ». Voici un extrait de code d’un de mes laboratoires récents où j’ai trouvé ||= particulièrement utile.

class School attr_reader :roster def initialize(name) 
@name = name 
@roster = {} 
end def add_student(name, grade)
@roster ||= 
@roster << name 
endend

Ici, j’ai défini une classe, School, avec quelques méthodes. La chose clé à comprendre est qu’en appelant roster sur une instance de ma classe School, je cherche à renvoyer ma liste d’étudiants sous forme de hachage de notes pointant vers un tableau d’étudiants associés à chaque note.

Permet d’instancier un exemple d’école et de remplir certains élèves.

metro = School.new("Metro High")
metro.add_student("Jared", 9)
metro.roster #=> {9=>}metro.add_student("Graham", 9)
metro.roster #=> {9=>}

Pour ajouter un étudiant à l’instance roster de mon School, je dois passer la méthode add_studenta name et ungrade. Cependant, nous pouvons voir que lorsque j’ai ajouté "Graham” et sa note correspondante, 9, son nom a été ajouté au tableau existant créé lorsque j’ai ajouté "Jared”. C’est la magie de ||=. Dans ce cas, l’opérateur « double-pipe equals » a reconnu qu’une clé de note a déjà été ajoutée et que

Si ma méthode add_student avait été utilisée =au lieu de ||=, j’aurais écrasé mon entrée d’étudiant "Jared” div> lorsque j’ai ajouté un autre élève en classe 9.