Arrays, Funções e POO

Um array é uma lista ordenada de valores, guardada numa única variável. Em vez de criares nome1, nome2, nome3 separadamente, guardas todos numa lista:

const frutas = ["maçã", "banana", "pera"];
console.log(frutas);        // ["maçã", "banana", "pera"]
console.log(frutas.length); // 3 — o número de elementos

Acesso por índice

Cada posição num array tem um índice, e — tal como viste no for na Fase 3 — a contagem começa em 0, não em 1:

console.log(frutas[0]); // "maçã"  — primeiro elemento
console.log(frutas[1]); // "banana"
console.log(frutas[2]); // "pera"  — último elemento
console.log(frutas[3]); // undefined — não existe, e o JavaScript não avisa

Este é o erro mais comum com arrays: tentar aceder a um índice que não existe não dá erro — dá undefined silenciosamente, o que só se torna um bug óbvio várias linhas mais tarde. Sempre que não tiveres a certeza se um índice existe, compara-o com array.length.

Um array declarado com const ainda pode mudar de conteúdo

Isto surpreende muita gente: const frutas = [...] impede-te de reatribuir frutas a um array totalmente novo, mas não impede alterar o seu conteúdo. Podes adicionar, remover ou modificar elementos livremente — porque, tecnicamente, a "caixa" (a variável) continua a apontar para a mesma lista, só o interior dela mudou.

const numeros = [1, 2, 3];
numeros.push(4);      // válido! [1, 2, 3, 4]
// numeros = [5, 6];  // inválido — isto sim reatribuiria a variável

Percorrer um array

Combina o que aprendeste na Fase 3: um for que vai de 0 até array.length - 1 visita cada elemento:

for (let i = 0; i < frutas.length; i++) {
  console.log(i, "→", frutas[i]);
}

Repara porque o limite é array.length e a condição é < (não <=): um array com 3 elementos tem índices 0, 1 e 2 — usar <= tentaria aceder ao índice 3, que não existe.

Arrays em JavaScript vêm com métodos (funções já incluídas) para as tarefas mais comuns:

• push(valor) — adiciona um elemento ao fim do array.
• pop() — remove e devolve o último elemento.
• includes(valor) — devolve true ou false consoante o valor existir no array.
• indexOf(valor) — devolve a posição do valor, ou -1 se não existir.
• join(separador) — junta todos os elementos numa única string, com o separador que escolheres.
• forEach(funcao) — executa uma função para cada elemento, sem precisares de escrever o for manualmente.

const tarefas = ["Estudar", "Correr"];

tarefas.push("Cozinhar");
console.log(tarefas); // ["Estudar", "Correr", "Cozinhar"]

console.log(tarefas.includes("Correr")); // true
console.log(tarefas.indexOf("Cozinhar")); // 2

tarefas.forEach(function (tarefa) {
  console.log("Fazer:", tarefa);
});

forEach vs for tradicional

forEach é mais curto e mais legível quando só precisas de "fazer algo com cada elemento". O for tradicional continua a ser necessário quando precisas do índice para outra coisa além de aceder ao elemento (ex: parar a meio com break — o forEach não permite break), ou quando precisas de percorrer o array ao contrário.

Existem ainda métodos mais avançados como map e filter, que transformam um array noutro sem alterar o original — vais precisar deles quando começares a trabalhar com dados vindos de uma base de dados ou de uma API, mais à frente no plano. Por agora, os seis métodos acima cobrem a maioria dos problemas que vais resolver.

Uma função é um bloco de código com um nome, que podes "chamar" (executar) quantas vezes quiseres, com valores diferentes de cada vez. É a ferramenta que evita copiares e colares o mesmo código várias vezes.

function saudar(nome) {
  console.log("Olá, " + nome + "!");
}

saudar("Ana");
saudar("Bruno");

• function — a palavra que declara uma função.
• saudar — o nome da função (as mesmas regras de nomes das variáveis aplicam-se).
• (nome) — os parâmetros: variáveis que a função recebe de fora, diferentes a cada chamada.
• saudar("Ana") — uma chamada da função, com "Ana" como o valor real (o argumento) para o parâmetro nome.

return: devolver um resultado

Uma função pode simplesmente fazer algo (como o console.log acima), ou pode calcular e devolver um valor, usando return:

function somar(a, b) {
  return a + b;
}

const resultado = somar(3, 4);
console.log(resultado); // 7

Assim que o JavaScript encontra um return, sai imediatamente da função — qualquer código depois dele, dentro da mesma função, nunca é executado. Uma função sem return explícito devolve undefined automaticamente.

Porque funções tornam o código mais fácil de testar e de ler

Uma função com um nome bom (calcularTotal, validarEmail) documenta-se a si própria — quem lê o código sabe o que ela faz sem ter de ler o corpo inteiro. E como o comportamento está isolado num só sítio, testar ou corrigir um bug fica muito mais simples do que se a mesma lógica estivesse copiada em cinco sítios diferentes do programa.

As arrow functions (funções seta) são uma sintaxe alternativa, mais compacta, para escrever funções — vais vê-las em praticamente todo o código JavaScript moderno, incluindo dentro de forEach.

// Função tradicional
function dobrar(numero) {
  return numero * 2;
}

// A mesma função, como arrow function
const dobrarSeta = (numero) => {
  return numero * 2;
};

// Se o corpo for só um return, podes simplificar ainda mais
const dobrarCurta = (numero) => numero * 2;

As três formas acima fazem exatamente a mesma coisa. A última versão, sem chavetas e sem return explícito, chama-se implicit return — funciona só quando o corpo inteiro da função é uma única expressão a devolver.

Onde vais usá-las mais

Arrow functions são especialmente comuns como argumento de métodos como forEach, tornando o código mais curto:

const numeros = [1, 2, 3];

numeros.forEach((numero) => {
  console.log(numero * 2);
});

Não precisas de escolher "uma forma para sempre" — programadores experientes usam ambas consoante o contexto. Para já, o mais importante é conseguires ler arrow functions no código de outras pessoas (e nos exemplos desta plataforma) sem estranhar a sintaxe.

Um objeto agrupa várias propriedades relacionadas, cada uma com um nome, numa única estrutura:

const utilizador = {
  nome: "Marta",
  idade: 30,
  ativo: true,
};

console.log(utilizador.nome);  // "Marta"
console.log(utilizador.idade); // 30

Repara na diferença para um array: num array acedes por posição (frutas[0]); num objeto acedes por nome (utilizador.nome). Usa arrays quando a ordem importa e os itens são do mesmo tipo (uma lista de tarefas); usa objetos quando queres agrupar propriedades diferentes de uma mesma "coisa" (os vários dados de um utilizador).

Objetos podem ter funções lá dentro (métodos)

const conta = {
  saldo: 100,
  depositar(valor) {
    this.saldo += valor;
  },
};

conta.depositar(50);
console.log(conta.saldo); // 150

A palavra this, dentro de um método, refere-se ao próprio objeto que está a chamar o método — é como o objeto se refere a si mesmo.

Classes: um "molde" para criar vários objetos parecidos

Quando precisas de criar muitos objetos com a mesma estrutura (várias contas bancárias, vários utilizadores), uma classe funciona como um molde:

class ContaBancaria {
  constructor(titular, saldoInicial) {
    this.titular = titular;
    this.saldo = saldoInicial;
  }

  depositar(valor) {
    this.saldo += valor;
  }
}

const contaDaAna = new ContaBancaria("Ana", 100);
const contaDoBruno = new ContaBancaria("Bruno", 50);

contaDaAna.depositar(30);
console.log(contaDaAna.saldo);   // 130
console.log(contaDoBruno.saldo); // 50 — cada instância tem o seu próprio estado

O constructor corre automaticamente sempre que crias uma nova conta com new, e é onde defines os valores iniciais de cada propriedade. Repara que contaDaAna e contaDoBruno são objetos completamente independentes, mesmo vindo da mesma classe — depositar na conta da Ana não afeta a do Bruno. Este é o conceito central de Programação Orientada a Objetos (POO): moldes que descrevem estrutura e comportamento, e instâncias independentes criadas a partir deles.