¿Qué sucede en JavaScript cuando se realiza una…

En la comparación no estricta (==) en JavaScript, se realiza una conversión de tipos (coerción) de los operandos antes de la comparación. Si los tipos de los operandos difieren, JavaScript intenta convertir uno o ambos operandos a un mismo tipo, basándose en una serie de reglas.

Reglas principales de conversión con ==:

Número y cadena: La cadena se convierte en número. Si no se puede convertir (NaN), el resultado siempre es false.

// "10" se convierte en 10. Resultado: true
console.log(10 == "10");
// "abc" se convierte en NaN. Resultado: false
console.log(10 == "abc");

Booleano y no-Booleano: El Booleano se convierte en número (true en 1, false en 0). Luego se comparan el número y el otro operando (que puede ser convertido).

// true se convierte en 1. Resultado: true
console.log(true == 1);
// false se convierte en 0. Resultado: true
console.log(false == 0);
// false se convierte en 0, "0" se convierte en 0. Resultado: true
console.log(false == "0");

Null y Undefined: null se compara con undefined como true, y con nada más (excepto consigo mismo) como true.

// Resultado: true
console.log(null == undefined);
// Resultado: false
console.log(null == 0);
// Resultado: false
console.log(undefined == 0);

Objeto y primitivo: El objeto se convierte en primitivo (usando los métodos valueOf o toString), y luego se comparan los primitivos.

// El objeto se convierte en la cadena "10" (a través de toString()), y luego se compara con el número 10
// "10" se convierte en 10. Resultado: true
console.log({ toString: () => "10" } == 10);

Símbolo y otro: El símbolo solo puede compararse con otro símbolo o con un valor primitivo al que el símbolo pueda ser convertido (lo cual en casos estándar es imposible).
```
// Resultado: false
console.log(Symbol('a') == 'a');
```

La comparación no estricta puede dar resultados inesperados debido a la conversión automática de tipos. Para un comportamiento más predecible, se recomienda usar comparación estricta (===), que no realiza conversión de tipos y compara los operandos directamente.

¿Qué sucede en JavaScript cuando se realiza una comparación no estricta (==)?