Ir al contenido

VORABLES LESEN

Block 02. Frontend mit HTML, CSS und JavaScript

0Lesungen

Block 02. Frontend mit HTML, CSS und JavaScript

Einführung

In diesem Block lernen wir, die drei grundlegenden Frontend-Technologien zu kombinieren.

HTML: Die Auszeichnungssprache, die die Struktur und Semantik des Inhalts definiert (das Skelett der Website).

CSS: Die CSS-Stilbeschreibungssprache, die das visuelle Erscheinungsbild des Inhalts definiert (das Webdesign).

JavaScript: Die Programmiersprache, die es ermöglicht, Inhalte dynamisch zu ändern und mit dem Benutzer zu interagieren (das Gehirn der Website).

Wir werden uns darauf konzentrieren, das Potenzial von modernem JavaScript (ES6+) für die Erstellung interaktiver Webanwendungen zu entdecken. JavaScript ist die Sprache, die das Frontend zum Leben erweckt und Folgendes ermöglicht:

  • Ereignisse erfassen und auf Benutzeraktionen reagieren
  • Inhalte dynamisch und in Echtzeit manipulieren.
  • Mit dem Backend über Formulare oder APIs kommunizieren.

Wir werden die grundlegenden Programmierkonzepte wiederholen und mit der Erstellung eines kleinen Web-Videospiels abschließen. Dabei werden wir Schlüsselkonzepte wie DOM-Manipulation, Event-Handling, objektorientierte Programmierung, JSON-Verarbeitung und die Nutzung von APIs bearbeiten.

JavaScript-Grundlagen (Wiederholung)

Variablen und Konstanten

JavaScript verwendet die reservierten Wörter let und const, um Variablen und Konstanten zu deklarieren.

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;

Datentypen

JavaScript ist dynamisch; es ermittelt automatisch den Datentyp basierend auf dem Wert, der Konstanten oder Variablen zugewiesen wird. Diese können sein:

  • Primitive Datentypen: String, Number, Boolean, Null, Undefined
  • Komplexe Datentypen: Arrays, Functions, Dates, usw.
// 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"]
};

Arithmetische, Relationale und Logische Operatoren

Arithmetische Operatoren: Ermöglichen die Durchführung mathematischer Operationen mit numerischen Werten, Konstanten und Variablen.

  • + (Addition): Addiert zwei Werte.
  • - (Subtraktion): Subtrahiert zwei Werte.
  • * (Multiplikation): Multipliziert zwei Werte.
  • / (Division): Dividiert zwei Werte.
  • % (Modulo): Gibt den Rest der Division zweier Werte zurück.
  • ** (Exponent): Erhöht einen Wert auf eine Potenz.
  • ++ (Inkrement): Erhöht den Wert einer Variable um 1.
  • -- (Dekrement): Verringert den Wert einer Variable um 1.
  • + (String-Konkatenation): Alte Methode zum Verketten von Zeichenfolgen.

Relationale Operatoren: Ermöglichen den Vergleich von Werten. Bestimmen, ob das Ergebnis der Operation wahr oder falsch ist.

  • == (Gleich): Prüft, ob zwei Werte gleich sind (berücksichtigt nur den Wert).
  • === (Strikte Gleichheit): Prüft, ob zwei Werte exakt gleich sind (Wert und Typ).
  • != (Ungleich): Prüft, ob zwei Werte nicht gleich sind (berücksichtigt nur den Wert).
  • !== (Nicht identisch): Prüft, ob zwei Werte nicht gleich sind (Wert und Typ).
  • > (Größer als): Prüft, ob der erste Wert größer als der zweite Wert ist.
  • < (Kleiner als): Überprüft, ob der erste Wert kleiner ist als der zweite Wert.
  • >= (Größer oder gleich): Prüft, ob der erste Wert größer oder gleich dem zweiten Wert ist.
  • <= (Kleiner oder gleich): Überprüft, ob der erste Wert kleiner oder gleich dem zweiten Wert ist.

Logische Operatoren: Ermöglichen die Kombination von Bedingungen und die Bestimmung ihres Endergebnisses (wahr oder falsch).

  • && (UND): Überprüft, ob die Bedingungen wahr sind. Gibt wahr oder falsch zurück, wenn dies nicht der Fall ist.
  • || (ODER): Prüft, ob mindestens eine Bedingung wahr ist. Gibt andernfalls wahr oder falsch zurück.
  • ! (NICHT): Kehrt den Wert einer Bedingung um. Gibt wahr zurück, wenn die Bedingung falsch ist, und umgekehrt.
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;

Bedingte Kontrollstrukturen

JavaScript kann Entscheidungen darüber treffen, welcher Codeblock basierend auf dem Ergebnis arithmetischer, relationaler und logischer Operationen ausgeführt wird.

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

Iterative Kontrollstrukturen

JavaScript kann die Ausführung eines Codeblocks wiederholen, bis eine Bedingung erfüllt ist oder eine bestimmte Anzahl von Iterationen (auch Schleifen genannt) erreicht wurde.

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

Funktionen und Prozeduren

Funktionen sind Codeblöcke, die eine bestimmte Aufgabe ausführen; sie können Eingabeparameter entgegennehmen und ein Ergebnis zurückgeben. Sie sind unabhängig vom Programm und können an jeder beliebigen Stelle im Code „aufgerufen“ werden.

Wir werden die Funktionen wie folgt ausführen:

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

Wir müssen verstehen, dass Funktionen in der Programmierung von grundlegender Bedeutung sind und die Wiederverwendung von Code ermöglichen. Wir können Funktionen Parameter übergeben und Ergebnisse erhalten. Funktionen können auch anonym oder als Arrow-Funktionen (Pfeilfunktionen) definiert sein, wie im obigen Beispiel gezeigt.

Wir werden weitere Beispiele dafür sehen, wie wir Funktionen in unseren Programmen einsetzen.