Ao executar +, -, *, /, ==,! =, Etc. Em JavaScript, se o valor digitar em ambos os lados do operador for inconsistente com o tipo esperado, o JavaScript converterá os valores em ambos os lados do operador no tipo esperado antes de executar operações. Quando o tipo de valor esperado for string, o JavaScript converterá o valor em string; Quando o tipo de valor esperado é o número, o JavaScript converterá o valor em número (se não puder ser convertido em um valor numérico, ele retornará a NAN). Por exemplo:
A cópia do código é a seguinte:
console.log (10 + "gatos"); // 10 gatos
console.log (10 * "gatos"); // nan, "gatos" serão convertidos em nan
console.log (10 + "2"); // 102
console.log (10 - "2"); // 8
console.log (10/"2"); // 5
console.log (10 * "2"); // 20
console.log (10 * "2"); // 20
console.log ("10" * "2"); // 20
Regras de conversão de tipo de valor
Para obter as regras de conversão de valor em JavaScript, consulte a Tabela 3-2. Conversões do tipo JavaScript no livro "JavaScript the Definitive Guide". Alguns dos lugares mais notáveis são:
1. O resultado é NAN após a conversão indefinida em número.
2. O resultado é 0 após a conversão de NULL em número.
3. O resultado é 0 após a conversão da string vazia "" em número.
4. O resultado é "0" após a conversão-0 em string.
5. O resultado é 0 após a conversão da matriz vazia [] em número.
6. A matriz com apenas um membro do número (como [9]) é convertida em número e o resultado é o valor do número (9).
Quando JavaScript converte a string em número, há mais duas regras interessantes:
1. O JavaScript excluirá os caracteres de espaço em branco no início e no final da string antes de convertê -la, para que as cordas como "42" possam ser convertidas com sucesso no número 42.
2. Depois de excluir os caracteres de espaço em branco no início e no final, se a string ainda contiver caracteres não numéricos, a string será convertida em NAN. Por exemplo: "3 m" será convertido em NAN.
Exemplo:
A cópia do código é a seguinte:
console.log (10 * "3"); // 30
console.log (10 * "3 m"); // nan, "3 m" será convertido em nan
Tipo de valor Conversão e comparação
No JavaScript, o uso de operador igual (==) envolve conversão de tipo de valor: se os tipos de valor nos dois lados do operador == forem inconsistentes, o JS os converterá em tipos consistentes antes de fazer julgamentos. Tenha cuidado para que dois tipos diferentes de valores possam ser equivalentes após a conversão do tipo, mas isso não significa que o resultado do uso do operador == para eles deve ser verdadeiro. Um exemplo simples é indefinido e falso: o resultado de indefinido após a conversão indefinido para o tipo booleano é exatamente falso, mas na verdade o resultado de indefinido == false é falso.
Conversão do tipo explícito
A conversão do tipo automático usando JavaScript é muito conveniente, mas pode causar facilmente problemas como a manutenção de código. Para tornar o código do programa mais claro e menos ambiguidade, as conversões de tipo explícitas são às vezes usadas nos programas JS:
A cópia do código é a seguinte:
Número ("3") // 3
String (false) // "false"
Booleano ([]) // true
Na maioria dos casos, o resultado da conversão do tipo explícito é consistente com o resultado da conversão do tipo automático JS; Mas há um caso especial: quando nulo ou indefinido é automaticamente convertido em objeto, o JS lançará um erro TypeError; Mas quando nulo ou indefinido é explicitamente convertido em objeto, o JS retornará um objeto vazio:
A cópia do código é a seguinte:
console.log (objeto (indefinido)); // Objeto vazio
console.log (objeto (nulo)); // Objeto vazio
Ao mesmo tempo, se o tipo especificado pela conversão explícita for diferente do tipo especificado pela conversão automática de JS, os resultados obtidos também serão diferentes. Por exemplo, o resultado de indefinido == false mencionado anteriormente é falso; Se o tipo de conversão for explicitamente especificado como booleano, o resultado será verdadeiro:
A cópia do código é a seguinte:
console.log (indefinido == false); // false
console.log (booleano (indefinido) == boolean (false)); // true
Uso de conversão do tipo automático
No JS, a conversão automática de tipos de valor pode ser usada para alcançar o mesmo efeito que a conversão explícita por meio de operadores, como:
A cópia do código é a seguinte:
console.log (false + ""); // "false"
console.log (+false); // 0
console.log (!! 3); // true