Tipos primitivos ECMAScript

O ECMAScript possui 5 tipos primitivos (primitive type), ou seja, Undefined, Null, Boolean, Number e String.

Operador typeof

O operador typeof tem um parâmetro, que é a variável ou valor a ser verificado. Por exemplo:

var sTemp = "test string";
alert (typeof sTemp);    //Saída "string"
alert (typeof 86);    //Saída "number"

A chamada do operador typeof em uma variável ou valor retornará um dos seguintes valores:

  • undefined - Se a variável for do tipo Undefined
  • boolean - Se a variável for do tipo Boolean
  • number - Se a variável for do tipo Number
  • string - Se a variável for do tipo String
  • object - Se a variável for um tipo de referência ou do tipo Null

Notas:Talvez você pergunte, por que o operador typeof retorna "Object" para valores null. Isso é, na verdade, um erro na implementação inicial do JavaScript, que foi adotado pelo ECMAScript. Agora, null é considerado um placeholder para objetos, explicando essa contradição, mas tecnicamente, ele ainda é um valor primitivo.

Tipo Undefined

Como mencionado anteriormente, o tipo Undefined possui apenas um valor, ou seja, undefined. Quando uma variável declarada não for inicializada, o valor padrão dessa variável é undefined.

var oTemp;

A linha de código anterior declara a variável oTemp sem valor inicial. Essa variável será atribuída o valor undefined, que é o literal do tipo undefined. Pode-se usar o seguinte código para testar se o valor da variável é igual a undefined: }}

var oTemp;
alert(oTemp == undefined);

Este código exibe "true", o que indica que esses dois valores realmente são iguais. Além disso, o operador typeof pode ser usado para exibir que o valor da variável é undefined:

var oTemp;
alert(typeof oTemp); // Saída: "undefined"

Dica:O valor undefined é diferente do valor não definido. No entanto, o operador typeof não realmente distingue esses dois valores. Considere o seguinte código:

var oTemp;
alert(typeof oTemp);  // Saída: "undefined"
alert(typeof oTemp2);  // Saída: "undefined"

O código acima imprime "undefined" para os dois variáveis, mesmo que apenas a variável oTemp2 nunca tenha sido declarada. Se usar um operador diferente de typeof com o oTemp2, isso causará um erro, pois esses operadores só podem ser usados com variáveis declaradas.

Por exemplo, o seguinte código causará um erro:

var oTemp;
alert(oTemp2 == undefined);

Quando uma função não tem um valor de retorno explícito, também retorna o valor "undefined", conforme exemplo a seguir:

function testFunc() {
}
alert(testFunc() == undefined);  // Saída: "true"

Tipo Null

Outro tipo que tem apenas um valor é Null, que tem apenas um valor especial: null, que é seu literal.

alert(null == undefined);  // Saída: "true"

Embora esses dois valores sejam iguais, sua significação é diferente. undefined é o valor atribuído a uma variável que foi declarada mas não inicializada, enquanto null é usado para representar um objeto que ainda não existe (isto foi simplesmente introduzido ao discutir o operador typeof). Quando uma função ou método deve retornar um objeto e não encontrar esse objeto, o valor retornado geralmente é null.

Tipo Boolean

O tipo Boolean é um dos tipos mais usados no ECMAScript. Ele tem dois valores: true e false (ou seja, dois literais Boolean).

即使 false 不等于 0，0 也可以在必要时被转换成 false，这样在 Boolean 语句中使用两者都是安全的。

var bFound = true;
var bLost = false;

Number 类型

ECMA-262 中定义的最特殊的类型是 Number 类型。这种类型既可以表示 32 位的整数，还可以表示 64 位的浮点数。

直接输入的（而不是从另一个变量访问的）任何数字都被看做 Number 类型的字面量。例如，下面的代码声明了存放整数值的变量，它的值由字面量 86 定义：

var iNum = 86;

八进制数和十六进制数

整数也可以被表示为八进制（以 8 为底）或十六进制（以 16 为底）的字面量。八进制字面量的首数字必须是 0，其后的数字可以是任何八进制数字（0-7），如下面的代码所示：

var iNum = 070;  //070 等于十进制的 56

要创建十六进制的字面量，首位数字必须为 0，后面接字母 x，然后是任意的十六进制数字（0 到 9 和 A 到 F）。这些字母可以是大写的，也可以是小写的。例如：

var iNum = 0x1f;  //0x1f 等于十进制的 31
var iNum = 0xAB;  //0xAB 等于十进制的 171

Dica:尽管所有整数都可以表示为八进制或十六进制的字面量，但所有数学运算返回的都是十进制结果。

浮点数

要定义浮点值，必须包括小数点和小数点后的一位数字（例如，用 1.0 而不是 1）。这被看作浮点数字面量。例如：

var fNum = 5.0;

对于浮点字面量的有趣之处在于，用它进行计算前，真正存储的是字符串。

科学计数法

对于非常大或非常小的数，可以用科学计数法表示浮点数，可以把一个数表示为数字（包括十进制数字）加 e（或 E），后面加乘以 10 的倍数。例如：

var fNum = 5.618e7

该符号表示的是数 56180000。把科学计数法转化成计算式就可以得到该值：5.618 x 107。

也可以用科学计数法表示非常小的数，例如 0.00000000000000008 可以表示为 8-e17(Aqui, 10 é elevado ao -17º poder, o que significa que precisa ser dividido por 10 17 vezes). O ECMAScript padrão converte números de ponto flutuante com 6 ou mais zeros ao início para notação científica.

Dica:Os valores de ponto flutuante também podem ser armazenados em formato 64 bits IEEE 754, o que significa que o valor decimal pode ter no máximo 17 dígitos decimais. Os valores a partir do décimo-oitavo dígito são cortados, causando alguns erros matemáticos menores.

Valores especiais do Number

Alguns valores especiais também são definidos como tipo Number. Os dois primeiros são Number.MAX_VALUE e Number.MIN_VALUE, que definem os limites externos do conjunto de valores Number. Todos os números ECMAScript devem estar entre esses dois valores. No entanto, os resultados de cálculos gerados podem não cair entre esses dois valores.

Quando o número calculado é maior que Number.MAX_VALUE, ele é atribuído ao valor Number.POSITIVE_INFINITY, o que significa que não há mais valores numéricos. Da mesma forma, se o valor calculado for menor que Number.MIN_VALUE, ele será atribuído ao valor Number.NEGATIVE_INFINITY, também significando que não há mais valores numéricos. Se o cálculo retornar um valor infinito, o resultado gerado não pode ser usado em outros cálculos.

De fato, há valores específicos que representam o infinito, como você pode imaginar,那就是 Infinity. O valor de Number.POSITIVE_INFINITY é Infinity. O valor de Number.NEGATIVE_INFINITY é -Infinity.

Como o número infinito pode ser positivo ou negativo, é possível usar um método para determinar se um número é finito (ao invés de testar cada número infinito separadamente). Pode-se chamar o método isFinite() para qualquer número para garantir que ele não é infinito. Por exemplo:

var iResult = iNum * some_really_large_number;
if (isFinite(iResult)) {
    alert("finite");
}
else {
    alert("infinite");
}

O último valor especial é NaN, que representa 'Não é Número' (Not a Number). O NaN é um valor especial estranho. Geralmente, esse tipo de situação ocorre quando a conversão de tipo (String, Boolean, etc.) falha. Por exemplo, tentar converter a palavra 'blue' para um número falhará, pois não há um número equivalente. Como o infinito, o NaN também não pode ser usado em cálculos aritméticos. Outra característica peculiar do NaN é que ele não é igual a si mesmo, o que significa que o seguinte código retornará false:

alert(NaN == NaN);  //saída "false"

Por essa razão, não é recomendável usar o valor NaN em si. A função isNaN() faz um bom trabalho:

alert(isNaN("blue"));  //saída "true"
alert(isNaN("666"));  //saída "false"

Tipo String

A característica única do tipo String é que ele é o único tipo primitivo que não tem tamanho fixo. Pode armazenar 0 ou mais caracteres Unicode, representados por inteiros de 16 bits (Unicode é um conjunto de caracteres internacionais, que será discutido no tutorial posterior).

Cada caractere em uma string tem uma posição específica, o primeiro caractere começa no posição 0, o segundo caractere está na posição 1, e assim por diante. Isso significa que a posição do último caractere na string é sempre 1 menos o comprimento da string:

Tamanho da string e posição do caractere

Os literais de string são declarados por aspas duplas (" ) ou aspas simples ( ' ). O Java declara strings com aspas duplas e caracteres com aspas simples. No entanto, como o ECMAScript não tem tipo de caractere, qualquer uma dessas representações pode ser usada. Por exemplo, as duas linhas de código a seguir são válidas:

var sColor1 = "red";
var sColor2 = 'red';

O tipo String também inclui vários literais de caractere, os desenvolvedores de Java, C e Perl devem estar muito familiarizados com isso.

A seguir estão listados os literais de caractere do ECMAScript:

literação significado
\n nova linha
\t tabulação
\b espaço
\r enter
\f quebra de página
\\\ barra invertida
\' aspas simples
\" aspas duplas
\0nnn código octal nnn representa o caractere (n é um número octal entre 0 e 7
\xnn código hexadecimal nn representa o caractere (n é um número hexadecimal entre 0 e F
\unnnn código hexadecimal nnnn representa o caractere Unicode (n é um número hexadecimal entre 0 e F