Considere o código JavaScript a seguir. var x1 var x2 var x3 var y = 11 var z = 12 x1= z++ == ++y x2= 10 + "casa" x3= y+1 === z && 10 != "20" Após a execução dessas operações, os valores de x1, x2 e x3 são, respectivamente:
- A)false 10casa true
Errada, porque x1 não é false e x3 também não é false; ambos ficam true.
- B)false 10casa false
Errada, porque x1 não é false e x3 não é false, embora x2 esteja correto.
- C)false undefined false
Errada, porque x2 não vira undefined, e x1 e x3 também não são false.
- D)true 10casa true
Correta, pois x1 = true, x2 = 10casa e x3 = true após as conversões e incrementos.
- E)true undefined false
Errada, porque x1 não é true por acaso e x2 não é undefined; o segundo valor é concatenação de string.
Gabarito: D
Em JavaScript, alguns operadores parecem simples, mas adoram fazer você cair em armadilha de conversão de tipos. Aqui entram três clássicos: incremento pós-fixado (z++) e pré-fixado (++y), comparação frouxa (==, !=) e comparação estrita (===). A regra prática é: com == e !=, o JavaScript pode converter valores antes de comparar; com === e !==, ele compara valor e tipo ao mesmo tempo. Na primeira expressão, x1 = z++ == ++y, o valor de z++ é usado antes do aumento, então ele vale 12 na comparação e depois vira 13. Já ++y incrementa y antes de comparar, então y vai de 11 para 12 e a comparação fica 12 == 12, resultando em true. Ou seja, x1 é true. Na segunda, x2 = 10 + "casa". Como um dos operandos é texto, o operador + vira concatenação. Resultado: "10casa". É o famoso momento em que a matemática pede licença e a string toma conta da conta. Na terceira, x3 = y+1 === z && 10 != "20". Depois da primeira linha, y vale 12 e z vale 13. Então y+1 dá 13, que é estritamente igual a z, logo a primeira parte é true. Na segunda parte, 10 != "20" também é true, porque "20" é convertido para número 20 e 10 é diferente de 20. Assim, true && true dá true. Por isso o gabarito D está correto: x1 = true, x2 = 10casa e x3 = true.