ECMAScript Unaire Operator

Een eenargumentenoperator heeft slechts één parameter, namelijk het object of de waarde dat moet worden bewerkt. Ze zijn de eenvoudigste operatoren in ECMAScript.

delete

De delete-bewerker verwijdert verwijzingen naar eerder gedefinieerde objecteigenschappen of methoden. Bijvoorbeeld:

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

In dit voorbeeld wordt de name-eigenschap verwijderd, wat betekent dat de referentie ernaar wordt opgeheven en deze wordt ingesteld op undefined (de waarde van een ongeïnitialiseerde variabele).

De delete operator kan geen eigenschappen en methoden van ontwikkelaars verwijderen. Bijvoorbeeld, onderstaande code zal een fout veroorzaken:

delete o.toString;

Zelfs als toString een geldige methodenaam is, zal deze regel een fout veroorzaken omdat toString() een oorspronkelijke ECMAScript-methode is en geen door ontwikkelaars gedefinieerde methode.

void

De void operator retourneert undefined voor elke waarde. Deze operator wordt meestal gebruikt om waarden te vermijden die niet mogen worden weergegeven, bijvoorbeeld bij het oproepen van een JavaScript-functie vanuit een HTML <a>-element. Om dit correct te doen, mag de functie geen geldige waarde retourneren, anders zal de browser de pagina leeg maken en alleen het resultaat van de functie weergeven. Bijvoorbeeld:

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

Als je deze regel in een HTML-pagina plaatst en op de link klikt, wordt "[object]" weergegeven op het scherm.TIY

Dit komt omdat de methode window.open() een verwijzing retourneert naar het nieuw geopende venster. Vervolgens wordt dit object omgezet in de te weergeven string.

Om dit effect te voorkomen, kun je de functie window.open() oproepen met behulp van de void operator:

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

Dit maakt dat de aanroep van window.open() undefined retourneert, wat geen geldige waarde is en niet wordt weergegeven in het browservenster.

Tip:Onthoud, een functie zonder returnwaarde retourneert altijd undefined.

Voorafgaande increment/decrement operatoren

De twee operatoren die direct van C (en Java) zijn overgenomen zijn de voorafgaande increment en decrement operatoren.

De voorafgaande increment operator is het toevoegen van 1 aan de waarde, en de vorm is om twee plus tekens voor de variabele te plaatsen (++):

var iNum = 10;
++iNum;

De tweede regel verhoogt iNum tot 11, en is in feite equivalent aan:

var iNum = 10;
iNum = iNum + 1;

Evenzo, de voorafgaande decrement operator vermindert de waarde met 1, en de vorm is om twee min tekens voor de variabele te plaatsen (--):

var iNum = 10;
--iNum;

In dit voorbeeld vermindert de tweede regel de waarde van iNum tot 9.

Let op bij het gebruik van voorvoegseloperatoren dat de increment en decrement operatoren voor de berekening van de expressie plaatsvinden.

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

De tweede regel van de code voert een postfix decrement operatie uit op iNum, de derde regel toont het resultaat ("9"). De vierde regel voert opnieuw een postfix decrement operatie uit op iNum, maar deze keer in dezelfde zin als de decrement en output operatie, het resultaat is "8". Om te bewijzen dat alle decrement operaties zijn uitgevoerd, wordt opnieuw "8" uitgevoerd in de vijfde regel.

In een wiskundige expressie is de prioriteit van de prefix increment en prefix decrement operatoren gelijk, dus moet men de berekeningen volgens de volgorde van links naar rechts uitvoeren. Bijvoorbeeld:

var iNum1 = 2;
var iNum2 = 20;
var iNum3 = --iNum1 + ++iNum2;	// gelijk aan "22"
var iNum4 = iNum1 + iNum2;		// gelijk aan "22"

In de eerdere code is iNum3 gelijk aan 22, omdat de expressie die moet worden berekend 1 + 21 is. De variabele iNum4 is ook gelijk aan 22, en ook 1 + 21.

Postfix increment/decrement operatoren

Er zijn ook twee operatoren die direct van C (en Java) zijn overgenomen, namelijk de postfix increment en postfix decrement operatoren.

De postfix increment operator voegt ook 1 toe aan de waarde, en heeft de vorm van twee plus tekens achter de variabele (++):

var iNum = 10;
iNum++;

Net zoals verwacht, vermindert de postfix decrement operator de waarde met 1, en heeft de vorm van twee min tekens achter de variabele (--):

var iNum = 10;
iNum--;

De tweede regel van de code vermindert de waarde van iNum tot 9.

Anders dan de prefix operatoren, voeren de postfix operatoren de increment of decrement operatie uit nadat de expressie waarin ze zich bevinden is berekend. Overweeg het volgende voorbeeld:

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

Het voorbeeld van de prefix operatoren is vergelijkbaar, de tweede regel van de code voert een post-decrement operatie uit op iNum, de derde regel toont het resultaat ("9"). De vierde regel toont de waarde van iNum voortdurend, maar deze keer wordt de post-decrement operatie in dezelfde zin toegepast. Omdat de decrement operatie na het berekenen van de expressie wordt uitgevoerd, toont deze zin het getal "9". Na het uitvoeren van de vijfde regel toont de alert-functie "8", omdat na het uitvoeren van de vierde regel en voordat de vijfde regel wordt uitgevoerd, de post-decrement operatie wordt uitgevoerd.

In een wiskundige expressie is de prioriteit van de post-increment en post-decrement operatoren gelijk, dus moet men de berekeningen volgens de volgorde van links naar rechts uitvoeren. Bijvoorbeeld:

var iNum1 = 2;
var iNum2 = 20;
var iNum3 = iNum1-- + iNum2++;	// gelijk aan "22"
var iNum4 = iNum1 + iNum2;		// gelijk aan "22"

In de voorgaande code is iNum3 gelijk aan 22, omdat de expressie 2 + 20 moet worden berekend. De variabele iNum4 is ook gelijk aan 22, maar het berekent 1 + 21, omdat de increment en decrement operatoren na het toewijzen van de waarde aan iNum3 plaatsvinden.

Unaire plus- en minusbewerkers

De meeste mensen zijn bekend met de unaire plus- en minusbewerkers, hun gebruik in ECMAScript is vergelijkbaar met wat je in de middelbare school hebt geleerd.

De unaire plusbewerker heeft in wezen geen effect op cijfers:

var iNum = 20;
iNum = +iNum;
alert(iNum); // Uitvoer "20"

Dit code fragment past de unaire plusbewerker toe op het getal 20, en het retourneert nog steeds 20.

Hoewel de unaire plusbewerker geen effect heeft op cijfers, heeft het een interessante effect op strings, het zal strings omzetten naar cijfers.

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

Dit code fragment zet de string "20" om naar een echte nummer. Wanneer de unaire plusbewerker een string manipuleert, berekent hij de string op een manier die vergelijkbaar is met parseInt(), het belangrijkste verschil is dat alleen strings die beginnen met "0x" (die hexadecimale cijfers vertegenwoordigen) door de unaire bewerker kunnen worden omgezet naar een decimale waarde. Dus "010" wordt altijd 10, terwijl "0xB" wordt omgezet naar 11.

Aan de andere kant is de unaire minusbewerker het ontnemen van een getal (bijvoorbeeld 20 naar -20):

var iNum = 20;
iNum = -iNum;
alert(iNum); // Uitvoer "-20"

Vergelijkbaar met de unaire plusbewerker zal de unaire minusbewerker ook strings omzetten naar een bijna equivalent nummer, en zal het ook de waarde ontnemen. Bijvoorbeeld:

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

In de bovenstaande code zal de unaire minusbewerker de string "-20" omzetten naar -20 (de manier waarop de unaire minusbewerker omgaat met hexadecimaal en decimaal is vergelijkbaar met de unaire plusbewerker, alleen zal het ook de waarde ontnemen).