Programação · CESPE / CEBRASPE · 2025 | Questão sqc-ce216471

JavaScript: operadores de comparação e coerção de tipos

Gabarito: letra E (ERRADO). O código JavaScript apresentado não exibirá true como resultado, pois a comparação '9' > 7 (string com número) é avaliada como true devido à coerção implícita de tipos, mas a expressão '9' === 7 (comparação estrita) é false, pois os tipos são diferentes. A questão explora exatamente a diferença entre os operadores == (igualdade solta) e === (igualdade estrita).

O JavaScript é uma linguagem fracamente tipada, o que significa que ela realiza conversões automáticas de tipos em diversas operações. Isso é uma característica poderosa, mas também uma fonte frequente de bugs e pegadinhas em provas. Para dominar esse tema, é essencial entender como os operadores de comparação se comportam diante de tipos diferentes.

O que são operadores de comparação?

Os operadores de comparação são utilizados para comparar dois valores e retornar um resultado booleano (true ou false). Eles são a base das estruturas condicionais, como if, else e switch. No JavaScript, temos dois grupos principais:

Operadores de igualdade: == (igualdade solta) e === (igualdade estrita).
Operadores relacionais: >, <, >=, <= (maior, menor, maior ou igual, menor ou igual).

A grande diferença entre == e === está na coerção de tipos. O operador == tenta converter os operandos para um tipo comum antes de comparar, enquanto o === exige que ambos os operandos sejam do mesmo tipo e tenham o mesmo valor.

A pegadinha da coerção implícita

A questão apresenta um código que, à primeira vista, parece simples. No entanto, a banca explora a confusão entre os operadores de igualdade. Vamos analisar o que acontece em cada comparação:

'9' > 7: O operador > é relacional. Quando comparamos uma string com um número, o JavaScript converte a string para número. Neste caso, '9' vira 9, e 9 > 7 é true.
'9' === 7: O operador === é de igualdade estrita. Ele não realiza coerção de tipos. Como '9' é uma string e 7 é um número, a comparação é false.

Portanto, a expressão '9' > 7 && '9' === 7 resulta em true && false, que é false. O código não exibirá true.

Exemplo prático

Vamos simular a execução do código em um console JavaScript:

console.log('9' > 7);      // true (a string '9' é convertida para o número 9)
console.log('9' === 7);    // false (tipos diferentes: string vs number)
console.log('9' > 7 && '9' === 7); // false

O resultado final é false, não true.

A distinção que importa: `==` vs `===`

A tabela abaixo resume a diferença crucial entre os dois operadores de igualdade:

Operador	Nome	Coerção de tipos	Exemplo	Resultado
`==`	Igualdade solta	Sim	`'9' == 9`	`true`
`===`	Igualdade estrita	Não	`'9' === 9`	`false`

A banca adora explorar essa diferença. Se a questão tivesse usado == em vez de ===, o resultado seria true, pois '9' == 7 é false (a string '9' vira 9, e 9 não é igual a 7), mas '9' > 7 é true, então true && false ainda seria false. Para que o resultado fosse true, a expressão precisaria ser algo como '9' > 7 && 9 > 7.

A pegadinha da banca

NÃO CAIA NESSA!

A banca troca o operador de igualdade estrita (===) pelo de igualdade solta (==) para confundir o candidato. A pegadinha está em não perceber que '9' === 7 é false porque os tipos são diferentes, mesmo que o valor numérico de '9' seja 9. O candidato que não domina a coerção de tipos do JavaScript pode marcar "Certo" pensando que a string é convertida para número em todas as comparações.

Conclusão

A questão testa o conhecimento sobre os operadores de comparação e a coerção de tipos em JavaScript. A expressão '9' > 7 && '9' === 7 é avaliada como false, pois a segunda parte da expressão é false. Portanto, o item está ERRADO.

Gabarito: letra E (ERRADO).