Ir al contenido

LETTURA PRELIMINARE

Blocco 02. Frontend con HTML, CSS e JavaScript

0letture

Modulo 02. Frontend con HTML, CSS e JavaScript

Introduzione

In questo blocco impariamo a combinare le 3 tecnologie fondamentali del frontend.

HTML: Il linguaggio di markup che definisce la struttura e la semantica del contenuto (lo scheletro del web).

CSS: Il linguaggio di stile CSS che definisce l'aspetto visivo del contenuto (il design del web).

JavaScript: Il linguaggio di programmazione che permette di modificare il contenuto dinamicamente e di interagire con l'utente (il cervello del web).

Ci concentreremo sullo scoprire il potenziale del JavaScript moderno (ES6+) per creare applicazioni web interattive. JavaScript è il linguaggio che dà vita al frontend, consente:

  • Catturare eventi e rispondere alle azioni dell'utente
  • Manipolare il contenuto in modo dinamico e in tempo reale.
  • Comunicare con il backend utilizzando moduli o API.

Faremo una revisione dei concetti fondamentali di programmazione e concluderemo con la creazione di un piccolo videogioco web. Lavoreremo su concetti chiave come la manipolazione del DOM, la gestione degli eventi, la programmazione orientata agli oggetti, la gestione dei JSON e il consumo di API.

Concetti di base di JavaScript (Ripasso)

Variabili e Costanti

JavaScript utilizza le parole riservate let e const per dichiarare variabili e costanti.

Ventana de terminal
// Constants (el seu contingut no es podrà modificar)
const MAX_VIDES = 3;
const NOM_JOC = "Shooter 2D";
const NUM_ENEMICS = 5;
// Variables (els seus valors assignats i tipus poden canviar durant l'execució)
let punts = 0;
let nivell = 1;
let vides = MAX_VIDES;
punts = 50;

Tipi di dati

JavaScript è dinamico, determina automaticamente il tipo di dato in base al valore assegnato alle costanti o alle variabili. Questi possono essere:

  • Tipi di dati primitivi: String, Number, Boolean, Null, Undefined
  • Tipi di dati composti: Array, Funzioni, Date, ecc.
// Tipus Primitius
let nom = "Jugador"; // String
let punts = 50; // Number
let estaDisparant = false; // Boolean
let nickname = null; // Null
let velocitat; // Undefined
// Vectors (Arrays)
const enemics = ["TieFighter", "StarDestroyer", "DeathStar"];
const puntuacions = [50, 100, 300];
// Objecte literal (Objectes simples creats pel desenvolupador)
const jugador = {
nom: "X-Wing",
vides: 3,
punts: 0,
energia: 100,
posicio: { x: 250, y: 450 }, // "posició" seria un altre objecte
armes: ["laser", "metralleta"]
};

Operatori aritmetici, relazionali e logici

Operatori aritmetici: Consentono di eseguire operazioni matematiche con valori numerici, costanti e variabili.

  • + (Somma): Somma due valori.
  • - (Sottrazione): Sottrae due valori.
  • * (Moltiplicazione): Moltiplica due valori.
  • / (Divisione): Divide due valori.
  • % (Modulo): Restituisce il resto della divisione tra due valori.
  • ** (Esponente): Eleva un valore a una potenza.
  • ++ (Incremento): Aumenta il valore di una variabile di 1.
  • -- (Decremento): Diminuisce il valore di una variabile di 1.
  • + (Concatenazione stringhe): Vecchio metodo per concatenare le stringhe.

Operatori Relazionali: Consentono di confrontare valori. Determinano se il risultato dell'operazione è vero o falso.

  • == (Uguale a): Verifica se due valori sono uguali (tiene conto solo del valore).
  • === (Uguale stretto): Verifica se due valori sono esattamente uguali (il valore e il tipo).
  • != (Diverso da): Verifica se due valori non sono uguali (tiene conto solo del valore).
  • !== (Diverso stretto): Verifica se due valori non sono uguali (il valore e il tipo).
  • > (Maggiore di): Controlla se il primo valore è maggiore del secondo valore.
  • < (Minore di): Verifica se il primo valore è più piccolo del secondo valore.
  • >= (Maggiore o uguale a): Controlla se il primo valore è maggiore o uguale al secondo valore.
  • <= (Minore o uguale a): Verifica se il primo valore è minore o uguale al secondo valore.

Operatori logici: Permettono di combinare condizioni e determinare il loro risultato finale (vero o falso).

  • && (AND): Verifica se le condizioni sono vere. Ritorna vero o falso in caso contrario.
  • || (OR): Verifica se almeno una condizione è vera. Restituisce vero o falso in caso contrario.
  • ! (NOT): Inverte il valore di una condizione. Restituisce vero se la condizione è falsa e viceversa.
Ventana de terminal
// Aritmètics
let puntsTotal = punts + (bonus * nivell);
let videsTotals = vides - errades;
const statusJugador = "Pepet: " + puntsTotal;
// Relacionals
let haGuanyat = punts >= puntsPerfecte;
let finalJoc = nivell === MAX_NIVELLS;
// Lògics
let potAtacar = vides >= 0 && municio > 0;
let negacio = !estaViu;
let continuaJoc = punts >= 0 || estaViu;

Strutture di controllo condizionali

JavaScript può prendere decisioni su quale blocco di codice eseguire in base al risultato di operazioni aritmetiche, relazionali e logiche.

// (if) Executa el bloc de codi si es compleix la condició
// (else) Executa el bloc de codi si no es compleix la condició
if (vides > 0 && punts >= 50) {
vides--;
punts -= 50;
} else {
//Comanda que mostra informació i dades de l'aplicació a la consola del desenvolupador
console.log(`Game Over! T'has quedat amb ${vides} vides.`);
}
// (switch) Estructura condicional de casos
// Executa el bloc de codi segons el valor assignat a la variable
switch (nivell) {
case 1:
numEnemics = 5;
maxPunts = 100;
break;
case 2:
numEnemics = 10;
maxPunts = 200;
break;
default:
numEnemics = 3;
maxPunts = 50;
}
// (Operador ternari) - Assigna un valor si es compleix la condició sinó assigna un altre valor.
const missatge = (vides > 0) ? "Estàs viu" : "Has mort";
const nomUsuari = (usuari === null) ? "Jugador1" : usuari;

Strutture di controllo iterative

JavaScript può ripetere l'esecuzione di un blocco di codice finché non viene soddisfatta una condizione o viene eseguito un numero determinato di iterazioni (chiamate anche loop).

// (while) Executa un bloc de codi repetidament fins que es compleixi una condició
let estaViu = true;
let numEnemics = 3;
let vides = 5;
while (estaViu && numEnemics > 0) {
numEnemics--;
vides--;
if (vides === 0) {
estaViu = false;
}
}
// (for) Executa un bloc de codi repetidament un número determinat de vegades
let posicioEnemic = 0;
for (let i = 0; i < 10; i++) {
posicioEnemic += 5;
}
// (forEach) Executa un bloc de codi per a cada element d'un vector
const enemics = ["TieFighter", "StarDestroyer", "DeathStar"];
enemics.forEach((enemic) => {
console.log(`Enemic: ${enemic}`);
});
// (for .. in) Executa un bloc de codi per a cada clau d'un objecte (simula un array associatiu)
const puntuacions = { "facil": 100, "normal": 200, "dificil": 500 };
for (const dificultat in puntuacions) {
console.log(dificultat, puntuacions[dificultat]);
}

Funzioni e Procedure

Le funzioni sono blocchi di codice che eseguono un compito specifico, possono ricevere parametri di input e restituire un risultato. Sono indipendenti dal programma e possiamo "chiamarle" in qualsiasi punto del codice.

Eseguiremo le funzioni nel seguente modo:

// Función tradicional
function calcularPuntuacion(puntos, tiempos, nivel) {
let puntosTotales = Math.floor((puntos - tiempos) * nivel);
return puntosTotales;
}
// Función flecha
const calcularPuntuacion = (puntos, tiempos, nivel) => Math.floor((puntos - tiempos) * nivel);
// Tipus Primitius
let nom = "Jugador"; // String
let punts = 50; // Number
let estaDisparant = false; // Boolean
let nickname = null; // Null
let velocitat; // Undefined
// Vectors (Arrays)
const enemics = ["TieFighter", "StarDestroyer", "DeathStar"];
const puntuacions = [50, 100, 300];
// Objecte literal (Objectes simples creats pel desenvolupador)
const jugador = {
nom: "X-Wing",
vides: 3,
punts: 0,
energia: 100,
posicio: { x: 250, y: 450 }, // "posició" seria un altre objecte
armes: ["laser", "metralleta"]
};

Dobbiamo comprendere che le funzioni sono fondamentali nella programmazione e ci permettono di riutilizzare il codice. Possiamo passare parametri alle funzioni e ottenere risultati. Le funzioni possono anche essere anonime o arrow function, come mostrato nell'esempio precedente.

Vedremo altri esempi di come utilizzeremo le funzioni nei nostri programmi.