JavaScript
Unaire operatoren

Syntaxis

• ongeldige uitdrukking; // Evalueert expressie en negeert retourwaarde
• + Expressie; // Poging om uitdrukking naar een getal te converteren
• object.property verwijderen; // Verwijder de eigenschap van het object
• verwijder object ["property"]; // Verwijder de eigenschap van het object
• type operand; // Retourneert het type operand
• ~ Expressie; // Voer NIET-bewerking uit op elk bit van uitdrukking
• !uitdrukking; // Voer logische ontkenning uit bij expressie
• -uitdrukking; // Negeer uitdrukking na poging tot conversie naar nummer

De operator Unary plus (+)

De unaire plus ( + ) gaat vooraf aan zijn operand en evalueert zijn operand. Het probeert de operand te converteren naar een getal, als dit nog niet is gebeurd.

Syntaxis:

+expression

Geeft terug:

• een Number .

Beschrijving

De operator unary plus ( + ) is de snelste (en voorkeurs) methode om iets in een getal om te zetten.

Het kan omzetten:

• tekenreeksrepresentaties van gehele getallen (decimaal of hexadecimaal) en drijvers.
• booleans: true , false .
• null

Waarden die niet kunnen worden geconverteerd, worden geëvalueerd naar NaN .

Voorbeelden:

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

Merk op dat het proberen om een array te converteren kan leiden tot onverwachte retourwaarden.
Op de achtergrond worden arrays eerst geconverteerd naar hun stringvoorstellingen:

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

De operator probeert vervolgens die tekenreeksen om te zetten in getallen:

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

De verwijderoperator

De delete verwijdert een eigenschap van een object.

Syntaxis:

delete object.property

delete object['property']

Geeft terug:

Als het verwijderen is gelukt of de eigenschap niet bestond:

• true

Als de te verwijderen eigenschap een eigen niet-configureerbare eigenschap is (kan niet worden verwijderd):

• false in niet-strikte modus.
• Gooit een fout in de strikte modus

Beschrijving

De delete maakt niet direct geheugen vrij. Het kan indirect geheugen vrijmaken als de bewerking betekent dat alle verwijzingen naar de eigenschap zijn verdwenen.

delete werkt aan de eigenschappen van een object. Als er een eigenschap met dezelfde naam bestaat in de prototypeketen van het object, wordt de eigenschap overgenomen van het prototype.
delete werkt niet op variabelen of functienamen.

Voorbeelden:

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

Het type operator

De typeof operator retourneert het gegevenstype van de niet-uitgevoerde operand als string.

Syntaxis:

typeof operand

Geeft terug:

Dit zijn de mogelijke retourwaarden van typeof :

Het ongebruikelijke gedrag van document.all met de typeof operator is afkomstig van het eerdere gebruik om oudere browsers te detecteren. Zie Waarom is document.all gedefinieerd maar typeof document.all retourneert "undefined" voor meer informatie .

Voorbeelden:

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

De ongeldige operator

De void operator evalueert de gegeven uitdrukking en retourneert vervolgens undefined .

Syntaxis:

void expression

Geeft terug:

• undefined

Beschrijving

De void operator wordt vaak gebruikt om de undefined primitieve waarde te verkrijgen, door middel van het schrijven van void 0 of void(0) . Merk op dat void een operator is, geen functie, dus () is niet vereist.

Gewoonlijk kunnen het resultaat van een void uitdrukking en undefined door elkaar worden gebruikt.
In oudere versies van ECMAScript kon aan window.undefined echter elke waarde worden toegewezen en het is nog steeds mogelijk om undefined als naam te gebruiken voor functieparametervariabelen in functies, waardoor andere code wordt verstoord die afhankelijk is van de waarde van undefined .
void zal echter altijd de echte undefined waarde opleveren.

void 0 wordt ook vaak gebruikt in codeminificatie als een kortere manier om undefined schrijven. Bovendien is het waarschijnlijk veiliger omdat een andere code met window.undefined .

Voorbeelden:

Retourneren undefined :

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

De waarde van undefined binnen een bepaald bereik wijzigen:

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

De unaire ontkenning operator (-)

De unaire ontkenning ( - ) gaat vooraf aan de operand en ontkent deze, nadat hij heeft geprobeerd deze naar een getal te converteren.

Syntaxis:

-expression

Geeft terug:

• een Number .

Beschrijving

De unaire ontkenning ( - ) kan dezelfde typen / waarden converteren als de operator unary plus ( + ).

Waarden die niet kunnen worden geconverteerd, worden geëvalueerd naar NaN (er is geen -NaN ).

Voorbeelden:

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

Merk op dat het proberen om een array te converteren kan leiden tot onverwachte retourwaarden.
Op de achtergrond worden arrays eerst geconverteerd naar hun stringvoorstellingen:

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

De operator probeert vervolgens die tekenreeksen om te zetten in getallen:

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

De operator Bitwise NOT (~)

De bitwise NOT ( ~ ) voert een NOT-bewerking uit op elk bit in een waarde.

Syntaxis:

~expression

Geeft terug:

• een Number .

Beschrijving

De waarheidstabel voor de NIET-operatie is:

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

Een beetje niet op een nummer resulteert in: -(x + 1) .

Voorbeelden:

De logische NOT-operator (!)

De operator logisch NOT ( ! ) Voert logische ontkenning uit op een uitdrukking.

Syntaxis:

!expression

Geeft terug:

• een Boolean .

Beschrijving

De operator logisch NOT ( ! ) Voert logische ontkenning uit op een uitdrukking.

Booleaanse waarden worden gewoon omgekeerd !true === false en !false === true .
Niet-booleaanse waarden worden eerst geconverteerd naar booleaanse waarden en worden vervolgens tenietgedaan.

Dit betekent dat een dubbele logische NOT ( !! ) kan worden gebruikt om elke waarde naar een Boolean te casten:

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

Deze zijn allemaal gelijk aan !true :

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

Deze zijn allemaal gelijk aan !false :

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

Voorbeelden:

!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

Overzicht

Unaire operatoren zijn operatoren met slechts één operand. Unaire operators zijn efficiënter dan standaard JavaScript-functie-aanroepen. Bovendien kunnen unaire operators niet worden opgeheven en daarom is hun functionaliteit gegarandeerd.

De volgende unaire operatoren zijn beschikbaar: