function summa(a,b) {
         var tulos = a+b;
         return tulos;
       }

• Funktion sisällä var-määritellyt muuttujat ovat funktion paikallisia muuttujia. Ne näkyvät vain funktion sisälle ja mahdollisesti näkyvät funktion sisältämien paikallisten funktioiden sisälle.
  Muista: Funktion sisältämissä nimettömissä lohkoissa var-määritellyt muuttujat eivät ole uusia muuttujia, mutta let-määritellyt ovat!

• Muiden muuttujien tapaan JavaScriptin muodollisilla parametreilla ei ole tyyppiä. Todellisilla parametreilla on tyyppi kuten kaikilla arvoilla.

• Muodolliset parametrit ovat Javan tapaan arvoparametreja: ne ovat funktion paikallisia muuttujia, jotka saavat alkuarvoikseen funktion kutsussa annettujen todellisten parametrien arvot. Näin alkeistyyppiset arvot kopioidaan sellaisinaan, mutta olioarvot välitetään olioviitteinä, "langan alkupäinä" eli viitteiden arvoina. Kaikki Java-taitoiset tietenkin tuntevat tilanteen! Tunnethan sinäkin? ;-)

  function muutaMolemmat (taulu1,taulu2) {
    taulu1[1] = "kissa";     // taulukko-olion alkio on muutettavissa
    taulu2 = [666,666,666];  // sijoitus muodolliseen parametriin ei muuta todellista
  }
  
  var t1 = [1,2,3]
  var t2 = [1,2,3]
  
  muutaMolemmat(t1,t2);
  
  write(t1);   // 1,kissa,3
  write(t2);   // 1,2,3
  

• Funktio voi sisältää yhden tai useamman return-lauseen, joka ilmaisee funktion palauttaman arvon. Funktion suoritus päättyy tällaiseen lauseeseen. Jos funktion suoritus ei pääty arvon ilmaisevaan return-lauseeseen, funktion palauttama arvo on undefined. Tämä ei ole virhetilanne.

function ulompi() {
  // koodia...
  sisempi();
  // koodia...
  function sisempi() {write("Minä löydyn!");}
}
ulompi();  // Minä löydyn!

Normaalisti toki on selkeintä kirjoittaa alifunktioiden määrittelyt funktion alkuun, mutta jos alifunktioilla toteutetaan keskinäistä rekursiota ("mutual recursion"), kieleen valittu ratkaisu on hyvä.

Esimerkki keskinäisestä rekursiosta (joku vähän varttuneempi saattaa tunnistaa tämän vanhoilta peruskursseilta... ;-):

function taikuutta(raja) {

  function abra(jono) {
    if (jono.length < raja) {
      jono += "ABRA"    
      write("Abra ennen kadin kutsua  : "+jono)
      kad (jono)          // kad siis tunnetaan jo täällä!
      write("Abra jälkeen kadin kutsun: "+jono)
    }
  }

  function kad(jono) {
    if (jono.length < raja) {
      jono += "KAD"    
      write("Kad ennen abran kutsua   : "+jono)
      abra (jono)
      write("Kad jälkeen abran kutsun : "+jono)
    }
  }

  abra("")
}
taikuutta(15)

Abra ennen kadin kutsua  : ABRA
Kad ennen abran kutsua   : ABRAKAD
Abra ennen kadin kutsua  : ABRAKADABRA
Kad ennen abran kutsua   : ABRAKADABRAKAD
Abra ennen kadin kutsua  : ABRAKADABRAKADABRA
Abra jälkeen kadin kutsun: ABRAKADABRAKADABRA
Kad jälkeen abran kutsun : ABRAKADABRAKAD
Abra jälkeen kadin kutsun: ABRAKADABRA
Kad jälkeen abran kutsun : ABRAKAD
Abra jälkeen kadin kutsun: ABRA

• Ylimääräiset todelliset parametrit jätetään huomiotta. Puuttuvia todellisia parametreja vastaavat muodolliset parametrit saavat arvokseen undefined, mikä ei ole virhe, vaan tutkittavissa oleva asiaintila: undefined==undefined on nimittäin true.

  function fun(a,b) {
    write("a="+a +", b="+b)
  }
  
  fun();         // a=undefined, b=undefined
  fun(1);        // a=1, b=undefined
  fun(1,2,3,4);  // a=1, b=2
  
  

• Kuten jo edellä mainittiin funktion muodollisten parametrien tällä kutsukerralla saamia todellisia arvoja voi tutkia myös "taulukko-olion kaltaisesta" arguments-oliosta:

  function fun(a,b) {
    for (var i=0; i < arguments.length; ++i)
      write("parametri "+ i + " on " + arguments[i])
  }
  
  write("fun():");             // fun():
  fun();
  
  write("fun(11):");           // fun(11):
  fun(11);                     // parametri 0 on 11
  
  write("fun(11,22,33,44):");  // fun(1,2,3,4):
  fun(11,22,33,44);            // parametri 0 on 11
                               // parametri 1 on 22
                               // parametri 2 on 33
                               // parametri 3 on 44
  

• Näin funktion voi siis "omin käsin" ohjelmoida käsittelemään mielivaltaisen määrän parametreja. Kehittyneempiäkin keinoja on.

• Tuo "talukko-olion kaltaisuus" tarkoittaa, että arguments-oliolle ei ole käytettävissä kaikkia talukko-olioille sovellettavia operaatioita.

• Parametreille voi antaa oletusalkuarvoja:

  function f (x, y = 7, z = 42) { return x + y + z } 
  write(f(1))  // 50
  

  Ennen tämä piti ohjelmoida tutkimalla onko jokin parametri arvoltaan undefined ja tarvittaessa sijoittaa alkuarvo funktion algoritmissa.

• Vaihtuvan mittainen parametrilista:

  function kurssi(nimi, ...osallistujat) {
    write("Kurssin " + nimi + " osallistujat")
    for (oppilas of osallistujat)
      write(oppilas)
  }
  
  kurssi("JavaScript", "Matti", "Maija")
  kurssi("XYZ", "aaa","bee","cee","dee", "äf")
  

  Tulostus:

  Kurssin JavaScript osallistujat
  Matti
  Maija
  Kurssin XYZ osallistujat
  aaa
  bee
  cee
  dee
  äf
  

  Kuten edellä nähtiin, vanhastaan tämä jouduttiin ohjelmoimaan tutkimalla arguments-oliota "omin käsin".

• Iteroituvan kokoelman hajotus alkoiksi: (Tekniikka ei rajoitu pelkästään parametrivälitykseen!)

  function kirjoitaKaikki(...kaikki) {
    for (let yksi of kaikki)
      write(yksi)
  }
  
  var params = ["kissantassu", true, 7] 
  var other =  [1, 2, ...params]
  
  write(other)
  
  kirjoitaKaikki(3.14, 210, ...params, 666)
  
  var str = "böö, säikähditkö"             
  var chars = [...str]  // merkkijono jaetaan merkeiksi!
  write(chars)                 // b,ö,ö,,, ,s,ä,i,k,ä,h,d,i,t,k,ö
  
  

  Tulostus kokonaisuudessaan:

  1,2,kissantassu,true,7
  3.14
  210
  kissantassu
  true
  7
  666
  b,ö,ö,,, ,s,ä,i,k,ä,h,d,i,t,k,ö
  
  

function f(x) {
  var a=1, b=2;

  var g = function(y) {
            var c=3;
            return a+b+x+ // vapaita muuttujia
                   y+c;   // sidottuja muuttujia
          }
  return g(4);
}

write(f(5));  // 15

Tässä esimerkissä funktioliteraalissa määritellään muuttujien tunnukset y ja c. Nämä muuttujat on sidottu funktioliteraaliin ja niillä on merkitys vain literaalin sisällä. Vapaiden muuttujien tunnukset x, a ja b puolestaan on määritelty funktioliteraalin ulkopuolella Näkyvyyssäännöt sallivat näiden muuttujien käytön koska "sisältä näkyy ulos".

function map(muunnos,taulukko) {
  var tulos = []; // uusi tyhjä taulukko
  for (var i = 0; i < taulukko.length; i++)
    tulos[i] = muunnos(taulukko[i]);
  return tulos;
}
var luvut = [1,2,3,4,5]
var a = map(x => x*x, luvut);
            // vain sidottu muuttuja

Tässä map-funktiolle siis annetaan parametrina sulkeuma, joka ei oikeastaan "sulje" yhtään mitään. (Vrt. "Joukko se tyhjäkin joukko on" ;-)

var taulu =[43,-2,9, 66, 18];
write(taulu);                // 43,-2,9,66,18
taulu.sort((a,b) => a-b); 
write(taulu);                // -2,9,18,43,66

function f(x) {
  var a=111, b=222;
  x(); // täällä parametrina saadun sulkeuman suoritus käynnistetään
  a=1234; b=5678
}

function g() {
  var a=10, b=20;
  f(function() {a=77; b=99;}); // funktioparametri, jossa vapaita muuttujia
  write(a+" "+b);
}
g();    // tulostus 77 99

function omaFor(operaatio, kertaa) {
  for (var i = 0; i< kertaa; i++) 
   operaatio();
}

function hoiteleHommat() {
  var t = [1,2,3,4,5];
  var i=0;
  omaFor(function() {t[i]*=t[i];++i;}, t.length);
  write(t);  // 1,4,9,16,25
}

hoiteleHommat()

   omaFor(() => {t[i]*=t[i];++i;}, t.length);

function teeLaskuri() {
  var x=0;
  return function() {++x; return x;}  // palautusarvo on siis funktio!
}

var laskuri1 = teeLaskuri(); // huom: EI teeLaskuri ilman sulkeita, koska 
                             // halutaan paluuarvo ei funktioviitettä

write("laskuri1 = " + laskuri1());  // 1
write("laskuri1 = " + laskuri1());  // 2
write("laskuri1 = " + laskuri1());  // 3

var laskuri2 = teeLaskuri();

write("laskuri2 = " + laskuri2());  // 1 !
write("laskuri2 = " + laskuri2());  // 2
write("laskuri1 = " + laskuri1());  // 4 !

var laskuri3 = teeLaskuri();
write("laskuri3 = " + laskuri3());  // 1

Kuten nähdään, kukin laskuri aloittaa laskennan ykkösestä. Jokaisella sulkeumalla siis on oma x-muuttujansa. Tuo muuttuja on myös piilossa, siihen ei pääse käsiksi. (Syttyykö mikään lamppu? ;-)

function piste() {
  var x=0, y=0;  // piilossa pidetyt kentät

  // aksessorit:
  return {                           // palautetaan siis olio, joka
      getX:  function() {return x},  // sisältää aksessorit!
      setX:  function(ux) {
               ux = parseFloat(ux);
               if (!isNaN(ux))       // vain numeeriset kelpaavat
                 x=ux;
             },
      getY:  function() {return y},
      setY:  function(uy) {
               uy = parseFloat(uy);
               if (!isNaN(uy))       // vain numeeriset kelpaavat
                 y=uy;
             },
      print: function() {write("("+x+", "+y+")")} 
  }
}

var a = piste();
write(a.getX());               // 0
a.setX(87);
write(a.getX());               // 87
a.setY(3.14);
write(a.getY());               // 3.14
a.print();                     // (87, 3.14)
var b = piste();
b.setX(123); b.setY(-9.762);
b.print();                     // (123, -9.762)

// jatketaan edellisen ohjelman suoritusta vaihtamalla b:n kentän sisältö:
b.print = function() {write("BÖÖ!")};  // mikään ei estä tätä!
b.print();  // tulostuu BÖÖ!

var taulu =[43,-2,9, 66, 18];
write(taulu);                           // 43,-2,9,66,18
taulu.sort((a,b) => a-b); 
write(taulu);                           // -2,9,18,43,66

function f(x) {
  var a=111, b=222;
  x(); // täällä parametrina saadun sulkeuman suoritus käynnistetään
}

function g() {
  var a=10, b=20;
  f(() => {a=77; b=99}); // funktioparametri, jossa vapaita muuttujia
  write(a+" "+b);
}
g();    // tulostus 77 99

function teeLaskuri() {
  var x=0;
  return () => ++x    // !!   
}

var laskuri1 = teeLaskuri()
write("laskuri1 = " + laskuri1());  // 1
write("laskuri1 = " + laskuri1());  // 2
write("laskuri1 = " + laskuri1());  // 3

var laskuri2 = teeLaskuri();
write("laskuri2 = " + laskuri2());  // 1 !

• eval(koodia) suorittaa parametrina annetun JavaScript-ilmauksen. Jos parametri on lauseke, arvon ilmaus, sen ei tarvitse olla merkkijonona, mutta se saa olla. Jos parametri on lause tai määrittely, sen on esitettävä merkkijonona:

  write(eval(23));         // 23
  write(eval("23"));       // 23
  write(eval("23")+44);    // 67
  write(eval("23")+"44");  // 2344
  eval("var a=123");
  write(a);                // 123
  
  var b=987;
  eval(b=456);
  write(b);                // 456
  
  // ...
  // ... on jopa mahdollista:
  
  eval(prompt("Anna ohjelmarivi niin suoritan sen"))
  
  

• isFinite(arvo) – onko parametri äärelliseksi luvuksi ymmärrettävissä:

  true:  5, -3.14, 0, "", '', "    ", "123", false, true, -0, ...
  false: NaN, Infinity, -Infinity, "abc", ...
  
  

• isNaN(arvo):

  true:  NaN, "abc", 
  false: 23, "23", Infinity, -Infinity, "", '', "    ", false, true, -0, ...
  
  

• parseInt(arvo) ja parseFloat(arvo) pyrkivät jäsentämään merkkijonosta (merkkijonon alusta!) kokonais- tai desimaaliluvun. Ellei onnistu, palauttavat NaN.

  parseInt("123")     --> 123
  parseInt("123abc")  --> 123
  parseInt(123)       --> 123
  parseInt(123asd)    --> SyntaxError: identifier starts immediately after numeric literal
  parseInt("kissa")   --> NaN
  parseInt(true)      --> NaN
  parseInt("")        --> NaN
  parseInt(Infinity)  --> NaN
  
  

• Number(olio) kutsuu olion valueOf-metodia, String(olio), kutsuu olion toString-metodia:

  var a = { valueOf:  function() {return 123},
            toString: function() {return "abc"}
          }
  
  write(Number(a)); // 123
  write(String(a)); // abc
  
  a = Date();
  write(Number(a)); // NaN
  write(String(a)); // Mon Nov 12 2018 16:14:04 GMT+0200 (Eastern European Standard Time)
  
  //myös toki:
  write(a)          // Mon Nov 12 2018 16:14:04 GMT+0200 (Eastern European Standard Time)
  

  Siispä toteuttamalla omaan olioon metodit valueOf ja toString voi määritellä olion "arvon" ja "merkkiesityksen".

function sum(a,b) {return a+b} 

var plus_7 = sum.bind(null, 7); 
write(plus_7(9))  // 16

var arpaLisays = sum.bind(null, Math.floor(10*Math.random()))
write(arpaLisays(10))  // esim. 14

function f(a,b,c,d) {
  write(a + "/" + b + "/" + c + "/" + d)
}

var f0 = f.bind(null)            // ei kiinitetä yhtään parametria
f0(1,2,3,4)                      // 1/2/3/4

var f1 = f.bind(null,10)         // kiinitetään a
f1(1,2,3)                        // 10/1/2/3

var f2 = f.bind(null,10,20)      // kiinitetään a ja b
f2(1,2)                          // 10/20/1/2

var f3 = f.bind(null,10,20,30)    // kiinitetään a, b ja c
f3(1)                             // 10/20/30/1

var f4 = f.bind(null,10,20,30,40) // kiinnitetään kaikki parametrit
f4()                              // 10/20/30/40

function lounas(nimi,herkku,lkm) {
  //jotain raskasta laskentaa ...
  write(nimi + "lle " + lkm+" "+ herkku + "a!")
}

// perusversio:
lounas("Sini", "piirakka", 3)  // Sinille 3 piirakkaa!

// erikoistetaan:
var sininLounas = lounas.bind(null, "Sini", "piirakka")

sininLounas(7)  // Sinille 7 piirakkaa!
sininLounas(2)  // Sinille 2 piirakkaa!