Cheatsheet JavaScript

console.log("Hello World");

Mostra texto no console — útil para debug rápido.

typeof "abc"; // "string"

Retorna o tipo de uma variável.

+, -, *, /, %, ++, --

Operações básicas de matemática em JavaScript.

switch(day){ case 1: break; default: ... }

Alternativa para múltiplas comparações.

for(let key in obj){ console.log(key, obj[key]); }

Percorre propriedades de objetos.

const arr = [1, 2, 3, 4];

Coleção de valores indexados numericamente.

"name" in obj; obj.hasOwnProperty("age");

Checar se um objeto possui determinada propriedade.

// Comentário de uma linha

/* Comentário multilinha */

Permite adicionar notas que o JS ignora.

Number("123"); String(123); Boolean(0);

Converte valores entre tipos primitivos.

==, ===, !=, !==, <, <=, >, >=

Comparar valores e tipos.

for(let i=0; i<5; i++){ console.log(i); }

Repetição controlada por contador.

function soma(a,b){ return a+b; }

Declaração clássica de função.

console.log(arr[0]); // 1

Usa o índice para acessar elementos do array.

var a = 10; let b = 20; const c = 30;

var: escopo global/função, let: escopo de bloco, const: constante que não muda.

let a = "Hello"; let b = "World"; let c = a + " " + b;

Une strings usando +.

&& (E), || (OU), ! (NÃO)

Usados para combinar condições.

let i = 0; while(i<5){ console.log(i); i++; }

Executa enquanto a condição for verdadeira.

const soma = (a,b) => a+b;

Sintaxe curta e this léxico.

arr.push(5); arr.pop(); arr.shift(); arr.unshift(0);

Adicionar ou remover elementos do início ou fim do array.

String, Number, Boolean, null, undefined, Symbol

Tipos básicos do JavaScript.

let name = "Ana"; console.log(`Olá ${name}`);

Interpolação de variáveis em strings usando ``.

if (x > 10) { ... } else { ... }

Estrutura condicional básica.

for(let item of arr){ console.log(item); }

Percorre arrays facilmente.

const obj = {name: "Ana", age: 30};

Criação simples de objetos com propriedades.

console.log(obj.name); obj.age = 31;

Como ler e modificar propriedades de um objeto.

let num = 42;

Declara um número simples.

Math.ceil(0.8); // 1

Arredonda para cima.

let a = 1; a++; a--;

Aumenta ou diminui o valor em 1.

const hoje = new Date();

Cria objeto Date com data e hora atuais.

Date.now(); data.getTime();

Obtém o número de milissegundos desde 01/01/1970.

const d = new Date("2025-09-28T12:00:00");

Cria objeto Date a partir de string ISO.

let pi = 3.1415;

Números com casas decimais.

Math.random(); // 0 ≤ x < 1

Gera um número aleatório entre 0 e 1.

+, -, *, /, %

Adição, subtração, multiplicação, divisão e resto da divisão.

const data = new Date(2025, 8, 28);

Mês é 0-indexado (0 = Janeiro).

data1 < data2

Datas podem ser comparadas diretamente (timestamp implícito).

data.getDay(); // 0 = Domingo, 6 = Sábado

Obtém o dia da semana como número.

Math.round(0.8); // 1

Arredonda para o inteiro mais próximo.

Math.floor(Math.random() * (100 - 10 + 1)) + 10;

Gera um número inteiro aleatório entre 10 e 100.

Number("123"); parseInt("123"); parseFloat("123.45");

Converte strings em números inteiros ou decimais.

data.getDate(); data.getMonth(); data.getFullYear();

Obtém dia, mês e ano da data.

let novaData = new Date(data); novaData.setDate(novaData.getDate() + 5);

Cria nova data adicionando dias.

data.getTime() + data.getTimezoneOffset() * 60000;

Converte hora local em UTC em milissegundos.

Math.floor(0.8); // 0

Arredonda para baixo.

Math.min(1,5,10); Math.max(1,5,10);

Encontra o menor ou maior valor.

String(123); (123).toString();

Transforma números em texto.

data.getHours(); data.getMinutes(); data.getSeconds();

Obtém componentes de tempo.

data.toDateString(); data.toTimeString(); data.toISOString();

Mostra a data em diferentes formatos legíveis.

if (x > 10) { console.log("Maior que 10"); }

Executa o bloco se a condição for verdadeira.

for(let i = 0; i < 5; i++){ console.log(i); }

Executa um bloco um número conhecido de vezes.

for(let key in obj){ console.log(key, obj[key]); }

Percorre as propriedades enumeráveis de um objeto.

x > 5 && x < 10

Usa && (E), || (OU), ! (NÃO) para combinar condições.

if (x > 10) { ... } else { console.log("10 ou menor"); }

Executa o bloco alternativo se a condição do if for falsa.

let i = 0; while(i < 5){ console.log(i); i++; }

Executa enquanto a condição for verdadeira.

for(let i=0;i<10;i++){ if(i===5) break; }

Interrompe imediatamente o loop.

let result = value || "default";

Se value for falsy, usa o valor default.

if (x > 10) { ... } else if (x > 5) { ... } else { ... }

Permite testar várias condições em sequência.

let i = 0; do { console.log(i); i++; } while(i < 5);

Executa pelo menos uma vez antes de verificar a condição.

for(let i=0;i<5;i++){ if(i===2) continue; console.log(i); }

Pula a iteração atual e continua com a próxima.

switch(day) { case 1: ... break; default: ... }

Escolha entre múltiplas opções com base em um valor.

for(let item of arr){ console.log(item); }

Percorre valores de arrays ou iteráveis.

const status = x > 10 ? "big" : "small";

Forma curta de if/else para atribuição de valores.

const arr = [1,2,3,4];

Cria um array simples de valores indexados.

arr.unshift(0);

Adiciona elemento no início do array.

const filtered = arr.filter(x => x > 2);

Filtra elementos com base em condição.

arr.find(x => x > 2);

Retorna o primeiro elemento que satisfaz a condição.

const part = arr.slice(1,3);

Extrai uma parte do array sem modificar o original.

console.log(arr[0]);

Usa índice para acessar elementos.

arr.shift();

Remove o primeiro elemento do array.

const sum = arr.reduce((acc, x) => acc + x, 0);

Reduz array a um único valor acumulando resultados.

arr.findIndex(x => x > 2);

Retorna o índice do primeiro elemento que satisfaz a condição.

arr.splice(1,2,9,10);

Remove e/ou adiciona elementos no array.

arr.push(5);

Adiciona elemento no final do array.

arr.forEach(item => console.log(item));

Executa função para cada elemento do array.

arr.some(x => x > 3);

Retorna true se pelo menos um elemento satisfizer a condição.

arr.includes(3);

Verifica se um valor existe no array.

arr.pop();

Remove o último elemento do array.

const newArr = arr.map(x => x * 2);

Cria novo array transformando os elementos.

arr.every(x => x > 0);

Retorna true se todos os elementos satisfizerem a condição.

const arr2 = arr.concat([5,6]);

Concatena dois arrays em um novo.

function soma(a, b){ return a + b; }

Forma clássica de declarar funções.

function createUser(name){ return {name: name}; }

Função pode retornar objetos.

delete obj.age;

Remove propriedade do objeto.

const obj = {name:"Ana", show:()=>{ console.log(this.name); }}

Arrow functions não têm seu próprio this; ele é léxico.

const {name: firstName} = obj;

Extrai propriedade com nome diferente.

const [first, ...rest] = arr;

Captura o resto dos elementos em um array.

(function(){ console.log("executada imediatamente"); })();

Função que se autoexecuta ao ser definida.

const soma = (a, b) => a + b;

Sintaxe curta para funções; o this é léxico.

const obj = {name: "Ana", age: 30};

Criação simples de objeto com propriedades.

const obj = {greet: function(){ console.log("Olá"); }};

Funções atribuídas como propriedades são chamadas de métodos.

Object.keys(obj); Object.values(obj);

Obtém arrays de chaves ou valores do objeto.

const [a,b] = [1,2];

Extrai valores de arrays em variáveis.

function sum(...nums){ return nums.reduce((a,b)=>a+b,0); }

Permite receber número variável de argumentos.

arr.filter(x=>x>0).map(x=>x*2).reduce((a,b)=>a+b,0);

Combina várias operações de array de forma concisa.

function hello(){ console.log("Hello"); }

Função que não recebe argumentos.

console.log(obj.name); console.log(obj["age"]);

Duas formas de acessar valores de um objeto.

const obj = {greet(){ console.log("Olá"); }};

Forma curta de declarar métodos.

Object.entries(obj);

Retorna array de pares [chave, valor].

const obj2 = {...obj, city:"Lisboa"};

Cria novo objeto copiando propriedades e adicionando/alterando algumas.

function fatorial(n){ return n <= 1 ? 1 : n * fatorial(n-1); }

Função que chama a si mesma.

const user = {name:"Ana", age:30, greet(){ console.log(`Olá ${this.name}`); }};

Objeto completo com dados e comportamento.

function greet(name="Visitante"){ console.log(`Olá ${name}`); }

Define valores padrão caso nenhum argumento seja passado.

obj.city = "Lisboa";

Adiciona uma nova propriedade ao objeto.

const obj = {name:"Ana", show:function(){ console.log(this.name); }}

Em funções tradicionais, this refere-se ao objeto chamador.

const {name, age} = obj;

Extrai propriedades diretamente em variáveis.

const arr2 = [...arr, 4,5];

Cria novo array copiando elementos existentes.

const f = function(){ console.log("anônima"); };

Função sem nome atribuída a uma variável.

fetch("/api/data").then(res => res.json()).then(data => console.log(data));

Faz requisição HTTP e manipula JSON.

JSON.parse(str); JSON.stringify(obj);

Converte entre objetos e strings JSON.

const str = "Ele disse: \"Olá\"";

Usa \ para escapar caracteres especiais.

Inclua tokens únicos em formulários para prevenir CSRF.

Evita requisições maliciosas de outros sites.

Content-Security-Policy, X-Content-Type-Options, X-Frame-Options

Reduz ataques comuns via browser.

HSTS força o browser a usar HTTPS

Evita downgrade attacks.

Guarde apenas o necessário de cada usuário.

Reduz risco em caso de breach.

const data = await fetch("/api/data").then(res => res.json());

Escreve código assíncrono de forma sequencial.

element.textContent = userInput;

Não insira HTML de usuários diretamente com innerHTML.

Use bcrypt ou argon2 para senhas.

Nunca guarde senhas em texto simples.

Set-Cookie: key=value; SameSite=Strict

Protege cookies de serem enviados em requests cross-site.

Não use eval() em inputs de usuários.

Execução de código arbitrário é perigosa.

Não logue dados sensíveis em produção

Evita exposição de informações críticas.

Segurança deve ser sempre server-side, JS só auxilia na UX.

Evita falsas sensações de proteção.

localStorage.setItem("key","value"); localStorage.getItem("key");

Armazena dados persistentes no browser.

Use prepared statements ao enviar dados ao servidor.

Nunca concatene strings diretamente em queries SQL.

Use sempre conexões seguras (https) para dados sensíveis.

Evita interceptação de dados em redes públicas.

Remova caracteres perigosos antes de enviar para o servidor.

Evita XSS e injections.

Use HttpOnly e Secure cookies para JWTs

Evita acesso via JavaScript.

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

Regex simples para validar e-mails.

sessionStorage.setItem("key","value");

Armazena dados que duram apenas a sessão do browser.

if(/^\d+$/.test(input)){ ... }

Valida dados do usuário usando regex antes de processar.

Access-Control-Allow-Origin: https://meusite.com

Controla quais origens podem acessar a API.

Encode HTML antes de exibir no browser

Evita execução de scripts maliciosos.

Implemente lockout ou rate limiting

Previne brute force attacks.

/^\+?\d{9,15}$/

Regex para validar números internacionais.

const name = "Ana"; console.log(`Olá ${name}`);

Permite interpolação de variáveis dentro de strings.

const value = input ?? "default";

Usa "default" apenas se input for null ou undefined.

!true // false

Inverte valor booleano.

"abcde".match(/abc/);

Retorna array com correspondências ou null.

a{2} a{2,4} a{2,}

Indica quantas vezes o padrão deve repetir.

!!value

Converte qualquer valor em boolean true/false.

const clone = {...obj};

Copia objeto sem referência ao original.

const text = `linha1\nlinha2`;

Strings multilinha usando backticks (`).

const name = user?.profile?.name;

Evita erros se algum nível do objeto for undefined/null.

/abc/

Cria expressão regular simples para buscar padrão "abc".

"abcde".replace(/abc/, "XYZ");

Substitui padrão encontrado por outro texto.

^abc $abc

^ → início da string, $ → fim da string.

const [a,b] = arr; const {name,age} = obj;

Extrai valores de arrays e objetos facilmente.

false, 0, "", null, undefined, NaN

Valores que são considerados falsy em condições.

const value = input || "default";

Se input for falsy, usa "default".

const status = x > 10 ? "big" : "small";

Escolha rápida entre dois valores.

/abc/i

Flag "i" torna regex case-insensitive.

\. \d \w \s

\. → ponto literal, \d → dígito, \w → letra/número, \s → espaço.

const str = "Ele disse: \"Olá\"";

Usa \ para escapar caracteres especiais.

[a,b] = [b,a];

Troca valores sem variável temporária.

true, {}, [], 1, "text"

Valores que são considerados truthy em condições.

input && console.log(input);

Executa ação apenas se input for truthy.

let x = 0; x++; ++x; x--; --x;

Aumenta ou diminui o valor em 1.

/abc/.test("abcde"); // true

Verifica se string casa com regex.

[^a-z]

Qualquer caractere que não seja de "a" a "z".

+str // string para número

Usa operador + para converter string em número.

const clone = [...arr];

Copia array sem referência ao original.

Estruturas de dados fundamentais em JavaScript.

// Arrays
let frutas = ["maçã", "banana", "laranja"];
let numeros = new Array(1, 2, 3, 4, 5);

// Acessar elementos
console.log(frutas[0]);        // "maçã"
console.log(frutas.length);    // 3

// Adicionar/remover elementos
frutas.push("uva");           // Adiciona no final
frutas.unshift("manga");      // Adiciona no início
let ultimo = frutas.pop();     // Remove do final
let primeiro = frutas.shift(); // Remove do início

// Métodos úteis
frutas.includes("banana");     // Verificar se existe
frutas.indexOf("laranja");     // Encontrar índice

// Objetos
let pessoa = {
    nome: "João",
    idade: 30,
    cidade: "Lisboa",
    falar: function() {
        return `Olá, eu sou ${this.nome}`;
    }
};

// Acessar propriedades
console.log(pessoa.nome);      // "João"
console.log(pessoa["idade"]); // 30
console.log(pessoa.falar());   // "Olá, eu sou João"

// Adicionar/modificar propriedades
pessoa.email = "joao@email.com";
pessoa.idade = 31;

// Verificar propriedades
console.log("nome" in pessoa);           // true
console.log(pessoa.hasOwnProperty("nome")); // true

Métodos de array importantes:

• push/pop: Adicionar/remover do final
• unshift/shift: Adicionar/remover do início
• includes: Verificar se contém elemento
• map/filter/reduce: Transformar arrays

Fundamentos do JavaScript para começar a programar.

// Comentários
// Comentário de linha
/* Comentário de bloco */

// Variáveis
var nome = "João";        // Function scope
let idade = 25;           // Block scope
const PI = 3.14159;       // Constante

// Tipos de dados
let texto = "string";
let numero = 42;
let decimal = 3.14;
let booleano = true;
let nulo = null;
let indefinido = undefined;

// Saída
console.log("Olá mundo");
console.error("Erro!");
console.warn("Aviso!");

// Alert (no browser)
alert("Mensagem");

Diferenças entre var, let, const:

• var: Escopo de função, pode ser redeclarada
• let: Escopo de bloco, pode ser reatribuída
• const: Escopo de bloco, não pode ser reatribuída