⚡ Interatividade e Dinamismo

Aprenda JavaScript

A linguagem de programação que dá vida às páginas web. Aprenda a criar interações, manipular dados e construir aplicações completas.

40+ Conceitos
30+ Exemplos
15+ Desafios
app.js
const mensagem = "Olá, Mundo!";

function saudar(nome) {
    return `Bem-vindo, ${nome}!`;
}

console.log(saudar("Dev"));
// Output: Bem-vindo, Dev!
JavaScript

A Linguagem da Web

JavaScript é a linguagem de programação mais popular do mundo, responsável por toda a interatividade nas páginas web modernas.

🌐

Executa no Navegador

JavaScript roda diretamente no browser, sem necessidade de instalar nada. Todo navegador moderno já suporta!

🎨

Manipula o DOM

Permite modificar HTML e CSS dinamicamente, criando interfaces interativas e responsivas.

🔄

Assíncrono

Executa operações sem travar a página, como carregar dados de APIs ou responder a eventos.

🚀

Full Stack

Com Node.js, JavaScript também funciona no servidor, permitindo criar aplicações completas!

📚 Fundamentos

Conceitos Básicos

Domine os fundamentos do JavaScript antes de avançar para tópicos mais complexos.

📦 Variáveis e Constantes

Variáveis são containers para armazenar dados. Em JavaScript moderno, usamos let e const.

let

Valor pode ser alterado

Escopo de bloco

Ideal para valores que mudam

const

Valor não pode ser reatribuído

Escopo de bloco

Ideal para valores fixos

var (evitar)

Escopo de função

Sofre "hoisting"

⚠️ Pode causar bugs

Exemplos
// 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
💡
Dica: Sempre comece com const. Só use let quando realmente precisar mudar o valor. Nunca use var em código moderno.

🔤 Tipos de Dados

JavaScript tem tipos primitivos e tipos de referência (objetos).

String
Texto
"Olá" ou 'Olá' ou `Olá`
Number
Números
42, 3.14, -10
Boolean
Verdadeiro/Falso
true, false
Undefined
Não definido
undefined
Null
Vazio intencional
null
Array
Lista ordenada
[1, 2, 3]
Object
Coleção de dados
{nome: "João"}
Symbol
Identificador único
Symbol("id")
Verificando Tipos
// 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

Operadores

Aritméticos

+ Adição
- Subtração
* Multiplicação
/ Divisão
% Resto (módulo)
** Exponenciação
++ Incremento
-- Decremento

Comparação

== Igual (valor)
=== Igual (valor e tipo)
!= Diferente (valor)
!== Diferente (valor e tipo)
> Maior
< Menor
>= Maior ou igual
<= Menor ou igual

Lógicos

&& E (AND)
|| OU (OR)
! NÃO (NOT)
?? Nullish coalescing
== vs === (Importante!)
// == 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!

📝 Strings (Texto)

Template Literals (Crase `)
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étodos Úteis de String

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"
🔀 Controle de Fluxo

Condicionais e Loops

Condicionais (if/else)

If, Else If, Else
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!");
}

🔄 Switch Case

Quando usar switch
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"

🔁 Loops (Repetição)

for

Quando sabe quantas vezes repetir

for (let i = 0; i < 5; i++) {
    console.log(i);
}
// 0, 1, 2, 3, 4

for...of

Para iterar arrays (valores)

const frutas = ["🍎", "🍌", "🍇"];
for (const fruta of frutas) {
    console.log(fruta);
}
// 🍎, 🍌, 🍇

for...in

Para iterar objetos (chaves)

const pessoa = {nome: "Ana", idade: 25};
for (const chave in pessoa) {
    console.log(chave, pessoa[chave]);
}
// nome Ana, idade 25

while

Enquanto condição for verdadeira

let x = 0;
while (x < 3) {
    console.log(x);
    x++;
}
// 0, 1, 2
⚙️ Funções

Blocos de Código Reutilizáveis

📦 Declarando Funções

Diferentes formas de criar funções
// 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

🎯 Parâmetros e Valores Padrão

Parâmetros avançados
// 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"
📚 Arrays

Trabalhando com Listas

📋 Métodos Essenciais de Array

.map()
Transforma cada elemento
[1,2,3].map(x => x * 2)
→ [2, 4, 6]
.filter()
Filtra elementos
[1,2,3,4].filter(x => x > 2)
→ [3, 4]
.reduce()
Reduz a um valor
[1,2,3].reduce((a,b) => a+b, 0)
→ 6
.find()
Encontra primeiro match
[1,2,3].find(x => x > 1)
→ 2
.some()
Algum passa no teste?
[1,2,3].some(x => x > 2)
→ true
.every()
Todos passam no teste?
[1,2,3].every(x => x > 0)
→ true
Exemplos Práticos
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, ...}
🌐 DOM

Manipulando a Página

O DOM (Document Object Model) permite que JavaScript interaja com HTML e CSS.

🔍 Selecionando Elementos

Métodos de Seleção
// 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");

✏️ Modificando Elementos

Alterando conteúdo e estilos
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

Eventos permitem responder a ações do usuário como cliques, teclas, scroll, etc.

addEventListener
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

🎮 Teste ao Vivo

Resultado aparece aqui...

⏱️ Assíncrono

Promises e Async/Await

🔄 Fetch API - Consumindo APIs

Buscando dados de uma API
// 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");
💡 Dicas

Boas Práticas

01

Use const por padrão

Declare variáveis com const. Use let apenas quando precisar reatribuir.

02

Sempre use ===

Comparação estrita evita bugs. === compara valor e tipo.

03

Nomes descritivos

Use usuarioAtivo em vez de ua. Código é lido mais do que escrito.

04

Funções pequenas

Cada função deve fazer uma coisa. Se tem mais de 20 linhas, considere dividir.

05

Evite var

var tem escopo de função e hoisting. let e const são mais seguros.

06

Console é seu amigo

Use console.log(), console.table(), console.dir() para debugar.

Pronto para Mais?

Continue aprendendo com nossos outros conteúdos!

💻 Ver Git