Ir al contenido

LECTURE PRÉCÉDENTE

Bloc 02. Frontend avec HTML, CSS et JavaScript

0vues

Bloc 02. Frontend avec HTML, CSS et JavaScript

Introduction

Dans ce bloc, nous apprenons à combiner les 3 technologies de base du frontend.

HTML : Le langage de balisage qui définit la structure et la sémantique du contenu (le squelette du web).

CSS : Le langage de feuilles de style CSS qui définit le style visuel du contenu (le design du web).

JavaScript : Le langage de programmation qui permet de modifier le contenu de manière dynamique et d'interagir avec l'utilisateur (le cerveau du web).

Nous nous concentrerons sur la découverte du potentiel du JavaScript moderne (ES6+) pour créer des applications web interactives. JavaScript est le langage qui donne vie au frontend, permettant :

  • Capturer les événements et répondre aux actions de l'utilisateur
  • Manipuler le contenu de manière dynamique et en temps réel.
  • Communiquer avec le backend en utilisant des formulaires ou des API.

Nous passerons en revue les concepts fondamentaux de la programmation et nous terminerons par la création d'un petit jeu vidéo web. Nous travaillerons sur des concepts clés tels que la manipulation du DOM, la gestion des événements, la programmation orientée objet, le traitement du JSON et la consommation d'API.

Concepts de base de JavaScript (Révision)

Variables et Constantes

JavaScript utilise les mots réservés let et const pour déclarer des variables et des constantes.

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;

Types de données

JavaScript est dynamique, il détermine automatiquement le type de données en fonction de la valeur assignée aux constantes ou aux variables. Ceux-ci peuvent être :

  • Types de données primitifs : String, Number, Boolean, Null, Undefined
  • Types de données composés : Arrays, Functions, Dates, etc.
// 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"]
};

Opérateurs arithmétiques, relationnels et logiques

Opérateurs arithmétiques : Permettent d'effectuer des opérations mathématiques avec des valeurs numériques, des constantes et des variables.

  • + (Addition) : Additionne deux valeurs.
  • - (Soustraction) : Soustrait deux valeurs.
  • * (Multiplication) : Multiplie deux valeurs.
  • / (Division) : Divise deux valeurs.
  • % (Modulo) : Retourne le reste de la division de deux valeurs.
  • ** (Exposant) : Élève une valeur à une puissance.
  • ++ (Incrémentation) : Augmente la valeur d'une variable de 1.
  • -- (Décrémentation) : Diminue la valeur d'une variable de 1.
  • + (Concaténation de chaînes) : Ancienne méthode pour concaténer des chaînes.

Opérateurs relationnels : permettent de comparer des valeurs. Déterminent si le résultat de l'opération est vrai ou faux.

  • == (Égal à) : Vérifie si deux valeurs sont égales (ne prend en compte que la valeur).
  • === (Égalité stricte) : Vérifie si deux valeurs sont exactement égales (la valeur et le type).
  • != (Différent de) : Vérifie si deux valeurs ne sont pas égales (ne prend en compte que la valeur).
  • !== (Différent de strict) : Vérifie si deux valeurs ne sont pas égales (la valeur et le type).
  • > (Supérieur à) : Vérifie si la première valeur est plus grande que la seconde valeur.
  • < (Inférieur à) : Vérifie si la première valeur est inférieure à la deuxième valeur.
  • >= (Supérieur ou égal à) : Vérifie si la première valeur est supérieure ou égale à la deuxième valeur.
  • <= (Inférieur ou égal à) : Vérifie si la première valeur est inférieure ou égale à la deuxième valeur.

Opérateurs logiques : Ils permettent de combiner des conditions et de déterminer leur résultat final (vrai ou faux).

  • && (ET) : Vérifie si les conditions sont vraies. Retourne vrai ou faux dans le cas contraire.
  • || (OR) : Vérifie si au moins une condition est vraie. Retourne vrai ou faux dans le cas contraire.
  • ! (NOT) : Inverse la valeur d'une condition. Retourne vrai si la condition est fausse et vice versa.
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;

Structures de contrôle conditionnelles

JavaScript peut prendre des décisions sur le bloc de code à exécuter en fonction du résultat d'opérations arithmétiques, relationnelles et logiques.

// (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;

Structures de contrôle itératives

JavaScript peut répéter l'exécution d'un bloc de code jusqu'à ce qu'une condition soit remplie ou qu'un nombre déterminé d'itérations soit effectué (également appelés boucles).

// (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]);
}

Fonctions et procédures

Les fonctions sont des blocs de code qui effectuent une tâche spécifique, elles peuvent recevoir des paramètres d'entrée et retourner un résultat. Elles sont indépendantes du programme et nous pouvons les « appeler » à n'importe quel point du code.

Nous exécuterons les fonctions de la manière suivante :

// 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"]
};

Il faut comprendre que les fonctions sont fondamentales en programmation et nous permettent de réutiliser le code. Nous pouvons passer des paramètres aux fonctions et obtenir des résultats. Les fonctions peuvent également être anonymes ou fléchées, comme le montre l'exemple précédent.

Nous verrons d'autres exemples de la manière dont nous utiliserons les fonctions dans nos programmes.