4 Lausekkeita ja operaatioita

• Lausekkeiden esitys JavaScriptissä muistuttaa hyvin paljon Javan (ja siten siis myös C:n) käytäntöjä.
• Valitettavasti myös sijoituslause on myös lauseke, sillä on arvo. Kyseessä on siis Javan tapaan "lausekelause", "expression statement".
• Kurssilla ei käsitellä JavaScriptin bittioperaatioita. Ne vaikuttavat hyvin javamaisilta.

• Huom: Tämän luvun write-sisältöiset ohjelmaesimerkit on tarkoitettu suoritettaviksi Pienellä testiympäristöllä.

• Aritmeettiset lausekkeet ja operaatiot ovat kuin Javassa:
  • 1+2, (a+b)*44, i%2, i++, ++i, x=3, z += 10, ... jne.

  • Koska kokonais- ja liukulukuja ei erotella, joidenkin laskutoimitusten tulokset poikkeavat Javan vastaavista, esim. 1.5.+1.5==3.

  • Minkä tahansa luvun jakaminen nollalla tuottaa arvon Infinity. Minkä tahansa luvun jakaminen arvolla Infinity on nolla ja Infinity/Infinity luontevasti on NaN.

• ECMAScript 6 esitteli uusia sijoitusoperaatioita, joilla voi sijoittaa rakenteisen arvon alkioita erillisiin muuttujiin ("destructuring assignment"):

  • Taulukon alkioita muuttujiin:

    var x = [23, 44, 67]
    var a, b, c;
    [a, b, c] = x;
    write(b)           // 44
    

  • Olion kenttiä muuttujiin:

    var x = {a:23, b:44, c:67}
    var {a, b, c} = x;
    write(b)           // 44
    

  • Yhdellä sijoituksella useita arvoja:

    var a, b;
    [a, b] = [123, 456];
    write(b)             // 456
    

  • Kahden muuttujan arvon vaihto, "swäppäys":

    var a=123, b=456;
    [a, b] = [b, a];
    write(b)             // 123
    write([a, b])        // 456,123  !!
    

  • Funktio voi palauttaa useita arvoja:

    function f() {return [123, 234]}
    var a, b;
    [a, b] = f();
    write(b)       // 234
    

  • Arvoja voi myös jättää käyttämättä:

    var x = [23, 44, 67]
    var a, b;
    [a, , b] = x;
    write(b)            // 67
    
    function f() {return [123, 234, 345]}
    var [a, , b] = f();
    write(b)            // 345
    

  • Jne, jne, ...

• ECMAScript 6:ssa on myös muita mm. sijoitusoperaatioon liittyviä uutuuksia:

  • var parts = ['shoulder', 'knees'];
    var lyrics = ['head', ...parts, 'and', 'toes'];
    
    write(lyrics) // head,shoulder,knees,and,toes
    
    function f(x, y, z) { }
    var args = [0, 1, 2];
    f(...args);
    ...
    

    Näihin palattaneen myöhemmin.

• Totuusarvoiset lausekkeet ja operaatiot toimivat Javan tapaan:
  • ab && cd, !(c || d), ..., jne.

  • Operaatiot && ja || ovat Javan tapaan ehdollisia. Jälkimmäinen operandi siis evaluoidaan vain, jos totuusarvo ei selviä jo ensimmäisestä.

  • JavaScriptin villin ja vapaan tyypittelyn ansiosta (vai syystä?) loogisilla operaatioilla voidaan myös temppuilla:

    var a = "kissa" && "koira";  //  a=="koira";
    var b = "kissa" || "koira";  //  b=="kissa!
    

    Looginen operaatio siis palauttaa arvonaan viimeksi evaluoimansa arvon!

    JavaScript-idiomiin (vakiintuneeseen ilmaisutapaan) kuuluu seuraavan esimerkin kaltainen tyyli korvata kelvoton syöte (tms.) sopivalla oletusarvolla:

    // käyttäjältä on pyydetty syöte muuttujaan s
    var vastaus = s || "oletusarvo";
    

    Jos käyttäjä syöttää jotakin epätodeksi tulkittavaa kuten "", undefined, NaN, ..., muuttuja vastaus saa oletusarvon.

• Vertailuoperaatiot muistuttavat Javan vastaavia, mutta JavaScriptin automaattiset tyyppimuunokset tekevät asiasta hieman "mielenkiintoisemman".
  • Esimerkiksi seuraavat lausekkeet ovat arvoltaan true:

    7=="7", 6<="7", "6"<=7, ... jne.

  • Myös merkkijonoja voi vertailla erisuuruusoperaatoilla. Kyseessä on Unicode-merkkikoodien mukainen leksikaalinen järjestys (vrt. Javan Stringien compareTo-metodi) Esimerkiksi seuraavat lausekkeet ovat arvoltaan true:

    "a"<"b", !("a"<"B"), "aasi"<"aasia" ... jne.

  • Yhtäsuuruuden ja erisuuruisuuden tutkimiseen JavaScriptissä on kolme samuuden versiota: abstrakti (== ja !=), tiukka (=== ja !==) ja erityiskäyttöön tarkoitettu Object.is-metodi.
    • Abstraktit samuusvertailut == ja != tekevät tarvittaessa tyyppimuunnoksia samuuden tutkimisessa. Esimerkiksi seuraavat lausekkeet ovat arvoltaan true:
      123=="123", new String("abc")=="abc", false==0, ""==false, ""==0, null==undefined, []==0

    • Tiukat samuusvertailut === ja !== eivät tee tyyppimuunnoksia ennen samuuden tutkimista. Edellisen luettelon abstraktista vertailusta poiketen lausekkeet ovat arvoltaan false:
      123==="123", new String("abc")==="abc", false===0, ""===false, ""===0, null===undefined, []===0

    • Samuusvertailu Object.is poikkeaa tiukasta siten, että seuraavat kaksi ovat arvoltaan true päivastoin kuin tiukassa:
      Object.is(NaN,NaN), !Object.is(+0,-0). Tästä ei sen enempää.

    • Perusteellinen luettelo samuusvertailuista ja pohdintaa asian tiimoilta löytyy MDN:n sivulta Sameness in JavaScript.

    • On syytä muistaa, että oliot Javan tapaan "riippuvat langan päässä" eli hienosti sanottuna niillä on viitesemantiikka. Tällä on kaikille tutut seurauksensa.

• Ehdollinen lauseke

  • Ehdollinen lauseke on Javasta tuttu:

    var ika = prompt("Mikä on ikäsi?")
    alert(
      (ika >= 18) ? "Tervetuloa ravintolaan!" 
                  : "Seis lapsi!"
      )
    

• Erikoisoperaatioita

  • Pilkku: Lauseke arvo1, arvo2 on arvoltaan listan viimeinen arvo: arvo2. Seuraava on mahdollinen vaan ei järkevä:

    var a = (3.14, "kissa", "koira");   // a=="koira"
    

    Järkevä(?) käyttö liittyy esim. for-lauseen otsikon alkuarvon ja etenemisilmauksen monitoiminnallisuuteen:

    for (var i=1, j=5; i<j; ++i, --j, alert("Ja taas mennään!"))
      alert(i*j);
    

  • Operaatioita delete, in, instanceof, new, this ja typeof käsitellään aikanaan oikeassa yhteydessään.

• Operaatioiden sitovuus eli operaattoripresedenssi tiukimmasta löyhimpään:

  

by WebCounter
(12.10.2013)