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ê
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:
Configurando o Prettier
Criar um arquivo .prettierrc na raiz do projeto garante que todos no time
usem as mesmas regras de formatação:
{
"semi": false,
"singleQuote": true,
"tabWidth": 2,
"trailingComma": "es5",
"printWidth": 100,
"arrowParens": "avoid"
}
Configurando o VS Code (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:
! → 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:
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
// 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:
- Abra o DevTools antes de recarregar a página (ou clique no ícone 🔴 para gravar)
- Recarregue com
F5ouCtrl+R - Veja as requisições listadas em ordem cronológica
- Clique em qualquer requisição para ver Headers, Payload (corpo) e Response
- 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
Navegação — comandos essenciais
# 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
# 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
# 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.
$ 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
# 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.
{
"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.
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:
# 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.
# 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.
# 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
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:
mkdir meu-projeto && cd meu-projeto && git init && npm init -y
Criar o .gitignore e fazer o primeiro commit.
Instalar dependências (npm install), configurar Prettier e ESLint,
subir o servidor de desenvolvimento com npm run dev.
Criar uma branch por funcionalidade (git switch -c feature/nome),
desenvolver, commitar com mensagens claras.
Usar o Console para erros de JavaScript, Elements para ajustes de CSS, Network para problemas com APIs.
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 commitenode_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