ruby - visual - string to boolean javascript




¿Por qué la expresión(true== true== true) produce un error de sintaxis? (2)

TL; DR La sintaxis implica que los 3 valores son iguales, esto no es lo que hace en javascript o C, por lo que al dar ruby ​​un error de sintaxis, la puerta está abierta para que esto se implemente en el futuro.

Si entiendo la pregunta correctamente, value_a == value_b == value_c solo debería devolver verdadero si todos son iguales usando == como el operador de comparación como se muestra en este método

# version 1
def compare_3_values(a, b, c)
  a == b && a == c && b == c
end

Sin embargo, hay otro posible resultado esperado. para implementar esto como se muestra en la respuesta anterior:

#version 2
def compare_3_values(a, b, c)
  (a == b) == c
end

Los resultados son mundos aparte.

JavaScript siempre usa la versión 2, que es bastante inútil ya que el tercer elemento siempre se compara con verdadero o falso (0 o 1 si el tercer elemento es un entero) es por eso que false == false == true devuelve verdadero.

para asegurar que si un método es uno de los tres valores que solo se llama una vez que tengamos que crear una copia (no una referencia) de las tres variables y luego hacer las comparaciones de esta manera:

def compare_3_values(a_original, b_original, c_original)
  #duplicate all three values as a, b, c
  a, b, c = a_original.dup, b_original.dup, c_original.dup

  a == b && b == c && a == c
end

La buena noticia es que debido a que Ruby da un error de sintaxis, es el único lenguaje que puede implementar esto sin romper el código de todos.

para cualquier otro idioma, rompería tanto código que, incluso si se implementara en una versión principal posterior, necesitaría una bandera / configuración para activar o desactivar esto en los próximos años, por lo que nunca valdrá la pena.

Algunos resultados interesantes en Ruby

false .== false == true
=> true

false .== true == false
=> true

true .== false == false
=> true

false .== false == false
=> false

true .== true == false
false

Y en javascript

false == false == true
=> true

false == true == false
=> true

true == false == false
=> true

false == false == false
=> false

true == true == false
=> false

Editar probado también en C, actúa de manera similar a JavaScript en que compara el resultado de los dos primeros valores con el tercer valor

Rubí :

true == true == true

error de sintaxis, tEQ inesperado

vs. JavaScript :

true == true == true
// => true

vs. C :

1 == 1 == 1
// => 1

La primera respuesta es excelente, pero en caso de que no esté completamente claro (y la gente pregunta por qué), aquí hay algunos ejemplos más.

En C, el operador == es asociativo de izquierda a derecha y el booleano se representa como 1 (verdadero) y 0 (falso), por lo que el primer 1 == 1 evalúa como 1 (verdadero) y luego está evaluando el resultado de primera expresión con la segunda. Puedes probar:

2 == 2 == 2 // => 0

Que en C, se evalúa como:

(2 == 2) == 2
1 == 2 // => 0

En Javascript, de manera similar a C, == es asociativo de izquierda a derecha. Intentemos con 0 esta vez (aunque el mismo ejemplo de C también funcionaría):

0 == 0 == 0
false

Otra vez:

0 == 0 == 0
true == 0 // => false

En Ruby == no tiene propiedades asociativas, es decir. no se puede usar varias veces en una sola expresión, por lo que esa expresión no se puede evaluar. Por qué se tomó esa decisión es una pregunta para el autor del lenguaje. Además, Ruby no define el número 1 como booleano, por lo que 1 == true evalúa como falso.

La segunda respuesta indica que hay algunos casos "extraños" en Ruby, pero todos evalúan como se esperaba:

(1 == 1) == 1
true == 1 # => false

1 == (1 == 1)
1 == true # => false

1 .== 1 == 1
(1 == 1) == 1
true == 1 # => false

false .== false == true
(false == false) == true
true == true # => true

false .== true == false
(false == true) == false
false == false # => true

true .== false == false
(true == false) == false
false == false # => true

false .== false == false
(false == false) == false
true == false # => false

true .== true == false
(true == true) == false
true == false # => false




associativity