funciona - ¿Por qué 2==[2] en JavaScript?

javascript pdf

Question

Recientemente descubrí que 2 == [2] en JavaScript. Como resultado, esta peculiaridad tiene un par de consecuencias interesantes:

var a = [0, 1, 2, 3];
a[[2]] === a[2]; // this is true

Del mismo modo, los siguientes trabajos:

var a = { "abc" : 1 };
a[["abc"]] === a["abc"]; // this is also true

Aún más extraño aún, esto también funciona:

[[[[[[[2]]]]]]] == 2; // this is true too! WTF?

Estos comportamientos parecen consistentes en todos los navegadores.

¿Alguna idea de por qué esta es una función de idioma?

Aquí hay más consecuencias insanas de esta "característica":

[0] == false // true
if ([0]) { /* executes */ } // [0] is both true and false!
var a = [0];
a == a // true
a == !a // also true, WTF?

Estos ejemplos fueron encontrados por jimbojw http://jimbojw.com fame y walkingeyerobot .

Answer 1

Está comparando 2 objetos en cada caso ... No use ==, si está pensando en la comparación, está teniendo === en mente y no ==. == a menudo puede dar efectos locos. Busque las partes buenas en el idioma :)

Answer 2

Explicación para la sección EDITAR de la pregunta:

Primer ejemplo

[0] == false // true
if ([0]) { /* executes */ } // [0] is both true and false!

Primero tipocast [0] a un valor primitivo según la respuesta de Christoph anterior, tenemos "0" ( [0].valueOf().toString() )

"0" == false

Ahora, escriba booleano (falso) en Número y luego en Cadena ("0") en Número

Number("0") == Number(false)
or 0 == 0
so, [0] == false // true

En cuanto a la instrucción if , si no hay una comparación explícita en la condición if en sí misma, la condición evalúa los valores verdaderos .

Solo hay 6 valores falsy : falso, nulo, indefinido, 0, NaN y cadena vacía "". Y cualquier cosa que no sea un valor falso es un valor verdadero.

Como [0] no es un valor falso, es un valor verdadero, la instrucción if evalúa como verdadera y ejecuta la declaración.

Segundo ejemplo

var a = [0];
a == a // true
a == !a // also true, WTF?

Nuevamente, ingrese los valores a primitivo,

 a = a
or [0].valueOf().toString() == [0].valueOf().toString()
or "0" == "0" // true; same type, same value
a == !a
or [0].valueOf().toString() == [0].valueOf().toString()
or "0" == !"0"
or "0" == false
or Number("0") == Number(false)
or 0 = 0 // true

Answer 3

Para agregar un pequeño detalle a las otras respuestas ... al comparar una Array con un Number , Javascript convertirá la Array con parseFloat(array) . Puede probarlo usted mismo en la consola (por ejemplo, Firebug o Web Inspector) para ver a qué se convierten los diferentes valores de Array .

parseFloat([2]); // 2
parseFloat([2, 3]); // 2
parseFloat(['''', 2]); // NaN

Para Array s, parseFloat realiza la operación en el primer miembro de la Array y descarta el resto.

Editar: Según los detalles de Christoph, puede ser que esté utilizando la forma más larga internamente, pero los resultados son consistentemente idénticos a parseFloat , por lo que siempre puede usar parseFloat(array) como taquigrafía para saber con certeza cómo se convertirá.

Answer 4

Para el caso == , esta es la razón por la que Doug Crockford recomienda usar siempre === . No realiza ninguna conversión de tipo implícita.

Para los ejemplos con === , la conversión de tipo implícita se realiza antes de llamar al operador de igualdad.

Answer 5

Puede buscar el algoritmo de comparación en la especificación ECMA (secciones relevantes de ECMA-262, 3ª edición para su problema: 11.9.3, 9.1, 8.6.2.6).

Si traduces los algoritmos abstractos involucrados de nuevo a JS, lo que sucede al evaluar 2 == [2] es básicamente esto:

2 === Number([2].valueOf().toString())

donde valueOf() para matrices devuelve la matriz en sí misma y la representación de cadena de una matriz de un elemento es la representación de cadena del elemento individual.

Esto también explica el tercer ejemplo como [[[[[[[2]]]]]]].toString() sigue siendo solo la cadena 2 .

Como puede ver, hay una gran cantidad de magia detrás de escena involucrada, por lo que generalmente solo uso el operador estricto de igualdad === .

El primer y segundo ejemplo son más fáciles de seguir ya que los nombres de propiedad siempre son cadenas, por lo que

a[[2]]

es equivalente a

a[[2].toString()]

que es solo

a["2"]

Tenga en cuenta que incluso las claves numéricas se tratan como nombres de propiedad (es decir, cadenas) antes de que ocurra cualquier magia de matriz.

Answer 6

Se debe a la conversión de tipo implícito del operador == .

[2] se convierte en Número es 2 cuando se compara con un Número. Pruebe el operador unario + en [2].

> +[2]
2

Answer 7

Una matriz de un elemento se puede tratar como el elemento mismo.

Esto se debe a la mecanografía pato. Desde "2" == 2 == [2] y posiblemente más.

Answer 8

[0] == false // true
if ([0]) { /* executes */ } // [0] is both true and false!

Eso es interesante, no es que [0] sea verdadero y falso, en realidad

[0] == true // false

Es la forma divertida de Javascript de procesar el operador if ().

Answer 9

var a = [0, 1, 2, 3];
a[[2]] === a[2]; // this is true

En el lado derecho de la ecuación, tenemos a [2], que devuelve un tipo de número con valor 2. A la izquierda, primero estamos creando una nueva matriz con un solo objeto de 2. Entonces estamos llamando a un [( array está aquí)]. No estoy seguro de si esto se evalúa como una cadena o un número. 2 o "2". Vamos a tomar el caso de cuerda primero. Creo que un ["2"] crearía una nueva variable y devolvería nulo. null! == 2. Asumamos que en realidad se está convirtiendo implícitamente en un número. a [2] devolvería 2. 2 y 2 coinciden en tipo (por lo que === funciona) y valor. Creo que está convirtiendo implícitamente la matriz en un número porque un [valor] espera una cadena o un número. Parece que el número tiene mayor prioridad.

En una nota lateral, me pregunto quién determina esa precedencia. ¿Es porque [2] tiene un número como primer elemento, por lo que se convierte en un número? ¿O es que al pasar una matriz a una [matriz] intenta convertir primero la matriz en un número, luego en una cadena? ¿Quién sabe?

var a = { "abc" : 1 };
a[["abc"]] === a["abc"];

En este ejemplo, está creando un objeto llamado a con un miembro llamado abc. El lado derecho de la ecuación es bastante simple; es equivalente a a.abc. Esto devuelve 1. Primero, el lado izquierdo crea una matriz literal de ["abc"]. A continuación, busca una variable en el objeto pasando la matriz recién creada. Como esto espera una cadena, convierte la matriz en una cadena. Esto ahora se evalúa como a ["abc"], que equivale a 1. 1 y 1 son del mismo tipo (por lo que === funciona) e igual valor.

[[[[[[[2]]]]]]] == 2;

Esto es solo una conversión implícita. === no funcionaría en esta situación porque hay un desajuste de tipo.