ECMAScript Enkel operators

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

delete operator removes the reference to the 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"

I detta exempel tas name-egenskapen bort, vilket innebär att det tvingas bryta referensen till den, och den sätts till undefined (dvs. värdet för en oinitierad variabel).

Delete-operatorn kan inte ta bort egenskaper och metoder som inte är definierade av utvecklaren. Till exempel kommer följande kod att orsaka ett fel:

delete o.toString;

Även om toString är ett giltigt metodnamn kommer denna kod att orsaka ett fel, eftersom toString() är en ursprunglig ECMAScript-metod, inte definierad av utvecklaren.

void

Void-operatorn returnerar undefined för alla värden. Operatorn används vanligtvis för att undvika att outputa värden som inte ska outputas, till exempel när du anropar en JavaScript-funktion från ett HTML <a>-element. För att göra detta korrekt kan funktionen inte returnera ett giltigt värde,否则浏览器将清除页面，只显示函数的结果。Exempelvis:

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

Om du lägger in denna kod i en HTML-sida och klickar på länken visas "[object]" på skärmen.TIY

Detta beror på att window.open() -metoden returnerar en referens till det nyligen öppnade fönstret. Därefter omvandlas detta objekt till den sträng som ska visas.

För att undvika detta kan du använda void-operatorn för att anropa window.open() -funktionen:

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

Detta gör att anropet till window.open() returnerar undefined, vilket inte är en giltig värde, och visas inte i webbläsarens fönster.

Tips:Kom ihåg att en funktion utan returvärde verkligen returnerar undefined.

Förökning/Förminskningssymboler

De två operatorer som lånats direkt från C (och Java) är förökningssymbolen och förminskningssymbolen.

Förökning av förökningssymbolen innebär att lägga till 1, och formen är att placera två plusstecken framför variabeln (++):

var iNum = 10;
++iNum;

Den andra raden i koden ökar iNum till 11, och det är egentligen ekvivalent med:

var iNum = 10;
iNum = iNum + 1;

Likaså, är förminskningsoperatoren att minska med 1, och formen är att placera två minusstecken framför variabeln (--):

var iNum = 10;
--iNum;

I detta exempel minskar den andra raden i koden värdet av iNum till 9.

När du använder prefixoperatorer, notera att ökning och minskning sker innan beräkningen av uttrycket. Överväg följande exempel:

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

Den andra raden kod minskar värdet av iNum, den tredje raden visar resultatet ("9"). Den fjärde raden utför återigen en minskning av iNum, denna gång är prefixdekrementoperationen och utdataoperatören i samma mening, resultatet är "8". För att bevisa att alla minskningsoperationer har genomförts, visar den femte raden återigen "8".

I algebraiska uttryck är prioriteringen för prefixinkrement- och prefixdekrementoperatorer samma, därför måste de beräknas i vänster till höger-följd. Till exempel:

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

I den tidigare koden är iNum3 lika med 22, eftersom uttrycket som ska beräknas är 1 + 21. Variabeln iNum4 är också lika med 22, och det är också 1 + 21.

Postinkrement/postdekrementoperatorer

Det finns också två operatorer som har lånats direkt från C (och Java), nämligen postinkrement- och postdekrementoperatorerna.

Postinkrementoperatorn lägger också till 1 till värdet, i form av att lägga till två plus-tecken efter variabeln (++):

var iNum = 10;
iNum++;

Som förväntat minskar postdekrementoperatorn också värdet med 1, i form av att lägga till två bindestreck efter variabeln (--):

var iNum = 10;
iNum--;

Den andra raden kod minskar värdet av iNum till 9.

Skillnaden från prefixoperatorer är att postinkrement- och postdekrementoperatorer utför inkrement eller dekrement efter att uttrycket som de ingår i har beräknats. Överväg följande exempel:

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

Liksom i exempel med prefixoperatorer, utför den andra raden kod minskningen av iNum, den tredje raden visar resultatet ("9"). Den fjärde raden visar fortfarande värdet av iNum, men denna gång tillämpas minskningsoperatorn i samma mening. Eftersom minskningen sker efter att uttrycket har beräknats, visar denna mening numret "9". Efter att ha kört den femte raden visar alert-funktionen "8", eftersom en postdekrementoperation utfördes efter den fjärde raden och innan den femte raden kördes.

I algebraiska uttryck är prioriteringen för postinkrement- och postdekrementoperatorer samma, därför måste de beräknas i vänster till höger-följd. Till exempel:

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

I den tidigare koden är iNum3 lika med 22, eftersom uttrycket ska beräkna 2 + 20. Variabeln iNum4 är också lika med 22, men den räknar 1 + 21, eftersom ökningen och minskningen sker efter att värdet till iNum3 har tilldelats.

Den unara plus- och minusoperatorn

De flesta människor är vana vid den unara plus- och minusoperatorn, deras användning i ECMAScript är densamma som du lärde dig i gymnasiet.

Den unara plusoperatorn har i grunden ingen effekt på nummer:

var iNum = 20;
iNum = +iNum;
alert(iNum);	//Uppgiften är "20"

Denna kod tillämpar den unara plusoperatorn på numret 20 och returnerar fortfarande 20.

Trots att den unara plusoperatorn inte har någon effekt på nummer, har den intressanta effekter på strängar, den konverterar strängar till nummer.

var sNum = "20";
alert(typeof sNum);	//Uppgiften är "string"
var iNum = +sNum;
alert(typeof iNum);	//Uppgiften är "number"

Denna kod konverterar strängen "20" till ett verkligt nummer. När den unara plusoperatorn opererar på en sträng, räknar den strängen på samma sätt som parseInt(), men den skillnaden är att endast strängar som börjar med "0x" (som representerar hexadecimala nummer) kan konverteras till decimala värden av den unara operatorn. Därför kommer "010" att konverteras till 10, medan "0xB" kommer att konverteras till 11.

Å andra sidan är den unara minusoperatorn att ta det negativa av ett nummer (t.ex. konvertera 20 till -20):

var iNum = 20;
iNum = -iNum;
alert(iNum);	//Uppgiften är "-20"

Liksom den unara plusoperatorn kommer den unara minusoperatorn också att konvertera strängar till närliggande nummer, och den kommer också att räkna ut det negativa värdet. Till exempel:

var sNum = "20";
alert(typeof sNum);	//Uppgiften är "string"
var iNum = -sNum;
alert(iNum);		//Uppgiften är "-20"
alert(typeof iNum);	//Uppgiften är "number"

I ovanstående kod kommer den unara minusoperatorn att konvertera strängen "-20" till -20 (den unara minusoperatorns behandling av hexadecimala och decimala värden är lik den unara plusoperatorns, men den räknar också ut det negativa värdet).