// aula 01 · JavaScript · JS Básico

JavaScript — história,
DOM, eventos e funções


A história do JavaScript

JavaScript nasceu em 1995, criado por Brendan Eich em apenas 10 dias enquanto trabalhava na Netscape. O objetivo era simples: dar vida às páginas web — fazer botões funcionarem, validar formulários, criar interações sem precisar recarregar a página.

Originalmente chamado de Mocha, depois LiveScript, e só então renomeado para JavaScript — aproveitando a popularidade do Java na época. Apesar do nome, não tem nada a ver com Java. São linguagens completamente diferentes.

1995

Brendan Eich cria o JavaScript

Desenvolvido em 10 dias para o Netscape Navigator. Nasce como linguagem de script para o browser.

1997

ECMAScript — a padronização

O JavaScript é padronizado pela ECMA International como ECMAScript. A partir daí, todas as versões são chamadas de ES + número (ES5, ES6, ES2023...).

2009

Node.js — JS fora do browser

Ryan Dahl lança o Node.js, permitindo rodar JavaScript no servidor. O JS deixa de ser exclusivo do browser e vai para o backend também.

2015 — hoje

ES6+ — JavaScript moderno

Arrow functions, classes, módulos, promises, async/await... O JS se torna uma linguagem madura e dominante. Hoje está em todo lugar: browser, servidor, mobile e desktop.

Curiosidade: JavaScript é a única linguagem que roda nativamente em todos os browsers sem precisar instalar nada. É por isso que hoje é a linguagem mais usada no mundo — está em todo site que você acessa.


O que o JavaScript faz na web

A web é construída em três camadas: HTML define a estrutura (o esqueleto), CSS define a aparência (a roupa), e JavaScript define o comportamento (os músculos). Sem JS, a página é estática — um documento que não reage a nada.

HTML — estrutura

Define o que existe na página: títulos, parágrafos, botões, imagens. É o esqueleto.

CSS — aparência

Define como cada elemento aparece: cor, tamanho, posição, animação visual.

JavaScript — comportamento

Define o que acontece quando o usuário interage: cliques, formulários, animações dinâmicas.

JS pode...

O que o JavaScript faz

  • Reagir a cliques, teclas e movimentos do mouse
  • Mostrar e esconder elementos da página
  • Validar formulários antes de enviar
  • Fazer requisições a APIs sem recarregar a página
  • Criar contadores, cronômetros e animações
  • Armazenar dados no navegador (localStorage)
Atenção

O que JS não é

  • Não é Java — são linguagens completamente diferentes
  • Não é só para web — roda também no servidor (Node.js)
  • Não precisa de compilação — o browser interpreta direto
  • Não é uma linguagem fraca — é poderosa e tipada dinamicamente

Onde escrever JavaScript

Inline

Diretamente na tag

Usando atributos como onclick. Funciona, mas não é recomendado para projetos maiores.

Internal

Tag <script> no HTML

Dentro de uma tag <script> no próprio arquivo HTML. Bom para páginas simples.

External

Arquivo .js separado

Arquivo externo linkado com src="script.js". Melhor prática — separa HTML do JS.

as três formas na prática

<!-- 1. Inline — evitar -->
<button onclick="alert('clicou!')">Clique</button>

<!-- 2. Internal — dentro do HTML -->
<script>
  console.log('olá do script interno');
</script>

<!-- 3. External — arquivo separado (melhor prática) -->
<script src="script.js"></script>

<!-- ⚠️ Sempre coloque o script antes do </body>
     para garantir que o HTML já foi carregado -->

Variáveis — var, let e const

Variável é um espaço na memória com um nome para guardar informação. No JavaScript moderno, usamos let e const. O var é o jeito antigo — ainda funciona, mas tem comportamentos confusos e é evitado.

Palavra-chave Pode reatribuir? Escopo Quando usar
var ✅ Sim Função (confuso) Não usar — legado
let ✅ Sim Bloco { } Valores que mudam
const ❌ Não Bloco { } Valores fixos (padrão)

variáveis na prática

// const — valor não muda (use sempre que possível)
const nome = 'Lucilia';
const idade = 30;
const ativo = true;

// let — valor pode mudar
let pontos = 0;
pontos = 10;   // reatribuição ok
pontos += 5;   // pontos agora é 15

// Tipos de dados
const texto   = 'string — texto entre aspas';
const numero  = 42;           // number — inteiro ou decimal
const decimal = 3.14;
const ligado  = true;         // boolean
const vazio   = null;         // null — sem valor intencional
let   naodef;                 // undefined — não inicializada

// Template literal — string com variável dentro
console.log(`Olá, ${nome}! Você tem ${idade} anos.`);
// → Olá, Lucilia! Você tem 30 anos.

Funções — definindo e chamando

Função é um bloco de código com nome que você escreve uma vez e chama várias vezes. Em JavaScript existem três formas principais de declarar funções.

as três formas de declarar funções

// 1. Function declaration — içamento (hoisting) automático
function somar(a, b) {
  return a + b;
}

// 2. Function expression — guardada em variável
const multiplicar = function(a, b) {
  return a * b;
};

// 3. Arrow function (ES6) — forma moderna e curta
const dividir = (a, b) => a / b;

// Chamando as funções
console.log(somar(3, 4));         // → 7
console.log(multiplicar(3, 4));  // → 12
console.log(dividir(10, 2));     // → 5

parâmetros, retorno e valor padrão

// Parâmetro com valor padrão
function saudacao(nome = 'visitante') {
  return `Olá, ${nome}!`;
}

console.log(saudacao('Lucilia'));  // → Olá, Lucilia!
console.log(saudacao());           // → Olá, visitante!

// Função sem retorno — só executa uma ação
function mostrarMensagem(msg) {
  console.log('📢 ' + msg);
}

mostrarMensagem('Bem-vinda ao JavaScript!');

DOM — Document Object Model

Quando o browser carrega uma página HTML, ele cria uma representação em memória chamada DOM — uma árvore de objetos onde cada tag HTML é um nó. O JavaScript acessa e modifica essa árvore, mudando o que aparece na tela sem recarregar a página.

🌳

DOM é uma árvore

O document é a raiz. Dentro dele tem o <html>, que tem <head> e <body>, que têm outros elementos — e assim vai formando galhos.

🎭

JS manipula o DOM

Com JavaScript você pode: mudar texto, trocar cor, esconder elementos, adicionar classes CSS, criar novos elementos e removê-los — tudo em tempo real.

selecionando elementos do DOM

// Selecionando um elemento pelo ID
const titulo = document.getElementById('meu-titulo');

// Selecionando pelo seletor CSS (mais moderno e flexível)
const botao  = document.querySelector('#btn-salvar');
const card   = document.querySelector('.card');       // primeiro .card
const todos  = document.querySelectorAll('.card');   // todos os .card

// Formas antigas (ainda funcionam)
document.getElementsByClassName('card');
document.getElementsByTagName('p');

modificando elementos do DOM

const titulo = document.querySelector('#titulo');

// Mudar o texto
titulo.textContent = 'Novo título!';

// Mudar o HTML interno (aceita tags)
titulo.innerHTML = 'Título com <em>itálico</em>';

// Mudar estilos CSS
titulo.style.color = '#c84b31';
titulo.style.fontSize = '24px';

// Adicionar e remover classes CSS
titulo.classList.add('destaque');
titulo.classList.remove('oculto');
titulo.classList.toggle('ativo');     // adiciona ou remove

// Ler e mudar atributos
titulo.getAttribute('id');
titulo.setAttribute('data-valor', '42');

Eventos — reagindo à interação do usuário

Evento é qualquer coisa que acontece na página: um clique, uma tecla pressionada, o mouse passando por cima de um elemento, a página terminando de carregar. O JavaScript escuta esses eventos e executa uma função quando eles acontecem.

Mouse

Eventos de mouse

  • click — clicou
  • dblclick — duplo clique
  • mouseover — passou o mouse
  • mouseout — saiu o mouse
Teclado

Eventos de teclado

  • keydown — tecla pressionada
  • keyup — tecla solta
  • keypress — tecla digitada
Formulário

Eventos de form

  • submit — formulário enviado
  • change — valor mudou
  • input — digitando
  • focus — campo ativo
Página

Eventos da página

  • load — página carregou
  • DOMContentLoaded — DOM pronto
  • scroll — rolou a página
  • resize — janela redimensionada

addEventListener — a forma correta de escutar eventos

const btn = document.querySelector('#meu-botao');

// addEventListener(evento, função)
btn.addEventListener('click', function() {
  console.log('Botão clicado!');
});

// Com arrow function (mais moderno)
btn.addEventListener('click', () => {
  alert('Olá!');
});

// Usando o objeto de evento (e) para mais informações
document.addEventListener('keydown', (e) => {
  console.log('Tecla pressionada:', e.key);
});

// Evento de scroll
window.addEventListener('scroll', () => {
  const btn = document.getElementById('back-to-top');
  btn.classList.toggle('visible', window.scrollY > 400);
});

exemplo completo — botão que muda texto e cor

<!-- HTML -->
<button id="btn-tema">Ativar modo escuro</button>
<div id="caixa">Conteúdo da página</div>

// JavaScript
const btn  = document.getElementById('btn-tema');
const box  = document.getElementById('caixa');
let   dark = false;

btn.addEventListener('click', () => {
  dark = !dark;  // inverte o valor

  box.style.background = dark ? '#1c1917' : '#fff';
  box.style.color      = dark ? '#faf7f2' : '#1c1917';
  btn.textContent      = dark ? 'Desativar modo escuro' : 'Ativar modo escuro';
});

Console — seu melhor amigo no debug

O console do navegador (F12 → Console) é onde o JavaScript se comunica com você durante o desenvolvimento. É a ferramenta mais usada para testar, debugar e entender o que está acontecendo no código.

os principais métodos do console

// Exibir valores — o mais usado
console.log('mensagem normal');
console.log(variavel, outra);      // pode passar vários valores

// Tipos de mensagem
console.warn('atenção — amarelo');
console.error('erro — vermelho');
console.info('informação — azul');

// Mostrar objeto formatado como tabela
const usuarios = [
  { nome: 'Lucilia', idade: 30 },
  { nome: 'Vinicius', idade: 32 }
];
console.table(usuarios);

// Medir tempo de execução
console.time('minhaOperacao');
// ... código ...
console.timeEnd('minhaOperacao');  // ex: minhaOperacao: 3.2ms

Erros comuns de quem está começando

Erro 1

Script antes do HTML

Colocar o <script> no <head> faz o JS executar antes do HTML existir. O elemento não é encontrado e dá null. Sempre coloque antes do </body>.

Erro 2

= vs == vs ===

= atribui valor. == compara com conversão de tipo. === compara valor e tipo (use sempre esse). '5' == 5 é true, mas '5' === 5 é false.

Erro 3

querySelector retorna null

Se o seletor não encontra nada, retorna null. Tentar chamar um método em null gera TypeError. Verifique se o ID ou classe está correto no HTML.

Erro 4

Esquecer o addEventListener

Usar onclick inline no HTML mistura comportamento com estrutura. Prefira sempre addEventListener no JavaScript — é mais organizado e permite múltiplos eventos.

Dica de debug: quando algo não funciona, abra o console do browser (F12) e leia a mensagem de erro. Ela diz exatamente o que aconteceu e em qual linha. A maioria dos erros de iniciante aparece ali.