JAVASCRIPT

È un linguaggio che fu introdotto nel 1995 da Netscape con l’idea di consentire la programmazione di pagine
web dinamiche.

Inizialmente era client-side ovvero l’utente richiede al server attraverso il browser una determinata pagina web
che viene fisicamente trasferita dal server al computer, interpretato dal browser ed infine visualizzata a
schermo. I processi di elaborazione e il codice vengono eseguiti sul computer in locale. Lo svantaggio
principale è che uno script può comportarsi in maniera differente a seconda del browser su cu viene eseguito.

Ora il suo utilizzo è diventato anche server-side ovvero l’utente richiede sempre al server una determinata
pagina web attraverso il browser ma i processi di elaborazione e il codice avvengono sul server, la pagina viene
interpretata dal server e all’utente arriva soltanto un file (pagina HTML) con le elaborazioni fatte dal server in
base alle richieste dell’utente. Il programma non è reso disponibile all’utente che può vedere solo il risultato
del programma.

Ci sono stati diversi upgrade negli ultimi 25 anni e la versione più diffusa è ECMAscript2021.

Java script è un linguaggio interpretato.

Linguaggio compilato o imperativo → permette di scrivere un codice che viene poi controllato e compilato,
ovvero ogni istruzione viene trasformata nel corrispondente codice macchina formando un file eseguibile che
può essere eseguito dal processore.

Linguaggio interpretato → il codice sorgente viene interpretato da un programma interprete, trasformato in

linguaggio macchina ed eseguito istruzione per istruzione a mano a mano che viene letto.

Si tratta inoltre di un linguaggio weakly type ovvero debolmente tipizzato perché consente di omettere la
descrizione del tipo di una variabile in fase di dichiarazione. Una stessa variabile può quindi cambiare tipo e
contenere in sequenza valori di ogni tipo. Questo concede al linguaggio grande flessibilità e poche restrizioni
ma rende più difficile il debugging.

Dato un problema da risolvere bisogna progettare un algoritmo che presi dei dati in input restituiscano un
output. Il programma è l’implementazione di una soluzione algoritmica che risolve un problema. Affinché il
programma implementi l’algoritmo noto bisogna mettere in sequenza una serie di comandi da eseguire in
ordine. Questi comandi devono essere comprensibili per l’interprete, quindi devono seguire le regole della
sintassi del linguaggio.
Sommario
BNF ........................................................................................................................................................ 4
TIPI DI DATO E CASTING ........................................................................................................................... 4
ESERCIZI .......................................................................................................................................... 6
CONTROLLO DI FLUSSO........................................................................................................................... 8
CONDIZIONALE: COMANDO IF - ELSE .................................................................................................... 8
ESERCIZI .......................................................................................................................................... 9
CONDIZIONALE: COMANDO SWITCH .................................................................................................... 9
ESERCIZI ........................................................................................................................................ 10
ITERAZIONE: COMANDO FOR .............................................................................................................. 11
ESERCIZI ........................................................................................................................................ 11
ITERAZIONE: COMANDO WHILE .......................................................................................................... 12
ESERCIZI ........................................................................................................................................ 12
ITERAZIONE: COMANDO DO WHILE ..................................................................................................... 13
BREAK E CONTINUE ............................................................................................................................ 13
FUNZIONI .............................................................................................................................................. 15
ESERCIZI ........................................................................................................................................ 17
ARRAY................................................................................................................................................... 19
ESERCIZI ........................................................................................................................................ 22
OGGETTI ............................................................................................................................................... 25
ESERCIZI ........................................................................................................................................ 27
RAPPRESENTAZIONE BINARIA ................................................................................................................ 29
ESERCIZI ........................................................................................................................................ 33
SCOPING .............................................................................................................................................. 35
INSIEMI ................................................................................................................................................. 38
ESERCIZI ........................................................................................................................................ 38
ALBERI BINARI ....................................................................................................................................... 40
ESERCIZI ........................................................................................................................................ 40
ALBERI K-ARI ......................................................................................................................................... 44
ESERCIZI ........................................................................................................................................ 44
ALGORITMI DI ORDINAMENTO ................................................................................................................ 48
STRUTTURE DATI CON ARRAY ................................................................................................................. 52
COPIA SHADOW E DEEP ......................................................................................................................... 55
ASSEGNAMENTI DESTRUTTURANTI ......................................................................................................... 56
OPERATORE SPREAD ............................................................................................................................. 58
ESPERIMENTI SUI CONCETTI DI ANALISI .................................................................................................. 59
PASSAGGIO PER VALORE O RIFERIMENTO ............................................................................................... 62
COSTRUTTORI ....................................................................................................................................... 64
METODI................................................................................................................................................. 65
PROTOTIPI............................................................................................................................................. 67
CLASSI .................................................................................................................................................. 69
EREDITARIETÁ .................................................................................................................................... 70
DICHIARAZIONI DI CAMPO .................................................................................................................. 71
MEMBRI PRIVATI ................................................................................................................................. 72
MEMBRI STATICI ................................................................................................................................. 72
GETTER E SETTER ............................................................................................................................... 72
GENERATORI ......................................................................................................................................... 74
ECCEZIONI............................................................................................................................................ 76
MODULI ................................................................................................................................................ 80
WRAPPER DI TIPI BASE ........................................................................................................................ 82
DATE ................................................................................................................................................. 83
ESPRESSIONI REGOLARI ..................................................................................................................... 84
ARRAY CON TIPI DI MACCHINA ............................................................................................................ 85
CLASSE SET ....................................................................................................................................... 85
CLASSE MAP ...................................................................................................................................... 85
JSON ................................................................................................................................................. 86
OGGETTI DELL’AMBIENTE (HOST-DEFINED).......................................................................................... 87
MODULO FILE SYSTEM ........................................................................................................................ 87
MODULO OPERATING SYSTEM ............................................................................................................ 87
MODULO PROCESS ............................................................................................................................ 87
MODULI URL E HTTP (ACCESSO AL WEB).............................................................................................. 88
BNF
Tutti i linguaggi di programmazione seguono una determinata grammatica più o meno complessa. La Backus-
Naur Form (BNF) è un modo di descrivere sinteticamente la grammatica di un linguaggio. La grammatica è data
da un insieme di produzioni ciascuna delle quali ha la forma:
classe ::= definizione1 | definizione2 | … | definizionen
e ogni definizione è una sequenza di simboli terminali e classi.

TIPI DI DATO E CASTING

JS consente di denotare valori letterali di determinati tipi.
I tipi di dati primitivi o predefiniti sono:
▪ Numeri
o Interi (2, -5, 0)
o Reali (2.5, 8.3)
o Numeri speciali (Infinity, -Infinity, NaN)
o Sono rappresentati su 54 bit –(10^53-1)<n<(10^53-1)

▪ Booleani
o True, false
o Valore di verità di espressioni (confronti)
o Operatori (AND, &&, OR, ||, NOT, !)

▪ Stringhe
o Letterali (caratteri alfanumerici o unicode) delimitati da ‘ ‘, “ “, ` `.
o Per usare apici dentro altri apici devono essere diversi.
o Operatori (+concatenazione, <, >, ==)

ESEM `2+5=${2+5}` `2+5=7` \\dollaro dice di calcolare il valore fra parentesi

“ciao”==”ciao” true
“ciao”==”Ciao” false \\controlla carattere per carattere e non la semantica
“5”==”cinque” false
“ciao”>”miao” false \\usa come ordinamento quello alfabetico
“ciao”<”Ciao” false \\le lettere maiuscole vengono prima
“ciao”<”Ciaone” false

Inoltre, posso combinare dei valori:

Espressione → pezzo di codice valutato ad un valore (somma, divisione, concatenazione di stringhe, AND).
Un’espressione viene valutata e restituisce un valore ovvero ha un valore finale.
Comandi → sono espressioni che potrebbero non avere un valore finale (console.log(), let)
Posso conoscere il tipo di una variabile con il comando typeof

ESEM typeof 5 numero

typeof “ciccio” stringa
typeof true booleano

Variabile → è un elemento del programma a cui viene assegnato un nome identificatore e un valore che
cambia. Si dichiara con let o var. Ci sono dei nomi che non possiamo assegnare alle variabili come 15 o true.
Constante → non è possibile modificarne il valore e si dichiara con const.

Sottolineiamo la differenza fra let, var e const

▪ Se qualcosa viene dichiarato con let o const viene visto soltanto all’interno del blocco in cui viene
dichiarato
▪ Invece una variabile dichiarata con var è visibile globalmente all’interno di tutto il programma anche se
dichiarata in un blocco
Casting → interpretare una variabile o un valore come se fosse di un altro tipo rispetto a quello che è. Fare
casting significa prendere una variabile che ha un valore di un tipo e trasformarlo in un altro. JavaScript proverà
sempre a farlo.
• Qualunque numero diverso da 0 e NaN è true
• 0, Null, undefined e NaN valgono false
• Qualunque stringa non vuota è true
• La stringa vuota è false

ESEM let a=10

console.log(Number(a)) 10
console.log(String(a)) “10”
console.log(Boolean(a)) true \\qualunque numero diverso da 0 e NaN è true

Quando si fanno operazioni tra tipi diversi viene messo in atto il casting automatico.

ESEM let a=”5”, b=6

let c=a +b
console.log(typeof(c)) stringa
console.log(c) “56” \\il + vale sia fra numeri che per la concatenazione
di stringhe, per regole di priorità fa il cast del numero
let c=a-b
console.log(typeof(c)) numero
console.log(c) -1 \\il – è definito solo fra numeri, quindi fa il cast della
stringa a cui sottrae 6
let c=Number(a)+b
console.log(typeof(c)) number
console.log(c) 11 \\riconosce due numeri e li somma

console.log(a==b) true \\== cerca di uguagliare i valori, trasforma in stringa

console.log(a!==b) true \\!== diversi in termini di valore e tipo, !(a===b)
console.log(a===b) false \\=== uguali in termini di valore e tipo, non fa cast

Altri tipi di dato sono:

▪ BigInt (dati primitivi): c’è una capienza di numeri che si possono rappresentare; dunque, si usa questo
tipo per allocare più spazio e rappresentare numeri molto grandi senza la virgola (interi a precisione
infinita). Si rappresenta con una n finale: 4356748395n
▪ Undefined rappresenta che a quella variabile non è stato associato o definito nessun valore, viene
assegnato dall’interprete o quando non c’è un valore restituito da una funzione
▪ Null viene assegnato dal programmatore quando quella variabile non ha valore.
▪ Oggetti (dati strutturali): permettono di rappresentare dei dizionari e mappe in cui a ciascuna chiave
vado ad associare un valore.
o Array
o Function (dati primitivi)

Il programma produce la soluzione al problema un output, ovvero il risultato del programma che va mostrato o
salvato, sulla base di input forniti, ovvero dati iniziali su cui lavorare.
Il comando per passare parametri esterni da tastiera è prompt()
Il comando per mostrare a video nella console è console.log().
Se stampo console.log() è una riga vuota
Bisogna utilizzare: const prompt = require("prompt-sync")();
Il comando \\ commenta la riga, altrimenti per un paragrafo */
Per eseguire un’espressione all’interno di una stringa si utilizza `La somma è $(a+b)`
Si usa typeof per controllare il tipo della variabile
Number()/String()/Double() permettono di fare il casting
ESERCIZI
ESERCIZIO: scriviamo un programma che risolve un’equazione di primo grado
▪ A*x +b=c; x=?
▪ A, b, c sono input del programma
▪ X è l’output

let a, b, c
a=prompt(“Inserisci a:”) \\ a risulta come stringa, è sbagliato
a=Number(prompt(“Inserisci a:”))
b=Number(prompt(“Inserisci b:”))
c=Number(prompt(“Inserisci c:”))
let x=(c-b)/a
console.log(x)

ESERCIZIO: Scrivere un programma che stampa la tabella di verità per la funzione Booleana “OR”

console.log(“true OR true=”, true || true) \\la virgola viene sostituita con uno spazio mentre
il + non viene sostituito, non viene eseguito il cast
e stampa una stringa e un booleano
console.log(“true OR false= ” + String(true||false)) \\posso anche non mettere il cast perché con una
stringa e un booleano concatenati (+) trasforma il
booleano in stringa
console.log(“false OR true=”, (false!!true)) \\avendo la virgola stampa una stringa e un
booleano
console.log(`false OR false = ${false ||false}`) \\metodo per eseguire l’operazione all’interno
della stringa con dollaro, parentesi graffe e apici
storti esterni
Posso anche prendere valori da tastiera:

let a= prompt("a?")
let b= prompt("b?")
let ris = (a == "true") || (b == "true")
console.log("a OR b =", ris)

ESERCIZIO: Scrivere un programma che stampa la tabella di verità per la funzione Booleana “AND”

console.log(“true AND true=”, true && true)

console.log("true AND false=", true && false)
console.log("false AND true=", false && true)
console.log("false AND false=", false && false)

Prendendo valori da tastiera:

let a= prompt(”a?”)
let b= prompt(“b?”)
let ris = (a == "true") && (b == "true")
console.log("a AND b =", ris)

ESERCIZIO: Scrivere un programma che stampa la tabella di verità per la funzione Booleana “NOT”

console.log(“NOT true=”, !true)

console.log(“NOT false= ” + String(!false))

ESERCIZIO: Scrivere un programma che dati un numero n ed un esponente e (letti dalla tastiera), calcola e
mostra a video il valore n^e
 let n = Number(prompt(“n?”))
let e = Number(prompt(“e?”))
console.log(n**e)

^ vuol dire fare SOR ovvero esclusivo mentre ** vuol dire moltiplicare n per sé stesso e volte. Questo esercizio
si può fare anche con un ciclo.

ESERCIZIO: Scrivere un programma che data una temperatura in Celsius dalla tastiera, calcola e mostra a
video la temperatura in Fahrenheit (F=C * 1.8 + 32)

let Celsius=Number(prompt(“Che temperatura vuoi convertire?”))

let Fahrenheit= (Celsius*1.8) + 32
console.log(Fahrenheit)

ESERCIZIO: Scrivere un programma che data una temperatura in Fahrenheit dalla tastiera, calcola e mostra a
video la temperatura in Celsius.

let Fahrenheit=Number(prompt(“Che temperatura vuoi convertire?”))

let Celsius = (Fahrenheit-32)*1.8)
console.log(Celsius)

ESERCIZIO: Scrivere un programma che dato un numero di secondi dalla tastiera calcola e mostra a video il
numero di ore, minuti e secondi inclusi

let secondi = Number(prompt("Numero di secondi:"))

let restoSecondi=secondi%3600
let ore=(secondi-(restoSecondi))/3600
console.log(ore)
secondi=restoSecondi
restoSecondi=restoSecondi%60
let minuti =(secondi-(restoSecondi))/60
console.log(minuti)
console.log(secondi)
CONTROLLO DI FLUSSO
Flusso di un programma → sequenza di comandi eseguiti in ordine dall’alto in basso.
Possiamo controllare il flusso ovvero il modo in cui l’interprete legge ed esegue le istruzioni a seconda di cosa
succede nel codice sorgente.

Controllare il flusso permette attraverso:

▪ COSTRUTTI CONDIZIONALI di eseguire determinate istruzioni solo se determinate condizioni sono
vere e dunque cambiare i comandi eseguiti in base a risultati di calcoli o input di utente (if, switch)
▪ COSTRUTTI DI ITERAZIONE di ripetere un blocco di istruzioni per un certo numero di volte prefissato o
fintanto che vale una condizione (for, while)

Oltre alle grammatiche per rappresentare queste istruzioni si utilizzano i diagrammi di sintassi, una
rappresentazione grafica delle grammatiche.

CONDIZIONALE: COMANDO IF - ELSE

Ciò che viene messo fra parentesi viene sempre valutato come un’espressione e quindi restituisce un
risultato. L’espressione può essere di qualsiasi tipo di dato grazie al cast automatico (una variabile, una
somma di interi, una concatenazione di stringhe) ma restituirà sempre un booleano. Se l’espressione viene
valutata true si esegue il primo comando, se false si esegue l’else o nel caso in cui non fosse specificato salta
la sequenza di comandi.

ESEM let secondi = Number(prompt("Numero di secondi:"))

if (secondi==0) console.log("Nada!")
else {
let restoSecondi=secondi%3600
let ore=(secondi-(restoSecondi))/3600
if (ore != 0) console.log(ore)
secondi=restoSecondi
restoSecondi=restoSecondi%60
let minuti =(secondi-(restoSecondi))/60
if (minuti != 0) console.log(minuti)
console.log(secondi)
}

Un modo alternativo all’if è l’espressione condizionale, che tuttavia essendo un’espressione restituisce
sempre un risultato. L’istruzione che svolge l’espressione condizionale è: se è vera la prima espressione
prendi il primo valore altrimenti prendi il secondo.

ESEM console.log(ore>0?ore + “ ore” : “”)

ESERCIZI
ESERCIZIO: Scrivere un programma che legga da tastiera un numero e stabilisca se quel numero è pari o
dispari, stampando in uscita rispettivamente 1 o 0

let n = Number(prompt("n")) oppure console.log(n%2==0?1:0)

if (n%2==0) console.log(1)
else console.log(0)

ESERCIZIO: Scrivere un programma che legga da tastiera tre numeri e mostri a video il loro massimo.

let a = Number(prompt("Primo numero: "))

let b = Number(prompt("Secondo numero: "))
let c = Number(prompt("Terzo numero: "))
if (a>b) {
if(a>c) console.log(a)
else console.log(c)
}
else {
if (b>c) console.log(b)
else console.log(c)
}

CONDIZIONALE: COMANDO SWITCH

Lo switch permette di controllare più valori possibili per una stessa espressione. Sia l’espressione fra
parentesi che l’espressione del case possono essere qualsiasi cosa (variabile, formula) basta che venga
valutata ad un valore. Il comando parte dal valore che gli viene passato e lo uguaglia ai vari case secondo ===
(quindi sia valore che tipo), quando trova una corrispondenza esegue tutto quello che c’è sotto quindi nei vari
case è necessario mettere break, ovvero interrompere l’esecuzione di un blocco e forzare l’uscita (nel caso
default invece termina il blocco quindi non importa a patto che sia scritto in fondo). Il caso default può essere
messo in qualsiasi punto ma verrà comunque considerato per ultimo però in questo caso servirebbe il break

Comando_switch:

Elenco_casi: Casi:

Caso: Defaulf:

Comandi:
ESEM Stampa del giorno della settimana in base all’input

let giorno = Number(prompt("Giorno"))

switch (giorno) {
case 1:
console.log("Lunedì")
break
case 2:
console.log("Martedì")
break
case 3:
console.log("Mercoledì")
break
case 4:
console.log("Giovedì")
break
case 5:
console.log("Venerdì")
break
case 6:
console.log("Sabato")
break
case 7:
console.log("Domenica")
break
default:
console.log("Boh")
}

Casi strani ma corretti:

switch (n) { switch (n) {
case 1: case n/2:
fai qualcosa fai qualcosa
case 2: break
fai qualcosa case n*2:
break fai qualcosa
} break
\\posso evitare il break per continuare anche con i }
casi successivi perché magari il caso prima è più //non è sempre detto che come negli esempi la
specifico mentre quello successivo più generale prima sia una variabile e la seconda una costante

ESERCIZI
ESERCIZIO: Scrivere un programma che legga da tastiera due numeri ed un operatore (tra +, -, * e /) e mostri a
video il risultato dell’operazione tra due numeri.

let n1 = Number(prompt("Primo numero: "))

let n2 = Number(prompt("Secondo numero: "))
let operatore = String(prompt("Operatore: ")
switch(operatore) {
case "*":
console.log("Il risultato è", n1*n2)
break
case "/":
console.log("Il risultato è", n1/n2)
break
case "+":
 console.log("Il risultato è", n1+n2)
break
case "-":
console.log("Il risultato è", n1-n2)
break
default:
console.log("Operatore non valido")
}

ITERAZIONE: COMANDO FOR

Il for permette di ripetere un insieme di comandi per un dato numero di volte. Solitamente si usa per realizzare
iterazioni determinate ovvero quando si conosce a priori il numero di iterazioni da eseguire.

▪ Nel primo caso il primo comando assegna il valore iniziale della variabile di iterazione, la seconda
espressione determina la condizione per cui si ripete il comando, il terzo comando indica come andare
ad aggiornare la variabile di iterazione.
▪ La forma in e of si utilizza quando si opera su un array, ovvero un insieme di elementi.

ESEM For per n elevato alla e

let n=Number(prompt("n"))
let e=Number(prompt("e"))
let res=1
for(let i=0; i<e; i++) {
res=res*n
}
console.log(res)

ESEM Somma dei primi n numeri naturali

let n=Number(prompt("n"))
let sum = 0
for (let i=1; i<=n; i++) { //per ripetere il ciclo n volte o (da 0 a <n) o (da 1 a <=n)
sum+=i //prima calcola la somma e poi l’assegna alla variabile
}
console.log(sum)

ESERCIZI
ESERCIZIO: Si scriva un programma che, dato un intero positivo n, calcola e stampa la somma dei numeri
dispari da 1 a n (con n compreso)

let n = Number(prompt("n<"))
let sum = 0
for(let i=1; i<=n; i=i+2)
sum += i
console.log(sum)
ITERAZIONE: COMANDO WHILE
Il comando while esegue il blocco di comandi fino a quando l’espressione guardia è vera, per questo motivo si
usa per iterazioni indeterminate ovvero quando non si conosce a priori il numero di iterazioni da eseguire.
L’espressione ha valore booleano ma può essere qualsiasi tipo di dato grazie al cast automatico. È importante
modificare il valore di guardia nel corpo affinché sia possibile terminare il ciclo.

ESEM Somma di valori inseriti dall’utente e termina per -1

let n, sum = 0
while (n!= -1) {
n = Number(prompt("n"))
sum+= n
}
console.log("La somma è", sum)

ESEM Somma di valori inseriti dall’utente escluso -1 per cui termina

let n, sum = 0 let n = Number(prompt("n"))
while (n!= -1) { let sum = 0
n = Number(prompt("n")) while (n!= -1) {
if (n != -1) sum+= n
sum+= n let n = Number(promp("n"))
} }
console.log("La somma è", sum) console.log("La somma è", sum)
\\la lettura devo farla almeno una volta

Spesso se sappiamo che almeno una volta dobbiamo eseguire una certa espressione scriviamo l’istruzione
prima del while, mettere la condizione e il blocco del while e poi ripetere l’istruzione.

ESERCIZI
ESERCIZIO: Si scriva un programma che legge numeri fino a che la loro somma non supera 101. Il programma
deve poi stampare la somma ottenuta

let sum =0
while (sum<=101){
let n = Number(prompt("n<"))
sum += n
}
console.log(sum)

ESERCIZIO: Si scriva un programma che legge un intero n e valuta se è primo, ovvero che non esista un numero
d tra 2 e n-1 tale che n sia divisibile per d. Si stampi 1 se il numero è primo, 0 altrimenti. Si stampi inoltre il
tempo di esecuzione del programma

let n = Number(prompt("n<")) let n = Number(prompt("n"))

let inizio= Date.now() let primo = 1
let primo = 1 let inizio = Date.now()
for (let i=2; i<=n/2; i++){ let i = 2
resto=n%i while (i<=n/2 && primo) {
if (resto==0){ if (n%i == 0) primo = 0
primo=0 i ++
break }
 } let tempo = (Date.now() - inizio)/1000
} console.log(primo)
let tempo=(Date.now()-inizio)/1000 console.log("Ci ho messo",tempo,"secondi")
console.log(primo)
console.log(tempo)

Per misurare prendere il tempo si usa: Date.now()

ESERCIZIO: Si modifichi il programma di sopra in modo che legga 10 numeri n e calcoli per ciascuno se si tratta
di un numero primo

for (let j=0;j<10;j++) {

let n = Number(prompt("n"))
let primo = 1
let i = 2
while (i<=n/2 && primo) {
if (n%i == 0) primo = 0
i ++
}
console.log(primo)
}

ITERAZIONE: COMANDO DO WHILE

È simile al while ma cambia il momento in cui viene valutata la condizione. Nel while se la condizione è falsa il
blocco di comandi non viene mai eseguito, nel do while invece il comando viene eseguito prima di controllare
la condizione, dunque, viene sempre eseguito almeno una volta. Ripete il blocco di comandi fino a che la
condizione è vera.

ESEM let n
let sum = 0
do {
n = Number(prompt("n"))
if (n!= -1) sum+= n
} while (n!=-1)
console.log("La somma è", sum)

Sottolineiamo la differenza fra il while e il do-while

let x=0 let x=0
while(x>0) do
X++ X++
console.log("Finito!") while(x>0)
console.log("Finito!")
\\termina stampando “Finito!” \\non termina mai

BREAK E CONTINUE
A volte possono verificarsi delle condizioni per cui è necessario interrompere una o tutte le iterazioni. I
comandi con cui è possibile farlo sono:
▪ BREAK esce dal comando iterativo interrompendone l’esecuzione e proseguendo con il blocco di
comandi successivo al comando iterativo interrotto
 ▪ CONTINUE salta l’iterazione corrente e passa alla successiva continuando l’iterazione prescritta dal
comando iterativo

ESEM while (true) {

let x= Number(prompt("x")))
if (x==0) continue //passa alla prossima lettura del valore senza stampare “Hai inserito x”
if (x<0) break //esce dal blocco e stampa “The end”
console.log("Hai inserito", x) //viene stampato se supera le condizioni degli if
}
console.log("The end")
FUNZIONI
Le funzioni matematiche definiscono una relazione attraverso un’espressione che da un punto del dominio
(parametro) ottiene un punto del codominio.

ESEM for (let x=-5; x<=5;x++) //iterazione per pari/dispari su un intervallo del dominio
console.log(“f(${x})==${x%2==0 ? 1 : 0}”);

ESEM for (let x=-5; x<=5; x++){ //funzione a due parametri che calcola la differenza
for(let y=2;y<=2;y++){
console.log (“f(“ + x + “, “ + y “)=“, x-y)
}
}

Le funzioni sono uno dei tipi base di JavaScript ovvero possono essere denotate da costanti letterali, cioè è
possibile esprimere un valore di tipo funzione scrivendolo nel testo del programma. Una funzione prende in
input dati e calcola un valore nuovo che sarà il valore di tipo funzione. Un valore di tipo funzione è per sempre
un valore e in quanto tale esso può essere usato nelle espressioni come parametro o può essere il risultato di
un’espressione, può essere assegnato ad una variabile o inserito in un array; in più posso applicare una
funzione che mi restituisca una funzione o combinare più funzioni.

Abbiamo due notazioni per esprimere una costante letterale di tipo funzione:
▪ La notazione “freccia” (o lambda espressione) => non dà alla funzione un nome ma indica quali
parametri formali prende in input (può essere un singolo identificatore o una lista di parametri fra
parentesi tonde) e un’espressione o un blocco di comandi fra parentesi graffe che indicano che valore
restituire.
(x)=>(x[0]!="o") oppure (a,b)=>{}

▪ Con la parola chiave function posso invece dare un identificatore alla funzione, una lista di parametri
fra parentesi tonde e un blocco di comandi fra parentesi graffe
function nome (a,b){}
Ciò è equivalente a dichiarare una variabile con var di nome f e inizializzarla con un valore di tipo
funzione
var f= (a,b)=>{return a+n}

letterale funzione:

Parametri formali: lista_parametri:

ESEM //assegno lambda espressione a un identificatore, passo due parametri fra tonde e uso un’espressione
aritmetica
 let somma = (a,b) => a+b

//assegno lambda espressione a un identificatore, passo due parametri fra tonde e ho come
implementazione un blocco di comandi fra graffe
let somma2 = (a,b) => {
return a+b
}

//assegno function a un identificatore

let somma3 = function (a,b) {
return a+b
}

//è il metodo più comune per assegnare un identificatore ad una funzione.

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

Essendo le funzioni dei valori ci sono degli operatori che si possono applicare alle funzioni.
Il più importante è un operatore postfisso che si chiama applicazione (invocazione o chiamata) della funzione
ed è indicato da una coppia di parentesi posta a destra del valore. Questa operazione serve per far partire la
funzione ponendo fra le parentesi i parametri che volete passare alla funzione. Concettualmente sto
applicando un operatore al valore funzione proprio come applichiamo l’operatore + ai valori 2 e 3 per una
somma; infatti, come 2+3 è un’espressione che calcola un valore, applicando l’operatore postfisso ad una
funzione si ottiene un’espressione che calcola il valore di quella funzione secondo quell’invocazione.

ESEM let f = (x=> 2*x)

f(3)

f è l’identificatore della funzione, fra parentesi tonde l’espressione lambda in cui ho il parametro formale x
ovvero l’input secondo la definizione della funzione e il corpo che utilizza il parametro formale per calcolare il
valore restituito dalla funzione.

Quando chiamo la funzione fra parentesi all’interno dell’operatore di applicazione di funzione ho il parametro
attuale o argomento ovvero l’input che passo come parametro alla funzione e che viene assegnato alla
variabile che denota il parametro formale; a quel punto si esegue il corpo. Il parametro attuale viene passato
come riferimento, dunque se viene modificato all’interno della funzione, verrà modificato anche all’esterno di
essa.

Il corpo della funzione viene valutato in un ambiente in cui i nomi dei parametri formali sono associati ai valori
dei parametri attuali sia nel caso in cui il corpo è un’espressione sia nel caso in cui sia un blocco di comandi.

Altri casi strani ma corretti: (x=>2*x) (2+1)

Posso non associare un nome ad una funzione ma semplicemente mettere il valore funzione tra parentesi
denotando la funzione. In realtà anche quando scrivo f(3) vado a leggere il valore assegnato ad f ovvero
(x=>2*x) e se questo è un valore funzione gli passo il parametro formale.
Inoltre, come parametro attuale invece che un singolo valore posso mettere un’espressione che viene prima
calcolata e poi il suo valore viene assegnato al parametro formale della funzione.

ESEM somma(3,4) → 7
somma=9
somma(3,4) → errore \\ sto provando ad invocare una funzione su un valore che è di tipo intero

Accortezze quando il corpo di una funzione è un blocco di comandi {}

• Se dentro al blocco dichiaro una variabile con var, essa è visibile soltanto all’interno della funzione. Se
invece il var è al di fuori della funzione nel programma principale allora è visibile in tutto il programma
compreso all’interno della funzione.
 • Se dentro ad un blocco dichiaro una variabile con let essa è visibile soltanto nel blocco in cui è
dichiarata
• Il comando return all’interno del blocco interrompe l’esecuzione della funzione e restituisce come
valore della chiamata della funzione il valore attuale associato alla variabile che gli passate (ad
esempio return x restituisce il valore di x). Ci sono anche funzioni che non restituiscono alcun valore e
allora uso return per bloccare la funzione.

ESEM minimo di una funzione in un intervallo

let f = (x)=>(x*x) //definizione funzione che calcola il quadrato
let a= -5
let b= 5
let x_min=undefined
let y_min= Infinity //oppure posso metterlo a un valore di f(x) qualsiasi
for(let i=a; i<=b; i++) {
if (f(i)<min)
min=f(i)
}
console.log("Il minimo è f(", x_min, ")=", y_min)

ESERCIZI
ESERCIZIO: Scrivere una funzione minimo() che legga da tastiera x interi e restituisca il minimo dei valori letti

function minimo(x) {
let min=Infinity
for(let i=0; i<x; i++){
let n=Number(prompt ("n"))
if (n<min) min=n
return min
}

ESERCIZIO: si scriva una funzione che legga da tastiera 10 interi e restituisca la media aritmetica di tutti i valori
diversi da 0 e di segno uguale al numero passato come parametro.

function media(x){
let totale =0
let quanti =0
for (let i =0; i<10; i++){
let n=Number(prompt(“n”))
if(n!=0 && n*x>0){ \\oppure if(n!=0 && ((n>0 && x>0)||(n<0 && x<0)))
totale +=n
quanti++ \\vengono inseriti 10 valori ma quanti vengono sommati?
}
}
if (quanti > 0) \\evita il caso in cui non venga sommato alcun numero
return totale / quanti
return undefined \\non metto else perchè, se entra nell’if con return si blocca
}

ESERCIZIO: scrivere una funzione zeri (f,a,b) che conti gli zeri della funzione f nell’intervallo [a,b]

function zeri(f,a,b){ \\prende una funzione come input

let zeri = 0
for(let i=a; i<=b; i++)
if (f(i)==0) z++
return z
 }

ESERCIZIO: composizione di funzioni

function composizione(f,g) { function composizione(f,g) {
return f(g(x)) return (x) => f(g(x))
} }
let quadrato = (x) =>x*x let quadrato = (x) =>x*x
let doppio = (x) =>2x let doppio = (x) =>2x
let qd = composizione (doppio, quadrato) let qd = composizione (doppio, quadrato)

let dq = composizione (quadrato, doppio) let dq = composizione (quadrato, doppio)

\\ritorniamo un valore che è un numero e non \\uso un’espressione lambda per denotare
una funzione una funzione nel return

ESERCIZIO: funzione che restituisce una funzione

function sposta(p){
return function (n,m){
p.x+=n
p.y+=m
return p
}
}
ARRAY
Gli array sono strutture di dati nate come porzioni di memoria contigua a cui accedere attraverso un indice che
indica una specifica cella di memoria che può essere interpretata e che si comporta come una variabile
tradizionale. Tipicamente:
▪ tutte le celle sono variabili di uno stesso tipo detto tipo base dell’array
▪ il numero di celle è prefissato e denota la dimensione dell’array
▪ ogni cella è identificata da un valore di indice
▪ gli indici sono contigui, partono da 0 e finiscono a n-1

In JavaScript invece:
▪ le celle possono avere variabili di diverso tipo
▪ il numero di celle non è prefissato ma può essere modificato
▪ gli indici non vanno obbligatoriamente in ordine e non sono obbligatoriamente positivi.

Un array è delimitato da [] dentro alle quali si trova una lista di espressioni separate da virgole in cui però
alcune espressioni possono anche mancare occupando un posto vuoto nell’array con un indice ma non un
valore. Se l’espressione mancante si trova in fondo all’array invece viene ignorata.

ESEM let array=[ ,10, ,4, ] \\si tratta di un array di 4 elementi in cui l’elemento in posizione 0 e 2 non ci sono
L’ultimo elemento vuoto invece viene eliminato e non conta nella dimensione dell’array.

ESEM var a=[“Banana”, “Mela”, “Pera”, “Prugna”]

\\dichiarazione di un array: definisce un letterale array [] e lo assegna alla variabile a.

Attraverso l’indice è possibile accedere agli elementi dell’array e scorrere sequenzialmente tutti gli elementi
mediante un ciclo iterativo.

ESEM a[0] \\ sintassi di accesso alla variabile in posizione 0 dell’array

a[2]=”Castagna” \\assegno una stringa alla posizione 2 dell’array
console.log(a) \\restituisce [“Banana”, “Mela”, “Castagna”, “Prugna”]

Quando stampo l’array gli elementi vengono visualizzati in ordine secondo l’indice.

OPERAZIONI SUGLI ARRAY

▪ A.push(z) aggiunge z in coda all’array

▪ A.concat(b) forma un array con tutti gli elementi di a seguiti da tutti gli elementi di b in ordine

▪ A.pop() rimuove l’ultimo elemento dell’array e lo restituisce

▪ A.reverse() inverte l’ordine degli elementi

▪ A.toSorted() nuovo array con elementi in ordine crescente senza modificare quello originale

▪ A.toSpliced() stessa cosa di splice ma in un nuovo array senza modificare l’originale

▪ A.shift() rimuove il primo elemento dell’array, lo restituisce e l’array viene traslato in modo che
l’elemento prima in posizione 1 venga spostato in posizione 0

▪ A.unshift(5) aggiunge l’elemento passato in cima e trasla tutto di una posizione

▪ A.sort() ordina un array in base al valore degli elementi e possiamo passargli un criterio di
ordinamento. La funzione prende a e b, se restituisce negativa a>b, se restituisce
positivo a<b, altrimenti con 0 sono uguali

▪ A.length mostra la lunghezza di un array ovvero il suo numero di elementi. Ad un array posso
anche assegnare una lunghezza definita come a.length=1

▪ delete(a[1]) cancella un elemento lasciando l’indice vuoto, dunque la lunghezza dell’array non varia

▪ A.toString() trasforma l’array in una stringa unendo gli elementi intervallati dalla virgola

▪ A.map(f) crea un nuovo array a partire dal precedente e applicando a tutti gli elementi
dell’array la funzione f passata come parametro. La funzione f può prendere fino a tre
parametri e map li riconoscerà come elemento, indice e array in questo ordine.

▪ A.filter(f) crea un nuovo array a partire dal precedente mantenendo soltanto gli elementi che
rispettano la funzione passata come parametro.

• A.splice(x,y,z) rimuove dalla posizione x, y elementi e aggiunge z dove z possono essere più elementi.
Se y e z non vengono espressi elimina fino alla fine dell’array. Non lascia buchi
nell’array. Restituisce un array con gli elementi eliminati

• for (let k in a) scorre tutti gli indici di a

• for (let k of a) scorre tutti i valori di a

• A.every(p) restituisce true se tutti gli elementi di A soddisfano il predicato p, false altrimenti

• A.some(p) restituisce true se almeno uno degli elementi di A soddisfa il predicato p, false altrimenti

• A.find(p) restituisce un elemento e di A tale che p(e) è true, e undefined se nessun e soddisfa p

• A.findIndex(p) restituisce l’indice di un elemento e di A tale che p(e) è true, o -1 se nessun e soddisfa p

• A.includes(e) restituisce true se A contiene un elemento uguale a e, false altrimenti

• A.indexOf(e) restituisce l’indice del primo elemento uguale a quello passato

• A.forEach(f) invoca f(e) per ogni elemento e dell’array A

• A.slice(x, y) viene utilizzata per copiare pezzi di array. Se non gli passo parametri copia l’array
dall’inizio alla fine; altrimenti il primo parametro indica da dove iniziare a copiare, il
secondo l’ultimo elemento da copiare che però non viene copiato. Questa funzione
restituisce una copia dell’array originale.

• A.split(“a”) prende un modello e divide questa stringa in un elenco ordinato di sottostringhe

cercando il modello, inserisce queste sottostringhe in un array e restituisce l'array.

• A.reduce(f,z) scorre l’array da sx verso dx, viene chiamata sui singoli elementi dell’array in maniera
 ricorsiva e restituisce un solo valore finale. La funzione f prende due parametri f(x,y) cui
il primo è l’elemento dell’array mentre il secondo viene passato da reduce stessa.
Reduce prende il primo elemento a1 di A e ci applica la funzione data f, la cui prima
chiamata sarà f(a1,z) dove x è il primo elemento dell’array e y è il valore z passato dalla
funzione reduce. A questo punto viene chiamata la funzione data f sul secondo
elemento dell’array f(a2,f(a1,z), chiamata in cui x è il secondo elemento dell’array
mentre il valore y è il risultato della funzione sull’elemento dell’array precedente. La
chiamata sul terzo elemento a3 sarà f(a3,f(a2,f(a1,z))) e così via fino alla fine degli
elementi dell’array.
A=[a1,a2,a3]
f(x,y)=x+y
reduce(f,0) → z1=f(a1,0)=a1
z2=f(a2,z1)=a2+a1
f(a3,z2)=a3+a2+a1

• A.reduceRigth(f,z) è uguale alla A.reduce ma legge gli elementi dell’array da dx verso sx

• Array(m) crea un array di dimensione m
• A.fill(a,b,c) trasforma tutti i valori dall’indice b all’indice c (non compreso) con il valore a
• Array.isArray(m) true se il parametro passato è un array

In JavaScript gli indici possono essere sparsi e non per forza positivi. Tuttavia, un indice negativo non lo trovo
come si potrebbe intuire prima dell’indice zero ma in ultima posizione scritto in modo particolare

ESEM let a=[“Pippo”, “Pluto”, “Topolino”]

a[-1]= “Paperino”
a[0]=”Gambadilegno”
console.log(a) \\restituisce [“Gambadilegno”, “Pluto”, “Topolino”, “-1”=”Paperino”]

Posso anche avere degli array con indici sparsi dove alcuni elementi mancano. La lettura relativa ad indici che
non esistono restituisce undefined.

ESEM let a=[“Pippo”, “Pluto”]

a[4]=”Paperino”
console.log(a) \\restituisce [“Pippo, “Pluto, <2 empty items>, “Paperino”]

Le stringhe hanno una sintassi molto simile agli array, infatti, posso accedere ai singoli caratteri con la
notazione degli array e possiedono il modulo per la lunghezza ma non si comportano nello stesso modo infatti
non è possibile modificare un singolo carattere di una stringa.

ESEM s=”pippo” \\stringa

console.log(s[0]) \\restituisce s
console.log(s) \\restituisce “pippo”
s[0]=”c” \\modifico un elemento della stringa
console.log(s) \\restituisce comunque “pippo”

ESEM s1=[“p”, “i”, “p”]

console.log(s1) \\restituisce l’array [“p”, “i”, “p”]
s=”pip”
console.log(s) \\restituisce la stringa “pip”
console.log(s1==s) \\restituisce false perchè sono due cose diverse
s=”p,i,p”
console.log(s1==s) \\restituisce true perchè fa il cast automatico dell’array in stringa con il
modulo s1.toString() in “p,i,p”
console.log(s1===s) \\restituisce false perché il tipo è diverso

ESEM s1=[“p”, “i”, “p”]

s2=[“p”, “i”, “p”]
 console.log(s1==s2) \\restituisce false perchè non confronta il contenuto ma i loro
identificatori

ESERCIZI
ESERCIZIO: funzione che somma tutti gli elementi di un array a passato come argomento

a=[1,2,4,5}
function somma(a){
let sum=0
for(i=0; i<a.length;i++){ oppure i<=(a.length-1)
sum+=a[i]
}
return sum
}

ESEM a=[1,2,3,”w”]
sum(a) \\restituisce la stringa “6w”

L’operatore + è over loading ovvero ha due comportamenti a seconda del tipo di dato su cui viene applicato.
Applicato a due interi restituisce un intero, applicato a stringhe restituisce la concatenazione fra le stringhe,
applicato ad un intero e una stringa converte l’intero in una stringa e fa la somma fra stringhe che restituisce
una stringa.

In questo caso fa due operazioni ovvero inizialmente somma interi e sum è un intero, quando trova una stringa
converte sum a stringa e inizia a concatenare.

ESEM a=[“w”,1,2,3]
sum(a) \\restituisce “0w123” in quanto sum è inizializzato a 0 che viene sommato alla stringa w

ESERCIZIO: funzione che trova il massimo in un array a passato come argomento

function max(a){
let max=a[0] //tiene in memoria il massimo parziale partendo dalla prima
casella
for (i=1; i<a.length; i++){ //la riga sopra è il motivo per cui parto dall’indice 1
if (a[1]>max)
max=a[i] //con espressione condizionale max=a[i]>max?a[i]:max
}
return max
}

ESERCIZIO: funzione che trova il minimo di un array

function min(a){
let min=a[0] \\tiene il massimo parziale partendo dalla prima casella
for(i=1; i<a.length; i++{ \\la riga sopra è il motivo per cui parto dall’indice 1
if (a[1]<min)
min=a[i] \\con espressione condizionale min=a[i]>min?a[i]:min
}
return min
}

ESERCIZIO: funzione che trova minimo e massimo in un array a e li mette in ordine min, max in un altro array
restituito come valore di ritorno della funzione

function minmax(a){ function minmax(a){

 return [min(a), max(a)] let arr=[]
} arr.push(min(a))
\\basta il letterale per denotare questo array arr.push(max(a))
return arr
}

ESERCIZIO: funzione che prende un array a e ne scambia gli elementi in posizione i, j passati come parametri.

function swap(a,i,j){
if((i<0) || (i>a.length-1) || (j<0) || (j>a.length-1)){ //condizioni limite
let x=a[i]
a[i]=a[j]
a[j]=x
}
return a
}

ESERCIZIO: funzione che inverte tutto l’array

function inverti(a){
let i=0
let j=a.length-1
while(i<j){ //finchè i>j continuo a sommare
swap(a, i, j)
I++
J--
}
return a
}

ESERCIZIO: confronta due array e dire se sono uguali

let a=[]
let b=[2]
var som=0
if(a.length==b.length){
for (let i=0;i<(a.length); i++){
for(let j=0;j<(b.length); j++){
if (a[i]==b[j]) som=som+1
}
}
if(som==(a.length)) console.log("a=b")
}
else console.log("a è diverso da b")

ESERCIZIO: cancellare elementi di array senza lasciare buchi

//eliminare un elemento sapendo //eliminare un elemento //eliminare un elemento

l'indice cercandolo con while cercandolo con for
let a=[1,2,3,4] let a=[1,2,3,4] let a=[1,2,3,4]
let ind=1 //2 let i=0 let n=a.length
let n=a.length let n=a.length for(let i=0;i<n;i++){
for(ind;ind<(n-1); ind++){ while(i<n){ if(a[i]==4){
var tmp=a[ind] if(a[i]==2){ for(i;i<(n-1); i++){
a[ind]=a[ind+1] for(i;i<(n-1); i++){ var tmp=a[i]
a[ind+1]=tmp var tmp=a[i] a[i]=a[i+1]
} a[i]=a[i+1] a[i+1]=tmp
 let z=a.pop() a[i+1]=tmp }
console.log(z) } let z=a.pop()
console.log(a) let z=a.pop() console.log(z)
console.log(z) console.log(a)
console.log(a) return
return }
} }
else i++ console.log("L'elemento
} non è nell'array")
console.log("L'elemento
non è nell'array")

ESERCIZIO: funzione che cerca un elemento in un array e restituisce la sua posizione

function cerca(A,k){
var i=0
var R=-1
while(i<A.length && R==-1){
if (A[i]==k) R=1
else i++
}
if (i<=(A.length-1)) return i
else return -1
}

ESERCIZIO: funzione che cerca un elemento in un array ordinato e restituisce la sua posizione

function binarysearch(A, k){

var r=A.length-1
var p=0
while (p<=r) {
var q=(p+r)/2
if (A[q]==k) return q
if (A[q]<k) {p=q+1}
else {r=q}
}
return -1
}

ESERCIZIO: uso di map e filter

function triangoliRettangoliV2(triangoli) {
let rettangolo = (t) => (t.rettangolo)
let genera = (t) => {
let nt = {}
nt.cateti = [t.base, t.altezza]
nt.ipotenusa = Math.sqrt(t.base ** 2 + t.altezza ** 2)
return nt
}
return triangoli.filter(rettangolo).map(genera)
}
OGGETTI
Letterale oggetto: lista proprietà:

Def proprietà: chiave:

Gli oggetti (o dizionario) è una mappa da chiavi a valori. Si tratta di una funzione matematica il cui dominio è
l’insieme di tutte le chiavi (stringhe e numeri) e il codominio è l’insieme di tutti i valori possibili. Possiamo
anche dire che un oggetto è un insieme di coppie (chiave, valore). Gli oggetti possono essere denotati dal
valore letterale racchiuso fra parentesi graffe. Gli oggetti consentono quindi di raccogliere in un solo valore (di
tipo oggetto) molti valori di diverso tipo, assegnando a ciascuno di essi un nome (chiave).

ESEM Pippo={(“passione”, “Fondamenti”), (“età”, 35), (“capelli”, true)}

Pippo={
passione: “fondamenti”,
età: 35,
capelli: true
}

In questo esempio le chiavi sono stringhe che potremmo usare anche come identificatori ma in realtà fra i
valori ragionevoli di stringa in JavaScript abbiamo anche gli smile. All’interno della parentesi graffe troviamo
una lista di proprietà che possono essere descritte come chiave: espressione oppure con un identificatore
ovvero il nome di una variabile che crea una chiave con lo stesso nome della variabile e un valore associato
che è quello della variabile.
Una chiave invece può essere un nome di variabile, un letterale stringa, un letterale numero o può essere
valutata tramite con un’espressione fra quadre.

Esempi di letterali di tipo oggetto:

▪ { } oggetto vuoto
▪ {nome: “Pippo”, età:35}
▪ {x} espansione di variabile: se x vale 5, è come {x: 5}
▪ {“nome”: “Pippo”, “età”: 35} denotiamo esplicitamente che le chiavi sono stringhe
▪ {“!!”: 5, “☺”:true} le chiavi possono anche essere stringhe che non sono identificatori
▪ {0: 6, 1: 4, 2: 12} le chiavi possono essere numeri
▪ {[“pip”+f]: 1} le chiavi possono essere espressioni da calcolare: se f vale “po” è come (pippo: 1}

L’operazione principale sugli oggetti è l’accesso a una chiave. Inoltre, gli oggetti sono attrezzi dinamici che
possono essere modificati dinamicamente: aggiungendo o eliminando chiavi o modificando il valore di esse.
COMANDI OGGETTI
▪ Accedere a una chiave => ogg.chiave / ogg[chiave]

ESEM let pippo={ nome: ”Filippo”, età; 35, capelli: true}

pippo.nome \\variabile_oggetto.chiave
pippo[“nome”] \\restituisce Filippo

▪ Modificare un valore associato ad una chiave => ogg.chiave=””

ESEM pippo.nome= “Antonio” \\modifico l’oggetto

▪ Aggiungere una nuova chiave all’oggetto => ogg.chiave=””

ESEM pippo.barba= true \\aggiungo una nuova chiave all’oggetto

▪ Controllare se esiste una chiave => chiave in ogg

ESEM “nome” in pippo \\restituisce true

“occhi” in pippo \\restituisce false

▪ Cancellare una coppia chiave: espressione => delete ogg.chiave

ESEM delete pippo.nome \\elimina la chiave e il valore associato

▪ Scorrere le chiavi del ciclo. Ad ogni iterazione k prende una chiave dell’oggetto. Il valore della chiave è
dentro k ma non è k => var k in ogg

ESEM for (var k in pippo)

delete pippo[k] \\svuota l’oggetto

Come per gli array == non confronta il contenuto ma l’identificativo assegnato, dunque, per valutare se due
oggetti sono uguali bisogna confrontare elemento per elemento. Devo estrarre una per una ogni chiave
dell’oggetto e per quella chiave confrontare il valore con quello della chiave corrispondente dell’altro oggetto.

ESEM let pippo = { nome: "Filippo", età: 35, capelli: true }

let pippo2 = { nome: "Filippo", età: 35, capelli: false }
function cmp(ob1,ob2){
for (let c in ob1){
if (!(c in ob2)) \\so che c è una chiave di ob1 ma non so se anche di ob2
return false
if (!(ob1[c] == ob2[c])) \\confronto I valori associati alla stessa chiave. Devo mettere c fra
quadre per considerarla con un’espressione e non come stringa, non va
bene scrivere ob1.c perché c non è la chiave
return false
}
for (let c in ob2){
if (!(c in ob1)) return false
}
return true
}
ARRAY COME OGGETTI
Gli array sono un tipo particolare di oggetto caratterizzato dal fatto che le chiavi sono numeri interi.
Posso aggiungere elementi all’array a[-1]=”Iacopo” con indice non ordinato con risultato a=[Alina, Vincenzo,
Giuseppe, Davide, “-1”: Jacopo] ovvero l’elemento viene aggiunto all’array inteso come oggetto con una chiave
e un valore. Posso inoltre scorrere le chiavi con for (k in a) (mette dentro k il valore delle chiavi in ordine) sia di
un array sia di un oggetto, oppure le chiavi di un array possono essere scorse con for(i=0; i<a.length; i++).
Tuttavia, a.length==4 dunque se scorro gli elementi di un array scorro soltanto gli elementi dell’array con indici
positivi; se uso il for sequenziale da 0 a n devo essere sicura che l’array sia pieno.

L’istruzione for(e of a) invece estrae i valori corrispondenti alle chiavi di un array ma soltanto delle chiavi
positive. For(e of a) però funziona soltanto su cose iterabili e non funziona sugli oggetti; gli array sono iterabili
nelle loro chiavi numeriche positive mentre gli oggetti non lo sono.

Dunque, gli array sono oggetti ma non hanno il loro stesso comportamento, sono implementati dagli oggetti
ma sono iterabili e deve essere prestata attenzione per lo scorrimento dell’array; solo le chiavi positive sono
chiavi proprie dell’array e definiscono un comportamento iterabile

ESERCIZI
ESERCIZIO: Scrivere una funzione che calcola la distanza tra due punti su un piano cartesiano, date le loro
coordinate x e y

var punto1={x: 0, y:0}

var punto2={x: 0, y:0}
function distanza(punto1, punto2){
return(Math.sqrt(Math.pow(punto1.x-punto2.x)+Math.pow(punto1.y-punto2.y)))
}

ESERCIZIO: Scrivere una funzione che, dati due punti (di cui si conoscono le coordinate x e y), restituisce il
punto che è più lontano dall’origine (0,0)

var origine={x:0, y:0}

function far(punto1, punto2){
return distanza(punto1,origine)>distanza(punto2,origine)?punto1:punto2
}

ESERCIZIO: Scrivere un programma che legge da tastiera una lista parole fino a che l’utente non scrive
“BASTA!”. A quel punto il programma deve stampare la lista delle parole inserite.

let w=prompt("Parola? ")

let parole= {}
while (w!="BASTA!"){
parole[w]=true
w=prompt("Parola? ")
}
for (j in parole) console.log(j)

ESERCIZIO: Scrivere un programma che legge da tastiera una lista parole fino a che l’utente non scrive
“BASTA!”. A quel punto il programma deve stampare la lista delle parole inserite (senza ripetizioni)

let w=prompt("Parola? ")

let parole= {}
while (w!="BASTA!"){
for(j in parole){
if (j==w) break
}
parole[w]=true
 w=prompt("Parola?")
}
for (j in parole) console.log(j)

ESERCIZIO: Modificare l’esempio precedente in modo che il programma stampi anche la quantità di volte che
una parola è stata inserita.

let parole={}
let w=prompt("Parola?")
while (w!="BASTA!"){
let trovata=false
for(j in parole){
if (j==w) {
trovata=true
break
}
}
if(!trovata){
parole[w]=1
j++
}
else parole[w]+=1
w=prompt("Parola?")
}
console.log(parole)
RAPPRESENTAZIONE BINARIA
L’informazione all’interno dei calcolatori viene rappresentata tramite la rappresentazione binaria.

Rappresentare una cifra in base 10 significa moltiplicare ogni cifra per una potenza di 10:
7452 = 7*103 + 4*102 + 5*10 + 2*100
In numeri in base dieci 𝑛10 = ∑𝑛−1𝑖=0 𝑑𝑖 ∗ 10
𝑖

Cifre={0,1,2,3,4,5.., B-1} Base=B=10

do cifra meno significativa (LSb Least Significant bit)
dn-1 cifra più significativa (MSb Most Significant bit)

ESEM funzione che stampa le cifre di un numero, dalla meno significativa alla più significativa
function cifre(n){
s=""
i=0
while(n>0){
resto=n%10
s= resto+"*10^" + i + "+" + s
n=(n-rest)/10
i++
}
console.log(s)
}

Nella rappresentazione binaria le cifre vanno da 0 a 1.

I numeri naturali in base due 𝑛2 = ∑𝑛−1
𝑖=0 𝑏𝑖 ∗ 2
𝑖

Cifre={0,1} Base=B=2
Se hai N bit ovvero N posizioni, il massimo numero naturale che puoi rappresentare è 2𝑁 − 1 = ∑𝑛−1
𝑖=0 2 ; su N
𝑖

bit non posso rappresentare 2 N

ESEM function cifre(n){

s=""
i=0
while(n>0){
resto=n%2
s= resto + "*2^" + i + "+" + s
n=(n-resto)/2
i++
}
console.log(s)
}

ESEM funzione che stampa le cifre di un numero rappresentato in base 10 in un'altra base
SIMB=[0,1,2,3,4,5,6,7,8,9,”A”,”B”,”C”,”D”,”E”,”F]
function converti(n,b){
s="-" + b //specifichiamo in quale base rappresentiamo
while(n>0){
resto=n%b
s= SIMB[resto] + s
n=(n-resto)/b
}
console.log(s)
}

I numeri naturali in base generica B 𝑛𝐵 = ∑𝑛−1

𝑖=0 𝑎𝑖 ∗ 𝐵
𝑖

Cifre={0,1, ..., B-1} Base=B

La rappresentazione ottale (Cifre={0,1,2,3,4,5,6,7), Base=B=8) ed esadecimale
(Cifre={0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F}, Base=B=16) sono utili per rappresentare i numeri binari in forma
compatta.

15410 = 10011010 considero gruppi di 3 bit da dx a sx e ottengo 232 8 in base 8

15410 = 10011010 considero gruppi di 4 bit da dx a sx e ottengo 910 16 in base 16

Un numero di 8 cifre in base 2 diventa un numero di 2 simboli in base 16.

OVERFLOW E UNDERFLOW
I computer usano la rappresentazione binaria in quanto i circuiti elettronici la possono rappresentare e fare
operazioni a costo basso. Tuttavia, come abbiamo visto i numeri che si possono rappresentare sono finiti.
Possiamo rappresentare tutti e soli i numeri che stanno dentro il numero massimo di bit a disposizione. Le
architetture di un calcolatore sono fatte per calcolare con un numero massimo N di bit. Fissare un numero
massimo di bit impone un limite alla rappresentazione. Un calcolatore rappresenta le informazioni in maniera
discretizzata.

BIT: unità elementare di informazione. Ha solo due stati (il minimo perché si possa parlare di cose diverse).
Convenzionalmente li denotiamo con 0 e 1
BYTE: 8 bit unità elementare di memoria, 2 8 valori distinti.
PAROLA DI MEMORIA: 8,16,32,64 bit dimensione dei registri nella CPU

10011010+
11111111=
100110011

Non riesco a rappresentare il risultato dell’operazione con lo stesso numero di bit degli operandi. Quando si
superano le capacità di rappresentazione dell’architettura si va in overflow ovvero c’è un riporto oltre il bit più
significativo. Bisogna stare attenti perché due numeri potrebbero essere rappresentabili ma ciò non garantisce
che lo sia la loro somma. L’ultimo 1 a sx andrà perso e la somma sarà più piccola di uno dei due addendi. Non
è dunque possibile rappresentare tutti i numeri naturali fino all’infinito perché fissare un numero massimo di
bit pone un limite ai numeri che si possono rappresentare.

I numeri interi si possono rappresentare tramite il loro modulo e segno. Si può tenere il primo bit (MSb) per
rappresentare il segno del numero (0 per il + e 1 per il -); mentre N-1 bit vengono utilizzati per rappresentare il
modulo di numeri interi in un intervallo fra [-2N-1 -1; 2N-1 -1]. In questo modo però ho una capacità di
rappresentazione minore di un bit (quello occupato per il segno), ho due rappresentazioni diverse per zero
(0000 0000 e 1000 0000) che corrispondono a 0+ e 0-; inoltre la somma di due positivi è negativa se riporto sul
bit di segno.

Utilizziamo dunque per rappresentare i numeri interi il complemento a 2

Il complemento a 1 è l’inversione di tutti i bit del numero con cui rappresento l’equivalente negativo di a in
modo da non sprecare il bit di segno ma usiamo una rappresentazione che assume che i numeri positivi e
negativi siano legati da questa operazione di complemento.
a=10110011 𝑎̅=01001100 matematicamente 𝑎̅= (2N -1)-a.
Questo risolve il problema dello spreco di spazio ma non quello delle due rappresentazioni dello zero.

Il complemento a 2 è l’inversione di tutti i bit di a, a cui sommo 1.

𝑎̿=2N-a
Questa soluzione risolve il problema delle due rappresentazioni dello zero perché, se lo 0 + è 0000, il suo
complemento a 1 ovvero 0- è 1111 ma se ci sommo uno diventa 0000. In questo modo ho una
rappresentazione dei numeri positivi e negativi e il complemento dello 0 è lo 0 stesso.

ESEM a=510 =000001012

𝑎̿=11111010+1=11111011= -510
L’operazione di somma non ha bisogno di controllare il segno e la sottrazione a-b è la somma a+𝑏̿. Rimane il
problema dell’overflow perché quello dipende dal numero massimo di bit che abbiamo a disposizione
(dimensione della parola di memoria)

Per quanto riguarda invece la rappresentazione di numeri reali, i numeri con la virgola vengono rappresentati in
termini di mantissa (nella forma 0, x) ed esponente.

ESEM 21,56 =0,2156 *102 ( r=m*2E )

num.reale mantissa esponente

Tutti i numeri reali sono rappresentati con la notazione esponenziale rappresentando la mantissa (numeri
dopo la virgola) separatamente dall’esponente. Se la dimensione di rappresentazione dei miei interi sta su 32
bit: uno è dedicato al segno, 8 bit rappresentano l’esponente fino a 27 -1 e 23 bit per la mantissa che è un
numero intero fino a 222 -1.
Questa notazione crea problemi dovuti alla finitezza della rappresentazione e se fra due numeri interi c’è un
buco di 1 fra due numeri reali non c’è nessun buco sulla linea dei numeri ma sul computer questo buco c’è
perché non è possibile rappresentarli tutti. Quello che succede è che ci sono sia i problemi di overflow nel
sommare numeri troppo grandi e nel sommare numeri troppo piccoli ovvero troppo negativi, ma anche il
problema di underflow ovvero il problema di precisione vicino allo zero. Se bisogna rappresentare un numero
molto piccolo che magari deriva da una moltiplicazione di numeri piccoli che può succedere che il numero
significativo cascherà nell’area rossa in cui non abbiamo abbastanza esponente per rappresentare quel
numero o potremmo finire la mantissa. C’è un numero finito di numeri reali rappresentabili che sono un ordine
di infinito in più rispetto ai numeri interi rappresentabili. Più aumento la precisione di macchina più la parte
rossa non rappresentabile è piccola. I linguaggi di programmazioni danno il numero massimo rappresentabile
sia intero sia con la virgola per fare dei calcoli di sicurezza.

Anche il testo si rappresenta in maniera binaria quindi quando scrivo un particolare carattere questo avrà
associato un codice decimale nell’ASCII che ha una sua codifica binaria, ottale e sedicimale. La prima
standardizzazione fatta della codifica dei caratteri va da 0 a 127 perché era il numero massimo
rappresentabile nelle architetture quando è stata formalizzata. Successivamente è arrivato UNICODE che mi
permette di rappresentare tutti i linguaggi del mondo. Tutti i simboli grafici sono rappresentati all’interno del
calcolatore perché ciascuno ha un codice numerico associato in UNICODE che si trasforma in un insieme di
bit.

Le immagini raster chiamate bitmap sono degli insiemi di bit dove 0 significa che il pixel è spento e 1 accesso
all’interno di una matrice che riescono a rappresentare un oggetto di natura grafica in bianco e nero. La
matrice posso anche rappresentarla con un vettore che mi codifica ogni riga della matrice composta da 8 bit in
base esadecimale in un numero di 2 cifre; espandendo il vettore con il trasformatore di base chiedendogli la
conversione binaria viene fuori l’immagine.
Per immagini più complesse ho sempre una matrice in cui nelle varie caselle non ho solo 0 e 1 che codificano
acceso o spento ma definisco tutte le tonalità di grigio fra 0 e 254 (2 8) dove 0 significa spento e 254 nero.
Dunque, in ogni pixel dell’immagine ho un numero tra questo intervallo. Se invece è un’immagine a colori
prendo tre matrici ognuna con il canale rosso, verde e blu e indico da 0 a 254 quando proporzione di ogni
colore c’è, faccio poi sintesi additiva e ottengo il colore finale come somma dei pixel. Ogni pixel diventa una
tripletta di tre valori separati da virgola (x,y)=(R,V,B) rappresentabile in 3 bit.

Anche il suono che è un’onda meccanica deve essere digitalizzato. Il che significa che l’onda sonora che esiste
nel continuo potenzialmente in maniera infinita con tutti i valori infiniti possibili in ogni istante di tempo, deve
entrare nel mondo finito rappresentandola in un insieme di numeri finiti, ovvero discretizzandola. Devo
discretizzare il tempo perché non posso rappresentare un numero infinito di punti di un’onda ma devo
rappresentarne uno ogni tot tempo, intervallo che prende il nome di tempo di campionamento, e devo
discretizzare il valore rappresentandolo con un numero reale più o meno uguale. L’onda digitalizzata diventa
un array dove l’indice rappresenta il tempo in cui è stata misurata e il valore rappresenta il suono campionato.
Dunque, anche il suono campionato viene rappresentato con valori numerici su un alfabeto discreto.

OPERATORI BIT A BIT

Gli operatori bit a bit ci permettono di modificare l’informazione nella sua rappresentazione bit a bit lavorando
sui singoli bit del numero e non su valori booleani.

Operatore Nome Descrizione Esempio

Data una specifica posizione pone il bit a 1 se i bit di entrambe le 0101 & 1100 =
a&b AND
variabili sono 1. Viene fatto l’and dei singoli bit allineati. 0100

Data una specifica posizione pone il bit a 1 se almeno un bit è pari 0101 | 1100 =
a | b OR
a1 1101

Data una specifica posizione pone il bit a 1 se uno e un solo bit è 0101 ^ 1100 =
a ^ b XOR
pari a 1 1001

~a NOT Inverte tutti i bit. Fa il complemento ad 1 ~0101 = 1010

OPERATORI DI SCORRIMENTO (BIT SHIFT)
Operatori binari di scorrimento permettono di modificare il dato nella sua natura binaria.

Operatore Nome Descrizione Esempio

Sposta i bit di n a sinistra di x posizioni,

n << x Bit shift a sinistra 0101 << 1 = 1010
inserendo 0 a destra. Perdo i bit di sinistra

Bit shift a destra con Sposta i bit di n a destra di x posizioni, 0101 >> 1 = 0010
n >> x
mantenimento del segno inserendo il bit di segno a sx 1101 >> 1 = 1110

Bit shift a destra con Sposta i bit di n a destra di x posizioni, 0101 >>> 1 = 0010
n >>> x
inserimento di 0 inserendo 0 a sinistra 1101 >>> 1 = 0110

ESERCIZI
ESERCIZIO: dati due interi a e b azzerare da a i bit settati a 1 in b

function azzera (a,b){ a=01011 b=10011 a&b=00011

return(a & -b) a=01011 -b=01100 a&-b=01000
}

ESERCIZIO: funzione che trasforma da una base all’altra

function trasf(n,b1,b2){
let n1=parseInt(n, b1)
return n1.toString(b2)
}

ESERCIZIO: funzione che stampa la rappresentazione in complemento a 2 di un numero intero

function complemento2(n){
return -a+1
}

ESERCIZIO: contare i bit settati a 1 in un numero a

000101!=0
function conta(a){ & 000001
let c=0 c+ 000001 c=1
while (a!=0){ >>> 000010!=0
c+=a&1 & 000001
a=a >>> 1 c+ 000000
} >>> 000001!=
return c & 000001
} c+ 000001 c=2
>>> 000000==0

ESERCIZIO: cambiare i valori di due variabili a e b utilizzando lo XOR

c={v:1}
d={v:2}
function scambia(a,b){
 a.v=a.v^b.v
b.v=a.v^b.v
a.v=a.v^b.v
console.log(a.v)
console.log(b.v)
}

ESERCIZIO: funzione che trasforma da una base all’altra

function trasf(n,b1,b2){
let n1 = parseInt(n,b1)
return n1.toString(b2)
}
SCOPING
La dichiarazione di una variabile consiste nel definire il suo nome (identificatore). Se una variabile non viene
dichiarata il nome non è disponibile perché l’interprete non sa che semantica dare ad una cosa che non è
dichiarata.
L’inizializzazione di una variabile consiste nell’assegnarle un valore per la prima volta.
La dichiarazione non implica inizializzazione e una dichiarazione può essere fatta sia con che senza
inizializzazione. Se dichiarate una variabile ma non la inizializzate essa diventa disponibile come nome legale
all’interno del codice ma ha come valore associato undefined.

Le funzioni sono valori e tutto ciò che è un valore può essere assegnato ad una variabile; dunque, una
dichiarazione di funzione con function è un modo diverso di scrivere una dichiarazione di variabile e
inizializzarla con un valore di tipo funzione.

function nome(a,b){} è equivalente a var nome=(a,b) =>{}

VISIBILITÀ
Un nome dichiarato è visibile, ovvero è utilizzabile come stringa legale del linguaggio, in certe parti del
programma più o meno ampie a seconda di dove è stato dichiarato e di quale tipo di dichiarazione viene usata.
JS prevede tre scope o ambiti di visibilità:

console.log(“benvenuto”)
n = 1

function map(f,a) {
let r=[]
for (var i=0;i<a.length;i++) {
r.push(f(n,a[i]))
n= 1-n
}
return r
}

Function mul(a,b) { return a*b }

Const aa = [4,7,12,3,22,1,6]
Var t = map(mul, aa)
console.log(t)

▪ SCOPE GLOBALE
Le dichiarazioni fatte fuori da qualunque funzione avvengono nello scope globale. Queste dichiarazioni
sono visibili in tutto il programma, sia fuori che dentro le funzioni o blocchi. Per dichiarare una variabile
globale si può usare var, const, let, function o lasciare la dichiarazione implicita.

Le variabili dichiarate implicitamente nel programma senza usare le parole chiave, si intendono
implicitamente dichiarate nello scope globale ovunque siano dichiarate.

Notare che function map e function mul sono due dichiarazioni di funzioni definite nello scope globale,
dunque, le parole map e mul saranno disponibili in tutto il codice. Posso anche usare mul dentro map
anche se dichiarata dopo.

ESEM La variabile n=1 che non viene neanche dichiarata con var o let, ma implicitamente, fa si che la
variabile n abbia visibilità o scope globale. Hanno scope globale anche le dichiarazioni delle
due funzioni, aa e t.

▪ SCOPE DI FUNZIONE
Ogni funzione definisce il proprio scope di funzione, ovvero una visibilità ristretta al corpo della
funzione. I parametri formali si intendono dichiarati nello scope di funzione ma il nome della funzione
 invece è nello scope globale. Le dichiarazioni fatte all’interno di una funzione con var, let, const sono
visibili nello scope di quella funzione ma non fuori.

Quando dichiaro una funzione creo due scope uno di funzione e uno di blocco.

ESEM I parametri formali f e a della funzione map è equivalente a una dichiarazione all’interno della
funzione delle due variabili che sono visibili in tutto il blocco della funzione. Quando successivamente
dichiaro la funzione mul che ha parametri formali a e b, il parametro a è diverso dal parametro a in map
perché sono variabili con scope di funzione.

▪ SCOPE DI BLOCCO
Ogni blocco (comandi racchiusi tra {}) definisce il proprio scope di blocco; in particolare il corpo di una
funzione è un blocco. Un blocco può essere contenuto in un altro blocco. Le dichiarazioni all’interno di
un for si considerano fatte nel suo blocco, compresa la dichiarazione della sua guardia e non sono
dunque disponibili al di fuori del for.
Le dichiarazioni fatte all’interno di un blocco con let o const sono visibili nello scope di quel blocco ma
non fuori. Se invece dichiariamo all’interno di un blocco con var la variabile viene automaticamente
promossa allo scope di funzione.

Var ha un comportamento leggermente diverso rispetto a let perché promuove la dichiarazione locale
al blocco all’ambiente esterno della funzione.

ESEM La variabile i dichiarata con var nella guardia del for è visibile dentro il ciclo e anche quando esso
finisce. Se fosse stata dichiarata con let sarebbe stata visibile dentro il ciclo e basta.

ANNIDAMENTI E SHADOWING
Si noti che gli scope sono contenuti uno nell’altro. Lo scope globale contiene 0 o più scope di funzione e 0 o più
scope di blocco. Ogni scope di funzione contiene 0 o più scope di funzione e 1 o più scope di blocco. Ogni
scope di blocco contiene 0 o più scope di funzione e 0 o più scope di blocco. Da dentro uno scope si vedono gli
scope esterni ma da quelli esterno non possiamo guardare a quelli interni.

Quando JS incontra una dichiarazione di un identificatore definisce una nuova variabile con quel nome e
inserisce il nome del blocco corrispondente. Quando JS incontra un riferimento a un identificatore lo interpreta
come un riferimento alla dichiarazione più interna con lo stesso nome, partendo dalla posizione in cui incontra
il riferimento.

Quando sono dentro la funzione map e mi riferisco al simbolo f per prima cosa cerco f all’interno della
funzione se non lo trovo salto fuori e vedo se è definito nella scatola esterna.

La regola del “dall’interno all’esterno” fa sì che sia possibile ri-usare lo stesso nome all’interno di uno scope
senza troppi problemi in quanto la variabile esterno non sarà più visibile perché quella interna con lo stesso
nome la copre: shadowing. I nomi dichiarati dentro uno scope sono locali o privati allo scope.

SOLLEVAMENTO O HOISTING
Le dichiarazioni, ovunque si trovino all’interno di uno scope, sono implicitamente spostate all’inizio del loro
scope (hoisting). Questo è il motivo per cui possiamo utilizzare la funzione mul all’interno di map anche se mul
è dichiarata dopo rispetto a map.

Tuttavia, le inizializzazioni rimangono dove sono scritte quindi la variabile prima della riga in cui è dichiarata
sarà visibile ma non inizializzata (undefined nel caso di var).

Eccezionalmente per le funzioni dichiarate con function, anche l’inizializzazione si considera all’inizio dello
scope
CLOSURE
Function è un tipo di dato come tutti gli altri in JS. Possiamo usare una funzione in un’espressione o comando,
possiamo passare una funzione come parametro a un’altra funzione e restituire una funzione da un’altra
funzione.
Closure: lo scope attivo durante la dichiarazione della funzione rimane visibile alla funzione restituita anche se
la funzione padre finisce.

RIASSUNTO
▪ JS ha scope globale, di funzione e di blocco
▪ C’è un solo scope globale ma gli scope di funzione e di blocco possono essere annidati uno nell’altro
▪ Le dichiarazioni con let e const hanno scope di blocco, o di funzione, o globale (vale lo scope più
interno in cui sono scritte)
▪ Le dichiarazioni con var hanno scope di funzione o globale (vale lo scope più interno in cui sono scritte)
▪ Le variabili non dichiarate hanno scope globale
▪ Le dichiarazioni con function si comportano come var ma si portano dietro l’inizializzazione in caso di
hosting
INSIEMI
Un insieme è un raggruppamento di elementi di qualsiasi tipo che può essere individuato mediante una
caratteristica comune agli elementi che vi appartengono oppure per semplice elencazione degli elementi
dell’insieme.
Si tratta di una struttura dati dove mettere elementi tutti distinti tra loro, dove non conta l’ordine e la
molteplicità e dove non conta l’indice ma solo l’appartenenza o meno dell’elemento.

Gli insiemi sono molto diversi dagli array dove posso aggiungere, ripetere gli elementi e dove conta l’ordine
mentre c’è una similitudine con gli oggetti perché ragionando in termini delle chiavi sono in grado di elencarle,
vedere se è definita oppure no nell’oggetto, e siccome indicizzano i campi se aggiungo un chiave che già
esistente cambio il valore di quella chiave stessa ma non la aggiungo più volte.
Un generico insieme S di elementi può essere realizzato sfruttando le chiavi degli oggetti JS che saranno i
nostri elementi dell’insieme a cui associo un valore predefinito in quanto tanto questa informazione verrà
persa. Posso dunque usare tutti i comandi degli oggetti per vedere se un elemento (chiave) è in un oggetto, per
scorrere gli elementi, per aggiungere elementi senza inserirli due volte se già presenti.

ESEM L’insieme S:{Pippo, Pluto, Topolino} può essere rappresentato con l’oggetto S={Pippo:1, Pluto: 1,
Topolino: 1}

ESERCIZI
ESERCIZIO: funzione che verifica se val appartiene a S

function contains(S,val) {
return (val in S)
}

ESERCIZIO: funzione che inserisce val nell’insieme S

function insert(S,val) {
S[val] = 1
}

ESERCIZIO: funzione che rimuove val dall’insieme S

function remove(S,val) {
delete S[val]
}

ESERCIZIO: funzione che verifica se A è sottoinsieme di B

function subset(A,B) {
for (let a in A) {
if (!(a in B)) return false
}
return true
}

ESERCIZIO: funzione che verifica se A è uguale a B

function equal(A,B) {
return subset(A,B) && subset(B,A)
}

ESERCIZIO: funzione che restituisce A intersecato a B

 function intersection(A,B) {
let I = {}
for (a in A) {
if (a in B) insert(I,a)
}
return I
}

ESERCIZIO: funzione che restituisce A – B

function subtract(A,B) {
let S = {}
for (a in A) {
if (!(a in B)) insert(S,a)
}
return S
}

ESERCIZIO: funzione che restituisce A unito a B

function union(A,B) {
let U = {}
for (a in A) insert(U,a)
for (b in B) insert(U,b)
return U
}

ESERCIZIO: funzione che calcola la cardinalità di un insieme

function cardinality(A) {
let i = 0
for (a in A) i++
return i
}

ESERCIZIO: funzione che calcola la similarità di Jaccard tra due insiemi (jaccard(A,B) = | A ∩ B | / | A U B |)

function jaccard(A,B) {
return cardinality(intersection(A,B)) / cardinality(union(A,B))
}
ALBERI BINARI
Un albero è un grafo connesso aciclico. I nodi di grado 1 sono detti foglie, esiste un nodo senza genitori, la
radice, e poi abbiamo i nodi interni di grado maggiore di 1. Ogni nodo interno ha 1 o più figli che consideriamo
ordinati. In un albero binario i nodi interni hanno al massimo 2 figli (arietà 2). Si possono definire sottoalberi
sinistri e destri, estrazioni di parti dell’albero che hanno il nodo destro o sinistro come radice.

Ad ogni nodo associamo un qualche valore (o etichetta) scomponendo l’informazione in modo organizzato.
Quando creo la rappresentazione di un albero devo definire tutti i nodi e per ogni nodo che valore contiene
valore. Si utilizzano quindi i dizionari.
Possiamo rappresentare un nodo come un oggetto con tre chiavi predefinite che definiscono la struttura del
nodo: la chiave val contiene il valore dell’etichetta del nodo, la chiave sx che contiene il figlio sinistro del nodo
che è a sua volta un oggetto e la chiave dx che contiene il figlio destro del nodo; se i figli sono assenti anche la
chiave sarà assente o conterrà null. L’assenza di entrambi i sottoalberi sinistro e destro è la condizione per
identificare una foglia. Quando si parla di alberi si parla quindi i oggetti annidati. Dentro al campo val ci
possono mettere un qualunque tipo di valore (numero, stringa, booleano, funzioni, array e oggetti) ed i nodi di
uno steso albero possono avere anche tipi diversi.

ESEM Posso definire prima due variabili una per ognuno degli oggetti foglia che non hanno figli.
let pino={val: “Giuseppe”}
let gigi={val: “Luigi”}
Poi definisco l’oggetto radice che contiene i due oggetti foglia
let ciccio={val:”Francesco”, sx: pino, dx: gigi}

Oppure posso scrivere drettamente:

let ciccio={val: “Francesco”, sx: {val: “Giuseppe”}, dx: {val: “Luigi”}}

Gli alberi sono naturalmente una struttura dati ricorsiva, ovvero definisce un tipo di dato con il tipo stesso,
perché un albero è un nodo che contiene altri nodi al suo interno fino ad arrivare a nodi senza figli. Se la
struttura dati è ricorsiva anche il codice che si scrive per processarla deve essere ricorsivo.

ESERCIZI
let T={val:7, let T={val: 1, let T={val:5,
sx:{val: 4, sx: {val: 2}, sx:{val:10,
sx: {val: 3}, dx: {val: 3, dx:{val:15,
dx: {val:12, dx: {val: 6}}} sx:{val:34,
sx: {val: 4, dx:{val:2,
sx:{val:8}, dx:{val:33}}},
dx:{val: 3}}}}, dx:{val:45,
dx:{val: 11, sx:{val:-10,
dx: {val: 1}, dx:{val:2}
sx: {val:9, },
sx: {val: 6}}}} dx:{val:8,
dx:{val: 12,
dx:{val: 5}}}}}}}

ESERCIZIO: massimo

function maxT(tree){ function maxT1(tree){

let maxdx = -Infinity if (tree==undefined) return -Infinity
let maxsx = -Infinity return Math.max(tree.val,maxT1(tree.sx),maxT1(tree.dx))
if (tree.sx != undefined) maxsx = maxT(tree.sx) }
if (tree.dx != undefined) maxdx = maxT(tree.dx)
return Math.max(tree.val,maxsx,maxdx)
}
ESERCIZIO: minimo

function minNode(tree) {
if (tree === null){
return Infinity;
}
return Math.min(tree.val, Math.min(minNode(tree.sx), minNode(tree.dx)))
}

ESERCIZIO: somma dei valori

function sommaT(tree){
if (tree==undefined) return 0
return tree.val + sommaT(tree.sx) + sommaT(tree.dx)
}

ESERCIZIO: cerca elemento

function isInT(tree,x){
if (tree==undefined) return false
return (tree.val == x) || isInT(tree.sx,x) || isInT(tree.dx,x)
}

ESERCIZIO: conta numero nodi con radice

function size(tree){
if(tree==undefined) return 0
let c=1
return c+size(tree.sx)+size(tree.dx)
}

ESERCIZIO: stampa grafico dell’albero

function printTree(tree, ind){

if(tree){
console.log(ind+"|-", tree.val )
printTree(tree.sx, ind+" ")
printTree(tree.dx, ind+" ")
}
}

function stampaAlbero(tree){
printTree(tree, "")
}

ESERCIZIO: conta occorrenze

function conta(tree, x){

if(tree==undefined) return 0
let c=0
if(tree.val==x) c++
return c+conta(tree.sx, x)+conta(tree.dx, x)
}

ESERCIZIO: scambia rami sinistro e destro

function swap(tree){
 let tmp = tree.dx
tree.dx = tree.sx
tree.sx = tmp
}

ESERCIZIO: rimuovi rami che iniziano con val

function prune(tree,val){
if ((tree) && (tree.val == val)) {
delete tree.sx
delete tree.dx
} else{
if (tree) {
prune(tree.sx,val)
prune(tree.dx,val)
}
}
}

ESERCIZIO: applica ad ogni nodo la funzione modificando l’originale

function update(tree,fun){
if(tree){
tree.val=fun(tree.val)
update(tree.sx,fun)
update(tree.dx,fun)
}
return tree
}

ESERCIZIO: aggiungi un nodo dato il padre

function aggiungi(tree, value, pval){

if(tree){
if(tree.val==pval){
if(tree.sx){
tree=tree.sx
while(tree.dx!=undefined){
tree=tree.dx
}
tree.dx={val: value}
return tree
}
else{
tree.sx={val: value}
return tree
}
}
aggiungi(tree.sx, value, pval)
aggiungi(tree.dx, value, pval)
}
return tree
}

ESERCIZIO: stampa i valori dei nodi attraversati implementando la seguente visita: se il valore di un nodo è
pari, visita il figlio sinistro; altrimenti, visita il figlio destro
 function even_odd_visit(tree){
if(tree){
console.log(tree.val)
if(tree.val%2==0) even_odd_visit(tree.sx)
else even_odd_visit(tree.dx)
}
}

ESERCIZIO: si scriva una funzione che, dato un albero binario che rappresenta un'espressione, restituisca il
valore calcolato da tale espressione

function compute(expr) {
if (!expr.sx && !expr.dx)
return expr.val
let op = expr.val
let l_value = compute(expr.sx)
let r_value = compute(expr.dx)
switch (op) {
case "+":
return l_value + r_value
case "-":
return l_value - r_value
case "*":
return l_value * r_value
case "/":
return l_value / r_value
case "%":
return l_value % r_value
case "**":
return l_value ** r_value
default:
return NaN
}
}
ALBERI K-ARI
Possiamo considerare gli alberi k-ari con k>2 ovvero alberi in cui i nodi possono avere più di 2 figli. A questo
punto non possiamo più rappresentare i nodi come oggetti con tre chiavi (val, sx, dx) perché un nodo può avere
un numero qualsiasi di figli. Per questo motivo i nodi figli, ognuno rappresentato da un oggetto, vengono messi
in un array. Ognuno degli n figli di un nodo è la radice di un sottoalbero.

Un nodo in un albero k-ario è rappresentato da un oggetto con due chiavi: la chiave val indica il valore del nodo
e una chiave figli a cui è associato un array contenente tutti gli oggetti figli in maniera ordinata.
nodo={val: 5, figli: []}
Se il nodo in questione è una foglia e dunque non ha figli l’array è vuoto o è assente la chiave figli.
Notate che il numero di figli può crescere o diminuire arbitrariamente come la lunghezza di un array può
variare.

Possiamo sfruttare il fatto che il valore associato a un nodo può essere di qualunque tipo anche diverso da
nodo a nodo per creare strutture interessanti.

RAPPRESENTAZIONE LEFTCHILD-RIGTHSIBLING
Gli alberi k-ari si possono rappresentare a loro volta come alberi binari (evitando array di figli) facendo in modo
che il sottoalbero di sinistra di un nodo siano i suoi figli mentre il sottoalbero destro i suoi fratelli. Si
rappresenta come:

nodo= {val: 5, child:.., next: …}

ESERCIZI
let T = {
val: 5,
figli: [
{ val: 10, figli: [] },
{ val: 15, figli: [
{ val: 34, figli: [] },
{ val: 2, figli: [] },
{ val: 33, figli: [] },
] },
{ val: 45, figli: [
{ val: -10, figli: [] },
{ val: 2, figli: [] },
] },
{ val: 8, figli: [] },
{ val: 12, figli: [] },
{ val: 5, figli: [] }
]
}

ESERCIZIO: massimo

function max(tree){
if (tree == {})
return undefined
 if(!(tree.figli) || tree.figli==[]){
return tree.val
}
let max=tree.val
for(let i in tree.figli){
let mf=max(i)
if(mf>max) max=mf
}
return max
}

ESERCIZIO: cerca valore

function cerca(tree, x){

if(!(tree.figli)||tree.figli.length==0)
return tree.val==x
if (tree.val==x)
return true
for(let k of tree.figli){
if(cerca(k,x)) return true
}
return false
}

ESERCIZIO: conta occorrenze

function conta(t, x){

let c=0
if(t==undefined) return 0
if(t.val==x) c++
if(t.figli){
for(let k of t.figli){
c+=conta(k,x)
}
}
return c
}

ESERCIZIO: conta numero nodi con radice

function size(t){
if(t==undefined) return 0
let c=1
if(t.figli){
for(let k of t.figli){
c+=size(k)
}
}
return c
}

ESERCIZIO: applica ad ogni nodo la funzione modificando l’originale

function update(tree,fun){
tree.val=fun(tree.val)
for(let k of tree.figli){
update(k,fun)
 }
}

ESERCIZIO: stampa in modo grafico

function printTree(tree, ind){

console.log(ind+"|-", tree.val)
for(let k of tree.figli)
printTree(k,ind+" ")
}

function stampaAlbero(tree){
printTree(tree,"")
}

ESERCIZIO: somma valori

function somma(tree){
let somma=tree.val
if(!tree.figli || tree.figli.length==0){
return tree.val
}
for(let k of tree.figli){
somma+=somma(k)
}
return somma
}

ESERCIZIO: aggiungi un nodo dato il padre

function aggiungi(tree, value, pval){

if(tree.val==pval){
tree.figli=[]
tree.figli.push({val: value, figli: []})
return true
}
for(let k of tree.figli){
if(aggiungi(k, value, pval))
return true
}
return false
}

ESERCIZIO: insieme valori foglie

function insert(set,x){
set[x]=true
}

function union(set1,set2){
let ins={}
for(let i in set1){
insert(ins, i)
}
for(let i in set2){
insert(ins, i)
}
 return ins
}

function ins_foglie(tree){
let foglie={}
if(!tree.figli || tree.figli.length==0){
insert(foglie, tree.val)
return foglie
}
for(let k of tree.figli){
foglie=union(foglie, ins_foglie(k))
}
return foglie
}

ESERCIZIO: insieme valori interni

function ins_nodiint(tree){
let nodi_int={}
for(let k of tree.figli){
if(k.figli && k.figli.length!=0){
insert(nodi_int, k.val)}
nodi_int=union(nodi_int, kins_nodiint(k))
}
return nodi_int
}
ALGORITMI DI ORDINAMENTO
RICERCA IN ARRAY CON RICERCA SEQUENZIALE E RICERCA BINARIA
1) Generiamo un array a di interi casuali di dimensione size (non gli viene passata la dimensione)

function gen(size) { // se non specificata, size = 100

if(size==undefined)
size = 100
let array = []
for(let i=0;i<size;i++) {
array.push(Math.floor(Math.random() * 10000))
}
return array
}

Crea un array e poi lo scorre mettendoci numeri interi casuali. Per ottenere numeri casuali
Math.random mi genera un numero tra 0 e 1 lo moltiplico per 100000 per avere un numero tra 0 e
100000 e poi lo arrotondo al numero superiore per eliminare le virgole.

2) Selezioniamo un elemento da cercare che può essere presente o meno

3) Ordiniamo l’array a con selectionSort

function selectionSort(a) {
for (let i=0; i<a.length; i++) {
let min = a[i]
let minIndex = i
for (let j=i+1; j<a.length;j++) {
if (a[j] < min) {
min = a[j]
minIndex = j
}
}
let tmp = a[i]
a[i] = a[minIndex]
a[minIndex] = tmp
}
}

ELEMENTI TEMPO SORTING

10 elementi 1 ms
1000 elementi 10 ms
100000 elementi 6862 ms
250000 elementi 35417 ms

RICERCA SEQUENZIALE
function search(x,a) {
for (let i=0; i<a.length; i++)
if (a[i] == x)
return i
return -1
}

RICERCA BINARIA
function binarySearch(x,a,left,right) { function binarySearch(a,x) {
if (left == undefined) left = 0 let left = 0
 if (right == undefined) right = a.length-1 let right = a.length-1
if (right < left) return -1 while(left <= right) {
let center = Math.round((left + right)/2) let center = Math.round((left + right)/2)
if (a[center] == x) if(a[center] == x)
return center return center
else if (a[center] > x) if(a[center] < x)
return binarySearch(x,a,left,center-1) left = center + 1
else else
return binarySearch(x,a,center+1,right) right = center - 1
} }
return -1
}

ELEMENTI TEMPO SEQUENZIALE al caso TEMPO BINARIA al caso pess

pess
10 elementi 0 ms 0 ms
1000 elementi 0 ms 0 ms
100000 elementi 3 ms 0 ms
250000 elementi 4 ms 0 ms

Mi conviene sempre ordinare l’array e applicare la ricerca binaria? Non sempre usare l’algoritmo più
efficiente è la scelta migliore. Se costruiamo noi l’array potremmo fare in modo che i valori vengono
inseriti già in modo ordinato in modo tale da non doverlo ordinare successivamente

CONFRONTO FRA ALGORITMI DI ORDINAMENTO

Implementazione di algoritmi noti
• insertionSort
→ caso medio/pessimo: O(n^2)
→fa moltissimi accessi in memoria richiedendo informazioni alla CPU
• selectionSort
→ caso medio/pessimo: O(n^2)
• mergeSort (in tre versioni)
→ caso medio/pessimo: O(n*logn)
→ occupa di più in memoria
• quickSort (in due versioni)
→ più efficiente in memoria ma fa un sacco di accessi in memoria
→ caso medio: O(n*logn)
→ caso pessimo: O(n^2)
• nativeSort
→ O(?)
→ funzione sort nativa di JS a.sort() li ordina in base al minore o lessicograficamente
→ fa l’ordinamento in loco modificando l’array originale
→ posso passargli una funzione e lui lo ordinerà in base a quella. La funzione restituisce un
numero minore di 0 se deve essere messo prima, maggiore di 0 se deve essere messo dopo,
uguale a 0 se sono uguali
→ è l’algoritmo di ordinamento più veloce con tempi e accessi molto simili a quelli del
mergesort in JS perché questo è stato implementato su quello

ESEM function nativeSort(a) {

a.sort( (a,b)=>a-b );
}

tfun(f) → visualizza il grafico della funzione f sul grafico del tempo

// utile per plottare la complessità ideale/asintotica di un algoritmo
time(f,limit) → prende un limite (se non specificato, 10000) e testa l’algoritmo f per dimensioni successive da
10 a limite (mostrando anche il numero di letture/scritture)
// utile per visualizzare la complessità reale di un algoritmo

Inoltre la complessià degli algoritmi O(f(n)) indica l’ordine di grandezza della complesità ma nella realtà f(n)
avrà una costante moltiplicativa che inclina più o meno della curva particolare rappresentata da O(f(n)). Tale
costante si può determinare con (num_elementi_array^2)/tempo_esecuzione. Usiamo questi accorgimenti per
confrontare gli algoritmi implementati con la loro complessità ideale.

INSERTIONSORT
function insertionSort(a) {
for (j = 1; j < a.length; j++) {
key = a[j];
i = j - 1;
while (i>-1 && a[i] > key) {
a[i+1] = a[i];
i = i - 1;
}
a[i+1] = key;
}
}

MERGESORT
Versione umana Versione di JS Versione Cormen
function merge(a1, function mergeJS(a1, a2){ function mergeCormen(a, p, q, r)
a2){ let sorted = []; {
let result = []; while (a1.length && a2.length) { n1 = q-p+1;
let i = 0; if (a1[0] < a2[0]) sorted.push(a1.shift()); n2 = r-q;
let j = 0; else sorted.push(a2.shift()); let L = [];
while(i < a1.length && }; let R = [];
j < a2.length){ return for (i = 0; i < n1; i ++) {
if(a1[i] > a2[j]) { sorted.concat(a1.slice().concat(a2.slice())); L[i] = a[p+i];
result.push(a2[j]); }; }
j++; for (j = 0; j < n2; j++) {
} else { function mergeSortJS(a) { R[j] = a[q+j+1];
result.push(a1[i]); if (a.length <= 1) return a; }
i++; let q = Math.floor(a.length / 2); L[n1] = Infinity;
} let L = mergeSortJS(a.slice(0, q)); R[n2] = Infinity;
} let R = mergeSortJS(a.slice(q)); i = 0;
while(i < a1.length){ return mergeJS(L, R); j = 0;
result.push(a1[i]); }; for (k = p; k <= r; k++) {
i++; if (L[i] <= R[j]) {
} a[k] = L[i];
while(j < a2.length){ i++;
result.push(a2[j]); } else {
j++; a[k] = R[j];
} j++
return result; }
} }
return a;
function mergeSort(a){ }
if(a.length <= 1) return
a; function
let q = mergeSortCormen0(a,p,r) {
Math.ceil(a.length / 2); if (p < r) {
let q = Math.floor((p + r) / 2);
mergeSortCormen0(a,p,q);
 let L = mergeSortCormen0(a,q+1,r);
mergeSort(a.splice(0, mergeCormen(a,p,q,r);
q)); }
let R = }
mergeSort(a.splice(-
q)); function mergeSortCormen(a) {
return merge(L, R);
} mergeSortCormen0(a,0,a.length-
1)
}

Le tre versioni di Mergesort pur avendo la stessa complessità possono farci registrare tempi diversi. La più
veloce è quella scritta in versione umana. La versione del Cormen fa molti accessi in scrittura e in lettura in
memoria e questo è il motivo per cui all’aumentare della dimensione aumenta il tempo.
La versione in JS fa un po’ di accessi in lettura e praticamente 0 accessi di scrittura mentre la versione umana
fa pochissimi accessi sia in lettura che in scrittura.

QUICKSORT
function quickSortCormen0(a,p,r) {
if (p < r) {
q = partitionCormen(a,p,r);
quickSortCormen0(a,p,q-1);
quickSortCormen0(a,q+1,r);
}
}

function partitionCormen(a,p,r) {
x = a[r];
i = p - 1;
for (j = p; j < r; j++) {
if (a[j] <= x) {
i = i + 1;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
temp = a[i+1];
a[i+1] = a[r];
a[r] = temp;
return i+1;
}

function quickSortCormen(a) {
quickSortCormen0(a,0,a.length-1);
}
STRUTTURE DATI CON ARRAY
Gli array in JS sono molo flessibili. Infatti mentre in C gli array sono un blocco di celle di memoria in JS gli array
sono dei dizionari con chiavi numeriche.
• Possono essere disomogenei
[ 1, 2, “pippo”, 3.1415, {x: 10, y:12}, 3 ]
• Possono essere sparsi ovvero presentare spazi vuoti
[ 1, 2, <empty>×4, 7 ]
• Possono avere chiavi non numeriche in quanto sotto l’implementazione degli array c’è un oggetto
var a=[1, 2]; a.pippo=3
a → [1, 2, pippo: 3] a.length → 2
• c’è una gestione implicita della lunghezza perché operando sul campo lunghezza posso modificare
l’array.
var a=[1, 2, 3]; a.length → 3
a.length=2; a → [1, 2]
a.length=4; a → [1, 2, <empty>×2 ]

TUPLE
Gli array possono essere utilizzati per implementare le tuple fissando la loro lunghezza. Una tupla è un insieme
ordinato di k elementi. La posizione all’interno delle tuple ha un significato.
La tupla <4, 1> può essere rappresentato dall’array t=[4,1]
Si tratta di una convenzione in cui il programmatore promette di usare sempre array di lunghezza 2 e sempre
con gli elementi corretti. Se ho una tupla t=[4,1] posso:

• accedere agli elementi

t[0] → 4 t[1] → 1

• assegnare l’intera tupla a un identificatore

q = t; q → [4, 1]

• assegnare separatamente gli elementi attraverso l’assegnamento destrutturante che prende una
struttura dati e assegna tutti o solo alcuni elementi a delle variabili.
[a, b] = t a→4 b→1

• chiamare una funzione passando una tupla come parametro formale semplicemente passando un
array

• restituire più risultati da una funzione restituendo una tupla (array) e poi destrutturandola in due
variabili.

LISTE
Gli array possono anche essere usati come liste ovvero come sequenze di elementi di lunghezza variabile. In
questo stile raramente si accede agli elementi tramite la loro posizione (per indice) ma si lavora in maniera
strutturale ovvero ricorsivamente. Le liste sono delle strutture ricorsive in quanto ogni lista è formata da un
elemento + una lista a sua volta formata da un elemento + una lista…
• Una lista vuota è una lista [ ]
• Un elemento seguito da una lista è una lista: [testa resto]
• Una lista seguita da un elemento è una lista: [resto coda]

Molte funzioni predefinite sugli array li trattano come liste e consentono di realizzare facilmente strutture dati
come code e pile. Queste funzioni permettono di eliminare e inserire elementi in posizioni precise:
▪ a.push(x)
▪ a.pop()
▪ a.shift()
▪ a.unshift(x)
Per realizzare una pila opero convenzionalmente con a.push() per inserire in coda e con a.pop() per estrarre
dalla coda (last in-first out). In realtà potrei anche utilizzare a.unshifth() per inserire dalla testa e shift per
rimuovere dalla testa.

Per realizzare una coda opero convenzionalmente con a.push() per aggiungere in coda e con a.shift() per
estrarre dalla testa. Il primo elemento ad essere entrato è il primo ad uscire (first in-first out). In realtà potrei
anche utilizzare a.unshift() per inserire in testa e a.pop() per estrarre dalla coda.

Se volessi rappresentare un’immagine quindi dire attraverso una matrice quali pixel colorare potrei fare un
array di array.

ESEM let B= {{1,2,3},

[4,5,6],
[7,8,9],
[10,11,12]]

Questa è una matrice 4x3 dove gli elementi del primo array rappresentano le righe mentre gli elementi dei vari
array annidati, le colonne

A questo punto per ottenere l’immagine posso fare una funzione che inserisce i valori nella matrice

ESEM function init(v,r,c){

let M=[ ]
for(let i=0; i<r; i++){
let a=[ ]
for(let j=0; j<c;j++){
a.push(v)
} //a contiene c copie di v
M.push(a)
}
return M
}

Se guardo gli array come liste ho bisogno di vederli ricorsivamente come strutture dati ricorsive composte da
una testa e un’altra lista (che al caso base è vuota). Per fare ciò possiamo utilizzare sulle liste l’assegnamento
destrutturante con spread.

Se l’array contiene tre elementi uso l’assegnamento destrutturante ed assegno il primo elemento alla prima
variabile, poi il secondo e così via fino a quando ho variabili o elementi nell’array. Se un elemento dell’array
non viene assegnato semplicemente rimane nell’array originale, al contrario se a una variabile non viene
assegnato un elemento assume il valore undefined o il valore assegnato di default.
La funzione spread invece mi permette di assegnare attraverso l’assegnamento destrutturante il primo
elemento dell’array (testa) ad una variabile e tutti il resto dell’array ad un’altra variabile come un array.
[testa, …resto] = [1, 2, 3, 4, 5] testa → 1 resto → [2, 3, 4, 5]
[testa, …resto] = [1] testa → 1 resto → [ ]
[testa, …resto] = [ ] testa → undefined resto → [ ]

Posso iterare questa procedura fino a quando non arrivo al caso base che può essere visto in due modi:
quando alla testa viene assegnato il valore undefined oppure quando resto è un array vuoto.

A questo punto possiamo scrivere degli algoritmi ricorsivi sugli array vedendoli come liste.

ESEM function len(a) {

let [t, ...r] = a
return t?1+len(r):0
}

Con l’assegnamento destrutturante assegno a t il primo elemento dell’array e assegno a r il resto dell’array. La
funzione deve restituire 1 più len(r) fino a quando t==undefined o r==[ ] che è il caso base in cui non richiamo la
funzione.

ESEM function sum(a) {

let [t, ...r] = a
return t?t+sum(r):0
}

function max(a) {
let [t, ...r] = a
if (t)
return Math.max(t,max(r))
else
return -Infinity
}

Sulle liste possiamo usare alcuni metodi predefiniti degli array.

ALBERI
Combinando le convenzioni per tuple e liste possiamo rappresentare alberi binari o k-ari con gli array.

Precedentemente abbiamo rappresentato gli alberi come:

• Binari: T={val: 5, sx:{}, dx :{}}
• K-ari : T={val: 5, figli:[]}

In un’implementazione degli alberi con gli array ho:

• Binari: T=[valore, sx, dx] //se non è presente un sottoalbero avrò un array sparso
• K-ari: T=[valore, figli] //il tipo del valore figli è un array
COPIA SHADOW E DEEP
Prendiamo l’array di dati di tipo primitivo A=[1,2,3,4] e l’array di array B={[1,2,3], [4,5,6], [7,8,9], [10,11,12]}

Se applico il modulo A.slice dall’inizio alla fine mi posso copiare l’array A in A1=[1,2,3,4]. A questo punto se io
modifico gli elementi di A1, queste modifiche non cambieranno l’array originale A. questo perché essendo A un
array di valori di tipo primitivo essi vengono copiati con una deep copia ovvero una copia fisica dei valori che
hanno un codice fiscale diverso dai valori all’interno dell’array originale.

Se applico il modulo B.slice dall’inizio alla fine mi posso copiare l’array di array B in B1={[1,2,3], [4,5,6], [7,8,9],
[10,11,12]]. A questo punto se io cambio l’elemento in posizione 0 di B1 ottengo:

ESEM B1[0]=10
B1={10, [4,5,6], [7,8,9], [10,11,12]}
B={[1,2,3], [4,5,6], [7,8,9], [10,11,12]}

Noto dunque che la modifica è avvenuta solo sull’array copia senza modificare l’array originale questo perché i
vari elementi dell’array B sono stati copiati con una deep copia e quindi indipendenti dall’array originale.
Al contrario se io cambio l’elemento in posizione 0 dell’elemento in posizione 0 di B1:

ESEM B1[0][0]=10
B1={[10,2,3], [4,5,6], [7,8,9], [10,11,12]}
B={[10,2,3], [4,5,6], [7,8,9], [10,11,12]}

Noto che la modifica non è avvenuta solo sull’array copia B1 ma che è stato modificato anche l’array originale.
Questo accade perché gli elementi all’interno degli elementi copia di B sono shadow copie ovvero non sono
copie fisiche ma per ottimizzare metto il riferimento ai valori originali dunque l’elemento B1[0][0] si riferisce
esattamente all’elemento B[0][0], hanno lo stesso codice fiscale, si riferiscono alla stessa casella di memoria.

Per fare una copia fisica di elementi di tipo non primitivo è necessario farlo a mano elemento per elemento.
ASSEGNAMENTI DESTRUTTURANTI
La destrutturazione è un’operazione che permette di prendere un tipo strutturato (array strutturato in posizioni
denotate da indici, oggetto strutturato in campi denotati da chiavi) e di spacchettare le sue componenti in
delle variabili indipendenti. JS permette di usare la notazione di un letterale array o oggetto in cui al posto dei
valori si indicano dei nomi di variabili a sinistra dell’operatore per questo tipo di assegnamento.

NEGLI ARRAY

1. Negli array l’assegnamento destrutturante mette dentro le varie variabili i singoli elementi dell’array

ESEM A=[4,7,1]
[a, b] = A a→4 b→7
[a,b,c,d]=A a→4 b→7 c→1 d → undefined

2. Allo stesso modo per cui se faccio una chiamata alla funzione in cui mi scordo i parametri al parametro
non definito viene assegnato undefined oppure un valore di default (f(x, y=3)) posso anche in caso di
assegnamento destrutturante passare un valore di default.
Posso farlo anche qui ovvero se non ci sono gli do un valore di default:

ESEM [a,b,c=3,d=8]=A a→4 b→7 c→1 d→8

3. E anche possibile saltare degli elementi all’interno dell’array per assegnarne solo alcuni:

ESEM [ , ,c]=A c→1

4. Posso fare un assegnamento destrutturante con spreed che mi permette di spacchettare il primo
elemento dell’array in una variabile e il resto dell’array in un’altra:

ESEM [ a, ...r ] = A a→4 r → [ 7, 1 ]

5. Posso usare l’assegnamento destrutturante per scambiare i valori x e y senza variabili intermedie
mettendoli prima all’interno di un array in ordine e poi assegnandoli alle variabili in ordine inverso.

ESEM [ y, x ] = [ x, y ]

6. Posso utilizzarlo per ottenere due valori da una funzione:

ESEM [ x, y ] = f(“pippo”,3)

Negli array le cose vengono impacchettate per posizione (indice) e anche l’assegnamento destrutturante
avviene per posizione. L’assegnamento destrutturante può essere utilizzato anche sugli oggetti, tuttavia per gli
oggetti dobbiamo lavorare sulle chiavi che dobbiamo quindi conoscere.

NEGLI OGGETTI

ESEM O={n:pippo, a:35, c:true}

1. {a,c}=O a → 35 c → true
Cerca in O le chiavi a e c e poi assegna ad una variabile a il valore della chiave a e ad una variabile c il
valore della chiave c

2. {a,d}=O a → 35 d → undefined
Cerca in O le chiavi a e d, per a procede come prima mentre se non trova la chiave d assegna alla
variabile d il valore undefined.
 3. {a, d=2 } = O a → 35 d→2
Oppure è possibile mettere un valore di default nel caso non venisse trovata la chiave

4. {a: età, n: nome} = O età → 35 nome → “Pippo”

Non è obbligatorio restituire i valori delle chiavi in variabili che hanno lo stesso nome della chiave
dell’oggetto. In questo caso si cercano le chiavi a e n e i loro valori vengono assegnati rispettivamente a
delle variabili chiamate età e nome.

5. {a, ...r} = O a → 35 r → { n: “Pippo”, c: true }

Posso nuovamente usare lo spread per dividere l’oggetto in una variabile con un valore e in un oggetto
con tutte le chiavi tranne quella estratta. Posso dunque anche per gli oggetti operare ricorsivamente ed
il aso base è l’oggetto vuoto.

6. {x, y} = f(“pluto”, 3)
Posso destrutturare un oggetto che è il valore di ritorno di una funzione assegnando i vari valori restituiti
in variabili diverse.

In alcuni casi, il simbolo { potrebbe essere interpretato come l’inizio di un blocco. Per evitare confusione, si
può scrivere l’assegnamento fra parentesi tonde.

✔ let { a, c } = O
✘ { a, c } = O
✔ ( { a, c } = O )

Inoltre, devo dichiarare l’oggetto che contiene le variabili. Se a e c esistono di già all’interno del programma
allora racchiudo solo fra tonde.

La destrutturazione sugli oggetti consente di avere funzioni di libreria con molti parametri non tutti obbligatori. I
parametri obbligatori verranno chiamati per posizione nella chiamata della funzione, mentre quelli facoltativi
si troveranno fra i parametri formali in un oggetto e verranno chiamati nella chiamata della funzione non per
posizione ma con il loro nome e un valore altrimenti assumeranno il valore di default.

function disegna( x, y, { raggio=0, colore=“nero”, bordo=1, etichetta=”” } ) {

/* codice di disegno; usa x,y, raggio, colore, bordo, etichetta */
}

Il chiamante può decidere quali caratteristiche specificare:

disegna(5,8, {colore=”blu”})
disegna(3, 2)
disegna(5,8,{colore=”rosso”, bordo=2})
disegna(0,1,stile)

VALORI DI DEFAULT
Come abbiamo visto i valori di default si usano:
• Nella dichiarazione di funzione per dare un valore di default a parametri formali
• Negli assegnamenti destrutturanti per dare un valore agli elementi assenti (per numero negli array e per
nome negli oggetti)
In generale quando normalmente a una variabile sarebbe assegnato undefined se nella dichiarazione c’è un
valore di default si assegna quel valore
OPERATORE SPREAD
L’operatore di spread è denotato da tre puntini consecutivi. Ha il significato generale di trasformare una
sequenza di elementi singoli in un singolo dato strutturato e viceversa
A è un array:
• f(...A) chiama la funzione f passandogli gli elementi di a come parametri formali singoli. L’array
viene spacchettato nelle sue componenti che diventano elementi distinti passati a f
come parametri singoli.

• p={…q, c:3} definiamo un nuovo letterale oggetto p dove vengono copiate (copia shadow quindi per
riferimento se non primitivi) tutte le chiavi e i valori associati di q. Se l’oggetto q non
possiede una chiave c questa viene aggiunta con valore 3 altrimenti la chiave c di q viene
sovrascritta e assume valore 3.

• p ={ c: 3, ...q} definiamo un nuovo letterale oggetto p dove inseriamo la chiave c con valore 3 e poi
copiamo tutte le chiavi con corrispettivi valori di q. Se q contiene una chiave c questa
sovrascriverà il valore 3.

• B={1,2,…A,6] array contenente gli elementi 1,2, tutti gli elementi di A e poi 6

• C=[…a,..b] concatenazione dei due array (copia shadow). Se A e B contengono valori di tipo
primitivo
abbiamo delle copie fisiche altrimenti se contengono array o oggetti abbiamo i
riferimenti agli oggetti originali.

• R=[…o1,..02] unione dei due oggetti. Copiamo prima tutte le chiavi di o1 e poi tutte le chiavi di 02 il
che
significa che se ci sono chiavi in comune alla fine queste avranno i valori che avevano in
o2.
ESPERIMENTI SUI CONCETTI DI ANALISI
DERIVAZIONE NUMERICA
Consiste nel calcolo del valore della derivata in un punto. Il più delle volte non sono interessato a scrivere la
funzione derivata ma sono interessato a calcolare la derivata in un punto. Data una funzione f ed un punto (x,
f(x)) il valore della derivata f’ in x è:
f’(x)=lim (f(x)-f(x0))/(x-x0) per x che tende a x0

Che si può anche scrivere usando E invece di x0 come:

f’(x)=lim (f(x+E)-f(x))/E per E che tende a 0
la derivata f’(x) indica la velocità con cui f cresce/decresce in x
La derivazione numerica approssima una funzione ben definita con il limite di un rapporto incrementale e
dunque è approssimata rispetto alla derivazione simbolica.

Per calcolare la derivazione numerica in JS basta riscrivere la definizione matematica in linguaggio JS:function

function valDerivataDx(f,x,epsilon=0.0001){
return (f(x+epsilon)-f(x))/epsilon
}

Abbiamo l’assegnamento di un valore di default per il parametro formale epsilon e possiamo aumentare la
precisione della derivata andando a ridurre tale valore. Questa funzione ci restituisce il valore numerico della
derivata destra della funzione in un punto.

Data una funzione f ed un punto (x,f(x)) la derivata f’ in x esiste se il valore della derivata dx (f’(x)_dx=lim (f(x+E)-
f(x))/E per E che tende a 0) e la derivata sinistra (f’(x)_sx=lim (f(x)-f(x-E))/E per E che tende a 0) coincidono.

function valDerivataSx(f,x,epsilon=0.0001){
return (f(x)-f(x-epsilon))/epsilon
}

Tuttavia, se io uguaglio queste due derivate esse possono risultare diverse perché abbiamo
un’approssimazione nei calcoli tale per cui entrambe le derivate hanno un errore che raramente le rende
uguali. Dunque, nell’uguaglianza fra queste due derivate dobbiamo tener conto dell’errore:

function valDerivata(f,x,epsilon=0.0001){
var dx=valDerivataDx(f,x,epsilon)
var sx=valDerivataSx(f,x,epsilon)
if(Math.abs(dx-sx)<0,01) return sx
}

Adesso ho una funzione che mi restituisce la derivata in un punto ovvero f’(x) con x fissato ad un valore e voglio
una funzione che dato f mi restituisce f’ ovvero la funzione della derivata numerica in ogni punto.

function funDerivata(f,epsilon=0.0001){
return x=>valDerivata(f,x,epsilon)
}

La funzione restituita mantiene l’accesso alle variabili f e epsilon che sono passate a funDerivata anche se non
sono tra i suoi parametri formali. F e epsilon sono chiuse nello scope della funzione restituita da funDerivata
(chiusura lessicale).

ESEM var fun=(x=>x**2)

var dfun=funDerivata(fun)
console.log(dfun((0)))
Si chiama classe di derivabilità il numero delle volte che una funzione può essere derivabile, una funzione della
classe Cn può essere derivata n volte. Come posso dalla derivata prima ottenere le altre derivate? Creo una
funzione che mi calcola la derivata ennesima di una funzione con la ricorsione.

function derN(f,N=1,eps=0.00001){
if (N==0) return f
return derN(funDerivata(f,epsilon),N--,epsilon)
}

DERIVAZIONE SIMBOLICA
Spesso però quando si fa il calcolo della derivata non si calcola il limite ma si lavora sui simboli.

DERIVAZIONE SIMBOLICA DI UN POLINOMIO

Come si può rappresentare un polinomio in JS? Esso è identificato dal grado e dai coefficienti dei monomi in
esso contenuto quindi: x3+4x2-5 posso rappresentarlo come (3, [1,4,0,-5]) ma il grado del polinomio
corrisponde alla lunghezza dell’array -1 quindi possiamo rappresentalo semplicemente come [1,4,0,-5].
Inoltre, per comodità ribalto l’array in modo tale ce la cella di indice 0 contenga il monomio con x di grado 0.

Valori -5 0 4 1

Indice 0 1 2 3 => x3+4x2-5

Monomio x0 x1 x2 x3

function poly(p) { \\da array a polinomio

var t=""
for (var e=p.length-1; e>0; e--)
if (p[e]!=0) t+= `(${p[e]!=1?p[e]:""}x${e==1?"":”^”+e})+`
t+=`(${p[0]})`
return t
}

Se dovessi calcolare il polinomio in certo punto x dovrei scorrere l’array e sommare tutti i prodotti fra x elevato
all’indice per il coefficiente.

function polyinx(p,x){
var ris=0
for(var i=0; i<p.length; i++){
ris+=(x**i)*p[i]
}
return ris
}

La regola di derivazione dei polinomi dice di moltiplicare il coefficiente per l’esponente e di ridurre l’esponente
di 1.

-5 0 4 1  / 0 8 3

function derPoly(p){
function modifica(e,i){
let ne=e*(i)
return ne
}
let ris=p.map(modifica)
ris.shift()
return ris
 }

REGOLE DI DERIVAZIONE
La derivata, dunque, è definita ricorsivamente e il caso base sono i polinomi o i numeri. Dunque, davanti alla
derivata di una funzione complessa si richiama la funzione derivata in accordo con le regole sopra fino ad
arrivare ad un polinomio o ad una costante

Ci serve dunque un modo per rappresentare le funzioni in maniera simbolica e si utilizza la codifica prefissa
ovvero una notazione composta da una tupla di tre posizioni dove il primo elemento è l’operatore e gli elementi
che seguono gli operandi. Si dice essere una tupla perché si assume un ordinamento specifico al suo interno.
essa potrebbe anche essere composta soltanto da due elementi nel caso l’operatore sia unario. Ho dunque
una struttura ricorsiva, la tupla, su cui posso operare ricorsivamente.
a+b => [“+”, a, b]
(a * b) + c => [“+”, [“*”, a, b], c]
x^3 => [“^”, x, 3]

Per prima cosa si definiscono delle costanti come che cosa è un numero, che cosa è una variabile, la
negazione per distinguerla dalla sottrazione e così via…
Successivamente la funzione derivata prende una generica espressione “e” rappresentata come una tupla
(che può essere formata a sua volta da tuple) e inizia a lavorarci ricorsivamente.
Attraverso un assegnamento destrutturante estraggo i tre elementi della tupla che per definizione sono in
ordine e li assegno a tre variabili op, x e y. Nel caso in cui la tupla contenesse soltanto due elementi y
risulterebbe undefined.
A questo punto proseguo in modo differente a seconda dell’operatore che mi trovo davanti.
• Nel caso in cui l’operatore sia un numero allora quello che segue è la denotazione di una costante e la
derivata di una costante è 0. Dunque, restituisce una tupla che afferma che la derivata di una costante
è lei stessa una costante e specificatamente 0
• Nel caso in cui l’operatore sia x restituisce una tupla che afferma che la derivata è una costante e
specificatamente 1
• Nel caso in cui l’operatore fosse la negazione restituisce una tupla che afferma che la derivata è la
negazione della derivata dell’argomento facendo una chiamata ricorsiva.
• …
PASSAGGIO PER VALORE O RIFERIMENTO
JS prevede valori di tipi base come numeri, booleani e stringhe e valori di tipo complesso come gli array, gli
oggetti e le funzioni (che però sono tipi primitivi). Nella maggior parte dei contesti il valore effettivo a cui si fa
riferimento tramite un identificatore non fa differenza ma tuttavia è importante ricordare che i tipi base hanno
una semantica per valore mentre i tipi complessi hanno una semantica per riferimento.

• Quando si parla di una semantica per valore si intende che le variabili contengono direttamente il
valore e dunque l’assegnamento copia il valore mentre l’uguaglianza confronta il valore.

• Quando si parla invece di una semantica per riferimento si intende che le variabili contengono un
riferimento a un’area della memoria dove è memorizzato il valore. Consiste essenzialmente nell’usare
indirizzi di memoria come valori e nell’avere operazioni di indirizzamento implicito (o.chiave, o[chiave],
a[indice],funzione(arg)) per accedere ai valori contenuti nella memoria all’indirizzo dato.
L’assegnamento copia, dunque, il riferimento e non i contenuti dell’area di memoria e allo stesso
modo l’uguaglianza confronta il riferimento e non i contenuti. La semantica per riferimento permette la
condivisione di oggetti in memoria e le modifiche apportate tramite un riferimento sono visibili
attraverso altri riferimenti allo stesso oggetto.

In particolare, questo è vero per gli argomenti passati alle funzioni. JS usa il passaggio per valore degli
argomenti. Per il corpo della funzione il parametro formale è una variabile locale, inizializzata con una copia
del valore del parametro attuale, oppure con il valore di default se indicato nella dichiarazione e se la chiamata
non comprendeva quel parametro. Questo implica che la funzione non può modificare il valore di una variabile
usata nella sua invocazione.
Però se il valore è un riferimento, una funzione può modificare il valore di tipo complesso riferito al riferimento.

Il concetto di riferimento si applica anche alle strutture dati. Finora abbiamo lavorato con strutture dati in cui
ogni oggetto appariva in un solo posto. Per esempio, gli alberi godono di questa proprietà: ogni nodo compare
come valore solo nel campo sx o nel campo dx del padre. Invece una volta chiarito l’uso del riferimento
possiamo definire strutture dati in cui lo stesso oggetto compaia in più campi per esempio i grafi.

ESEM Usiamo la definizione classica dei grafi ovvero G= <N,E> dove N è un insieme di nodi (oggetto) e E è un
insieme di archi incluso in NxN. Rappresentiamo un grafo come un oggetto con un campo nodi e un
campo archi: G = {nodi: N, archi: E}
Rappresentiamo un nodo come un oggetto con un campo val per ospitare un’etichetta: n1 = {val: x}
Rappresentiamo un arco come un oggetto con un campo da e un campo a: a = {da: n1, a: n2}

Per esprimere il fatto che gli archi b,c e d insistono sullo stesso nodo è indispensabile fare affidamento
ai riferimenti. La via più semplice è quella di usare delle variabili per riferire i vari nodi e archi.
var n1 = {val: 1}, n2 = {val: 2}, n3 = {val: 3}, n4 = {val: 4}, n5 = {val: 5}
var a = {da: n1, a: n2}, b = {da: n1, a: n3}, c = {da: n3, a: n5}, d = {da: n3, a: n4}, e = {da: n4, a: n5},
f = {da: n5, a: n2}
G = {nodi: [n1, n2, n3, n4, n5], archi: [a, b, c, d, e, f]}

Vogliamo scoprire il nodo di grado massimo all’interno del grafo.

function nodoGradoMassimo(G){
var nodo_max, grado_max= 0
for(var n of G.nodi){
var grado_nodo=0
for (var e of G.archi){
if(e.da==n) grado_nodo++
if(e.a==n) geado_nodo++
}
if (grado_nodo>grado_max){
grado_max=grado_nodo
nodo_max=n
 }
}
return nodo_max
}
COSTRUTTORI
Quando si usano oggetti complicati è usuale (e comodo) usare una funzione per costruire l’oggetto, spesso
partendo da alcuni valori che lo descrivono. In questo modo facendo costruire gli oggetti tutte le volte che
serve da una sola funzione siamo sicuri di avere sempre i campi giusti. Queste funzioni usano il fatto che ogni
volta che viene valutato un letterale di tipo oggetto viene allocato un suo riferimento diverso da tutti quelli già
esistenti. Spesso queste funzioni prevedono argomenti di default oppure effettuano dei calcoli o dei controlli
prima di inizializzare l’oggetto.

ESEM function arco(n1, n2){

return {da: n1, a: n2}
}

function persona(n, e){

return {nome: n, età: e}
}

L’operazione di creare un nuovo oggetto e assegnare le sue proprietà e i suoi metodi all’interno di una funzione
costruttore in modo da costruire oggetti tutti con la stessa struttura è molto comune. Tanto comune che JS
prevede un modo speciale per farlo attraverso l’operatore new.

L’operatore new crea un nuovo oggetto vuoto, chiama la funzione costruttore passando come this l’oggetto
vuoto appena creato, più i parametri indicati e restituisce l’oggetto inizializzato.

Invece di scrivere: Scriveremo:

function persona(n,e){ function Persona(n,e){
return { this.nome=n
nome: n, this.età=e
età: e, }
} var pippo=new Persona ("Pippo", 35)
}
var pippo=persona (“Pippo, 35)

In questa nuovo modo di scrivere i costruttori non c’è più un letterale di tipo oggetto per creare il nuovo oggetto
perché la creazione viene fatta da new e non c’è un return perché new implicitamente restituisce l’oggetto
creato da new e inizializzato da Persona.

Per convenzione le funzioni-costruttore destinate a essere usate con new iniziano per lettera maiuscola.
METODI
Inoltre, un oggetto può avere proprietà ovvero coppie chiave-valore con valori di tipo funzione. Conosciamo
due modi per denotare un valore funzione: con => o con functon. Tuttavia, per il caso particolare di funzioni
definite come proprietà di un oggetto esiste una terza sintassi abbreviata.

ESEM var o={

inc: x=>x+1,
dec: function(x){return x-1},
zero(x) {return x-x} \\equivalente a zero: x=> {return x-x}
}

Finora abbiamo utilizzato funzioni speciali come Console.log(), Math.max e così via. Console e Math sono in
effetti variabili globali pre-dichiarate nell’ambiente di esecuzione. Si tratta di variabili di tipo oggetto e le
funzioni speciali sopracitate sono proprietà di questi oggetti con valori di tipo funzione. Naturalmente anche gli
oggetti che definiamo noi possono avere proprietà di tipo funzione.

A questi oggetti (Math e Console) possiamo volendo aggiungere anche nostre funzioni nello stesso modo in cui
normalmente impostiamo proprietà di un qualunque altro oggetto. Queste nuove funzioni possono essere poi
usate normalmente in tutto il resto del programma esattamente come quelle definite.

ESEM Math.fattoriale = n=>{…}

console.poly = p=>{…}

Le funzioni di Math sono funzioni pure ovvero non hanno effetti collaterali, si limitano a calcolare il risultato
che dipende solo dagli argomenti. È però assai più comune il caso in cui una funzione debba modificare
l’oggetto a cui si riferisce.

• Math.floor(…) difetto
• Math.round() eccesso
• Math.abs()
• Math.exp
• Math.max(…)
• Math.min(…)
• Math.random()
• Math.sqrt()

ESEM function compleanno(p){

p.età++
}

Possiamo usare le funzioni costruttori per assicurarci che tutti gli oggetti di una certa tipologia abbiamo i
metodi che ci servono. Più proprietà e metodi vogliamo aggiungere a un oggetto più è utile definire una
funzione per assicurarsi che tutti gli oggetti della stessa tipologia siano costruiti esattamente allo stesso
modo.

Potremmo ad esempio assegnare la funzione compleanno a una proprietà del costruttore-persona:

persona.compleanno =p =>{p.età++} ma poi per incrementare l’età dell’oggetto-persona pippo dovremmo
scrivere pippo.compleanno(pippo). JS prevede che, quando una funzione è invocata tramite una proprietà di
un oggetto ha a disposizione un parametro in più implicito che si chiama this e contiene un riferimento
all’oggetto su cui è stata invocata.
In questo modo possiamo scrivere nel costruttore la funzione compleanno che non prende parametri:
persona.compleanno= function ()=>{this.età++} e poi invocare il compleanno di un oggetto-persona soltanto
con pippo.compleanno().
Quando una funzione è fornita come proprietà di un oggetto e al suo interno riferisce l’oggetto si usa chiamarla
metodo dell’oggetto.

ESEM function Grafo(N=[],E=[]){

this.nodi=N
this.archi=E
size(){return this.nodi.length}
figli(n) {return this.archi.filter(({da})=>da==n).map(({a})=>a)}
fan(n) {return this.archi.filter(({da,a})=>(da==n||a==n))}
}
var G=new Grafo([n1, n2, n3, n4, n5], [a, b, c, d, e, f])

La funzione figli prende come argomento un nodo n che è un oggetto, successivamente prende
l’insieme degli archi del grafo che è un array composto da oggetti e crea con il metodo filter un nuovo
array in cui inserisce soltanto gli archi che partono dal nodo n. Il predicato del metodo filter è una
funzione a cui si passa un argomento con l’assegnamento destrutturante: si cerca nell’oggetto passato
(in questo caso un singolo oggetto arco dell’array archi alla volta) la chiave “da” e si passa il suo valore
come parametro. Inoltre su questo nuovo array viene applicato il metodo map che crea un nuovo array
in cui per ogni nodo che parte da n si inserisce il nodo di destinazione. Anche l’argomento di map è
passato attraverso l’assegnamento destrutturante: si cerca all’interno dei singoli oggetti archi la chiave
“a” e si passa il suo valore come argomento della funzione.

ESEM function Studente(nome,matricola) {

this.nome = nome
this.matricola = matricola
this.voti = []
this.verbalizza = (materia,voto,cfu) => {
this.voti.push({
materia: materia,
voto: voto,
cfu: cfu})
}
this.media = () => {
let cfu = 0
let media = 0
for (let v of this.voti) {
media += v.voto*v.cfu
cfu += v.cfu
}
return media/cfu
}
}
PROTOTIPI
Tutto questo spiega come sono realizzate molte funzioni predefinite di JS ma non tutte. Ad esempio se
guardiamo tra le proprietà degli array non vediamo il metodo push() o non troviamo il metodo split() per le
stringhe.
Infatti, il meccanismo con cui JS accede alle proprietà di un oggetto è più complesso di come l’abbiamo usato
fino ad ora.

Ogni oggetto ha un prototipo, che è un altro oggetto, tranne il prototipo dell’oggetto Object che non ha
prototipo. Quando si vuole leggere il valore di una proprietà di un oggetto si guarda se l’oggetto ha la chiave
cercata, se la chiave è presente il valore è quello della chiave nell’oggetto, se la chiave non è presente e
l’oggetto ha un prototipo si cerca la proprietà nel prototipo, se la chiave non è presente e l’oggetto non ha un
prototipo il risultato è undefined. Quando si vuole scrivere il valore di una proprietà di un oggetto, la chiave e il
valore vengono inseriti nell’oggetto eventualmente sovrascrivendo il valore precedente della stessa chiave
presente nel prototipo.

Dunque, i metodi mancanti si trovano nella catena dei prototipi dei nostri oggetti. Possiamo scoprire chi è il
prototipo di un oggetto o accedendo alla sua proprietà speciale o.__proto__ con due prefissi e due suffissi,
oppure invocando Object.getPrototypeOf(o)

LA CATENA DI PROTOTIPI

Da notare che l’enumerazione delle proprietà di un oggetto fatta con for(k in o){} restituisce solo le chiavi
proprie dell’oggetto quindi non quelle che vengono trovate nei prototipi. Lo stesso vale anche per i metodi
Object.keys(o), Object.entries(o), ecc… In questo modo le chiavi presenti nel prototipo sono leggibili se le
accedete ma non sono enumerabili e ciò è particolarmente comodo per array e dizionari.

Object.keys(o) restituisce un array i cui elementi sono le chiavi sotto forma di stringhe in ordine se numeriche
Object.values(o) restituisce un array i cui elementi sono i valori, se si usano chiavi numeriche li restituisce in
ordine
Object.entries(o) restituisce un array contenente array di due elementi chiave-valore come stringhe, se si
usano chiavi numeriche le restituisce in ordine

Se aggiungiamo un metodo a un particolare oggetto il metodo sarà disponibile solo per quell’oggetto. Se
invece aggiungiamo un metodo al prototipo di un oggetto come Persona allora il metodo sarà disponibile per
tutti gli oggetti che hanno lo stesso prototipo.

Tutte le funzioni e in particolare le funzioni costruttore hanno una proprietà che si chiama prototype
inizializzata automaticamente dal linguaggio quando si dichiara una funzione e che contiene un oggetto pronto
per fare da prototipo per gli oggetti inizializzati dalla funzione.
L’operatore new assegna automaticamente come prototipo dell’oggetto creato il prototype della sua funzione
costruttore. Ciò crea un vero legame permanente fra gli oggetti e i loro costruttori, praticamente un tipo.

ESEM function Persona(n,e){ Persona.prototype

this.nome=n; {constructor: f}
this.età=e pippo.__proto__
} {constructor: f}
var pippo=new Persona("Pippo", 35) pippo.__proto__==Persona.prototype
true

Il prototipo di pippo è il suo valore del prototype del suo costruttore.

Questa caratteristica suggerisce un modo diverso per definire costruttori in JS che lo avvicina ad altri linguaggi
basati su classi:
• Aggiungiamo le proprietà che descrivono lo stato di un oggetto all’oggetto creato
• Aggiungiamo i metodi che descrivono il suo comportamento al prototipo della funzione costruttore.
In questo modo i campi dell’oggetto sono enumerabili e i suoi metodi no.

ESEM costruttore con prototype

function Persona(n,e){ pippo.compleanno()
this.nome=n pippo
this.età=e {nome: “Pippo”, età:36}
}
Persona.prototype.compleanno=function(){this.età++}
var pippo=new Persona("Pippo", 35)

La versione più recente di JS ha aggiunto un modo diverso di dichiarare le classi. Si tratta comunque solo di
sintassi più facile: in realtà tutta la componente orientata agli oggetti di JS è basata sul concetto di prototipo.
• Gli oggetti sono creati da new tramite funzioni-costruttori
• Le funzioni-costruttori definiscono implicitamente il prototipo di ogni oggetto creato
• Tutte le parti in comune di oggetti della stessa famiglia vengono implementate dai prototipi, le parti
proprie sono implementate da ogni oggetto individualmente
CLASSI
La sintassi con la dichiarazione class consente di definire funzioni-costruttore e metodi di un oggetto di
particolare tipo in maniera molto più compatta. All’interno dei metodi, incluso il costruttore, l’oggetto viene
manipolato e riferito da this. Le classi non sono altro che funzioni.

ESEM class Persona { typeof Persona

constructor(nome,età){ “function”
this.nome=nome Persona.__proto__
this.età=età f(){{native code}}
} Persona.prototype
compleanno(){ {constructor:f, compleanno:f}
this.età++ typeof pippo
} “object”
} pippo
var pippo= new Persona("Pippo", 35) Persona{nome: “Pippo, età: 35}
pippo.__proto__
{constructor:f, compleanno:f}
pippo.constructor === Persona
true

Tecnicamente Persona non è una classe (un concetto che non esiste in JS) ma una funzione come abbiamo
visto. La creazione di nuovi oggetti avviene dunque con new.

Persona è una funzione-costruttore e in

quanto tale ha una proprietà prototype
inizializzata automaticamente dal
linguaggio quando si dichiara la
funzione e che contiene un oggetto
pronto per fare da prototipo per gli
oggetti inizializzati dalla funzione.
Quando creiamo l’oggetto pippo a
partire da Persona esso avrà una
proprietà costruttore che rimanda a
Persona e una proprietà prototipo che
rimanda al prototype del suo
costruttore

ESEM class Studente { class Esame {

constructor (cognome,nome,matric,anno) { constructor(materia,data,voto,cfu=6) {
this.cognome = cognome this.materia = materia
this.nome = nome this.data = data
this.matricola = matricola this.voto = voto
this.anno = anno this.cfu = cfu
this.voti = []} }
media() { equals(e) {
let somma = 0, cfu = 0 for (let k in this) {
for (let v of this.voti) { if (this[k] != e[k])
somma += v.voto*v.cfu return false
cfu += v.cfu} }
return somma/cfu} return true
crediti() { }
let somma = 0 toString() {
for (let v of this.voti) { return this.materia + " (" +
somma += v.cfu} this.cfu + "): " +
 return somma} this.voto
anni() { }}
let anno_corrente = new Date().getFullYear()
return anno_corrente - this.anno}
equals(s) {
return this.matricola == s.matricola }
toString() {
let s = this.matricola + ", " + this.cognome
for (let v of this.voti) {
s += "\n - " + v.toString()}
return s}}

EREDITARIETÁ
Finora abbiamo visto le classi come dichiarazioni ma essendo esse delle funzioni, ovvero dei valori in JS, esiste
anche la variante espressione.

class Persona { var Persona = class{

constructor(nome,età){ constructor (nome, età){
this.nome=nome this.nome=nome
this.età=età this.età=età
} }
compleanno(){ compleanno(){
this.età++ this.età++
} }
} }
var pippo= new Persona("Pippo", 35) var pippo= new Persona("Pippo", 35)

Abbiamo visto come per ogni oggetto sia definita la sua catena dei prototipi. Quando si accede in lettura a una
proprietà se la chiave non è definita nell’oggetto, si va a cercare nel prototipo e così via ricorsivamente.

È anche possibile impostare il prototipo di una nuova classe a un’altra classe. Grazie al meccanismo dei
prototipi, gli oggetti della nuova classe avranno anche tutti i metodi definiti dalla classe che viene estesa. In più
la sottoclasse può aggiungere ulteriori metodi. Solo le istanze della sottoclasse avranno i metodi aggiunti.

ESEM class Studente extends Persona { ugo

laurea(){ Studente{nome:”Ugo”, età:19}
return "Evviva!" ugo.compleanno()
} ugo
} Studente{nome:”Ugo”, età:20}
var ugo=new Studente("Ugo",19) ugo.laurea()
Evviva!
pippo.laurea()
error

Applicando il meccanismo di ricerca nella catena dei prototipi osserviamo che:

• Una sottoclasse può ridefinire un metodo già definito in una sua superclasse (overriding)
• Una sottoclasse eredita tutti i metodi della superclasse che non ridefinisce
• Usando l’operatore delete sul prototipo è possibile cancellare dalla sottoclasse un metodo definito
dalla superclasse senza sovrascriverlo
• Un’istanza può sovrascrivere o ampliare un metodo della propria classe
Tutto questo vale anche per il constructor()

ESEM class StMagistrale extends Studente{ pia.laurea()

laurea(){ Stra-evviva galattico!
return "Stra-evviva galattico!"
 }
}
var pia=new StMagistrale ("Pia", 23)

Capita spesso che il codice in una sottoclasse debba fare riferimento ai metodi della sua superclasse per
completarlo o aggiungere caratteristiche. La parola chiave super è un riferimento alla superclasse di un
oggetto come this è un riferimento all’oggetto su cui il metodo è invocato. La classe è in realtà una funzione
quindi super è una funzione.

ESEM class StMagistrale extends Studente{ Pia

constructor(nome, età, triennale){ StMagistrale{nome: “Pia”, età: 24,
super(nome, età) triennale: Info}
this.triennale=triennale pia.laurea()
} Evviva, evviva galattico!
laurea(){
return super.laurea() + ", evviva galattico!"
}
}
var pia=new StMagistrale ("Pia", 23, info)

I diagrammi delle classi si disegnano spesso usando il linguaggio di modellazione UML. Ogni istanza di una
classe è anche istanza di tutte le sue superclassi ricorsivamente.

typeof anna
“object”
anna instanceof Liceale
true
anna instanceof Persona
true
pippo instanceof Studente
false

Se una classe ne estende un’altra ma senza modificare o aggiungere proprietà e metodi basterà scrivere:
class Studenti extends Persona{} e le istanze Studenti avranno metodi e proprietà di Persona.

DICHIARAZIONI DI CAMPO
È possibile dichiarare le proprietà di un oggetto direttamente nella classe anziché con assegnamenti a
this.proprietà nel costruttore. Se non viene fornito un inizializzatore di default il valore iniziale sarà undefined
per cui in pratica serve comunque inizializzarle nel constructor(). Ci sono comunque casi in cui le dichiarazioni
di campo sono utili, per esempio, quando il valore di inizializzazione è calcolato chiamando un metodo. Se non
è presente un constructor i campi rimangono inizializzati come fuori da esso altrimenti se presente vengono
sovrascritti.

ESEM class Persona {

nome="anonimo"
età=-1
constructor (nome, età){
this.nome=nome
 this.età=età
}
}

MEMBRI PRIVATI
I nomi di proprietà che iniziano per # sono visibili sono all’interno della classe. Essi sono campi che possono
essere usati all’interno dei metodi ma che non sono visibili o accessibili dall’esterno. Ogni accesso a una
proprietà il cui nome inizia con # fuori dalla definizione della classe produce un errore.

ESEM class C{ c.pubblico()

#privato() {} c.#privato()
pubblico() {qui si può usare this.#privato()} errore
}
var c= new C()

MEMBRI STATICI
Una classe può includere delle proprietà statiche, introdotte dalla parola chiave static. Queste proprietà non
saranno proprietà delle singole istanze ma della classe stessa. A differenza di altri linguaggi non si può
accedere a un membro statico tramite un’istanza occorre proprio indicare il nome della classe.

ESEM class Auto{ Auto.metodo()

static metodo() {} kia.metodo()
} errore
var kia= new Auto()

ESEM class Liceale extends Studente{ Luca

static quanti=0 Liceale{nome: “Luca”, età: 15}
#iscritto=false Liceale.quanti
constructor(...arg){ 1
super(...arg) Liceale
Liceale.quanti++ [class Liceale extends Studente] {quanti: 1}
} luca.unipi()
unipi(){return this.#iscritto} false
static bellaVita() {return true} luca.#iscritto
} error
var luca=new Liceale(“Luca”, 15) luca.quanti
undefined
Liceale.bellaVita()
true
luca.bellaVita
error

GETTER E SETTER
Js include alcune caratteristiche che sono di uso generale, ma che vengono usate con particolare efficacia
nella definizione di classi.

ESEM var oggetto = {get x() {return 1}, set x() {;}}

I metodi di accesso (getter e setter) consentono di simulare la presenza di una proprietà in un oggetto, però le
letture o le scritture di quella proprietà causano l’esecuzione di un metodo anziché una lettura o scrittura nel
dizionario dell’oggetto.
Le parole chiave get e set davanti al nome della proprietà creano i metodi di accesso. Dall’esterno la proprietà
appare come una normale chiave con valore.
Ogni lettura di proprietà causa l’invocazione del getter.
Ogni scrittura di proprietà causa l’invocazione del setter passando come argomento il valore assegnato.

ESEM var oggetto={get x() {return 1}, set x() {;}}

o.x -> 1
o.x=5 -> 5
o.x -> 1

I metodi di accesso possono essere usati per esempio per consentire l’accesso allo stesso dato in modi
diverso

ESEM class Distanza{ d

static #MIGLIO=1.60234 Distanza()
#distanza=0 d.km
get km() {return this.#distanza} 0
set km(v) {this.#distanza=v} d.km=5
get miglia() {return 5
this.#distanza/Distanza.#Miglio} d.km
set miglia(v) 5
{this.#distanza=v*Distanza.#MIGLIO} d.miglia
} 3.106
var d=new Distanza() d.miglia=3
} 3
d.km
4.828

• Quando si vuole leggere il valore di una proprietà di un oggetto, si guarda se l’oggetto ha la chiave
cercata
Se la chiave è presente si controlla se è un getter o una proprietà base
Se è un getter si invoca la funzione corrispondente e il valore è quello restituito dalla funzione
Se è una proprietà base il valore è quello della chiave nell’oggetto
Se la chiave non è presente e l’oggetto ha un prototipo si cerca la proprietà nel prototipo
ricorsivamente
Se la chiave non è presente e l’oggetto non ha un prototipo il risultato è undefined
• Quando si vuole scrivere il valore di una proprietà di un oggetto, si guarda se l’oggetto ha la chiave
cercata
Se la chiave è presente si controlla se è un setter o una proprietà base
Se è un setter si invoca la funzione corrispondente passando come unico argomento il valore
che si vuole assegnare
Se è una proprietà base si assegna il valore alla proprietà eventualmente sovrascrivendo il
valore precedente
Se la chiave non è presente si cerca ricorsivamente un setter nel prototipo ricorsivamente
Se si trova un setter lungo la catena si esegue la funzione corrispondente passando come unico
argomento il valore che si vuole assegnare
Se non si trova un setter lungo la catena la proprietà viene aggiunta all’oggetto con il valore he si
vuole assegnare
GENERATORI
In alcuni casi si vorrebbe poter tornare da una invocazione di funzione restituendo il controllo al chiamante,
ma poi riprendere la computazione da dove si era rimasti. I generatori sono un particolare tipo di funzione (e
dunque di metodo) che ha proprio questa caratteristica.

I generatori si dichiarano con function* f() {} oppure *metodo() {} dentro le classi. Nel corpo di un generatore si
può usare il comando yield expr che restituisce al chiamante il valore di espressione ma riprende l’esecuzione
dal comando successivo e non dall’inizio del corpo in caso di rientro.

ESEM function* range(a,b) {var i=a; while (i<b) yield i++}

La funzione range(a,b) restituisce un generatore che quando lo scorreremo ci darà ogni volta un valore
compreso fra a(incluso) e b(escluso) ricordandosi di dove eravamo arrivati.

Per scorrere un generatore si chiama ripetutamente il suo metodo next()

Il generatore è un oggetto con due proprietà: value che è il valore restituito e done, che vale true se la
generazione è completa.

Nella pratica spesso lo scorrimento è fatto con un for(... of ...) e non si invoca esplicitamente next() oppure con
lo spread.

ESEM var x=range(4,8) X

Object [Generator] {}
x.next()
{value: 4, done:false}
x.next()
{value: 5, done:false}
x.next()
{value: 6, done:false}
x.next()
{value: 7, done:false}
x.next()
{value: undefined, done:true}

Se viene passato un argomento a next() questo sarà trattato come il valore restituito da yield dentro il corpo al
momento della ripresa.

ESEM for (var i of range(4,8)) 4

console.log(i) 5
6
7

ESEM […range(3,7)] [3,4,5,6]

ESEM class Poesia{ […p.parole()}

#testo [“La”, “vispa”, “Teresa”, “avea”, “fra”,
constructor(t) { “l’erbetta”, “d’un”, “tratto”, “sorpresa”,
this.#testo=t} “farfalletta”]
*parole(){
var i=0
while (true){
let f=this.#testo.indexOf(" ",i)
if (f>=0) yield this.#testo.slice(i,f)
else {
yield this.#testo.slice(i)
break
 }
i=f+1
}
}
}
var p= new Poesia("La vispa Teresa avea fra
l'erbetta d'un tratto sorpresa farfalletta"

ESEM function * potenze(n){ function * potenzeLimitate(n,e){

let a=n let a=n
while(true){ for (let i=0; i<e; i++){
a=n*a a=n*a
yield a yield a
} }
} }
ECCEZIONI
Le eccezioni sono un meccanismo presente in molti linguaggi per la gestione degli errori.

BUG => denota un problema o un difetto che si introduce nel programma involontariamente come:
• Errori di sintassi che vengono riconosciuti dai programmi sia compilati che interpretati
• Errori di battitura come scrivere male il nome di variabile che può essere un problema nei linguaggi in
cui non è sempre necessario dichiarare una variabile e dunque è possibile non accorgersene
• Errori di logica ovvero non considerare all’interno del programma alcuni casi che si possono verificare
• Errori di input o output come l’inserimento di una stringa in un programma che si aspetta numeri

ESEM Scriviamo una funzione calc(A) che dato come argomento un array a in cui il primo elemento è un
operatore aritmetico rappresentato come carattere restituisca il risultato applicando l’operatore fra
tutti i rimanenti elementi dell’array utilizzando l’assegnamento destrutturante e la reduce

function calc(a){
[op,...el]=a
switch(op){
case "+":
return el.reduce((acc,el)=>(acc+el),0)
case "-":
[x,...el]=el
return el.reduce((acc,el)=>(acc-el),x)
case "*":
return el.reduce((acc,el)=>(acc*el),1)
case "/":
[x,...el]=el
return el.reduce((acc,el)=>(acc/el),x)
default:
return undefined
}
}

Stiamo assumendo che il primo elemento sia una stringa che contenga un operatore e che i restanti
elementi siano dei numeri.

La prima cosa da fare quando un risultato non è quello che ci aspettiamo è il debugging ovvero cercare e
rimuovere i bug che sono stati introdotti. A volte però può essere molto difficile fare debugging in programmi
molto lunghi o complicati. Per questo motivo è importante scrivere codice ben organizzato per risalire più
facilmente alle cause di vari bug.
C’è poi una modalità dei JS “strict” che si attiva inserendo all’inizio del codice “use strict” che evita che JS
faccia delle correzioni, ad esempio, se non viene inserito il return in una funzione questa non prova a
indovinare cosa deve ritornare ma non restituisce niente.

Ci sono però delle situazioni in cui JS non è capace di trovare una soluzione come ad esempio se noi
facessimo una divisione per zero esso ci restituirebbe Infinito ma magari noi preferiremmo che non eseguisse
l’operazione, o può capitare il caso in cui si ritrova un “uno” scritto in lettere anziché in numero e JS non
saprebbe gestire la situazione.
Per tutte queste situazioni fino ad ora restituivamo undefined oppure stampavamo a schermo un messaggio di
errore ma non è una buona idea esibire i messaggi di errore all’utente, bisogna gestire gli errori, dare feedback
all’utente e continuare l’esecuzione dal punto giusto utilizzando le eccezioni.

Un’eccezione è un meccanismo di interruzione del flusso del programma in caso di errore, dunque, si
interrompe l’esecuzione del programma e viene lanciata l’eccezione. Ci sono alcune eccezioni che sono
automatiche come, ad esempio, “ReferenceError” o “TypeError” che vengono lanciate dall’interprete, mentre
altre le possiamo lanciare manualmente ad esempio per segnalare che il programma non supporta la divisione
per 0 o un altro tipo di operatore. Questo perché nel momento in cui una funzione può dire la motivazione per
cui non funziona, chi l’ha invocata può prevedere meccanismi per gestire quelle eccezioni attraverso il blocco
try-catch.

ESEM Scriviamo una funzione calcAll(e) che dato come argomento un array e di espressioni invoca calc su
ciascuna espressione.

function calcAll(a){
return a.map(calc)
}

Se proviamo a fare console.log(calcAll([[“+”,1,2,3],[“-“,1,2,3], undefined])) ci restituisce un TypeError

(eccezione automatica) in quanto undefined non è iterabile e quindi non riesce ad eseguire lo spread.

Se il nostro obiettivo è far visualizzare l’errore baserà creare eccezioni ad hoc e lanciarle in caso l’errore si
presenti, se invece in caso di errore si desidera rispondere con una determinata azione è possibile catturare le
eccezioni che ci lancia JS come, ad esempio, il “TypeError” e dire cosa fare se si presenta un determinato
problema attraverso il comando try-catch.
Dentro il blocco try si mette una sequenza di comandi che potrebbe lanciare un’eccezione, se ciò accade
quella sequenza di comandi si interrompe e si passa alla sequenza di comandi nel blocco catch che è pensata
per gestire le eccezioni.

ESEM try{
a=calcAll(expressions)
console.log(a)
} catch(e){
console.log("Sorry not working today!")
}

Il codice del blocco try viene eseguito fino al primo comando che genera un errore incluso nelle chiamate
annidiate di funzioni. Se non c’è nessun errore il blocco try termina e il blocco catch viene saltato continuando
l’esecuzione del programma altrimenti se compare un errore i comandi oltre l’errore non vengono eseguiti e si
esegue il blocco catch a cui si passano nella variabile e le informazioni sull’errore.

Possiamo fare qualcosa in più rispetto a stampare a video un messaggio in caso di errore. Ad esempio,
potremmo decidere di identificare l’eccezione che è stata lanciata e diversificare la gestione in base la tipo di
errore. Infatti, la variabile che viene passata a catch è una variabile di tipo Error o un suo sottotipo che
memorizza l’eccezione. Quella variabile avrà a disposizione una serie di campi e di informazioni che possiamo
utilizzare per gestire l’eccezione come message, stack, name…

ESEM try{
a=calcAll(expressions)
console.log(a)
} catch(e){
console.log("Sorry not working because of a", e.name, “[“, e.message, “]”)
}

Oltre alle eccezioni che in caso di errore lancia automaticamente JS tante volte può essere utile poter lanciare
un’eccezione noi stessi per poter segnalare un problema specifico del nostro programma. In questi casi
l’esecuzione si ferma e si salta al blocco catch più vicino.

Possiamo ora gestire due bug del nostro programma quali un operatore non supportato o il passaggio di una
stringa al posto di un numero

ESEM In questo momento la funzione se non riconosce l’operatore ritorna semplicemente undefined

default:
throw new Error("Operator”, op, “ is not correct, should be one of +-*/")
 In questo modo quando l’operatore non è supportato si interrompe l’esecuzione di calc, anche quella
di calcAll e si passa al catch che restituisce “Sorry not working because of a Error [Operator op is not
correct, should be one of +-*/]

ESEM In questo momento il programma procederebbe in caso di + con la somma finchè trova numeri ma in
presenza di una stringa passerebbe alla concatenazione restituendo “0a23”, mentre con gli altri
operatori restituirebbe NaN

function calc(a){
[op,...el]=a
for(let e of el){
if(typeof(e) != "number")
throw new Error("Values must all be numbers")
}
switch(op){…]

Inoltre è possibile distingue i vari tipi di errore non solo dal messaggio ma ragionando in termini di tipo di
errore. Gli errori automatici di JS sono ad esempio TypeError e ReferenceError ma questi non sono gli unici
possibili nomi di errore assegnabili ad un’eccezione, possiamo definirci i nostri errori. New Error() è utile ma
non permette di riconoscere errori di natura diversa e nasconde gli altri errori, lancia un errore generico che
nasconde la vera tipologia dell’errore e ci affidiamo totalmente al messaggio per la differenziazione.

Noi invece vorremmo in grado di creare i nostri tipi di errore che vogliamo gestire e rilanciare al chiamante le
altre tipologie di errore. Ciò si può fare usando le classi e l’ereditarietà.

ESEM class CalcError extends Error{

constructor(...arg){
super(...arg)
this.name="CalcError"
}
}

class OperatorError extends CalcError{

constructor(...arg){
super(...arg)
this.name="OperatorError"
}
}

class ValueError extends CalcError{

constructor(...arg){
super(...arg)
this.name="ValueError"
}
}

for(let e of el){
if(typeof(e) != "number")
throw new ValueError("Values must all be numbers")
}

default:
throw new OperatorError("Operator”, op, “ is not correct, should be one of +-*/")
 Adesso quando lancio ValueError e OperatorError trova il nome della classe e restituisce quello ad
esempio “Sorry not working because of a OperatorError [Operator op is not correct, should be one of +-
*/]

In questo momento la calcolatrice mi lancia differentemente un ValueError e un OperatorError in modo tale

che io possa differenziare fra questi due casi attraverso instanceof e decidere opportunamente cosa fare
all’interno del catch.

ESEM try{
a=calcAll(expressions)
console.log(a)
} catch(e){
if(e instanceof CalcError)
console.log("Sorry not working because of", e.message)
else
throw e
}

In questo modo nel caso di un ReferenceError o di un TypeError viene rilanciato un nuovo tipo di errore
differenziando così gli errori che vogliamo gestire da quelli che non vogliamo o non possiamo gestire
che invece di creare un nuovo tipo di errore verranno rilanciati esattamente come li abbiamo ottenuti

È buona norma definirsi una propria gerarchia di eccezioni in modo tale che tutti gli errori sono figli di Error ma
quelli riferiti alla nostra funzione sono istanze di CalcError in questo modo è possibile prendere tutti i figli
relativi ad una specifica funzione escludendo gli altri oppure è possibile andare ancora più nello specifico
prendendo solo un singolo particolare errore.

Inoltre oltre a try e catch abbiamo anche finally. Si esegue il try se va tutto bene si esegue il catch altrimenti in
caso di errore si interrompe il try e si esegue il catch; indipendentemente da questo alla fine si esegue il blocco
finally per ripulire l’ambiente o fare determinate operazioni. Tante volte uscire dal programma subito dopo un
errore non è indicato ma bisogna lasciare i dati su cui si è lavorato in uno stato valid, chiudere i file… Il blocco
Finally ci permette di includere comandi da eseguire sempre sia nel caso di errore che non.

È possibile mettere il catch e mettere solo finally, in questo caso in caso di errore si interromperà l’esecuzione
del try e si andrà direttamente al finally senza gestire le eccezioni.
MODULI
I moduli sono un meccanismo che consente di dividere il codice sorgente dei programmi in vari pezzi ognuno
caricato indipendentemente nel suo file invece di scrivere un unico grande file JS che contiene tutto. Ciò
permette di tenere le cose ordinate, permette di riutilizzare una funzione o una classe in programmi diversi
trasformandole in una libreria evitando di fare copia incolla (se mi accorgo di un bag devo modificarlo solo una
volta), inoltre solitamente la programmazione è cooperativa e quindi è più facile suddividere il lavoro e le
responsabilità lavorando su file separati.

In JS un modulo è un file sorgente in JS contenente una o più dichiarazioni (di funzioni, variabili, classi,
costanti, generatori). In aggiunta il file deve contenere alcune istruzioni specifiche per indicare quali fra le
dichiarazioni presenti devono essere visibili a chi userà il modulo.
• Si dice che il modulo esporta alcune dichiarazioni mentre le dichiarazioni non esportate (magari usate
per implementare le funzioni esportate) rimangono private e visibili sono all’interno del modulo. Il
programmatore del modulo dichiarerà esplicitamente cosa esportare.
• Si dice che il codice che usa il modulo importa alcune dichiarazioni (fra quelle esportate dal modulo).

Ogni linguaggio ha il suo modo di importare ed esportare i moduli con varie metodologie per scrivere una
libreria da riutilizzare.

ESPORTARE
In JS un modulo si può scrivere come un file .js chiamato ad esempio “modulo.js” che implementa una libreria
che dichiara un certo numero di funzioni, variabili o costanti e alla fine espliciterà quali cose fra queste sono
esportabili con la dicitura in fondo di “exports.fun=f2” dove f2 è la funzione da esportare e fun il nome che avrà
nel file in cui viene importata. Dunque, le funzioni importate nel file principale non saranno visibili con il nome
che hanno all’interno della libreria ma con il nome con la quali le esporto; all’esterno sarà visibile solo il
campo dell’exports.

IMPORTARE
Nel file principale la libreria viene importata con la dicitura “const mod=require(‘./modulo’)” e mod sarà una
costante a cui è associato un oggetto {fun: {…} , …} le cui chiavi sono i nomi delle funzioni importate. In questo
caso mod è una costante ma potrebbe benissimo essere una variabile dichiarata con var, let, ecc; si dichiara
const per evitare che sia modificabile dal programmatore.

Una volta che si ha la costante mod con un oggetto per valore all’interno del programma principale posso
richiamare ciò che ho importato attraverso la notazione degli oggetti quindi con “mod.fun” ecc.
 ESEM index.js modulo.js
const mod=require("./modulo.js") function square(x){
console.log(mod.compute(3)) return x**2
}

function cube(x){
return x**3
}

function poly(x){
return 2*square(x)+3*cube(x)
}
exports.compute=poly

Mi sono definito due funzioni che utilizzo per implementare la funzione che voglio esportare e rendo
visibile all’esterno solo la funzione poly

Questo è la modalità standard di dare l’import supportata da tutti gli interpreti js ma non è l’unica. Ci sono altri
approcci più moderni che ricalcano altri programmi di programmazione.

SECONDA MODALITÁ PER IMPORT/EXPORT

In questo secondo modo invece che scrivere il file modulo.js esplicitando alla fine cosa si vuole esportare, si
esplicita ciò che si esporterà al momento della dichiarazione della funzione o della variabile con “export
function f2(n){}”. In questo modo le funzioni avranno lo stesso nome sia nel modulo che nel programma
principale.

Nel file principale per importare una libreria si usa “import * as mod from ‘./modulo.js’” che nuovamente
creerà una variabile mod a cui è associato un oggetto che ha come campi le funzioni e variabili esportate a cui
si può accedere con la notazione “mod.f2”.
È possibile però in questo modo importare anche solo una funzione implementata nella libreria scrivendo
“import f2 as poly from ‘./modulo.js’ ed in questo modo importo un oggetto che contiene la sola funzione e
rinomino la funzione nel programma principale.

Tutte le varianti di import ed export permettono:

• di decidere quali chiavi deve avere l’oggetto, ovvero i nomi delle funzioni esportate nel programma
principale
 • di decidere quali valori devono avere le chiavi, ovvero gli elementi esportati
• tutto quello che non viene esportato dal modulo non è accessibile dal programma principale ma è
privato al modulo
• consentono ad ogni modulo di avere al massimo un “export di default” che consente di esportare un
valore senza nome.

COMANDO AGGIUNTA ALL’OGGETTO EXPORTS

export pippo {pippo: pippo}
export function f(x) {} {f: f}
export class Student {} {Studente: Studente}
export default const const PI=4 {PI: 4}
export {pippo, f as fibo, Studente} {pippo: pippo, fibo: f, Studente: Studente}
export * from ‘./altro_modulo.js’ ri-esporto tutti gli export di altro_modulo

import pippo from ‘./modulo.js’

import * as pippo from ‘./modulo.js’
import {f, Studente} from ‘./modulo.js’
import {fibo as fibonacci} from ‘./modulo.js’
import ‘./modulo.js’

Se un file JS è un modulo ovvero contiene export allora tutto il file viene interpretato in modo “Strict”.
Il letterale stringa che rappresenta il nome di un modulo può essere interpretato in modi diversi a seconda
dell’ambiente di esecuzione:
• Un path-name: dire dove si trova il file da importare). Utilizzare come prima “./” significa cercare il file
nella cartella corrente. Se sono su un server come su Replit posso andare a partire da punto del file
system in cui viene eseguito il codice, a cercare il modulo seguendo il path
• Una URL che è supportato soprattutto nei browser ma non in tutti gli ambienti e permettono di fare
animazioni.
• Con nome semplice ovvero senza . o / come con prompt.sync per cui non dicevamo dove tale libreria si
trovava nel nostro computer o nell’internet ma andavamo ad utilizzare un nome noto di libreria per far
si che il package manager fosse in grado di trovarlo e scaricarla per metterla a disposizione.

Come nome di moduli sono ammesse solo stringhe letterali e se lo stesso modulo è importato più volte in
punti diversi del programma il sistema ne tiene una sola copia quando ad esempio un modulo A che sto
importando è stato implementato importando un altro modulo B e poi noi importiamo nuovamente il modulo
B.

Usare i moduli ES6 ovvero il secondo modo di import e export dei moduli è più complicato su Replit perché
richiedono una configurazione particolare.
Tuttavia su Replit è molto facile usare i package ovvero i moduli di libreria come prompt.sync. Questo è utile
non tanto per i moduli che già conosciamo ma per altri che non conosciamo cercandoli per argomento e
aggiungendoli al programma con require dopo averli scaricati.

È importante distinguere ciò che è nel sistema, oggetti predefiniti in qualunque interprete JS, come console,
Math, Number, Error e moduli esistenti che non abbiamo di default ma che possono essere utili.

WRAPPER DI TIPI BASE

Una cosa che abbiamo sempre utilizzato sono le classi wrapper di cui ne esiste una per ogni tipo base di JS con
lo stesso nome del tipo ma con l’iniziale maiuscola come Number, Boolen, String... I costruttori di queste
classi prendono un argomento di tipo qualunque e provano a convertirlo nel tipo corrispondente.

ESEM Number(“1.33”)===1.33 true

String(14)===14 false
String(14)===”14” true
Inoltre, queste classi offrono costanti e metodi statici.

ESEM Number.EPSILON 2.22044684… rappresenta un numero molto piccolo vicino allo 0

Number.isFinite(3.14) true

Gli oggetti offrono metodi di istanza.

ESEM Number(3.14).toFixed(4) “3.1400”

Per quando riguarda i numeri se provo ad utilizzare i metodi di ciò che è un numero su un numero ovvero
3.24.toFixed(4) non funziona banalmente perché interpreta il punto come virgola dunque se voglio prendere un
qualunque valore e applicargli uno dei metodi predefiniti di Number devo fare il cast e poi invocarlo. Mentre le
costanti letterali numeriche non vengono automaticamente promosse ad oggetti, ciò succede invece con le
stringe e i booleani dunque è possibile scrivere “pippo”.indexOf(“i”) che chiama il metodo indexOf della classe
Sring sulla stringa “pippo”.

• Number.EPSILON rappresenta un numero molto vicino allo 0

• Number.isFinite(13) il numero è finito?
• Number(13).toFixed(4) sistema il numero di cifre decimali
• Number.toString(13) da numero a stringa
• Number.toExponential(13) scrive il numero con la notazione esponenziale
• Number(13).toPrecision(4) scrive il numero con una specifica lunghezza
• Number.isInteger(13) il numero è un intero?

• a.concat(b) concatena due stringhe restituendo una nuova stringa

• a.indexOf(“dog”) restituisce l’indice della prima occorrenza
• a.lastIndexOf(“dog”) restituisce l’indice dell’ultima occorrenza
• a.repeat(3) restituisce una stringa che contiene n copie della stringa
• a.slice(3,7) restituisce una nuova stringa a partire dal primo indice fino al
secondo
• a.split(“ “) cerca il carattere e divide la stringa mettendo tutti in un array
• a.toLowerCase() converte tutto in minuscolo
• a.toUpperCase() converte tutto in maiuscolo

DATE
La classe Date che abbiamo anche questa già utilizzato (Date.now) fornisce oggetti che rappresentano date di
calendario nel range 20 aprile 271.821 a.C. – 13 Settembre 275.760 d.C.
Il costruttore cerca di interpretare date espresse come stringhe in una varietà di formati. Senza argomenti
Date() restituisce data e ora correnti. Con numeri li interpreta come anno, mese, giorno, ora, minuti, secondi,
millisecondi.

ESEM Date() “Thu Mar 18 2021 21:25:34 GMT+0000”

New Date() “2021-03-18T21:25:34.725Z
New Date(“19 marzo”) “2020-03-19T00:00:00:000Z”
New Date(2021,3,19,14,15) “2021-04-19T14:15:00:000Z”

Gennaio viene indicato con 0 mentre per i giorni della settimana 0 è la domenica.

Gli oggetti Date sono sostanzialmente numeri espressi in millisecondi dal 1 gennaio 1970 dunque possiamo
usare l’aritmetica su di essi e confrontarli. Gli oggetti Date hanno numerosi metodi di istanza: getter e setter
per i vari componenti e conversioni da/verso stringhe e numeri.

ESEM a=new Date(“19 marzo 2021”)

b=new Date(2021,3,19,14,15)
a>b false
 b-a 2729200000
(b-a)/(24*60*60*1000) 31,59375

• Date.now() restituisce il momento corrente in millisecondi

• a.toISOString() “2021-03-19T00:00:00.000Z”
• a.toUCTString() “Fri, 19 marzo 2021 00:00:00 GMT”
• a.toLocaleString() “3/19/2021, 12:00:00 AM”
• a.getMonth() restituisce il mese
• a.setMonth(a.getMonth()+1) passa al mese successivo
• a.getDate() restituisce il giorno del mese
• a.setMonth
• a.getDay() restituisce il giorno della settimana
• a.getFullYear() restituisce l’anno
• a.setFullYear(1969) cambia l’anno

ESPRESSIONI REGOLARI
Una delle applicazioni dei linguaggi regolari sono le espressioni regolari che sono un modo per esprimere
schemi di corrispondenza su stringhe ovvero permettono di dire se una qualunque stringa è scritta secondo il
linguaggio. Ciò è utile perché stiamo ad esempio facendo dei log che seguono un template data-gravità-
messaggio ed io vorrei poter trasformare questa stringa in informazioni separate; io sapendo quale è il
linguaggio regolare dei log ovvero il loro template scrivo l’espressione regolare che rappresenta quel linguaggio
e riesco a scorporare i vari pezzi.
Le espressioni regolari sono supportate dalla classe RegExp di JS che è una classe di default.

Le RegExp possono avere degli ulteriori flag per

esempio:
/…/g tutte le occorrenze
/…/i ignora maiuscole/minuscole
/…/m funziona su più linee

ESEM e=new RegExp(“[a-z]+”) oppure e=/[a-z]+/

e.test(“pippo”) true
e.test(“4ndr34”) true
e.test(“1337”) false
e.exec(“4ndr34”) [“ndr”, index: 1, input: “4ndr34”, groups: undefined]
4ndr34.match(e) [“ndr”, index: 1, input: “4ndr34”, groups: undefined]
for (var m of “4ndr34.matchAll(/\d+/g))
console.log(m) [“4”, index: 0, input: “4ndr34”, groups: undefined]
[“34”, index: 4, input: “4ndr34”, groups: undefined]

• e.test(a) verifica se la stringa a corrisponde alla RegExp

• e.exec(a) fornisce informazioni più complete
• s.match(e) è analogo a quello sopra
• s.matchAll(e) è un generatore che restituisce un iteratore su tutti i match
ARRAY CON TIPI DI MACCHINA
Ci sono poi gli array in generale e classi speciali di array. Per implementare certi algoritmi, specialmente se è
necessario scambiare dati in formati predeterminati con altri programmi è necessario poter manipolare
blocchi di memoria di dimensione specificata. Ci sono dunque classi specifiche di array che permettono di
creare array:
• Int8Array, Int16Array, Int32Array rispettivamente interi di 8,16,32 bit
• BigInt64Array, BigUint64Array
• Float32Array, Float64Array

Nonostante JS sia un linguaggio privo di tipo definisco degli array con i tipi perché ad esempio se sto
programmando un device con poca memoria e storage e ho bisogno di processare un certo numero di dati
prodotti da dei sensori, se so che quei dati sono temperature non ho bisogno di un intero di 32 bit ma mi
interessa utilizzare meno memoria. Se mi creo uno di questi oggetti se l’interprete Js è ottimizzato per
funzionare opportunamente non occuperà più spazio del necessario. Gli oggetti di questo tipo sono detti
“TypedArray” e offrono metodi per convertire da normali array JS a TypedArray e viceversa.

CLASSE SET
La classe Set implementa insiemi di valori qualunque nel senso matematico del termine e fornisce operazioni
per aggiungere, togliere, svuotare, cercare, restituire la dimensione o fare l’enumerazione dei contenuti...
Finora abbiamo usato gli oggetti per implementare gli insiemi ma con chiavi che devono essere stringhe. Con i
Set le chiavi possono essere qualunque valore valido in JS e si possono per esempio creare insiemi di funzioni
o di oggetti.

let S = new Set()

Posso creare come in questo caso un Set vuoto e poi aggiungere gli elementi oppure passargli come
argomento un array.

• S.add(e) aggiunge e a S
• S.delete(e) rimuove e da S
• S.clear(e) svuota S
• S.has(e) metodo che controlla se S contiene e e restituisce un booleano
• S.size proprietà che contiene il numero di elementi
• S.values()/ S.keys() restituisce gli e in S (iteratore), come un generatore si usa con next()
• S.forEach(f) invoca la funzione f su ogni elemento e di S
• A.difference(B) restituisce un Set che è la sottrazione A-B
• A.intersection(B) restituisce l’intersezione fra gli insiemi
• A.symmetric(B) restituisce ciò che non è nell’intersezione
• A.union(B) restituisce l’unione
• A.isDisjointFrom(B) restituisce true se gli insiemi sono distinti
• A.isSubsetOf(B) restituisce true se A è un sottoinsieme di B
• A.isSupersetOf(B) restituisce true se B è un sottoinsieme di A

Trasformo un Set in un array: arr=[…mySet]

Da array a Set: myset=new Set([ ])
Posso usarlo per eliminare gli elementi doppi da un array
Se gli passo una stringa mi crea un insieme di tutti i caratteri senza ripetizioni, ma distingue maiuscole e
minuscole.

CLASSE MAP
Analogamente alla classe Set, la classe Map implementa una mappa che è una struttura dati diversa da un
insieme perché mantiene un’associazione tra la chiave e il valore. A differenza dei dizionari di JS in cui le chiavi
possono essere solo stringhe, con la classe Map sia le chiavi che i valori possono essere di qualunque tipo. Si
tratta della generalizzazione del dizionario di JS. Come al solito sono implementati dei metodi per aggiungere
elementi o fare operazioni. Una chiave nella mappa può esserci una sola volta.

let M=new Map()

• M.set(k,v) aggiunge la chiave k con valore v

• M.delete(k) elimina la chiave k, restituisce true se esiste ed è stato eliminato, altrimenti false
• M.clear() svuota M
• M.has(k) controlla se M contiene k e restituisce un booleano
• M.get(k) restituisce valore se la chiave è presente in M, altrimenti undefined
• M.size restituisce la dimensione di M
• M.keys() restituisce le k in M (iteratore), devo usare la funzione next()
• M.values() restituisce i valori in M (iteratore)
• M.entries() restituisce array formati da [chiave, valore] in M (iteratore)
• M.forEach(f) invoca f(v,k,M) per ogni chiave in M

Posso fare: for(const [key, values] of MyMap)

For(const key of MyMap.keys())
For(const values of MyMap.values())

Posso passare da un array di forma [[“key1”, “value1”],[“key2”, “value2”]] ad una mappa con new Map(array)
Al contrario trasformo una mappa in un array di quel tipo con Array.from(myMap) oppure […myMap]
Posso anche clonare una Mappa facendo new Map(myMap)
Unisco due mappe con new Map([…Map1, …Map2])

JSON
JSON sta per JavaScript Object Notation è un formato di serializzazione per oggetti JS. In pratica consente di
trasformare un oggetto qualunque in una stringa e viceversa. Una stringa JASON è fatta in un determinato
modo ovvero ha una { per indicare l’inizio di un oggetto, le chiavi sono fra virgolette e i valori rappresentati
nuovamente con la stessa notazione.

La classe JASON contiene due metodi statici:

• s=JSON.stringify(o) per passare da oggetto a stringa
• o=JSON.parse(s) per passare da stringa a oggetto

Questa scrittura ha avuto successo perché è facilmente leggibile sia dai programmi che dagli umani ma non
sempre è possibile effettuare una conversione da stringa a oggetto o viceversa.

let o={nome: “Jacopo”, cognome: “Soldani”, età: 35}.

Se io faccio un console.log di un oggetto mi viene stampato allo stesso modo in cui l’ho rappresentato su JS
{nome: “Jacopo”, cognome: “Soldani”, età: 35}.
Se io trasformassi l’oggetto nel suo corrispettivo JASON.stringify(o) e lo stampassi otterrei {“nome”: ”Jacopo”,
“cognome”: ”Soldani”, “età”: 35}. Dunque abbiamo ottenuto una stringa che rappresenta un oggetto in modo
analogo a come viene rappresentato un oggetto in JS.
Ciò è utile perché, se fosse necessario passare delle informazioni contenute in un oggetto possiamo non
passare un oggetto JS che sta nella RAM ma possiamo trasformarlo in una stringa e passare la stringa.

Mi serve dunque per andare da un programma ad un'altra parte passandogli un file o una stringa, ottenere un
risultato e ritrasformalo in un oggetto che JS può manipolare.
OGGETTI DELL’AMBIENTE (HOST-DEFINED)
Ci sono poi alcuni oggetti che non sono dipendenti da un interprete JS e che sono predefiniti in qualunque
interprete ma che dipendono da dove stiamo eseguendo il codice. Ogni ambiente di esecuzione (host) di JS
può fornire ulteriori nomi predefiniti nello scope globale con funzioni adatte allo specifico ambiente. Per
esempio:
• su Node.JS abbiamo dei nomi disponibili tipo console che utilizziamo per interagire con il server
• se sto lavorando in un browser (pagina web) avrò definite delle variabili globali come document che si
riferisce alla pagina web stessa, window ovvero la tab del browser, location per la URL e metodi di
utilità per accedere alle risorse di rete
• AppScript che è il linguaggio delle app di Google ha CalendarApp, DriveApp, GmailApp…
Questi oggetti vengono forniti dall’ambiente per manipolare e interagire con il contesto.

Il codice JS è eseguito da una macchina virtuale che interpreta il linguaggio applicando le regole di semantica e
che viene eseguita in un ambiente virtuale. Ci sono diverse versioni di implementazioni di macchina virtuale JS
come V8 usata in Chrome, Edge e Node.js.
Node.js è un ambiente di esecuzione basato su V8 specializzato per l’esecuzione di programmi singoli su
server e non dentro un browser, molto efficiente nella gestione della programmazione asincrona e dotato di
moltissimi moduli di libreria.

MODULO FILE SYSTEM

Il modulo fs (File System) che deve essere importato in JS e che contiene funzioni per leggere e scrivere
contenuti di un file, leggere i contenuti di una directory, creare, cancellare, troncare, rinominare, copiare file e
directory, ottenere e impostare metadati su file e directory.

Per importarlo utilizziamo const fs=require(‘fs’).

Funzioni di utilizzo più comune sono:

• var dati= fs.readFileSync(“index.js”) legge il file passato e lo mette come buffer (codice binario) in dati
• console.log(s.toString()) deve essere trasformato in una stringa
• fs.writeFileSync(“index2.js”, dati) crea un nuovo file se il file specificato non esiste e ci scrive i dati

A queste funzioni passiamo il path (“index.js) ovvero il nome del file da leggere di solito come stringa mentre i
dati possono essere di vario tipo.
Le funzioni readFileSync() e writeFileSync() mettono l’intero contenuto del file in una sola stringa dunque non
sono adatti per file di grandi dimensioni (metodo sincrono).
Altre funzioni consentono di leggere o scrivere file molto grandi processando il contenuto in blocchi più piccoli
chiamati chunk. Man mano che la lettura/scrittura procede una funzione passata come argomento (callback)
viene invocata ripetutamente passando un chunk dopo l’altro (metodo asincrono).

MODULO OPERATING SYSTEM

Il modulo os (operating system) che deve essere importato in JS contiene funzioni per ottenere informazioni
sull macchina, sul sistema operativo, e sull’utente che sta eseguendo il nostro programma.
In particolare, le funzioni:
• os.hostname()
• os.networkInterfaces()
Entrambe forniscono informazioni sugli indirizzi di rete che posso usare per accedere alla macchina su cui gira
il programma

La funzione os.userInfo() vi dice “chi siete voi” per il sistema operativo

MODULO PROCESS
Il modulo process che deve essere importato in JS contiene funzioni per vari scopi:
 • Ottenere informazioni sul processo che sta eseguendo il vostro programma come, ad esempio, con
che argomenti da riga di comando è stato lanciato o quali sono i valori delle variabili di ambiente del
sistema operativo
• Manipolare gli altri processi in esecuzione sulla macchina
• Registrare funzioni da eseguire in momenti specifici come subito prima di terminare

Per importarlo const process=require(“process”)

MODULI URL E HTTP (ACCESSO AL WEB)

I moduli url e http forniscono rispettivamente funzioni per fare il parsing di URL (conversioni URL-stringa e
simili) e per utilizzare il protocollo di rete http. Servono per programmare applicazioni web che devono fare
richieste, ottenere, chiedere o mandare informazioni a server remoti.
In particolare, con http potete implementare facilmente un vostro server web:
• Può restituire i contenuti di un file
• Può calcolare una risposta e restituirla
Si può procedere in modo sincrono ovvero si manda la richiesta al server e si aspetta la risposta mettendo il
processo in pausa oppure in modo asincrono mandando la richiesta e processando la risposta con una
funzione di callback nel momento in cui il server mi risponde.