ECMAScript unære operatorer

Enary operator har kun én parameter, nemlig det objekt eller værdi, der skal opereres på. De er de enkleste operatører i ECMAScript.

delete

delete-operator sletter referencer til tidligere definerede objektets egenskaber eller metoder. For eksempel:

var o = new Object;
o.name = "David";
advar o.name; // udskriv "David"
slet o.name;
alert(o.name);	//Uddrag "undefined"

I dette eksempel betyder sletning af name-attributten, at der tvunget oprettes en reference til det, hvilket sætter det til undefined (dvs. værdien af en ikke-initialiseret variabel).

Delete operatoren kan ikke slette attributter og metoder, der ikke er defineret af udvikleren. For eksempel vil følgende kode udløse en fejl:

delete o.toString;

Selvom toString er et gyldigt metodenavn, vil denne linje udløse en fejl, fordi toString() metoden er en oprindelig ECMAScript metode og ikke defineret af udvikleren.

void

Void operatoren returnerer undefined for enhver værdi. Denne operator bruges normalt til at undgå uønskede uddrag, for eksempel når en JavaScript-funktion kaldes fra et HTML <a>-element. For at gøre dette korrekt må funktionen ikke returnere en gyldig værdi, ellers vil browseren tømme siden og kun vise funktionens resultat. For eksempel:

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

Hvis du indsætter denne linje i en HTML-side og klikker på linket, vil du se "[object]" vises på skærmen.TIY

Dette skyldes, at window.open() metoden returnerer en reference til det nye åbnede vindue. Derefter konverteres dette objekt til den tekst, der skal vises.

For at undgå denne effekt kan du kalde window.open() funktionen med void operatoren:

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

Dette gør, at kaldet af window.open() returnerer undefined, hvilket ikke er en gyldig værdi og vil ikke blive vist i browserens vindue.

Påmindelse:Husk, at funktioner uden returværdi faktisk returnerer undefined.

Præ-increment/præ-decrement operatorer

De to operatorer, der direkte er lånt fra C (og Java), er præ-increment og præ-decrement operatorer.

Præ-increment operatoren betyder at tilføje 1 til værdien, og formen er at placere to plusstegn (++) foran variablen:

var iNum = 10;
++iNum;

Den anden linje øger iNum til 11, hvilket er sandt set lig med:

var iNum = 10;
iNum = iNum + 1;

Samme, præ-decrement operatoren trækker 1 fra værdien, og formen er at placere to minusstegn (--) foran variablen:

var iNum = 10;
--iNum;

I dette eksempel reducerer den anden linje værdien af iNum til 9.

Ved brug af præfiksoperatorer skal det bemærkes, at både increment og decrement operatører udføres før beregning af udtrykket. Overvej følgende eksempel:

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

Anden linjes kode udfører en decrementering af iNum, tredje linjes kode viser resultatet ("9"). Fjerde linjes kode udfører igen en decrementering af iNum, men denne gang er præfiksdecrementeringen og outputoperationen i samme sætning, og resultatet er "8". For at bevise, at alle decrementeringer er udført, udskrives "8" igen i femte linje.

I algebraiske udtryk er prioriteten for præfiks- og præfiksoperatorer samme, så de skal beregnes i henhold til rækkefølgen fra venstre til højre. For eksempel:

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

I det foregående kodeeksempel er iNum3 lig med 22, fordi udtrykket skal beregnes som 1 + 21. Variabeln iNum4 er også lig med 22, også 1 + 21.

Efterfølgende incrementering/decrementering

Der er to operatorer, der direkte er lånt fra C (og Java), nemlig efterfølgende incrementering og decrementering.

Efterfølgende incrementering tilføjer 1 til værdien, formet som to plusstegn efter variablen (++):

var iNum = 10;
iNum++;

Forventeligt er efterfølgende decrementering også at reducere værdien med 1, formet som to bindestreger efter variablen (--):

var iNum = 10;
iNum--;

Anden linjes kode reducerer værdien af iNum til 9.

Forskellen med præfiksoperatorer er, at postfiksoperatorer udfører incrementering eller decrementering efter at have beregnet udtrykket, der indeholder dem. Overvej følgende eksempel:

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

Ligesom med eksemplet med præfiksoperatorer, udfører anden linjes kode en decrementering af iNum, tredje linjes kode viser resultatet ("9"). Fjerde linjes kode viser fortsat værdien af iNum, men denne gang anvendes decrementeringstegnet i samme sætning. Da decrementeringen sker efter beregningen af udtrykket, viser denne sætning tallet "9". Efter at have udført femte linjes kode, viser alert-funktionen "8", fordi en efterfølgende decrementering udføres mellem udførelsen af fjerde og femte linje.

I algebraiske udtryk er prioriteten for efterfølgende og efterfølgende operatorer samme, så de skal beregnes i henhold til rækkefølgen fra venstre til højre. For eksempel:

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

I den tidligere kode er iNum3 lig med 22, fordi udtrykket skal beregne 2 + 20. Variablen iNum4 er også lig med 22, men den beregner 1 + 21, fordi øgningen og formindskningen sker efter at variablen iNum3 er blevet tildelt værdien.

Den enkle plus- og minusoperator

De fleste mennesker er bekendt med den enkle plus- og minusoperator, og deres brug i ECMAScript er den samme som du lærte i gymnasiet.

Den enkle plusoperator har ikke nogen indvirkning på tal i sig selv:

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

Dette kode stykke anvender den enkle plusoperator på tallet 20, og resultatet er stadig 20.

Selvom den enkle plusoperator ikke har nogen effekt på tal, har den nogle interessante effekter på strenge, der konverterer dem til tal.

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

Dette kode stykke konverterer strengen "20" til en rigtig tal. Når den enkle plusoperator opererer på en streng, beregner den strengen på samme måde som parseInt(), med den vigtigste forskel, at kun strenger, der starter med "0x" (der repræsenterer hexadecimal tal), kan konverteres til en decimal værdi af en enkle operator. Derfor, når du bruger en enkle plusoperator til at konvertere "010", får du altid 10, mens "0xB" vil blive konverteret til 11.

På den anden side er den enkle minusoperator bare at tage negationen af et tal (f.eks. konvertere 20 til -20):

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

Ligesom den enkle plusoperator konverterer den enkle minusoperator også strenger til近似 tal, og den beregner også værdien som negativ. For eksempel:

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

I ovenstående kode vil den enkle minusoperator konvertere strengen "-20" til -20 (den enkle minusoperator håndterer hexadecimal og decimal på samme måde som den enkle plusoperator, men den beregner også værdien som negativ).