Ir al contenido

LECTURA PREVIA

Bloque 02. Frontend con HTML, CSS y JavaScript

0lecturas

Bloque 02. Frontend con HTML, CSS y JavaScript

Introducción

En este bloque aprendemos a combinar las 3 tecnologías básicas del frontend.

HTML: El lenguaje de marcado que define la estructura y semántica del contenido (el esqueleto de la web).

CSS: El lenguaje de estilos CSS que define el estilo visual del contenido (el diseño de la web).

JavaScript: El lenguaje de programación que permite modificar el contenido dinámicamente y interactuar con el usuario (el cerebro de la web).

Nos centraremos en descubrir el potencial del JavaScript moderno (ES6+) para crear aplicaciones web interactivas. JavaScript es el lenguaje que da vida al frontend, permite:

  • Capturar eventos y dar respuesta a acciones del usuario
  • Manipular el contenido dinámicamente y en tiempo real.
  • Comunicarse con el backend haciendo uso de formularios o APIs.

Haremos un repaso de los conceptos fundamentales de programación y finalizaremos con la creación de un pequeño videojuego web. Trabajaremos conceptos clave como la manipulación del DOM, la gestión de eventos, la programación orientada a objetos, el tratamiento de JSON y el consumo de APIs.

Conceptos Básicos de JavaScript (Repaso)

Variables y Constantes

JavaScript utiliza las palabras reservadas let y const para declarar variables y 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;

Tipos de Datos

JavaScript es dinámico, determina automáticamente el tipo de dato en función del valor asignado a las constantes o variables. Estos pueden ser:

  • Tipos de datos Primitivos: String, Number, Boolean, Null, Undefined
  • Tipos de datos Compostos: 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"]
};

Operadores Aritméticos, Relacionales y Lógicos

Operadores Aritméticos: Permiten realizar operaciones matemáticas con valores numéricos, constantes y variables.

  • + (Suma): Suma dos valores.
  • - (Resta): Resta dos valores.
  • * (Multiplicación): Multiplica dos valores.
  • / (División): Divide dos valores.
  • % (Módulo): Retorna el residuo de la división entre dos valores.
  • ** (Exponente): Eleva un valor a una potencia.
  • ++ (Incremento): Aumenta el valor de una variable en 1.
  • -- (Decremento): Disminuye el valor de una variable en 1.
  • + (Concatenación strings): Antiguo método para concatenar cadenas.

Operadores Relacionales: Permiten comparar valores. Determina si el resultado de la operación es cierto o falso.

  • == (Igual a): Comprueba si dos valores son iguales (solo tiene en cuenta el valor).
  • === (Igual a estricto): Comprueba si dos valores son exactamente iguales (el valor y el tipo).
  • != (Diferente de): Comprueba si dos valores no son iguales (solo tiene en cuenta el valor).
  • !== (Diferente de estricto): Comprueba si dos valores no son iguales (el valor y el tipo).
  • > (Más grande que): Comprueba si el primer valor es más grande que el segundo valor.
  • < (Menos que): Comprueba si el primer valor es más pequeño que el segundo valor.
  • >= (Más grande o igual que): Comprueba si el primer valor es más grande o igual que el segundo valor.
  • <= (Menos o igual que): Comprueba si el primer valor es menor o igual que el segundo valor.

Operadores Lógicos: Permiten combinar condiciones y determinar su resultado final (cierto o falso).

  • && (AND): Verifica si las condiciones son ciertas. Retorna cierto o falso en caso contrario.
  • || (OR): Verifica si al menos una condición es cierta. Retorna cierto o falso en caso contrario.
  • ! (NOT): Invierte el valor de una condición. Retorna cierto si la condición es falsa y 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;

Estructuras de Control Condicional

JavaScript puede tomar decisiones sobre qué bloque de código ejecutar en función del resultado de operaciones aritméticas, relacionales y lógicas.

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

Estructuras de Control Iterativo

JavaScript puede repetir la ejecución de un bloque de código hasta que se cumpla una condición o se realice un número determinado de iteraciones (también se denominan bucles).

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

Funciones y Procedimientos

Las funciones son bloques de código que realizan una tarea concreta, pueden recibir parámetros de entrada y retornar un resultado. Son independientes del programa y las podemos “llamar” en cualquier punto del código.

Ejecutaremos las funciones de la siguiente manera:

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

Debemos entender que las funciones son fundamentales en la programación y nos permiten reutilizar código. Podemos pasar parámetros a las funciones y obtener resultados. Las funciones también pueden ser anónimas o flecha, como se muestra en el ejemplo anterior.

Veremos más ejemplos de cómo utilizaremos las funciones en nuestros programas.