Quelle est la différence entre l'égalité?, eql?, = = = et ==?

Je vais fortement citation l'Objet de la documentation ici, parce que je pense qu'il a quelques grandes explications. Je vous encourage à le lire, et aussi à la documentation de ces méthodes car elles sont remplacées dans d'autres classes, comme Chaîne.

Côté remarque: si vous voulez les essayer pour vous-même sur des objets différents, utiliser quelque chose comme ceci:

class Object
  def all_equals(o)
    ops = [:==, :===, :eql?, :equal?]
    Hash[ops.map(&:to_s).zip(ops.map {|s| send(s, o) })]
  end
end

"a".all_equals "a" # => {"=="=>true, "==="=>true, "eql?"=>true, "equal?"=>false}

---

== — générique de "l'égalité"

Au niveau de l'Objet, == renvoie true uniquement si obj et other sont le même objet. En général, cette méthode est redéfinie dans les classes descendantes de fournir spécifiques à la classe de sens.

C'est le plus commun de comparaison, et donc les plus fondamentales de l'endroit où vous (en tant qu'auteur d'une classe) de décider si deux objets sont "égaux" ou pas.

=== cas d'égalité

Pour Objet de classe, effectivement la même que l'appel à la #==, mais généralement remplacée par descendants de fournir une sémantique correcte dans le cas des déclarations.

C'est incroyablement utile. Des exemples de choses qui sont intéressantes === implémentations:

• Gamme
• Regex
• Proc (en Ruby 1.9)

De sorte que vous pouvez faire des choses comme:

case some_object
when /a regex/
  # The regex matches
when 2..4
  # some_object is in the range 2..4
when lambda {|x| some_crazy_custom_predicate }
  # the lambda returned true
end

Voir ma réponse ici pour un exemple clair de la façon dont case+Regex peut rendre le code beaucoup plus propre. Et bien sûr, en fournissant votre propre === mise en œuvre, vous pouvez obtenir personnalisé case sémantique.

eql? — Hash l'égalité

La eql? méthode retourne true si obj et other reportez-vous à la même clé de hachage. Il est utilisé par Hash pour tester les membres de l'égalité. Pour les objets de la classe Object, eql? est synonyme de ==. Les sous-classes normalement continuer cette tradition en aliasing eql? à leur substituée == méthode, mais il y a des exceptions. Numeric types, par exemple, d'effectuer le type de conversion à travers ==, mais pas à travers eql?, donc:

1 == 1.0     #=> true
1.eql? 1.0   #=> false

Vous êtes donc libre de remplacer cette valeur pour votre propre usage, ou vous pouvez remplacer == et l'utilisation alias :eql? :== donc, les deux méthodes se comportent de la même manière.

equal? — identité comparaison

Contrairement à ==, le equal? méthode ne doit jamais être remplacées par des sous-classes: il est utilisé pour déterminer l'identité de l'objet (qui est, a.equal?(b) iff a est le même objet que b).

C'est effectivement le pointeur de la comparaison.

Opérateurs d'égalité: == et !=

L'opérateur==, aussi connu comme l'égalité ou la double égalité, renvoie true si les deux objets sont égaux, et false si ils ne le sont pas.

"koan" == "koan" # Output: => true

L' != l'opérateur, aussi connu comme l'inégalité, est à l'opposé de ==. Elle renvoie true si les deux objets ne sont pas égaux, et false si elles sont égales.

"koan" != "discursive thought" # Output: => true

Noter que les deux tableaux, avec les mêmes éléments dans un ordre différent ne sont pas égaux, les majuscules et les minuscules versions de la même lettre ne sont pas égaux et ainsi de suite.

Lorsque l'on compare les nombres de types différents (par exemple, entiers et à virgule flottante), si leur valeur numérique est la même chose, == retourne true.

2 == 2.0 # Output: => true

l'égalité?

À la différence de l'opérateur == qui teste si les deux opérandes sont de valeur égale, l'égalité de méthode vérifie si les deux opérandes font référence au même objet. C'est la forme la plus stricte de l'égalité 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 de caractères avec la même valeur. Cependant, ils sont deux objets distincts, avec différents Identifiants d'objets. Par conséquent, l'égalité? méthode renvoie false.

Nous allons essayer de nouveau, mais cette fois-b sera une référence à un. Notez que l'ID de l'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, le eql? méthode il est utilisé pour tester des clefs pour l'égalité. Un peu de fond est nécessaire pour expliquer cela. Dans le contexte général de l'informatique, une fonction de hachage prend une chaîne de caractères (ou un fichier) de toute taille et génère une chaîne ou un entier de taille fixe appelés hashcode, communément appelé seulement de hachage. Couramment utilisé hashcode types sont MD5, SHA-1, et le CRC. Ils sont utilisés dans les algorithmes de chiffrement, indexation de bases de données, fichier de vérification de l'intégrité, etc. Certains langages de programmation, comme le Rubis, de fournir un type de collection appelée table de hachage. Les tables de hachage sont de type dictionnaire des collections qui stockent des données dans des paires, composé de clés uniques et leurs valeurs correspondantes. Sous le capot, ces clés sont stockées en tant que hashcodes. Les tables de hachage sont communément appelés les tables de hachage. Remarquez comment le mot hashcan se référer à un hashcode ou à une table de hachage. Dans le contexte de programmation Ruby, le mot de hachage renvoie presque toujours à un dictionnaire comme collection.

Ruby fournit une méthode intégrée appelé hash pour générer des codes hachés. Dans l'exemple ci-dessous, il prend une chaîne de caractères et renvoie un hashcode. Remarquez comment les chaînes avec la même valeur de toujours avoir le même hashcode, même si elles sont des objets distincts (avec différents Identifiants d'objets).

"meditation".hash  # Output: => 1396080688894079547
"meditation".hash  # Output: => 1396080688894079547
"meditation".hash  # Output: => 1396080688894079547

La méthode de hachage est mis en œuvre dans le module du Noyau, inclus dans la classe de l'Objet, qui est la valeur par défaut de la racine de tous les objets Ruby. Certaines classes comme le Symbole Entier et utiliser la valeur par défaut de mise en œuvre, d'autres, comme la Chaîne de Hachage et de fournir 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

En Ruby, lorsque nous stockons quelque chose dans une table de hachage (collection), l'objet fourni en tant que clé (par exemple, une chaîne ou un symbole) est convertie et stockée comme un hashcode. Plus tard, lors de la récupération d'un élément de la table de hachage (collection), nous fournissons un objet comme une clé, qui est converti en un hashcode et par rapport à l'existant clés. Si il y a une correspondance, la valeur de l'élément correspondant est retourné. La comparaison est faite à l'aide de la 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, la eql? la méthode se comporte de façon similaire à l' == méthode. Cependant, il existe quelques exceptions. Par exemple, eql? n'effectue pas de conversion de type implicite lors de la comparaison d'un nombre entier à un flotteur.

2 == 2.0    # Output: => true
2.eql? 2.0    # Output: => false
2.hash == 2.0.hash  # Output: => false

Cas opérateur d'égalité: ===

Beaucoup de Ruby sont intégrés dans les classes, tels que la Chaîne, la Portée et la Regexp, fournir leurs propres implémentations de l' === opérateur, aussi connu comme cas d'égalité, le triple est égal ou threequals. Parce qu'il est mis en œuvre différemment dans chaque classe, il va se comporter différemment selon le type d'objet, il a été appelé. Généralement, elle renvoie true si l'objet sur la droite "appartient à" ou "est un membre de" l'objet sur la gauche. Par exemple, il peut être utilisé pour tester si un objet est une instance d'une classe (ou un 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és pour le travail. Il est généralement préférable d'écrire du code qui est facile à lire par être 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

Avis le dernier exemple retourné false parce que des entiers tels que les 2 sont des instances de la Fixnum classe, qui est une sous-classe de la classe Integer. L' ===, is_a? et instance_of? méthodes renvoie true si l'objet est une instance de la classe donnée ou toutes les sous-classes. Le instance_of méthode est plus stricte et ne retourne true si l'objet est une instance de la même classe, pas une sous-classe.

La is_a? et kind_of? les méthodes sont implémentées dans le module du Noyau, qui est mélangé par la classe de l'Objet. Les deux sont des alias à la même méthode. Nous allons vérifier:

Noyau.instance_method(:kind_of?) == Noyau.instance_method(:is_a?) # Sortie: => true

Gamme de mise en Œuvre de l' ===

Lorsque l' === opérateur est appelée sur un objet de la plage, elle renvoie true si la valeur sur la droite se situe dans la plage sur la 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

Rappelez-vous que l' === opérateur invoque l' === méthode de la gauche de l'objet. Donc (1..4) === 3 est équivalent à (1..4).=== 3. En d'autres termes, la classe de la gauche opérande permettra de définir la mise en œuvre de l' === méthode sera appelée, si l'opérande de postes ne sont pas interchangeables.

Regexp mise en Œuvre de l' ===

Retourne true si la chaîne sur la droite correspond à l'expression régulière sur la gauche.
/zen/=== "la pratique de zazen aujourd'hui" # Sortie: => true
# est le même que
"la pratique de zazen aujourd'hui"=~ /zen/

Implicite de l'utilisation de l' === opérateur de cas/quand consolidés

Cet opérateur est également utilisé sous le capot de cas/quand consolidés. C'est son usage le plus courant.

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é le double opérateur égal (==), la gamme 10..20 ne serait pas considérée comme égale à un nombre entier, par exemple 15. Ils correspondent à cause de la triple opérateur égal (===) est implicitement utilisée dans tous les cas/quand consolidés. Le code dans l'exemple ci-dessus est équivalente à:

if (10..20) === minutes
  puts "match"
else
  puts "no match"
end

Pattern matching opérateurs: =~ et !~

L' =~ (égale-tilde) et !~ (bang-tilde) les opérateurs sont utilisés pour faire correspondre les chaînes de caractères et des symboles à l'encontre de modèles regex.

La mise en œuvre de l' =~ méthode dans la Chaîne et le Symbole des classes s'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

La mise en œuvre dans la classe Regexp attend une chaîne ou d'un symbole comme un argument.

/zen/ =~ "practice zazen"  # Output: => 11
/zen/ =~ "discursive thought" # Output: => nil

Dans toutes les implémentations, lorsque la chaîne ou le symbole correspond à l'expression régulière pattern, elle renvoie un entier qui correspond à la position (index) de la correspondance. Si aucune correspondance n'est trouvée, elle renvoie nil. Rappelez-vous que, en Ruby, n'importe quelle valeur entière est "truthy" et de néant est "falsy", de sorte que l' =~ opérateur peut être utilisé dans les instructions if et ternaires opérateurs.

puts "yes" if "zazen" =~ /zen/ # Output: => yes
"zazen" =~ /zen/?"yes":"no" # Output: => yes

"Pattern-matching" les opérateurs sont également utiles pour l'écriture de courts si les déclarations. 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' !~ l'opérateur est à l'opposé de =~, elle renvoie true quand il n'y a pas de match, et false si il y a un match.

Plus d'infos sont disponibles sur ce blog.

Je voudrais élargir le === opérateur.

=== n'est pas un opérateur d'égalité!

Pas.

Let's get ce point, vraiment partout.

Vous pourriez être familier avec === comme un opérateur d'égalité en Javascript et en PHP, mais ce tout simplement pas un opérateur d'égalité en Ruby et a fondamentalement différent de la sémantique.

Donc, ce n'est === faire?

=== est le filtrage de l'opérateur!

• === correspond à des expressions régulières
• === vérifie adhésion plage
• === vérifie instance d'une classe
• === appelle les expressions lambda
• === parfois vérifie l'égalité, mais la plupart du temps, il n'a pas

Alors, comment est-ce de la folie de sens?

• Enumerable#grep utilise === en interne
• case when consolidés === en interne
• Fait amusant, rescue utilise === en interne

C'est pourquoi vous pouvez utiliser des expressions régulières et des classes et des plages et même des expressions lambda dans un case when déclaration.

Quelques exemples

case value
when /regexp/
  # value matches this regexp
when 4..10
  # value is in range
when MyClass
  # value is an instance of class
when ->(value) { ... }
  # lambda expression returns true
when a, b, c, d
  # value matches one of a through d with `===`
when *array
  # value matches an element in array with `===`
when x
  # values is equal to x unless x is one of the above
end

Tous ces exemple travailler avec pattern === value trop, ainsi qu'avec grep méthode.

arr = ['the', 'quick', 'brown', 'fox', 1, 1, 2, 3, 5, 8, 13]
arr.grep(/[qx]/)                                                                                                                            
# => ["quick", "fox"]
arr.grep(4..10)
# => [5, 8]
arr.grep(String)
# => ["the", "quick", "brown", "fox"]
arr.grep(1)
# => [1, 1]

J'ai écrit un test simple pour tous les ci-dessus.

def eq(a, b)
  puts "#{[a, '==',  b]} : #{a == b}"
  puts "#{[a, '===', b]} : #{a === b}"
  puts "#{[a, '.eql?', b]} : #{a.eql?(b)}"
  puts "#{[a, '.equal?', b]} : #{a.equal?(b)}"
end

eq("all", "all")
eq(:all, :all)
eq(Object.new, Object.new)
eq(3, 3)
eq(1, 1.0)