Operatori Unari ECMAScript

A unary operator has only one parameter, which is the object or value to be operated on. They are the simplest operators in ECMAScript.

delete

The delete operator removes references to previously defined object properties or methods. For example:

var o = new Object;
o.name = "David";
alert(o.name);	// Output "David"
delete o.name;
alert(o.name);	// Output: "undefined"

In questo esempio, la rimozione dell'attributo name significa forzare la risoluzione della sua riferimento, impostandolo su undefined (cioè il valore di una variabile non inizializzata).

L'operatore delete non può rimuovere attributi e metodi non definiti dallo sviluppatore. Ad esempio, il seguente codice genererà un errore:

delete o.toString;

Anche se toString è un nome di metodo valido, questa riga di codice genererà un errore perché toString() è un metodo ECMAScript originale, non definito dallo sviluppatore.

void

L'operatore void restituisce undefined per qualsiasi valore. Questo operatore viene solitamente utilizzato per evitare di visualizzare valori che non dovrebbero essere visualizzati, ad esempio quando si chiama una funzione JavaScript da un elemento <a> di HTML. Per farlo correttamente, la funzione non deve restituire un valore valido, altrimenti il browser svuoterà la pagina e visualizzerà solo il risultato della funzione. Ad esempio:

<a href="javascript:window.open('about:blank')">Clicca qui</a>

Se inserisci questa riga di codice in una pagina HTML, facendo clic sul link, vedrai "[object]" visualizzato sullo schermo.TIY

Questo è perché il metodo window.open() restituisce un riferimento alla nuova finestra aperta. Poi l'oggetto viene convertito in una stringa da visualizzare.

Per evitare questo effetto, puoi chiamare la funzione window.open() con l'operatore void:

<a href="javascript:void(window.open('about:blank'))">Clicca qui</a>

Questo rende il chiamata a window.open() restituisce undefined, che non è un valore valido e non verrà visualizzato nella finestra del browser.

Suggerimento:Ricorda, tutte le funzioni che non restituiscono un valore ritornano truly undefined.

Operatore di incrementazione/decremento prefissa

I due operatori presi in prestito direttamente da C (e Java) sono l'operatore di incrementazione prefissa e l'operatore di decremento prefissa.

L'operatore di incrementazione prefisso aggiunge 1 al valore, con la forma di due plus davanti al variabile (++):

var iNum = 10;
++iNum;

La seconda riga di codice aumenta il valore di iNum a 11, è sostanzialmente equivalente a:

var iNum = 10;
iNum = iNum + 1;

Anche l'operatore di decremento prefisso sottrae 1 al valore, con la forma di due minuscoli davanti al variabile (--):

var iNum = 10;
--iNum;

In questo esempio, la seconda riga di codice riduce il valore di iNum a 9.

Attenzione: quando si utilizzano gli operatori di prefisso, sia l'operazione di incrementazione che quella di decremento avvengono prima del calcolo dell'espressione. Considera l'esempio seguente:

var iNum = 10;
--iNum;
alert(iNum);	// output "9"
alert(--iNum);	// output "8"
alert(iNum);	// output "8"

La seconda riga di codice esegue l'operazione di decrementazione su iNum, la terza riga di codice mostra il risultato ("9"). La quarta riga di codice esegue nuovamente l'operazione di decrementazione su iNum, ma questa volta l'operazione di decremento prefisso e l'operazione di output appaiono nella stessa espressione, mostrando il risultato "8". Per dimostrare che tutte le operazioni di decremento sono state eseguite, la quinta riga di codice mostra di nuovo "8".

Negli espressioni aritmetici, la priorità degli operatori di incrementazione e decrementazione prefissi è la stessa, quindi devono essere calcolati nell'ordine da sinistra a destra. Ad esempio:

var iNum1 = 2;
var iNum2 = 20;
var iNum3 = --iNum1 + ++iNum2;	// uguale a "22"
var iNum4 = iNum1 + iNum2;		// uguale a "22"

Nel codice precedente, iNum3 è uguale a 22, perché l'espressione da calcolare è 1 + 21. La variabile iNum4 è anche uguale a 22, anch'essa 1 + 21.

Operatori di incrementazione/decrementazione posteriore

Ci sono anche due operatori presi direttamente da C (e Java), ovvero l'operatore di incrementazione posteriore e l'operatore di decrementazione posteriore.

L'operatore di incrementazione posteriore aggiunge 1 al valore, nella forma di due punti doppi dopo la variabile (++):

var iNum = 10;
iNum++;

Non sorprende che l'operatore di decremento posteriore riduca il valore di 1, nella forma di due trattini doppi dopo la variabile (--):

var iNum = 10;
iNum--;

La seconda riga di codice riduce il valore di iNum a 9.

Diversamente dagli operatori prefissi, gli operatori postfissi eseguono l'operazione di incrementazione o decrementazione solo dopo aver calcolato l'espressione che li contiene. Consideriamo l'esempio seguente:

var iNum = 10;
iNum--;
alert(iNum);	// output "9"
alert(iNum--);	// output "9"
alert(iNum);	// output "8"

Similmente agli esempi degli operatori prefissi, la seconda riga di codice esegue l'operazione di decrementazione su iNum, la terza riga di codice mostra il risultato ("9"). La quarta riga di codice mostra nuovamente il valore di iNum, ma questa volta l'operatore di decrementazione è applicato nella stessa espressione. Poiché il decremento avviene dopo la valutazione dell'espressione, questa riga di codice mostra il numero "9". Dopo aver eseguito la quinta riga di codice, la funzione alert mostra "8", perché tra l'esecuzione della quarta riga di codice e l'esecuzione della quinta riga di codice, è stata eseguita l'operazione di decremento posteriore.

Negli espressioni aritmetiche, la priorità degli operatori di incrementazione e decrementazione è la stessa, quindi devono essere calcolati nell'ordine da sinistra a destra. Ad esempio:

var iNum1 = 2;
var iNum2 = 20;
var iNum3 = iNum1-- + iNum2++;	// uguale a "22"
var iNum4 = iNum1 + iNum2;		// uguale a "22"

Nel codice precedente, iNum3 è uguale a 22 perché l'espressione deve calcolare 2 + 20. La variabile iNum4 è anche uguale a 22, ma calcola 1 + 21 perché l'aumento e la riduzione avvengono dopo l'attribuzione a iNum3.

Operatore unario di somma e di sottrazione

Molti sono familiarizzati con l'operatore unario di somma e di sottrazione, il loro uso in ECMAScript è lo stesso di quello che hai imparato in matematica della scuola superiore.

L'operatore unario di somma non ha alcun effetto本质上 sui numeri:

var iNum = 20;
iNum = +iNum;
alert(iNum);	// Output: "20"

Questo codice applica l'operatore unario di somma al numero 20, e il risultato è ancora 20.

Nonostante l'operatore unario di somma non abbia alcun effetto sui numeri, ha un effetto interessante sulle stringhe, convertendo la stringa in un numero.

var sNum = "20";
alert(typeof sNum);	// Output: "string"
var iNum = +sNum;
alert(typeof iNum);	// Output: "number"

Questo codice converte la stringa "20" in un numero reale. Quando l'operatore unario di somma opera su una stringa, calcola la stringa allo stesso modo di parseInt(), la principale differenza è che solo le stringhe che iniziano con "0x" (che rappresentano numeri esadecimali) possono essere convertite in valori decimali. Pertanto, convertire "010" con l'operatore unario di somma darà sempre 10, mentre "0xB" sarà convertito in 11.

D'altra parte, l'operatore unario di sottrazione è il negativo di un numero (ad esempio, convertire 20 in -20):

var iNum = 20;
iNum = -iNum;
alert(iNum);	// Output: "-20"

Simile all'operatore unario di somma, l'operatore unario di sottrazione anche convertirà la stringa in un numero approssimativo, oltre a negare quel valore. Ad esempio:

var sNum = "20";
alert(typeof sNum);	// Output: "string"
var iNum = -sNum;
alert(iNum);		// Output: "-20"
alert(typeof iNum);	// Output: "number"

Nel codice sopra, l'operatore unario di sottrazione convertirà la stringa "-20" in -20 (l'operatore unario di sottrazione tratta l'esadecimale e il decimale allo stesso modo dell'operatore unario di somma, ma calcola anche il negativo di quel valore).