Opérateurs d'égalité: == et! =
L'opérateur ==, également appelé égal ou double égal, renverra true si les deux objets sont égaux et false s'ils ne le sont pas.
"koan" == "koan" # Output: => true
L'opérateur! =, Également connu sous le nom d'inégalité, est l'opposé de ==. Il retournera vrai si les deux objets ne sont pas égaux et faux s'ils sont égaux.
"koan" != "discursive thought" # Output: => true
Notez que deux tableaux avec les mêmes éléments dans un ordre différent ne sont pas égaux, les versions majuscules et minuscules de la même lettre ne sont pas égales et ainsi de suite.
Lorsque vous comparez des nombres de différents types (par exemple, entier et flottant), si leur valeur numérique est la même, == renvoie true.
2 == 2.0 # Output: => true
égal?
Contrairement à l'opérateur == qui teste si les deux opérandes sont égaux, la méthode égale vérifie si les deux opérandes se réfèrent au même objet. Il s'agit de la forme d'égalité la plus stricte en Ruby.
Exemple: a = "zen" b = "zen"
a.object_id # Output: => 20139460
b.object_id # Output :=> 19972120
a.equal? b # Output: => false
Dans l'exemple ci-dessus, nous avons deux chaînes avec la même valeur. Cependant, ce sont deux objets distincts, avec des ID d'objet différents. Par conséquent, l'égal? retournera false.
Essayons encore, seulement cette fois b sera une référence à a. Notez que l'ID d'objet est le même pour les deux variables, car elles pointent vers le même objet.
a = "zen"
b = a
a.object_id # Output: => 18637360
b.object_id # Output: => 18637360
a.equal? b # Output: => true
eql?
Dans la classe Hash, l'eql? méthode utilisée pour tester l'égalité des clés. Un certain fond est nécessaire pour expliquer cela. Dans le contexte général de l'informatique, une fonction de hachage prend une chaîne (ou un fichier) de n'importe quelle taille et génère une chaîne ou un entier de taille fixe appelé hashcode, communément appelé uniquement hachage. Certains types de codes de hachage couramment utilisés sont MD5, SHA-1 et CRC. Ils sont utilisés dans les algorithmes de chiffrement, l'indexation des bases de données, la vérification de l'intégrité des fichiers, etc. Certains langages de programmation, tels que Ruby, fournissent un type de collection appelé table de hachage. Les tables de hachage sont des collections de type dictionnaire qui stockent les données par paires, composées de clés uniques et de leurs valeurs correspondantes. Sous le capot, ces clés sont stockées sous forme de codes de hachage. Les tables de hachage sont communément appelées simplement des hachages. Remarquez comment le mot hachage peut faire référence à un code de hachage ou à une table de hachage.
Ruby fournit une méthode intégrée appelée hachage pour générer des codes de hachage. Dans l'exemple ci-dessous, il prend une chaîne et retourne un hashcode. Notez que les chaînes ayant la même valeur ont toujours le même code de hachage, même s'il s'agit d'objets distincts (avec des ID d'objet différents).
"meditation".hash # Output: => 1396080688894079547
"meditation".hash # Output: => 1396080688894079547
"meditation".hash # Output: => 1396080688894079547
La méthode de hachage est implémentée dans le module Kernel, inclus dans la classe Object, qui est la racine par défaut de tous les objets Ruby. Certaines classes telles que Symbol et Integer utilisent l'implémentation par défaut, d'autres comme String et Hash fournissent leurs propres implémentations.
Symbol.instance_method(:hash).owner # Output: => Kernel
Integer.instance_method(:hash).owner # Output: => Kernel
String.instance_method(:hash).owner # Output: => String
Hash.instance_method(:hash).owner # Output: => Hash
Dans Ruby, lorsque nous stockons quelque chose dans un hachage (collection), l'objet fourni sous forme de clé (par exemple, une chaîne ou un symbole) est converti et stocké en tant que code de hachage. Plus tard, lors de la récupération d'un élément du hachage (collection), nous fournissons un objet sous forme de clé, qui est converti en code de hachage et comparé aux clés existantes. En cas de correspondance, la valeur de l'élément correspondant est renvoyée. La comparaison est faite en utilisant l'eql? méthode sous le capot.
"zen".eql? "zen" # Output: => true
# is the same as
"zen".hash == "zen".hash # Output: => true
Dans la plupart des cas, l'eql? se comporte de manière similaire à la méthode ==. Il existe cependant quelques exceptions. Par exemple, eql? n'effectue pas de conversion de type implicite lors de la comparaison d'un entier à un flottant.
2 == 2.0 # Output: => true
2.eql? 2.0 # Output: => false
2.hash == 2.0.hash # Output: => false
Opérateur d'égalité de casse: ===
De nombreuses classes intégrées de Ruby, telles que String, Range et Regexp, fournissent leurs propres implémentations de l'opérateur ===, également connu sous le nom d'égalité de casse, triple égal ou triple. Parce qu'il est implémenté différemment dans chaque classe, il se comportera différemment selon le type d'objet auquel il a été appelé. Généralement, elle renvoie true si l'objet de droite "appartient à" ou "est membre de" l'objet de gauche. Par exemple, il peut être utilisé pour tester si un objet est une instance d'une classe (ou l'une de ses sous-classes).
String === "zen" # Output: => true
Range === (1..2) # Output: => true
Array === [1,2,3] # Output: => true
Integer === 2 # Output: => true
Le même résultat peut être obtenu avec d'autres méthodes qui sont probablement les mieux adaptées au travail. Il est généralement préférable d'écrire du code facile à lire en étant aussi explicite que possible, sans sacrifier l'efficacité et la concision.
2.is_a? Integer # Output: => true
2.kind_of? Integer # Output: => true
2.instance_of? Integer # Output: => false
Notez que le dernier exemple a renvoyé false car les entiers tels que 2 sont des instances de la classe Fixnum, qui est une sous-classe de la classe Integer. Le ===, is_a? et instance_of? Les méthodes renvoient true si l'objet est une instance de la classe donnée ou des sous-classes. La méthode instance_of est plus stricte et ne renvoie true que si l'objet est une instance de cette classe exacte, pas une sous-classe.
L'is_a? et kind_of? Les méthodes sont implémentées dans le module Kernel, qui est mélangé par la classe Object. Les deux sont des alias de la même méthode. Vérifions:
Kernel.instance_method (: kind_of?) == Kernel.instance_method (: is_a?) # Sortie: => true
Implémentation de la gamme ===
Lorsque l'opérateur === est appelé sur un objet de plage, il renvoie vrai si la valeur de droite se situe dans la plage de gauche.
(1..4) === 3 # Output: => true
(1..4) === 2.345 # Output: => true
(1..4) === 6 # Output: => false
("a".."d") === "c" # Output: => true
("a".."d") === "e" # Output: => false
N'oubliez pas que l'opérateur === appelle la méthode === de l'objet de gauche. Donc (1..4) === 3 est équivalent à (1..4). === 3. En d'autres termes, la classe de l'opérande de gauche définira quelle implémentation de la méthode === sera appelé, donc les positions d'opérande ne sont pas interchangeables.
Mise en œuvre regexp de ===
Renvoie true si la chaîne de droite correspond à l'expression régulière de gauche. / zen / === "pratiquer zazen aujourd'hui" # Sortie: => true # est le même que "pratiquer zazen aujourd'hui" = ~ / zen /
Utilisation implicite de l'opérateur === sur les instructions case / when
Cet opérateur est également utilisé sous le capot sur les déclarations case / when. C'est son utilisation la plus courante.
minutes = 15
case minutes
when 10..20
puts "match"
else
puts "no match"
end
# Output: match
Dans l'exemple ci-dessus, si Ruby avait implicitement utilisé l'opérateur double égal (==), la plage 10..20 ne serait pas considérée comme égale à un entier tel que 15. Ils correspondent parce que l'opérateur triple égal (===) est implicitement utilisé dans toutes les instructions case / when. Le code de l'exemple ci-dessus équivaut à:
if (10..20) === minutes
puts "match"
else
puts "no match"
end
Opérateurs de correspondance de motifs: = ~ et! ~
Les opérateurs = ~ (égal-tilde) et! ~ (Bang-tilde) sont utilisés pour faire correspondre les chaînes et les symboles aux motifs d'expression régulière.
L'implémentation de la méthode = ~ dans les classes String et Symbol attend une expression régulière (une instance de la classe Regexp) comme argument.
"practice zazen" =~ /zen/ # Output: => 11
"practice zazen" =~ /discursive thought/ # Output: => nil
:zazen =~ /zen/ # Output: => 2
:zazen =~ /discursive thought/ # Output: => nil
L'implémentation dans la classe Regexp attend une chaîne ou un symbole comme argument.
/zen/ =~ "practice zazen" # Output: => 11
/zen/ =~ "discursive thought" # Output: => nil
Dans toutes les implémentations, lorsque la chaîne ou le symbole correspond au modèle Regexp, il renvoie un entier qui est la position (index) de la correspondance. S'il n'y a pas de correspondance, il renvoie zéro. Souvenez-vous que, dans Ruby, toute valeur entière est "true" et nil est "falsy", donc l'opérateur = ~ peut être utilisé dans les instructions if et les opérateurs ternaires.
puts "yes" if "zazen" =~ /zen/ # Output: => yes
"zazen" =~ /zen/?"yes":"no" # Output: => yes
Les opérateurs de filtrage sont également utiles pour écrire des instructions if plus courtes. Exemple:
if meditation_type == "zazen" || meditation_type == "shikantaza" || meditation_type == "kinhin"
true
end
Can be rewritten as:
if meditation_type =~ /^(zazen|shikantaza|kinhin)$/
true
end
L'opérateur! ~ Est l'opposé de = ~, il renvoie vrai quand il n'y a pas de correspondance et faux s'il y a une correspondance.
Plus d'informations sont disponibles sur ce blog .
"a" == "a"
,"a" === "a"
et"a".eql? "a"
. Mais c'est faux:"a".equal? "a"
(Le mien est rubis 1.9.2-p180)