Dicionário de dados e conceitos

Termos de Python, JavaScript, TypeScript, SQL, React, Next.js, web e Git — com definição curta e exemplo de código.

118 termos

?? e ?. (nullish)
JavaScript
a ?? b usa b apenas se a for null/undefined (diferente de ||, que também troca 0 e ""). obj?.prop acessa sem erro se obj for null/undefined.
Ver exemplo
```
const porPagina = params.limite ?? 10;
const cidade = usuario?.endereco?.cidade;
```
'use client'
Next.js
Diretiva no topo do arquivo que o transforma em Client Component — necessário para estado, efeitos, eventos e APIs do navegador.
Ver exemplo
```
"use client";
import { useState } from "react";
```
@dataclass
Python
Decorator que gera automaticamente __init__, __repr__ e __eq__ a partir das anotações dos campos. Ideal para objetos que guardam dados.
Ver exemplo
```
from dataclasses import dataclass

@dataclass
class Ponto:
    x: float
    y: float = 0.0
```
*args e **kwargs
Python
*args recebe argumentos posicionais extras como tupla; **kwargs recebe argumentos nomeados extras como dicionário. Também servem para 'espalhar' listas/dicts em chamadas.
Ver exemplo
```
def log(*args, **kwargs):
    print(args, kwargs)

log(1, 2, nivel="info")  # (1, 2) {'nivel': 'info'}
```
=== vs ==
JavaScript
=== compara valor E tipo (use sempre). == converte tipos antes de comparar e gera surpresas.
Ver exemplo
```
0 == ""    // true  😱
0 === ""   // false ✅
```
Anotação de tipo
TypeScript
Declarar explicitamente o tipo de uma variável, parâmetro ou retorno com : Tipo. Onde o TS consegue inferir, a anotação é opcional.
Ver exemplo
```
function area(largura: number, altura: number): number {
  return largura * altura;
}
```
API
Web/APIs
Application Programming Interface: contrato que permite um sistema conversar com outro. Na web, normalmente endpoints HTTP que recebem e devolvem JSON.
Ver exemplo
```
const resposta = await fetch("https://api.github.com/users/octocat");
const dados = await resposta.json();
```
App Router
Next.js
Sistema de rotas do Next.js baseado em pastas dentro de app/. Arquivos especiais: page.tsx, layout.tsx, loading.tsx, error.tsx, not-found.tsx, route.ts. [param] cria segmentos dinâmicos.
Ver exemplo
```
app/
  layout.tsx
  page.tsx            → /
  vagas/[id]/page.tsx → /vagas/123
```
Array
JavaScript
Lista ordenada. Métodos que NÃO alteram: map, filter, reduce, slice, concat, find, some, every, toSorted. Métodos que ALTERAM: push, pop, splice, sort, reverse.
Ver exemplo
```
const nums = [3, 1, 2];
nums.includes(2);  // true
nums.at(-1);       // 2
```
Arrow function
JavaScript
Sintaxe curta de função: (params) => expressão. Não tem seu próprio this (herda do escopo externo), o que é útil em callbacks.
Ver exemplo
```
const dobro = (n) => n * 2;
const soma = (a, b) => {
  return a + b;
};
```
async / await
JavaScript
Sintaxe para escrever código assíncrono como se fosse síncrono. await pausa a função async até a Promise resolver; trate erros com try/catch. Python tem o mesmo conceito (asyncio).
Ver exemplo
```
async function carregar() {
  try {
    const r = await fetch("/api/vagas");
    return await r.json();
  } catch (e) {
    return [];
  }
}
```
Busca binária
Geral
Algoritmo que encontra um valor em uma lista ORDENADA dividindo o intervalo pela metade a cada passo. Complexidade O(log n): 1 milhão de itens em ~20 passos.
Ver exemplo
```
meio = (inicio + fim) // 2
```
Cache / memoização
Geral
Guardar resultados já calculados para reutilizar. Memoização é o cache de resultados de uma função. Em Python existe functools.lru_cache; na web, Redis e cache HTTP.
Ver exemplo
```
from functools import lru_cache

@lru_cache
def fib(n): ...
```

CASE WHEN

SQL

O 'if' do SQL: gera valores condicionais em uma coluna.

Ver exemplo

SELECT nome,
  CASE WHEN estoque = 0 THEN 'esgotado' ELSE 'ok' END AS situacao
FROM produtos;

Chave primária e estrangeira
SQL
Primária (PK) identifica cada linha de forma única. Estrangeira (FK) referencia a PK de outra tabela, garantindo integridade dos relacionamentos.
Ver exemplo
```
cliente_id INTEGER REFERENCES clientes(id)
```
CI/CD
Geral
Integração contínua (build, lint e testes a cada push) e entrega/implantação contínua (deploy automático). No GitHub: GitHub Actions.
Ver exemplo
```
# .github/workflows/ci.yml
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm test
```
Classe
Geral
Molde para criar objetos que juntam dados (atributos) e comportamentos (métodos). Cada objeto criado é uma instância.
Ver exemplo
```
class Cachorro:
    def __init__(self, nome):
        self.nome = nome

    def latir(self):
        return f"{self.nome}: au!"
```
Closure
Geral
Função que 'lembra' as variáveis do escopo onde foi criada, mesmo depois que esse escopo terminou. Base de decorators, hooks do React e estado privado.
Ver exemplo
```
function contador() {
  let n = 0;
  return () => ++n;
}
const c = contador();
c(); c(); // 2
```
Códigos de status HTTP
Web/APIs
2xx sucesso (200 OK, 201 Created, 204 No Content); 3xx redirecionamento; 4xx erro do cliente (400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 422 Unprocessable, 429 Too Many Requests); 5xx erro do servidor.
Ver exemplo
```
return Response.json({ erro: "não encontrado" }, { status: 404 });
```
Complexidade (Big O)
Geral
Forma de descrever como o tempo/memória cresce com o tamanho da entrada. O(1) constante, O(log n) busca binária, O(n) um laço, O(n²) laços aninhados. Tema frequente em entrevistas.
Ver exemplo
```
# O(n²): compara todos com todos
for a in nums:
    for b in nums: ...

# O(n): um passe + dicionário
vistos = {}
```
Componente
React
Função que recebe props e retorna JSX. Nome sempre com letra maiúscula. Componha a UI a partir de componentes pequenos.
Ver exemplo
```
function Card({ titulo }: { titulo: string }) {
  return <div className="card">{titulo}</div>;
}
```
Comprehension
Python
Sintaxe compacta para criar listas, dicts e sets a partir de iteráveis, com filtro opcional. Mais legível e rápida que um for com append.
Ver exemplo
```
[n * 2 for n in nums if n > 0]
{u.id: u for u in usuarios}
```
Condicionais (if / elif / else)
Geral
Executam blocos diferentes conforme condições. São avaliadas de cima para baixo; a primeira verdadeira vence. Em JS: if / else if / else.
Ver exemplo
```
if nota >= 7:
    print("aprovado")
elif nota >= 5:
    print("recuperação")
else:
    print("reprovado")
```
Conjunto (set)
Python
Coleção sem ordem e sem repetição, com busca O(1). Suporta operações de conjunto: | união, & interseção, - diferença.
Ver exemplo
```
a = {1, 2, 3}
b = {2, 3, 4}
a & b   # {2, 3}
set([1, 1, 2])  # {1, 2}
```
Context manager (with)
Python
Objeto com __enter__/__exit__ que garante limpeza de recursos mesmo com erro: arquivos, conexões, locks, transações.
Ver exemplo
```
with open("dados.txt") as f:
    conteudo = f.read()
# arquivo fechado automaticamente
```
CORS
Web/APIs
Cross-Origin Resource Sharing: regra do navegador que bloqueia chamadas entre origens diferentes, a menos que o servidor responda com headers permitindo (Access-Control-Allow-Origin).
Ver exemplo
```
Access-Control-Allow-Origin: https://meusite.com
```
CTE (WITH)
SQL
Common Table Expression: uma consulta nomeada e temporária que deixa SQL complexo legível, como variáveis.
Ver exemplo
```
WITH caros AS (
  SELECT * FROM produtos WHERE preco > 1000
)
SELECT COUNT(*) FROM caros;
```
DDL (CREATE, ALTER, DROP)
SQL
Comandos que definem a estrutura: criar tabelas, colunas, índices e restrições (NOT NULL, UNIQUE, CHECK, DEFAULT). Em projetos, feitos via migrations.
Ver exemplo
```
CREATE TABLE tags (
  id INTEGER PRIMARY KEY,
  nome TEXT NOT NULL UNIQUE
);
```
Decorator
Python
Função que recebe uma função e devolve outra, adicionando comportamento (log, cache, autenticação). Aplicado com @. Muito usado em Flask/FastAPI.
Ver exemplo
```
@app.get("/vagas")
def listar_vagas(): ...
```
Desempacotamento
Python
Atribuir os elementos de uma sequência a várias variáveis de uma vez. * captura o resto.
Ver exemplo
```
a, b = b, a            # troca
primeiro, *resto = [1, 2, 3]
```
Destructuring
JavaScript
Extrai valores de objetos/arrays para variáveis. Muito usado em props do React e em retornos de hooks.
Ver exemplo
```
const { nome, idade = 0 } = usuario;
const [estado, setEstado] = useState(0);
```
Dicionário (dict)
Python
Estrutura chave → valor com busca muito rápida (O(1)). Preserva a ordem de inserção. Métodos: get, items, keys, values, setdefault, update.
Ver exemplo
```
u = {"nome": "Ana", "idade": 28}
u.get("email", "—")  # '—'
for chave, valor in u.items(): ...
```
Discriminated union
TypeScript
União de objetos com um campo literal comum (ex: type, kind, ok) que permite ao TS saber exatamente qual variante você está tratando. Base de reducers e tratamento de erros.
Ver exemplo
```
type Acao =
  | { type: "somar"; valor: number }
  | { type: "zerar" };
```
DML (INSERT, UPDATE, DELETE)
SQL
Comandos que alteram dados. Sempre use WHERE em UPDATE/DELETE (senão afeta a tabela inteira) e prefira fazê-los dentro de transações.
Ver exemplo
```
UPDATE produtos SET preco = preco * 0.9 WHERE categoria = 'Móveis';
```
Docker
Geral
Empacota a aplicação e suas dependências em imagens que rodam igual em qualquer máquina, como containers. docker compose sobe vários serviços juntos (app + banco).
Ver exemplo
```
FROM python:3.12-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["uvicorn", "main:app", "--host", "0.0.0.0"]
```
enumerate() e zip()
Python
enumerate devolve pares (índice, item); zip percorre várias sequências em paralelo. Evite for i in range(len(lista)).
Ver exemplo
```
for i, nome in enumerate(nomes, start=1): ...
for nome, nota in zip(nomes, notas): ...
```
Escopo
Geral
Região do código onde uma variável existe. let e const têm escopo de bloco ({ }); var tem escopo de função (evite). Em Python, funções criam escopo, mas if/for não.
Ver exemplo
```
if (true) {
  const x = 1;
}
// x não existe aqui
```
Event loop
JavaScript
Mecanismo que permite ao JS (single-thread) lidar com tarefas assíncronas: executa o código síncrono, depois a fila de microtasks (Promises) e então macrotasks (setTimeout, I/O).
Ver exemplo
```
setTimeout(() => console.log("2º"), 0);
Promise.resolve().then(() => console.log("1º"));
```
Exceção (try/except)
Python
Erros em tempo de execução que interrompem o fluxo. Trate com try/except (capture tipos específicos!) e lance com raise. finally sempre executa.
Ver exemplo
```
try:
    n = int(texto)
except ValueError:
    n = 0
finally:
    print("fim")
```
f-string
Python
String com prefixo f que interpola expressões entre chaves. Aceita formatação: {valor:.2f} (2 casas), {n:,} (milhar), {texto!r} (repr).
Ver exemplo
```
preco = 9.5
print(f"Total: R$ {preco:.2f}")  # Total: R$ 9.50
```
Fatiamento (slice)
Python
Extrai partes de sequências com [início:fim:passo]. Não inclui o fim. [::-1] inverte.
Ver exemplo
```
s = "python"
s[0:2]   # 'py'
s[-3:]   # 'hon'
s[::-1]  # 'nohtyp'
```
Função
Geral
Bloco de código nomeado e reutilizável que recebe parâmetros e pode retornar um valor. Prefira funções pequenas que fazem uma coisa só.
Ver exemplo
```
def soma(a, b):
    return a + b
```
Funções de agregação
SQL
COUNT, SUM, AVG, MIN e MAX resumem várias linhas em uma. COUNT(*) conta linhas; COUNT(coluna) ignora NULLs.
Ver exemplo
```
SELECT COUNT(*), AVG(salario) FROM funcionarios;
```
Generics
TypeScript
Parâmetros de tipo (<T>) que tornam funções, classes e tipos reutilizáveis mantendo a segurança de tipos. Ex: Array<T>, Promise<T>, useState<T>.
Ver exemplo
```
function primeiro<T>(lista: T[]): T | undefined {
  return lista[0];
}
primeiro([1, 2]); // number | undefined
```
Gerador (yield)
Python
Função que produz valores sob demanda com yield, pausando entre eles. Economiza memória em grandes volumes (ler arquivos, paginar APIs).
Ver exemplo
```
def contagem(n):
    while n > 0:
        yield n
        n -= 1
```
Git
Git/Terminal
Sistema de controle de versão distribuído. Comandos essenciais: init, clone, status, add, commit, push, pull, switch, merge, log, diff.
Ver exemplo
```
git switch -c feature/filtro
git add .
git commit -m "feat: filtro de vagas"
git push -u origin feature/filtro
```
GROUP BY / HAVING
SQL
GROUP BY agrupa linhas com o mesmo valor para agregar por grupo. HAVING filtra os grupos (WHERE filtra linhas antes de agrupar).
Ver exemplo
```
SELECT categoria, COUNT(*) AS qtd
FROM produtos
GROUP BY categoria
HAVING COUNT(*) > 2;
```
Herança
Geral
Uma classe filha reaproveita atributos e métodos de uma classe mãe, podendo sobrescrevê-los. Use com moderação: muitas vezes composição é melhor.
Ver exemplo
```
class Animal: ...
class Gato(Animal): ...
```
Hidratação
Next.js
Processo em que o React no navegador conecta eventos e estado ao HTML que veio do servidor. Divergências entre servidor e cliente geram 'hydration errors'.
Ver exemplo
```
// ❌ causa erro de hidratação
<p>{Math.random()}</p>
```
Hooks
React
Funções use* que dão estado e ciclo de vida a componentes de função: useState, useEffect, useMemo, useCallback, useRef, useContext, useReducer. Sempre chamados no topo do componente.
Ver exemplo
```
const ref = useRef<HTMLInputElement>(null);
```
Imutabilidade
Geral
Não alterar dados existentes; criar cópias modificadas. Evita bugs e é obrigatória no estado do React (senão a tela não atualiza).
Ver exemplo
```
const novo = { ...usuario, nome: "Ana" };
const lista2 = [...lista, item];
```
Índice
SQL
Estrutura (geralmente B-Tree) que acelera buscas e ordenações em colunas, com custo em escrita e espaço. Crie para colunas muito filtradas/joinadas.
Ver exemplo
```
CREATE INDEX idx_pedidos_cliente ON pedidos(cliente_id);
```
interface
TypeScript
Descreve o formato de um objeto. Pode ser estendida (extends) e implementada por classes (implements).
Ver exemplo
```
interface Usuario {
  id: number;
  nome: string;
}
interface Admin extends Usuario {
  permissoes: string[];
}
```
Intl
Web/APIs
API nativa de internacionalização: formata moeda, números, datas, listas e plurais conforme o idioma.
Ver exemplo
```
new Intl.NumberFormat("pt-BR", { style: "currency", currency: "BRL" }).format(10)
// 'R$ 10,00'
```
JOIN
SQL
Combina linhas de tabelas relacionadas. INNER JOIN: só o que casa dos dois lados. LEFT JOIN: tudo da esquerda + o que casar da direita (NULL se não houver).
Ver exemplo
```
SELECT p.id, c.nome
FROM pedidos p
JOIN clientes c ON c.id = p.cliente_id;
```
JSON
Web/APIs
JavaScript Object Notation: formato de texto para trocar dados entre sistemas (APIs). Suporta objetos, arrays, strings, números, booleanos e null.
Ver exemplo
```
import json
dados = json.loads('{"ok": true}')   # texto → dict
texto = json.dumps({"ok": True})       # dict → texto
```
JSX
React
Sintaxe parecida com HTML dentro do JS/TS. Expressões entram em { }. Use className, htmlFor e feche todas as tags.
Ver exemplo
```
<ul>
  {itens.map((i) => <li key={i.id}>{i.nome}</li>)}
</ul>
```
JWT
Web/APIs
JSON Web Token: token assinado (header.payload.assinatura) usado para autenticação stateless. Enviado no header Authorization: Bearer <token>. O payload é legível — não guarde segredos nele.
Ver exemplo
```
Authorization: Bearer eyJhbGciOiJIUzI1NiJ9...
```
keyof
TypeScript
Produz a união das chaves de um tipo. Muito usado com generics para restringir parâmetros a chaves válidas.
Ver exemplo
```
type Chaves = keyof { id: number; nome: string }; // "id" | "nome"
```
Laço for
Geral
Repete um bloco para cada item de uma sequência. Em Python percorre qualquer iterável; em JS use for...of para valores e for...in para chaves.
Ver exemplo
```
for fruta in ["maçã", "uva"]:
    print(fruta)
```
lambda
Python
Função anônima de uma única expressão. Muito usada como key em sorted/max/min.
Ver exemplo
```
sorted(pessoas, key=lambda p: p["idade"])
```
let, const e var
JavaScript
const para valores que não serão reatribuídos (padrão), let quando precisar reatribuir. Evite var (escopo de função e hoisting confusos).
Ver exemplo
```
const PI = 3.14;
let contador = 0;
contador++;
```
Lista (list)
Python
Sequência ordenada e mutável. Métodos: append, extend, insert, pop, remove, sort. Acesso por índice começando em 0; índices negativos contam do fim.
Ver exemplo
```
nums = [3, 1, 2]
nums.append(4)
nums[-1]     # 4
sorted(nums) # [1, 2, 3, 4]
```
map, filter, reduce
JavaScript
map transforma cada item, filter mantém os que passam no teste, reduce acumula tudo em um único valor. Sempre retornam algo novo sem mudar o original.
Ver exemplo
```
precos.map((p) => p * 1.1)
precos.filter((p) => p > 100)
precos.reduce((soma, p) => soma + p, 0)
```
Mapped types
TypeScript
Criam um tipo novo percorrendo as chaves de outro: { [K in keyof T]: ... }. É assim que Partial e Readonly são implementados.
Ver exemplo
```
type Opcional<T> = { [K in keyof T]?: T[K] };
```
Merge vs rebase
Git/Terminal
Merge junta históricos criando um commit de junção. Rebase reaplica seus commits sobre outra base, deixando o histórico linear. Não faça rebase de branches compartilhadas.
Ver exemplo
```
git switch minha-branch
git rebase main   # ou: git merge main
```
Métodos mágicos (dunder)
Python
Métodos com dois underscores (__init__, __str__, __repr__, __eq__, __add__, __len__) que integram seus objetos com a sintaxe do Python.
Ver exemplo
```
def __len__(self):
    return len(self.itens)  # len(obj) funciona
```
Modo strict
TypeScript
Conjunto de checagens rígidas (noImplicitAny, strictNullChecks...) ativado com "strict": true no tsconfig.json. Padrão em projetos modernos (incluindo Next.js).
Ver exemplo
```
{
  "compilerOptions": { "strict": true }
}
```
Módulo / resto (%)
Geral
O operador % devolve o resto da divisão. Muito usado para saber se um número é par (n % 2 == 0) ou múltiplo de outro.
Ver exemplo
```
10 % 3  # 1
9 % 3   # 0 → 9 é múltiplo de 3
```

Narrowing (estreitamento)

TypeScript

O TS refina o tipo dentro de blocos após checagens com typeof, instanceof, in, === ou type guards.

Ver exemplo

function f(x: string | number) {
  if (typeof x === "string") return x.length; // x: string
  return x.toFixed(2);                         // x: number
}

never
TypeScript
Tipo que não possui valores. Usado para checagem exaustiva: se sobrar algum caso não tratado, a atribuição a never dá erro.
Ver exemplo
```
default: {
  const _x: never = acao; // erro se faltar um case
}
```
NULL e COALESCE
SQL
NULL representa 'ausência de valor' e não é igual a nada (nem a NULL). Use IS NULL / IS NOT NULL. COALESCE devolve o primeiro valor não nulo.
Ver exemplo
```
SELECT nome, COALESCE(telefone, 'sem telefone')
FROM clientes
WHERE email IS NOT NULL;
```
Objeto
JavaScript
Coleção de pares chave: valor. Utilitários: Object.keys, Object.values, Object.entries, Object.fromEntries.
Ver exemplo
```
const u = { nome: "Ana", idade: 28 };
Object.entries(u); // [["nome","Ana"],["idade",28]]
```
Operadores
Geral
Símbolos para cálculos e comparações: aritméticos (+ - * / // % **), comparação (== != < >), lógicos (and/or/not em Python; && || ! em JS).
Ver exemplo
```
7 // 2   # 3 (divisão inteira)
7 % 2    # 1 (resto)
2 ** 3   # 8 (potência)
```
ORDER BY / LIMIT
SQL
Ordena o resultado (ASC padrão, DESC decrescente) e limita a quantidade de linhas. Com OFFSET, faz paginação.
Ver exemplo
```
SELECT * FROM vagas
ORDER BY salario DESC
LIMIT 10 OFFSET 20;
```
Polimorfismo
Geral
Objetos de classes diferentes respondem à mesma chamada, cada um do seu jeito. Ex: forma.area() funciona para Círculo e Retângulo.
Ver exemplo
```
for f in [Circulo(1), Retangulo(2, 3)]:
    print(f.area())
```
Portfólio
Geral
Conjunto de projetos públicos que provam suas habilidades. Para júnior: 2–3 projetos completos, com deploy, README com prints, testes e histórico de commits limpo.
Ver exemplo
```
# Vagas Remotas
App full-stack (Next.js + FastAPI + PostgreSQL)
🔗 Demo: https://...
## Como rodar
...
```
print()
Python
Função que mostra valores na saída padrão (terminal). Aceita vários argumentos, separados por espaço; sep e end mudam o separador e o final.
Ver exemplo
```
print("Olá", "mundo")        # Olá mundo
print(1, 2, 3, sep="-")       # 1-2-3
```
Promise
JavaScript
Objeto que representa um valor futuro (pendente, resolvido ou rejeitado). Base de toda operação assíncrona: fetch, banco, arquivos.
Ver exemplo
```
fetch(url)
  .then((r) => r.json())
  .catch((erro) => console.error(erro));
```
Propriedade opcional (?)
TypeScript
Campo que pode não existir. Seu tipo passa a incluir undefined, então é preciso tratar antes de usar.
Ver exemplo
```
interface Perfil {
  bio?: string;
}
perfil.bio?.toUpperCase();
```
Props
React
Parâmetros que o componente pai passa ao filho. São somente leitura. children é a prop especial com o conteúdo entre as tags.
Ver exemplo
```
<Botao cor="azul" onClick={salvar}>Salvar</Botao>
```
Pull Request (PR)
Git/Terminal
Pedido para integrar uma branch em outra, com revisão de código e testes automáticos (CI). Descreva o que mudou, por quê e como testar.
Ver exemplo
```
## O que muda
Adiciona filtro de vagas remotas

## Como testar
1. Acesse /vagas?remoto=true
```
range()
Python
Gera uma sequência de inteiros sob demanda: range(fim), range(início, fim) ou range(início, fim, passo). O fim não é incluído.
Ver exemplo
```
list(range(1, 6))      # [1, 2, 3, 4, 5]
list(range(10, 0, -3)) # [10, 7, 4, 1]
```
readonly
TypeScript
Impede a reatribuição de uma propriedade depois da criação (apenas na checagem de tipos). Readonly<T> aplica a todas as propriedades.
Ver exemplo
```
interface Config {
  readonly apiUrl: string;
}
```
Recursão
Geral
Quando uma função chama a si mesma para resolver um problema menor. Precisa sempre de um caso base, senão estoura a pilha (RecursionError / Maximum call stack).
Ver exemplo
```
def fatorial(n):
    if n <= 1:          # caso base
        return 1
    return n * fatorial(n - 1)
```
Reducer / useReducer
React
Função pura (estado, ação) => novoEstado. Centraliza a lógica de estados complexos; mesmo padrão do Redux.
Ver exemplo
```
const [estado, dispatch] = useReducer(reducer, inicial);
dispatch({ type: "adicionar", produto });
```
REST
Web/APIs
Estilo de API em que recursos têm URLs (substantivos) e as ações são os métodos HTTP: GET /vagas, POST /vagas, GET /vagas/1, PATCH /vagas/1, DELETE /vagas/1.
Ver exemplo
```
GET    /api/vagas?remoto=true
POST   /api/vagas
DELETE /api/vagas/42
```
Route Handler
Next.js
Arquivo app/**/route.ts que exporta funções GET, POST, PUT, PATCH, DELETE usando as APIs Web Request e Response — cria endpoints de API dentro do Next.js.
Ver exemplo
```
export async function GET(request: Request) {
  return Response.json({ ok: true });
}
```
SELECT
SQL
Comando de consulta. Ordem lógica de execução: FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT.
Ver exemplo
```
SELECT nome, email FROM clientes;
```
self
Python
Primeiro parâmetro dos métodos de instância: referência ao próprio objeto. Equivale ao this do JS, mas é explícito.
Ver exemplo
```
class Conta:
    def depositar(self, valor):
        self.saldo += valor
```
Server Component
Next.js
Padrão no App Router: renderiza no servidor, pode ser async e acessar banco/segredos, e não envia JavaScript ao navegador.
Ver exemplo
```
export default async function Page() {
  const vagas = await db.vaga.findMany();
  return <Lista vagas={vagas} />;
}
```
Spread / rest (...)
JavaScript
Spread 'espalha' elementos (cópias e junções); rest agrupa o restante em parâmetros ou destructuring.
Ver exemplo
```
const copia = [...lista];
const novo = { ...obj, ativo: true };
function soma(...nums) {}
```
SQL Injection
SQL
Ataque em que o input do usuário é interpretado como SQL. Evite com consultas parametrizadas — nunca concatene strings.
Ver exemplo
```
# ❌ f"SELECT * FROM u WHERE email = '{email}'"
# ✅
cursor.execute("SELECT * FROM u WHERE email = %s", (email,))
```
SSR, SSG, ISR e CSR
Next.js
Estratégias de renderização: SSR gera HTML a cada requisição; SSG no build; ISR regenera estáticos periodicamente; CSR renderiza no navegador.
Ver exemplo
```
export const revalidate = 60; // ISR: no máximo a cada 60s
```
String
Geral
Texto: uma sequência de caracteres. Strings são imutáveis em Python e JS — métodos como upper()/toUpperCase() devolvem uma nova string.
Ver exemplo
```
s = "Python"
s.lower()    # 'python'
s[0]         # 'P'
len(s)       # 6
```
Subquery
SQL
Consulta dentro de outra, usada como valor, lista (IN) ou tabela (FROM). Correlacionada quando referencia a consulta externa.
Ver exemplo
```
SELECT nome FROM produtos
WHERE preco > (SELECT AVG(preco) FROM produtos);
```
Template string
JavaScript
String delimitada por crases que permite interpolação com ${} e múltiplas linhas.
Ver exemplo
```
const nome = "Ana";
console.log(`Olá, ${nome}! 2 + 2 = ${2 + 2}`);
```
Terminal / shell
Git/Terminal
Interface de texto para comandar o sistema. Básico: pwd, ls, cd, mkdir, rm, cat, grep, | (pipe), > (redireciona), && (encadeia).
Ver exemplo
```
mkdir projeto && cd projeto
ls -la
grep -rn "TODO" src/
```
Teste automatizado
Geral
Código que verifica código. Unitário testa uma função isolada; integração testa partes juntas; E2E testa o sistema como o usuário (Playwright). Ferramentas: pytest, Vitest, Jest.
Ver exemplo
```
def test_soma():
    assert soma(2, 3) == 5
```
this
JavaScript
Referência ao objeto que está chamando o método. Em funções normais depende de COMO a função é chamada; arrow functions herdam o this externo.
Ver exemplo
```
class Conta {
  saldo = 0;
  depositar(v) { this.saldo += v; }
}
```
Tipo literal
TypeScript
Tipo que aceita apenas um valor exato. Combinado com union substitui enums de forma leve.
Ver exemplo
```
type Tema = "claro" | "escuro";
let t: Tema = "claro";
```
Tipos do JavaScript
JavaScript
Primitivos: string, number, bigint, boolean, undefined, null, symbol. Todo o resto é object (arrays, funções, datas). typeof null retorna 'object' por um bug histórico.
Ver exemplo
```
typeof 42        // 'number'
typeof []        // 'object'
Array.isArray([]) // true
```
Transação (ACID)
SQL
Grupo de operações que acontece por inteiro ou nada (BEGIN → COMMIT, ou ROLLBACK). ACID: Atomicidade, Consistência, Isolamento, Durabilidade.
Ver exemplo
```
BEGIN;
UPDATE contas SET saldo = saldo - 100 WHERE id = 1;
UPDATE contas SET saldo = saldo + 100 WHERE id = 2;
COMMIT;
```
Truthy e falsy
JavaScript
Valores falsy viram false em condições: false, 0, -0, 0n, "", null, undefined, NaN. Todo o resto é truthy — inclusive [] e {}.
Ver exemplo
```
if ([]) console.log("array vazio é truthy!");
```
Tupla (tuple)
Python
Sequência ordenada e IMUTÁVEL. Usada para retornar vários valores e como chave de dicionário.
Ver exemplo
```
ponto = (10, 20)
x, y = ponto  # desempacotamento
```
Type erasure
TypeScript
Os tipos do TypeScript são apagados na compilação: não existem em runtime. Por isso validação de dados externos precisa de código (type guards, Zod).
Ver exemplo
```
// TS:  const n: number = 1
// JS:  const n = 1
```
Type guard
TypeScript
Função que retorna x is Tipo: se retornar true, o TS passa a tratar o valor como aquele tipo.
Ver exemplo
```
function ehString(x: unknown): x is string {
  return typeof x === "string";
}
```
Type hints
Python
Anotações de tipo opcionais em Python. Não são checadas em runtime, mas ferramentas (mypy, Pyright, IDE) e frameworks (FastAPI, Pydantic) as usam.
Ver exemplo
```
def saudacao(nome: str, vezes: int = 1) -> str:
    return nome * vezes
```
Union type (|)
TypeScript
Um valor que pode ser de um tipo OU de outro. É preciso estreitar (narrowing) antes de usar métodos específicos.
Ver exemplo
```
type Id = string | number;
```
unknown vs any
TypeScript
any desliga a checagem (evite). unknown aceita qualquer valor mas obriga a verificar o tipo antes de usar — ideal para dados externos (JSON, catch).
Ver exemplo
```
const dados: unknown = JSON.parse(texto);
if (typeof dados === "object" && dados !== null) { ... }
```
useEffect
React
Executa efeitos colaterais após a renderização (assinaturas, timers, sincronizar com APIs do navegador). O array de dependências controla quando roda; retorne uma função de limpeza.
Ver exemplo
```
useEffect(() => {
  const id = setInterval(tick, 1000);
  return () => clearInterval(id);
}, []);
```
useState
React
Hook de estado local. Retorna [valor, setValor]; chamar o setter agenda uma nova renderização. Use a forma funcional quando o novo valor depende do anterior.
Ver exemplo
```
const [n, setN] = useState(0);
setN((atual) => atual + 1);
```
Utility types
TypeScript
Tipos prontos que transformam outros: Partial (tudo opcional), Required, Pick (escolhe chaves), Omit (remove chaves), Record<K, V>, ReturnType, Awaited.
Ver exemplo
```
type NovoUsuario = Omit<Usuario, "id">;
type Patch = Partial<NovoUsuario>;
```
Validação de dados
Web/APIs
Conferir se dados externos (formulários, APIs) têm o formato esperado antes de usar. Nunca confie no cliente: valide no servidor. Ferramentas: Zod (TS), Pydantic (Python).
Ver exemplo
```
const Usuario = z.object({ nome: z.string().min(2), email: z.string().email() });
```
Variável
Geral
Um nome que aponta para um valor guardado na memória. Em Python é criada na atribuição; em JS use const (não muda) ou let (muda).
Ver exemplo
```
nome = "Ana"
idade = 28
```
Variável de ambiente
Geral
Configuração externa ao código (URLs, chaves, modo). Em dev ficam no arquivo .env (que NUNCA vai para o Git). No Next.js, só as com prefixo NEXT_PUBLIC_ chegam ao navegador.
Ver exemplo
```
import os
url = os.environ["DATABASE_URL"]
```
WHERE
SQL
Filtra linhas com condições: =, <>, <, >, AND, OR, NOT, IN, BETWEEN, LIKE ('%' = qualquer sequência, '_' = um caractere).
Ver exemplo
```
SELECT * FROM produtos
WHERE preco BETWEEN 100 AND 500
  AND nome LIKE 'Mouse%';
```
Window function
SQL
Calcula sobre um conjunto de linhas relacionadas SEM agrupar o resultado: ROW_NUMBER, RANK, LAG, LEAD, SUM() OVER. Muito usada em análise de dados.
Ver exemplo
```
SELECT nome, salario,
  RANK() OVER (PARTITION BY depto ORDER BY salario DESC) AS pos
FROM funcionarios;
```

Dicionário de dados e conceitos

?? e ?. (nullish)

'use client'

@dataclass

*args e **kwargs

=== vs ==

Anotação de tipo

API

App Router

Array

Arrow function

async / await

Busca binária

Cache / memoização

CASE WHEN

Chave primária e estrangeira

CI/CD

Classe

Closure

Códigos de status HTTP

Complexidade (Big O)

Componente

Comprehension

Condicionais (if / elif / else)

Conjunto (set)

Context manager (with)

CORS

CTE (WITH)

DDL (CREATE, ALTER, DROP)

Decorator

Desempacotamento

Destructuring

Dicionário (dict)

Discriminated union

DML (INSERT, UPDATE, DELETE)

Docker

enumerate() e zip()

Escopo

Event loop

Exceção (try/except)

f-string

Fatiamento (slice)

Função

Funções de agregação

Generics

Gerador (yield)

Git

GROUP BY / HAVING

Herança

Hidratação

Hooks

Imutabilidade

Índice

interface

Intl

JOIN

JSON

JSX

JWT

keyof

Laço for

lambda

let, const e var

Lista (list)

map, filter, reduce

Mapped types

Merge vs rebase

Métodos mágicos (dunder)

Modo strict

Módulo / resto (%)

Narrowing (estreitamento)

never

NULL e COALESCE

Objeto

Operadores

ORDER BY / LIMIT

Polimorfismo

Portfólio

print()

Promise