Operaatorid

Operaatorid on erinevad sümbolid ja märgendid, mis võimaldavad JavaScripti programmil teostada mitmesuguseid tegevusi - kontrollida tingimuste vastavust, muuta väärtusi ja muud sellist. Reeglina on operaatoril kaks operandi, vasak ja parem. Näiteks a + b, kus a on operaatori + vasak operand ning b siis vastavalt parem. Eksisteerib ka kolme operandiga operaator (?:, ternaarne tingimuslause) ning ühe operandiga (-, unaarne - või ++ inkrement).

Operatsioone saab ka liita. a + b + c - sellisel juhul pole tegu mitte kolme operandiga operatsiooniga vaid kahe liidetud operatsiooniga. Pikemalt saab selle operatsiooni lahti kirjutada nii

(a + b) + c;

(kus (a+b) on esimene operatsioon ja (a + b) + c on teine operatsioon)

või

z = a + b;
z + b;

m1 + m2;
5 + 2 // 7

Juhul kui üks liidetavatest on string, teisendatakse mõlemad operandid tekstikujule. Sellisel juhul ei liideta operandide numbrilisi väärtusi, vaid liidetakse stringid üksteise järele. Seega tuleb selle tehte juures olla ettevaatlik ning vajadusel teisendada operandid näiteks parseInt funktsiooniga eelnevalt numbriteks.

3 + 4 = 7;
"3" + 4 = "34";

Üks situatsioon kus väärtus tuleks kindlasti enne numbrilisi tehteid teisendada, on andmete lugemine veebilehe vormiväljadest. Kõik vormiväljadelt loetud väärtused on alati tekstikujul ning seega nendega väärtustega liitmisel, ilma eelneva teisendamiseta, võib tekkida ootamatuid probleeme.

m1 - m2;
5 - 2 // 3

m1 * m2;
5 * 2 // 10

m1 / m2; 
5 / 2 // 2.5

Jagamisel nulliga ei ole tulemuseks mitte viga, vaid eritüübiline väärtus +/- Infinity (lõpmatus).

Jäägioperaatorit kasutatakse järgnevalt: m1 % m2, tulemuseks on jääk muutuja m1 jagamisel muutujaga m2.

m1 % m2;
5 % 2 // 1

Inkrement ++ suurendab operandi väärtust 1 võrra. Juhul kui operand asub operaatorist vasakul m++, on operatsiooni tagastusväärtuseks esialgne väärtus m (kõigepealt tagastatakse väärtus ja siis liidetakse muutujale 1). Juhul kui operand asub paremal, siis on tagastusväärtuseks m+1 (kõigepealt liidetakse muutujale 1 ning seejärel tagastatakse selle väärtus).

var m1 = 0;
alert(m1++) // 0;
alert(m1)   // 1;
alert(++m1) // 2;

Dekrement -- vähendab operandi väärtust 1 võrra. Juhul kui operand asub operaatorist vasakul m--, on operatsiooni tagastusväärtuseks esialgne väärtus m. Juhul kui operand asub paremal, siis on tagastusväärtuseks m-1.

var m1 = 5;
alert(m1--) // 5;
alert(m1)   // 4;
alert(--m1) // 3;

Muudab väärtuse negatiivseks.

-m1;

Operaatorist vasakul olevale muutujale omistatakse operaatorist paremal asuv väärtus.

var a = 123;

Järgmised operaatorid on omistamise lühivormid operaatorist vasakul oleva muutuja suhtes.

x += y; 
x = x + y;

x += y; 
x = x + y;

x *= y; 
x = x * y;

x /= y;
x = x / y;

Operaator nihutab bitid muutujas väärtuse võrra paremale, säilitab märgi.

x >>= y;
x = x >> y;

Operaator nihutab bitid muutujas väärtuse võrra vasakule, säilitab märgi.

x <<= y;
x = x << y;

Operaator nihutab bitid muutujas väärtuse võrra paremale, vasakud bitid täidetakse nullidega.

x >>>= y;
x = x >>> y;

x &= y;
x = x & y;

x |= y;
x = x | y;

x ^= y;
x = x ^ y;

Operatsiooni tagastusväärtus on tõene, kui operaatori mõlemad pooled on võrdsed. Juhul kui väärtused on eri tüüpi, teisendatakse kõigepealt tüübid. Kui üks operand on number või loogiline muutuja, teisendatakse operandid numbriteks. Juhul kui üks operand on string, teisendatakse ka teine stringiks.

var m1 = 5;
m1 == 5 // tõene, 5 == 5
"5" == m1 // tõene, "5" == "5"
m1 == '5' // tõene, "5" == "5"
m1 == m1 + 0 // tõene, 5 == 5

Operatsiooni tagastusväärtus on tõene, kui operaatori pooled ei ole võrdsed.

var m1 = 5;
m1 != 5 // väär
"4" != m1 // tõene
m1 == '3' // tõene
m1 != m1 + 2 // tõene

Operatsiooni tagastusväärtus on tõene, kui operaatori mõlemad pooled on võrdsed ning sama tüüpi.

var m1 = 5;
m1 === 5 // tõene
"5" === m1 // väär
m1 === '5' // väär
m1 === m1 + 0 // tõene

Operatsiooni tagastusväärtus on tõene, kui operaatori pooled ei ole võrdsed või on eri tüüpi.

var m1 = 5;
m1 !== 5   // väär
m1 !== '5' // tõene

Operatsiooni tagastusväärtus on tõene, kui operatsiooni vasaku operandi väärtus on suurem kui parema operandi väärtus.

5 > 3; // tõene
5 > 5 // väär

Operatsiooni tagastusväärtus on tõene, kui operatsiooni vasaku operandi väärtus on suurem või võrdne parema operandi väärtusega.

5 >= 3; // tõene
5 >= 5 //tõene

Operatsiooni tagastusväärtus on tõene, kui operatsiooni vasaku operandi väärtus on väiksem kui parema operandi väärtus.

3 < 5; // tõene
5 < 5 // väär

Operatsiooni tagastusväärtus on tõene, kui operatsiooni vasaku operandi väärtus on väiksem või võrdne parema operandi väärtusega.

3 <= 5; // tõene
5 <= 5 // tõene

Operatsioon on tõene, kui mõlemad operandid on tõesed - sellisel juhul on tagastusväärtuseks viimase operandi väärtus.

3 && 5; //tõene, 5
4 && 0 //väär

Kuna vaadatakse vaid esimese ebatõese operandini, on see hea viis kontrollida mingi alamväärtuse kehtivust.

if(a && a.b);

Näites kontrollitakse väärtust a.b ainult juhul, kui a on defineeritud.

Kuna kontrollitakse vaid esimese väära operandini, siis tuleb operaatori puhul olla parempoolse operandiga ettevaatlik - sealne avaldis täidetakse vaid juhul, kui vasak operand tagastab tõese väärtuse. Probleem võib tekkida, kui parempoolne operand peab sooritama mingit tegevust iga iteratsiooni ajal.

var c = 10, a = false;
while(c){
    if(a && c--){};
}

Näites olev tsükkel ei jõua kunagi lõpuni, kuna käsk c– jääb alati täitmata. Muutuja a väärtus on false ning seega tingimust edasi ei kontrollita.

Samuti tasub ette vaadata tekstiliste väärtustega "0" ning "false" - JavaScripti arvates on nende stringide väärtus võrdlustehetes true, kuigi osad teised keeled, näiteks PHP peavad antud väärtusi samas kontekstis ebatõesteks.

Tagastusväärtus on tõene, kui üks operandidest on tõene. Tagastusväärtuseks on esimene tõene operand.

3 || 5; //tõene (3)
0 || 4; //tõene, 4

Juhul kui vasak operand on tõene, siis parem operand jääb täitmata.

Operaatorit || saab kasutada ka mugavaks muutujate lähtestamiseks funktsioonide parameetritena - juhul kui väärtus on seadmata, saab muutuja väärtuseks mingi vaikimisi suuruse.

function test(nr){
    nr = nr || 12;
}

Näites kontrollitakse parameeter nr väärtust ning kui seda pole seatud, saab väärtuseks vaikimisi suurus 12. Sama saaks kirjutada ka tingimuslausega if(!nr){nr = 12;} või nr = nr?nr:12, kuid loogilise operaatoriga on lause mugavam kirja panna ning koodi lugedes on see ka kergemini mõistetav.

Tagastusväärtus on tõene kui operandi väärtus on väär.

!false; //tõene
!10 //väär

Operaatoriga ! saab teisendada suvalist väärtust loogiliseks väärtuseks true või false, kui kasutada operaatorit topelt - esimese korraga kontrollitakse, kas väärtust ei eksisteeri ning teise korraga kontrollitakse väärtuse mitte-eksisteerimise eksisteerimist

!!10 //tõene, väärtuseks true
!!0 //väär, väärtuseks false

x = x & y

x = x | y

x = x ^ y

x = x ~ y

Operaator nihutab bitid muutujas väärtuse võrra vasakule, säilitab märgi.

x = x << y

Operaator nihutab bitid muutujas väärtuse võrra paremale, säilitab märgi.

x = x >> y

Operaator nihutab bitid muutujas väärtuse võrra paremale, vasakud bitid täidetakse nullidega.

x = x >>> y

Bitioperatsioonide kohta loe lähemalt bitioperatsioonide peatükist.

Juhul kui üks operandidest on string, teisendatab operaator kõik operandid stringideks ning järjestab need stringid üheks kokku. Juhul kui sooviks on siiski liita operande kui numbreid, tuleks stringi kujul number ennem teisendada numbriks funktsiooniga parseInt().

"abc" + "def"; //"abcdef"
3 + "3" // "33"

var a = "abc";
a += "def"; // a=="abcdef"

Punkt objekti ning elemendi nime vahel tagastab objekti elemendi.

var z = document.getElementById('x');

Näites saab muutuja z väärtuseks objektis document oleva meetodi getElementById tagastusväärtus.

Kuna punkt on tavaline operaator, siis võib operandide ja operaatori vahel olla ka tühikuid. Mõnel juhul on see isegi kohustuslik - näiteks kui soovime objektina kasutada tavalist numbrit. Selliselt peab numbri ja punkti vahele jääma tühik, kuna vastasel korral peetakse punkti mitte notatsioonioperaatoriks, vaid komakoha eraldajaks.

5.toFixed(2) // SyntaxError
5 . toFixed(2) // "5.00"

Nurksulud objekti nime järel elemendi tekstikujul nimetusega tagastavad objekti elemendi. Sama mis punktnotatsioon, erinevusega et täiendavalt saab kasutada genereeritud elemendi nimetust (elemendi nimetus ei pea olema programmikoodis defineeritud).

var z = document['getElementById']('x');
// või
var n = 'getElementById';
var z = document[n]('x');

(tingimus ? kuiTõene : kuiVäär). tingimus - avaldis, mis tagastab väärtusena tõese true või väära false. kuiTõene ja kuiVäär võivad olla suvalised avaldised.

alert( a>b?"a on suurem kui b":"a ei ole suurem kui b");

Operaatorina käivitab koma avaldistena mõlemad operandid ning tagastusväärtusena väljastab parempoolse avaldise väärtuse. Operaatorit on kõige parem kasutada olukordades, kus on vaja käivitada mitu avaldist ühe lausena - näiteks for tsükli lähtestamisel.

for(var i=0, len=arr.length; i<len; i++);

Operaator delete kustutab objekti, objekti elemendi või massiivi kindlal indeksil asuva elemendi, v.a. need muutujaid, mis on deklareeritud käsuga var. Operaator delete kustutab tegelikult muutuja väärtuse asemel ainult viite selle väärtuse juurde, väärtust ennast ta ei eemalda. Väärtuse tegelikuks kustutamiseks on JavaScriptis olemas „prügikoristaja“ (garbage collector), mis käivitudes kustutab mälust kõik väärtused, mille juurde ei ole ühtegi töötavat viidet. Seega programmeerija ei pea ise muretsema kasutuks muutunud objektide eemaldamise pärast.

a = {sisu: "see on objekt"};
b = a;
delete a;
alert(b.sisu); // "see on objekt"

Antud näites „kustutasime“ küll esialgse objekti, kuid tegelikult kadus vaid esialgne viide objekti juurde. Hiljem loodud viide b = a jäi siiski kasutatavaks.

Elemendi olemasolu kontroll objektis. „element“ in objekt väljastab tõese tagastusväärtuse juhul kui objektis on olemas element või numbriline indeks nimega „element“.

if ("getElementById" in document){
    document.getElementById("elemendi_id");
}

Objekti tüübi vastavuse kontroll. objekt instanceof tyyp väljastab tõese tagastusväärtuse juhul kui objekti tüüp on tyyp.

new String("abc") instanceof String //true

Viide hetkel aktiivsele objektile, meetodi sees viitab this kutsuvale objektile.

var Auto = function(mark){
    this.mark = mark;  // this viitab hetkel aktiivsele funktsioonile Auto
}
Auto.prototype.getMark = function(){
    return this.mark;  // Kuna tegu on meetodiga, viitab this meetodi omanikule - funktsioonile Auto
}
var auto = new Auto('Audi');
alert(auto.mark); // Audi
alert(auto.getMark()); // Audi

this võib tekitada probleeme sulundite korral - kui objekti sees on defineeritud anonüümne funktsioon, on selle anonüümse funktsiooni this viiteks mitte väline objekt, vaid hoopis globaalne objekt window. Anonüümsele funktsioonile saab õige viite edastada läbi mõne muutuja, mis on defineeritud välise objekti skoobis.

var Auto = function(mark){
    this.mark = mark;
    var that = this;
    (function(){
        alert(that.mark); // anonüümses funktsioonis viitab this enesele, kasutada tuleb välise skoobi muutujat
    })(); // pane tähele lõpetavaid sulge, mis käivitavad esimestes sulgudes tagastatud anonüümse funktsiooni
}
new Auto('Toyota'); // Toyota

Teine võimalus on siduda this sulundfunktsiooniga läbi funktsiooni meetodi apply või call (loe lähemalt funktsioonide peatükist).

var Auto = function(mark){
    this.mark = mark;
    (function(){
        alert(this.mark); // seekord on this "õige"
    }).apply(this);
}
new Auto('Toyota'); // Toyota

Väljastab avaldise tüübi stringi kujul.

typeof "tekst" // "string";
typeof 2 // "number"

Käivitab etteantud avaldise ning väljastab tulemusena undefined. Avaldise parameeter on kohustuslik.

void (a = 2);
void; // SyntaxError, parameeter on kohustuslik

Konstruktoroperaator, mis loob paremal olevast objektist uue instantsi ning omistab vasakul olevale muutujale loodud instantsile suunatud viite this.

var objekt = new Konstruktor();
var aeg = new Date();

Kommentaarid on koodiblokid, mille interpretaator jätab vahele ning mida on mugav kasutada programmi töö kohta selgituste lisamiseks.

// kommenteerib rea lõpuni, lõpetavat märgendit ei vaja
/* kommenteerib kuni
kommentaari lõpetava märgendini */

Erinevad minimeerimisprogrammid, mis on mõeldud JavaScript failide suuruse vähendamiseks (vähendamaks serveri koormust failide laadimisel), kustutavad kommentaarid koodist automaatselt ise ära.

Erinevate operatsioonide korral ühes lauses tekib alati küsimus, missugune operatsioon nendest kõigepealt teostatakse? Näiteks kas lauses a + 4 / 5 teostatakse esiteks kõige vasakpoolsem st. esimene operatsioon lauses (+) või mingi muu (/). Allolevast tabelist leiabki vastava järjestuse, kus eelistuse number näitab järjekorda mille alusel erinevaid operatsioone koheldakse. Mida väiksem number, seda eelistatum operatsioon teistega võrreldes on. Eelnenud näites oleks seega esimeseks operatsiooniks jagamine / (5) ja teiseks liitmine + (6).

Tabel 2. Operaatorite järjekord