A linguagem de programação que dá vida às páginas web. Aprenda a criar interações, manipular dados e construir aplicações completas.
const mensagem = "Olá, Mundo!";
function saudar(nome) {
return `Bem-vindo, ${nome}!`;
}
console.log(saudar("Dev"));
// Output: Bem-vindo, Dev!
JavaScript é a linguagem de programação mais popular do mundo, responsável por toda a interatividade nas páginas web modernas.
JavaScript roda diretamente no browser, sem necessidade de instalar nada. Todo navegador moderno já suporta!
Permite modificar HTML e CSS dinamicamente, criando interfaces interativas e responsivas.
Executa operações sem travar a página, como carregar dados de APIs ou responder a eventos.
Com Node.js, JavaScript também funciona no servidor, permitindo criar aplicações completas!
Domine os fundamentos do JavaScript antes de avançar para tópicos mais complexos.
Variáveis são containers para armazenar dados. Em JavaScript
moderno, usamos let e const.
Valor pode ser alterado
Escopo de bloco
Ideal para valores que mudam
Valor não pode ser reatribuído
Escopo de bloco
Ideal para valores fixos
Escopo de função
Sofre "hoisting"
⚠️ Pode causar bugs
// CONST - para valores que não mudam
const PI = 3.14159;
const NOME_SITE = "DevStudy";
const usuario = { nome: "João", idade: 25 }; // objetos podem ter propriedades alteradas
// LET - para valores que podem mudar
let contador = 0;
let mensagem = "Olá";
contador = contador + 1; // ✅ OK
mensagem = "Bem-vindo!"; // ✅ OK
// PI = 3.14; // ❌ ERRO! const não pode ser reatribuído
// Mas propriedades de objetos const podem ser alteradas:
usuario.idade = 26; // ✅ OK
usuario.email = "joao@email.com"; // ✅ OK
const. Só
use let quando realmente precisar mudar o valor.
Nunca use var em código moderno.
JavaScript tem tipos primitivos e tipos de referência (objetos).
"Olá" ou 'Olá' ou `Olá`
42, 3.14, -10
true, false
undefined
null
[1, 2, 3]
{nome: "João"}
Symbol("id")
// typeof retorna o tipo de um valor
console.log(typeof "texto"); // "string"
console.log(typeof 42); // "number"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" (bug histórico!)
console.log(typeof [1, 2, 3]); // "object"
console.log(typeof {a: 1}); // "object"
// Para verificar arrays:
console.log(Array.isArray([1, 2, 3])); // true
+ Adição- Subtração* Multiplicação/ Divisão% Resto (módulo)** Exponenciação++ Incremento-- Decremento== Igual (valor)=== Igual (valor e tipo)
!= Diferente (valor)!== Diferente (valor e tipo)
> Maior< Menor>= Maior ou igual<= Menor ou igual&& E (AND)|| OU (OR)! NÃO (NOT)?? Nullish coalescing
// == compara apenas o VALOR (faz conversão de tipo)
console.log(5 == "5"); // true ⚠️
console.log(0 == false); // true ⚠️
console.log(null == undefined); // true ⚠️
// === compara VALOR e TIPO (recomendado!)
console.log(5 === "5"); // false ✅
console.log(0 === false); // false ✅
console.log(null === undefined); // false ✅
// SEMPRE use === para evitar bugs!
const nome = "Maria";
const idade = 28;
// Forma antiga (concatenação)
const msg1 = "Olá, " + nome + "! Você tem " + idade + " anos.";
// Forma moderna (template literals) ✨
const msg2 = `Olá, ${nome}! Você tem ${idade} anos.`;
// Múltiplas linhas
const html = `
<div class="card">
<h2>${nome}</h2>
<p>Idade: ${idade}</p>
</div>
`;
// Expressões dentro do ${}
const preco = 100;
const desconto = 0.2;
console.log(`Preço final: R$ ${preco * (1 - desconto)}`); // R$ 80
| Método | Descrição | Exemplo |
|---|---|---|
.length |
Tamanho da string | "Olá".length → 3 |
.toUpperCase() |
Maiúsculas | "olá".toUpperCase() → "OLÁ" |
.toLowerCase() |
Minúsculas | "OLÁ".toLowerCase() → "olá" |
.trim() |
Remove espaços | " oi ".trim() → "oi" |
.includes() |
Contém texto? | "Olá".includes("l") → true |
.split() |
Divide em array | "a,b,c".split(",") → ["a","b","c"] |
.replace() |
Substitui texto | "Olá".replace("O", "A") → "Alá" |
.slice() |
Extrai parte | "JavaScript".slice(0,4) → "Java" |
const nota = 85;
if (nota >= 90) {
console.log("Excelente! Nota A");
} else if (nota >= 80) {
console.log("Muito bom! Nota B"); // ← Este será executado
} else if (nota >= 70) {
console.log("Bom! Nota C");
} else if (nota >= 60) {
console.log("Regular. Nota D");
} else {
console.log("Precisa melhorar. Nota F");
}
// Operador Ternário (if/else em uma linha)
const status = nota >= 60 ? "Aprovado" : "Reprovado";
console.log(status); // "Aprovado"
// Múltiplas condições
const idade = 25;
const temCNH = true;
if (idade >= 18 && temCNH) {
console.log("Pode dirigir!");
}
const diaSemana = 3;
let nomeDia;
switch (diaSemana) {
case 1:
nomeDia = "Segunda-feira";
break;
case 2:
nomeDia = "Terça-feira";
break;
case 3:
nomeDia = "Quarta-feira";
break;
case 4:
nomeDia = "Quinta-feira";
break;
case 5:
nomeDia = "Sexta-feira";
break;
case 6:
case 7:
nomeDia = "Fim de semana! 🎉";
break;
default:
nomeDia = "Dia inválido";
}
console.log(nomeDia); // "Quarta-feira"
Quando sabe quantas vezes repetir
for (let i = 0; i < 5; i++) {
console.log(i);
}
// 0, 1, 2, 3, 4
Para iterar arrays (valores)
const frutas = ["🍎", "🍌", "🍇"];
for (const fruta of frutas) {
console.log(fruta);
}
// 🍎, 🍌, 🍇
Para iterar objetos (chaves)
const pessoa = {nome: "Ana", idade: 25};
for (const chave in pessoa) {
console.log(chave, pessoa[chave]);
}
// nome Ana, idade 25
Enquanto condição for verdadeira
let x = 0;
while (x < 3) {
console.log(x);
x++;
}
// 0, 1, 2
// 1. Function Declaration (tradicional)
function somar(a, b) {
return a + b;
}
// 2. Function Expression
const subtrair = function(a, b) {
return a - b;
};
// 3. Arrow Function (ES6) ✨ - Mais usada atualmente
const multiplicar = (a, b) => {
return a * b;
};
// Arrow Function simplificada (retorno implícito)
const dividir = (a, b) => a / b;
// Com um parâmetro, parênteses são opcionais
const dobrar = n => n * 2;
// Usando as funções
console.log(somar(5, 3)); // 8
console.log(multiplicar(4, 2)); // 8
console.log(dobrar(10)); // 20
// Valores padrão
function saudar(nome = "Visitante", saudacao = "Olá") {
return `${saudacao}, ${nome}!`;
}
console.log(saudar()); // "Olá, Visitante!"
console.log(saudar("Maria")); // "Olá, Maria!"
console.log(saudar("João", "Oi")); // "Oi, João!"
// Rest parameters (...) - recebe múltiplos argumentos
function somarTodos(...numeros) {
return numeros.reduce((total, n) => total + n, 0);
}
console.log(somarTodos(1, 2, 3, 4, 5)); // 15
// Destructuring em parâmetros
function mostrarPessoa({ nome, idade, cidade = "Não informada" }) {
console.log(`${nome}, ${idade} anos, mora em ${cidade}`);
}
mostrarPessoa({ nome: "Ana", idade: 30, cidade: "SP" });
// "Ana, 30 anos, mora em SP"
[1,2,3].map(x => x * 2)
[1,2,3,4].filter(x => x > 2)
[1,2,3].reduce((a,b) => a+b, 0)
[1,2,3].find(x => x > 1)
[1,2,3].some(x => x > 2)
[1,2,3].every(x => x > 0)
const produtos = [
{ nome: "Camiseta", preco: 50, categoria: "roupa" },
{ nome: "Calça", preco: 120, categoria: "roupa" },
{ nome: "Tênis", preco: 200, categoria: "calçado" },
{ nome: "Boné", preco: 35, categoria: "acessório" }
];
// Filtrar apenas roupas
const roupas = produtos.filter(p => p.categoria === "roupa");
// [{nome: "Camiseta"...}, {nome: "Calça"...}]
// Pegar apenas os nomes
const nomes = produtos.map(p => p.nome);
// ["Camiseta", "Calça", "Tênis", "Boné"]
// Soma total dos preços
const total = produtos.reduce((soma, p) => soma + p.preco, 0);
// 405
// Encadeamento de métodos (muito comum!)
const totalRoupas = produtos
.filter(p => p.categoria === "roupa")
.map(p => p.preco)
.reduce((soma, preco) => soma + preco, 0);
// 170
// Encontrar produto mais caro
const maisCaro = produtos.reduce((max, p) =>
p.preco > max.preco ? p : max
);
// {nome: "Tênis", preco: 200, ...}
O DOM (Document Object Model) permite que JavaScript interaja com HTML e CSS.
// Por ID (retorna um elemento)
const header = document.getElementById("header");
// Por classe (retorna coleção)
const botoes = document.getElementsByClassName("btn");
// Por tag (retorna coleção)
const paragrafos = document.getElementsByTagName("p");
// querySelector - MAIS USADO! (retorna primeiro match)
const titulo = document.querySelector("h1");
const btnPrimario = document.querySelector(".btn-primary");
const inputEmail = document.querySelector("#email");
const primeiroLink = document.querySelector("nav a");
// querySelectorAll (retorna todos os matches)
const todosLinks = document.querySelectorAll("a");
const todasCards = document.querySelectorAll(".card");
const elemento = document.querySelector("#meuElemento");
// Alterar texto
elemento.textContent = "Novo texto";
// Alterar HTML interno
elemento.innerHTML = "<strong>Texto em negrito</strong>";
// Alterar atributos
elemento.setAttribute("data-id", "123");
elemento.id = "novoId";
elemento.src = "imagem.jpg"; // para imgs
// Manipular classes
elemento.classList.add("ativo");
elemento.classList.remove("inativo");
elemento.classList.toggle("visivel"); // adiciona/remove
elemento.classList.contains("ativo"); // true/false
// Alterar estilos diretamente
elemento.style.backgroundColor = "#667eea";
elemento.style.padding = "20px";
elemento.style.display = "none"; // esconde elemento
Eventos permitem responder a ações do usuário como cliques, teclas, scroll, etc.
const botao = document.querySelector("#meuBotao");
const input = document.querySelector("#meuInput");
// Evento de clique
botao.addEventListener("click", function(event) {
console.log("Botão clicado!");
console.log(event.target); // elemento clicado
});
// Com arrow function
botao.addEventListener("click", (e) => {
e.preventDefault(); // previne comportamento padrão
alert("Clicou!");
});
// Evento de input (digitação)
input.addEventListener("input", (e) => {
console.log("Digitou:", e.target.value);
});
// Evento de submit (formulário)
const form = document.querySelector("form");
form.addEventListener("submit", (e) => {
e.preventDefault(); // previne reload da página
const dados = new FormData(form);
console.log("Formulário enviado!", Object.fromEntries(dados));
});
// Eventos comuns:
// click, dblclick, mouseenter, mouseleave
// keydown, keyup, keypress
// submit, change, input, focus, blur
// scroll, resize, load
Resultado aparece aqui...
// Usando Promises (.then)
fetch("https://api.exemplo.com/dados")
.then(response => response.json())
.then(data => {
console.log(data);
})
.catch(error => {
console.error("Erro:", error);
});
// Usando async/await (mais moderno e legível)
async function buscarDados() {
try {
const response = await fetch("https://api.exemplo.com/dados");
const data = await response.json();
console.log(data);
return data;
} catch (error) {
console.error("Erro:", error);
}
}
// Exemplo prático: buscar usuários do GitHub
async function buscarUsuario(username) {
try {
const response = await fetch(`https://api.github.com/users/${username}`);
if (!response.ok) {
throw new Error("Usuário não encontrado");
}
const usuario = await response.json();
console.log(`Nome: ${usuario.name}`);
console.log(`Repositórios: ${usuario.public_repos}`);
return usuario;
} catch (error) {
console.error(error.message);
}
}
buscarUsuario("octocat");
Declare variáveis com const. Use
let apenas quando precisar reatribuir.
Comparação estrita evita bugs. === compara valor e
tipo.
Use usuarioAtivo em vez de ua. Código é
lido mais do que escrito.
Cada função deve fazer uma coisa. Se tem mais de 20 linhas, considere dividir.
var tem escopo de função e hoisting.
let e const são mais seguros.
Use console.log(), console.table(),
console.dir() para debugar.