Tipi primitivi ECMAScript

ECMAScript ha 5 tipi primitivi (primitive type), ovvero Undefined, Null, Boolean, Number e String.

Operatore typeof

L'operatore typeof ha un parametro, ovvero la variabile o il valore da controllare. Ad esempio:

var sTemp = "test string";
alert (typeof sTemp);    // Output: "string"
alert (typeof 86);    // Output: "number"

Chiamare l'operatore typeof su una variabile o un valore restituirà uno dei seguenti valori:

  • undefined - se la variabile è di tipo Undefined
  • booleano - se la variabile è di tipo Boolean
  • numero - se la variabile è di tipo Number
  • stringa - se la variabile è di tipo String
  • oggetto - se la variabile è di tipo riferimento o Null

Nota:Potrebbe chiedersi perché l'operatore typeof restituisca "Object" per il valore null. Questo è in realtà un errore nella prima implementazione di JavaScript, che è stato mantenuto da ECMAScript. Ora, null è considerato un placeholder per gli oggetti, spiegando questa contraddizione, ma tecnicamente è ancora un valore primitivo.

Tipo Undefined

Come già menzionato, il tipo Undefined ha solo un valore, ovvero undefined. Quando una variabile non è inizializzata, il suo valore predefinito è undefined.

var oTemp;

La riga di codice precedente dichiara la variabile oTemp senza valore iniziale. Questa variabile verrà assegnata il valore undefined, ossia il letterale del tipo undefined. Si può testare se il valore della variabile è uguale a undefined con il seguente segmento di codice:}}

var oTemp;
alert(oTemp == undefined);

Questo codice mostrerà "true", dimostrando che questi due valori sono effettivamente uguali. Si può anche utilizzare l'operatore typeof per mostrare che il valore della variabile è undefined:

var oTemp;
alert(typeof oTemp); // Output: "undefined"

Suggerimento:Il valore undefined è diverso dal valore non definito. Tuttavia, l'operatore typeof non distingue veramente queste due tipologie di valori. Consideriamo il seguente codice:

var oTemp;
alert(typeof oTemp);  // Output: "undefined"
alert(typeof oTemp2);  // Output: "undefined"

Il codice precedente stampa "undefined" per entrambe le variabili, anche se solo la variabile oTemp2 non è stata dichiarata. Se si utilizza un altro operatore oltre typeof per oTemp2, si genererà un errore perché gli altri operatori possono essere utilizzati solo sulle variabili dichiarate.

Ad esempio, il seguente codice genererà un errore:

var oTemp;
alert(oTemp2 == undefined);

Quando una funzione non ha un valore di ritorno esplicito, restituisce anche il valore "undefined", come mostrato di seguito:

function testFunc() {
}
alert(testFunc() == undefined);  // Output: "true"

Il tipo Null

Un altro tipo che ha solo un valore è Null, che ha un valore speciale null, ossia il suo letterale. Il valore undefined è derivato dal valore null, quindi ECMAScript li definisce uguali.

alert(null == undefined);  // Output: "true"

Nonostante questi due valori siano uguali, il loro significato è diverso. undefined è il valore assegnato a una variabile non inizializzata, null viene utilizzato per rappresentare un oggetto non esistente (un concetto introdotto semplicemente quando si discute dell'operatore typeof). Se una funzione o un metodo deve restituire un oggetto e non lo trova, di solito restituisce null.

Il tipo Boolean

Il tipo Boolean è uno dei tipi più utilizzati in ECMAScript. Ha due valori true e false (ovvero due letterali 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

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

浮点数

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

var fNum = 5.0;

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

科学计数法

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

var fNum = 5.618e7

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

也可以用科学计数法表示非常小的数，例如 0.00000000000000008 可以表示为 8-e17(qui, 10 viene elevato al -17mo potenza, il che significa che deve essere diviso per 10 17 volte). ECMAScript di default converte i numeri a virgola mobile con 6 o più zeri iniziali in notazione scientifica.

Suggerimento:I valori a virgola mobile possono anche essere memorizzati in forma 64 bit IEEE 754, il che significa che i valori decimali possono avere al massimo 17 cifre decimali. I valori dopo le 17 cifre vengono troncati, causando alcuni errori matematici minori.

Valori speciali Number

Alcuni valori speciali sono anche definiti come tipo Number. I primi due sono Number.MAX_VALUE e Number.MIN_VALUE, che definiscono i limiti esterni dell'insieme dei valori Number. Tutti i numeri ECMAScript devono trovarsi tra questi due valori. Tuttavia, i risultati dei calcoli possono non cadere tra questi due valori.

Quando il numero calcolato è maggiore di Number.MAX_VALUE, viene assegnato il valore Number.POSITIVE_INFINITY, il che significa che non ci sono più valori numerici. Allo stesso modo, il calcolo di un valore numerico inferiore a Number.MIN_VALUE viene assegnato il valore Number.NEGATIVE_INFINITY, il che significa che non ci sono più valori numerici. Se il calcolo restituisce un valore infinito, il risultato generato non può essere utilizzato in altri calcoli.

In effetti, ci sono valori speciali dedicati per rappresentare l'infinito, come forse ti aspettavi, ovvero Infinity. Il valore di Number.POSITIVE_INFINITY è Infinity. Il valore di Number.NEGATIVE_INFINITY è -Infinity.

Poiché i numeri infiniti possono essere positivi o negativi, è possibile utilizzare un metodo per determinare se un numero è finito (invece di testare ogni numero infinito singolarmente). È possibile chiamare il metodo isFinite() su qualsiasi numero per assicurarsi che non sia infinito. Ad esempio:

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

L'ultimo valore speciale è NaN, che rappresenta 'Non un numero' (Not a Number). NaN è un valore speciale strano. Di solito, questo tipo di situazione si verifica quando la conversione di tipo (Stringa, Booleano, ecc.) fallisce. Ad esempio, convertire la parola 'blue' in un numero fallirà perché non c'è un valore numerico equivalente. Come l'infinito, NaN non può essere utilizzato nei calcoli aritmetici. Un'altra peculiarità di NaN è che non è uguale a se stesso, il che significa che il seguente codice restituirà false:

alert(NaN == NaN);  // Output: "false"

Per questo motivo, non si raccomanda di utilizzare il valore NaN stesso. La funzione isNaN() fa un buon lavoro:

alert(isNaN("blue"));  // Output: "true"
alert(isNaN("666"));  // Output: "false"

Tipo String

L'unico punto unico del tipo String è che è l'unico tipo primitivo senza dimensioni fisse. Puoi memorizzare 0 o più caratteri Unicode con un intero di 16 bit (Unicode è un set di caratteri internazionale, che verrà discusso in questo tutorial).

Ogni carattere nella stringa ha una posizione specifica, il primo carattere inizia dalla posizione 0, il secondo carattere è nella posizione 1, ecc. Questo significa che la posizione dell'ultimo carattere nella stringa è sempre una meno la lunghezza della stringa:

La lunghezza della stringa e la posizione dei caratteri

I letterali di stringa sono dichiarati da virgolette doppi ("), virgolette singole ('), Java utilizza virgolette doppi per dichiarare stringhe, virgolette singole per dichiarare caratteri. Tuttavia, poiché ECMAScript non ha un tipo di carattere, può utilizzare qualsiasi di queste due rappresentazioni. Ad esempio, le due righe di codice seguenti sono entrambe valide:

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

Il tipo String include anche diversi letterali di caratteri, i developer di Java, C e Perl dovrebbero essere molto familiari con essi.

Di seguito è riportato un elenco dei letterali di caratteri ECMAScript:

letterale significato
\n carattere di nuova riga
\t tabulatore
\b spazio
\r carattere di ritorno
\f carattere di nuova pagina
\\\ backslash
\' virgolette singole
\" virgolette doppi
\0nnn codice ottale nnn rappresenta il carattere (n è un numero ottale tra 0 e 7)
\xnn codice esadecimale nn rappresenta il carattere (n è un numero esadecimale tra 0 e F)
\unnnn codice esadecimale nnnn rappresenta il carattere Unicode (n è un numero esadecimale tra 0 e F)