Node.js: Instalação e Configuração

Última atualização: 2026-08-26

Bob é um desenvolvedor front-end que acabou de começar a trabalhar em uma empresa de tecnologia. No primeiro dia, seu mentor lhe passou a URL do repositório do projeto. Depois de cloná-lo, ele executou o npm install, mas recebeu vários erros — descobriu-se que o projeto da empresa estava usando o Node.js 22 LTS, enquanto ele ainda estava executando a versão mais antiga, a 18, em sua máquina local. Bob ficou em um dilema, pois temia que uma atualização direta pudesse afetar outros projetos legados. Felizmente, seu mentor recomendou o nvm, que permitiu que ele alternasse livremente entre diferentes versões do Node.js, garantindo que cada projeto usasse sua própria versão compatível sem interferir nos demais. A partir de então, Bob nunca mais precisou se preocupar com conflitos de versão.

O que você vai aprender

• Como instalar e alternar entre versões do Node.js usando o nvm
• Verifique se o Node.js e o npm foram instalados corretamente
• Executar código JavaScript no ambiente interativo REPL
• Escreva e execute seu primeiro script em Node.js
• Use npm init para criar um arquivo de configuração de projeto パッケージ.json

1. Instalando e usando o nvm

(1) Por que precisamos do nvm?

O Node.js é atualizado com frequência, e diferentes projetos podem depender de versões diferentes. O nvm (Node Version Manager) permite instalar várias versões do Node.js na mesma máquina e alternar entre elas conforme necessário, evitando assim conflitos de versão.

(2) Instalar o nvm

macOS / Linux:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash

Assim que a instalação estiver concluída, reinicie o terminal ou execute o seguinte comando:

source ~/.bashrc

Windows:

Os usuários do Windows podem usar o nvm-windows. Após baixar o instalador, siga as instruções do assistente para concluir a instalação.

▶ Exemplo:(3) Instalação e alternância entre versões do Node.js

nvm install 22
nvm use 22
nvm alias default 22

▶ Exemplo: Instalando o Node.js 22 LTS e mudando de versão

$ nvm install 22
Downloading and installing node v22.11.0...
Now using node v22.11.0 (npm v10.9.0)

$ nvm use 22
Now using node v22.11.0 (npm v10.9.0)

$ nvm current
v22.11.0

(4) Comparação dos métodos de instalação do Node.js

2. Verificando a instalação do Node.js

(1) Verifique a versão do Node.js

Assim que a instalação estiver concluída, abra o terminal e digite:

node --version

Se a saída for semelhante a v22.11.0, isso significa que o Node.js foi instalado corretamente.

(2) Verifique a versão do npm

O npm é instalado junto com o Node.js. Para verificar isso:

npm --version

Se a saída for semelhante a 10.9.0, isso significa que o npm está disponível.

▶ Exemplo: Processo completo de verificação

$ node --version
v22.11.0

$ npm --version
10.9.0

$ node -e "console.log('Node.js is working!')"
Node.js is working!

Dica: node -e permite executar diretamente uma única linha de código JavaScript, o que é útil para testes rápidos.

3. Ambiente interativo REPL

(1) Entrando e saindo do REPL

Digite node no terminal para acessar o ambiente interativo REPL (Read-Eval-Print Loop):

node

Para sair: Digite .exit ou pressione Ctrl + C duas vezes.

(2) Comandos comuns do REPL

(3) Entrada com várias linhas

O REPL detecta automaticamente parênteses e chaves não fechados e entra no modo de entrada em várias linhas:

> function add(a, b) {
...   return a + b;
... }
undefined
> add(3, 5)
8

▶ Exemplo: Testando código rapidamente no REPL

> const prices = [9.99, 24.5, 3.75, 18.0]
undefined
> prices.filter(p => p > 10).reduce((sum, p) => sum + p, 0)
42.5
> const total = prices.reduce((sum, p) => sum + p, 0)
undefined
> total
56.24

4. Execute seu primeiro script

(1) Criar um arquivo JavaScript

Crie um novo arquivo chamado hello.js:

const greeting = 'Hello, Node.js!';
console.log(greeting);

const version = process.version;
console.log(`Running on ${version}`);

▶ Exemplo:(2) Execute usando o comando node

node hello.js

▶ Exemplo: Executando um script e passando parâmetros

Criado por greet.js:

const name = process.argv[2] || 'World';
console.log(`Hello, ${name}!`);
console.log(`Node version: ${process.version}`);
console.log(`Current directory: ${process.cwd()}`);

Executar:

$ node greet.js Bob
Hello, Bob!
Node version: v22.11.0
Current directory: /home/bob/projects/demo

(3) Introdução ao objeto process

process é um objeto global no Node.js que pode ser usado sem require. Propriedades comuns:

5. Criando o arquivo package.json

▶ Exemplo:(1) Criar interativamente usando npm init

npm init

O npm solicitará informações como o nome do projeto, a versão e a descrição, uma por uma, e, por fim, gerará package.json.

▶ Exemplo:(2) Use npm init -y para criar rapidamente um projeto

npm init -y

-y Ignora todas as perguntas e gera package.json usando valores padrão, o que o torna ideal para um início rápido.

▶ Exemplo: arquivo package.json gerado por npm init -y

$ mkdir my-app && cd my-app
$ npm init -y

{
  "name": "my-app",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

(3) Descrição dos campos principais no arquivo package.json

(4) Notação de intervalo de versão semântica

6. Ferramentas comuns de desenvolvimento

(1) Instalação e configuração do VS Code

O VS Code é o editor mais popular para o desenvolvimento em Node.js, com um terminal e um depurador integrados.

(2) Extensões recomendadas para o Node.js

(3) Terminal integrado do VS Code

Use o atalho de teclado Ctrl + para abrir o terminal integrado, assim você não precisa alternar entre o editor e o terminal.

▶ Exemplo: Configurando o VS Code para depurar o Node.js

Crie .vscode/launch.json no diretório raiz do projeto:

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

Pressione F5 para iniciar a depuração.

7. O processo de gerenciamento de várias versões do Node.js com o nvm

flowchart TD
    A[Installation nvm] --> B[nvm install 22]
    B --> C[nvm install 18]
    C --> D[nvm use 22]
    D --> E{Project Switching?}
    E -->|Enter the Project A| F[nvm use 22]
    E -->|Enter the Project B| G[nvm use 18]
    F --> H[node --version Verification]
    G --> H
    H --> I[Run Project]
    I --> E

flowchart TD
    A[Installation nvm] --> B[nvm install 22]
    B --> C[nvm install 18]
    C --> D[nvm use 22]
    D --> E{Project Switching?}
    E -->|Enter the Project A| F[nvm use 22]
    E -->|Enter the Project B| G[nvm use 18]
    F --> H[node --version Verification]
    G --> H
    H --> I[Run Project]
    I --> E

8. Exemplo completo: Criando um projeto Node.js do zero

O passo a passo a seguir demonstra todo o processo, desde a instalação do Node.js até a execução do seu primeiro script:

# 1. Install and switch to Node.js 22 LTS
nvm install 22
nvm use 22

# 2. Verify the Installation
node --version
npm --version

v22.11.0
10.9.0

# 3. Create a project directory and initialize it
mkdir bob-project
cd bob-project
npm init -y

Criado por index.js:

const projectName = require('./パッケージ.json').name;
const version = process.version;

console.log(`Project: ${projectName}`);
console.log(`Node.js: ${version}`);
console.log(`Directory: ${process.cwd()}`);

const アイテム = ['setup', 'config', 'deploy'];
アイテム.forEach((item, index) => {
  console.log(`Step ${index + 1}: ${item}`);
});

Projetos em andamento:

node index.js

Project: bob-project
Node.js: v22.11.0
Directory: /home/bob/bob-project
Step 1: setup
Step 2: config
Step 3: deploy

❓ Perguntas Frequentes

P: Qual é a diferença entre usar o nvm e instalar o Node.js diretamente? R: Quando você instala o Node.js diretamente, só pode usar uma versão, e a versão antiga é sobrescrita quando você atualiza; o nvm permite instalar várias versões ao mesmo tempo e alternar entre elas a qualquer momento, para que você possa usar versões diferentes para cada projeto sem que elas interfiram umas nas outras.

P: Qual é a diferença entre npm init -y e npm init? R: O npm init solicita informações como o nome e a versão do projeto, uma por uma; o npm init -y ignora todas as solicitações e gera um arquivo package.json usando valores padrão, tornando-o adequado para a criação rápida de projetos.

P: Como faço para inserir código em várias linhas no REPL? R: O REPL detecta automaticamente parênteses ou chaves não fechados e muda para o modo de várias linhas (exibindo o prompt “...” ). Você também pode digitar .editor para entrar no modo de editor de várias linhas.

P: Como escolho uma versão do Node.js? R: Dê prioridade às versões LTS (Suporte de Longo Prazo), que oferecem pelo menos 30 meses de suporte de manutenção e são adequadas para ambientes de produção. As versões atuais incluem os recursos mais recentes, mas têm um ciclo de manutenção mais curto, o que as torna adequadas para testar novos recursos.

P: Qual é a diferença entre ^ e ~ no arquivo package.json? R: ^ permite a atualização para a versão mais recente dentro da mesma versão principal (por exemplo, ^1.2.3 permite 1.x.x, mas não 2.x.x), enquanto ~ permite apenas a atualização para a versão mais recente dentro da mesma versão secundária (por exemplo, ~1.2.3 permite 1.2.x, mas não 1.3.x).

P: Os comandos do nvm-windows são os mesmos que os comandos do nvm no macOS e no Linux? R: Os comandos principais (install, use, ls) são essencialmente os mesmos, mas o nvm-windows é uma implementação independente; portanto, alguns recursos avançados podem ser diferentes. Recomendamos consultar a documentação respectiva.

P: O que devo fazer se não conseguir encontrar o comando npm após instalar o Node.js? R: O npm é instalado junto com o Node.js. Se você não conseguir encontrá-lo, talvez suas variáveis de ambiente não estejam configuradas corretamente. Tente reinstalar o Node.js ou adicionar manualmente o diretório de instalação do Node.js ao PATH do seu sistema.

📖 Resumo

• O nvm é a ferramenta preferida para gerenciar várias versões do Node.js; ele permite instalar, alternar entre versões e definir a versão padrão
• node --version e npm --version são usados para verificar se a instalação foi bem-sucedida
• O REPL oferece um ambiente de execução interativo, ideal para testar rapidamente trechos de código
• Use node <file> para executar um script JavaScript e process.argv para recuperar os argumentos da linha de comando
• npm init -y Crie rapidamente um arquivo package.json — esse é o primeiro passo para inicializar um projeto
• As extensões do VS Code + Node.js são a combinação mais popular de ferramentas de desenvolvimento

📝 Exercícios

1. Instale o Node.js 22 LTS usando o nvm e defina-o como a versão padrão
2. Acesse o REPL, defina uma função que calcule a soma de todos os números pares em um array e verifique o resultado
3. Crie um diretório de projeto, inicialize-o usando npm init -y e, em seguida, modifique os campos name e description no arquivo package.json
4. Escreva um script info.js que exiba a versão atual do Node.js, a plataforma do sistema operacional (process.platform) e o ambiente de execução (process.uptime()).
5. Instalar o Node.js Extension Pack no VS Code, configurar o launch.json e depurar e executar um script com sucesso

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós