Ir al contenido

LEITURA PRÉVIA

Bloco 02. Frontend com HTML, CSS e JavaScript

0lecturas

Bloco 02. Frontend com HTML, CSS e JavaScript

Introdução

Neste bloco aprendemos a combinar as 3 tecnologias básicas do frontend.

HTML: A linguagem de marcação que define a estrutura e semântica do conteúdo (o esqueleto da web).

CSS: A linguagem de estilos CSS que define o estilo visual do conteúdo (o design da web).

JavaScript: A linguagem de programação que permite modificar o conteúdo dinamicamente e interagir com o usuário (o cérebro da web).

Focar-nos-emos em descobrir o potencial do JavaScript moderno (ES6+) para criar aplicações web interativas. O JavaScript é a linguagem que dá vida ao frontend, permitindo:

  • Capturar eventos e responder a ações do usuário
  • Manipular o conteúdo dinamicamente e em tempo real.
  • Comunicar com o backend utilizando formulários ou APIs.

Faremos uma revisão dos conceitos fundamentais de programação e finalizaremos com a criação de um pequeno videojogo web. Trabalharemos conceitos-chave como a manipulação do DOM, a gestão de eventos, a programação orientada a objetos, o tratamento de JSON e o consumo de APIs.

Conceitos Básicos de JavaScript (Revisão)

Variáveis e Constantes

O JavaScript utiliza as palavras reservadas let e const para declarar variáveis e 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 Dados

O JavaScript é dinâmico, determina automaticamente o tipo de dado com base no valor atribuído às constantes ou variáveis. Estes podem ser:

  • Tipos de Dados Primitivos: String, Number, Boolean, Null, Undefined
  • Tipos de Dados 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, Relacionais e Lógicos

Operadores Aritméticos: Permitem realizar operações matemáticas com valores numéricos, constantes e variáveis.

  • + (Soma): Soma dois valores.
  • - (Subtração): Subtrai dois valores.
  • * (Multiplicação): Multiplica dois valores.
  • / (Divisão): Divide dois valores.
  • % (Módulo): Retorna o resto da divisão entre dois valores.
  • ** (Exponente): Eleva um valor a uma potência.
  • ++ (Incremento): Aumenta o valor de uma variável em 1.
  • -- (Decremento): Diminui o valor de uma variável em 1.
  • + (Concatenação de strings): Método antigo para concatenar strings.

Operadores Relacionais: Permitem comparar valores. Determina se o resultado da operação é verdadeiro ou falso.

  • == (Igual a): Verifica se dois valores são iguais (considera apenas o valor).
  • === (Igualdade estrita): Verifica se dois valores são exatamente iguais (o valor e o tipo).
  • != (Diferente de): Verifica se dois valores não são iguais (considera apenas o valor).
  • !== (Diferença estrita): Verifica se dois valores não são iguais (o valor e o tipo).
  • > (Maior que): Verifica se o primeiro valor é maior que o segundo valor.
  • < (Menos que): Verifica se o primeiro valor é menor que o segundo valor.
  • >= (Maior ou igual a): Verifica se o primeiro valor é maior ou igual ao segundo valor.
  • <= (Menos o igual que): Comprueba si el primer valor es menor o igual que el segundo valor.

Operadores Lógicos: Permitem combinar condições e determinar o seu resultado final (verdadeiro ou falso).

  • && (AND): Verifica si las condiciones son ciertas. Retorna cierto o falso en caso contrario.
  • || (OR): Verifica se pelo menos uma condição é verdadeira. Retorna verdadeiro ou falso caso contrário.
  • ! (NOT): Inverte o valor de uma condição. Retorna verdadeiro se a condição for falsa e 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;

Estruturas de Controle Condicionais

O JavaScript pode tomar decisões sobre qual bloco de código executar com base no resultado de operações aritméticas, relacionais e 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;

Estruturas de Controle Iterativas

O JavaScript pode repetir a execução de um bloco de código até que uma condição seja atendida ou um número determinado de iterações seja realizado (também chamados de loops).

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

Funções e Procedimentos

As funções são blocos de código que realizam uma tarefa específica, podem receber parâmetros de entrada e retornar um resultado. São independentes do programa e podemos “chamá-las” em qualquer ponto do código.

Executaremos as funções da seguinte maneira:

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

Devemos entender que as funções são fundamentais na programação e nos permitem reutilizar código. Podemos passar parâmetros para as funções e obter resultados. As funções também podem ser anônimas ou de seta, como mostrado no exemplo anterior.

Veremos mais exemplos de como utilizaremos as funções em nossos programas.