JavaScript
Unäre Operatoren

Syntax

• leerer Ausdruck; // Wertet den Ausdruck aus und verwirft den Rückgabewert
• + Ausdruck; // Versuch, den Ausdruck in eine Zahl umzuwandeln
• Lösche object.property; // Lösche die Eigenschaft des Objekts
• Objekt löschen ["Eigenschaft"]; // Lösche die Eigenschaft des Objekts
• Typ des Operanden; // Gibt den Typ des Operanden zurück
• ~ Ausdruck; // NOT-Operation für jedes Bit des Ausdrucks ausführen
• !Ausdruck; // Logische Negation für Ausdruck ausführen
• -Ausdruck; // Negiere den Ausdruck nach dem Versuch der Umwandlung in eine Zahl

Der unäre Plusoperator (+)

Das unäre Plus ( + ) steht vor seinem Operanden und wird zu seinem Operanden ausgewertet . Es wird versucht, den Operanden in eine Zahl umzuwandeln, falls diese noch nicht vorhanden ist.

Syntax:

+expression

Kehrt zurück:

• eine Number

Beschreibung

Der unäre Plus ( + ) - Operator ist die schnellste (und bevorzugte) Methode, etwas in eine Zahl umzuwandeln.

Es kann konvertieren:

• Zeichenfolgendarstellungen von Ganzzahlen (dezimal oder hexadezimal) und Fließkommazahlen.
• booleans: true , false .
• null

Werte, die nicht konvertiert werden können, werden in NaN ausgewertet.

Beispiele:

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

Beachten Sie, dass der Versuch, ein Array zu konvertieren, zu unerwarteten Rückgabewerten führen kann.
Im Hintergrund werden Arrays zuerst in ihre Stringdarstellungen konvertiert:

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

Der Bediener versucht dann, diese Zeichenfolgen in Zahlen umzuwandeln:

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

Der Löschoperator

Der delete Operator löscht eine Eigenschaft aus einem Objekt.

Syntax:

delete object.property

delete object['property']

Kehrt zurück:

Wenn das Löschen erfolgreich ist oder die Eigenschaft nicht vorhanden ist:

• true

Wenn die zu löschende Eigenschaft eine eigene nicht konfigurierbare Eigenschaft ist (kann nicht gelöscht werden):

• false im nicht strengen Modus.
• Löst einen Fehler im strikten Modus aus

Beschreibung

Der delete gibt Speicher nicht direkt frei. Dadurch kann indirekt Speicherplatz freigegeben werden, wenn alle Verweise auf die Eigenschaft gelöscht werden.

delete funktioniert auf die Eigenschaften eines Objekts. Wenn eine Eigenschaft mit demselben Namen in der Prototypkette des Objekts vorhanden ist, wird die Eigenschaft vom Prototyp übernommen.
delete funktioniert nicht bei Variablen oder Funktionsnamen.

Beispiele:

// 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)

Der Typ des Operators

Der Operator typeof gibt den Datentyp des nicht ausgewerteten Operanden als Zeichenfolge zurück.

Syntax:

typeof operand

Kehrt zurück:

Dies sind die möglichen Rückgabewerte von typeof :

Das ungewöhnliche Verhalten von document.all mit dem typeof Operator beruht auf seiner früheren Verwendung zur Erkennung älterer Browser. Weitere Informationen finden Sie unter Warum ist document.all definiert, aber typeof document.all gibt "undefined" zurück.

Beispiele:

// 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;

Der leere Operator

Der void Operator wertet den angegebenen Ausdruck aus und gibt dann undefined .

Syntax:

void expression

Kehrt zurück:

• undefined

Beschreibung

Der void Operator wird häufig verwendet, um den undefined Grundwert durch Schreiben von void 0 oder void(0) . Beachten Sie, dass void ein Operator und keine Funktion ist. Daher ist () nicht erforderlich.

Normalerweise kann das Ergebnis eines void Ausdrucks und undefined austauschbar verwendet werden.
In älteren Versionen von ECMAScript konnte window.undefined jedoch ein beliebiger Wert zugewiesen werden. Es ist weiterhin möglich, undefined als Namen für Funktionsparametervariablen innerhalb von Funktionen zu verwenden, was anderen Code stört, der auf den Wert von undefined beruht.
void liefert jedoch immer den wahren undefined Wert.

void 0 wird auch häufig in der Code-Minifizierung als kürzere Schreibweise undefined . Darüber hinaus ist es wahrscheinlich sicherer, da window.undefined einen anderen Code manipuliert werden window.undefined .

Beispiele:

Rückgabe undefined :

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

Ändern des Werts von undefined innerhalb eines bestimmten Bereichs:

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

Der unäre Negationsoperator (-)

Die unäre Negation ( - ) steht vor ihrem Operanden und negiert diesen, nachdem versucht wurde, ihn in eine Zahl umzuwandeln.

Syntax:

-expression

Kehrt zurück:

• eine Number

Beschreibung

Die unäre Negation ( - ) kann dieselben Typen / Werte konvertieren wie der unäre Plus ( + ) - Operator.

Werte, die nicht konvertiert werden können, werden in NaN ausgewertet (es gibt kein -NaN ).

Beispiele:

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

Beachten Sie, dass der Versuch, ein Array zu konvertieren, zu unerwarteten Rückgabewerten führen kann.
Im Hintergrund werden Arrays zuerst in ihre Stringdarstellungen konvertiert:

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

Der Bediener versucht dann, diese Zeichenfolgen in Zahlen umzuwandeln:

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

Der bitweise NOT-Operator (~)

Das bitweise NOT ( ~ ) führt für jedes Bit in einem Wert eine NOT-Operation aus.

Syntax:

~expression

Kehrt zurück:

• eine Number

Beschreibung

Die Wahrheitstabelle für die NICHT-Operation lautet:

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

Ein bitweiser Wert ohne Zahl ergibt: -(x + 1) .

Beispiele:

Der logische NOT-Operator (!)

Der logische NOT-Operator ( ! ) Führt eine logische Negation eines Ausdrucks aus.

Syntax:

!expression

Kehrt zurück:

• ein Boolean

Beschreibung

Der logische NOT-Operator ( ! ) Führt eine logische Negation eines Ausdrucks aus.

Boolesche Werte werden einfach invertiert !true === false und !false === true .
Nicht-boolesche Werte werden zuerst in boolesche Werte konvertiert und dann negiert.

Dies bedeutet, dass ein doppeltes logisches NOT ( !! ) verwendet werden kann, um einen beliebigen Wert in einen booleschen Wert umzuwandeln:

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

Dies sind alle gleich !true :

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

Dies sind alle gleich !false :

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

Beispiele:

!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

Überblick

Unäre Operatoren sind Operatoren mit nur einem Operanden. Unäre Operatoren sind effizienter als standardmäßige JavaScript-Funktionsaufrufe. Außerdem können unäre Operatoren nicht außer Kraft gesetzt werden, sodass ihre Funktionalität garantiert ist.

Die folgenden unären Operatoren stehen zur Verfügung: