Funções: encapsular e reutilizar lógica.

// ❌ sem função — lógica duplicada em três lugares
// na listagem:
const tempoListagem = Math.ceil(artigo.palavras / 200);
// na página:
const tempoPagina = Math.ceil(palavras / 200);
// no painel:
const tempoAdmin = Math.ceil(totalPalavras / 200);

// ✅ com função — uma definição, N usos
function calcularTempoLeitura(palavras) {
  const palavrasPorMinuto = 238;
  return Math.ceil(palavras / palavrasPorMinuto);
}

// os três lugares chamam a mesma função
const tempoListagem = calcularTempoLeitura(artigo.palavras);
const tempoPagina = calcularTempoLeitura(palavras);
const tempoAdmin = calcularTempoLeitura(totalPalavras);

// chamada antes da declaração — funciona por causa do hoisting
const tempo = calcularTempoLeitura(1200);
console.log(tempo); // → 6

// a declaração aparece depois no arquivo — tudo bem
function calcularTempoLeitura(palavras) {
  return Math.ceil(palavras / 200);
}

// sem return explícito — a função retorna undefined
function exibirLog(mensagem) {
  console.log(`[Blog] ${mensagem}`);
  // sem return — retorna undefined implicitamente
}

// ❌ chamar antes da declaração causa erro
// const resultado = formatarData(new Date()); // ReferenceError

const formatarData = function(date) {
  return new Intl.DateTimeFormat("pt-BR", {
    year: "numeric",
    month: "long",
    day: "numeric",
  }).format(date);
};

const resultado = formatarData(new Date("2025-03-15"));
// → "15 de março de 2025"

// forma completa com bloco e return
const calcularTempoLeitura = (palavras) => {
  const palavrasPorMinuto = 238;
  return Math.ceil(palavras / palavrasPorMinuto);
};

// forma concisa — corpo de expressão, retorno implícito
const formatarData = (date) => new Intl.DateTimeFormat("pt-BR").format(date);

// parâmetro único — parênteses opcionais
const dobrar = x => x * 2;

// sem parâmetros — parênteses obrigatórios
const agora = () => new Date();

// retorno implícito de objeto — precisa de parênteses
const criarArtigo = (titulo, autor) => ({
  titulo,
  autor,
  criadoEm: new Date(),
});

// parâmetro padrão — usado quando o argumento não é passado
function gerarSlug(titulo = "sem-titulo") {
  return titulo
    .toLowerCase()
    .trim()
    .replace(/\s+/g, "-")
    .replace(/[^a-z0-9-]/g, "");
}

gerarSlug("Meu Primeiro Projeto Web"); // → "meu-primeiro-projeto-web"
gerarSlug();                           // → "sem-titulo"

// desestruturação nos parâmetros — nomear propriedades diretamente
function renderizarCard({ titulo, autor, curtidas = 0, publicadoEm }) {
  return `
    <article class="card-artigo">
      <h2>${titulo}</h2>
      <p>Por ${autor} · ${curtidas} curtidas</p>
      <time>${formatarData(publicadoEm)}</time>
    </article>
  `;
}

// chamado com um objeto — as propriedades são extraídas automaticamente
renderizarCard({ titulo: "CSS em geral", autor: "Dev Aprendiz", publicadoEm: "2025-03-15" });

// rest parameters — função que aceita N artigos
function combinarTags(...artigos) {
  return artigos.flatMap(a => a.tags);
}

combinarTags(artigo1, artigo2, artigo3);

function processarArtigos(artigos) {
  const total = artigos.length; // acessível em toda a função

  for (const artigo of artigos) {
    const slug = gerarSlug(artigo.titulo); // só existe dentro do for
    console.log(slug);
  }

  // console.log(slug); // ReferenceError — slug não existe aqui

  return total;
}

// criarContador retorna uma função que lembra 'n'
function criarContador() {
  let n = 0; // variável no escopo da função externa

  return () => {
    n += 1; // a função interna acessa e modifica 'n'
    return n;
  };
}

// cada chamada a criarContador() cria um escopo separado
const contadorArtigo1 = criarContador();
const contadorArtigo2 = criarContador();

contadorArtigo1(); // → 1
contadorArtigo1(); // → 2
contadorArtigo2(); // → 1 (escopo separado — não compartilha 'n')
contadorArtigo1(); // → 3

function configurarBotaoCurtir(artigoId) {
  const botao = document.querySelector(`[data-artigo-id="${artigoId}"] .botao-curtir`);

  botao.addEventListener("click", () => {
    // esta função é uma closure — lembra artigoId do escopo externo
    curtir(artigoId); // artigoId ainda é acessível aqui
  });
}