Ruby Language Opérateur d'égalité de cas (===)


Exemple

Aussi connu sous le nom de triple equals .

Cet opérateur ne teste pas l'égalité, mais teste plutôt si l'opérande droit a une relation IS A avec l'opérande gauche. En tant que tel, l' opérateur d'égalité de noms populaire est trompeur.

Cette réponse SO le décrit ainsi: la meilleure façon de décrire a === b est "si j'ai un tiroir étiqueté a , est-il judicieux d'y mettre b ?" En d'autres termes, l'ensemble a inclut-il le membre b ?

Exemples ( source )

(1..5) === 3            # => true
(1..5) === 6            # => false

Integer === 42          # => true
Integer === 'fourtytwo' # => false

/ell/ === 'Hello'       # => true
/ell/ === 'Foobar'      # => false

Classes qui remplacent ===

De nombreuses classes remplacent === pour fournir une sémantique significative dans les instructions de cas. Certains d'entre eux sont:

╔═════════════════╦════════════════════╗
║      Class      ║     Synonym for    ║
╠═════════════════╬════════════════════╣
║ Array           ║ ==                 ║
║                 ║                    ║
║ Date            ║ ==                 ║
║                 ║                    ║
║ Module          ║ is_a?              ║
║                 ║                    ║
║ Object          ║ ==                 ║
║                 ║                    ║
║ Range           ║ include?           ║
║                 ║                    ║
║ Regexp          ║ =~                 ║
║                 ║                    ║
║ String          ║ ==                 ║
╚═════════════════╩════════════════════╝

Pratique recommandée

L'utilisation explicite de l'opérateur d'égalité de casse === doit être évitée. Il ne teste pas l'égalité, mais plutôt la subsomption , et son utilisation peut être source de confusion. Le code est plus clair et plus facile à comprendre lorsque la méthode synonyme est utilisée à la place.

# Bad
Integer === 42
(1..5) === 3
/ell/ === 'Hello'

# Good, uses synonym method
42.is_a?(Integer)
(1..5).include?(3)
/ell/ =~ 'Hello'