🛠️ Ferramentas

Ferramentas do Desenvolvedor

Saber a linguagem é metade do caminho. A outra metade é dominar as ferramentas que tornam seu trabalho mais rápido, organizado e menos frustrante. Aqui estão as essenciais.

VS Code — O Editor dos Devs

O Visual Studio Code (VS Code) é o editor de código mais popular do mundo — e não é à toa. É gratuito, open source, leve, cheio de extensões e funciona em Windows, Mac e Linux. Se você ainda usa o Bloco de Notas para escrever código, esse é o upgrade mais importante que você pode fazer agora.

📊

Números que impressionam: Segundo a pesquisa anual do Stack Overflow, o VS Code é usado por mais de 73% dos desenvolvedores em todo o mundo. Ele foi lançado pela Microsoft em 2015 e em menos de dois anos já havia desbancado o Sublime Text e o Atom que reinavam antes. Hoje tem mais de 35 mil extensões disponíveis.

Instalação e primeiros passos

Baixe em code.visualstudio.com. Instale, abra uma pasta do seu projeto com File → Open Folder (ou arraste a pasta para a janela) e pronto — você já está em casa.

Interface — o que é o quê

LAYOUT DO VS CODE
Activity Bar faixa vertical esquerda — Explorer, Search, Git, Extensions, Debug
Explorer (Ctrl+Shift+E) árvore de arquivos do seu projeto
Editor área central — onde você escreve código. Abre em abas. Split com Ctrl+\
Terminal Integrado (Ctrl+`) painel inferior — roda comandos sem sair do editor
Status Bar rodapé — branch Git, erros, warnings, linguagem do arquivo

Atalhos que salvam vidas

Decorar esses atalhos é o maior salto de produtividade que você pode ter como dev:

Atalho (Windows) Atalho (Mac) O que faz
Ctrl+P Cmd+P Abre arquivo pelo nome (busca fuzzy em todo o projeto)
Ctrl+Shift+P Cmd+Shift+P Paleta de comandos — acessa qualquer função do editor
Ctrl+` Ctrl+` Abre/fecha o terminal integrado
Ctrl+D Cmd+D Seleciona próxima ocorrência da palavra (multi-cursor)
Alt+↑ / Alt+↓ Option+↑ / Option+↓ Move a linha atual para cima ou para baixo
Shift+Alt+↓ Shift+Option+↓ Duplica a linha atual abaixo
Ctrl+/ Cmd+/ Comenta/descomenta a linha selecionada
Ctrl+Shift+F Cmd+Shift+F Busca em todos os arquivos do projeto
Ctrl+H Cmd+Option+F Buscar e substituir no arquivo atual
F12 F12 Vai para a definição da função/variável
Ctrl+Z / Ctrl+Shift+Z Cmd+Z / Cmd+Shift+Z Desfazer / Refazer
Ctrl+\ Cmd+\ Divide o editor em duas colunas

Extensões essenciais

Extensões transformam o VS Code num ambiente completo para qualquer linguagem. Instale via Ctrl+Shift+X ou pela paleta de comandos:

Produtividade
Prettier
Formata seu código automaticamente ao salvar. Acabaram as brigas sobre indentação.
Qualidade
ESLint
Analisa seu JavaScript em tempo real e aponta erros antes de você rodar o código.
HTML/CSS
Live Server
Cria um servidor local que recarrega o browser automaticamente ao salvar o arquivo.
HTML
Auto Rename Tag
Renomeia a tag de fechamento automaticamente quando você muda a de abertura.
Visual
GitLens
Mostra inline quem fez qual alteração, quando e em qual commit. Git turbinado.
Visual
Indent Rainbow
Coloriza os níveis de indentação, facilitando muito a leitura de código aninhado.
CSS
CSS Peek
Permite ver e navegar para a definição CSS ao passar o mouse sobre uma classe no HTML.
PHP
PHP Intelephense
Autocomplete, diagnóstico de erros e navegação de código para PHP.

Configurando o Prettier

Criar um arquivo .prettierrc na raiz do projeto garante que todos no time usem as mesmas regras de formatação:

.prettierrc
{
  "semi": false,
  "singleQuote": true,
  "tabWidth": 2,
  "trailingComma": "es5",
  "printWidth": 100,
  "arrowParens": "avoid"
}

Configurando o VS Code (settings.json)

settings.json — Ctrl+Shift+P → "Open User Settings JSON"
{
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.fontSize": 14,
  "editor.tabSize": 2,
  "editor.wordWrap": "on",
  "editor.minimap.enabled": false,
  "editor.fontFamily": "'Cascadia Code', 'Fira Code', Consolas, monospace",
  "editor.fontLigatures": true,
  "files.autoSave": "onFocusChange",
  "terminal.integrated.defaultProfile.windows": "Git Bash",
  "workbench.colorTheme": "One Dark Pro"
}
💡

Fonte com ligaduras: instale a fonte Cascadia Code (Microsoft, gratuita) ou Fira Code e ative "editor.fontLigatures": true. Símbolos como =>, !== e >= viram caracteres especiais muito mais legíveis. Parece bobagem até você experimentar.

Emmet — HTML ultrarrápido

O Emmet já vem embutido no VS Code e permite escrever HTML e CSS com atalhos. Digite a abreviação e pressione Tab:

Emmet — Abreviações → HTML gerado
! → estrutura completa do HTML5

ul>li*3 →
<ul>
  <li></li>
  <li></li>
  <li></li>
</ul>

div.card>h2.card__title+p.card__text →
<div class="card">
  <h2 class="card__title"></h2>
  <p class="card__text"></p>
</div>

input[type="email"]#email.form-input →
<input type="email" id="email" class="form-input">

table>thead>tr>th*3^^tbody>tr*3>td*3 →
tabela completa com thead e 3 linhas de 3 colunas

DevTools — Seus Olhos no Browser

O DevTools é a coleção de ferramentas de desenvolvedor embutida em todo browser moderno. É gratuito, sempre disponível e absolutamente indispensável. Sem ele, depurar CSS e JavaScript seria como operar no escuro.

🔬

O DevTools é o bisturi do dev front-end. Você consegue inspecionar cada elemento da página, ver cada requisição HTTP que o browser fez, executar JavaScript em tempo real, simular celulares, medir performance e até gravar um perfil de CPU — tudo sem sair do browser. É uma das ferramentas mais poderosas do ecossistema web e a maioria dos devs usa menos de 20% do que ela oferece.

Como abrir

Em qualquer browser baseado em Chromium (Chrome, Edge, Brave) ou Firefox:

Atalho
F12
A forma mais rápida. Abre/fecha o DevTools em qualquer página.
Atalho
Ctrl+Shift+I
Alternativa para abrir o DevTools. Cmd+Option+I no Mac.
Mouse
Botão Direito → Inspecionar
Abre o DevTools direto na aba Elements, já no elemento que você clicou.
Atalho
Ctrl+Shift+J
Abre o DevTools diretamente na aba Console. Cmd+Option+J no Mac.

As abas principais

Aba Para que serve Use quando...
Elements Inspeciona e edita HTML e CSS em tempo real Ajustar estilos, entender a estrutura, debugar layout
Console Logs, erros e execução de JS ao vivo Ver erros, testar código, depurar JavaScript
Network Todas as requisições HTTP da página Debugar APIs, ver headers, medir tempo de carga
Sources Código-fonte do site, debugger com breakpoints Pausar execução JS linha a linha
Application Cookies, LocalStorage, SessionStorage, Cache Gerenciar dados salvos no browser
Performance Perfil de CPU e renderização frame a frame Otimizar animações lentas e gargalos de JS
Lighthouse Auditoria automática de performance, SEO e a11y Checar a saúde geral do site com notas de 0-100

Aba Elements — editando CSS ao vivo

Console do DevTools — experimentos úteis
// Muda o fundo da página inteira (teste imediato!)
document.body.style.background = 'hotpink'

// Seleciona e exibe um elemento
document.querySelector('h1')

// Inspeciona todas as propriedades de um elemento
dir(document.querySelector('h1'))

// $_ retorna o último resultado do Console
document.querySelectorAll('.card')
$_.length // → número de cards na página

// Cronometrar um bloco de código
console.time('operacao')
// ... código a medir ...
console.timeEnd('operacao') // → "operacao: 1.23ms"

// Logar um objeto formatado (muito melhor que console.log)
console.table([{nome: 'Ana', idade: 28}, {nome: 'Bruno', idade: 32}])

// Agrupar logs relacionados
console.group('Dados do usuário')
console.log('nome:', nome)
console.log('email:', email)
console.groupEnd()

Aba Network — debugando requisições

A aba Network é onde você vê cada arquivo que o browser buscou para montar a página — HTML, CSS, JS, imagens, fontes e chamadas de API. Para usá-la bem:

  1. Abra o DevTools antes de recarregar a página (ou clique no ícone 🔴 para gravar)
  2. Recarregue com F5 ou Ctrl+R
  3. Veja as requisições listadas em ordem cronológica
  4. Clique em qualquer requisição para ver Headers, Payload (corpo) e Response
  5. Use o filtro XHR / Fetch para ver só chamadas de API
💡

Simulação de rede lenta: Na aba Network, clique no menu "No throttling" e selecione "Slow 3G" ou "Fast 3G". Assim você consegue testar como seu site se comporta em conexões ruins — algo que usuários de celular enfrentam todos os dias.

Modo responsivo — testando em celular

Pressione Ctrl+Shift+M (ou clique no ícone de celular/tablet no DevTools) para ativar o Device Toolbar. Você pode simular qualquer device, resolução e até toque na tela sem sair do computador.

Terminal — Falando com o Computador

O terminal (também chamado de linha de comando, CLI ou prompt) é uma interface de texto onde você digita comandos para interagir com o sistema. Parece intimidador no começo, mas é uma das ferramentas mais poderosas que existem — e desenvolvedores usam o tempo todo.

🎮

Analogia de RPG: usar uma interface gráfica (GUI) é como jogar com o controle padrão do game. O terminal é como usar os comandos de debug do desenvolvedor — você acessa tudo, sem restrições, de forma muito mais rápida. Sim, tem curva de aprendizado. Mas uma vez que você aprende, nunca mais volta.

Qual terminal usar

Windows
Git Bash
Instala junto com o Git. Emula um terminal Linux no Windows. É o mais recomendado para iniciantes no Windows — comandos compatíveis com tutoriais.
Windows
Windows Terminal
Terminal moderno da Microsoft, disponível na Microsoft Store. Suporta abas, múltiplos shells (PowerShell, CMD, WSL) e personalização.
Mac
Terminal / iTerm2
O Terminal nativo do Mac já é ótimo. O iTerm2 é uma alternativa popular com mais recursos, como divisão de painéis e autocomplete avançado.
Linux
Bash / Zsh
Qualquer emulador de terminal no Linux funciona. Zsh com Oh My Zsh é a configuração mais popular entre devs — temas e plugins incríveis.

Navegação — comandos essenciais

BASH / TERMINAL
# Onde estou agora? (print working directory)
pwd
# → /home/usuario/projetos

# Listar arquivos da pasta atual
ls
ls -la    # listagem detalhada, incluindo arquivos ocultos
ls -lh    # tamanhos legíveis (KB, MB)

# Navegar entre pastas (change directory)
cd projetos           # entra na pasta "projetos"
cd ..                 # sobe um nível
cd ../outro-projeto   # sobe e entra em outra pasta
cd ~                  # vai para a pasta home do usuário
cd -                  # volta para a pasta anterior

# Tab completa o nome → cd proj[Tab] → cd projetos/

Manipulação de arquivos e pastas

BASH / TERMINAL
# Criar pasta
mkdir meu-projeto
mkdir -p src/components/ui   # cria estrutura de pastas de uma vez

# Criar arquivo vazio
touch index.html style.css app.js

# Mostrar conteúdo de um arquivo
cat package.json

# Copiar arquivo
cp index.html backup.html
cp -r src/ src-backup/    # copia pasta inteira (-r = recursivo)

# Mover / renomear
mv arquivo.txt nova-pasta/
mv nome-antigo.js nome-novo.js

# Remover (CUIDADO — sem lixeira!)
rm arquivo.txt
rm -rf pasta/    # remove pasta e tudo dentro dela — IRREVERSÍVEL!

# Abrir a pasta atual no VS Code
code .

# Limpar a tela do terminal
clear   # ou Ctrl+L
⚠️

Atenção total com rm -rf: esse comando deleta arquivos e pastas permanentemente, sem passar pela lixeira. Não existe Ctrl+Z. Sempre confira o que você está digitando antes de pressionar Enter. Há histórias de devs que deletaram o projeto inteiro (ou pior, o servidor de produção) por descuido.

Comandos de busca e utilidades

BASH / TERMINAL
# Buscar texto dentro de arquivos (grep)
grep "console.log" app.js
grep -r "TODO" src/           # busca recursiva em pastas
grep -rn "fetch(" src/          # -n mostra número da linha

# Histórico de comandos
history             # lista os últimos comandos
!!                  # repete o último comando
# Ctrl+R → busca no histórico enquanto você digita

# Verificar se um programa está instalado
which node          # → /usr/bin/node
which git           # → /usr/bin/git

# Ver versão de ferramentas instaladas
node --version      # → v20.11.0
npm --version       # → 10.2.4
git --version       # → git version 2.43.0

# Encadear comandos
mkdir projeto && cd projeto && git init
# && só roda o próximo se o anterior foi bem-sucedido
💡

Atalhos que economizam tempo no terminal:
Tab — autocompleta nomes de arquivos e comandos
Ctrl+C — cancela o comando em execução
Ctrl+L — limpa a tela (igual ao clear)
↑ / ↓ — navega no histórico de comandos
Ctrl+A — vai para o início da linha
Ctrl+E — vai para o fim da linha

Node.js e npm — JavaScript no Servidor

Node.js é um ambiente de execução que permite rodar JavaScript fora do browser — no servidor, no terminal, em scripts de automação. Ele é construído sobre o motor V8 do Chrome e tornou o JavaScript uma linguagem verdadeiramente full stack.

🧠

Por que Node.js importa mesmo que você não seja backend? Praticamente todas as ferramentas modernas de frontend — Vite, Webpack, ESLint, Prettier, Sass, TypeScript — rodam em Node.js. Mesmo desenvolvendo só HTML/CSS/JS no browser, você vai usar Node.js como infraestrutura de desenvolvimento. É inevitável e vale muito aprender o básico.

Instalação

Baixe a versão LTS (Long Term Support) em nodejs.org. A LTS é a versão estável e recomendada para projetos. O instalador já inclui o npm.

TERMINAL — Verificando a instalação
$ node --version
v20.11.0

$ npm --version
10.2.4

# Rodar um arquivo JavaScript no terminal
$ node app.js

# Modo interativo (REPL) — digita JS e vê o resultado
$ node
> 2 + 2
4
> 'olá'.toUpperCase()
'OLÁ'
> .exit  # ou Ctrl+C duas vezes

npm — o gerenciador de pacotes

npm (Node Package Manager) é o maior repositório de pacotes open source do mundo. Com ele você instala, atualiza e remove bibliotecas em qualquer projeto com um único comando.

📦

O npm tem mais de 2 milhões de pacotes disponíveis. Precisa validar emails? Tem pacote. Formatar datas? Tem pacote. Criar gráficos, manipular imagens, conectar ao banco, enviar email? Tem pacote pra tudo. A filosofia é: não reinvente a roda — use o que a comunidade já construiu e testou. Só tome cuidado com pacotes desatualizados ou mal mantidos.

Comandos npm essenciais

TERMINAL — npm
# Inicializar um projeto (cria o package.json)
npm init         # modo interativo com perguntas
npm init -y      # aceita tudo com valores padrão (mais rápido)

# Instalar um pacote (salva em dependencies)
npm install lodash
npm i lodash      # forma abreviada

# Instalar como dependência de desenvolvimento (devDependencies)
npm install --save-dev prettier
npm i -D prettier # forma abreviada

# Instalar globalmente (disponível em qualquer projeto)
npm install -g nodemon

# Instalar todas as dependências de um projeto existente
npm install      # lê o package.json e instala tudo

# Remover um pacote
npm uninstall lodash

# Atualizar pacotes
npm update

# Checar pacotes desatualizados
npm outdated

# Rodar um script definido no package.json
npm run dev
npm run build
npm run test

O package.json — o coração do projeto

Todo projeto Node.js tem um package.json. Ele funciona como a "ficha técnica" do projeto: nome, versão, dependências, scripts e configurações.

package.json — exemplo comentado
{
  "name": "meu-projeto",
  "version": "1.0.0",
  "description": "Uma descrição breve do projeto",
  "main": "index.js",

  // Scripts que você roda com "npm run nome"
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "build": "vite build",
    "test": "jest"
  },

  // Dependências de produção (vão para o servidor)
  "dependencies": {
    "express": "^4.18.2"
  },

  // Dependências apenas de desenvolvimento (não vão para produção)
  "devDependencies": {
    "nodemon": "^3.0.2",
    "prettier": "^3.2.5",
    "eslint": "^8.57.0"
  }
}

O que é o node_modules e por que não commitar

Quando você roda npm install, o npm baixa todos os pacotes para uma pasta chamada node_modules. Ela pode ter centenas de megabytes e dezenas de milhares de arquivos — mesmo para projetos simples.

⚠️

NUNCA commite o node_modules no Git. Sempre adicione node_modules/ no .gitignore. O arquivo package.json já registra quais dependências o projeto precisa — qualquer pessoa que clonar o repositório roda npm install e recria a pasta automaticamente.

.gitignore — Node.js
node_modules/
.env
.env.local
dist/
build/
*.log

Nodemon — reinício automático

Toda vez que você salva um arquivo, normalmente precisa parar o servidor e reiniciar. O Nodemon faz isso automaticamente — monitora os arquivos e reinicia o Node.js quando detecta mudanças:

TERMINAL
# Instalar globalmente
npm install -g nodemon

# Usar no lugar de "node"
nodemon app.js
# → [nodemon] starting `node app.js`
# → (você salva o arquivo...)
# → [nodemon] restarting due to changes...

# Dica: adicionar no package.json como script "dev"
# "dev": "nodemon app.js"
npm run dev

Outras Ferramentas Essenciais

Além do VS Code, DevTools, terminal e Node.js, existe um conjunto de ferramentas que aparecem no dia a dia de quase todo desenvolvedor web. Você não precisa aprender todas de uma vez — mas vale conhecer para saber o que buscar quando precisar.

Postman e Insomnia — testando APIs

Quando você está desenvolvendo ou consumindo uma API, precisa fazer requisições HTTP e inspecionar as respostas sem escrever código. É aí que entram o Postman e o Insomnia: interfaces gráficas para testar endpoints de API.

📮 Postman

O mais popular. Interface rica, suporte a coleções de requests, ambientes, variáveis, testes automatizados e documentação. Tem plano gratuito generoso.

🦋 Insomnia

Interface mais limpa e simples que o Postman. Ótima para quem está começando. Também tem suporte a ambientes e variáveis. Open source.

TERMINAL — Testando API com curl (sem instalar nada)
# GET simples
curl https://viacep.com.br/ws/01310-100/json/

# POST com JSON
curl -X POST https://jsonplaceholder.typicode.com/posts \
  -H "Content-Type: application/json" \
  -d '{"title": "Teste", "body": "Conteúdo", "userId": 1}'

# Com autenticação por token
curl -H "Authorization: Bearer SEU_TOKEN" https://api.exemplo.com/dados

# Salvar resposta em arquivo
curl -o resposta.json https://api.exemplo.com/dados

Figma — design e prototipagem

O Figma é a ferramenta de design de interfaces mais usada atualmente. Como dev, você não precisa ser designer — mas entender como usar o Figma para inspecionar designs, copiar valores de CSS e colaborar com designers é uma habilidade muito valorizada.

💡

Dev Mode no Figma: clique no botão "Dev Mode" (ícone </>) em qualquer arquivo Figma. Você passa a ver o CSS exato de cada elemento — cores, fontes, espaçamentos, border-radius. Não precisa ficar adivinhando valores: o Figma já entrega o código pronto.

Vite — servidor de desenvolvimento moderno

O Vite substituiu o Create React App e ferramentas similares como o padrão para projetos frontend modernos. É extremamente rápido, com hot reload instantâneo e build otimizado para produção.

TERMINAL — Criando projeto com Vite
# Criar projeto Vite (escolha o framework na interface)
npm create vite@latest meu-projeto
cd meu-projeto
npm install
npm run dev
# → Server running at http://localhost:5173

# Criar projeto React com Vite diretamente
npm create vite@latest meu-react -- --template react

# Criar projeto vanilla JS (sem framework)
npm create vite@latest meu-vanilla -- --template vanilla

Ferramentas por categoria

Versionamento
GitHub Desktop
Interface gráfica para Git. Ideal para quem está começando e prefere evitar o terminal para operações do dia a dia.
Performance
PageSpeed Insights
Ferramenta do Google que analisa a performance do seu site em produção e dá sugestões de melhoria com pontuação detalhada.
Banco de Dados
DBeaver / TablePlus
Clientes gráficos para gerenciar bancos de dados MySQL, PostgreSQL, SQLite e outros. Muito mais cômodo que usar o terminal do banco.
Imagens
Squoosh
Ferramenta online do Google para compressão de imagens. Reduz o tamanho sem perda visível de qualidade — essencial para performance web.
Fontes
Google Fonts
Biblioteca gratuita de fontes do Google. Mais de 1.400 famílias tipográficas prontas para usar em qualquer projeto web.
Ícones
Lucide / Heroicons
Bibliotecas de ícones SVG open source. Consistentes, acessíveis e fáceis de customizar via CSS. Substitutos modernos ao Font Awesome.
Cores
Coolors / Realtime Colors
Geradores de paletas de cores. O Coolors cria combinações harmoniosas; o Realtime Colors mostra como a paleta fica aplicada numa interface real.
Acessibilidade
Contrast Checker
Verifica se a combinação de cores de texto e fundo atende ao padrão WCAG 2.1 de contraste mínimo (4.5:1 para texto normal).

O fluxo de trabalho completo

Juntando tudo que vimos neste e nos outros módulos, o fluxo de um projeto real se parece com isso:

1
Criar o projeto

mkdir meu-projeto && cd meu-projeto && git init && npm init -y
Criar o .gitignore e fazer o primeiro commit.

2
Configurar o ambiente de desenvolvimento

Instalar dependências (npm install), configurar Prettier e ESLint, subir o servidor de desenvolvimento com npm run dev.

3
Desenvolver em branches

Criar uma branch por funcionalidade (git switch -c feature/nome), desenvolver, commitar com mensagens claras.

4
Depurar com DevTools

Usar o Console para erros de JavaScript, Elements para ajustes de CSS, Network para problemas com APIs.

5
Revisar e fazer merge

Abrir Pull Request no GitHub, revisar o código, fazer merge na branch principal e publicar.

📋 Resumo do módulo — Ferramentas

  • VS Code é o editor mais popular do mundo — gratuito, extensível e cheio de atalhos de produtividade
  • Instale Prettier, ESLint e Live Server logo de cara — você vai usar em todo projeto
  • Emmet acelera a escrita de HTML com abreviações expandidas pelo Tab
  • O DevTools (F12) permite inspecionar HTML/CSS, debugar JS e analisar requisições de rede em tempo real
  • O terminal é indispensável para navegar em pastas, rodar scripts e usar ferramentas de linha de comando
  • Node.js permite rodar JS fora do browser — necessário para qualquer ferramenta moderna de frontend
  • npm gerencia as dependências do projeto via package.json — nunca commite node_modules/
  • Postman ou Insomnia para testar APIs; Figma para inspecionar designs; Vite para projetos frontend modernos
  • Conhecer as ferramentas certas para cada situação é tão importante quanto conhecer a linguagem
← Git Início →