Процесс

Объект process — это global, предоставляющий информацию о текущем процессе Node.js и управление им. Как глобальный объект, он всегда доступен приложениям Node.js без использования require().

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

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

Событие: 'beforeExit'

Добавлен в: v0.11.12

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

Функция обратного вызова обработчика вызывается со значением process.exitCode в качестве единственного аргумента.

Событие 'beforeExit' не генерируется для условий, вызывающих явное завершение, таких как вызов process.exit() или необработанные исключения.

Событие 'beforeExit' не следует использовать в качестве альтернативы событию 'exit', если только не планируется выполнение дополнительных задач.

Событие: 'disconnect'

Добавлен в: v0.7.7

Если процесс Node.js запущен с каналом IPC (см. документацию по Процессам-детям и Кластеру), событие 'disconnect' будет сгенерировано при закрытии канала IPC.

Событие: 'exit'

Добавлен в: v0.1.7

Событие 'exit' генерируется, когда процесс Node.js собирается завершиться в результате:

Явного вызова метода process.exit();
Отсутствия дополнительных задач для выполнения в цикле событий Node.js.

Нет способа предотвратить завершение цикла событий на этом этапе, и после завершения выполнения всех обработчиков события 'exit' процесс Node.js завершится.

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

Например:

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

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

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

Событие: 'message'

Добавлен в: v0.5.10

Если процесс Node.js запущен с каналом IPC (см. документацию по Процессам-детям и Кластеру), событие 'message' генерируется всякий раз, когда сообщение, отправленное родительским процессом с помощью childprocess.send(), принимается дочерним процессом.

Функция обратного вызова обработчика вызывается со следующими аргументами:

message <Объект> разобранный JSON-объект или примитивное значение
sendHandle <Объект-дескриптор> объект net.Socket или net.Server, или undefined.

Событие: 'rejectionHandled'

Добавлен в: v1.4.1

Событие 'rejectionHandled' генерируется всякий раз, когда Promise отклонен, и обработчик ошибок был прикреплён к нему (например, с помощью promise.catch()) позже, чем за один оборот цикла событий Node.js.

Функция обратного вызова вызывается со ссылкой на отклоненный Promise в качестве единственного аргумента.

Объект Promise ранее был сгенерирован в событии 'unhandledRejection', но в процессе обработки получил обработчик отклонений.

Нет понятия верхнего уровня для цепочки Promise, в котором отклонения всегда могут быть обработаны. Будучи по своей сути асинхронными, отклонение Promise может быть обработано в будущий момент времени — возможно, намного позже, чем в цикле событий, в котором генерируется событие 'unhandledRejection'.

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

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

В асинхронном коде событие 'unhandledRejection' генерируется, когда список необработанных отклонений увеличивается, а событие 'rejectionHandled' генерируется, когда список необработанных отклонений уменьшается.

Например:

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

В этом примере, список unhandledRejections Map будет расти и уменьшаться со временем, отражая отклонения, которые начинаются необработанными, а затем обрабатываются. Можно записывать такие ошибки в журнал ошибок, либо периодически (что, вероятно, лучше для долгоживущих приложений), либо при выходе процесса (что, вероятно, удобнее для скриптов).

Событие: 'uncaughtException'

Добавлен в: v0.1.18

Событие 'uncaughtException' генерируется, когда необработанное исключение JavaScript поднимается до цикла событий. По умолчанию Node.js обрабатывает такие исключения, выводит трассировку стека в stderr и завершается. Добавление обработчика для события 'uncaughtException' переопределяет это поведение по умолчанию.

Функция обработчика вызывается с объектом Error в качестве единственного аргумента.

Например:

process.on('uncaughtException', (err) => {
  fs.writeSync(1, `Caught exception: ${err}`);
});

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

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

Предупреждение: Правильное использование `'uncaughtException'`

Обратите внимание, что 'uncaughtException' — это примитивный механизм обработки исключений, который следует использовать только в крайнем случае. Событие не следует использовать как эквивалент On Error Resume Next. Необработанные исключения подразумевают, что приложение находится в неопределённом состоянии. Попытка возобновить работу приложения без надлежащей обработки исключения может привести к дополнительным непредвиденным и непредсказуемым проблемам.

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

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

Правильное использование 'uncaughtException' заключается в выполнении синхронной очистки выделенных ресурсов (например, дескрипторов файлов, дескрипторов, и т. д.) перед завершением процесса. После 'uncaughtException' невозможно безопасно продолжать нормальную работу.

Для более надежного перезапуска аварийного приложения, независимо от того, было ли сгенерировано событие uncaughtException или нет, следует использовать внешний монитор в отдельном процессе для обнаружения сбоев приложения и восстановления или перезапуска по мере необходимости.

Событие: 'unhandledRejection'

Добавлен в: v1.4.1

Событие 'unhandledRejection генерируется всякий раз, когда Promise отклоняется, и никакой обработчик ошибок не прикреплён к обещанию в рамках оборота цикла событий. При программировании с обещаниями исключения инкапсулированы как «отклоненные обещания». Отклонения могут быть перехвачены и обработаны с помощью promise.catch() и распространяются через цепочку Promise. Событие 'unhandledRejection' полезно для обнаружения и отслеживания обещаний, которые были отклонены, а их отклонения ещё не обработаны.

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

reason <Ошибка> | <любое> Объект, с помощью которого обещание было отклонено (обычно объект Error).
p отклоненное Promise.

Например:

process.on('unhandledRejection', (reason, p) => {
  console.log('Unhandled Rejection at: Promise', p, '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`

Следующее также вызовет событие 'unhandledRejection':

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

В этом случае можно отслеживать отклонение как ошибку разработчика, как это обычно делается для других событий 'unhandledRejection'. Для устранения таких неполадок может быть прикреплён неактивный обработчик .catch(() => { }) к resource.loaded, что предотвратит генерацию события 'unhandledRejection'. В качестве альтернативы можно использовать событие 'rejectionHandled'.

Событие: 'warning'

Добавлен в: v6.0.0

Событие 'warning' генерируется всякий раз, когда Node.js генерирует предупреждение процесса.

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

Функция обработчика вызывается с единственным аргументом warning, значение которого является объектом Error. Существует три ключевых свойства, описывающих предупреждение:

name <строка> Название предупреждения (в настоящее время Warning по умолчанию).
message <строка> Описание предупреждения, предоставленное системой.
stack <строка> Трассировка стека до места в коде, где было выведено предупреждение.

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.js будет выводить предупреждения процесса в stderr. Опцию командной строки --no-warnings можно использовать для подавления стандартного вывода в консоль, но событие 'warning' всё равно будет генерироваться объектом process.

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

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

В отличие от этого, в следующем примере отключается вывод стандартных предупреждений и добавляется обработчик для события 'warning':

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

Опция командной строки --trace-warnings может быть использована для включения в стандартный вывод предупреждений в консоль полного стека вызовов предупреждения.

Выдача пользовательских предупреждений

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

// Emit a warning using a string...
process.emitWarning('Something happened!');
// Prints: (node 12345) Warning: Something happened!

// Emit a warning using an object...
process.emitWarning('Something Happened!', 'CustomWarning');
// Prints: (node 12345) CustomWarning: Something happened!

// Emit a warning using a custom Error object...
class CustomWarning extends Error {
  constructor(message) {
    super(message);
    this.name = 'CustomWarning';
    Error.captureStackTrace(this, CustomWarning);
  }
}
const myWarning = new CustomWarning('Something happened!');
process.emitWarning(myWarning);
// Prints: (node 12345) CustomWarning: Something happened!

Выдача пользовательских предупреждений об устаревании

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

process.emitWarning('This API is deprecated', 'DeprecationWarning');

Или,

const err = new Error('This API is deprecated');
err.name = 'DeprecationWarning';
process.emitWarning(err);

Запуск Node.js с флагом командной строки --throw-deprecation заставит пользовательские предупреждения об устаревании быть выброшены как исключения.

Использование флага командной строки --trace-deprecation заставит пользовательские предупреждения об устаревании выводиться в stderr вместе со стеком вызовов.

Использование флага командной строки --no-deprecation подавит весь вывод пользовательских предупреждений об устаревании.

Флаги командной строки *-deprecation влияют только на предупреждения, использующие имя DeprecationWarning.

События сигналов

События сигналов будут генерироваться, когда процесс Node.js получит сигнал. Обратитесь к signal(7) для списка стандартных имен сигналов POSIX, таких как SIGINT, SIGHUP, и т. д.

Имя каждого события будет соответствовать общепринятому имени сигнала в верхнем регистре (например, 'SIGINT' для сигналов SIGINT).

Например:

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

Примечание: простой способ отправить сигнал SIGINT — это использование сочетания клавиш <Ctrl>-C в большинстве терминальных программ.

Важно отметить следующее:

SIGUSR1 зарезервирован в Node.js для запуска отладчика. Можно установить слушатель, но это не остановит запуск отладчика.
SIGTERM и SIGINT имеют обработчики по умолчанию на платформах, отличных от Windows, которые сбрасывают режим терминала перед завершением с кодом 128 + signal number. Если для одного из этих сигналов установлен слушатель, его поведение по умолчанию будет удалено (Node.js больше не завершится).
SIGPIPE игнорируется по умолчанию. Можно установить слушатель.
SIGHUP генерируется в Windows, когда окно консоли закрывается, и на других платформах в различных аналогичных ситуациях, см. signal(7). Можно установить слушателя, однако Node.js будет безусловно завершён Windows примерно через 10 секунд. На платформах, отличных от Windows, поведение по умолчанию SIGHUP заключается в завершении Node.js, но после установки слушателя его поведение по умолчанию будет удалено.
SIGTERM не поддерживается в Windows, его можно прослушивать.
SIGINT из терминала поддерживается на всех платформах и обычно может быть сгенерирован с помощью CTRL+C (хотя это может быть настраиваемо). Он не генерируется, когда режим терминала сырой.
SIGBREAK доставляется в Windows при нажатии <Ctrl>+<Break>, на платформах, отличных от Windows, его можно прослушивать, но нет способа его отправлять или генерировать.
SIGWINCH доставляется при изменении размера консоли. В Windows это произойдет только при записи в консоль при перемещении курсора или при использовании читаемого tty в сыром режиме.
SIGKILL не может иметь установленного слушателя, он безусловно завершит Node.js на всех платформах.
SIGSTOP не может иметь установленного слушателя.
SIGBUS, SIGFPE, SIGSEGV и SIGILL, если они не были искусственно возбуждены с помощью kill(2), по своей природе оставляют процесс в состоянии, при котором небезопасно пытаться вызывать JS-слушатели. Это может привести к зависанию процесса в бесконечном цикле, так как слушатели, подключенные с помощью process.on() вызываются асинхронно и, следовательно, не могут исправить основную проблему.

Примечание: Windows не поддерживает отправку сигналов, но Node.js предлагает некоторую эмуляцию с помощью process.kill() и subprocess.kill(). Отправка сигнала 0 может быть использована для проверки существования процесса. Отправка SIGINT, SIGTERM, и SIGKILL вызывает безусловное завершение целевого процесса.

process.abort()

Добавлена в: v0.7.0

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

process.arch

Добавлена в: v0.5.0

<строка>

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

Возможные значения: 'arm', 'arm64', 'ia32', 'mips', 'mipsel', 'ppc', 'ppc64', 's390', 's390x', 'x32', и 'x64'.

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

process.argv

Добавлена в: v0.1.27

<Массив>

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

Второй элемент — путь к исполняемому JavaScript-файлу. Остальные элементы — дополнительные аргументы командной строки.

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

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

Запуск процесса Node.js как:

$ node process-2.js one two=three four

Даст следующий вывод:

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

process.argv0

Добавлена в: 6.4.0

<строка>

Свойство 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.chdir(directory)

Добавлена в: v0.1.17

directory <строка>

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

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

process.config

Добавлена в: v0.7.7

<Объект>

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

Пример возможного вывода:

{
  target_defaults:
   { cflags: [],
     default_configuration: 'Release',
     defines: [],
     include_dirs: [],
     libraries: [] },
  variables:
   {
     host_arch: 'x64',
     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_dtrace: 'false',
     node_use_openssl: 'true',
     node_shared_openssl: 'false',
     strict_aliasing: 'true',
     target_arch: 'x64',
     v8_use_snapshot: 'true'
   }
}

Примечание: свойство process.config не является только для чтения, и в экосистеме существуют модули, которые, как известно, расширяют, изменяют или полностью заменяют значение process.config.

process.connected

Добавлена в: v0.7.2

<логическое значение>

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

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

process.cpuUsage([previousValue])

Добавлена в: v6.1.0

previousValue <Объект> Предыдущее возвращенное значение вызова process.cpuUsage()
Возвращает: <Объект>
- user <целое число>
- system <целое число>

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

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

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

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

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

process.cwd()

Добавлен в: v0.1.8

Возвращает: <строка>

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

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

process.disconnect()

Добавлен в: v0.7.2

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

Эффект вызова process.disconnect() такой же, как вызов метода ChildProcess.disconnect() родительского процесса.

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

process.env

Добавлен в: v0.1.27

<Объект>

Свойство 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. Другими словами, следующий пример не сработает:

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

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

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

Присвоение свойства объекту process.env неявно преобразует значение в строку.

Пример:

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

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

Пример:

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

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

Пример:

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

process.emitWarning(warning[, name][, ctor])

Добавлен в: v6.0.0

warning <строка> | <Ошибка> Предупреждение для отправки.
name <строка> Когда warning является строкой, name — имя для использования в предупреждении. По умолчанию: Warning.
ctor <Функция> Когда warning является строкой, ctor — необязательная функция, используемая для ограничения генерируемого отслеживания стека. По умолчанию process.emitWarning

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

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

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

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

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

Если warning передаётся как объект Error, он передаётся обработчику события process.on('warning') без изменений (и необязательные аргументы name и ctor игнорируются):

// Emit a warning using an Error object...
const myWarning = new Error('Warning! Something happened!');
myWarning.name = 'CustomWarning';

process.emitWarning(myWarning);
// Emits: (node:56338) CustomWarning: Warning! Something Happened!

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

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

В следующих случаях реализована дополнительная обработка, если предупреждение name — DeprecationWarning:

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

Избегание дублирующих предупреждений

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

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

process.execArgv

Добавлен в: v0.7.7

<Объект>

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

Например:

$ node --harmony script.js --version

Результатом является process.execArgv:

['--harmony']

И process.argv:

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

process.execPath

Добавлен в: v0.1.100

<строка>

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

Например:

'/usr/local/bin/node'

process.exit([code])

Добавлен в: v0.1.13

code <целое число> Код выхода. По умолчанию 0.

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

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

process.exit(1);

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

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

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

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

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

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

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

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

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

process.exitCode

Добавлен в: v0.11.8

<целое число>

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

Указание кода для process.exit(code) переопределит любое предыдущее значение process.exitCode.

process.getegid()

Добавлен в: v2.0.0

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

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

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

process.geteuid()

Добавлен в: v2.0.0

Возвращает: <Объект>

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

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

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

process.getgid()

Добавлен в: v0.1.31

Возвращает: <Объект>

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

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

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

process.getgroups()

Добавлен в: v0.9.4

Возвращает: <Массив>

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

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

process.getuid()

Добавлена в: v0.1.28

Возвращает: <целое число>

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

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

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

process.hrtime([time])

Добавлена в: v0.7.6

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

Передача результата предыдущего вызова process.hrtime() полезна для вычисления прошедшего времени между вызовами:

const time = process.hrtime();
// [ 1800216, 25 ]

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

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

Создание массива любым методом, кроме вызова process.hrtime() и передачи результата в process.hrtime(), приведёт к неопределённому поведению.

process.initgroups(user, extra_group)

Добавлена в: v0.9.4

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

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

Обратите внимание на необходимость осторожности при снятии привилегий. Пример:

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

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

process.kill(pid[, signal])

Добавлена в: v0.0.6

pid <число> Идентификатор процесса
signal <строка> | <число> Сигнал для отправки, в виде строки или числа. По умолчанию 'SIGTERM'.

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

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

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

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

Например:

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

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

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

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

process.mainModule

Добавлена в: v0.1.17

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

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

process.memoryUsage()

Добавлена в: v0.1.16

Возвращает: <Объект>
- rss <целое число>
- heapTotal <целое число>
- heapUsed <целое число>
- external <целое число>

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

Например, код:

console.log(process.memoryUsage());

Сгенерирует:

{
  rss: 4935680,
  heapTotal: 1826816,
  heapUsed: 650472,
  external: 49879
}

heapTotal и heapUsed относятся к использованию памяти V8. external относится к использованию памяти объектами C++, связанными с объектами JavaScript, управляемыми V8. rss, Резидентный объём памяти, — это занимаемое в основной памяти устройство (которое является подмножеством общей выделенной памяти) процессом пространство, включающее кучу, сегмент кода и стек.

Куча — это место хранения объектов, строк и замыканий. Переменные хранятся в стеке, а фактический JavaScript-код находится в сегменте кода.

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

Добавлена в: v0.1.26

callback <Функция>
...args <любой> Дополнительные аргументы для передачи при вызове callback

Метод process.nextTick() добавляет callback в очередь "следующей итерации". После завершения текущего цикла событий все колбэки в очереди следующей итерации будут вызваны.

Это не просто псевдоним для setTimeout(fn, 0). Он намного эффективнее. Он выполняется до запуска дополнительных событий ввода-вывода (включая таймеры) на последующих циклах событий.

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

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

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

  process.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);
}

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

const maybeTrue = Math.random() > 0.5;

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

bar();

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

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

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

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

Примечание: очередь следующей итерации полностью очищается на каждом проходе цикла событий до обработки дополнительных операций ввода-вывода. В результате, рекурсивное задание колбэков nextTick заблокирует выполнение операций ввода-вывода, подобно циклу while(true);.

process.noDeprecation

Добавлена в: v0.8.0

<булево>

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

process.pid

Добавлена в: v0.1.15

<целое число>

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

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

process.platform

Добавлена в: v0.1.16

<строка>

Свойство process.platform возвращает строку, идентифицирующую платформу операционной системы, на которой работает процесс Node.js. Например, 'darwin', 'freebsd', 'linux', 'sunos' или 'win32'

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

process.ppid

Добавлена в: v6.13.0

<целое число>

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

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

process.release

Добавлена в: v3.0.0

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

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

name <строка> Значение, которое всегда будет 'node' для Node.js. Для устаревших выпусков io.js это будет 'io.js'.
lts: строка со значением, указывающим имя кода LTS (Long-term Support) линии, к которой относится текущий выпуск. Это свойство существует только для LTS-выпусков и является undefined для всех других типов выпусков, включая стабильные. Текущие допустимые значения:
- 'Argon' для линии v4.x LTS, начиная с v4.2.0.
- 'Boron' для линии v6.x LTS, начиная с v6.9.0.
sourceUrl <строка> абсолютный URL, указывающий на файл .tar.gz, содержащий исходный код текущего выпуска.
headersUrl<строка> абсолютный URL, указывающий на файл .tar.gz, содержащий только исходные заголовочные файлы для текущего выпуска. Этот файл значительно меньше, чем полный исходный файл, и может использоваться для компиляции нативных дополнений Node.js.
libUrl <строка> абсолютный URL, указывающий на файл node.lib, соответствующий архитектуре и версии текущего выпуска. Этот файл используется для компиляции нативных дополнений Node.js. Это свойство присутствует только в Windows-версиях Node.js и отсутствует на всех других платформах.
lts <строка> строковая метка, идентифицирующая метку LTS для данного выпуска. Если выпуск Node.js не является LTS-выпуском, это будет undefined.

Например:

{
  name: 'node',
  lts: 'Argon',
  sourceUrl: 'https://nodejs.org/download/release/v4.4.5/node-v4.4.5.tar.gz',
  headersUrl: 'https://nodejs.org/download/release/v4.4.5/node-v4.4.5-headers.tar.gz',
  libUrl: 'https://nodejs.org/download/release/v4.4.5/win-x64/node.lib'
}

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

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

Добавлен в: v0.5.9

message <Объект>
sendHandle <Объект-обработчик>
options <Объект>
callback <Функция>
Возвращает: <булево>

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

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

Примечание: Эта функция использует JSON.stringify() для сериализации message.

process.setegid(id)

Добавлен в: v2.0.0

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

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

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)

process.seteuid(id)

Добавлен в: v2.0.0

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

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

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)

process.setgid(id)

Добавлен в: v0.1.31

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

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

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)

process.setgroups(groups)

Добавлен в: v0.9.4

groups <Массив>

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

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

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

process.setuid(id)

Добавлен в: v0.1.28

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

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)

process.stderr

<Поток>

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

Примечание: process.stderr отличается от других потоков Node.js важными способами, см. примечание о потоках ввода-вывода процесса для получения дополнительной информации.

process.stdin

<Поток>

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

Например:

process.stdin.setEncoding('utf8');

process.stdin.on('readable', () => {
  const chunk = process.stdin.read();
  if (chunk !== null) {
    process.stdout.write(`data: ${chunk}`);
  }
});

process.stdin.on('end', () => {
  process.stdout.write('end');
});

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

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

process.stdout

<Поток>

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

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

process.stdin.pipe(process.stdout);

Примечание: process.stdout отличается от других потоков Node.js важными способами, см. примечание о потоках ввода-вывода процесса для получения дополнительной информации.

Примечание о потоках ввода-вывода процесса

process.stdout и process.stderr отличаются от других потоков Node.js важными способами:

Они используются внутри console.log() и console.error(), соответственно.
Их нельзя закрыть (end() выбросит ошибку).
Они никогда не будут генерировать событие 'finish'.
Записи могут быть синхронными в зависимости от того, к чему подключён поток, и от того, Windows или POSIX система:
- Файлы: синхронные в Windows и POSIX
- TTY (терминалы): асинхронные в Windows, синхронные в POSIX
- Паровые трубы (и сокеты): синхронные в Windows, асинхронные в POSIX

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

Синхронные записи избегают проблем, таких как неожиданное переплетение вывода, записанного с помощью console.log() или console.error(), или его отсутствие, если process.exit() вызывается до завершения асинхронной записи. См. process.exit() для получения дополнительной информации.

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

Чтобы проверить, подключен ли поток к контексту TTY, проверьте свойство isTTY.

Например:

$ 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

См. документацию TTY для получения дополнительной информации.

process.throwDeprecation

Добавлен в: v0.9.12

<boolean>

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

process.title

Добавлен в: v0.1.104

<string>

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

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

process.traceDeprecation

Добавлен в: v0.8.0

<boolean>

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

process.umask([mask])

Добавлен в: v0.1.19

mask <number>

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

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

process.uptime()

Добавлен в: v0.5.0

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

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

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

process.version

Добавлен в: v0.1.3

<string>

Свойство process.version возвращает строку версии Node.js.

console.log(`Version: ${process.version}`);

process.versions

Добавлен в: v0.2.0

<Object>

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

console.log(process.versions);

Сгенерирует объект, подобный:

{
  http_parser: '2.3.0',
  node: '1.1.1',
  v8: '4.1.0.14',
  uv: '1.3.0',
  zlib: '1.2.8',
  ares: '1.10.0-DEV',
  modules: '43',
  icu: '55.1',
  openssl: '1.0.1k'
}

Коды выхода

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

1 Необработанное критическое исключение - Произошло необработанное исключение, и оно не было обработано доменом или обработчиком события 'uncaughtException'.
2 - Не используется (зарезервировано Bash для неправильного использования встроенных функций)
3 Внутренняя ошибка парсинга JavaScript - Внутренний код JavaScript в процессе загрузки Node.js вызвал ошибку синтаксического анализа. Это крайне редко, и, как правило, может произойти только во время разработки самого Node.js.
4 Внутренняя ошибка вычисления JavaScript - Внутренний код JavaScript в процессе загрузки Node.js не смог вернуть значение функции при вычислении. Это крайне редко, и, как правило, может произойти только во время разработки самого Node.js.
5 Критическая ошибка - Произошла необработанная и невосстановимая ошибка в V8. Обычно сообщение будет выведено в stderr с префиксом FATAL ERROR.
6 Нефункциональный обработчик внутренних исключений - Произошло необработанное исключение, но внутренняя функция обработки критических исключений была как-то установлена в не функцию и не могла быть вызвана.
7 Ошибка во время работы внутреннего обработчика исключений - Произошло необработанное исключение, и сама внутренняя функция обработки критических исключений выбросила ошибку при попытке обработать его. Это может произойти, например, если 'uncaughtException' или обработчик domain.on('error') выбросил ошибку.
8 - Не используется. В предыдущих версиях Node.js код выхода 8 иногда указывал на необработанное исключение.
9 - Неверный аргумент - Была указана неизвестная опция или опция, требующая значения, была предоставлена без значения.
10 Внутренняя ошибка выполнения JavaScript - Внутренний код JavaScript в процессе загрузки Node.js выбросил ошибку при вызове функции загрузки. Это крайне редко, и, как правило, может произойти только во время разработки самого Node.js.
12 Неверный аргумент отладки - Опции --debug, --inspect и/или --debug-brk были установлены, но выбранный номер порта был неверным или недоступным.
>128 Завершение по сигналам - Если Node.js получит критический сигнал, такой как SIGKILL или SIGHUP, его код выхода будет 128 плюс значение кода сигнала. Это стандартная практика POSIX, поскольку коды выхода определены как целые числа с 7 битами, а сигнальные завершения устанавливают старший бит, а затем содержат значение кода сигнала.

© Joyent, Inc. and other Node contributors
Licensed under the MIT License.
Node.js is a trademark of Joyent, Inc. and is used with its permission.
We are not endorsed by or affiliated with Joyent.
https://nodejs.org/dist/latest-v6.x/docs/api/process.html

Процесс

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

Событие: 'beforeExit'

Событие: 'disconnect'

Событие: 'exit'

Событие: 'message'

Событие: 'rejectionHandled'

Событие: 'uncaughtException'

Предупреждение: Правильное использование 'uncaughtException'

Событие: 'unhandledRejection'

Событие: 'warning'

Выдача пользовательских предупреждений

Выдача пользовательских предупреждений об устаревании

События сигналов

process.abort()

process.arch

process.argv

process.argv0

process.chdir(directory)

process.config

process.connected

process.cpuUsage([previousValue])

process.cwd()

process.disconnect()

process.env

process.emitWarning(warning[, name][, ctor])

Избегание дублирующих предупреждений

process.execArgv

process.execPath

process.exit([code])

process.exitCode

process.getegid()

process.geteuid()

process.getgid()

process.getgroups()

process.getuid()

process.hrtime([time])

process.initgroups(user, extra_group)

process.kill(pid[, signal])

process.mainModule

process.memoryUsage()

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

process.noDeprecation

process.pid

process.platform

process.ppid

process.release

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

process.setegid(id)

process.seteuid(id)

process.setgid(id)

process.setgroups(groups)

process.setuid(id)

process.stderr

process.stdin

process.stdout

Примечание о потоках ввода-вывода процесса

process.throwDeprecation

process.title

process.traceDeprecation

process.umask([mask])

process.uptime()

process.version

process.versions

Коды выхода

Предупреждение: Правильное использование `'uncaughtException'`