Node.js: Módulos os e process

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

Alice é uma engenheira de DevOps responsável pelo gerenciamento de dezenas de servidores. Sempre que ela faz a implantação de um novo aplicativo, precisa fazer login manualmente nos servidores para verificar os valores dos núcleos da CPU, da memória disponível e da versão do sistema operacional e, em seguida, alterar as configurações com base nas variáveis de ambiente. Durante uma implantação de emergência às 3 da manhã, ela não percebeu um problema de falta de memória durante suas verificações manuais, o que fez com que a implantação falhasse. Por isso, decidiu escrever um script de detecção automatizado em Node.js para recuperar informações sobre os recursos do servidor e do ambiente com um único clique, garantindo que futuras implantações ocorressem sem problemas.

1. O que você vai aprender

• Principais métodos do módulo os: Recuperar informações como CPU, memória, nome do host e plataforma
• Principais características do módulo process: argv, env, exit, cwd, etc.
• Operações padrão com fluxos: stdin / stdout / stderr
• Quando o process.nextTick() é executado e qual é a sua finalidade
• Gerenciamento de variáveis de ambiente: arquivos .env e a biblioteca dotenv
• Dicas práticas para a criação de ferramentas CLI multiplataforma

2. O módulo os: Coleta de informações do sistema

(1) Informações sobre a CPU e a memória

os.cpus() retorna uma matriz com detalhes dos núcleos da CPU; os.totalmem() e os.freemem() retornam a memória total e a memória disponível, respectivamente (em bytes).

▶ Exemplo: Verificando a CPU e a memória do servidor

const os = require('os');

const cpus = os.cpus();
console.log(`CPU Number of cores: ${cpus.length}`);
console.log(`CPU Model: ${cpus[0].model}`);

const totalMem = os.totalmem();
const freeMem = os.freemem();
const usedPercent = ((totalMem - freeMem) / totalMem * 100).toFixed(1);

console.log(`Total Memory: ${(totalMem / 1024 / 1024 / 1024).toFixed(2)} GB`);
console.log(`Available memory: ${(freeMem / 1024 / 1024 / 1024).toFixed(2)} GB`);
console.log(`Memory Usage: ${usedPercent}%`);

CPU Number of cores: 8
CPU Model: Intel(R) Core(TM) i7-9700K CPU @ 3.60GHz
Total Memory: 15.88 GB
Available memory: 6.23 GB
Memory Usage: 60.7%

(2) Identificador do sistema operacional

os.platform() retorna o identificador da plataforma (por exemplo, win32, linux, darwin); os.type() retorna o nome do sistema operacional; os.arch() retorna a arquitetura da CPU; e os.hostname() retorna o nome do host.

▶ Exemplo: Obtenção de informações sobre o sistema operacional

const os = require('os');

console.log(`Platform: ${os.platform()}`);
console.log(`System Type: ${os.type()}`);
console.log(`CPU Architecture: ${os.arch()}`);
console.log(`Hostname: ${os.hostname()}`);
console.log(`System Version: ${os.version()}`);

Platform: linux
System Type: Linux
CPU Architecture: x64
Hostname: web-server-01
System Version: #1 SMP Thu Jan 1 00:00:00 UTC 2026

(3) Informações sobre usuários e diretórios

os.userInfo() Retorna as informações do usuário atual; os.homedir() retorna o diretório pessoal do usuário; os.tmpdir() retorna o diretório de arquivos temporários.

▶ Exemplo: Recuperação de informações sobre usuários e diretórios

const os = require('os');

const userInfo = os.userInfo();
console.log(`Username: ${userInfo.username}`);
console.log(`Home Directory: ${os.homedir()}`);
console.log(`Shell: ${userInfo.shell}`);
console.log(`Temporary Directory: ${os.tmpdir()}`);

Username: alice
Home Directory: /home/alice
Shell: /bin/bash
Temporary Directory: /tmp

(4) Informações sobre a interface de rede

os.networkInterfaces() Retorna informações detalhadas sobre todas as interfaces de rede, incluindo endereços IP, endereços MAC e famílias de endereços.

▶ Exemplo: Visualizando interfaces de rede

const os = require('os');

const interfaces = os.networkInterfaces();
for (const [name, addrs] of Object.entries(interfaces)) {
  for (const addr of addrs) {
    if (addr.family === 'IPv4' && !addr.internal) {
      console.log(`${name}: ${addr.address} (${addr.family})`);
    }
  }
}

eth0: 192.168.1.100 (IPv4)
wlan0: 10.0.0.5 (IPv4)

(5) Referência rápida aos métodos comuns do sistema operacional

3. O módulo process: Controle de processos

(1) Argumentos da linha de comando process.argv

process.argv é um array; argv[0] é o caminho para o executável do Node.js; argv[1] é o caminho para o script que está sendo executado; e os elementos subsequentes são os argumentos de linha de comando passados.

flowchart TD
    A["Command-Line Input<br/>node app.js --env prod --port 3000"] --> B["process.argv Array"]
    B --> C["argv[0]: Node.js Path<br/>/usr/local/bin/node"]
    B --> D["argv[1]: Script Path<br/>/home/alice/app.js"]
    B --> E["argv[2]: --env"]
    B --> F["argv[3]: prod"]
    B --> G["argv[4]: --port"]
    B --> H["argv[5]: 3000"]
    E --> I["Parameter Parsing Logic"]
    G --> I
    I --> J["{ env: 'prod', port: '3000' }"]

flowchart TD
    A["Command-Line Input<br/>node app.js --env prod --port 3000"] --> B["process.argv Array"]
    B --> C["argv[0]: Node.js Path<br/>/usr/local/bin/node"]
    B --> D["argv[1]: Script Path<br/>/home/alice/app.js"]
    B --> E["argv[2]: --env"]
    B --> F["argv[3]: prod"]
    B --> G["argv[4]: --port"]
    B --> H["argv[5]: 3000"]
    E --> I["Parameter Parsing Logic"]
    G --> I
    I --> J["{ env: 'prod', port: '3000' }"]

▶ Exemplo: Análise de argumentos da linha de comando

function parseArgs(argv) {
  const args = {};
  for (let i = 2; i < argv.length; i++) {
    if (argv[i].startsWith('--')) {
      const key = argv[i].slice(2);
      const value = argv[i + 1] && !argv[i + 1].startsWith('--')
        ? argv[++i]
        : true;
      args[key] = value;
    }
  }
  return args;
}

const config = parseArgs(process.argv);
console.log(config);

node cli.js --env production --port 8080 --verbose

{ env: 'production', port: '8080', verbose: true }

(2) A variável de ambiente process.env

process.env Contém todos os pares chave-valor das variáveis de ambiente e serve como base principal para que o script de implantação determine o ambiente de execução.

▶ Exemplo: Como ler e definir variáveis de ambiente

console.log(`NODE_ENV: ${process.env.NODE_ENV || 'development'}`);
console.log(`PATH: ${process.env.PATH}`);

process.env.APP_MODE = 'production';
console.log(`APP_MODE: ${process.env.APP_MODE}`);

NODE_ENV: development
PATH: /usr/local/bin:/usr/bin:/bin
APP_MODE: production

(3) Encerramento do processo e o diretório de trabalho

process.exit(code) Encerrar o processo (0 indica sucesso; valor diferente de zero indica falha), process.cwd() Retornar ao diretório de trabalho atual.

▶ Exemplo: Saída condicional e verificação de diretório

const requiredEnv = ['DATABASE_URL', 'APP_SECRET'];
const missing = requiredEnv.filter(key => !process.env[key]);

if (missing.length > 0) {
  console.error(`Missing required environment variables: ${missing.join(', ')}`);
  process.exit(1);
}

console.log(`Working Directory: ${process.cwd()}`);
console.log(`Process ID: ${process.pid}`);
console.log(`Runtime: ${process.uptime().toFixed(0)} seconds`);

Missing required environment variables: DATABASE_URL, APP_SECRET

(4) Fluxos padrão: stdin / stdout / stderr

process.stdout e process.stderr são fluxos de gravação, enquanto process.stdin é um fluxo de leitura usado para interagir com o terminal.

▶ Exemplo: Usando a entrada e a saída padrão

process.stdout.write('Please enter your name: ');

process.stdin.once('data', (data) => {
  const name = data.toString().trim();
  process.stdout.write(`Hello, ${name}!\n`);
  process.exit(0);
});

Please enter your name: Alice
Hello, Alice!

(5) process.nextTick()

process.nextTick() Coloca a função de retorno de chamada na fila de microtarefas, onde ela é executada após a conclusão da operação atual, mas antes que ocorram quaisquer eventos de E/S. Isso costuma ser usado para garantir que as operações assíncronas ocorram na ordem esperada.

▶ Exemplo: Ordem de execução de nextTick

console.log('1 - Synchronize Code');

process.nextTick(() => {
  console.log('3 - nextTick callback');
});

console.log('2 - Synchronize Code');

setImmediate(() => {
  console.log('5 - setImmediate');
});

Promise.resolve().then(() => {
  console.log('4 - Promise then');
});

1 - Synchronize Code
2 - Synchronize Code
3 - nextTick callback
4 - Promise then
5 - setImmediate

(6) Referência rápida às propriedades e métodos comuns de processos

4. Constantes multiplataforma e tratamento de caminhos

(1) Quebras de linha e separadores de caminho

As quebras de linha e os separadores de caminho variam de acordo com o sistema operacional; portanto, codificá-los de forma rígida pode causar problemas entre plataformas.

▶ Exemplo: Usando os.EOL e os.sep

const os = require('os');
const path = require('path');

const lines = ['First line', 'Second line', 'Third line'].join(os.EOL);
console.log('Escaping Line Breaks:', JSON.stringify(os.EOL));
console.log('Path separator:', os.sep);
console.log('path.join Results:', path.join('src', 'utils', 'index.js'));

Escaping Line Breaks: "\n"
Path separator: /
path.join Results: src/utils/index.js

(2) Comparação entre caminhos multiplataforma e constantes de quebra de linha

5. Gerenciamento de variáveis de ambiente: .env e dotenv

(1) Usos básicos da biblioteca dotenv

dotenv Carregar variáveis de ambiente do arquivo .env no arquivo process.env é a abordagem padrão do setor para gerenciar configurações de projeto.

▶ Exemplo: Como usar o dotenv para carregar um arquivo .env

Crie o arquivo .env:

NODE_ENV=production
DATABASE_URL=postgresql://db.example.com:5432/myapp
APP_SECRET=my-super-secret-key
APP_PORT=3000

Carregue o código:

require('dotenv').config();

console.log(`Environment: ${process.env.NODE_ENV}`);
console.log(`Database: ${process.env.DATABASE_URL}`);
console.log(`Port: ${process.env.APP_PORT}`);

Environment: production
Database: postgresql://db.example.com:5432/myapp
Port: 3000

(2) Comparação de métodos para definir variáveis de ambiente

(3) Como ler variáveis de ambiente com segurança

▶ Exemplo: Como ler variáveis de ambiente com validação

function getEnv(key, options = {}) {
  const value = process.env[key];

  if (value === undefined) {
    if (options.required) {
      throw new Error(`Environment Variables ${key} It is necessary`);
    }
    return options.default ?? null;
  }

  if (options.type === 'number') {
    const num = Number(value);
    if (isNaN(num)) throw new Error(`Environment Variables ${key} It must be a number`);
    return num;
  }

  if (options.type === 'boolean') {
    return value === 'true' || value === '1';
  }

  return value;
}

const port = getEnv('APP_PORT', { default: 3000, type: 'number' });
const debug = getEnv('DEBUG', { default: false, type: 'boolean' });
const dbUrl = getEnv('DATABASE_URL', { required: true });

6. Exemplo abrangente: Ferramenta CLI de diagnóstico do sistema

Crie uma ferramenta CLI completa: detecte o sistema operacional, a memória e a CPU → leia as variáveis de ambiente → formate o relatório de saída.

▶ Exemplo: syscheck.js

const os = require('os');

function parseArgs(argv) {
  const args = {};
  for (let i = 2; i < argv.length; i++) {
    if (argv[i].startsWith('--')) {
      const key = argv[i].slice(2);
      const value = argv[i + 1] && !argv[i + 1].startsWith('--')
        ? argv[++i] : true;
      args[key] = value;
    }
  }
  return args;
}

function formatBytes(bytes) {
  const units = ['B', 'KB', 'MB', 'GB'];
  let i = 0;
  let size = bytes;
  while (size >= 1024 && i < units.length - 1) {
    size /= 1024;
    i++;
  }
  return `${size.toFixed(2)} ${units[i]}`;
}

function getSystemInfo() {
  const cpus = os.cpus();
  const totalMem = os.totalmem();
  const freeMem = os.freemem();
  return {
    hostname: os.hostname(),
    platform: os.platform(),
    arch: os.arch(),
    osType: os.type(),
    cpuModel: cpus[0].model,
    cpuCores: cpus.length,
    totalMemory: formatBytes(totalMem),
    freeMemory: formatBytes(freeMem),
    memUsage: ((totalMem - freeMem) / totalMem * 100).toFixed(1) + '%',
    uptime: (os.uptime() / 3600).toFixed(1) + ' hours'
  };
}

function getEnvInfo(keys) {
  const result = {};
  for (const key of keys) {
    result[key] = process.env[key] || '(Not set)';
  }
  return result;
}

function printReport(sys, env) {
  const sep = '='.repeat(48);
  console.log(`\n${sep}`);
  console.log('  System Diagnostic Report');
  console.log(`${sep}`);
  console.log(`  Hostname     : ${sys.hostname}`);
  console.log(`  Platform       : ${sys.platform} / ${sys.arch}`);
  console.log(`  Operating System   : ${sys.osType}`);
  console.log(`  CPU        : ${sys.cpuModel}`);
  console.log(`  CPU Number of cores : ${sys.cpuCores}`);
  console.log(`  Total Memory     : ${sys.totalMemory}`);
  console.log(`  Available memory   : ${sys.freeMemory}`);
  console.log(`  Memory Usage : ${sys.memUsage}`);
  console.log(`  Runtime   : ${sys.uptime}`);
  console.log(`${sep}`);
  console.log('  Environment Variables');
  console.log('-'.repeat(48));
  for (const [key, val] of Object.entries(env)) {
    console.log(`  ${key.padEnd(20)} : ${val}`);
  }
  console.log(`${sep}\n`);
}

const args = parseArgs(process.argv);
const envKeys = args.envKeys
  ? args.envKeys.split(',')
  : ['NODE_ENV', 'HOME', 'PATH', 'SHELL'];
const sys = getSystemInfo();
const env = getEnvInfo(envKeys);
printReport(sys, env);

node syscheck.js --envKeys NODE_ENV,APP_PORT,DATABASE_URL

================================================
  System Diagnostic Report
================================================
  Hostname     : web-server-01
  Platform       : linux / x64
  Operating System   : Linux
  CPU        : Intel(R) Xeon(R) CPU E5-2680 v4
  CPU Number of cores : 8
  Total Memory     : 15.88 GB
  Available memory   : 6.23 GB
  Memory Usage : 60.7%
  Runtime   : 72.5 hours
================================================
  Environment Variables
------------------------------------------------
  NODE_ENV             : production
  APP_PORT             : (Not set)
  DATABASE_URL         : (Not set)
================================================

❓ Perguntas Frequentes

P: O que são process.argv[0] e process.argv[1], respectivamente? R: argv[0] é o caminho para o executável do Node.js (por exemplo, /usr/local/bin/node), e argv[1] é o caminho para o arquivo de script que está sendo executado (por exemplo, /home/alice/app.js). Os argumentos efetivamente fornecidos pelo usuário começam em argv[2].

P: Como posso ler variáveis de ambiente com segurança? R: Sempre forneça um valor padrão ou verifique se a variável existe; converta e valide tipos numéricos; use o dotenv para gerenciar o arquivo .env; e nunca envie o arquivo .env para o controle de versão.

P: Quais unidades a função os.freemem() retorna? R: Ela retorna o número de bytes. Para exibir o resultado em GB, é preciso dividir manualmente por 1073741824 (ou seja, 1024 × 1024 × 1024), ou pode-se usar uma função de formatação para converter automaticamente o valor.

P: Como faço para ler a entrada do usuário no Node.js? R: Você pode usar o fluxo de leitura process.stdin em conjunto com um ouvinte de eventos data, ou utilizar a interface de leitura linha por linha fornecida pelo módulo readline; o readline é mais adequado para cenários interativos de perguntas e respostas.

P: Por que process.exit() deve ser usado com cautela? R: process.exit() encerra imediatamente o processo, ignorando todas as chamadas de retorno pendentes, operações de E/S e lógica de limpeza, o que pode resultar em perda de dados ou recursos não liberados. Você deve priorizar permitir que o ciclo de eventos termine naturalmente.

P: Qual é a diferença entre process.nextTick() e setImmediate()? R: A chamada de retorno nextTick está na fila de microtarefas; ela é executada imediatamente após a operação atual e tem precedência sobre todas as operações de E/S. setImmediate está na fila de macrotarefas e é executada durante a fase do ciclo de eventos de E/S; nextTick tem prioridade mais alta.

P: Onde deve ser colocado o arquivo .env do dotenv? R: Por padrão, ele fica no diretório raiz do projeto. Você pode especificar um caminho usando config({ path: 'custom/path' }). Certifique-se de adicionar .env a .gitignore para evitar que informações confidenciais sejam expostas.

📖 Resumo

• O módulo os fornece informações no nível do sistema: CPU, memória, plataforma, interfaces de rede, informações do usuário e muito mais.
• process.argv analisa os argumentos da linha de comando; argv[0] é o caminho do Node, e argv[1] é o caminho do script
• process.env gerencia variáveis de ambiente; a biblioteca dotenv carrega configurações a partir de arquivos .env
• Use process.exit() com cautela para evitar que a lógica de limpeza seja ignorada.
• process.nextTick() é uma microtarefa e tem prioridade sobre setImmediate e Promise
• Use os.EOL, os.sep e path.join para lidar com as diferenças entre plataformas

📝 Exercícios

1. Escreva um script que exiba o número de núcleos da CPU, a memória total (GB), a memória disponível (GB) e a porcentagem de uso da memória no sistema atual.
2. Use process.argv para implementar uma calculadora simples de linha de comando que suporte três operações: --add, --sub e --mul.
3. Crie um arquivo .env para armazenar as informações de conexão com o banco de dados, carregue-o usando o dotenv e leia-o com segurança no script (forneça valores padrão)
4. Implemente uma função que verifique se a plataforma atual é o Windows; se for, use o caractere de quebra de linha \r\n; caso contrário, use \n.
5. Escreva um script para monitorar o uso da memória e exibir uma mensagem de aviso no stderr quando ele ultrapassar 90%.

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