• Leia rápido. Se você reconhece o tópico e sabe o snippet de cor, siga. Se travou, é sinal de estudar.
• Os → aprofunde em… apontam para as apostilas completas: JavaScript Fullstack, Full Stack com TypeScript & Next.js, Next.js, DevTools & Debug, Aceleração de Código com IA.
• As caixas ⚠️ armadilha são o que mais cai em entrevista e o que mais gera bug — não pule.
• A auto-checagem no fim de cada seção: se você não responde de cabeça, volte.
• O checklist final é a lista literal para marcar antes de dizer "sei o básico de JS".

Checagem e igualdade

typeof x               // "string" | "number" | ... | "object" | "function" | "undefined"
Array.isArray(x)       // typeof [] é "object" — use isso p/ array
x === y                // SEMPRE. Sem coerção.
x == y                 // coage — evite. Exceção comum: x == null pega null E undefined
Number.isNaN(x)        // NaN !== NaN — a única forma correta de testar NaN
Object.is(x, y)        // como === mas Object.is(NaN,NaN)===true e -0 !== +0

Truthy / falsy

Falsy (só estes 8): false, 0, -0, 0n, "", null, undefined, NaN. Todo o resto é truthy — incluindo "0", "false", [], {}.

Closure

Uma função "lembra" as variáveis do escopo onde foi criada, mesmo depois que esse escopo terminou.

function contador() {
  let n = 0;
  return () => ++n;   // esta arrow fecha sobre `n`
}
const next = contador();
next(); next();          // 1, 2 — `n` sobrevive, privado

Usos: estado privado, memoização, factories, handlers que capturam contexto.

function f(a, b = 1, ...rest) { }   // default + rest params
const g = (a, b) => a + b;           // arrow: retorno implícito, sem { }
const h = a => ({ a });               // retornar objeto: parênteses
(function(){ ... })();               // IIFE

As 4 regras de this (para function, resolvido na CHAMADA)

Arrow function: não tem this próprio — usa o do escopo onde foi definida (lexical). Também não tem arguments, não serve de construtor, não tem prototype.

// literal + shorthand + computed key
const nome = "Ana", chave = "id";
const u = { nome, [chave]: 1, saudar() { return `Oi, ${this.nome}` } };

// destructuring (com default e rename)
const { nome: n, idade = 0, ...resto } = u;
const [primeiro, , terceiro] = arr;
function f({ a, b = 10 }) { }         // destructuring em parâmetro

// spread (cópia RASA) e merge
const copia = { ...u, idade: 30 };       // último vence
const arr2 = [...a, ...b, 99];

// acesso seguro
u?.endereco?.rua               // undefined se algo no caminho for null/undefined
u.telefone ?? "sem tel"          // fallback SÓ se null/undefined (não se 0 ou "")
u.lista?.[0]                   // optional chaining com índice
minhaFn?.()                   // chama só se existir

Utilitários de objeto

Object.keys(o) / .values(o) / .entries(o)   // arrays
Object.assign(alvo, ...fontes)               // merge raso (muta alvo)
Object.freeze(o)                             // imutável raso
structuredClone(o)                           // cópia PROFUNDA (moderno)
JSON.parse(JSON.stringify(o))                // cópia profunda antiga (perde Date, undefined, fn...)
"x" in o  /  o.hasOwnProperty("x")  /  Object.hasOwn(o, "x")

// encadeamento típico
const total = pedidos
  .filter(p => p.pago)
  .map(p => p.valor)
  .reduce((s, v) => s + v, 0);

// iterar: for...of dá break/continue e await; forEach não
for (const item of lista) { if (cond) break; }

Event loop em uma frase

A stack roda até esvaziar; então processa todas as microtasks (Promises, queueMicrotask); depois uma macrotask (timer, evento, I/O); repete. Por isso Promise.then roda antes de setTimeout(…, 0).

const p = new Promise((resolve, reject) => { ... });   // pending → fulfilled | rejected
p.then(v => ...).catch(e => ...).finally(() => ...);

async function f() {
  try {
    const a = await fetch(url);           // pausa a função, não a thread
    const data = await a.json();
    return data;                        // async sempre retorna Promise
  } catch (e) { ... }                    // pega rejeições dos await
}

Combinadores

// paralelo (as 3 disparam juntas):
const [a, b, c] = await Promise.all([getA(), getB(), getC()]);
// sequencial (uma espera a outra) — só se houver dependência:
for (const id of ids) { await processar(id); }

class Animal {
  #energia = 100;                 // campo privado (só dentro da classe)
  static reino = "Animalia";      // na classe, não na instância
  constructor(nome) { this.nome = nome; }
  mover() { this.#energia--; }
  get vivo() { return this.#energia > 0; }   // getter: acessa como propriedade
}
class Gato extends Animal {
  constructor(nome) { super(nome); }        // super() antes de usar this
  mover() { super.mover(); console.log("miau"); }
}
const g = new Gato("Tom");
g instanceof Animal;   // true

Por baixo

• Todo objeto tem um protótipo (Object.getPrototypeOf(o)); acessar o.x sobe a cadeia até achar ou chegar a null.
• Métodos de classe ficam no Prototype (compartilhados); campos de instância são copiados por objeto.
• class não é hoisted (TDZ); o corpo roda em strict mode.

// export
export const PI = 3.14;              // named
export function soma(a, b) {}       // named
export default class Cliente {}     // default (um por arquivo)
export { a, b as bee };              // lista / rename

// import
import Cliente, { PI, soma } from "./mod.js";
import * as mod from "./mod.js";
const m = await import("./pesado.js");   // dinâmico → code splitting

try {
  arriscado();
} catch (e) {
  if (e instanceof TypeError) { ... }
  throw new Error(`ao processar: ${e.message}`, { cause: e });  // re-lança com contexto
} finally {
  limpar();   // sempre roda
}

class ValidationError extends Error {
  constructor(campo) { super(`inválido: ${campo}`); this.name = "ValidationError"; this.campo = campo; }
}

• throw pode lançar qualquer valor, mas sempre lance um Error (tem stack, name, message).
• Error.cause (ES2022) encadeia o erro original.
• Assíncrono: await dentro de try/catch captura rejeições; .catch() na Promise faz o mesmo.
• Globais: window.addEventListener("unhandledrejection", …) e "error" (browser); process.on("unhandledRejection", …) (Node).