Istruzioni condizionali, cicli e funzioni

Il flusso del codice può essere gestito attraverso una serie di istruzioni contenute in blocchi definiti da parentesi graffe { }. Questi blocchi possono contenere funzioni oppure istruzioni di tipo condizionale o ciclico.
Lo scopo di questo capitolo è quello di presentare la sintassi con cui funzioni e istruzioni necessitano di essere definite.

Le istruzioni condizionali sono i classici "if" che determinano l'esecuzione di una porzione di codice al verificarsi di una condizione. Possono essere di tipo semplice, presentare un'alternativa o una serie di alternative (detti a cascata).

a = 10;
b = 25;
var testo ="";

// if semplice
if (a < b) {
   testo = "la condizione è verificata";
}

// if ... else
if (a < b) {
   testo = "la condizione è verificata";
} else {
   testo = "la condizione NON è verificata";
}

// if ... else if ... else
if (a < b) {
   testo = "la condizione è verificata";
} else if (a == b) {
   testo = "la condizione NON è verificata";
} else {
   testo = "la condizione NON è verificata";
}

L'if a cascata può essere più comodamente sostituito dall'istruzione "switch ... case" dove sono meglio identificati i blocchi di codice da eseguire confrontando l'espressione di riferimento (switch) con quelle presenti nei vari "case". Da notare, dal semplicissimo esempio di codice seguente, l'utilizzo dell'istruzione "break" all'interno di ciascun blocco di codice che permette l'uscita dal selettore una volta eseguito il caso verificato e la presenza del blocco "default" (non obbligatorio) che viene eseguito se non ci sono corrispondenze precedenti.

// Poniamo che a e b siano due variabili popolate dinamicamente
// in questo caso i valori sono rispettivamente 1 e 2
a = 1;
b = 2;
c = a + b;
testo = "";
switch (c) {
   case 0:
      testo = "la somma risulta 0";
      break;
   case 1:
      testo = "la somma risulta 1";
      break;
   case 2:
      testo = "la somma risulta 2";
      break;
   default:
      testo = "la somma risulta superiore a 2";
      break;
}

A livello di iterazioni è previsto l'utilizzo di cicli while, do-while e cicli for. Questi permettono di eseguire il codice all'interno del blocco finchè la condizione di riferimento è verificata. Nel codice seguente riporto con degli esempi la sintassi dei 3 tipi di ciclo.

a = 1;
b = 5;
c = 0;
d = 0;

// Finchè a è diverso da b il ciclo viene rieseguito (nel caso
// specifico viene eseguito 4 volte
while (a != b) {
   c = c + (a * b); 
   a = a + 1;
}

// do ... while. La condizione viene verificata successivamente per assicurarsi che
// il ciclo venga eseguito almeno una volta.
// In questo caso, infatti, nonostante la condizione non sia rispettata (perché a e b non sono uguali) il blocco di codice viene eseguito.
do {
   c = c + (a * b);
   a = a + 1;
}
while (a == b)

// Ciclo for. Tra parentesi abbiamo l'inizializzazione (d = 0), la condizione (d <  b)
// e l'incremento del contatore (d++)
for (d = 0; d < b; d++) {
   a = a + b;
}

I cicli possono essere interrotti anche prima che la condizione si sia verificata inserendo nel codice l'istruzione "break". Con l'istruzione "continue" invece si può evitare che vengano eseguite le operazioni successive ad esso pur continuando l'iterazione del ciclo.

a = 0;
b = 20;
while (a >= b) {
   a = a + 1;
   if (a == 15) break;
   if (a == 10) continue;
   c = c + (a * b); 
}
// Il ciclo prevedrebbe normalmente 20 iterazioni ed i calcoli di c vengono
// eseguiti fino a che il valore di a diventa 10. Quando a diventa 15 esco dal ciclo

Passando alle funzioni è possibile affermare che una funzione contiene una serie di comandi con la finalità di modificare e/o restituire dei valori. Può accettare parametri in ingresso ed essere richiamata tramita il suo nome. Esistono funzioni predefinite già nel linguaggio, abbiamo già visto, ad esempio nel capitolo precedente, l'uso di parseInt e parseFloat, ma ce ne sono altre come isNaN (la cui finalità è intuibile) oppure eval che esegue il contenuto di una stringa permettendo la costruzione di operazioni costruite a runtime.
Al di là comunque delle funzioni predefinite la sintassi di una funzione in Javascript è descritta di seguito:

function somma(val_a, val_b) {
   var z = val_a + val_b;
   return z;
}

a = 11;
b = 5;
var miasomma = somma(a, b);

Nel codice di cui sopra viene inserito all'interno della variabile "miasomma" il risultato della funzione "somma" in base ai parametri passati. Nel caso specifico il valore della variabile "miasomma" sarà 16.
Da notare la presenza del comando "return" al fine di far restituire un valore alla funzione. Tale comando non è obbligatio e la funzione pertanto potrebbe servire solo per eseguire determinate istruzione.
Un'arma a doppio taglio è la flessibilità di Javascript per quanto riguarda i parametri passati, infatti se io avessi richiamato la funzione in questo modo: somma(a) non mi verrebbe restituito un errore ma semplicemente il secondo parametro sarebbe identificato come undefined ponendo il valore di z uguale a NaN (Not a Number spiegato nel capitolo precedente della guida).
Il codice mette in evidenza anche due tipi di variabili, locali (all'interno della funzione ed accessibili solo da essa) come z e globali (all'esterno della funzione) quali appunto a, b e miasomma. L'esempio in questione non mostrà però l'ambito di visibilità, detto scope, ovvero che due variabili una locale ed una globale possono avere lo stesso nome ma appartenendo ad ambiti diversi il loro valore non è dipendente dalle operazioni che ognuna subisce; è tuttavia buona norma, anche per garantire una migliore leggibilità e gestione del codice, non utilizzare nomi uguali per variabili distinte.