Prerequisiti
- Costrutti fondamentali della programmazione strutturata.
- Variabili strutturate di tipo array.
Obiettivi
- Abituarsi alla codifica di algoritmi strutturati in linguaggio JavaScript.
Competenze da acquisire
- Conoscere la sintassi dei vari costrutti di selezione e iterazione.
- Conoscere la differenza fra tecnica di programmazione con uso intensivo di variabili globali e tecnica con uso intensivo di passaggio di parametri.
- Conoscere come dichiarare e accedere agli elementi degli array.
- Saper impostare i costrutti di selezione e iterazione.
- Saper impostare programmi con il minor uso possibile di variabili globali.
- Saper utilizzare le variabili array per risolvere esercizi.
Le istruzioni che controllano il flusso di elaborazione del codice possono:
- Eseguire decisioni condizionate.
- Realizzare iterazioni.
- Interrompere l’esecuzione dei blocchi di istruzioni.
- Richiamare funzioni.
Una delle strutture di controllo più importanti è JavaScript.
JavaScript, è il linguaggio di programmazione web interpretato dai browser e già dalla prima versione dispone di tutte le istruzioni tipiche della programmazione strutturata.
Le due istruzioni rese disponibili più recenti sono:
- l’istruzione switch.
- l’istruzione do while.
Istruzioni condizionali
Queste consentono di scegliere tra due o più alternative. Per fare questo usano espressioni booleane o condizionali.
Un esempio di espressione condizionale è:
(valore<10 && valore>O)
Questa espressione è true (vero) se il numero é compreso tra 1 e 9 ed è false (falso) per tutti gli altri numeri.
L’operatore di uguaglianza usato nelle istruzioni condizionali é “==“; mentre l’operatore di assegnamento é “=“.
leggi l’articolo sugli operatori del linguaggio
Il costrutto if… else
L’istruzione condizionale più importante è il costrutto if…. else, la cui sintassi è:
if(EspressioneCondizionale)
BloccolstruzioniRamoAllora
[else
BloccolstruzioniRamoAltrimenti]
In cui:
- Espressione Condizionale può assumere solo i valori true (veri) o false (falsi).
- BloccolstruzioniRamoAllora è un blocco di istruzioni che viene eseguito quando Espressione Condizionale è vera.
- BloccolstruzioniRamoAltrimenti è un blocco di istruzioni che viene eseguito quando Espress-ione Condizionale è falsa.
Osserva l’esempio riportato qui sotto:
<html>
<head>
<script language = “JavaScript”>
function Max()
{
N1 = parseInt(prompt(“Inserisci il primo numero”))
N2 = parseInt(prompt(“Inserisci il secondo numero”))
if(N1 > N2)
Max = N1
else
Max = N2
alert(“Il massimo è” + Max)
}
</script>
</head>
<body>
<form name = “f1”>
<input type = “button” name = “confronta”
value =“CONFRONTA” onClick = “Max()”>
</form>
</body>
</html>
Viene utilizzato l’operatore + per concatenare due stringhe:
alert("Il massimo è " + Max)
In questo caso Max, infatti, viene convertito in stringa.
Se si vogliono controllare più condizioni in successione si può iterare l’uso di else; ti spieghiamo come.
if (EspressioneCondizionale)
BloccoIstruzioni
[else if (EspressioneCondizionale)
Bloccolstruzioni] else Bloccolstruzioni
In questo caso viene valutata l’espressione condizionale iniziale, se risulta vera, viene eseguito il relativo Bloccolstruzioni e termina l’esecuzione.
Altrimenti, si valuta l’espressione condizionale posta accanto a ogni else if, e si continua con la valutazione dell’espressione relativa in cascata.
In questo caso si termina l’esecuzione, altrimenti si esegue il Bloccolstruzioni dell’else finale.
Leggi l’esempio per aver ben chiaro il concetto:
<html>
<head>
<script language = “JavaScript”>
var X = prompt(“Inserisci il valore di X: “);
if (X == 10)
document.write(“Hai inserito un valore di X pari a 10”)
else if(X == 20)
document.write(“Hai inserito un valore di X pari a 20”)
else if(X == 30)
document.write(“Hai inserito un valore di X pari a 30”)
else
document.write(“Hai inserito un valore di X diverso da 10, 20, 30”)
</script>
</head>
</html>
Il costrutto switch
Come abbiamo visto prima, un’altra istruzione condizionale è l’istruzione switch, la cui forma sintattica è:
switch (EspressioneCondizionale)
{
case Costante: BloccoIstruzioni
[break]
case Costante: BloccoIstruzioni
[break]
default: BloccoIstruzioni]
}
Dove il valore dell’espressione condizionale viene confrontato con un valore diverso costante del ramo case: quando viene trovata una corrispondenza, si esegue il blocco correlato.
Il blocco delle istruzioni dopo la parola chiave default facoltativo e può essere eseguito solo se non è stata trovata alcuna corrispondenza con tutti i precedenti valori costanti.
L’istruzione break è facoltativa perché consente al programma di uscire dal ciclo di switch: se manca, il programma continuerà a confrontare il valore dell’espressione con il valore costante successivo.
Esempio con costrutto switch:
<html>
<head>
<script language = "JavaScript">
var X = parseInt (prompt("Inserisci il valore di X:")
switch (X)
{
case 10:
{
document. write("Hai inserito un valore di X pari a 10")
break
}
case 20:
{
document.write("Hai inserito un valore di X pari a 20")
break
}
case 30:
{
document. write("Hai inserito un valore di X pari a 30")
break
}
default
document. write ("Hai inserito un valore di X diverso da 10, 20 e 30")
}
</script>
</head>
</html>
Istruzioni iterative
Le istruzioni iterative permettono di ripetere una porzione di istruzione in relazione al verificarsi di una condizione.
In generale controllano se una espressione è vera o falsa, nel primo caso eseguono le istruzioni seguenti racchiuse in un blocco { }.
Il costrutto while
Il costrutto iterativo di base è il while, la cui sintassi è:
while (Espressione Condizionale)
{
BloccoIstruzioni
}
Esempio con costrutto while:
<html>
<head>
<title> Usiamo il while </title>
</head>
<body>
<script>
function Leggi( )
{
while (I = 0; I <10; I ++;)
{
X = parseInt(prompt("Inserisci un numero"))
}
}
</script>
<form>
<input type = "button" name = "leggi" value = "premimi" onClick = "Leggi( )">
</form>
</body>
</html>
Il costrutto do…while
Se occorre eseguire il blocco di istruzioni almeno una volta, ci viene in aiuto l’istruzione iterativa: do… while, la cui sintassi è:
do
{
BloccoIstruzioni
}
while (EspressioneCondizionale).
Viene eseguito il Bloccolstruzioni finché l’EspressioneCondizionale è vera.
Per meglio comprendere, vediamo questo esempio del costrutto do…while.
function Leggi2()
{
let I = 0
do
{
X = parseInt(prompt(“Inserisci un numero”))
I ++
}
while (I < 10)
}
Il costrutto for
Un’altra istruzione iterativa molto usata è il costrutto for, la cui sintassi è:
for(EspressioneIniziale; EspressioneCondizionale; Passo)
{
BloccoIstruzioni
}
In questo caso Espressionelniziale e Passo sono due espressioni non condizionali.
Chiariamo il funzionamento:
Si imposta l’Espressionelniziale e si controlla l’EspressioneCondizionale.
Se quest’ultima è vera, viene eseguito il blocco di istruzioni.
Ogni ciclo si esegue il Passo e si verifica nuovamente l’EspressioneCondizionale. Quando quest’ultima è falsa, l’esecuzione termina.
Ti aiutiamo a capire meglio con questo esempio.
<html>
<head>
<title> Leggi 10 numeri da input </title>
</head>
<body>
<script>
function Leggi()
{
for(I = 0; I < 10; I ++)
{
X = parseInt(prompt(“Inserisci un numero”))
}
}
</script>
<form>
<input type = “button” name = “leggi” value = “premimi” onClick = “Leggi ()”>
</form>
</body>
</html>
Le istruzioni break e continue
Le istruzioni break e continue vengono utilizzate per ottimizzare cicli e istruzioni for, while e if…else.
L’istruzione break, infatti, consiste nell’interrompere un blocco di istruzioni e passare alla prima istruzione che segue il blocco contenente break.
Quindi, se l’istruzione break è incluso in un blocco di istruzioni in loop, l’effetto è interromperlo e passare il controllo alla prima istruzione dopo il ciclo.
D’altra parte, un comando continue inserito in un ciclo interromperà l’esecuzione blocco istruzioni e riprenderà l’esecuzione del ciclo all’iterazione successiva.
Entrambe queste istruzioni sono utili e sono preferite dai programmatori (esperti e no), anche se violano le rigide regole della programmazione strutturata.
Esempio istruzione break e continue:
Calcolare il divisore più grande di un numero intero N
function MaxDivisore(N)
{
let I= N-1
while(I>=1)
{
if (N%I == 0) break
I--
}
return(I)
}
