process

Если warning имеет тип string, type — это имя, которое следует использовать для типа выдаваемого предупреждения.

Уникальный идентификатор выдаваемого экземпляра предупреждения.

Если warning имеет тип string, ctor — это необязательная функция, используемая для ограничения формируемой трассировки стека.

Дополнительный текст, включаемый в сообщение об ошибке.

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

В отличие от process.hrtime(), этот метод не поддерживает дополнительный аргумент времени, поскольку разницу можно вычислить простым вычитанием двух значений 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);

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

Относится к использованию памяти V8.

Относится к использованию памяти V8.

Относится к памяти, выделенной для ArrayBuffer и SharedArrayBuffer, включая все буферы Node.js. Эта память также учитывается в значении external. При использовании Node.js в качестве встроенной библиотеки это значение может быть 0, поскольку в этом случае выделение памяти для ArrayBuffer может не отслеживаться.

Метод возвращает целое число, представляющее Resident Set Size (RSS) в байтах.

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

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

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

stdin.pipe(stdout);

process.stdout существенно отличается от других потоков Node.js. Дополнительные сведения см. в разделе note on process I/O.

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

process.stderr существенно отличается от других потоков Node.js. Дополнительные сведения см. в разделе note on process I/O.

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

Сведения о чтении из stdin см. в разделе readable.read().

Как поток Duplex, process.stdin также можно использовать в «старом» режиме, совместимом со скриптами, написанными для Node.js до версии v0.10. Дополнительные сведения см. в разделе Stream compatibility.

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

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

Например, предположим, что для process-args.js используется следующий скрипт:

import { argv } from 'node:process';

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

Запуск процесса Node.js командой:

node process-args.js one two=three four

Выведет:

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

Свойство 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'

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

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

В результате получается process.execArgv:

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

А process.argv:

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

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

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

'/usr/local/bin/node'

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

import process from 'node:process';

process.debugPort = 5858;

Свойство 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'
}

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

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

А следующий сработает:

import { env } from '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'

Чтобы удалить свойство из process.env, используйте delete.

import { env } from '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

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

Число, которое будет кодом завершения процесса, если процесс завершится штатно или будет завершен с помощью exit без указания кода.

Указание кода завершения переопределит все предыдущие значения process.exitCode.

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

import process from 'node:process';

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

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

Метод 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.log(`Failed to set gid: ${err}`);
  }
}

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

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

import process from 'node:process';

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

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

Метод 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.log(`Failed to set uid: ${err}`);
  }
}

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

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

import process from 'node:process';

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

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

Метод 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.log(`Failed to set uid: ${err}`);
  }
}

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

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

import process from 'node:process';

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

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

Метод 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.log(`Failed to set gid: ${err}`);
  }
}

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

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

import process from 'node:process';

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

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

Метод process.setgroups() задает дополнительные идентификаторы групп для процесса Node.js. Это привилегированная операция, для выполнения которой процесс Node.js должен иметь root или возможность 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.log(`Failed to set groups: ${err}`);
  }
}

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

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

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

import { version } from 'node:process';

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

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

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

import { versions } from 'node:process';

console.log(versions);

Будет создан объект, похожий на следующий:

{ node: '20.2.0',
  acorn: '8.8.2',
  ada: '2.4.0',
  ares: '1.19.0',
  base64: '0.5.0',
  brotli: '1.0.9',
  cjs_module_lexer: '1.2.2',
  cldr: '43.0',
  icu: '73.1',
  llhttp: '8.1.0',
  modules: '115',
  napi: '8',
  nghttp2: '1.52.0',
  nghttp3: '0.7.0',
  ngtcp2: '0.8.1',
  openssl: '3.0.8+quic',
  simdutf: '3.2.9',
  tz: '2023c',
  undici: '5.22.0',
  unicode: '15.0',
  uv: '1.44.2',
  uvwasi: '0.0.16',
  v8: '11.3.244.8-node.9',
  zlib: '1.2.13' }

Свойство 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',
     strict_aliasing: 'true',
     target_arch: 'x64',
     v8_use_snapshot: 1
   }
}

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

import { pid } from 'node:process';

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

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

import { ppid } from 'node:process';

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

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

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

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

Архитектура ЦП операционной системы, для которой был скомпилирован двоичный файл 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}`);

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

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

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

import { platform } from 'node:process';

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

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

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

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

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

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

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

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

{
  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'
}

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

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

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

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

Свойство 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
  // ...
});

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

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

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

Начальное значение 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' }

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

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

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

Метод 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}`);
}

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

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

import { cwd } from 'node:process';

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

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

Аргумент flags — это целое число, позволяющее указать поведение dlopen. Подробности см. в документации [os.constants.dlopen](https://nodejs.org/docs/latest-v22.x/api/os.html#dlopen-constants).

Важное требование при вызове 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();

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

import { emitWarning } from '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!

import { emitWarning } from 'node:process';

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

In each of the previous examples, an `Error` object is generated internally by `process.emitWarning()` and passed through to the `'warning'` handler.

```js
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'
});

Если в качестве объекта Error передан warning, он без изменений будет передан обработчику события '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!

Если warning — не строка и не объект Error, будет выброшена ошибка TypeError.

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

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

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

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

Чтобы завершить работу с кодом «ошибки»:

import { exit } from '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);
}

Проблема заключается в том, что операции записи в 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;
}

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

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

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

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

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

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

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

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

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

Эта функция не может использоваться одновременно с устаревшим встроенным модулем domain.

Показывает, задан ли обратный вызов с помощью setUncaughtExceptionCaptureCallback.

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

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

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

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

Имена сигналов представляют собой строки, например 'SIGINT' или 'SIGHUP'. Дополнительные сведения см. в Signal Events и 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');

Когда процесс Node.js получает SIGUSR1, Node.js запускает отладчик. См. Signal Events.

Загружает конфигурацию окружения из файла .env в process.env. Если файл не найден, будет выброшена ошибка.

Чтобы загрузить определенный файл .env, указав его путь, используйте следующий код:

import { loadEnvFile } from 'node:process';

loadEnvFile('./development.env')

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

Дополнительные сведения см. в uv_get_constrained_memory.

Получает объем свободной памяти, которая еще доступна процессу (в байтах). Дополнительные сведения см. в uv_get_available_memory.

Метод 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 }

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

import { nextTick } from '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.

Крайне важно, чтобы API были либо полностью синхронными, либо полностью асинхронными. Рассмотрим следующий пример:

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

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

Этот API небезопасен в следующем случае:

const maybeTrue = Math.random() > 0.5;

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

bar();

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

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

import { nextTick } from 'node:process';

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

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

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

Можно задать только вне рабочего потока.

Метод process.uptime() возвращает время работы текущего процесса Node.js в секундах.

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

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

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

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

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

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

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

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

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

Можно использовать для изменения часового пояса по умолчанию во время выполнения

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверяет, имеет ли процесс доступ к указанной области и ссылке. Если ссылка не указана, предполагается глобальная область; например, process.permission.has('fs.read') проверит, есть ли у процесса все разрешения на чтение файловой системы.

Значение ссылки зависит от указанной области. Например, для области «Файловая система» ссылка обозначает файлы и папки.

Доступны следующие области:

• fs — вся файловая система
• fs.read — операции чтения файловой системы
• fs.write — операции записи в файловую систему
• child — операции запуска дочерних процессов
• worker — операция запуска потока worker

// 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');

Создавать отчёты в компактном формате — в виде однострочного JSON, который системам обработки журналов проще обрабатывать, чем многострочный формат по умолчанию, предназначенный для чтения людьми.

Каталог, в который записывается отчёт. По умолчанию используется пустая строка, означающая, что отчёты записываются в текущий рабочий каталог процесса Node.js.

Имя файла, в который записывается отчёт. Если задана пустая строка, имя выходного файла будет состоять из временной метки, PID и порядкового номера. По умолчанию используется пустая строка.

Если значение равно true, диагностический отчёт создаётся при критических ошибках, например при нехватке памяти или сбое проверок C++.

Если значение равно true, диагностический отчёт создаётся, когда процесс получает сигнал, указанный в process.report.signal.

Если значение равно true, диагностический отчёт создаётся при необработанном исключении.

Сигнал, используемый для запуска создания диагностического отчёта.

Возвращает представление диагностического отчёта для запущенного процесса в виде объекта JavaScript. Трассировка стека JavaScript отчёта берётся из err, если оно задано.

Записывает диагностический отчёт в файл. Если имя файла не указано, имя файла по умолчанию включает дату, время, PID и порядковый номер. Трассировка стека JavaScript отчёта берётся из err, если оно задано.

Если значением filename задано 'stdout' или 'stderr', отчёт записывается соответственно в stdout или stderr процесса.