O que acontece no JavaScript ao fazer uma comparação…

Na comparação não estrita (==) em JavaScript, ocorre uma conversão de tipos (coerção) dos operandos antes da comparação. Se os tipos dos operandos forem diferentes, o JavaScript tenta converter um ou ambos os operandos para um mesmo tipo, com base numa série de regras.

Regras principais de conversão com ==:

Número e string: A string é convertida em número. Se a conversão falhar (NaN), o resultado é sempre false.

// "10" converte-se em 10. Resultado: true
console.log(10 == "10");
// "abc" converte-se em NaN. Resultado: false
console.log(10 == "abc");

Booleano e não-Booleano: O Booleano é convertido em número (true em 1, false em 0). Depois, compara-se o número e o outro operando (que pode ser convertido).

// true converte-se em 1. Resultado: true
console.log(true == 1);
// false converte-se em 0. Resultado: true
console.log(false == 0);
// false converte-se em 0, "0" converte-se em 0. Resultado: true
console.log(false == "0");

Null e Undefined: null é igual a undefined como true, e a mais nada (exceto a si mesmo) como true.

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

Objeto e primitivo: O objeto é convertido em primitivo (usando valueOf ou toString), e depois os primitivos são comparados.

// O objeto converte-se na string "10" (via toString()), e depois é comparado com o número 10
// "10" converte-se em 10. Resultado: true
console.log({ toString: () => "10" } == 10);

Símbolo e outro: O símbolo só pode ser comparado com outro símbolo ou com um valor primitivo ao qual o símbolo possa ser convertido (o que na maioria dos casos é impossível).
```
// Resultado: false
console.log(Symbol('a') == 'a');
```

A comparação não estrita pode levar a resultados inesperados devido à conversão automática de tipos. Para um comportamento mais previsível, recomenda-se usar a comparação estrita (===), que não realiza conversão de tipos e compara os operandos diretamente.

O que acontece no JavaScript ao fazer uma comparação não estrita (==)?