События процесса

Объект process является экземпляром EventEmitter.

import process from 'node:process';

process.on('beforeExit', (code) => {
  console.log('Process beforeExit event with code: ', code);
});

process.on('exit', (code) => {
  console.log('Process exit event with code: ', code);
});

console.log('This message is displayed first.');

// Prints:
// This message is displayed first.
// Process beforeExit event with code: 0
// Process exit event with code: 0

const process = require('node:process');

process.on('beforeExit', (code) => {
  console.log('Process beforeExit event with code: ', code);
});

process.on('exit', (code) => {
  console.log('Process exit event with code: ', code);
});

console.log('This message is displayed first.');

// Prints:
// This message is displayed first.
// Process beforeExit event with code: 0
// Process exit event with code: 0

import process from 'node:process';

process.on('exit', (code) => {
  console.log(`About to exit with code: ${code}`);
});

const process = require('node:process');

process.on('exit', (code) => {
  console.log(`About to exit with code: ${code}`);
});

import process from 'node:process';

process.on('exit', (code) => {
  setTimeout(() => {
    console.log('This will not run');
  }, 0);
});

const process = require('node:process');

process.on('exit', (code) => {
  setTimeout(() => {
    console.log('This will not run');
  }, 0);
});

import process from 'node:process';

process.on('multipleResolves', (type, promise, reason) => {
  console.error(type, promise, reason);
  setImmediate(() => process.exit(1));
});

async function main() {
  try {
    return await new Promise((resolve, reject) => {
      resolve('First call');
      resolve('Swallowed resolve');
      reject(new Error('Swallowed reject'));
    });
  } catch {
    throw new Error('Failed');
  }
}

main().then(console.log);
// resolve: Promise { 'First call' } 'Swallowed resolve'
// reject: Promise { 'First call' } Error: Swallowed reject
//     at Promise (*)
//     at new Promise (<anonymous>)
//     at main (*)
// First call

const process = require('node:process');

process.on('multipleResolves', (type, promise, reason) => {
  console.error(type, promise, reason);
  setImmediate(() => process.exit(1));
});

async function main() {
  try {
    return await new Promise((resolve, reject) => {
      resolve('First call');
      resolve('Swallowed resolve');
      reject(new Error('Swallowed reject'));
    });
  } catch {
    throw new Error('Failed');
  }
}

main().then(console.log);
// resolve: Promise { 'First call' } 'Swallowed resolve'
// reject: Promise { 'First call' } Error: Swallowed reject
//     at Promise (*)
//     at new Promise (<anonymous>)
//     at main (*)
// First call

import process from 'node:process';

const unhandledRejections = new Map();
process.on('unhandledRejection', (reason, promise) => {
  unhandledRejections.set(promise, reason);
});
process.on('rejectionHandled', (promise) => {
  unhandledRejections.delete(promise);
});

const process = require('node:process');

const unhandledRejections = new Map();
process.on('unhandledRejection', (reason, promise) => {
  unhandledRejections.set(promise, reason);
});
process.on('rejectionHandled', (promise) => {
  unhandledRejections.delete(promise);
});

import process from 'node:process';
import fs from 'node:fs';

process.on('uncaughtException', (err, origin) => {
  fs.writeSync(
    process.stderr.fd,
    `Caught exception: ${err}\n` +
    `Exception origin: ${origin}\n`,
  );
});

setTimeout(() => {
  console.log('This will still run.');
}, 500);

// Intentionally cause an exception, but don't catch it.
nonexistentFunc();
console.log('This will not run.');

const process = require('node:process');
const fs = require('node:fs');

process.on('uncaughtException', (err, origin) => {
  fs.writeSync(
    process.stderr.fd,
    `Caught exception: ${err}\n` +
    `Exception origin: ${origin}\n`,
  );
});

setTimeout(() => {
  console.log('This will still run.');
}, 500);

// Intentionally cause an exception, but don't catch it.
nonexistentFunc();
console.log('This will not run.');

import process from 'node:process';

process.on('uncaughtExceptionMonitor', (err, origin) => {
  MyMonitoringTool.logSync(err, origin);
});

// Intentionally cause an exception, but don't catch it.
nonexistentFunc();
// Still crashes Node.js

const process = require('node:process');

process.on('uncaughtExceptionMonitor', (err, origin) => {
  MyMonitoringTool.logSync(err, origin);
});

// Intentionally cause an exception, but don't catch it.
nonexistentFunc();
// Still crashes Node.js

import process from 'node:process';

process.on('unhandledRejection', (reason, promise) => {
  console.log('Unhandled Rejection at:', promise, 'reason:', reason);
  // Application specific logging, throwing an error, or other logic here
});

somePromise.then((res) => {
  return reportToUser(JSON.pasre(res)); // Note the typo (`pasre`)
}); // No `.catch()` or `.then()`

const process = require('node:process');

process.on('unhandledRejection', (reason, promise) => {
  console.log('Unhandled Rejection at:', promise, 'reason:', reason);
  // Application specific logging, throwing an error, or other logic here
});

somePromise.then((res) => {
  return reportToUser(JSON.pasre(res)); // Note the typo (`pasre`)
}); // No `.catch()` or `.then()`

import process from 'node:process';

function SomeResource() {
  // Initially set the loaded status to a rejected promise
  this.loaded = Promise.reject(new Error('Resource not yet loaded!'));
}

const resource = new SomeResource();
// no .catch or .then on resource.loaded for at least a turn

const process = require('node:process');

function SomeResource() {
  // Initially set the loaded status to a rejected promise
  this.loaded = Promise.reject(new Error('Resource not yet loaded!'));
}

const resource = new SomeResource();
// no .catch or .then on resource.loaded for at least a turn

import process from 'node:process';

process.on('warning', (warning) => {
  console.warn(warning.name);    // Print the warning name
  console.warn(warning.message); // Print the warning message
  console.warn(warning.stack);   // Print the stack trace
});

const process = require('node:process');

process.on('warning', (warning) => {
  console.warn(warning.name);    // Print the warning name
  console.warn(warning.message); // Print the warning message
  console.warn(warning.stack);   // Print the stack trace
});

$ node
> events.defaultMaxListeners = 1;
> process.on('foo', () => {});
> process.on('foo', () => {});
> (node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak
detected. 2 foo listeners added. Use emitter.setMaxListeners() to increase limit copy

$ node --no-warnings
> const p = process.on('warning', (warning) => console.warn('Do not do that!'));
> events.defaultMaxListeners = 1;
> process.on('foo', () => {});
> process.on('foo', () => {});
> Do not do that! copy

import process from 'node:process';

// Begin reading from stdin so the process does not exit.
process.stdin.resume();

process.on('SIGINT', () => {
  console.log('Received SIGINT. Press Control-D to exit.');
});

// Using a single function to handle multiple signals
function handle(signal) {
  console.log(`Received ${signal}`);
}

process.on('SIGINT', handle);
process.on('SIGTERM', handle);

const process = require('node:process');

// Begin reading from stdin so the process does not exit.
process.stdin.resume();

process.on('SIGINT', () => {
  console.log('Received SIGINT. Press Control-D to exit.');
});

// Using a single function to handle multiple signals
function handle(signal) {
  console.log(`Received ${signal}`);
}

process.on('SIGINT', handle);
process.on('SIGTERM', handle);

process.abort()

Метод process.abort() приводит к немедленному завершению процесса Node.js и созданию core-файла (дампа памяти).

Эта возможность недоступна в потоках Worker.

process.allowedNodeEnvironmentFlags

• Тип: <Set>

Свойство process.allowedNodeEnvironmentFlags представляет собой специальный, доступный только для чтения Set флагов, допустимых в переменной окружения NODE_OPTIONS.

process.allowedNodeEnvironmentFlags расширяет Set, но переопределяет Set.prototype.has для распознавания нескольких различных вариантов представления флагов. process.allowedNodeEnvironmentFlags.has() возвращает true в следующих случаях:

• Флаги могут не содержать начальных одинарных (-) или двойных (--) дефисов; например, inspect-brk вместо --inspect-brk или r вместо -r.
• Флаги, передаваемые в V8 (как указано в --v8-options), могут заменять один или несколько ненаправляющих дефисов на подчеркивание или наоборот; например, --perf_basic_prof, --perf-basic-prof, --perf_basic-prof и т. д.
• Флаги могут содержать один или несколько знаков равенства (=); все символы после первого знака равенства (включая его самого) будут проигнорированы; например, --stack-trace-limit=100.
• Флаги должны быть допустимыми в NODE_OPTIONS.

При итерации по process.allowedNodeEnvironmentFlags флаги будут встречаться только один раз; каждый из них будет начинаться с одного или нескольких дефисов. Флаги, передаваемые в V8, будут содержать символы подчеркивания вместо ненаправляющих дефисов:

import { allowedNodeEnvironmentFlags } from 'node:process';

allowedNodeEnvironmentFlags.forEach((flag) => {
  // -r
  // --inspect-brk
  // --abort_on_uncaught_exception
  // ...
});

const { allowedNodeEnvironmentFlags } = require('node:process');

allowedNodeEnvironmentFlags.forEach((flag) => {
  // -r
  // --inspect-brk
  // --abort_on_uncaught_exception
  // ...
});

Методы add(), clear() и delete() объекта process.allowedNodeEnvironmentFlags ничего не делают и завершаются без ошибок.

Если Node.js был скомпилирован без поддержки NODE_OPTIONS (как указано в process.config), process.allowedNodeEnvironmentFlags будет содержать то, что было бы допустимо.

process.arch

• Тип: <string>

Архитектура процессора операционной системы, для которой был скомпилирован исполняемый файл Node.js. Возможные значения: 'arm', 'arm64', 'ia32', 'loong64', 'mips', 'mipsel', 'ppc64', 'riscv64', 's390', 's390x' и 'x64'.

import { arch } from 'node:process';

console.log(`This processor architecture is ${arch}`);

const { arch } = require('node:process');

console.log(`This processor architecture is ${arch}`);

process.argv

• Тип: <string[]>

Свойство process.argv возвращает массив, содержащий аргументы командной строки, переданные при запуске процесса Node.js. Первым элементом будет process.execPath. См. process.argv0, если требуется доступ к исходному значению argv[0]. Если была указана точка входа программы, вторым элементом будет абсолютный путь к ней. Оставшиеся элементы — это дополнительные аргументы командной строки.

Например, предположим следующий сценарий для process-args.js:

import { argv } from 'node:process';

// print process.argv
argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
});

const { argv } = require('node:process');

// print process.argv
argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
});

Запуск процесса Node.js следующим образом:

node process-args.js one two=three four copy

Сгенерирует следующий вывод:

0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four copy

process.argv0

• Тип: <string>

Свойство process.argv0 хранит доступную только для чтения копию исходного значения argv[0], переданного при запуске Node.js.

$ bash -c 'exec -a customArgv0 ./node'
> process.argv[0]
'/Volumes/code/external/node/out/Release/node'
> process.argv0
'customArgv0' copy

process.availableMemory()

• Тип: <number>

Возвращает объем свободной памяти, все еще доступной процессу (в байтах).

Дополнительную информацию см. в разделе uv_get_available_memory.

process.channel

• Тип: <Object>

Если процесс Node.js был порожден с каналом IPC (см. документацию по Child Process), свойство process.channel является ссылкой на канал IPC. Если канал IPC отсутствует, это свойство имеет значение undefined.

process.chdir(directory)

• directory <string>

Метод process.chdir() изменяет текущую рабочую директорию процесса Node.js или генерирует исключение в случае неудачи (например, если указанный directory не существует).

import { chdir, cwd } from 'node:process';

console.log(`Starting directory: ${cwd()}`);
try {
  chdir('/tmp');
  console.log(`New directory: ${cwd()}`);
} catch (err) {
  console.error(`chdir: ${err}`);
}

const { chdir, cwd } = require('node:process');

console.log(`Starting directory: ${cwd()}`);
try {
  chdir('/tmp');
  console.log(`New directory: ${cwd()}`);
} catch (err) {
  console.error(`chdir: ${err}`);
}

Эта функция недоступна в потоках Worker.

process.config

• Тип: <Object>

Свойство process.config возвращает замороженный Object, содержащий JavaScript-представление параметров конфигурации, использованных при компиляции текущего исполняемого файла Node.js. Это то же самое, что и файл config.gypi, созданный при выполнении скрипта ./configure.

Пример возможного вывода выглядит следующим образом:

{
  target_defaults:
   { cflags: [],
     default_configuration: 'Release',
     defines: [],
     include_dirs: [],
     libraries: [] },
  variables:
   {
     host_arch: 'x64',
     napi_build_version: 5,
     node_install_npm: 'true',
     node_prefix: '',
     node_shared_cares: 'false',
     node_shared_http_parser: 'false',
     node_shared_libuv: 'false',
     node_shared_zlib: 'false',
     node_use_openssl: 'true',
     node_shared_openssl: 'false',
     target_arch: 'x64',
     v8_use_snapshot: 1
   }
} copy

process.connected

• Тип: <boolean>

Если процесс Node.js запущен с каналом IPC (см. документацию по разделам Child Process и Cluster), свойство process.connected будет возвращать true до тех пор, пока канал IPC подключен, и вернет false после вызова process.disconnect().

Как только process.connected принимает значение false, отправка сообщений по каналу IPC с помощью process.send() становится невозможной.

process.constrainedMemory()

• Тип: <number>

Возвращает объем памяти, доступной процессу (в байтах), с учетом ограничений, наложенных операционной системой. Если такое ограничение отсутствует или неизвестно, возвращается 0.

Дополнительную информацию см. в разделе uv_get_constrained_memory.

process.cpuUsage([previousValue])

• previousValue <Object> Предыдущее возвращаемое значение вызова process.cpuUsage()
• Возвращает: <Object>
  • user <integer>
  • system <integer>

Метод process.cpuUsage() возвращает время использования процессора текущим процессом в пользовательском и системном режимах в виде объекта со свойствами user и system, значения которых выражены в микросекундах (миллионных долях секунды). Эти значения измеряют время, проведенное в пользовательском и системном коде соответственно, и могут оказаться больше фактического прошедшего времени, если работу для этого процесса выполняют несколько ядер процессора.

Результат предыдущего вызова process.cpuUsage() можно передать в качестве аргумента функции, чтобы получить значение разницы.

import { cpuUsage } from 'node:process';

const startUsage = cpuUsage();
// { user: 38579, system: 6986 }

// spin the CPU for 500 milliseconds
const now = Date.now();
while (Date.now() - now < 500);

console.log(cpuUsage(startUsage));
// { user: 514883, system: 11226 }

const { cpuUsage } = require('node:process');

const startUsage = cpuUsage();
// { user: 38579, system: 6986 }

// spin the CPU for 500 milliseconds
const now = Date.now();
while (Date.now() - now < 500);

console.log(cpuUsage(startUsage));
// { user: 514883, system: 11226 }

process.cwd()

• Возвращает: <string>

Метод process.cwd() возвращает текущую рабочую директорию процесса Node.js.

import { cwd } from 'node:process';

console.log(`Current directory: ${cwd()}`);

const { cwd } = require('node:process');

console.log(`Current directory: ${cwd()}`);

process.debugPort

• Тип: <number>

Порт, используемый отладчиком Node.js при его включении.

import process from 'node:process';

process.debugPort = 5858;

const process = require('node:process');

process.debugPort = 5858;

process.disconnect()

Если процесс Node.js запущен с каналом IPC (см. документацию по разделам Child Process и Cluster), метод process.disconnect() закроет канал IPC с родительским процессом, позволяя дочернему процессу корректно завершить работу, когда больше не останется соединений, поддерживающих его активность.

Результат вызова process.disconnect() аналогичен вызову ChildProcess.disconnect() из родительского процесса.

Если процесс Node.js не был запущен с каналом IPC, свойство process.disconnect() будет равно undefined.

process.dlopen(module, filename[, flags])

• module <Object>
• filename <string>
• flags <os.constants.dlopen> По умолчанию: os.constants.dlopen.RTLD_LAZY

Метод process.dlopen() позволяет динамически загружать разделяемые объекты. В основном он используется require() для загрузки C++-аддонов и не должен использоваться напрямую, за исключением особых случаев. Другими словами, следует отдавать предпочтение require() перед process.dlopen(), если только нет особых причин, таких как пользовательские флаги dlopen или загрузка из модулей ES.

Аргумент flags представляет собой целое число, позволяющее настроить поведение dlopen. Подробности см. в документации по os.constants.dlopen.

Важным требованием при вызове process.dlopen() является передача экземпляра module. Функции, экспортируемые C++-аддоном, затем будут доступны через module.exports.

В приведенном ниже примере показано, как загрузить C++-аддон с именем local.node, экспортирующий функцию foo. Все символы загружаются до возврата из вызова путем передачи константы RTLD_NOW. В этом примере предполагается, что константа доступна.

import { dlopen } from 'node:process';
import { constants } from 'node:os';
import { fileURLToPath } from 'node:url';

const module = { exports: {} };
dlopen(module, fileURLToPath(new URL('local.node', import.meta.url)),
       constants.dlopen.RTLD_NOW);
module.exports.foo();

const { dlopen } = require('node:process');
const { constants } = require('node:os');
const { join } = require('node:path');

const module = { exports: {} };
dlopen(module, join(__dirname, 'local.node'), constants.dlopen.RTLD_NOW);
module.exports.foo();

process.emitWarning(warning[, options])

• warning <string> | <Error> Предупреждение для генерации.
• options <Object>
  • type <string> Если warning является String, type — это имя, используемое для типа генерируемого предупреждения. По умолчанию: 'Warning'.
  • code <string> Уникальный идентификатор для экземпляра генерируемого предупреждения.
  • ctor <Function> Если warning является String, ctor — это необязательная функция, используемая для ограничения создаваемой трассировки стека. По умолчанию: process.emitWarning.
  • detail <string> Дополнительный текст, включаемый в ошибку.

Метод process.emitWarning() можно использовать для генерации пользовательских предупреждений процесса или предупреждений, специфичных для приложения. Их можно отслеживать, добавив обработчик для события 'warning'.

import { emitWarning } from 'node:process';

// Emit a warning with a code and additional detail.
emitWarning('Something happened!', {
  code: 'MY_WARNING',
  detail: 'This is some additional information',
});
// Emits:
// (node:56338) [MY_WARNING] Warning: Something happened!
// This is some additional information

const { emitWarning } = require('node:process');

// Emit a warning with a code and additional detail.
emitWarning('Something happened!', {
  code: 'MY_WARNING',
  detail: 'This is some additional information',
});
// Emits:
// (node:56338) [MY_WARNING] Warning: Something happened!
// This is some additional information

В этом примере объект Error создается внутри process.emitWarning() и передается в обработчик 'warning'.

import process from 'node:process';

process.on('warning', (warning) => {
  console.warn(warning.name);    // 'Warning'
  console.warn(warning.message); // 'Something happened!'
  console.warn(warning.code);    // 'MY_WARNING'
  console.warn(warning.stack);   // Stack trace
  console.warn(warning.detail);  // 'This is some additional information'
});

const process = require('node:process');

process.on('warning', (warning) => {
  console.warn(warning.name);    // 'Warning'
  console.warn(warning.message); // 'Something happened!'
  console.warn(warning.code);    // 'MY_WARNING'
  console.warn(warning.stack);   // Stack trace
  console.warn(warning.detail);  // 'This is some additional information'
});

Если warning передан как объект Error, аргумент options игнорируется.

process.emitWarning(warning[, type[, code]][, ctor])

• warning <string> | <Error> Предупреждение для генерации.
• type <string> Если warning является String, type — это имя, используемое для типа генерируемого предупреждения. По умолчанию: 'Warning'.
• code <string> Уникальный идентификатор для экземпляра генерируемого предупреждения.
• ctor <Function> Если warning является String, ctor — это необязательная функция, используемая для ограничения создаваемой трассировки стека. По умолчанию: process.emitWarning.

Метод process.emitWarning() можно использовать для генерации пользовательских предупреждений процесса или предупреждений, специфичных для приложения. Их можно отслеживать, добавив обработчик для события 'warning'.

import { emitWarning } from 'node:process';

// Emit a warning using a string.
emitWarning('Something happened!');
// Emits: (node: 56338) Warning: Something happened!

const { emitWarning } = require('node:process');

// Emit a warning using a string.
emitWarning('Something happened!');
// Emits: (node: 56338) Warning: Something happened!

import { emitWarning } from 'node:process';

// Emit a warning using a string and a type.
emitWarning('Something Happened!', 'CustomWarning');
// Emits: (node:56338) CustomWarning: Something Happened!

const { emitWarning } = require('node:process');

// Emit a warning using a string and a type.
emitWarning('Something Happened!', 'CustomWarning');
// Emits: (node:56338) CustomWarning: Something Happened!

import { emitWarning } from 'node:process';

emitWarning('Something happened!', 'CustomWarning', 'WARN001');
// Emits: (node:56338) [WARN001] CustomWarning: Something happened!

const { emitWarning } = require('node:process');

process.emitWarning('Something happened!', 'CustomWarning', 'WARN001');
// Emits: (node:56338) [WARN001] CustomWarning: Something happened!

В каждом из предыдущих примеров объект Error генерируется внутри process.emitWarning() и передается в обработчик 'warning'.

import process from 'node:process';

process.on('warning', (warning) => {
  console.warn(warning.name);
  console.warn(warning.message);
  console.warn(warning.code);
  console.warn(warning.stack);
});

const process = require('node:process');

process.on('warning', (warning) => {
  console.warn(warning.name);
  console.warn(warning.message);
  console.warn(warning.code);
  console.warn(warning.stack);
});

Если warning передан как объект Error, он будет передан в обработчик события 'warning' без изменений (а необязательные аргументы type, code и ctor будут проигнорированы):

import { emitWarning } from 'node:process';

// Emit a warning using an Error object.
const myWarning = new Error('Something happened!');
// Use the Error name property to specify the type name
myWarning.name = 'CustomWarning';
myWarning.code = 'WARN001';

emitWarning(myWarning);
// Emits: (node:56338) [WARN001] CustomWarning: Something happened!

const { emitWarning } = require('node:process');

// Emit a warning using an Error object.
const myWarning = new Error('Something happened!');
// Use the Error name property to specify the type name
myWarning.name = 'CustomWarning';
myWarning.code = 'WARN001';

emitWarning(myWarning);
// Emits: (node:56338) [WARN001] CustomWarning: Something happened!

TypeError генерируется, если warning не является строкой или объектом Error.

Хотя предупреждения процесса используют объекты Error, механизм предупреждений процесса не является заменой обычных механизмов обработки ошибок.

Следующая дополнительная обработка применяется, если type предупреждения имеет значение 'DeprecationWarning':

• Если используется флаг командной строки --throw-deprecation, предупреждение об устаревании выбрасывается как исключение, а не генерируется как событие.
• Если используется флаг командной строки --no-deprecation, предупреждение об устаревании подавляется.
• Если используется флаг командной строки --trace-deprecation, предупреждение об устаревании выводится в stderr вместе с полной трассировкой стека.

import { emitWarning } from 'node:process';

function emitMyWarning() {
  if (!emitMyWarning.warned) {
    emitMyWarning.warned = true;
    emitWarning('Only warn once!');
  }
}
emitMyWarning();
// Emits: (node: 56339) Warning: Only warn once!
emitMyWarning();
// Emits nothing

const { emitWarning } = require('node:process');

function emitMyWarning() {
  if (!emitMyWarning.warned) {
    emitMyWarning.warned = true;
    emitWarning('Only warn once!');
  }
}
emitMyWarning();
// Emits: (node: 56339) Warning: Only warn once!
emitMyWarning();
// Emits nothing

process.env

• Тип: <Object>

Свойство process.env возвращает объект, содержащий пользовательское окружение. См. environ(7).

Пример такого объекта выглядит следующим образом:

{
  TERM: 'xterm-256color',
  SHELL: '/usr/local/bin/bash',
  USER: 'maciej',
  PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
  PWD: '/Users/maciej',
  EDITOR: 'vim',
  SHLVL: '1',
  HOME: '/Users/maciej',
  LOGNAME: 'maciej',
  _: '/usr/local/bin/node'
} copy

Этот объект можно изменять, однако такие изменения не будут отражаться за пределами процесса Node.js или (если это не запрошено явно) в других потоках Worker. Иными словами, следующий пример работать не будет:

node -e 'process.env.foo = "bar"' && echo $foo copy

В то время как следующий будет работать:

import { env } from 'node:process';

env.foo = 'bar';
console.log(env.foo);

const { env } = require('node:process');

env.foo = 'bar';
console.log(env.foo);

Присвоение свойства в process.env неявно преобразует значение в строку. Это поведение устарело. Будущие версии Node.js могут выдавать ошибку, если значение не является строкой, числом или логическим значением.

import { env } from 'node:process';

env.test = null;
console.log(env.test);
// => 'null'
env.test = undefined;
console.log(env.test);
// => 'undefined'

const { env } = require('node:process');

env.test = null;
console.log(env.test);
// => 'null'
env.test = undefined;
console.log(env.test);
// => 'undefined'

Используйте delete для удаления свойства из process.env.

import { env } from 'node:process';

env.TEST = 1;
delete env.TEST;
console.log(env.TEST);
// => undefined

const { env } = require('node:process');

env.TEST = 1;
delete env.TEST;
console.log(env.TEST);
// => undefined

В операционных системах Windows переменные окружения нечувствительны к регистру.

import { env } from 'node:process';

env.TEST = 1;
console.log(env.test);
// => 1

const { env } = require('node:process');

env.TEST = 1;
console.log(env.test);
// => 1

Если иное явно не указано при создании экземпляра Worker, каждый поток Worker имеет собственную копию process.env, основанную на process.env родительского потока или на том, что было указано в качестве параметра env в конструкторе Worker. Изменения в process.env не будут видны в других потоках Worker, и только главный поток может вносить изменения, видимые операционной системе или нативным аддонам. В Windows копия process.env в экземпляре Worker работает с учетом регистра, в отличие от главного потока.

process.execArgv

• Тип: <string[]>

Свойство process.execArgv возвращает набор параметров командной строки, специфичных для Node.js, переданных при запуске процесса Node.js. Эти параметры не отображаются в массиве, возвращаемом свойством process.argv, и не включают исполняемый файл Node.js, имя скрипта или любые параметры, следующие за именем скрипта. Эти параметры полезны для порождения дочерних процессов с той же средой выполнения, что и у родительского процесса.

node --icu-data-dir=./foo --require ./bar.js script.js --version copy

Приведет к process.execArgv:

["--icu-data-dir=./foo", "--require", "./bar.js"] copy

И process.argv:

['/usr/local/bin/node', 'script.js', '--version'] copy

Подробное описание поведения рабочих потоков с этим свойством см. в разделе конструктор Worker.

process.execPath

• Тип: <string>

Свойство process.execPath возвращает абсолютный путь к исполняемому файлу, запустившему процесс Node.js. Символические ссылки, если таковые имеются, разрешаются.

'/usr/local/bin/node' copy

process.execve(file[, args[, env]])

• file <string> Имя или путь к запускаемому исполняемому файлу.
• args <string[]> Список строковых аргументов. Ни один аргумент не может содержать нулевой байт (\u0000).
• env <Object> Пары ключ-значение переменных окружения. Ни один ключ или значение не могут содержать нулевой байт (\u0000). По умолчанию: process.env.

Заменяет текущий процесс новым процессом.

Это достигается с помощью POSIX-функции execve, и поэтому никакая память или другие ресурсы текущего процесса не сохраняются, за исключением файловых дескрипторов стандартного ввода, стандартного вывода и стандартного потока ошибок.

Все остальные ресурсы отбрасываются системой при замене процессов, не вызывая событий выхода или закрытия и не выполняя никаких обработчиков очистки.

Эта функция никогда не возвращает управление, если только не произошла ошибка.

Эта функция недоступна в Windows или IBM i.

process.exit([code])

• code <integer> | <string> | <null> | <undefined> Код завершения. Для типа string разрешены только целочисленные строки (например, '1'). По умолчанию: 0.

Метод process.exit() указывает Node.js синхронно завершить процесс со статусом выхода code. Если code опущен, выход использует либо код «успешно» 0, либо значение process.exitCode, если оно было установлено. Node.js не завершит работу до тех пор, пока не будут вызваны все слушатели события 'exit'.

Для выхода с кодом «ошибка»:

import { exit } from 'node:process';

exit(1);

const { exit } = require('node:process');

exit(1);

Командная оболочка, выполнившая Node.js, должна увидеть код завершения как 1.

Вызов process.exit() принудительно завершит процесс как можно быстрее, даже если все еще ожидается завершение асинхронных операций, включая операции ввода-вывода в process.stdout и process.stderr.

В большинстве ситуаций явный вызов process.exit() не требуется. Процесс Node.js завершится самостоятельно, если в цикле событий нет ожидающей работы. Свойство process.exitCode можно установить, чтобы указать процессу, какой код завершения использовать при корректном завершении процесса.

Например, следующий пример демонстрирует неправильное использование метода process.exit(), которое может привести к усечению и потере данных, выводимых в stdout:

import { exit } from 'node:process';

// This is an example of what *not* to do:
if (someConditionNotMet()) {
  printUsageToStdout();
  exit(1);
}

const { exit } = require('node:process');

// This is an example of what *not* to do:
if (someConditionNotMet()) {
  printUsageToStdout();
  exit(1);
}

Проблема заключается в том, что запись в process.stdout в Node.js иногда является асинхронной и может происходить в течение нескольких тиков цикла событий Node.js. Однако вызов process.exit() принудительно завершает процесс до того, как эти дополнительные операции записи в stdout смогут выполниться.

Вместо прямого вызова process.exit() коду следует установить process.exitCode и позволить процессу завершиться естественным путем, избегая планирования какой-либо дополнительной работы для цикла событий:

import process from 'node:process';

// How to properly set the exit code while letting
// the process exit gracefully.
if (someConditionNotMet()) {
  printUsageToStdout();
  process.exitCode = 1;
}

const process = require('node:process');

// How to properly set the exit code while letting
// the process exit gracefully.
if (someConditionNotMet()) {
  printUsageToStdout();
  process.exitCode = 1;
}

Если необходимо завершить процесс Node.js из-за ошибки, генерация неперехваченной ошибки и предоставление процессу возможности завершиться соответствующим образом безопаснее, чем вызов process.exit().

В потоках Worker эта функция останавливает текущий поток, а не текущий процесс.

process.exitCode

• Тип: <integer> | <string> | <null> | <undefined> Код завершения. Для типа string разрешены только целочисленные строки (например, '1'). По умолчанию: undefined.

Число, которое будет кодом завершения процесса, когда процесс либо завершается корректно, либо завершается через process.exit() без указания кода.

Значение process.exitCode может быть обновлено либо присвоением значения process.exitCode, либо передачей аргумента в process.exit():

$ node -e 'process.exitCode = 9'; echo $?
9
$ node -e 'process.exit(42)'; echo $?
42
$ node -e 'process.exitCode = 9; process.exit(42)'; echo $?
42 copy

Значение также может быть установлено неявно Node.js при возникновении неустранимых ошибок (например, при обнаружении неурегулированного await верхнего уровня). Однако явные манипуляции с кодом завершения всегда имеют приоритет над неявными:

$ node --input-type=module -e 'await new Promise(() => {})'; echo $?
13
$ node --input-type=module -e 'process.exitCode = 9; await new Promise(() => {})'; echo $?
9 copy

process.features.cached_builtins

• Тип: <boolean>

Логическое значение, равное true, если текущая сборка Node.js кэширует встроенные модули.

process.features.debug

• Тип: <boolean>

Логическое значение, равное true, если текущая сборка Node.js является отладочной.

process.features.inspector

• Тип: <boolean>

Логическое значение, равное true, если текущая сборка Node.js включает инспектор.

process.features.ipv6

• Тип: <boolean>

Логическое значение, равное true, если текущая сборка Node.js включает поддержку IPv6.

Поскольку все сборки Node.js поддерживают IPv6, это значение всегда равно true.

process.features.require_module

• Тип: <boolean>

Логическое значение, равное true, если текущая сборка Node.js поддерживает загрузку модулей ECMAScript с помощью require().

process.features.tls

• Тип: <boolean>

Логическое значение, равное true, если текущая сборка Node.js включает поддержку TLS.

process.features.tls_alpn

• Тип: <boolean>

Логическое значение, равное true, если текущая сборка Node.js включает поддержку ALPN в TLS.

В Node.js 11.0.0 и более поздних версиях зависимости OpenSSL безусловно поддерживают ALPN. Поэтому это значение идентично значению process.features.tls.

process.features.tls_ocsp

• Тип: <boolean>

Логическое значение, равное true, если текущая сборка Node.js включает поддержку OCSP в TLS.

В Node.js 11.0.0 и более поздних версиях зависимости OpenSSL безусловно поддерживают OCSP. Поэтому это значение идентично значению process.features.tls.

process.features.tls_sni

• Тип: <boolean>

Логическое значение, равное true, если текущая сборка Node.js включает поддержку SNI в TLS.

В Node.js 11.0.0 и более поздних версиях зависимости OpenSSL безусловно поддерживают SNI. Поэтому это значение идентично значению process.features.tls.

process.features.typescript

• Тип: <boolean> | <string>

Значение, которое по умолчанию равно "strip", равно "transform", если Node.js запущен с --experimental-transform-types, и false, если Node.js запущен с --no-strip-types.

process.features.uv

• Тип: <boolean>

Логическое значение, равное true, если текущая сборка Node.js включает поддержку libuv.

Поскольку невозможно собрать Node.js без libuv, это значение всегда равно true.

process.finalization.register(ref, callback)

• ref <Object> | <Function> Ссылка на отслеживаемый ресурс.
• callback <Function> Функция обратного вызова, вызываемая при финализации ресурса.
  • ref <Object> | <Function> Ссылка на отслеживаемый ресурс.
  • event <string> Событие, вызвавшее финализацию. По умолчанию 'exit'.

Эта функция регистрирует колбэк, который будет вызван, когда процесс сгенерирует событие exit, если объект ref не был собран сборщиком мусора. Если объект ref был собран сборщиком мусора до того, как сгенерировано событие exit, колбэк будет удален из реестра финализации и не будет вызван при завершении процесса.

Внутри колбэка можно освободить ресурсы, выделенные объектом ref. Обратите внимание, что все ограничения, применяемые к событию beforeExit, также применяются к функции callback; это означает, что существует вероятность того, что колбэк не будет вызван при особых обстоятельствах.

Идея этой функции заключается в том, чтобы помочь освободить ресурсы, когда процесс начинает завершаться, но при этом позволить объекту быть собранным сборщиком мусора, если он больше не используется.

Например: вы можете зарегистрировать объект, содержащий буфер; вы хотите убедиться, что этот буфер будет освобожден при завершении процесса, но если объект собирается сборщиком мусора до завершения процесса, освобождать буфер больше не требуется, поэтому в этом случае мы просто удаляем колбэк из реестра финализации.

const { finalization } = require('node:process');

// Please make sure that the function passed to finalization.register()
// does not create a closure around unnecessary objects.
function onFinalize(obj, event) {
  // You can do whatever you want with the object
  obj.dispose();
}

function setup() {
  // This object can be safely garbage collected,
  // and the resulting shutdown function will not be called.
  // There are no leaks.
  const myDisposableObject = {
    dispose() {
      // Free your resources synchronously
    },
  };

  finalization.register(myDisposableObject, onFinalize);
}

setup();

import { finalization } from 'node:process';

// Please make sure that the function passed to finalization.register()
// does not create a closure around unnecessary objects.
function onFinalize(obj, event) {
  // You can do whatever you want with the object
  obj.dispose();
}

function setup() {
  // This object can be safely garbage collected,
  // and the resulting shutdown function will not be called.
  // There are no leaks.
  const myDisposableObject = {
    dispose() {
      // Free your resources synchronously
    },
  };

  finalization.register(myDisposableObject, onFinalize);
}

setup();

Приведенный выше код опирается на следующие предположения:

• стрелочные функции не используются
• обычные функции рекомендуется размещать в глобальном контексте (root)

Обычные функции могут ссылаться на контекст, в котором существует obj, делая obj недоступным для сборщика мусора.

Стрелочные функции удерживают предыдущий контекст. Рассмотрим, например:

class Test {
  constructor() {
    finalization.register(this, (ref) => ref.dispose());

    // Even something like this is highly discouraged
    // finalization.register(this, () => this.dispose());
  }
  dispose() {}
} copy

Крайне маловероятно (но не невозможно), что этот объект будет собран сборщиком мусора, но если этого не произойдет, dispose будет вызван при вызове process.exit.

Будьте осторожны и избегайте использования этой функции для освобождения критически важных ресурсов, поскольку нет гарантии, что колбэк будет вызван при любых обстоятельствах.

process.finalization.registerBeforeExit(ref, callback)

• ref <Object> | <Function> Ссылка на отслеживаемый ресурс.
• callback <Function> Функция обратного вызова, вызываемая при финализации ресурса.
  • ref <Object> | <Function> Ссылка на отслеживаемый ресурс.
  • event <string> Событие, вызвавшее финализацию. По умолчанию 'beforeExit'.

Эта функция работает точно так же, как register, за исключением того, что колбэк будет вызван, когда процесс сгенерирует событие beforeExit, если объект ref не был собран сборщиком мусора.

Обратите внимание, что все ограничения, применяемые к событию beforeExit, также применяются к функции callback; это означает, что существует вероятность того, что колбэк не будет вызван при особых обстоятельствах.

process.finalization.unregister(ref)

• ref <Object> | <Function> Ссылка на ресурс, который был зарегистрирован ранее.

Эта функция удаляет регистрацию объекта из реестра финализации, поэтому колбэк больше вызываться не будет.

const { finalization } = require('node:process');

// Please make sure that the function passed to finalization.register()
// does not create a closure around unnecessary objects.
function onFinalize(obj, event) {
  // You can do whatever you want with the object
  obj.dispose();
}

function setup() {
  // This object can be safely garbage collected,
  // and the resulting shutdown function will not be called.
  // There are no leaks.
  const myDisposableObject = {
    dispose() {
      // Free your resources synchronously
    },
  };

  finalization.register(myDisposableObject, onFinalize);

  // Do something

  myDisposableObject.dispose();
  finalization.unregister(myDisposableObject);
}

setup();

import { finalization } from 'node:process';

// Please make sure that the function passed to finalization.register()
// does not create a closure around unnecessary objects.
function onFinalize(obj, event) {
  // You can do whatever you want with the object
  obj.dispose();
}

function setup() {
  // This object can be safely garbage collected,
  // and the resulting shutdown function will not be called.
  // There are no leaks.
  const myDisposableObject = {
    dispose() {
      // Free your resources synchronously
    },
  };

  // Please make sure that the function passed to finalization.register()
  // does not create a closure around unnecessary objects.
  function onFinalize(obj, event) {
    // You can do whatever you want with the object
    obj.dispose();
  }

  finalization.register(myDisposableObject, onFinalize);

  // Do something

  myDisposableObject.dispose();
  finalization.unregister(myDisposableObject);
}

setup();

process.getActiveResourcesInfo()

• Возвращает: <string[]>

Метод process.getActiveResourcesInfo() возвращает массив строк, содержащий типы активных ресурсов, которые в настоящее время поддерживают работу цикла событий.

import { getActiveResourcesInfo } from 'node:process';
import { setTimeout } from 'node:timers';

console.log('Before:', getActiveResourcesInfo());
setTimeout(() => {}, 1000);
console.log('After:', getActiveResourcesInfo());
// Prints:
//   Before: [ 'CloseReq', 'TTYWrap', 'TTYWrap', 'TTYWrap' ]
//   After: [ 'CloseReq', 'TTYWrap', 'TTYWrap', 'TTYWrap', 'Timeout' ]

const { getActiveResourcesInfo } = require('node:process');
const { setTimeout } = require('node:timers');

console.log('Before:', getActiveResourcesInfo());
setTimeout(() => {}, 1000);
console.log('After:', getActiveResourcesInfo());
// Prints:
//   Before: [ 'TTYWrap', 'TTYWrap', 'TTYWrap' ]
//   After: [ 'TTYWrap', 'TTYWrap', 'TTYWrap', 'Timeout' ]

process.getBuiltinModule(id)

• id <string> Идентификатор запрашиваемого встроенного модуля.
• Возвращает: <Object> | <undefined>

process.getBuiltinModule(id) предоставляет способ загрузки встроенных модулей с помощью глобально доступной функции. Модули ES, которым необходимо поддерживать другие среды, могут использовать ее для условной загрузки встроенного модуля Node.js при запуске в Node.js без необходимости обрабатывать ошибку разрешения модулей, которая может возникнуть при вызове import в среде, отличной от Node.js, или использовать динамический import(), который либо превращает модуль в асинхронный, либо превращает синхронный API в асинхронный.

if (globalThis.process?.getBuiltinModule) {
  // Run in Node.js, use the Node.js fs module.
  const fs = globalThis.process.getBuiltinModule('fs');
  // If `require()` is needed to load user-modules, use createRequire()
  const module = globalThis.process.getBuiltinModule('module');
  const require = module.createRequire(import.meta.url);
  const foo = require('foo');
} copy

Если id указывает встроенный модуль, доступный в текущем процессе Node.js, метод process.getBuiltinModule(id) возвращает соответствующий встроенный модуль. Если id не соответствует ни одному встроенному модулю, возвращается undefined.

process.getBuiltinModule(id) принимает идентификаторы встроенных модулей, которые распознаются module.isBuiltin(id). Некоторые встроенные модули должны загружаться с префиксом node:, см. раздел встроенные модули с обязательным префиксом node:. Ссылки, возвращаемые process.getBuiltinModule(id), всегда указывают на встроенный модуль, соответствующий id, даже если пользователи изменяют require.cache так, что require(id) возвращает что-то другое.

process.getegid()

Метод process.getegid() возвращает числовой эффективный идентификатор группы процесса Node.js. (См. getegid(2).)

import process from 'node:process';

if (process.getegid) {
  console.log(`Current gid: ${process.getegid()}`);
}

const process = require('node:process');

if (process.getegid) {
  console.log(`Current gid: ${process.getegid()}`);
}

Эта функция доступна только на платформах POSIX (т. е. не в Windows или Android).

process.geteuid()

• Возвращает: <Object>

Метод process.geteuid() возвращает числовой эффективный идентификатор пользователя процесса. (См. geteuid(2).)

import process from 'node:process';

if (process.geteuid) {
  console.log(`Current uid: ${process.geteuid()}`);
}

const process = require('node:process');

if (process.geteuid) {
  console.log(`Current uid: ${process.geteuid()}`);
}

Эта функция доступна только на платформах POSIX (т. е. не в Windows или Android).

process.getgid()

• Возвращает: <Object>

Метод process.getgid() возвращает числовой идентификатор группы процесса. (См. getgid(2).)

import process from 'node:process';

if (process.getgid) {
  console.log(`Current gid: ${process.getgid()}`);
}

const process = require('node:process');

if (process.getgid) {
  console.log(`Current gid: ${process.getgid()}`);
}

Эта функция доступна только на платформах POSIX (т. е. не в Windows или Android).

process.getgroups()

• Возвращает: <integer[]>

Метод process.getgroups() возвращает массив с дополнительными идентификаторами групп. POSIX оставляет неопределенным, включен ли эффективный идентификатор группы, но Node.js гарантирует, что он включен всегда.

import process from 'node:process';

if (process.getgroups) {
  console.log(process.getgroups()); // [ 16, 21, 297 ]
}

const process = require('node:process');

if (process.getgroups) {
  console.log(process.getgroups()); // [ 16, 21, 297 ]
}

Эта функция доступна только на платформах POSIX (т. е. не в Windows или Android).

process.getuid()

• Возвращает: <integer>

Метод process.getuid() возвращает числовой идентификатор пользователя процесса. (См. getuid(2).)

import process from 'node:process';

if (process.getuid) {
  console.log(`Current uid: ${process.getuid()}`);
}

const process = require('node:process');

if (process.getuid) {
  console.log(`Current uid: ${process.getuid()}`);
}

Эта функция недоступна в Windows.

process.hasUncaughtExceptionCaptureCallback()

• Возвращает: <boolean>

Указывает, был ли установлен колбэк с помощью process.setUncaughtExceptionCaptureCallback().

process.hrtime([time])

• time <integer[]> Результат предыдущего вызова process.hrtime()
• Возвращает: <integer[]>

Это устаревшая версия метода process.hrtime.bigint(), появившаяся до того, как в JavaScript был представлен bigint.

Метод process.hrtime() возвращает текущее реальное время высокого разрешения в виде кортежа [seconds, nanoseconds] Array, где nanoseconds — это оставшаяся часть реального времени, которая не может быть представлена с точностью до секунды.

time — необязательный параметр, который должен быть результатом предыдущего вызова process.hrtime() для вычисления разницы с текущим временем. Если переданный параметр не является кортежем Array, будет выброшено исключение TypeError. Передача пользовательского массива вместо результата предыдущего вызова process.hrtime() приведет к неопределенному поведению.

Эти временные значения рассчитываются относительно произвольного момента времени в прошлом, не связаны со временем суток и поэтому не подвержены смещению системных часов. Основное применение — измерение производительности между интервалами:

import { hrtime } from 'node:process';

const NS_PER_SEC = 1e9;
const time = hrtime();
// [ 1800216, 25 ]

setTimeout(() => {
  const diff = hrtime(time);
  // [ 1, 552 ]

  console.log(`Benchmark took ${diff[0] * NS_PER_SEC + diff[1]} nanoseconds`);
  // Benchmark took 1000000552 nanoseconds
}, 1000);

const { hrtime } = require('node:process');

const NS_PER_SEC = 1e9;
const time = hrtime();
// [ 1800216, 25 ]

setTimeout(() => {
  const diff = hrtime(time);
  // [ 1, 552 ]

  console.log(`Benchmark took ${diff[0] * NS_PER_SEC + diff[1]} nanoseconds`);
  // Benchmark took 1000000552 nanoseconds
}, 1000);

process.hrtime.bigint()

• Возвращает: <bigint>

Версия метода process.hrtime(), возвращающая текущее реальное время высокого разрешения в наносекундах в виде bigint (bigint).

В отличие от process.hrtime(), этот метод не поддерживает дополнительный аргумент time, так как разницу можно вычислить напрямую простым вычитанием двух bigint.

import { hrtime } from 'node:process';

const start = hrtime.bigint();
// 191051479007711n

setTimeout(() => {
  const end = hrtime.bigint();
  // 191052633396993n

  console.log(`Benchmark took ${end - start} nanoseconds`);
  // Benchmark took 1154389282 nanoseconds
}, 1000);

const { hrtime } = require('node:process');

const start = hrtime.bigint();
// 191051479007711n

setTimeout(() => {
  const end = hrtime.bigint();
  // 191052633396993n

  console.log(`Benchmark took ${end - start} nanoseconds`);
  // Benchmark took 1154389282 nanoseconds
}, 1000);

process.initgroups(user, extraGroup)

• user <string> | <number> Имя пользователя или числовой идентификатор.
• extraGroup <string> | <number> Имя группы или числовой идентификатор.

Метод process.initgroups() считывает файл /etc/group и инициализирует список доступа к группам, используя все группы, членом которых является пользователь. Это привилегированная операция, требующая, чтобы процесс Node.js либо имел доступ root, либо привилегию CAP_SETGID.

Будьте осторожны при сбросе привилегий:

import { getgroups, initgroups, setgid } from 'node:process';

console.log(getgroups());         // [ 0 ]
initgroups('nodeuser', 1000);     // switch user
console.log(getgroups());         // [ 27, 30, 46, 1000, 0 ]
setgid(1000);                     // drop root gid
console.log(getgroups());         // [ 27, 30, 46, 1000 ]

const { getgroups, initgroups, setgid } = require('node:process');

console.log(getgroups());         // [ 0 ]
initgroups('nodeuser', 1000);     // switch user
console.log(getgroups());         // [ 27, 30, 46, 1000, 0 ]
setgid(1000);                     // drop root gid
console.log(getgroups());         // [ 27, 30, 46, 1000 ]

Эта функция доступна только на платформах POSIX (т. е. не в Windows или Android). Эта возможность недоступна в потоках Worker.

process.kill(pid[, signal])

• pid <number> Идентификатор процесса (PID)
• signal <string> | <number> Отправляемый сигнал в виде строки или числа. По умолчанию: 'SIGTERM'.

Метод process.kill() отправляет signal процессу, определяемому pid.

Имена сигналов представляют собой строки, такие как 'SIGINT' или 'SIGHUP'. Дополнительную информацию см. в разделе События сигналов и на странице kill(2).

Этот метод выдаст ошибку, если целевой pid не существует. В качестве особого случая сигнал 0 можно использовать для проверки существования процесса. На платформах Windows возникнет ошибка, если pid используется для завершения группы процессов.

Хотя эта функция и называется process.kill(), на самом деле она просто отправляет сигнал, как и системный вызов kill. Отправленный сигнал может выполнять действие, отличное от завершения целевого процесса.

import process, { kill } from 'node:process';

process.on('SIGHUP', () => {
  console.log('Got SIGHUP signal.');
});

setTimeout(() => {
  console.log('Exiting.');
  process.exit(0);
}, 100);

kill(process.pid, 'SIGHUP');

const process = require('node:process');

process.on('SIGHUP', () => {
  console.log('Got SIGHUP signal.');
});

setTimeout(() => {
  console.log('Exiting.');
  process.exit(0);
}, 100);

process.kill(process.pid, 'SIGHUP');

При получении SIGUSR1 процессом Node.js, Node.js запустит отладчик. См. События сигналов.

process.loadEnvFile(path)

• path <string> | <URL> | <Buffer> | <undefined>. По умолчанию: './.env'

Загружает файл .env в process.env. Использование NODE_OPTIONS в файле .env не окажет никакого влияния на Node.js.

const { loadEnvFile } = require('node:process');
loadEnvFile();

import { loadEnvFile } from 'node:process';
loadEnvFile();

process.mainModule

• Тип: <Object>

Свойство process.mainModule предоставляет альтернативный способ получения require.main. Разница заключается в том, что при изменении основного модуля во время выполнения require.main может по-прежнему ссылаться на исходный основной модуль в модулях, которые были импортированы до того, как произошло изменение. Как правило, можно с уверенностью считать, что оба свойства ссылаются на один и тот же модуль.

Как и в случае с require.main, значение process.mainModule будет undefined, если точка входа (скрипт) отсутствует.

process.memoryUsage()

• Возвращает: <Object>
  • rss <integer>
  • heapTotal <integer>
  • heapUsed <integer>
  • external <integer>
  • arrayBuffers <integer>

Возвращает объект, описывающий использование памяти процессом Node.js, измеренное в байтах.

import { memoryUsage } from 'node:process';

console.log(memoryUsage());
// Prints:
// {
//  rss: 4935680,
//  heapTotal: 1826816,
//  heapUsed: 650472,
//  external: 49879,
//  arrayBuffers: 9386
// }

const { memoryUsage } = require('node:process');

console.log(memoryUsage());
// Prints:
// {
//  rss: 4935680,
//  heapTotal: 1826816,
//  heapUsed: 650472,
//  external: 49879,
//  arrayBuffers: 9386
// }

• heapTotal и heapUsed относятся к использованию памяти V8.
• external относится к использованию памяти C++ объектов, привязанных к объектам JavaScript, управляемым V8.
• rss, Resident Set Size (размер резидентного набора), — это объем пространства, занимаемый в оперативной памяти (являющийся подмножеством общей выделенной памяти) для процесса, включая весь C++ и JavaScript код и объекты.
• arrayBuffers относится к памяти, выделенной для ArrayBuffer и SharedArrayBuffer, включая все Buffer в Node.js. Это также включено в значение external. Если Node.js используется в качестве встроенной библиотеки, это значение может быть равным 0, поскольку в этом случае выделение памяти для ArrayBuffer может не отслеживаться.

При использовании потоков Worker значение rss будет действительным для всего процесса, тогда как остальные поля будут относиться только к текущему потоку.

Метод process.memoryUsage() выполняет итерацию по каждой странице для сбора информации об использовании памяти, что может работать медленно в зависимости от распределения памяти программой.

process.memoryUsage.rss()

• Возвращает: <integer>

Метод process.memoryUsage.rss() возвращает целое число, представляющее размер резидентного набора (RSS) в байтах.

Размер резидентного набора (Resident Set Size) — это объем пространства, занимаемый в оперативной памяти (являющийся подмножеством общей выделенной памяти) для процесса, включая весь C++ и JavaScript код и объекты.

Это то же самое значение, что и свойство rss, предоставляемое process.memoryUsage(), но метод process.memoryUsage.rss() работает быстрее.

import { memoryUsage } from 'node:process';

console.log(memoryUsage.rss());
// 35655680

const { memoryUsage } = require('node:process');

console.log(memoryUsage.rss());
// 35655680

process.nextTick(callback[, ...args])

• callback <Function>
• ...args <any> Дополнительные аргументы, передаваемые при вызове callback

process.nextTick() добавляет callback в «очередь следующего тика» (next tick queue). Эта очередь полностью очищается после завершения текущей операции в стеке JavaScript и до того, как цикл событий продолжит работу. При рекурсивном вызове process.nextTick() возможно создание бесконечного цикла. Дополнительную информацию см. в руководстве по циклу событий.

import { nextTick } from 'node:process';

console.log('start');
nextTick(() => {
  console.log('nextTick callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// nextTick callback

const { nextTick } = require('node:process');

console.log('start');
nextTick(() => {
  console.log('nextTick callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// nextTick callback

Это важно при разработке API, чтобы дать пользователям возможность назначать обработчики событий после создания объекта, но до выполнения какого-либо ввода-вывода:

import { nextTick } from 'node:process';

function MyThing(options) {
  this.setupOptions(options);

  nextTick(() => {
    this.startDoingStuff();
  });
}

const thing = new MyThing();
thing.getReadyForStuff();

// thing.startDoingStuff() gets called now, not before.

const { nextTick } = require('node:process');

function MyThing(options) {
  this.setupOptions(options);

  nextTick(() => {
    this.startDoingStuff();
  });
}

const thing = new MyThing();
thing.getReadyForStuff();

// thing.startDoingStuff() gets called now, not before.

Очень важно, чтобы API были либо на 100% синхронными, либо на 100% асинхронными. Рассмотрим этот пример:

// WARNING!  DO NOT USE!  BAD UNSAFE HAZARD!
function maybeSync(arg, cb) {
  if (arg) {
    cb();
    return;
  }

  fs.stat('file', cb);
} copy

Этот API опасен, поскольку в следующем случае:

const maybeTrue = Math.random() > 0.5;

maybeSync(maybeTrue, () => {
  foo();
});

bar(); copy

Неясно, что будет вызвано раньше: foo() или bar().

Следующий подход гораздо лучше:

import { nextTick } from 'node:process';

function definitelyAsync(arg, cb) {
  if (arg) {
    nextTick(cb);
    return;
  }

  fs.stat('file', cb);
}

const { nextTick } = require('node:process');

function definitelyAsync(arg, cb) {
  if (arg) {
    nextTick(cb);
    return;
  }

  fs.stat('file', cb);
}

import { nextTick } from 'node:process';

Promise.resolve().then(() => console.log('resolve'));
queueMicrotask(() => console.log('microtask'));
nextTick(() => console.log('nextTick'));
// Output:
// resolve
// microtask
// nextTick

const { nextTick } = require('node:process');

Promise.resolve().then(() => console.log('resolve'));
queueMicrotask(() => console.log('microtask'));
nextTick(() => console.log('nextTick'));
// Output:
// nextTick
// resolve
// microtask

console.log('start');
queueMicrotask(() => {
  console.log('microtask callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// microtask callback copy

function deferred(a, b) {
  console.log('microtask', a + b);
}

console.log('start');
queueMicrotask(deferred.bind(undefined, 1, 2));
console.log('scheduled');
// Output:
// start
// scheduled
// microtask 3 copy

process.noDeprecation

• Тип: <boolean>

Свойство process.noDeprecation указывает, установлен ли флаг --no-deprecation для текущего процесса Node.js. Дополнительную информацию о поведении этого флага см. в документации к событию 'warning' и методу emitWarning().

process.permission

• Тип: <Object>

Этот API доступен через флаг --permission.

process.permission представляет собой объект, методы которого используются для управления разрешениями текущего процесса. Дополнительная документация доступна в разделе Модель разрешений (Permission Model).

// Check if the process has permission to read the README file
process.permission.has('fs.read', './README.md');
// Check if the process has read permission operations
process.permission.has('fs.read'); copy

process.pid

• Тип: <integer>

Свойство process.pid возвращает PID процесса.

import { pid } from 'node:process';

console.log(`This process is pid ${pid}`);

const { pid } = require('node:process');

console.log(`This process is pid ${pid}`);

process.platform

• Тип: <string>

Свойство process.platform возвращает строку, идентифицирующую платформу операционной системы, для которой был скомпилирован бинарный файл Node.js.

В настоящее время возможными значениями являются:

• 'aix'
• 'darwin'
• 'freebsd'
• 'linux'
• 'openbsd'
• 'sunos'
• 'win32'

import { platform } from 'node:process';

console.log(`This platform is ${platform}`);

const { platform } = require('node:process');

console.log(`This platform is ${platform}`);

Значение 'android' также может возвращаться, если Node.js собран в операционной системе Android. Однако поддержка Android в Node.js является экспериментальной.

process.ppid

• Тип: <integer>

Свойство process.ppid возвращает PID родителя текущего процесса.

import { ppid } from 'node:process';

console.log(`The parent process is pid ${ppid}`);

const { ppid } = require('node:process');

console.log(`The parent process is pid ${ppid}`);

process.ref(maybeRefable)

• maybeRefable <any> Объект, который может поддерживать ссылку («refable»).

Объект является «refable», если он реализует протокол Node.js «Refable protocol». В частности, это означает, что объект реализует методы Symbol.for('nodejs.ref') и Symbol.for('nodejs.unref'). Объекты с активной ссылкой («ref'd») будут поддерживать цикл событий Node.js активным, тогда как объекты со снятой ссылкой («unref'd») — нет. Исторически это реализовывалось с помощью методов ref() и unref() непосредственно в объектах. Однако этот шаблон признается устаревшим в пользу протокола «Refable protocol», чтобы лучше поддерживать типы Web Platform API, чьи API нельзя изменить для добавления методов ref() и unref(), но которым всё равно необходимо поддерживать такое поведение.

process.release

• Тип: <Object>

Свойство process.release возвращает Object, содержащий метаданные, относящиеся к текущему релизу, включая URL-адреса архива с исходным кодом и архива, содержащего только заголовки.

process.release содержит следующие свойства:

• name <string> Значение, которое всегда будет равно 'node'.
• sourceUrl <string> абсолютный URL-адрес, указывающий на файл .tar.gz, содержащий исходный код текущего релиза.
• headersUrl<string> абсолютный URL-адрес, указывающий на файл .tar.gz, содержащий только исходные файлы заголовков для текущего релиза. Этот файл значительно меньше полного файла исходного кода и может использоваться для компиляции нативных аддонов Node.js.
• libUrl <string> | <undefined> абсолютный URL-адрес, указывающий на файл node.lib, соответствующий архитектуре и версии текущего релиза. Этот файл используется для компиляции нативных аддонов Node.js. Это свойство присутствует только в сборках Node.js для Windows и отсутствует на всех остальных платформах.
• lts <string> | <undefined> строковая метка, идентифицирующая метку LTS для этого релиза. Это свойство существует только для LTS-релизов и имеет значение undefined для всех остальных типов релизов, включая релизы Current. Допустимые значения включают кодовые имена релизов LTS (включая те, которые больше не поддерживаются).
  • 'Fermium' для ветки 14.x LTS, начиная с 14.15.0.
  • 'Gallium' для ветки 16.x LTS, начиная с 16.13.0.
  • 'Hydrogen' для ветки 18.x LTS, начиная с 18.12.0. Другие кодовые имена релизов LTS см. в архиве списков изменений Node.js

{
  name: 'node',
  lts: 'Hydrogen',
  sourceUrl: 'https://nodejs.org/download/release/v18.12.0/node-v18.12.0.tar.gz',
  headersUrl: 'https://nodejs.org/download/release/v18.12.0/node-v18.12.0-headers.tar.gz',
  libUrl: 'https://nodejs.org/download/release/v18.12.0/win-x64/node.lib'
} copy

В пользовательских сборках из нерелизных версий дерева исходного кода может присутствовать только свойство name. Наличие дополнительных свойств не гарантируется.

process.report

• Тип: <Object>

process.report — это объект, методы которого используются для создания диагностических отчетов для текущего процесса. Дополнительная документация доступна в документации по отчетам.

import { report } from 'node:process';

console.log(`Reports are compact? ${report.compact}`);

const { report } = require('node:process');

console.log(`Reports are compact? ${report.compact}`);

import { report } from 'node:process';

console.log(`Report directory is ${report.directory}`);

const { report } = require('node:process');

console.log(`Report directory is ${report.directory}`);

import { report } from 'node:process';

console.log(`Report filename is ${report.filename}`);

const { report } = require('node:process');

console.log(`Report filename is ${report.filename}`);

import { report } from 'node:process';
import util from 'node:util';

const data = report.getReport();
console.log(data.header.nodejsVersion);

// Similar to process.report.writeReport()
import fs from 'node:fs';
fs.writeFileSync('my-report.log', util.inspect(data), 'utf8');

const { report } = require('node:process');
const util = require('node:util');

const data = report.getReport();
console.log(data.header.nodejsVersion);

// Similar to process.report.writeReport()
const fs = require('node:fs');
fs.writeFileSync('my-report.log', util.inspect(data), 'utf8');

import { report } from 'node:process';

console.log(`Report on fatal error: ${report.reportOnFatalError}`);

const { report } = require('node:process');

console.log(`Report on fatal error: ${report.reportOnFatalError}`);

import { report } from 'node:process';

console.log(`Report on signal: ${report.reportOnSignal}`);

const { report } = require('node:process');

console.log(`Report on signal: ${report.reportOnSignal}`);

import { report } from 'node:process';

console.log(`Report on exception: ${report.reportOnUncaughtException}`);

const { report } = require('node:process');

console.log(`Report on exception: ${report.reportOnUncaughtException}`);

import { report } from 'node:process';

console.log(`Report signal: ${report.signal}`);

const { report } = require('node:process');

console.log(`Report signal: ${report.signal}`);

import { report } from 'node:process';

report.writeReport();

const { report } = require('node:process');

report.writeReport();

process.resourceUsage()

• Возвращает: <Object> использование ресурсов текущим процессом. Все эти значения получены из вызова uv_getrusage, который возвращает структуру uv_rusage_t.
  • userCPUTime <integer> соответствует ru_utime, вычисленному в микросекундах. Это то же значение, что и у process.cpuUsage().user.
  • systemCPUTime <integer> соответствует ru_stime, вычисленному в микросекундах. Это то же значение, что и у process.cpuUsage().system.
  • maxRSS <integer> соответствует ru_maxrss, представляющему максимальный размер резидентного набора (resident set size), использованного в кибибайтах (1024 байта).
  • sharedMemorySize <integer> соответствует ru_ixrss, но не поддерживается ни на одной платформе.
  • unsharedDataSize <integer> соответствует ru_idrss, но не поддерживается ни на одной платформе.
  • unsharedStackSize <integer> соответствует ru_isrss, но не поддерживается ни на одной платформе.
  • minorPageFault <integer> соответствует ru_minflt, представляющему количество некритических ошибок страниц (minor page faults) для процесса; подробнее см. в этой статье.
  • majorPageFault <integer> соответствует ru_majflt, представляющему количество критических ошибок страниц (major page faults) для процесса; подробнее см. в этой статье. Это поле не поддерживается в Windows.
  • swappedOut <integer> соответствует ru_nswap, но не поддерживается ни на одной платформе.
  • fsRead <integer> соответствует ru_inblock, представляющему количество операций ввода, выполненных файловой системой.
  • fsWrite <integer> соответствует ru_oublock, представляющему количество операций вывода, выполненных файловой системой.
  • ipcSent <integer> соответствует ru_msgsnd, но не поддерживается ни на одной платформе.
  • ipcReceived <integer> соответствует ru_msgrcv, но не поддерживается ни на одной платформе.
  • signalsCount <integer> соответствует ru_nsignals, но не поддерживается ни на одной платформе.
  • voluntaryContextSwitches <integer> соответствует ru_nvcsw, представляющему количество переключений контекста ЦП, произошедших из-за того, что процесс добровольно освободил процессор до истечения кванта времени (обычно в ожидании доступности ресурса). Это поле не поддерживается в Windows.
  • involuntaryContextSwitches <integer> соответствует ru_nivcsw, представляющему количество переключений контекста ЦП, произошедших из-за того, что процесс с более высоким приоритетом стал готовым к выполнению, либо текущий процесс исчерпал свой квант времени. Это поле не поддерживается в Windows.

import { resourceUsage } from 'node:process';

console.log(resourceUsage());
/*
  Will output:
  {
    userCPUTime: 82872,
    systemCPUTime: 4143,
    maxRSS: 33164,
    sharedMemorySize: 0,
    unsharedDataSize: 0,
    unsharedStackSize: 0,
    minorPageFault: 2469,
    majorPageFault: 0,
    swappedOut: 0,
    fsRead: 0,
    fsWrite: 8,
    ipcSent: 0,
    ipcReceived: 0,
    signalsCount: 0,
    voluntaryContextSwitches: 79,
    involuntaryContextSwitches: 1
  }
*/

const { resourceUsage } = require('node:process');

console.log(resourceUsage());
/*
  Will output:
  {
    userCPUTime: 82872,
    systemCPUTime: 4143,
    maxRSS: 33164,
    sharedMemorySize: 0,
    unsharedDataSize: 0,
    unsharedStackSize: 0,
    minorPageFault: 2469,
    majorPageFault: 0,
    swappedOut: 0,
    fsRead: 0,
    fsWrite: 8,
    ipcSent: 0,
    ipcReceived: 0,
    signalsCount: 0,
    voluntaryContextSwitches: 79,
    involuntaryContextSwitches: 1
  }
*/

process.send(message[, sendHandle[, options]][, callback])

• message <Object>
• sendHandle <net.Server> | <net.Socket>
• options <Object> используется для параметризации отправки определенных типов дескрипторов. options поддерживает следующие свойства:
  • keepOpen <boolean> Значение, которое может использоваться при передаче экземпляров net.Socket. Если true, сокет остается открытым в процессе-отправителе. По умолчанию: false.
• callback <Function>
• Возвращает: <boolean>

Если Node.js запущен с IPC-каналом, метод process.send() может использоваться для отправки сообщений родительскому процессу. Сообщения будут получены как событие 'message' в родительском объекте ChildProcess.

Если Node.js не был запущен с каналом IPC, process.send будет равен undefined.

Сообщение проходит сериализацию и синтаксический анализ. Полученное сообщение может отличаться от исходно отправленного.

process.setegid(id)

• id <string> | <number> Имя или идентификатор группы

Метод process.setegid() устанавливает эффективный идентификатор группы процесса. (См. setegid(2).) Параметр id может быть передан как в виде числового идентификатора, так и строки с именем группы. Если указано имя группы, этот метод блокирует выполнение во время разрешения соответствующего числового идентификатора.

import process from 'node:process';

if (process.getegid && process.setegid) {
  console.log(`Current gid: ${process.getegid()}`);
  try {
    process.setegid(501);
    console.log(`New gid: ${process.getegid()}`);
  } catch (err) {
    console.error(`Failed to set gid: ${err}`);
  }
}

const process = require('node:process');

if (process.getegid && process.setegid) {
  console.log(`Current gid: ${process.getegid()}`);
  try {
    process.setegid(501);
    console.log(`New gid: ${process.getegid()}`);
  } catch (err) {
    console.error(`Failed to set gid: ${err}`);
  }
}

Эта функция доступна только на платформах POSIX (т. е. не в Windows или Android). Эта возможность недоступна в потоках Worker.

process.seteuid(id)

• id <string> | <number> Имя пользователя или идентификатор

Метод process.seteuid() устанавливает эффективный идентификатор пользователя процесса. (См. seteuid(2).) Параметр id может быть передан как в виде числового идентификатора, так и строки с именем пользователя. Если указано имя пользователя, метод блокирует выполнение во время разрешения соответствующего числового идентификатора.

import process from 'node:process';

if (process.geteuid && process.seteuid) {
  console.log(`Current uid: ${process.geteuid()}`);
  try {
    process.seteuid(501);
    console.log(`New uid: ${process.geteuid()}`);
  } catch (err) {
    console.error(`Failed to set uid: ${err}`);
  }
}

const process = require('node:process');

if (process.geteuid && process.seteuid) {
  console.log(`Current uid: ${process.geteuid()}`);
  try {
    process.seteuid(501);
    console.log(`New uid: ${process.geteuid()}`);
  } catch (err) {
    console.error(`Failed to set uid: ${err}`);
  }
}

Эта функция доступна только на платформах POSIX (т. е. не в Windows или Android). Эта возможность недоступна в потоках Worker.

process.setgid(id)

• id <string> | <number> Имя или идентификатор группы

Метод process.setgid() устанавливает идентификатор группы процесса. (См. setgid(2).) Параметр id может быть передан как числовой идентификатор или строка с именем группы. Если указано имя группы, этот метод блокирует выполнение во время разрешения соответствующего числового идентификатора.

import process from 'node:process';

if (process.getgid && process.setgid) {
  console.log(`Current gid: ${process.getgid()}`);
  try {
    process.setgid(501);
    console.log(`New gid: ${process.getgid()}`);
  } catch (err) {
    console.error(`Failed to set gid: ${err}`);
  }
}

const process = require('node:process');

if (process.getgid && process.setgid) {
  console.log(`Current gid: ${process.getgid()}`);
  try {
    process.setgid(501);
    console.log(`New gid: ${process.getgid()}`);
  } catch (err) {
    console.error(`Failed to set gid: ${err}`);
  }
}

Эта функция доступна только на платформах POSIX (т. е. не в Windows или Android). Эта возможность недоступна в потоках Worker.

process.setgroups(groups)

• groups <integer[]>

Метод process.setgroups() устанавливает дополнительные идентификаторы групп для процесса Node.js. Это привилегированная операция, которая требует наличия у процесса Node.js прав root или привилегии (capability) CAP_SETGID.

Массив groups может содержать числовые идентификаторы групп, имена групп или и то, и другое.

import process from 'node:process';

if (process.getgroups && process.setgroups) {
  try {
    process.setgroups([501]);
    console.log(process.getgroups()); // new groups
  } catch (err) {
    console.error(`Failed to set groups: ${err}`);
  }
}

const process = require('node:process');

if (process.getgroups && process.setgroups) {
  try {
    process.setgroups([501]);
    console.log(process.getgroups()); // new groups
  } catch (err) {
    console.error(`Failed to set groups: ${err}`);
  }
}

Эта функция доступна только на платформах POSIX (т. е. не в Windows или Android). Эта возможность недоступна в потоках Worker.

process.setuid(id)

• id <integer> | <string>

Метод process.setuid(id) устанавливает идентификатор пользователя процесса. (См. setuid(2).) Параметр id может быть передан как в виде числового идентификатора, так и строки с именем пользователя. Если указано имя пользователя, метод блокирует выполнение во время разрешения соответствующего числового идентификатора.

import process from 'node:process';

if (process.getuid && process.setuid) {
  console.log(`Current uid: ${process.getuid()}`);
  try {
    process.setuid(501);
    console.log(`New uid: ${process.getuid()}`);
  } catch (err) {
    console.error(`Failed to set uid: ${err}`);
  }
}

const process = require('node:process');

if (process.getuid && process.setuid) {
  console.log(`Current uid: ${process.getuid()}`);
  try {
    process.setuid(501);
    console.log(`New uid: ${process.getuid()}`);
  } catch (err) {
    console.error(`Failed to set uid: ${err}`);
  }
}

Эта функция доступна только на платформах POSIX (т. е. не в Windows или Android). Эта возможность недоступна в потоках Worker.

process.setSourceMapsEnabled(val)

• val <boolean>

Эта функция включает или отключает поддержку Source Map для трассировки стека.

Она предоставляет те же возможности, что и запуск процесса Node.js с параметром командной строки --enable-source-maps.

Будут проанализированы и загружены только карты соответствия исходного кода в файлах JavaScript, которые загружаются после включения поддержки Source Map.

Это подразумевает вызов module.setSourceMapsSupport() с параметром { nodeModules: true, generatedCode: true }.

process.setUncaughtExceptionCaptureCallback(fn)

• fn <Function> | <null>

Функция process.setUncaughtExceptionCaptureCallback() устанавливает функцию, которая будет вызвана при возникновении необработанного исключения и получит само значение исключения в качестве первого аргумента.

Если такая функция задана, событие 'uncaughtException' генерироваться не будет. Если из командной строки был передан флаг --abort-on-uncaught-exception или он был установлен с помощью v8.setFlagsFromString(), процесс не завершится аварийно. Действия, настроенные для выполнения при исключениях, такие как генерация отчетов, также будут затронуты.

Для сброса функции перехвата можно использовать process.setUncaughtExceptionCaptureCallback(null). Вызов этого метода с аргументом, отличным от null, при уже установленной другой функции перехвата приведет к выбросу ошибки.

Использование этой функции является взаимоисключающим с использованием устаревшего встроенного модуля domain.

process.sourceMapsEnabled

• Тип: <boolean>

Свойство process.sourceMapsEnabled возвращает, включена ли поддержка Source Map для трассировок стека.

process.stderr

• Тип: <Stream>

Свойство process.stderr возвращает поток, подключенный к stderr (fd 2). Он представляет собой net.Socket (который является дуплексным потоком Duplex), за исключением случаев, когда fd 2 ссылается на файл — в этом случае он является потоком для записи Writable.

process.stderr во многом отличается от других потоков Node.js. Дополнительные сведения см. в разделе Замечания о вводе-выводе процесса.

process.stdin

• Тип: <Stream>

Свойство process.stdin возвращает поток, подключенный к stdin (fd 0). Он представляет собой net.Socket (который является дуплексным потоком Duplex), за исключением случаев, когда fd 0 ссылается на файл — в этом случае он является потоком для чтения Readable.

Подробные сведения о чтении из stdin см. в описании readable.read().

Будучи потоком Duplex, process.stdin также может использоваться в «старом» режиме, совместимом со скриптами, написанными для версий Node.js до v0.10. Дополнительные сведения см. в разделе Совместимость потоков.

В «старом» режиме потоков поток stdin по умолчанию приостановлен, поэтому для чтения из него необходимо вызвать process.stdin.resume(). Обратите внимание, что сам вызов process.stdin.resume() переключит поток в «старый» режим.

process.stdout

• Тип: <Stream>

Свойство process.stdout возвращает поток, подключенный к stdout (fd 1). Это net.Socket (являющийся дуплексным потоком Duplex), если fd 1 не ссылается на файл — в этом случае он является потоком для записи Writable.

Например, чтобы скопировать process.stdin в process.stdout:

import { stdin, stdout } from 'node:process';

stdin.pipe(stdout);

const { stdin, stdout } = require('node:process');

stdin.pipe(stdout);

process.stdout существенно отличается от других потоков Node.js. См. дополнительную информацию в разделе Примечание о вводе-выводе процесса.

$ node -p "Boolean(process.stdin.isTTY)"
true
$ echo "foo" | node -p "Boolean(process.stdin.isTTY)"
false
$ node -p "Boolean(process.stdout.isTTY)"
true
$ node -p "Boolean(process.stdout.isTTY)" | cat
false copy

process.throwDeprecation

• Тип: <boolean>

Начальное значение process.throwDeprecation указывает, установлен ли флаг --throw-deprecation для текущего процесса Node.js. Свойство process.throwDeprecation является изменяемым, поэтому то, приводят ли предупреждения об устаревании к ошибкам, можно изменить во время выполнения. Дополнительную информацию см. в документации по событию 'warning' и методу emitWarning().

$ node --throw-deprecation -p "process.throwDeprecation"
true
$ node -p "process.throwDeprecation"
undefined
$ node
> process.emitWarning('test', 'DeprecationWarning');
undefined
> (node:26598) DeprecationWarning: test
> process.throwDeprecation = true;
true
> process.emitWarning('test', 'DeprecationWarning');
Thrown:
[DeprecationWarning: test] { name: 'DeprecationWarning' } copy

process.threadCpuUsage([previousValue])

• previousValue <Object> Предыдущее возвращаемое значение вызова process.threadCpuUsage()
• Возвращает: <Object>
  • user <integer>
  • system <integer>

Метод process.threadCpuUsage() возвращает время использования процессора (пользовательское и системное) текущим рабочим потоком в виде объекта со свойствами user и system, значения которых выражены в микросекундах (миллионных долях секунды).

Результат предыдущего вызова process.threadCpuUsage() может быть передан в качестве аргумента функции для получения разностного показателя.

process.title

• Тип: <string>

Свойство process.title возвращает текущий заголовок процесса (т. е. возвращает текущее значение ps). Присвоение нового значения свойству process.title изменяет текущее значение ps.

При присвоении нового значения различные платформы налагают разные ограничения на максимальную длину заголовка. Обычно такие ограничения весьма строгие. Например, в Linux и macOS process.title ограничивается размером имени бинарного файла плюс длина аргументов командной строки, поскольку установка process.title перезаписывает память argv процесса. Node.js 0.8 допускал более длинные строки заголовка процесса за счет дополнительной перезаписи памяти environ, однако это было потенциально небезопасно и вносило путаницу в некоторых (достаточно редких) случаях.

Присвоение значения свойству process.title может не привести к точному отображению имени в приложениях диспетчера процессов, таких как «Мониторинг системы» в macOS или «Диспетчер служб Windows».

process.traceDeprecation

• Тип: <boolean>

Свойство process.traceDeprecation указывает, установлен ли флаг --trace-deprecation для текущего процесса Node.js. См. документацию по событию 'warning' и методу emitWarning() для получения дополнительной информации о поведении этого флага.

process.traceProcessWarnings

• <boolean>

Свойство process.traceProcessWarnings указывает, установлен ли флаг --trace-warnings для текущего процесса Node.js. Это свойство позволяет программно управлять трассировкой предупреждений, включая или отключая трассировку стека для предупреждений во время выполнения.

// Enable trace warnings
process.traceProcessWarnings = true;

// Emit a warning with a stack trace
process.emitWarning('Warning with stack trace');

// Disable trace warnings
process.traceProcessWarnings = false; copy

process.umask()

process.umask() возвращает маску создания режимов файлов процесса Node.js. Дочерние процессы наследуют маску от родительского процесса.

process.umask(mask)

• mask <string> | <integer>

process.umask(mask) устанавливает маску создания режимов файлов процесса Node.js. Дочерние процессы наследуют маску от родительского процесса. Возвращает предыдущую маску.

import { umask } from 'node:process';

const newmask = 0o022;
const oldmask = umask(newmask);
console.log(
  `Changed umask from ${oldmask.toString(8)} to ${newmask.toString(8)}`,
);

const { umask } = require('node:process');

const newmask = 0o022;
const oldmask = umask(newmask);
console.log(
  `Changed umask from ${oldmask.toString(8)} to ${newmask.toString(8)}`,
);

В потоках Worker метод process.umask(mask) выбросит исключение.

process.unref(maybeRefable)

• maybeRefable <any> Объект, для которого может быть вызван "unref".

Объект является «разрешающим отвязку» ("unrefable"), если он реализует «протокол Refable» в Node.js. В частности, это означает, что объект реализует методы Symbol.for('nodejs.ref') и Symbol.for('nodejs.unref'). Объекты с активной ссылкой ("ref'd") поддерживают цикл событий Node.js активным, тогда как объекты со снятой ссылкой ("unref'd") — нет. Исторически это реализовывалось с помощью методов ref() и unref() непосредственно на самих объектах. Однако этот шаблон признается устаревающим в пользу «протокола Refable», чтобы лучше поддерживать типы Web Platform API, чьи API нельзя изменять для добавления методов ref() и unref(), но которые по-прежнему должны поддерживать такое поведение.

process.uptime()

• Возвращает: <number>

Метод process.uptime() возвращает количество секунд, в течение которых работает текущий процесс Node.js.

Возвращаемое значение включает доли секунды. Используйте Math.floor() для получения целого числа секунд.

process.version

• Тип: <string>

Свойство process.version содержит строку с версией Node.js.

import { version } from 'node:process';

console.log(`Version: ${version}`);
// Version: v14.8.0

const { version } = require('node:process');

console.log(`Version: ${version}`);
// Version: v14.8.0

Чтобы получить строку версии без префикса v, используйте process.versions.node.

process.versions

• Тип: <Object>

Свойство process.versions возвращает объект, перечисляющий строки версий Node.js и его зависимостей. process.versions.modules указывает текущую версию ABI модуля, которая увеличивается при каждом изменении C++ API. Node.js откажется загружать модули, скомпилированные для другой версии ABI модуля.

import { versions } from 'node:process';

console.log(versions);

const { versions } = require('node:process');

console.log(versions);

Сформирует объект, подобный следующему:

{ node: '26.0.0-pre',
  acorn: '8.15.0',
  ada: '3.4.1',
  amaro: '1.1.5',
  ares: '1.34.6',
  brotli: '1.2.0',
  merve: '1.0.0',
  cldr: '48.0',
  icu: '78.2',
  llhttp: '9.3.0',
  modules: '144',
  napi: '10',
  nbytes: '0.1.1',
  ncrypto: '0.0.1',
  nghttp2: '1.68.0',
  nghttp3: '',
  ngtcp2: '',
  openssl: '3.5.4',
  simdjson: '4.2.4',
  simdutf: '7.3.3',
  sqlite: '3.51.2',
  tz: '2025c',
  undici: '7.18.2',
  unicode: '17.0',
  uv: '1.51.0',
  uvwasi: '0.0.23',
  v8: '14.3.127.18-node.10',
  zlib: '1.3.1-e00f703',
  zstd: '1.5.7' } copy

Коды завершения

Node.js обычно завершает работу с кодом состояния 0, когда больше нет ожидающих асинхронных операций. В других случаях используются следующие коды состояния:

• 1 Неперехваченное критическое исключение (Uncaught Fatal Exception): Произошло необработанное исключение, которое не было обработано доменом или обработчиком события 'uncaughtException'.
• 2: Не используется (зарезервировано Bash для случаев неправильного использования встроенных команд)
• 3 Внутренняя ошибка парсинга JavaScript (Internal JavaScript Parse Error): Исходный код JavaScript, используемый внутри процесса начальной загрузки Node.js, вызвал ошибку синтаксического анализа. Это происходит крайне редко и обычно возможно только во время разработки самой платформы Node.js.
• 4 Сбой выполнения внутреннего JavaScript (Internal JavaScript Evaluation Failure): Исходный код JavaScript, используемый внутри процесса начальной загрузки Node.js, не смог вернуть значение функции при вычислении. Это происходит крайне редко и обычно возможно только во время разработки самой платформы Node.js.
• 5 Критическая ошибка (Fatal Error): Произошла фатальная неустранимая ошибка в V8. Обычно сообщение выводится в stderr с префиксом FATAL ERROR.
• 6 Не являющийся функцией внутренний обработчик исключений (Non-function Internal Exception Handler): Произошло необработанное исключение, но внутренней функции-обработчику критических исключений почему-то было присвоено значение, не являющееся функцией, и она не смогла быть вызвана.
• 7 Сбой во время выполнения внутреннего обработчика исключений (Internal Exception Handler Run-Time Failure): Произошло необработанное исключение, и сама внутренняя функция-обработчик критических исключений вызвала ошибку при попытке его обработать. Это может произойти, например, если обработчик 'uncaughtException' или domain.on('error') вызывает ошибку.
• 8: Не используется. В предыдущих версиях Node.js код завершения 8 иногда указывал на необработанное исключение.
• 9 Недопустимый аргумент (Invalid Argument): Указан неизвестный параметр либо параметр, требующий значения, передан без него.
• 10 Сбой времени выполнения внутреннего JavaScript (Internal JavaScript Run-Time Failure): Исходный код JavaScript, используемый внутри процесса начальной загрузки Node.js, выбросил ошибку при вызове функции начальной загрузки. Это происходит крайне редко и обычно возможно только во время разработки самой платформы Node.js.
• 12 Недопустимый аргумент отладки (Invalid Debug Argument): Были установлены параметры --inspect и/или --inspect-brk, но выбранный номер порта оказался недопустимым или недоступным.
• 13 Неразрешенный await верхнего уровня (Unsettled Top-Level Await): Ключевое слово await было использовано вне функции в коде верхнего уровня, но переданный Promise так и не завершился (never settled).
• 14 Сбой моментального снимка (Snapshot Failure): Node.js был запущен для создания снимка состояния (snapshot) запуска V8, но операция завершилась ошибкой, поскольку определенные требования к состоянию приложения не были выполнены.
• >128 Завершение по сигналу (Signal Exits): Если Node.js получает фатальный сигнал, такой как SIGKILL или SIGHUP, его код завершения будет равен 128 плюс значение кода сигнала. Это стандартная практика POSIX, поскольку коды завершения определяются как 7-битные целые числа, а при завершении по сигналу устанавливается старший бит и сохраняется значение кода сигнала. Например, сигнал SIGABRT имеет значение 6, поэтому ожидаемым кодом завершения будет 128 + 6, то есть 134.