// Dichiarazione di variabile globale
    var globalVar = "Sono globale";
    
    function exampleFunction() {
        // Dichiarazione di variabile locale alla funzione
        var localVar = "Sono locale";
        
        if (true) {
            var blockVar = "Sono visibile fuori dal blocco";
        }
        console.log(blockVar); // Funziona, stampa "Sono visibile fuori dal blocco"
    }
    
    console.log(globalVar); // Funziona
    console.log(localVar); // Errore: localVar is not defined
                                

    // Dichiarazione di variabile con scope di blocco
    let x = 10;
    if (x === 10) {
        let y = 20; // y è visibile solo all'interno di questo blocco
        console.log(y); // Output: 20
    }
    console.log(y); // Errore: y is not defined
    
    // Riassegnazione di una variabile dichiarata con let
    let nome = "Mario";
    nome = "Luigi";
    console.log(nome); // Output: Luigi
                                

    // Dichiarazione di variabile con valore costante
    const PI = 3.14159;
    console.log(PI); // Output: 3.14159
    
    // Errore se si tenta di riassegnare la variabile
    // PI = 3.14; // Errore: Assignment to constant variable
    
    // Dichiarazione di un array con const
    const numeri = [1, 2, 3];
    numeri.push(4); // Funziona, poiché le proprietà di un array possono essere modificate
    console.log(numeri); // Output: [1, 2, 3, 4]
    
    // Errore se si tenta di riassegnare l'intero array
    // numeri = [5, 6, 7]; // Errore: Assignment to constant variable
                                

    // Dichiarazione di numeri
    let intero = 42;
    let decimale = 3.14;
    let esponenziale = 2.998e8; // 2.998 * 10^8
    
    // Operazioni matematiche
    let somma = 5 + 3; // 8
    let prodotto = 4 * 2.5; // 10
    let divisione = 10 / 3; // 3.3333333333333335
    
    // Valori speciali
    let infinito = Infinity;
    let nonNumero = NaN;
    
    // Verifiche
    console.log(isNaN(nonNumero)); // true
    console.log(isFinite(infinito)); // false
    
    // Conversioni
    let stringaNumero = "123";
    let numeroConvertito = Number(stringaNumero); // 123
    
    // Arrotondamento
    let piGreco = Math.PI;
    console.log(piGreco.toFixed(2)); // "3.14"
                                

    // Creazione di una stringa
    let messaggio = "Ciao, come stai?";
    
    // Ottenere la lunghezza della stringa
    console.log(messaggio.length); // 16
    
    // Accesso a un singolo carattere
    console.log(messaggio.charAt(0)); // 'C'
    
    // Concatenare due stringhe
    let nome = "Mario";
    let saluto = "Ciao " + nome;
    console.log(saluto); // 'Ciao Mario'
    
    // Usare template literals per concatenazione
    let età = 30;
    console.log(`Mario ha ${età} anni`); // 'Mario ha 30 anni'
    
    // Suddividere una stringa
    let parole = messaggio.split(' ');
    console.log(parole); // ['Ciao,', 'come', 'stai?']
    
    // Sostituire parte di una stringa
    let nuovoMessaggio = messaggio.replace('Ciao', 'Salve');
    console.log(nuovoMessaggio); // 'Salve, come stai?'
    
    // Estrarre una porzione di stringa
    let parte = messaggio.slice(6, 10);
    console.log(parte); // 'come'
                                

    // Dichiarazione di un valore booleano
    let isOnline = true;
    console.log(isOnline); // Output: true
    
    // Uso in una condizione
    if (isOnline) {
        console.log("L'utente è online");
    } else {
        console.log("L'utente è offline");
    }
    
    // Conversione di un valore in booleano
    let num = 0;
    let isValid = Boolean(num); // Conversione di 0 in false
    console.log(isValid); // Output: false
    
    // Verifica di "veridicità" di un valore
    let name = "Mario";
    if (name) {
        console.log("Il nome esiste"); // Questo blocco verrà eseguito, 
        poiché una stringa non vuota è "truthy"
    }
                                

    // Dichiarazione di un oggetto
    let persona = {
        nome: "Mario",
        età: 30,
        saluta: function() {
            console.log("Ciao, mi chiamo " + this.nome);
        }
    };
    
    // Accesso a proprietà e metodi
    console.log(persona.nome); // Output: Mario
    persona.saluta(); // Output: Ciao, mi chiamo Mario
    
    // Aggiunta di una nuova proprietà
    persona.occupazione = "Sviluppatore";
    console.log(persona.occupazione); // Output: Sviluppatore
    
    // Modifica di una proprietà
    persona.età = 31;
    console.log(persona.età); // Output: 31
                                

    // Dichiarazione di un array
    let colori = ["rosso", "verde", "blu"];
    
    // Accesso a un elemento tramite indice
    console.log(colori[0]); // Output: rosso
    
    // Aggiunta di un elemento alla fine
    colori.push("giallo");
    console.log(colori); // Output: ["rosso", "verde", "blu", "giallo"]
    
    // Rimozione dell'ultimo elemento
    colori.pop();
    console.log(colori); // Output: ["rosso", "verde", "blu"]
    
    // Iterazione su un array con forEach
    colori.forEach(function(colore) {
        console.log(colore);
    });
    // Output:
    // rosso
    // verde
    // blu
                                

    // Definizione di una funzione classica
    function somma(a, b) {
        return a + b;
    }
    console.log(somma(2, 3)); // 5
    
    // Funzione anonima assegnata a una variabile
    const moltiplica = function(x, y) {
        return x * y;
    };
    console.log(moltiplica(4, 5)); // 20
    
    // Arrow function
    const sottrai = (a, b) => a - b;
    console.log(sottrai(10, 6)); // 4
    
    // Passare una funzione come callback
    function saluta(callback) {
        callback();
    }
    saluta(() => console.log("Ciao!")); // "Ciao!"
                                

    // Dichiarazione di variabile senza inizializzazione
    let x;
    console.log(x); // Output: undefined
    
    // Proprietà inesistente di un oggetto
    let persona = { nome: "Mario" };
    console.log(persona.età); // Output: undefined
    
    // Funzione senza return esplicito
    function saluta() {
        let messaggio = "Ciao!";
    }
    console.log(saluta()); // Output: undefined
    
    // Controllo di undefined
    if (typeof x === "undefined") {
        console.log("La variabile x è undefined");
    }
                                

    // Dichiarazione di una variabile null
    let oggetto = null;
    console.log(oggetto); // Output: null
    
    // Usare null per "svuotare" un oggetto
    let utente = { nome: "Mario" };
    utente = null; // Il riferimento all'oggetto è rimosso
    console.log(utente); // Output: null
    
    // Controllo di null in una condizione
    if (utente === null) {
        console.log("L'utente non esiste più");
    }
    
    // Differenza tra null e undefined
    let variabile;
    console.log(variabile); // Output: undefined
    variabile = null;
    console.log(variabile); // Output: null
                                

    // Creazione di un symbol unico
    let simboloUnico = Symbol("descrizione");
    console.log(simboloUnico); // Output: Symbol(descrizione)
    
    // Uso di un symbol come chiave di una proprietà
    let persona = {
        nome: "Mario",
        [simboloUnico]: "Valore nascosto"
    };
    console.log(persona[simboloUnico]); // Output: Valore nascosto
    
    // Confronto tra symbol
    let simbolo1 = Symbol("id");
    let simbolo2 = Symbol("id");
    console.log(simbolo1 === simbolo2); // Output: false (i simboli sono sempre unici)
    
    // Uso di Symbol.for() per symbol globali condivisi
    let simboloGlobale1 = Symbol.for("chiave");
    let simboloGlobale2 = Symbol.for("chiave");
    console.log(simboloGlobale1 === simboloGlobale2); // Output: true
                                

    // Dichiarazione di un BigInt
    let grandeNumero = 123456789012345678901234567890n;
    console.log(grandeNumero); // Output: 123456789012345678901234567890n
    
    // Operazioni aritmetiche con BigInt
    let somma = grandeNumero + 100000000000000000000000000000n;
    console.log(somma); // Output: 223456789012345678901234567890n
    
    // Confronto tra BigInt e Number
    let piccoloNumero = 10;
    let grandeNumero2 = 10n;
    console.log(piccoloNumero === grandeNumero2); // Output: false (Number e BigInt non sono comparabili)
    
    // Conversione esplicita
    console.log(BigInt(piccoloNumero) === grandeNumero2); // Output: true
    
    // Errore nelle operazioni tra Number e BigInt
    // console.log(grandeNumero + piccoloNumero); // Errore: Cannot mix BigInt and other types
                                

    // Creazione di una nuova Map
    let mappa = new Map();
    
    // Aggiunta di coppie chiave-valore
    mappa.set('nome', 'Mario');
    mappa.set(1, 'Uno');
    mappa.set(true, 'Vero');
    
    // Ottenere il valore associato a una chiave
    console.log(mappa.get('nome')); // 'Mario'
    console.log(mappa.get(1)); // 'Uno'
    
    // Verifica se una chiave esiste nella Map
    console.log(mappa.has(true)); // true
    
    // Rimozione di una coppia chiave-valore
    mappa.delete(1);
    console.log(mappa.get(1)); // undefined
    
    // Iterazione su una Map
    for (let [chiave, valore] of mappa) {
        console.log(chiave, valore);
    }
    
    // Ottieni la dimensione della Map
    console.log(mappa.size); // 2 (due elementi restanti)
                                

                    // Creazione di un nuovo Set
                    let insieme = new Set();
                    
                    // Aggiunta di valori
                    insieme.add(1);
                    insieme.add(5);
                    insieme.add('ciao');
                    
                    // Tentativo di aggiungere un duplicato
                    insieme.add(1); // Non verrà aggiunto poiché già presente
                    
                    // Verifica della presenza di un valore
                    console.log(insieme.has(5)); // true
                    console.log(insieme.has(10)); // false
                    
                    // Rimozione di un valore
                    insieme.delete(5);
                    console.log(insieme.has(5)); // false
                    
                    // Iterazione su un Set
                    for (let valore of insieme) {
                        console.log(valore); // 1, 'ciao'
                    }
                    
                    // Rimozione di tutti gli elementi
                    insieme.clear();
                    console.log(insieme.size); // 0
                                

    // Creazione della data corrente
    let dataCorrente = new Date();
    console.log(dataCorrente); // Es: Wed Oct 22 2024 10:15:30 GMT+0200
    
    // Creazione di una data specifica
    let dataSpecifica = new Date('2023-10-10T10:00:00');
    console.log(dataSpecifica); // Es: Tue Oct 10 2023 10:00:00 GMT+0200
    
    // Ottenere parti della data
    let anno = dataCorrente.getFullYear(); // Anno corrente
    let mese = dataCorrente.getMonth(); // Mese (0-11)
    let giorno = dataCorrente.getDate(); // Giorno del mese (1-31)
    console.log(anno, mese, giorno); // Es: 2024 9 22
    
    // Formattazione della data
    console.log(dataCorrente.toISOString()); // 2024-10-22T08:15:30.000Z
    console.log(dataCorrente.toLocaleDateString('it-IT')); // 22/10/2024
    
    // Calcolare differenze tra date
    let dataInizio = new Date('2024-10-01');
    let diffMillisecondi = dataCorrente - dataInizio;
    let giorniDifferenza = diffMillisecondi / (1000 * 60 * 60 * 24); // Convertire in giorni
    console.log(giorniDifferenza); // Es: 21 giorni
                                

    // Creazione di un nuovo Set
    let insieme = new Set();
    
    // Aggiunta di valori
    insieme.add(1);
    insieme.add(5);
    insieme.add('ciao');
    
    // Tentativo di aggiungere un duplicato
    insieme.add(1); // Non verrà aggiunto poiché già presente
    
    // Verifica della presenza di un valore
    console.log(insieme.has(5)); // true
    console.log(insieme.has(10)); // false
    
    // Rimozione di un valore
    insieme.delete(5);
    console.log(insieme.has(5)); // false
    
    // Iterazione su un Set
    for (let valore of insieme) {
        console.log(valore); // 1, 'ciao'
    }
    
    // Rimozione di tutti gli elementi
    insieme.clear();
    console.log(insieme.size); // 0
                                    

    // Creazione di un'espressione regolare per cercare la parola "test"
    let regex = /test/;
    let testo = "Questo è un test di RegExp.";
    console.log(regex.test(testo)); // true
    
    // Esempio con flag "g" e "i"
    let regex2 = /test/i; // Ignora maiuscole/minuscole
    let regex3 = /test/g; // Ricerca globale
    let risultato = testo.match(regex3);
    console.log(risultato); // ['test']
    
    // Sostituire tutte le occorrenze di una parola con un'altra
    let frase = "La mela è rossa. La mela è dolce.";
    let nuovaFrase = frase.replace(/mela/g, "pera");
    console.log(nuovaFrase); // "La pera è rossa. La pera è dolce."
    
    // Validare un indirizzo email semplice
    let emailRegex = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/;
    let email = "test@example.com";
    console.log(emailRegex.test(email)); // true
                                

    // Creazione di un nuovo WeakMap
    let weakMap = new WeakMap();
    
    // Creazione di oggetti
    let obj1 = { nome: "Mario" };
    let obj2 = { nome: "Luigi" };
    
    // Aggiunta di coppie chiave-valore a WeakMap
    weakMap.set(obj1, "Informazioni private su Mario");
    weakMap.set(obj2, "Informazioni private su Luigi");
    
    // Recuperare il valore associato a un oggetto
    console.log(weakMap.get(obj1)); // "Informazioni private su Mario"
    
    // Verifica se una chiave esiste nel WeakMap
    console.log(weakMap.has(obj2)); // true
    
    // Rimozione di una coppia chiave-valore
    weakMap.delete(obj2);
    console.log(weakMap.has(obj2)); // false
    
    // Se obj1 non è più referenziato da nessuna parte nel codice, verrà rimosso automaticamente dalla memoria
                                

    // Creazione di un nuovo WeakSet
    let weakSet = new WeakSet();
    
    // Creazione di oggetti
    let obj1 = { nome: "Mario" };
    let obj2 = { nome: "Luigi" };
    
    // Aggiunta di oggetti a WeakSet
    weakSet.add(obj1);
    weakSet.add(obj2);
    
    // Verifica se un oggetto è presente nel WeakSet
    console.log(weakSet.has(obj1)); // true
    
    // Rimozione di un oggetto dal WeakSet
    weakSet.delete(obj2);
    console.log(weakSet.has(obj2)); // false
    
    // Se obj1 non è più referenziato da nessuna parte, verrà rimosso automaticamente dalla memoria
                                

    // Somma tra due numeri
    let a = 10;
    let b = 20;
    console.log(a + b); // Output: 30
    
    // Concatenazione di stringhe
    let nome = "Mario";
    let saluto = "Ciao, " + nome + "!";
    console.log(saluto); // Output: Ciao, Mario!
    
    // Coercizione implicita: concatenazione con un numero
    let anno = 2024;
    let messaggio = "Siamo nel " + anno;
    console.log(messaggio); // Output: Siamo nel 2024
    
    // Uso di template literal (miglior pratica)
    let messaggio2 = `Siamo nel ${anno}`;
    console.log(messaggio2); // Output: Siamo nel 2024
    
    // Attenzione alla coercizione implicita
    let risultato = "10" + 5;
    console.log(risultato); // Output: 105 (concatenazione, non somma)
                                

    // Sottrazione base
    let risultato = 10 - 5;  // risultato = 5
    
    // Sottrazione con decimali
    let decimali = 3.14 - 1.14;  // decimali = 2
    
    // Operatore di assegnazione con sottrazione
    let contatore = 10;
    contatore -= 3;  // contatore = 7
    
    // Sottrazione con date (timestamp)
    const data1 = new Date('2024-01-01');
    const data2 = new Date('2023-12-31');
    const differenzaGiorni = (data1 - data2) / (1000 * 60 * 60 * 24);  // 1
    
    // Gestione casi speciali
    console.log(10 - 'abc');  // NaN
    console.log(Infinity - Infinity);  // NaN
    console.log(10 - undefined);  // NaN
                                

    // Moltiplicazione base
    let prodotto = 5 * 3;  // prodotto = 15
    
    // Moltiplicazione con decimali
    let decimali = 2.5 * 3.2;  // decimali = 8
    
    // Operatore di assegnazione con moltiplicazione
    let valore = 4;
    valore *= 3;  // valore = 12
    
    // Calcolo percentuale
    let prezzo = 100;
    let sconto = 0.2;  // 20%
    let prezzoScontato = prezzo * (1 - sconto);  // 80
    
    // Casi speciali
    console.log(5 * Infinity);  // Infinity
    console.log(0 * Infinity);  // NaN
    console.log(5 * 'abc');     // NaN
    
    // Uso con BigInt
    let numeroBig = 9007199254740991n * 2n;  // Per numeri molto grandi
    
    // Scaling in grafica
    let scala = 2;
    let larghezza = 100;
    let altezza = 50;
    let nuovaLarghezza = larghezza * scala;  // 200
    let nuovaAltezza = altezza * scala;      // 100
                                

    // Divisione base
    let risultato = 10 / 2;  // risultato = 5
    
    // Divisione con decimali
    let decimale = 7 / 2;    // decimale = 3.5
    
    // Operatore di assegnazione con divisione
    let valore = 15;
    valore /= 3;  // valore = 5
    
    // Gestione della precisione decimale
    let prezzo = 10.99;
    let quantità = 3;
    let prezzoUnitario = (prezzo / quantità).toFixed(2);  // "3.66"
    
    // Casi speciali
    console.log(10 / 0);        // Infinity
    console.log(-10 / 0);       // -Infinity
    console.log(0 / 0);         // NaN
    console.log(Infinity / 2);  // Infinity
    
    // Conversione di unità
    function convertKmToMiles(km) {
        return km / 1.60934;
    }
    
    // Calcolo percentuali
    function calcolaPercentuale(parte, totale) {
        return (parte / totale * 100).toFixed(1) + '%';
    }
    
    // Divisione sicura con controllo del divisore
    function divisioneSicura(dividendo, divisore) {
        if (divisore === 0) {
            throw new Error('Divisione per zero non permessa');
        }
        return dividendo / divisore;
    }
    
    // Calcolo media
    function calcolaMedia(numeri) {
        return numeri.reduce((acc, val) => acc + val, 0) / numeri.length;
    }
                                

    // Calcolo base del resto
    console.log(10 % 3);  // 1
    console.log(15 % 4);  // 3
    
    // Verifica numero pari/dispari
    function isPari(numero) {
        return numero % 2 === 0;
    }
    
    // Limitare un numero in un range (utile per rotazioni)
    function limitaInRange(numero, max) {
        return numero % max;
    }
    
    // Implementazione di un orologio circolare (0-23)
    function getOra(ore) {
        return ore % 24;
    }
    
    // Distribuzione ciclica di elementi
    function distribuisciElemento(indice, numeroColonne) {
        return {
            riga: Math.floor(indice / numeroColonne),
            colonna: indice % numeroColonne
        };
    }
    
    // Creazione pattern ripetitivo
    function creaPattern(posizione, lunghezzaPattern) {
        return posizione % lunghezzaPattern;
    }
    
    // Gestione di indici circolari in un array
    function getElementoCircolare(array, indice) {
        return array[indice % array.length];
    }
    
    // Esempi con numeri negativi
    console.log(-10 % 3);   // -1
    console.log(10 % -3);   // 1
    console.log(-10 % -3);  // -1
    
    // Uso con operatore di assegnazione
    let numero = 10;
    numero %= 3;  // numero = 1
    
    // Validazione input numerico
    function validaInput(numero, max) {
        if (numero % 1 !== 0) {
            throw new Error('Il numero deve essere intero');
        }
        return numero % max;
    }
    
    // Generazione colori alternati
    function getColoreAlternato(indice) {
        return indice % 2 === 0 ? '#fff' : '#f0f0f0';
    }
                                

    // Esponenziazione base
    console.log(2 ** 3);    // 8
    console.log(10 ** 2);   // 100
    
    // Con numeri decimali
    console.log(2.5 ** 2);  // 6.25
    console.log(16 ** 0.5); // 4 (radice quadrata)
    
    // Esponenti negativi
    console.log(2 ** -2);   // 0.25
    console.log(10 ** -1);  // 0.1
    
    // Operatore di assegnazione
    let numero = 2;
    numero **= 3;  // numero = 8
    
    // Calcolo area cerchio
    function areaCircolo(raggio) {
        return Math.PI * (raggio ** 2);
    }
    
    // Crescita composta
    function crescitaComposta(principale, tasso, anni) {
        return principale * ((1 + tasso) ** anni);
    }
    
    // Calcolo scala logaritmica
    function valoreScalaLog(base, livello) {
        return base ** livello;
    }
    
    // Conversione unità
    function convertiPotenzeDiDieci(numero, esponente) {
        return numero * (10 ** esponente);
    }
    
    // Gestione errori
    function potenzaSicura(base, esponente) {
        if (base === 0 && esponente < 0) {
            throw new Error('Divisione per zero non permessa');
        }
        return base ** esponente;
    }
    
    // Calcolo radici n-esime
    function radiceNesima(numero, n) {
        return numero ** (1/n);
    }
    
    // Esempi con BigInt
    console.log(2n ** 3n);  // 8n
    console.log(10n ** 2n); // 100n
    
    // Calcolo distanza euclidea
    function distanzaEuclidea(x1, y1, x2, y2) {
        return ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5;
    }
                                

    // Incremento base
    let contatore = 0;
    contatore++;     // contatore = 1
    ++contatore;     // contatore = 2
    
    // Differenza tra prefisso e suffisso
    let a = 1;
    let b = a++;    // b = 1, a = 2
    let c = ++a;    // c = 3, a = 3
    
    // Uso in cicli for
    for (let i = 0; i < 5; i++) {
        console.log(i);  // Stampa 0,1,2,3,4
    }
    
    // Iterazione su array
    const array = ['a', 'b', 'c'];
    let index = 0;
    while (index < array.length) {
        console.log(array[index++]);
    }
    
    // Contatore personalizzato
    function createCounter() {
        let count = 0;
        return {
            increment: () => ++count,
            getValue: () => count
        };
    }
    
    // Gestione di sequenze
    function* numberSequence() {
        let num = 0;
        while (true) {
            yield ++num;
        }
    }
    
    // Implementazione di un iteratore
    class Iterator {
        constructor(start = 0) {
            this.value = start;
        }
        
        next() {
            return this.value++;
        }
    }
    
    // Gestione di indici circolari
    function circularIndex(current, max) {
        return (current + 1) % max;
    }
    
    // Contatore con limite
    function boundedIncrement(value, max) {
        return value < max ? ++value : value;
    }
                                

    // Decremento prefisso
    let a = 5;
    let b = --a; // a = 4, b = 4
    
    // Decremento postfisso
    let x = 5;
    let y = x--; // x = 4, y = 5
    
    // Uso in un ciclo
    for (let i = 10; i > 0; i--) {
        console.log(i); // Conto alla rovescia da 10 a 1
    }
    
    // Uso come contatore
    let counter = 3;
    while (counter--) {
        console.log('Iterazione rimanente:', counter);
    }
                                

    // Assegnazione di un valore numerico
    let x = 10;
    
    // Assegnazione di una stringa
    let name = "Mario";
    
    // Assegnazione del risultato di un'operazione
    let sum = 5 + 3;
    
    // Assegnazione di una funzione a una variabile
    let greet = function() {
        console.log("Ciao!");
    };
                                

    // Confronto tra numero e stringa
    console.log(5 == '5'); // true, a causa della coercizione
    
    // Confronto tra booleano e numero
    console.log(true == 1); // true, true viene convertito in 1
    
    // Confronto tra null e undefined
    console.log(null == undefined); // true, questi due valori sono considerati uguali in questo contesto
    
    // Confronto che genera un risultato inatteso
    console.log(0 == false); // true, a causa della coercizione implicita
                                

    // Confronto tra numero e stringa
    console.log(5 === '5'); // false, tipi diversi (numero e stringa)
    
    // Confronto tra numeri
    console.log(5 === 5); // true, stesso valore e stesso tipo
    
    // Confronto tra booleano e numero
    console.log(true === 1); // false, tipi diversi (booleano e numero)
    
    // Confronto tra null e undefined
    console.log(null === undefined); // false, tipi diversi
    
    // Confronto tra oggetti (riferimenti)
    let obj1 = { a: 1 };
    let obj2 = { a: 1 };
    console.log(obj1 === obj2); // false, riferimenti a oggetti diversi
                                

    // Confronto tra numero e stringa
    console.log(5 != '5'); // false, coercizione: '5' viene convertita in numero
    
    // Confronto tra booleano e numero
    console.log(true != 1); // false, coercizione: true viene convertito in 1
    
    // Confronto tra null e undefined
    console.log(null != undefined); // false, null e undefined sono considerati equivalenti in questo caso
    
    // Confronto tra numero e booleano
    console.log(0 != false); // false, coercizione: false viene convertito in 0
                                

    // Confronto tra numero e stringa
    console.log(5 !== '5'); // true, tipi diversi (numero e stringa)
    
    // Confronto tra booleano e numero
    console.log(true !== 1); // true, tipi diversi (booleano e numero)
    
    // Confronto tra numeri uguali
    console.log(5 !== 5); // false, stesso valore e stesso tipo
    
    // Confronto tra null e undefined
    console.log(null !== undefined); // true, tipi diversi
    
    // Confronto tra oggetti
    let obj1 = { a: 1 };
    let obj2 = { a: 1 };
    console.log(obj1 !== obj2); // true, diversi riferimenti in memoria
                                

    // Controllo di due condizioni
    let isAuthenticated = true;
    let hasAccess = true;
    if (isAuthenticated && hasAccess) {
        console.log('Accesso consentito');
    } else {
        console.log('Accesso negato');
    }
    
    // Valore "falsy" in una catena di espressioni
    console.log(null && 'Hello'); // Restituisce null, primo valore "falsy"
    
    // Tutti valori "truthy"
    console.log('Hello' && 123 && true); // Restituisce true, ultimo valore valutato
                                

    // Uso per fornire un valore di default
    let userName = userInput || 'Guest';
    console.log(userName); // Restituisce 'Guest' se userInput è falsy
    
    // Valore "truthy" in una catena di espressioni
    console.log('Hello' || null); // Restituisce 'Hello', primo valore "truthy"
    
    // Tutti valori "falsy"
    console.log(null || 0 || ''); // Restituisce '', ultimo valore valutato
    
    // Short-circuiting: evita esecuzione di funzioni costose
    let isLoggedIn = true;
    isLoggedIn || expensiveFunction(); // La funzione non viene chiamata
                                

    // Inversione di una condizione
    let isOnline = false;
    if (!isOnline) {
        console.log('L\'utente non è online');
    }
    
    // Conversione di un valore in booleano
    let inputValue = 'Hello';
    console.log(!inputValue); // false, perché 'Hello' è "truthy"
    
    // Doppia negazione per ottenere un valore booleano
    console.log(!!inputValue); // true, forza la conversione in booleano
    
    // Uso in un'espressione complessa
    let isLoggedIn = true;
    let hasAccess = false;
    if (!(isLoggedIn && hasAccess)) {
        console.log('Accesso negato');
    }
                                

    // Assegnazione di un valore in base a una condizione
    let age = 18;
    let canVote = age >= 18 ? 'Può votare' : 'Non può votare';
    console.log(canVote); // 'Può votare'
    
    // Operazione condizionale in una funzione
    function getDiscount(price) {
        return price > 100 ? 'Sconto del 10%' : 'Nessuno sconto';
    }
    console.log(getDiscount(120)); // 'Sconto del 10%'
    
    // Uso con valori "truthy" e "falsy"
    let userName = null;
    let displayName = userName ? userName : 'Ospite';
    console.log(displayName); // 'Ospite'
    
    // Valore predefinito con operatore OR
    let inputValue = '';
    let output = inputValue || 'Valore di default';
    console.log(output); // 'Valore di default'
                                

    // Accesso sicuro a una proprietà annidata
    let user = { profile: { name: 'Mario' } };
    console.log(user.profile?.name); // 'Mario'
    console.log(user.address?.city); // undefined, 'address' non esiste
    
    // Chiamata di una funzione in modo sicuro
    let obj = { greet: () => 'Ciao' };
    console.log(obj.greet?.()); // 'Ciao'
    console.log(obj.sayGoodbye?.()); // undefined, 'sayGoodbye' non esiste
    
    // Accesso sicuro agli elementi di un array
    let fruits = null;
    console.log(fruits?.[0]); // undefined, 'fruits' è null
    
    // Combinazione con l'operatore di coalescenza nulla
    let result = user.profile?.age ?? 'Età sconosciuta';
    console.log(result); // 'Età sconosciuta', 'age' non è definito
                                

    // Assegnazione di un valore di default
    let userAge = null;
    let age = userAge ?? 18;
    console.log(age); // 18, perché userAge è null
    
    // Valore "falsy" considerato valido
    let input = '';
    let value = input ?? 'Valore di default';
    console.log(value); // '', perché input non è null o undefined
    
    // Combinazione con l'operatore di concatenazione opzionale
    let user = { preferences: { theme: null } };
    let theme = user.preferences?.theme ?? 'light';
    console.log(theme); // 'light', perché il tema è null
    
    // Differenza rispetto all'operatore OR
    let count = 0;
    let result = count || 10;
    console.log(result); // 10, perché 0 è "falsy"
    
    result = count ?? 10;
    console.log(result); // 0, perché count non è null o undefined
                                

    // Copiare un array
    let originalArray = [1, 2, 3];
    let copiedArray = [...originalArray];
    console.log(copiedArray); // [1, 2, 3]
    
    // Concatenare array
    let array1 = [1, 2];
    let array2 = [3, 4];
    let concatenatedArray = [...array1, ...array2];
    console.log(concatenatedArray); // [1, 2, 3, 4]
    
    // Aggiungere elementi a un array
    let arrayWithExtra = [...originalArray, 4, 5];
    console.log(arrayWithExtra); // [1, 2, 3, 4, 5]
    
    // Clonare un oggetto
    let originalObject = { a: 1, b: 2 };
    let copiedObject = { ...originalObject };
    console.log(copiedObject); // { a: 1, b: 2 }
    
    // Unire oggetti
    let obj1 = { a: 1 };
    let obj2 = { b: 2 };
    let mergedObject = { ...obj1, ...obj2 };
    console.log(mergedObject); // { a: 1, b: 2 }
    
    // Usare con funzioni
    function sum(x, y, z) {
        return x + y + z;
    }
    let numbers = [1, 2, 3];
    console.log(sum(...numbers)); // 6
                                

    // Verifica del tipo di una variabile
    let name = 'Alice';
    console.log(typeof name); // "string"
    
    // Controllo di una funzione
    function greet() {
        return 'Hello!';
    }
    console.log(typeof greet); // "function"
    
    // Controllo di una variabile non definita
    let age;
    console.log(typeof age); // "undefined"
    
    // Uso con null (anomalia storica)
    let value = null;
    console.log(typeof value); // "object", anche se dovrebbe essere "null"
    
    // Verifica di un numero
    let count = 10;
    console.log(typeof count); // "number"
    
    // Controllo di un booleano
    let isActive = true;
    console.log(typeof isActive); // "boolean"
                                

    // Verifica di un'istanza di una classe
    class Person {
        constructor(name) {
            this.name = name;
        }
    }
    let john = new Person('John');
    console.log(john instanceof Person); // true
    
    // Verifica con classi native
    let date = new Date();
    console.log(date instanceof Date); // true
    console.log(date instanceof Object); // true, Date eredita da Object
    
    // Oggetto semplice non istanza di una classe
    let obj = {};
    console.log(obj instanceof Person); // false
    
    // Funzione costruttore
    function Car(make) {
        this.make = make;
    }
    let myCar = new Car('Toyota');
    console.log(myCar instanceof Car); // true
    
    // Verifica su tipi primitivi
    console.log('Hello' instanceof String); // false, le stringhe primitive non sono istanze di String
                                

    // Controllo di una condizione
    let age = 18;
    if (age >= 18) {
        console.log('Può votare');
    }
    
    // Uso di if con else
    let score = 75;
    if (score >= 60) {
        console.log('Promosso');
    } else {
        console.log('Bocciato');
    }
    
    // Uso di else if per più condizioni
    let temperature = 30;
    if (temperature > 30) {
        console.log('Fa molto caldo');
    } else if (temperature < 15) {
        console.log('Fa freddo');
    } else {
        console.log('Temperatura piacevole');
    }
    
    // Condizioni annidate
    let isLoggedIn = true;
    let hasAccess = false;
    if (isLoggedIn) {
        if (hasAccess) {
            console.log('Accesso consentito');
        } else {
            console.log('Accesso negato');
        }
    }
                                

    // Uso semplice di if-else
    let score = 55;
    if (score >= 60) {
        console.log('Promosso');
    } else {
        console.log('Bocciato');
    }
    
    // Uso di else come fallback
    let isLoggedIn = false;
    if (isLoggedIn) {
        console.log('Benvenuto!');
    } else {
        console.log('Accesso negato. Effettua il login.');
    }
                                

    // Uso di else if per più condizioni
    let grade = 85;
    if (grade >= 90) {
        console.log('Ottimo');
    } else if (grade >= 70) {
        console.log('Buono');
    } else if (grade >= 50) {
        console.log('Sufficiente');
    } else {
        console.log('Insufficiente');
    }
                                

    // Uso di switch per controllare il giorno della settimana
    let day = 3;
    switch (day) {
        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;
        default:
            console.log('Fine settimana');
    }
                                

    // Uso di break in un ciclo for
    for (let i = 0; i < 10; i++) {
        if (i === 5) {
            break; // Esce dal ciclo quando i è uguale a 5
        }
        console.log(i);
    }
    
    // Uso di break in un blocco switch
    let day = 3;
    switch (day) {
        case 1:
            console.log('Lunedì');
            break;
        case 2:
            console.log('Martedì');
            break;
        case 3:
            console.log('Mercoledì');
            break; // Esce dopo aver trovato il caso corrispondente
        default:
            console.log('Giorno non valido');
    }
                                

    // Uso di continue in un ciclo for
    for (let i = 0; i < 10; i++) {
        if (i % 2 === 0) {
            continue; // Salta i numeri pari
        }
        console.log(i); // Stampa solo i numeri dispari
    }
    
    // Uso di continue in un ciclo while
    let j = 0;
    while (j < 5) {
        j++;
        if (j === 3) {
            continue; // Salta quando j è uguale a 3
        }
        console.log(j);
    }
                                

    // Uso di return per restituire un valore
    function add(a, b) {
        return a + b;
    }
    console.log(add(5, 3)); // 8
    
    // Uso di return per uscire da una funzione
    function checkAge(age) {
        if (age < 18) {
            return 'Minorenne';
        }
        return 'Maggiorenne';
    }
    console.log(checkAge(17)); // 'Minorenne'
    
    // Return senza valore esplicito
    function doNothing() {
        return;
    }
    console.log(doNothing()); // undefined
                                

// Ciclo for classico
for (let i = 0; i < 5; i++) {
    console.log("Iterazione numero: " + i);
}
// Output:
// Iterazione numero: 0
// Iterazione numero: 1
// Iterazione numero: 2
// Iterazione numero: 3
// Iterazione numero: 4

// Iterazione su array
let colori = ["rosso", "verde", "blu"];
for (let i = 0; i < colori.length; i++) {
    console.log(colori[i]);
}
// Output:
// rosso
// verde
// blu
                

let i = 0;
while (i < 5) {
    console.log("Iterazione numero: " + i);
    i++;
}
// Output:
// Iterazione numero: 0
// Iterazione numero: 1
// Iterazione numero: 2
// Iterazione numero: 3
// Iterazione numero: 4
                

let i = 0;
do {
    console.log("Iterazione numero: " + i);
    i++;
} while (i < 5);
// Output:
// Iterazione numero: 0
// Iterazione numero: 1
// Iterazione numero: 2
// Iterazione numero: 3
// Iterazione numero: 4

// Esempio input simulato
let input;
do {
    input = prompt("Inserisci un numero maggiore di 10");
} while (input <= 10);
                

const persona = { nome: "Mario", età: 30, città: "Roma" };

for (let chiave in persona) {
    if (Object.hasOwn(persona, chiave)) {
        console.log(chiave + ": " + persona[chiave]);
    }
}
// Output (ordine non garantito):
// nome: Mario
// età: 30
// città: Roma
                

// Iterazione su array
const colori = ["rosso", "verde", "blu"];
for (let colore of colori) {
    console.log(colore);
}
// Output:
// rosso
// verde
// blu

// Iterazione su stringa
for (let carattere of "Ciao") {
    console.log(carattere);
}
// Output:
// C
// i
// a
// o
                

// Arrow function base
const somma = (a, b) => a + b;
console.log(somma(3, 4)); // Output: 7

// Arrow function con corpo esplicito
const saluta = (nome) => {
    return `Ciao, ${nome}!`;
};
console.log(saluta("Mario")); // Output: Ciao, Mario!
                

// Funzione che accetta una callback
function saluta(nome, callback) {
    console.log(`Ciao, ${nome}!`);
    callback();
}

// Uso di una callback
saluta("Mario", () => {
    console.log("Benvenuto nel sito!");
});
// Output:
// Ciao, Mario!
// Benvenuto nel sito!
                

// IIFE classica
(function() {
    console.log("Questa funzione si esegue subito!");
})();

// IIFE con arrow function
(() => {
    const messaggio = "Scope isolato";
    console.log(messaggio);
})();
                

function contatore() {
    let count = 0;
    return function() {
        count++;
        return count;
    };
}

const incrementa = contatore();
console.log(incrementa()); // 1
console.log(incrementa()); // 2
console.log(incrementa()); // 3
                

function saluta(nome = "Ospite") {
    console.log(`Ciao, ${nome}!`);
}

saluta();        // Output: Ciao, Ospite!
saluta("Mario"); // Output: Ciao, Mario!
                

function somma(...numeri) {
    return numeri.reduce((totale, num) => totale + num, 0);
}

console.log(somma(1, 2, 3));       // Output: 6
console.log(somma(4, 5, 6, 7, 8)); // Output: 30
                

const persona = {
    nome: "Mario",
    saluta: function() {
        console.log(`Ciao, sono ${this.nome}`);
    }
};

persona.saluta(); // Output: Ciao, sono Mario
                

const animale = {
    respira() {
        console.log("Respiro...");
    }
};

const cane = Object.create(animale);
cane.abbaia = function() {
    console.log("Bau!");
};

cane.respira(); // Output: Respiro...
cane.abbaia();  // Output: Bau!
                

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };

const risultato = Object.assign({}, obj1, obj2);
console.log(risultato); // Output: { a: 1, b: 3, c: 4 }
                

const persona = { nome: "Mario", età: 30, città: "Roma" };
console.log(Object.keys(persona));
// Output: ["nome", "età", "città"]
                

const persona = { nome: "Mario", età: 30, città: "Roma" };
console.log(Object.values(persona));
// Output: ["Mario", 30, "Roma"]
                

const persona = { nome: "Mario", età: 30, città: "Roma" };
for (let [chiave, valore] of Object.entries(persona)) {
    console.log(`${chiave}: ${valore}`);
}
// Output:
// nome: Mario
// età: 30
// città: Roma
                

const config = { tema: "scuro", lingua: "it" };
Object.freeze(config);

config.tema = "chiaro"; // Non ha effetto
console.log(config.tema); // Output: scuro
                

const persona = { nome: "Mario", età: 30 };
Object.seal(persona);

persona.nome = "Luca"; // Modifica consentita
delete persona.età;     // Non ha effetto

console.log(persona); // Output: { nome: "Luca", età: 30 }
                

const persona = { nome: "Mario" };

console.log(Object.hasOwn(persona, "nome")); // true
console.log(Object.hasOwn(persona, "età"));  // false
                

// Da oggetto
const persona = { nome: "Mario", età: 30 };
const { nome, età } = persona;
console.log(nome, età); // Output: Mario 30

// Da array
const colori = ["rosso", "verde", "blu"];
const [primo, secondo] = colori;
console.log(primo, secondo); // Output: rosso verde
                

const nome = "Mario";
const età = 30;

// Sintassi abbreviata
const persona = { nome, età };
console.log(persona); // Output: { nome: "Mario", età: 30 }
                

const prop = "età";
const persona = {
    nome: "Mario",
    [prop]: 30
};

console.log(persona); // Output: { nome: "Mario", età: 30 }
                

const numeri = [1, 2, 3];
numeri.push(4);
console.log(numeri); // Output: [1, 2, 3, 4]
                

const numeri = [1, 2, 3];
const ultimo = numeri.pop();
console.log(ultimo); // Output: 3
console.log(numeri); // Output: [1, 2]
                

const numeri = [1, 2, 3];
const primo = numeri.shift();
console.log(primo); // Output: 1
console.log(numeri); // Output: [2, 3]
                

const numeri = [2, 3];
numeri.unshift(1);
console.log(numeri); // Output: [1, 2, 3]
                

const numeri = [1, 2, 3, 4, 5];
const parte = numeri.slice(1, 4);
console.log(parte);   // Output: [2, 3, 4]
console.log(numeri);  // Output: [1, 2, 3, 4, 5]
                

const colori = ["rosso", "verde", "blu"];

// Rimuovi 1 elemento da index 1
const rimossi = colori.splice(1, 1);
console.log(rimossi); // ["verde"]
console.log(colori);  // ["rosso", "blu"]

// Inserisci senza rimuovere (deleteCount = 0)
colori.splice(1, 0, "giallo", "viola");
console.log(colori); // ["rosso", "giallo", "viola", "blu"]

// Sostituisci 1 elemento con 2
colori.splice(2, 1, "nero", "bianco");
console.log(colori); // ["rosso", "giallo", "nero", "bianco", "blu"]
                

const numeri = [1, 2, 3];
const raddoppiati = numeri.map(n => n * 2);
console.log(raddoppiati); // [2, 4, 6]
console.log(numeri);      // [1, 2, 3] (immutato)
                

const numeri = [1, 2, 3, 4, 5, 6];
const pari = numeri.filter(n => n % 2 === 0);
console.log(pari);   // [2, 4, 6]
console.log(numeri); // [1, 2, 3, 4, 5, 6]
                

// Somma
const numeri = [1, 2, 3, 4];
const somma = numeri.reduce((acc, n) => acc + n, 0);
console.log(somma); // 10

// Raggruppa per proprietà
const utenti = [
  { nome: "Ana", ruolo: "admin" },
  { nome: "Bea", ruolo: "user" },
  { nome: "Cal", ruolo: "user" }
];
const perRuolo = utenti.reduce((acc, u) => {
  (acc[u.ruolo] ??= []).push(u.nome);
  return acc;
}, {});
console.log(perRuolo); // { admin: ["Ana"], user: ["Bea", "Cal"] }
                

const colori = ["rosso", "verde", "blu"];
colori.forEach((colore, i) => {
  console.log(`${i}: ${colore}`);
});
// Output:
// 0: rosso
// 1: verde
// 2: blu
                

const utenti = [
  { nome: "Luca", attivo: false },
  { nome: "Anna", attivo: true },
  { nome: "Marta", attivo: true }
];
const primoAttivo = utenti.find(u => u.attivo);
console.log(primoAttivo); // { nome: "Anna", attivo: true }
                

const numeri = [5, 12, 8, 130, 44];
const indice = numeri.findIndex(n => n > 100);
console.log(indice); // 3
                

const numeri = [1, 2, 3, 4, 5];
console.log(numeri.some(n => n > 4)); // true
                

const numeri = [2, 4, 6];
console.log(numeri.every(n => n % 2 === 0)); // true
                

const frutti = ["mela", "banana", "pera"];
console.log(frutti.includes("banana")); // true
console.log(frutti.includes("kiwi"));   // false
                

try {
  let dati = JSON.parse('{"nome": "Luca"}');
  console.log(dati.nome);
} catch (errore) {
  console.error("Errore nel parsing:", errore.message);
}
                

function dividi(a, b) {
  if (b === 0) {
    throw new Error("Divisione per zero non consentita");
  }
  return a / b;
}

try {
  console.log(dividi(10, 0));
} catch (err) {
  console.error("Errore:", err.message);
}
                

try {
  console.log("Apro connessione...");
  throw new Error("Errore di rete");
} catch (e) {
  console.error(e.message);
} finally {
  console.log("Chiudo connessione");
}
                

try {
  throw new Error("Qualcosa è andato storto");
} catch (e) {
  console.error(e.name);    // "Error"
  console.error(e.message); // "Qualcosa è andato storto"
}
                

setTimeout(() => {
  console.log("Eseguito dopo 2 secondi");
}, 2000);
                

const id = setInterval(() => {
  console.log("Ogni 1 secondo");
}, 1000);

// Interrompi dopo 5 secondi
setTimeout(() => clearInterval(id), 5000);
                

const promessa = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("Operazione completata");
  }, 1000);
});

promessa
  .then(risultato => console.log(risultato))
  .catch(err => console.error("Errore:", err));
                

async function saluta() {
  return "Ciao!";
}

saluta().then(console.log); // Output: Ciao!
                

async function esempio() {
  try {
    const risultato = await Promise.resolve("Fatto!");
    console.log(risultato);
  } catch (err) {
    console.error("Errore:", err);
  }
}

esempio();
                

async function prendiDati() {
  try {
    const risposta = await fetch("https://jsonplaceholder.typicode.com/posts/1");
    const dati = await risposta.json();
    console.log(dati);
  } catch (errore) {
    console.error("Errore nella richiesta:", errore);
  }
}

prendiDati();
                

const bottone = document.querySelector("#mioBottone");

function saluta() {
  console.log("Ciao!");
}

bottone.addEventListener("click", saluta);
                

function saluta() {
  console.log("Ciao!");
}

const bottone = document.querySelector("#mioBottone");

bottone.addEventListener("click", saluta);

// Rimuove il listener dopo 5 secondi
setTimeout(() => {
  bottone.removeEventListener("click", saluta);
}, 5000);
                

// HTML: <button id="openModal">Apri</button>
const btn = document.querySelector("#openModal");
btn.addEventListener("click", (event) => {
  console.log("Attivato!", event.type);
});
        

document.addEventListener("keydown", (e) => {
  if (e.key === "Escape") {
    console.log("Chiudi modale");
    e.preventDefault();
  }
  if (e.key === "s" && (e.ctrlKey || e.metaKey)) {
    console.log("Salvataggio rapido");
    e.preventDefault();
  }
});
        

// HTML: <form id="contact">...</form>
const form = document.querySelector("#contact");

form.addEventListener("submit", async (e) => {
  e.preventDefault();
  const dati = new FormData(form);
  try {
    const res = await fetch("/api/contatti", { method: "POST", body: dati });
    if (!res.ok) throw new Error("Errore di invio");
    console.log("Inviato!");
  } catch (err) {
    console.error(err);
  }
});
        

document.addEventListener("click", (event) => {
  console.log(event.type);           // "click"
  console.log(event.target);         // nodo reale cliccato
  console.log(event.currentTarget);  // dove è agganciato il listener (document)
  if (event.defaultPrevented) {
    console.log("Default già prevenuto");
  }
});
        

// HTML: <div id="parent"><button id="child">Clicca</button></div>
const parent = document.querySelector("#parent");
const child = document.querySelector("#child");

parent.addEventListener("click", () => console.log("Parent (bubbling)"));
child.addEventListener("click", () => console.log("Child (target)"));
// Output tipico cliccando il bottone: "Child (target)" poi "Parent (bubbling)"
        

// HTML: <ul id="todo">...</ul>
// Delego il click sui bottoni .remove dentro la lista
const list = document.querySelector("#todo");

list.addEventListener("click", (e) => {
  const btn = e.target.closest("button.remove");
  if (!btn) return; // click non rilevante
  const item = btn.closest("li");
  item?.remove();
});
        

// HTML: <div id="hero">Ciao</div>
const hero = document.getElementById("hero");
if (hero) {
  hero.textContent = "Benvenuto!";
}
        

// HTML: <ul id="menu"><li class="active">Home</li>...</ul>
const activeItem = document.querySelector("#menu li.active");
activeItem?.classList.remove("active");
        

// HTML: <button class="filter">...</button> (x N)
const buttons = document.querySelectorAll("button.filter");
for (const btn of buttons) {
  btn.addEventListener("click", () => btn.classList.toggle("active"));
}
        

// HTML: <div id="out"></div>
const out = document.querySelector("#out");
out.innerHTML = `<h2>Titolo</h2><p>Contenuto</p>`;
        

// HTML: <p id="msg"></p>
document.getElementById("msg").textContent = "Ciao <strong>mondo</strong>!";
// Renderizza letteralmente i tag, non li interpreta
        

const li = document.createElement("li");
li.className = "todo-item";
li.textContent = "Studiare DOM";
document.querySelector("#todo").appendChild(li);
        

const list = document.querySelector("#todo");
const item = document.createElement("li");
item.textContent = "Fare pratica";
list.appendChild(item);
        

const list = document.querySelector("#todo");
const first = list.querySelector("li");
if (first) {
  list.removeChild(first);
}
        

// HTML: <img id="pic">
const img = document.getElementById("pic");
img.setAttribute("alt", "Foto profilo");
img.setAttribute("src", "/img/me.jpg");
        

// HTML: <div id="panel" class="panel"></div>
const panel = document.getElementById("panel");
panel.classList.add("is-open");
panel.classList.toggle("highlight");
if (panel.classList.contains("is-open")) {
  panel.classList.replace("is-open", "is-visible");
}
        

// utils.js
export function somma(a, b) { return a + b; }
export const PI = 3.14159;
export default class Logger { log(x) { console.log(x); } }

// main.js
import Logger, { somma, PI as pi } from "./utils.js";
const log = new Logger();
log.log(somma(2, 3), pi);

// import dinamico (code-splitting)
document.getElementById("btn").addEventListener("click", async () => {
  const mod = await import("./heavy-widget.js");
  mod.mountWidget();
});
        

// math.js
export const TAU = Math.PI * 2;
export function clamp(n, min, max) { return Math.min(Math.max(n, min), max); }
export default function media(...nums) {
  return nums.reduce((a,n) => a + n, 0) / nums.length;
}

// alt-reexport.js
export { clamp as limit } from "./math.js";
export * as math from "./math.js";
        

// modal.js
export default class Modal {
  open(){ /* ... */ }
  close(){ /* ... */ }
}
export function createModal(){ return new Modal(); }

// app.js
import Modal, { createModal } from "./modal.js";
const m = new Modal();
const m2 = createModal();
        

// date.js
export function parse(str){ /* ... */ }
export function format(date){ /* ... */ }
export const ONE_DAY = 86400000;

// usage.js
import { parse, format, ONE_DAY as DAY } from "./date.js";
const d = parse("2025-08-15");
console.log(format(d), DAY);
        

"use strict";
x = 10; // Errore: x non dichiarata
        

saluta(); // Funziona
function saluta() { console.log("Ciao"); }

console.log(x); // undefined (hoisting var)
var x = 5;
        

console.log(a); // ReferenceError
let a = 3;
        

let bigData = { huge: "..." };
bigData = null; // Ora l’oggetto è liberabile dal GC
        

function Animale(nome) {
  this.nome = nome;
}
Animale.prototype.parla = function() {
  console.log(this.nome + " fa un verso");
};

const cane = new Animale("Fido");
cane.parla(); // "Fido fa un verso"
console.log(Object.getPrototypeOf(cane) === Animale.prototype); // true