JavaScript
Operatori unari

Sintassi

• espressione vuota; // Valuta l'espressione e scarta il valore di ritorno
• + Espressione; // Tentativo di convertire un'espressione in un numero
• elimina object.property; // Elimina la proprietà dell'oggetto
• cancella oggetto ["proprietà"]; // Elimina la proprietà dell'oggetto
• tipo di operando; // Restituisce il tipo di operando
• ~ Espressione; // Esegue l'operazione NOT su ogni bit di espressione
• !espressione; // Esegue la negazione logica sull'espressione
• -espressione; // Negare l'espressione dopo aver tentato la conversione in numero

L'operatore unario più (+)

L'unario più ( + ) precede il suo operando e valuta il suo operando. Tenta di convertire l'operando in un numero, se non lo è già.

Sintassi:

+expression

Ritorna:

• un Number .

Descrizione

L'operatore unario più ( + ) è il metodo più veloce (e preferito) per convertire qualcosa in un numero.

Può convertire:

• rappresentazioni di stringa di interi (decimali o esadecimali) e galleggianti.
• booleans: true , false .
• null

I valori che non possono essere convertiti valuteranno in NaN .

Esempi:

+42           // 42
+"42"         // 42
+true         // 1
+false        // 0
+null         // 0
+undefined    // NaN
+NaN          // NaN
+"foo"        // NaN
+{}           // NaN
+function(){} // NaN

Si noti che il tentativo di convertire una matrice può comportare valori di ritorno imprevisti.
In background, gli array vengono prima convertiti nelle loro rappresentazioni di stringa:

[].toString() === '';
[1].toString() === '1';
[1, 2].toString() === '1,2';

L'operatore tenta quindi di convertire tali stringhe in numeri:

+[]           // 0   ( === +'' )
+[1]          // 1   ( === +'1' )
+[1, 2]       // NaN ( === +'1,2' )

L'operatore di cancellazione

L'operatore delete cancella una proprietà da un oggetto.

Sintassi:

delete object.property

delete object['property']

Ritorna:

Se la cancellazione ha esito positivo o la proprietà non esiste:

• true

Se la proprietà da eliminare è una proprietà non configurabile (non può essere cancellata):

• false in modalità non rigida.
• Genera un errore in modalità rigorosa

Descrizione

L'operatore di delete non libera la memoria direttamente. Può indirettamente liberare memoria se l'operazione significa che tutti i riferimenti alla proprietà sono andati.

delete lavori sulle proprietà di un oggetto. Se esiste una proprietà con lo stesso nome sulla catena di prototipi dell'oggetto, la proprietà verrà ereditata dal prototipo.
delete non funziona su variabili o nomi di funzioni.

Esempi:

// Deleting a property
foo = 1;              // a global variable is a property of `window`: `window.foo`
delete foo;           // true
console.log(foo);     // Uncaught ReferenceError: foo is not defined

// Deleting a variable
var foo = 1;
delete foo;           // false
console.log(foo);     // 1 (Not deleted)

// Deleting a function
function foo(){ };
delete foo;           // false
console.log(foo);     // function foo(){ } (Not deleted)

// Deleting a property
var foo = { bar: "42" };
delete foo.bar;       // true
console.log(foo);     // Object { } (Deleted bar)

// Deleting a property that does not exist
var foo = { };
delete foo.bar;       // true
console.log(foo);     // Object { } (No errors, nothing deleted)

// Deleting a non-configurable property of a predefined object
delete Math.PI;       // false  ()
console.log(Math.PI); // 3.141592653589793 (Not deleted)

L'operatore typeof

L'operatore typeof restituisce il tipo di dati dell'operando non valutato come una stringa.

Sintassi:

typeof operand

Ritorna:

Questi sono i possibili valori di ritorno da typeof :

Il comportamento insolito di document.all con l'operatore typeof deriva dal suo precedente utilizzo per rilevare i browser legacy. Per ulteriori informazioni, vedere Perché è document.all definito ma typeof document.all restituisce "undefined"?

Esempi:

// returns 'number'
typeof 3.14;
typeof Infinity;
typeof NaN;               // "Not-a-Number" is a "number"

// returns 'string'
typeof "";
typeof "bla";
typeof (typeof 1);        // typeof always returns a string

// returns 'boolean'
typeof true;
typeof false;

// returns 'undefined'
typeof undefined;
typeof declaredButUndefinedVariable;
typeof undeclaredVariable;
typeof void 0;
typeof document.all       // see above

// returns 'function'
typeof function(){};
typeof class C {};
typeof Math.sin;

// returns 'object'
typeof { /*<...>*/ };
typeof null;
typeof /regex/;           // This is also considered an object
typeof [1, 2, 4];         // use Array.isArray or Object.prototype.toString.call.
typeof new Date();
typeof new RegExp();
typeof new Boolean(true); // Don't use!
typeof new Number(1);     // Don't use!
typeof new String("abc"); // Don't use!

// returns 'symbol'
typeof Symbol();
typeof Symbol.iterator;

L'operatore del vuoto

L'operatore void valuta l'espressione data e quindi restituisce undefined .

Sintassi:

void expression

Ritorna:

• undefined

Descrizione

L'operatore void viene spesso utilizzato per ottenere il valore primitivo undefined , mediante la scrittura di void 0 o void(0) . Si noti che void è un operatore, non una funzione, quindi () non è richiesto.

Di solito il risultato di un'espressione di void e undefined può essere usato in modo intercambiabile.
Tuttavia, nelle versioni precedenti di ECMAScript, a window.undefined potrebbe essere assegnato qualsiasi valore ed è ancora possibile utilizzare undefined come nome per le variabili dei parametri di funzione all'interno delle funzioni, interrompendo in tal modo altri codici che si basano sul valore di undefined .
void restituirà sempre il vero valore undefined .

void 0 è anche comunemente usato nella minificazione del codice come un modo più breve di scrivere undefined . Inoltre, è probabilmente più sicuro dato che altri codici potrebbero aver manomesso window.undefined .

Esempi:

Ritorno undefined :

function foo(){
    return void 0;
}
console.log(foo()); // undefined

Modifica del valore di undefined all'interno di un determinato ambito:

(function(undefined){
    var str = 'foo';
    console.log(str === undefined); // true
})('foo');

L'operatore unario negazione (-)

La negazione unaria ( - ) precede il suo operando e lo nega, dopo aver provato a convertirlo in numero.

Sintassi:

-expression

Ritorna:

• un Number .

Descrizione

La negazione unaria ( - ) può convertire gli stessi tipi / valori dell'armatore unario più ( + ).

I valori che non possono essere convertiti valuteranno in NaN (non c'è -NaN ).

Esempi:

-42           // -42
-"42"         // -42
-true         // -1
-false        // -0
-null         // -0
-undefined    // NaN
-NaN          // NaN
-"foo"        // NaN
-{}           // NaN
-function(){} // NaN

Si noti che il tentativo di convertire una matrice può comportare valori di ritorno imprevisti.
In background, gli array vengono prima convertiti nelle loro rappresentazioni di stringa:

[].toString() === '';
[1].toString() === '1';
[1, 2].toString() === '1,2';

L'operatore tenta quindi di convertire tali stringhe in numeri:

-[]           // -0  ( === -'' )
-[1]          // -1  ( === -'1' )
-[1, 2]       // NaN ( === -'1,2' )

L'operatore NOT bit a bit (~)

NOT ( ~ ) bit a bit esegue un'operazione NOT su ciascun bit in un valore.

Sintassi:

~expression

Ritorna:

• un Number .

Descrizione

La tabella di verità per l'operazione NOT è:

1337  (base 10) = 0000010100111001 (base 2)
~1337 (base 10) = 1111101011000110 (base 2) = -1338 (base 10)

Un bit a bit non su un numero risulta in: -(x + 1) .

Esempi:

L'operatore logico NOT (!)

L'operatore logico NOT ( ! ) Esegue la negazione logica su un'espressione.

Sintassi:

!expression

Ritorna:

• un Boolean .

Descrizione

L'operatore logico NOT ( ! ) Esegue la negazione logica su un'espressione.

I valori booleani vengono semplicemente invertiti !true === false e !false === true .
I valori non booleani vengono convertiti in valori booleani per primi, quindi vengono annullati.

Ciò significa che un doppio NOT logico ( !! ) può essere utilizzato per trasmettere qualsiasi valore a un valore booleano:

!!"FooBar" === true
!!1 === true
!!0 === false

Questi sono tutti uguali a !true :

!'true' === !new Boolean('true');
!'false' === !new Boolean('false');
!'FooBar' === !new Boolean('FooBar');
![] === !new Boolean([]);
!{} === !new Boolean({});

Questi sono tutti uguali a !false :

!0 === !new Boolean(0);
!'' === !new Boolean('');
!NaN === !new Boolean(NaN);
!null === !new Boolean(null);
!undefined === !new Boolean(undefined);

Esempi:

!true         // false
!-1           // false
!"-1"         // false
!42           // false
!"42"         // false
!"foo"        // false
!"true"       // false
!"false"      // false
!{}           // false
![]           // false
!function(){} // false

!false        // true
!null         // true
!undefined    // true
!NaN          // true
!0            // true
!""           // true

Panoramica

Gli operatori unari sono operatori con un solo operando. Gli operatori unari sono più efficienti delle chiamate di funzioni JavaScript standard. Inoltre, gli operatori unari non possono essere sovrascritti e pertanto la loro funzionalità è garantita.

Sono disponibili i seguenti operatori unari: