variable - groovy when then

Groovy diferentes resultados en el uso de equals() y== en un GStringImpl

Question

De acuerdo con los documentos groovy , el == es solo un ''inteligente'' igual a () ya que también se encarga de evitar NullPointerException. Entonces, == y equals () deberían devolver el mismo valor si los objetos no son nulos. Sin embargo, obtengo resultados inesperados al ejecutar el siguiente script:

println "${''test''}" == ''test''
println "${''test''}".equals(''test'')

El resultado que obtengo es

true
false

Un ejemplo de esto se puede encontrar here .

¿Es este un error conocido relacionado con GStringImpl o algo que me falta?

Answer 1

Buena pregunta, lo sorprendente del código anterior es que

println "${''test''}".equals(''test'')

devuelve false . La otra línea de código devuelve el resultado esperado, así que olvidémonos de eso.

Resumen

"${''test''}".equals(''test'')

El objeto que se llama es equals a tipo GStringImpl mientras que ''test'' es de tipo String , por lo que no se consideran iguales.

¿Pero por qué?

Obviamente, la implementación de GStringImpl de equals podría haberse escrito de tal manera que cuando se pasa una String que contiene los mismos caracteres, devuelva verdadero. Prima facie, esto parece una cosa razonable de hacer.

Supongo que la razón por la que no se escribió de esta manera es porque violaría el contrato de equals , que establece que:

Es simétrico: para cualquier valor de referencia no nulo x e y, x.equals (y) debería devolver verdadero si y solo si y.equals (x) devuelve verdadero.

La implementación de String.equals(Object other) siempre devolverá false cuando pase un GSStringImpl , por lo que si GStringImpl.equals(Object other) devuelve true cuando pasa cualquier String , estaría en violación del requisito simétrico.

Answer 2

En groovy a == b comprueba primero compareTo método compareTo y usa a.compareTo(b) == 0 si existe un método compareTo . De lo contrario, usará equals .

Dado que Strings y GStrings implementan Comparable existe un método compareTo disponible.

Las siguientes impresiones son verdaderas, como se esperaba:

println "${''test''}".compareTo(''test'') == 0

El comportamiento de == está documentado here .

En Java == significa igualdad de tipos primitivos o identidad para objetos. En Groovy == traduce en a.compareTo(b)==0 , si son Comparable , y a.equals(b) caso contrario. Para verificar la identidad, existe is . Ej a.is(b) .

Para otros operadores, consulte esta tabla: http://docs.groovy-lang.org/docs/latest/html/documentation/#Operator-Overloading

Tabla vinculada provista en línea para la posteridad, en caso de que el enlace de arriba se rompa nuevamente.

| Operator | Method                  |
|----------|-------------------------|
| +        | a.plus(b)               |
| a[b]     | a.getAt(b)              |
| -        | a.minus(b)              |
| a[b] = c | a.putAt(b, c)           |
| *        | a.multiply(b)           |
| a in b   | b.isCase(a)             |
| /        | a.div(b)                |
| <<       | a.leftShift(b)          |
| %        | a.mod(b)                |
| >>       | a.rightShift(b)         |
| **       | a.power(b)              |
| >>>      | a.rightShiftUnsigned(b) |
| |        | a.or(b)                 |
| ++       | a.next()                |
| &        | a.and(b)                |
| --       | a.previous()            |
| ^        | a.xor(b)                |
| +a       | a.positive()            |
| as       | a.asType(b)             |
| -a       | a.negative()            |
| a()      | a.call()                |
| ~a       | a.bitwiseNegate()       |