tutorial - === vs.== en Ruby

ruby wikipedia

Question

En Ruby, ¿cuál es la diferencia entre == y ===? El RDoc dice

Igualdad de caso: para el objeto de clase, efectivamente es lo mismo que llamar a # ==, pero normalmente los anulan los descendientes para proporcionar una semántica significativa en las sentencias de caso.

¿Es #== lo mismo que == ? ¿Podría darnos un ejemplo de cuándo / cómo se usa en las declaraciones de casos?

Answer 1

Dato === , === también se usa para hacer coincidir excepciones en el rescue

Aquí hay un ejemplo

class Example
def self.===(exception)
puts "Triple equals has been called."
true
end
end
raise rescue Example
# => prints "Triple equals has been called."
# => no exception raised

Esto se usa para hacer coincidir los errores del sistema.

SystemCallError.=== se ha definido para devolver true cuando los dos tienen el mismo error. Con este sistema, los errores de llamada con el mismo número de error, como Errno::EAGAIN y Errno::EWOULDBLOCK , se pueden rescatar enumerando solo uno de ellos.

Answer 2

Los dos realmente no tienen nada que ver el uno con el otro. En particular, #== es el operador de igualdad y #=== tiene absolutamente nada con la igualdad. Personalmente, me parece bastante desafortunado que #=== vea tan similar a #== , use el signo igual y a menudo se lo llame operador de igualdad de casos , operador de triple igual o operador de tres puntos cuando realmente no tiene nada que ver con la igualdad.

Llamo a #=== el operador de subsunción de casos (es lo mejor que se me ocurre, estoy abierto a sugerencias, especialmente de hablantes nativos de inglés).

La mejor manera de describir a === b es "si tengo un cajón etiquetado a , ¿tiene sentido poner b en él?"

Entonces, por ejemplo, Module#=== prueba si b.is_a?(a) . Si tiene Integer === 2 , ¿tiene sentido poner 2 en una casilla etiquetada Integer ? Sí, lo hace. ¿Qué pasa con Integer === ''hello'' ? Obviamente no.

Otro ejemplo es Regexp#=== . Prueba para un partido. ¿Tiene sentido poner ''hello'' en una caja etiquetada /el+/ ? Sí, lo hace.

Para colecciones tales como rangos, Range#=== se define como una prueba de membresía: tiene sentido poner un elemento en una caja etiquetada con una colección si ese elemento está en la colección.

Entonces, eso es lo que #=== hace: prueba si el argumento puede ser subsumido bajo el receptor.

¿Qué tiene eso que ver con las expresiones de case ? Sencillo:

case foo
when bar
baz
end

es lo mismo que

if bar === foo
baz
end

Answer 3

Sí, por #== los documentos significan "el método de instancia == del objeto actual".

=== se usa en declaraciones de casos como tales:

case obj
when x
foo
when y
bar
end

Es lo mismo que

if x === obj
foo
elsif y === obj
bar
end

Algunas clases que definen su propio === son Range (para actuar como include? ), Class (para actuar como obj.is_a?(klass) ) y Regexp (para actuar como =~ excepto que devuelve un booleano). Algunas clases que no definen su propio === son las clases numéricas y String.

Asi que

case x
when 0
puts "Lots"
when Numeric
puts(100.0 / x)
when /^/d+$/
puts(100.0 / x.to_f)
default
raise ArgumentError, "x is not a number or numeric string"
end

es lo mismo que

if 0 == x
puts "Lots"
elsif x.is_a? Numeric
puts(100.0 / x)
elsif x =~ /^/d+$/
puts(100.0 / x.to_f)
else
raise ArgumentError, "x is not a number or numeric string"
end