JavaScript

Cartões · 53

Variável let

let idade = 25; idade = 26; // Usado para valores que mudam ao longo da execução do código no mesmo escopo de bloco.

Constante const

const PI = 3.14; // Usado por padrão para valores e referências que não devem ser reatribuídos.

Variável var

var nome = 'Ana'; // Escopo de função com hoisting; evitado no JS moderno em favor de let e const.

Tipo String

let texto = 'Olá Mundo'; // Usado para representar e manipular dados textuais.

Tipo Number

let preco = 19.99; // Usado para cálculos matemáticos inteiros ou decimais.

Tipo Boolean

let ativo = true; // Usado em tomadas de decisão e estruturas condicionais.

Tipo Undefined

let x; console.log(x); // Usado automaticamente pelo JS para variáveis declaradas sem valor atribuído.

Tipo Null

let usuario = null; // Usado explicitamente pelo programador para indicar ausência intencional de valor.

Template Literals

const msg = `Olá, ${nome}!`; // Usado para interpolar variáveis e expressões diretamente em strings.

Estrutura if / else

if (idade >= 18) { acesso = true; } else { acesso = false; } // Usado para bifurcar a lógica com base em condições.

Operador Ternário

const status = idade >= 18 ? 'Adulto' : 'Menor'; // Usado como atalho simples para atribuições condicionais if/else.

Estrutura switch

switch(cor) { case 'azul': return 1; default: return 0; } // Usado para substituir múltiplos if/else quando se avalia um único valor.

Operador de Igualdade Estrita (===)

1 === '1'; // false. Usado para comparar valor e tipo simultaneamente sem coerção implícita.

Operador Lógico E (&&)

if (temIdade && temCNH) { dirigir(); } // Usado para checar se múltiplas condições são verdadeiras.

Operador Lógico OU (||)

if (isAdmin || isEditor) { editar(); } // Usado para checar se ao menos uma condição é verdadeira.

Operador de Coalescência Nula (??)

const valor = input ?? 'padrão'; // Usado para atribuir valor alternativo apenas se o anterior for null ou undefined.

Laço for

for (let i = 0; i < 5; i++) { console.log(i); } // Usado para iterar um número determinado de vezes.

Laço while

while (saldo > 0) { pagar(); } // Usado para repetir tarefas enquanto uma condição permanecer verdadeira.

Laço for...of

for (const item of lista) { console.log(item); } // Usado para iterar diretamente sobre valores de arrays ou iteráveis.

Laço for...in

for (const chave in obj) { console.log(chave); } // Usado para iterar sobre as chaves enumeráveis de um objeto.

Função Tradicional (function)

function somar(a, b) { return a + b; } // Usado para criar blocos de lógica reutilizáveis com suporte a hoisting.

Arrow Function

const dobro = n => n * 2; // Usado para sintaxe concisa e para herdar lexicalmente o escopo do 'this'.

Parâmetro Padrão

function ola(nome = 'Visitante') { return nome; } // Usado para evitar valores undefined quando argumentos não são passados.

Função Anônima

btn.onclick = function() { alert('clicado'); }; // Usado quando uma função é passada como callback pontual sem nome.

Array (Criação e Acesso)

const cores = ['azul', 'verde']; cores[0]; // Usado para armazenar e acessar coleções ordenadas de dados.

Array: push e pop

arr.push('fim'); arr.pop(); // Usado para adicionar ou remover itens no final de uma lista.

Array: unshift e shift

arr.unshift('início'); arr.shift(); // Usado para inserir ou retirar itens do começo de uma lista.

Array.prototype.map

const dobro = nums.map(n => n * 2); // Usado para transformar cada elemento de um array gerando um novo array.

Array.prototype.filter

const pares = nums.filter(n => n % 2 === 0); // Usado para selecionar apenas os itens que cumprem um critério.

Array.prototype.reduce

const soma = nums.reduce((acc, n) => acc + n, 0); // Usado para acumular os valores de um array em um resultado único.

Array.prototype.forEach

itens.forEach(item => console.log(item)); // Usado para executar efeitos colaterais para cada elemento de um array.

Array.prototype.find

const usuario = lista.find(u => u.id === 5); // Usado para obter o primeiro item que satisfaz uma condição.

Array.prototype.includes

['a', 'b'].includes('a'); // true. Usado para testar rapidamente se um item está presente na lista.

Objeto Literal

const user = { nome: 'João', idade: 30 }; // Usado para agrupar propriedades e comportamentos relacionados.

Acesso a Propriedades (Ponto e Colchetes)

user.nome; user['idade']; // Usado para ler dados de objetos estaticamente ou via chave dinâmica.

Desestruturação de Objetos

const { nome, idade } = usuario; // Usado para extrair propriedades de objetos em variáveis individuais.

Desestruturação de Arrays

const [primeiro, segundo] = lista; // Usado para capturar posições específicas de um array em variáveis.

Operador Spread (...)

const novo = [...antigo, 4]; // Usado para clonar ou mesclar elementos de arrays e objetos.

Operador Rest (...)

function somar(...nums) { return nums.length; } // Usado para capturar um número indefinido de parâmetros em um array.

Encadeamento Opcional (?.)

const rua = user?.endereco?.rua; // Usado para acessar propriedades aninhadas com segurança sem lançar erro.

JSON.stringify e JSON.parse

const str = JSON.stringify(obj); JSON.parse(str); // Usado para serializar objetos para texto e desserializar texto para objeto.

Tratamento de Exceções: try / catch

try { JSON.parse(str); } catch (e) { console.error(e); } // Usado para capturar erros em tempo de execução sem travar a aplicação.

Instrução throw

if (!nome) throw new Error('Nome obrigatório'); // Usado para disparar erros customizados deliberadamente.

setTimeout

setTimeout(() => console.log('Tempo!'), 1000); // Usado para adiar a execução de uma ação por determinado intervalo de ms.

setInterval

const id = setInterval(() => tick(), 1000); // Usado para repetir uma função periodicamente até ser cancelada com clearInterval.

Promise

new Promise((res, rej) => res('OK')).then(console.log); // Usado para gerenciar operações assíncronas futuras e seus estados.

async / await

async function buscar() { const res = await fetch(url); } // Usado para escrever código assíncrono com sintaxe limpa e linear.

fetch API

fetch('/api/dados').then(r => r.json()); // Usado para disparar requisições HTTP e consumir dados de servidores e APIs.

Escopo de Bloco

{ let x = 10; } // x não existe fora. Usado para encapsular variáveis dentro de { } e evitar conflitos globais.

Closure

function criar() { let c = 0; return () => ++c; } // Usado para criar dados privados e funções que retêm o escopo externo.

Palavra-chave this

const obj = { nome: 'A', falar() { return this.nome; } }; // Usado para fazer referência ao contexto atual de execução do objeto.

Classes em JS

class Animal { constructor(nome) { this.nome = nome; } } // Usado para criar moldes de objetos orientados a objetos modernos.

Módulos: import e export

export const soma = (a, b) => a + b; import { soma } from './m'; // Usado para dividir e reutilizar código entre arquivos diferentes.