Myös aritmeettiset lausekkeet kirjoitetaan Javasta tuttuun tapaan, mutta semantiikassa on eroja, esim. 1.5+1.5 == 3 ja vaikkapa 10/3 == 3.3333333333333335 ja kuinka ollakaan kuitenkin 3*3.3333333333333335 == 10. Pyöristysvirheiden aiheuttamat ongelmat eivät toki ole vieraita JavaScriptillekään, mutta eipä kieli ole tarkoitettukaan raskaan sarjan numeeriseen laskentaan.

Totuusarvoisia lausekkeita kirjoitetaan Javasta tuttuun tapaan. Niistä lisää seuraavassa luvussa.

• Käytössä on Javasta tuttuja String-operaatioita ja String-arvot ovat Javan tapaan muuttumattomia. Merkkijonon yksittäisiä merkkejä voi tutkia myös taulukon indeksoinnin tapaan.

  write("kissa"[2])   // s
  

• Numeeristen arvojen ja merkkijonojen laskenta "+"-operaatiolla (yhteenlaskun ja katenaation tulkinta) on samantyyppistä kuin Javassa.

  write(22+33)        // 55
  write(22+"33")      // 2233
  write((4+2) + "3")  // 63
  write(4+2 + "3")    // 63
  write("3" + (4+2))  // 36
  

  Mutta eräillä katenaatioilla saattaa automaattisten tyyppimuunnosten takia saada odottamattomia tuloksia. Kokeile esimerkiksi seuraavia selaimen konsolissa: []+[], []+{}, {}+[], {}+{}. Tässä katenoidaan tyhjiä talukoita ja tyhjiä olioita. ;-)

• Operaatiot parseInt ja parseFloat ovat nimensä mukaisia, mutta niille riittää, että parametrimerkkijonon alku kelpaa luvuksi, mahdollinen häntä vain jätetään huomiotta.

  write(parseInt("123qwer"))        // 123
  write(parseFloat("123.4e-5xxx"))  // 0.001234
  write(parseFloat("kissanpoika"))  // NaN
  

  var x;
  if (x==undefined) {... tänne tullaan }
  else {... tänne ei tulla }

function neliosumma(x,y) {
  function nelio(x) {
    return x*x
  }
  function summa(x, y) {
    return x+y
  }
  return summa(nelio(x), nelio(y))
}
write(neliosumma(3,4))   // 25

     abc = 666;

(Yleisemmin: Arvon asettaminen oliolta puuttuvaan kenttään lisää tuon kentän olioon. Tämä on kiinnostavaa ja tästä paljon lisää tuonnempana...)

Tätä ominaisuutta voitaisiin pitää vakavana virheenä kielen suunnittelussa! Esimerkiksi kirjoitusvirhe tunnuksessa voi johtaa odottamattomiin seurauksiin. Tällaisia tyhjästä nyhjäistyjä muuttujia on syytä valttää! Ns. strict-mode auttaa tässä. Toisaalta tämä ominaisuus kuitenkin on linjassa kielen periaatteiden kanssa: globaalia oliota käsitellään aivan samoin kuin kaikkia muitakin olioita...

Kurkistus tulevaan:

WWW-sivun globaali JavaScript-ympäristö on window-olio. Jos mihin tahansa JavaScript-olioon asetetaan arvo kenttään, jota ei ole olemassa, tuo kenttä lisätään olioon!

Kun ohjelmassa evaluodaan edellisen esimerkin tapaan sijoitus määrittelemättömään muuttujaan, tuo muuttuja lisätään window-olion kentäksi!

abc = 666;
write(abc);        // 666
write(window.abc); // 666

Luennolla kurkistellaan myös siihen, mitä kaikkea kummallista tuosta window-oliosta löytyykään...

     var abc = 666;

function jotakin() {
  if (true) { 
    var a = 77;
  }
  write(a)  // viittaus lohkon ulkopuolelta!
}
jotakin();  // tulostuu 77

function jotakin() {
  if (false) {
    var a = 77;
  }
  write(a)  // viittaus lohkon ulkopuolelta!
}
jotakin();  // tulostuu undefined

function jotakin() {
  var a = 11;
  if (true) {
    let a = 22;
    write(a);
    for (let a=1; a<3; a++)
      write(a)
    write(a);
  }
  write(a);
}
jotakin()

function jotakin() {
  var a = 11;
  if (true) {
    var a = 22;
    write(a);
    for (var a=1; a<3; a++)
      write(a)
    write(a);
  }
  write(a);
}
jotakin()

   const a = 123;
   const b = "kissa";

["kissa", "koira", "hevonen"]
["yksi", 2, 3.14, "neljä"]     // alkiot toki voivat olla keskenään eri tyyppisiä
[11, , 22, 33]                 // alkio numero 1 on undefined
[ , 11, 22, , 33]              // alkiot numero 0 ja 3 ovat undefined
[11, 22, 33, ]                 // MUTTA tässä ei ole alkiota numero 3!
[11, 22, 33, ,]                // VAAN tässäpä on
                               // vain lopun viimeinen pilkku jätetään huomiotta

var aku = {etunimi: "Aku", sukunimi: "Ankka", rekisteriNro: 13};
write(aku.sukunimi);

var aku = {"etunimi": "Aku", sukunimi: "Ankka", rekisteriNro: 13};
write(aku.sukunimi);  // kenttänimen saa määrittelyssä ilmaista myös merkkijonona
write(aku.etunimi);

Myöhemmin kerrotaan paljon lisää olioista ja niiden kentistä.

var i=1;
var x = function() {alert("böö"+i); i++};
x();
var y = x;
y();

var summa = function(a,b) {return a+b};
var kukkuluuruu = summa;
write(kukkuluuruu(39,12));

var i=1;
var x = () => {alert("böö"+i); i++};
x();
var y = x;
y();

var summa = (a,b) => a+b;
var kukkuluuruu = summa;
write(kukkuluuruu(39,12));

var retki = {           // olioliteraali
             matka: 0,  // Km
             aika: 1,   // t
             nopeus: function() {return this.matka/this.aika}  // funktioliteraali olioliteraalin metodina!
            }

retki.matka = 150;
retki.aika = 2;
write(retki.nopeus() + " Km/t" );  // tulostaa 75 Km/t

ECMAScript 5:ssä tällaisia vielä jouduttiin rakentelemaan Javasta tutulla tavalla:

var customer = { name: "Foo" };
var card = { amount: 7, product: "Bar", unitprice: 42 };

message = "Hello " + customer.name + ",\n" +
"want to buy " + card.amount + " " + card.product + " for\n" +
"a total of " + (card.amount * card.unitprice) + " bucks?";
write(message)

var customer = { name: "Foo" } 
var card = { amount: 7, product: "Bar", unitprice: 42 } 

message = `Hello ${customer.name},
want to buy ${card.amount} ${card.product} for
a total of ${card.amount * card.unitprice} bucks?` 
write(message)

Huom: Tässä kirjoitustavassa muodostettavan merkkijonon rajoitinmerkki on siis "vasemmalle kallistuva hipsukka" eli gravis, ei yksinkertainen lainausmerkki!