Depuração de código no Node.js com o debugger

O que é o debugger do Node.js?

O debugger do Node.js é uma ferramenta que permite depurar o código JavaScript enquanto ele está sendo executado. Ele permite pausar a execução do código, inspecionar variáveis, analisar o fluxo de execução e corrigir erros de forma interativa. Utilizar o debugger pode acelerar o processo de identificação de bugs e melhorar a qualidade do código.

Ao usar o debugger, você pode pausar a execução do código em pontos específicos, chamados de breakpoints, e investigar o que está acontecendo naquele momento da execução.

Neste tutorial, vamos aprender a usar o debugger nativo do Node.js, abordando como definir breakpoints, inspecionar variáveis e avançar na execução do código para encontrar erros e melhorar o desempenho da aplicação.

1. Como iniciar o debugger no Node.js

O debugger do Node.js é fácil de usar e pode ser iniciado diretamente no terminal. Para começar a depurar seu código, basta executar o seu arquivo .js com o comando node inspect:

node inspect app.js

Este comando inicia a execução do arquivo app.js em modo de depuração. O Node.js entra em um modo interativo, onde você pode inserir comandos no terminal para controlar a execução.

Exemplo de uso básico do debugger

Para depurar um código, você pode adicionar um breakpoint usando o comando debugger diretamente no código JavaScript:

function soma(a, b) {
    debugger;  // Adicionando breakpoint aqui
    return a + b;
}

console.log(soma(2, 3));

Neste exemplo, adicionamos o comando debugger dentro da função soma(). Quando a execução chegar nesse ponto, a execução será pausada, e o controle será passado para o terminal, onde você pode inspecionar variáveis e executar comandos interativos.

2. Inspecionando variáveis no debugger

Depois de adicionar o debugger ao código e rodá-lo, o Node.js entra em modo de depuração e pausará no ponto do breakpoint. No terminal, você verá um prompt de depuração, onde poderá executar comandos para investigar o código. Por exemplo, você pode inspecionar as variáveis dentro do escopo atual.

Comandos úteis no debugger do Node.js

• n: Avança para a próxima linha de código.
• c: Continua a execução até o próximo breakpoint.
• repl: Entra em modo REPL (Read-Eval-Print Loop), onde você pode executar expressões JavaScript interativamente.
• bt: Exibe o call stack, ou pilha de chamadas.
• watch('variavel'): Monitora o valor de uma variável específica durante a execução.

3. Depuração remota no Node.js

Você também pode depurar o código de um servidor Node.js remoto ou de um processo em execução. Para isso, você pode usar a opção --inspect para habilitar a depuração remota:

node --inspect app.js

Após iniciar o debugger remoto, você pode conectar ao processo de depuração usando o Chrome DevTools ou outras ferramentas de depuração remota compatíveis. Para conectar via Chrome DevTools, basta abrir o Chrome e digitar chrome://inspect na barra de endereços, onde você verá uma lista de dispositivos e processos de depuração disponíveis. Clique no processo do Node.js e comece a depuração de forma remota.

4. Depuração de código assíncrono

Uma das vantagens do debugger do Node.js é que ele permite depurar código assíncrono facilmente. Quando você usa Promises, callbacks ou async/await, o debugger permite que você inspecione o estado de execução de cada função assíncrona.

Aqui está um exemplo de como depurar código assíncrono usando o async/await:

async function fetchData() {
    const data = await fetch('https://api.example.com/data');
    return data.json();
}

fetchData().then(data => console.log(data));

Você pode adicionar um debugger dentro da função assíncrona para verificar o valor da variável data enquanto ela aguarda pela resposta da API. Isso ajuda a identificar problemas de sincronização e erros de lógica em funções assíncronas.

5. Depuração com o VS Code

Se você preferir usar uma IDE para depurar seu código, o Visual Studio Code tem uma integração nativa com o debugger do Node.js. Para usar o debugger do VS Code, você só precisa adicionar um arquivo de configuração de depuração no seu projeto.

Exemplo de configuração de depuração no VS Code

Crie um arquivo .vscode/launch.json no diretório do seu projeto com a seguinte configuração:

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "node",
            "request": "launch",
            "name": "Launch Program",
            "skipFiles": ["<node_internals>/**"],
            "program": "${workspaceFolder}/app.js"
        }
    ]
}

Agora, você pode iniciar a depuração diretamente do VS Code, clicando no ícone de depuração e selecionando a configuração de depuração para Node.js. O VS Code irá executar o seu código e permitirá que você coloque breakpoints, inspecione variáveis e visualize o fluxo de execução.

6. Conclusão

O debugger do Node.js é uma ferramenta poderosa que permite depurar seu código diretamente no terminal ou usando ferramentas como o Chrome DevTools e o VS Code. Ele é especialmente útil para encontrar erros e entender o comportamento do código assíncrono, que pode ser mais difícil de depurar com métodos tradicionais. Ao utilizar breakpoints, comandos interativos e inspeção de variáveis, você consegue resolver problemas mais rapidamente e garantir que sua aplicação esteja funcionando corretamente.

Depuração no Node.js: Melhore seu fluxo de trabalho com o debugger

Depuração é uma parte essencial do processo de desenvolvimento, e o debugger do Node.js facilita muito o trabalho de identificar e corrigir erros. Se você está lidando com código assíncrono ou interações complexas com APIs ou bancos de dados, o debugger permite que você execute o código de forma controlada e inspecione variáveis e estados a cada momento.

O uso do debugger não só melhora a qualidade do código, mas também ajuda a aprender mais sobre o fluxo de execução e a estrutura interna do seu projeto. Ferramentas como o VS Code tornam a depuração ainda mais prática e eficiente, permitindo colocar breakpoints visualmente e acompanhar a execução do código em tempo real.

Algumas aplicações:

• Depurar requisições HTTP para verificar a lógica de rotas em APIs.
• Testar o comportamento de funções assíncronas com Promises e async/await.
• Verificar a execução de tarefas de I/O e interações com bancos de dados.
• Investigar erros de lógica e fluxos de controle em funções complexas.
• Usar o debugger remoto para depurar aplicações em servidores ou containers.

Dicas para quem está começando

• Adicione breakpoints em pontos chave do código para facilitar a depuração.
• Use o modo REPL no debugger para testar expressões JavaScript enquanto depura.
• Não depure diretamente em produções reais, use bancos de dados de teste ou mocks.
• Compreenda os fluxos de async/await e como eles podem afetar a execução assíncrona.
• Explore o debugger remoto para depurar aplicativos em ambientes de produção sem interromper o fluxo.

Compartilhe este tutorial