Lohkot

• Näkyvyysalueista puhuttiin jo luvussa 3. Nyt puhutaan lisää.

• Lohkot niputtavat lauseita yhteen samaan tapaan kuin Javassa. Tyypillisesti lohkoja käytetään rakenteisten lauseiden alilauseina:

    while (a!=b) {
      sitä;
      sun;
      tätä;
    }
  

• Tärkeä ero ero on, että JavaScriptissä lähtökohtaisesti lohko ei ole näkyvyysalue! Kun muuttuja määritellään var-määrellä, sisemmässä lohkossa määritelty samanniminen muuttuja tarkoittaa samaa muuttujaa!

  { var a=77;
    { write(a);  // 77
      var a=33;  // tarkoittaa samaa muuttujaa a!
      write(a);  // 33
    }
    write(a);    // 33
  }
  

• JavaScriptiä ei siis haittaa, että muuttuja var-"määritellään uudelleen" sisemmässä tai samassa (sic!) lohkossa, sama muuttuja se kumminkin on! Tämä on (mielestäni) JavaScriptin todellinen suunnitteluvirhe!

• Muista: Sisäkkäiset funktiot muodostavat aitoja näkyvyysalueita myös var-määritellyistä muuttujista:

  function f() { 
    var a=77;
    function g() { 
      write(a);  //  undefined (HUOM!)
      var a=33;
      write(a);  // 33
    }
    g();
    write(a);    // 77
  }
  
  f()
  

• ECMAScript 6:ssa ja JavaScriptin versiosta 1.7 lähtien käytössä on let-määre, jolla esitellyillä muuttujilla on "kunnon kielten tapaan" lohkokohtainen näkyvyysalue:

  { let a=77;
    { //write(a);  tämä olisi virhe, koska lohkon a ei ole vielä määritelty
      let a=33;  // tämä on uusi a, joka peittää ympäröivän lohkon a:n
      write(a);  // 33
    }
    write(a);    // 77
  }
  

  [Tuo sisemmän lohkon write(a) olisi mahdollista myös sallia, mutta tähän tulkintaan kielen suunnittelijat ovat päätyneet. Ja ihan perustellusti.]

• Jos oikein hölmöksi haluaa ryhtyä, var- ja let-määriteltyjä muuttujia voi yhdistelläkin:

  { let a=77;
    var b=99;
    { 
      let a=33;
      var b=55;  
      write(a);  // 33
      write(b);  // 55
    }
    write(a);    // 77
    write(b);    // 55
  }
  

• Ja on siis syytä muistaa, että funktiot muodostavat näkyvyysalueita ja että sisempi funktio näkee ympäröivän funktion muuttujat, ellei se itse peitä niitä samannimisillä muuttujilla. Ja tämä siis pätee myös var-määritellyille muuttujille.

Ehdolliset lauseet if ja switch

• JavaScriptin ehdolliset if- ja switch-lauseet muistuttavat Javan vastaavia, mutta merkittäviä erojakin on.

• Totuusarvoisten lausekkeiden kirjoittaminen on paljon villimpää ja vapaampaa, kuten jo luvussa 4 nähtiin.

• Epätodeksi evaluoituvat arvot false, undefined, null, 0, -0, +0, 0.0, NaN, '' ja "".

• Kaikki oliot ovat totuusarvoiksi tulkittuina true, esimerkiksi [], {} ja jopa new Boolean(false):

     if(new Boolean(false))
       write(1231)            // 1231
  

• Jos oikein tulkitsen ECMAScript-määrittelyä, switch-lauseessa käytetään tiukkaa samuusvertailua (===). Taidanpa oikein tulkita:

  switch("123") {
    case 123: write("löysä");
              break;
    default:  write("tiukka");  // tämä tärppää
  }
  
  switch("") {
    case 0:   write("löysä");
              break;
    default:  write("tiukka");  // tämä tärppää
  }
  

• JavaScriptin switch-lause on parissa suhteessa hyvin joustava ja vahva: case-ehdot voivat olla dynaamisesti laskettavia lausekkeita ja erota toisistaan myös tyypeiltään:

  var a=4, c=5;
  var b = "*"; // tai 3 tai 1 tai muuta ...
  switch (b) {
    case a-1: write(22);  // case-ehto voi olla dynaaminen
               break;
    case c-a: write(33);  // eli lasketaan suoritusaikana
               break;
    case "*": write(44);  // ehdot voivat olla eri tyyppisiä 
               break;
    default:  write(55)
  } 
  

  Kokeile antaa b:n arvoksi 3, 1 ja jotain muuta.

Toistolauseet

Olioiteraatiolauseet

Poikkeusten käsittelylauseet

by WebCounter
(14.10.2013)