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

Объект 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 dump.

Эта возможность недоступна в потоках 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', 'ppc', '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]. Вторым элементом будет путь к выполняемому файлу JavaScript. Остальными элементами будут любые дополнительные аргументы командной строки.

Например, при наличии следующего скрипта для 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, и поэтому память и другие ресурсы текущего процесса не сохраняются, за исключением файловых дескрипторов стандартного ввода, стандартного вывода и стандартного потока ошибок.

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

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

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

process.exit([code])

• code <integer> | <string> | <null> | <undefined> Код завершения. Для строкового типа разрешены только строки с целыми числами (например, '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> Код завершения. Для строкового типа разрешены только строки с целыми числами (например, '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 при возникновении неустранимых ошибок (например, при обнаружении неразрешенного top-level 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 является отладочной (debug build).

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-experimental-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() возвращает массив с дополнительными идентификаторами групп (supplementary group IDs). Стандарт 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(), использовавшаяся до появления bigint в JavaScript.

Метод 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 либо привилегии (capability) 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> Идентификатор процесса
• 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');

Когда процесс Node.js получает SIGUSR1, 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, включая все Node.js Buffer. Это значение также включено в 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». Эта очередь полностью очищается после завершения текущей операции в стеке 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 — это объект, методы которого используются для управления разрешениями текущего процесса. Дополнительная документация доступна в разделе Модель разрешений.

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

process.release

• Тип: <Object>

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

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, представляющему собой максимальный объём резидентной памяти (RSS) в кибибайтах (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> используется для параметризации отправки определённых типов дескрипторов (handles). 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> Имя или идентификатор (ID) группы

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

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

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

Парситься и загружаться будут только карты исходного кода (source maps) в файлах JavaScript, загруженных после включения поддержки source maps.

Это подразумевает вызов 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.cpuUsage()
• Возвращает: <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 v0.8 допускал более длинные строки заголовка процесса, также перезаписывая память environ, однако это было потенциально небезопасно и приводило к путанице в некоторых (весьма специфических) случаях.

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

process.traceDeprecation

• Тип: <boolean>

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

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)

• maybeUnfefable <any> Объект, который может быть "unref'd".

Объект считается «unrefable», если он реализует «протокол Refable» Node.js. В частности, это означает, что объект реализует методы Symbol.for('nodejs.ref') и Symbol.for('nodejs.unref'). Объекты с «ref'd» поддерживают цикл событий Node.js в активном состоянии, а объекты с «unref'd» — нет. Исторически это реализовывалось с помощью методов ref() и unref() непосредственно у объектов. Однако этот паттерн объявляется устаревшим в пользу «протокола Refable» для лучшей поддержки типов API веб-платформы (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: '23.0.0',
  acorn: '8.11.3',
  ada: '2.7.8',
  ares: '1.28.1',
  base64: '0.5.2',
  brotli: '1.1.0',
  cjs_module_lexer: '1.2.2',
  cldr: '45.0',
  icu: '75.1',
  llhttp: '9.2.1',
  modules: '127',
  napi: '9',
  nghttp2: '1.61.0',
  nghttp3: '0.7.0',
  ngtcp2: '1.3.0',
  openssl: '3.0.13+quic',
  simdjson: '3.8.0',
  simdutf: '5.2.4',
  sqlite: '3.46.0',
  tz: '2024a',
  undici: '6.13.0',
  unicode: '15.1',
  uv: '1.48.0',
  uvwasi: '0.0.20',
  v8: '12.4.254.14-node.11',
  zlib: '1.3.0.1-motley-7d77fb7' } 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 был запущен для создания снимка запуска V8, но произошел сбой из-за несоблюдения определенных требований к состоянию приложения.
• >128 Завершение по сигналу (Signal Exits): если Node.js получает критический сигнал, такой как SIGKILL или SIGHUP, его код выхода будет равен 128 плюс значение кода сигнала. Это стандартная практика POSIX, поскольку коды выхода определены как 7-битные целые числа, а завершение по сигналу устанавливает старший бит и затем содержит значение кода сигнала. Например, сигнал SIGABRT имеет значение 6, поэтому ожидаемый код выхода будет 128 + 6, то есть 134.