Spawn создать процесс


Содержание

Пример использования команды spawn()

Доброго времени суток, не могли бы вы дать мне пример использования команды Spawn() для создания нового процесса. И по возможности описать аргументы, которые она принимает.

Искал в интернете информацию, но пример не могу найти.

15.11.2020, 19:06

Пример использования свойства
Приведите, пожалуйста, пример использования свойства all. Не могу найти,что это такое.

Пример использования OemToChar.
Создаю текстовый файл. В него все пишется в виндовой кодировке, а мне надо в DOS. Спасибо.

Пример использования TExcelChart
Если кто-нибудь когда-нибудь использовал этот компонент у себя, подскажите, пожалуйста, где можно.

Пример использования CreatePipe
всем привет, подскажите ктонибуть работал с функцией CreatePipe, это перенаправление ввода вывода .

Пример использования Cookie
Не получается. Пришлите пожалуйста хотя бы малюсенький примерчик использования Cookie. Но не.

Spawn создать процесс

Spawning Processes — Порождение процессов с помощью fork() / exec() .

Краткое описание

Описание

Детали

enum GSpawnError

Коды ошибок возвращаемые при выполнении процессов.

G_SPAWN_ERROR_FORK форк не удался из-за нехватки памяти.
G_SPAWN_ERROR_READ чтение или выбор канала неудался.
G_SPAWN_ERROR_CHDIR изменение рабочего каталога неудалось.
G_SPAWN_ERROR_ACCES execv() вернул EACCES .
G_SPAWN_ERROR_PERM execv() вернул EPERM .
G_SPAWN_ERROR_2BIG execv() вернул E2BIG .
G_SPAWN_ERROR_NOEXEC execv() вернул ENOEXEC .
G_SPAWN_ERROR_NAMETOOLONG execv() вернул ENAMETOOLONG .
G_SPAWN_ERROR_NOENT execv() вернул ENOENT .
G_SPAWN_ERROR_NOMEM execv() вернул ENOMEM .
G_SPAWN_ERROR_NOTDIR execv() вернул ENOTDIR .
G_SPAWN_ERROR_LOOP execv() вернул ELOOP .
G_SPAWN_ERROR_TXTBUSY execv() вернул ETXTBUSY .
G_SPAWN_ERROR_IO execv() вернул EIO .
G_SPAWN_ERROR_NFILE execv() вернул ENFILE .
G_SPAWN_ERROR_MFILE execv() вернул EMFILE .
G_SPAWN_ERROR_INVAL execv() вернул EINVAL .
G_SPAWN_ERROR_ISDIR execv() вернул EISDIR .
G_SPAWN_ERROR_LIBBAD execv() вернул ELIBBAD .
G_SPAWN_ERROR_FAILED Некоторая другая проблема, error->message должно пояснить.

G_SPAWN_ERROR

Домен ошибки для порождения процессов. Ошибки в этом домене будут из перечисления GSpawnError . Смотрите GError для информации о доменах ошибки.

enum GSpawnFlags

G_SPAWN_LEAVE_DESCRIPTORS_OPEN дескриптор открытого родительского файла будет унаследован дочерним процессом; иначе все дескрипторы кроме stdin/stdout/stderr будут закрыты перед вызовом exec() в дочернем процессе.
G_SPAWN_DO_NOT_REAP_CHILD дочерний процесс не будет автоматически получен; вы должны вызвать waitpid() или обработать SIGCHLD самостоятельно, или дочерний процесс станет зомби.
G_SPAWN_SEARCH_PATH argv[0] не должен быть абсолютным путём, он будет найден в пользовательском PATH .
G_SPAWN_STDOUT_TO_DEV_NULL стандартный вывод из дочернего процесса будет отменён, вместо направления в тоже расположение родительского стандартного вывода.
G_SPAWN_STDERR_TO_DEV_NULL стандартные ошибки дочернего процесса будут отменены.
G_SPAWN_CHILD_INHERITS_STDIN дочерний процесс унаследует стандартный ввод родителя (по умолчанию, стандартный дочерний ввод прикреплён к /dev/null ).
G_SPAWN_FILE_AND_ARGV_ZERO первый элемент argv это выполняемый файл, остальные элементы являются фактически одномерным массивом параметров для помещения в файл. Обычно g_spawn_async_with_pipes() использует argv[0] как файл для выполнения и передаёт все argv в дочерний процесс.

GSpawnChildSetupFunc ()

Определяет тип установочной функции помещаемой в g_spawn_async() , g_spawn_sync() и g_spawn_async_with_pipes() . На POSIX платформах она вызывается в дочернем процессе после того как GLib выполнит все запланированные установки, но перед вызовом exec() . В POSIX, действия принятые в этой функции, затронут таким образом только дочерний процесс, а не родителя.

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

user_data : пользовательские данные помещаемые в функцию.

g_spawn_async_with_pipes ()

Выполняет дочернюю программу асинхронно (ваша программа не будет блокирована для выхода из дочернего процесса). Дочерняя программа определяет только аргументы которые должны быть предоставлены массивом argv . argv должен быть NULL -завершённым массивом строк, для помещения как одномерный массив в дочерний процесс. Первая строка в argv является названием программы для выполнения. По умолчанию имя программы должно быть полным путём; переменная PATH оболочки (shell) будет использоваться для поиска только если вы поместите флаг G_SPAWN_SEARCH_PATH .

Помните что в Windows все строки или одномерные строковые массивы аргументов для этой функции и других g_spawn*() функций находятся в кодировке UTF-8, кодировка имён файлов GLib. Unicode символы которые не являются частью системной кодовой страницы которые передают в одномерном массиве аргументов будут корректно доступны в порождённой программе только если она использует широкий символьный API для поиска в её командной строке. Для C программ собранных с помощью инструментария Microsoft’s достаточно создать программу имея wmain() вместо main() . wmain() имеет широкий символ одномерного массива как параметр.

По крайней мере в настоящее время mingw не поддерживает wmain() , поэтому если вы используете mingw для разработки порождаемых программ, то должны вызвать недокументированную функцию __wgetmainargs() для получения широкого символа аргументов одномерного массива и окружения. Смотрите gspawn-win32-helper.c в GLib исходниках или init.c в исходниках программы mingw для определения прототипа этой функции. Альтернативно вы можете найти широкий символ командной строки системного уровня Win32 помещаемый в порождённую программу используя функцию GetCommandLineW() .

В Windows нижний уровень API создания дочерних процессов CreateProcess() не использует одномерный массив аргументов, но использует командную строку. Семейство функций библиотеки C spawn*() (которые вызывают в конечном счёте g_spawn_async_with_pipes() ) помещают элементы одномерного массива аргументов вместе в командную строку, а во время выполнения C код делает соответствующую реконструкцию одномерного массива аргументов из командной строки для помещения в main() . Осложнения возникают когда вы имеете элементы одномерного массива аргументов которые содержат пробелы заключённые в двойные кавычки. Функции spawn*() не делают никакого квотирования или выхода, но с другой стороны код запуска закрывает кавычки и не выходит чтобы позволить получить аргументы с включёнными пробелами или двойными кавычками. Для работы вокруг этой ассиметрии, g_spawn_async_with_pipes() выполнит квотирование и прервёт элементы одномерного массива аргументов которые нужны ей перед вызовом функции C runtime spawn() .

envp это NULL -завершённый массив строк, где каждая строка имеет форму KEY=VALUE . Это будет окружением дочернего процесса. Если envp это NULL , дочерний процесс наследует окружение его родителя.

flags должен быть поразрядным ИЛИ любых флагов которые должны влиять на поведение функции. G_SPAWN_DO_NOT_REAP_CHILD означает что дочерний процесс не будет автоматически выполнен; вы должны использовать источник GChildWatch для получения уведомления об уничтожении дочернего процесса. В конечном счёте вы должны вызвать g_spawn_close_pid() в child_pid , для освобождения ресурсов связанных с дочерним процессом. (В Unix, используется источник GChildWatch равноценный вызову waitpid() или обрабатывается сигнал SIGCHLD вручную. В Windows, вызов g_spawn_close_pid() равноценно вызову CloseHandle() для обработки возвращаемого child_pid ). G_SPAWN_LEAVE_DESCRIPTORS_OPEN означает что родительский дескриптор открытого файла будет унаследован дочерним процессом; иначе все дескрипторы кроме stdin/stdout/stder будут закрыты перед вызовом exec() в дочернем процессе. G_SPAWN_SEARCH_PATH означает что argv[0] не должен быть абсолютным путём, он будет найден в пользовательской переменной PATH . G_SPAWN_STDOUT_TO_DEV_NULL означает что стандартный вывод дочернего процесса будет отменён, он будет направлен в тоже расположение что и стандартный вывод родительского процесса. Если вы используете этот флаг, standard_output должен быть NULL . G_SPAWN_STDERR_TO_DEV_NULL означает что дочерний стандартный поток error будет отменён, вместо этого он будет направлен в тоже расположение что и стандартный поток error родительского процесса. Если вы используете этот флаг, standard_error должен быть NULL . G_SPAWN_CHILD_INHERITS_STDIN означает что дочерний процесс будет наследовать родительский стандартный поток ввода (input) (по умолчанию, стандартный поток ввода дочернего процесса прикреплён к /dev/null). Если вы используете этот флаг, standard_input должен быть NULL . G_SPAWN_FILE_AND_ARGV_ZERO означает что первый элемент argv является исполняемым файлом, в то время как остальные элементы являются фактически одномерным массивом аргументов помещаемых в файл. Обычно g_spawn_async_with_pipes() использует argv [0] как исполняемый файл, и помещает остальные argv в дочерний процесс.

child_setup и user_data являются функцией и пользовательскими данными. На POSIX платформах, функция вызывается в дочернем процессе после выполнения GLib всех запланированных установок (включая создание каналов, закрытие дескрипторов файлов, etc.) но перед вызовом exec() . Таким образом, child_setup вызывается перед вызовом exec() в дочернем процессе. Очевидно что действия принятые в этой функции затронут только дочерний процесс, но не родителя. В Windows, нет разделения fork() и exec() функциональности. Дочерний процесс создаётся и выполняется единственным API вызовом, CreateProcess() . child_setup вызывается в родительском процессе как раз перед созданием дочернего процесса. Вы должны внимательно рассмотреть то что вы делаете в child_setup если вы планируете переносить свою программу в Windows.

Если не- NULL , child_pid будет заполнен в Unix с помощью >waitpid() если вы определили флаг G_SPAWN_DO_NOT_REAP_CHILD . В Windows, child_pid будет заполнен с помощью обработки дочернего процесса только если вы определили флаг G_SPAWN_DO_NOT_REAP_CHILD . Вы сможете тогда обратиться к дочернему процессу используя Win32 API, например ожидать его завершения с помощью функций WaitFor*() , или например проверить его код завершения с помощью GetExitCodeProcess() . Вы должны завершить обработку с помощью CloseHandle() или g_spawn_close_pid() когда вы больше не нуждаетесь в ней.

Если не- NULL , standard_input , standard_output , standard_error расположения будут заполнены дескрипторами файлов для записи в стандартном потоке ввода дочерних процессов или для чтения в стандартном потоке вывода или для стандартного потока error. Вызывающий g_spawn_async_with_pipes() должен закрыть этот дескриптор файла когда он больше не нужен. Если эти параметры равны NULL , соответственно канал не будет создан.

Если standard_input равен NULL, стандартный ввод дочернего процесса прикреплён к /dev/null пока не установлен G_SPAWN_CHILD_INHERITS_STDIN .

Если standard_error равен NULL, стандартный поток error дочернего процесса направлен в тоже расположение что и стандартный поток error родительского процесса пока не установлен G_SPAWN_STDERR_TO_DEV_NULL .

Если standard_output равен NULL, стандартный вывод дочернего процесса направлен в то же расположение что и стандартный вывод родительского процесса пока не установлен G_SPAWN_STDOUT_TO_DEV_NULL .

error может быть NULL для игнорирования ошибок, или не- NULL для сообщения об ошибках. Если error установлен, функция возвращает FALSE . Об ошибках сообщается даже если они происходят в дочернем процессе (например если исполняемый файл в argv[0] небыл найден). Обычно поле message возвращаемой ошибки должно отображаться пользователям. Возможные ошибки указаны в домене G_SPAWN_ERROR .

Если произошла ошибка, child_pid , standard_input , standard_output , и standard_error не будут заполнены допустимыми значениями.

Создание дочернего процесса с помощью MPI_Comm_spawn

Может кто-нибудь объяснить, почему даже когда я устанавливаю число процессов более чем на 1, только два дочерних процесса создаются в коде ниже. Каждый MPI_Comm_spawn может создать два дочерних процесса, используя следующий код: в коде, который используется каждый процесс, созданный с помощью mpirun, вызывается один раз MPI_Comm_spawn и будет генерировать 2 (#define NUM_SPAWNS 2) дочерний процесс, поэтому, если я вызову N процесс, то процесс childs 2 * N ребенок должен быть создан. Но этого не происходит.

В приведенном ниже примере число детей должно быть 4 * 2 = 8. Но.

$ mpirun -np 4./spawn_example

Кажется, вы неправильно поняли, что делает MPI_Comm_spawn . Это коллективный вызов, и он не порождает n дополнительных процессов за ранг, а скорее порождает дочернее задание MPI с n процессами, поэтому добавление n к общему числу процессов. Когда вызывается с n = 2 , оно порождает дочернее задание с двумя процессами и именно то, что вы наблюдаете на выходе.

Пока MPI_Comm_spawn является коллективным вызовом, вы можете использовать MPI_COMM_SELF для создания дочерних элементов для этого родителя:

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

Spawn создать процесс

8 просмотра

1 ответ

113 Репутация автора

Я пытаюсь создать дочерний процесс posix_spawn() . Я даю имя исполняемого файла (который существует), но posix_spawn() создает процесс зомби (я ищу в процессе, ps и он показывает как ). Даже когда я указываю несуществующее имя исполняемого файла, процесс зомби создается.

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

Вот мой код (PS исполняемого файла «dummy» не существует):

С получением статуса:

Ответы (1)

плюса

33117 Репутация автора

Вы можете сделать что-то вроде int wstatus; if(0 .

На словах попробуйте дождаться пида сразу после появления. Если ожидание прошло успешно и процесс завершился с 127, у вас произошел сбой exec.

Вопросы с тегом ‘spawn’


Количество результатов: 121

Как можно изменить дочерние процессы UID/GID на основе Предоставленного пользователя имени пользователя и пароль без предоставления корневого узла или других особых пр.

Я новичок в Python и пытается удалить/дифферента выход GEvent StackTrace когда возбуждается исключение. Я где-то читал, что я могу сделать это произошло с помощью Asyn.

Я пытаюсь создать дочерний процесс, используя икру, и хотел бы быть в состоянии справиться, если «УХО» не найдено. Когда он не найден, он выдает ошибку «ENOENT», котор.

содержание докер файла: From freeradius/freeradius-server COPY eccCertImport / RUN apt-get update -y && apt-get install -y expect RUN [«/bin/sh»,»/eccCertImpo.

Я должен EXEC скрипт VBS по Nodejs и поэтому я использую child_process. Моя проблема заключается в том, что если есть ошибка в процессе икры он не срабатывает событие.

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

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

Мне нужно использовать MPI икру на кластере. Для этого я понял, что нужно использовать MPI_Info_set для указания с узлами будет запускать процессы породили. я пытался .

Когда я подключаю к Linux с помощью SSH Баша подсказки centos-1:

#. Но когда я подключаю к Linux с помощью pexpect нереста Баша подсказка является \x1b]0;[email protected]

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

В настоящее время у меня есть простой модуль бегун Баш скрипт: «use strict»; function bashRun(commandList,stdoutCallback,completedCallback) < const proc=require.

Я пытаюсь захватить вывод из внешней программы, запущенной с AWS Lambda, написанной на NodeJS. Полный пример кода ниже. Подойдет любое тестовое событие, так как оно на.

Нужна помощь в выяснении этого. Я пытаюсь вызвать внешнее приложение через дочерний процесс spawn и после вызова приложения запрашивает пароль. Затем я получаю фаталь.

У нас есть устаревшее приложение, написанное на NodeJS, которое вызывает приложение C++ с require(‘child_process’).spawn() метод. Время работы приложения C++ составляе.

код выглядит следующим образом: var exec = require(‘child_process’).spawn; var child = exec(‘executable.exe’,[‘-nw’,’-nc’,’launch.txt’]); child.stdout.on(‘data’, func.

У меня есть сервер узла, и я бегу питона файл из него на конечной точке, как это: app.get(‘/api/endpoint’, (req, res) => < if (req.query.key !== 'key') < res.s.

Я успешно с помощью popen() для выполнения команд из моей программы C. Как я понимаю, он использует fork() а также exec() (или варианты) тех, за занавесками. Это работ.

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

Я хочу, чтобы вызвать .sh файл из питона сценария. Это требует разрешений SUDO и я хочу, чтобы автоматически передавать пароль без получения приглашения. Я попытался с.

Я работаю через Джо Армстронг Программирование Эрланга второго E. В книге есть упражнение в конце каждой главы. Глава 13, упражнение 1 говорит: Написать функцию my.

Выполняя функцию xdmp.spawn в MarkLogic, как показано ниже: var abc = «foo» xdmp.spawn(«/oneplusone.sjs», (xs.QName(«abc»), «foo»).Object,) Ошибка : .

Я работаю на devtool и одна из особенностей этого инструмента заключается в порождении дочернего процесса и читать стандартный вывод поток этого процесса. Мне нужно пр.

Я пытаюсь убить процесс, используя kill метод в child_process. Но я получаю следующую ошибку при попытке вызвать функцию: TypeError [ERR_UNKNOWN_SIGNAL]: Unknown sign.

Я пытаюсь создать резервную копию MySQL моего приложения с помощью mysqldump. Дочерний процесс порождения кажется неспособным написать пароль. Это все, что я пробовал .

Я хочу использовать child_process.spawn выполнить Windows EXE-файл и поймать его вывод. Когда я использую командную строку для запуска стороннего exe-файла (говорит A.

Следующая строка кода выполняется в моем скрипте Python: driver = webdriver.Chrome(CHROMEDRIVER_PATH, chrome_options = chrome_options) Эта строка может либо потерпе.

как начать икру в рубин, передавая ему аргументы? Я пытался, как это: validators_pid 0 голосов

У меня есть этот фрагмент кода для проверки целостности архива почтового индекса и записи вывода в файл (стандартный вывод и стандартный вывод): cmd = «gunzip -t » + .

Я пытаюсь породить дочерний процесс и иметь свои результаты в Promise. Дочерний процесс не может запустить несколько раз одновременно. Я оберточной Node.js-х child_pr.

У меня есть синхронное выполнение отправки несколько запросов и получения ответов несколько с сокетами в Python: # ATTENTION, SYNCHRONOUS WAY import socket from sele.

Я некоторый сценарий, написанный в nodejs, который использует spawn выполнить некоторые CMD команду: let cmd = spawn(«command name», [«my», «arguments»],

я завязывание использовать вывод скрипта Perl в Node.js for (my $i=10;$i 0 голосов

Я задаюсь вопросом, почему мои два респауна команды возвращают мне ошибку тайм-аута и ошибки во время, когда я вручную запускать их в терминале они работают. [[email protected]

Я пытался породить дочерний процесс — VVP (https://linux.die.net/man/1/vvp). В определенное время, мне нужно отправить CTRL+C к этому процессу. Я ожидаю, что моделиров.

Я пытаюсь запустить скрипт ожидать, когда он делает петлю Еогеаспа в именах хостов, а затем делает SSH в узлы и взять техническую-поддержку. Каждый узел имеет переменн.

Строительство моего проекта с использованием радиально-Cli работает, когда я использую его прямо из моего окна терминала, как это: $ ng build Теперь я хотел бы запус.

я использую child_process#spawn использовать внешние исполняемые файлы через Node.js. Каждый бинарный поиск точных слов в строке, в зависимости от языка, и производить.

У меня есть NodeJS код вроде следующего: [myFile.js] var path = require(«path»); var cp = require(«child_process»); var child = cp.spawn( «python»,[«HelloWorld.py».

У меня есть скрипт start.sh чья работа заключается в том, чтобы порождать несколько процессов Java в фоновом режиме, а затем завершать работу, как показано ниже: java.

Я не могу породить простую командную строку: su username -c «ls -la» вот мой код: var childArgs = [ ‘username’, ‘-c’, ‘»ls -la»‘ ]; var ph = spawn(‘su’.

Возможно ли для node.js свернуть окно дочернего процесса, запущенного с помощью spawn(), exec() или execFile()? Я запускаю с ним приложение, которое не позволяет сверн.

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

Я имею игру, порожденную как детский процесс. Все это прекрасно работает с оригинальным .exe-файлом игры. Тем не менее, я бы хотел, чтобы он выполнялся в свернутом вид.

Вот некоторые node.js код, который нерестится Линукс ls команда и предлагает свой результат const spawn = require(‘child_process’).spawn; const ls = spawn(‘ls’, [‘-l’.

#!/usr/bin/expect -f set login «root» set addr «10.10.10.10» set pw «123!» set localDir «/home/user/www/*» set servDir «/var/www/html/» spawn scp -r $localDir $lo.

Я хотел бы общаться с MPI между Фортраном (в качестве ведущего) и программой питона (как раба). Я написал следующий тест, но я не мог получить родительский коммуникато.

Я использую икру для запуска нескольких процессов в узле. Вот мой код: var spawn = require(‘child_process’).spawn; var log_spawn = function (out) < process.stdou.

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

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

Туториал по Unreal Engine. Часть 5: Как создать простую игру

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

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

  • Бесконечно перемещать игрока вперёд
  • Генерировать препятствия, которые игрок должен избегать
  • Рандомизировать препятствия для создания вариаций
  • Создавать кнопку перезапуска, которая отображается, когда игрок сталкивается с препятствием

В результате у нас получится вот такая игра:

Учтите, что в этой части мы будем пользоваться Blueprints и UMG. Если вам нужно освежить свои знания, то прочитайте части, посвящённые Blueprints и UI.

Примечание: эта статья является одной из восьми частей туториала по Unreal Engine:

Приступаем к работе

Скачайте заготовку проекта и распакуйте её. Перейдите в папку проекта и откройте InfiniteMatrix.uproject.

Примечание: если откроется окно, сообщающее, что проект создан в более ранней версии Unreal editor, то всё в порядке (движок часто обновляется). Можно или выбрать опцию создания копии, или опцию преобразования самого проекта.


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

Первое, что нам нужно сделать — заставить игрока постоянно двигаться.

Движение игрока вперёд

Перейдите в папку Blueprints и откройте BP_Player.

Чтобы двигать игрока вперёд, нужно добавлять в каждом кадре к местоположению игрока смещение.

Илон Маск рекомендует:  $IfDef - Директива компилятора Delphi

Во-первых, нам нужно создать переменную, задающую скорость движения игрока вперёд. Создайте переменную Float по названием ForwardSpeed и задайте значение по умолчанию 2000.

Теперь перейдите в Event Graph и найдите нод Event Tick. Создайте следующую схему:

Умножая ForwardSpeed на Delta Seconds, мы получим независимый от частоты кадров результат.

Примечание: если вам непонятно, что такое независимость от частоты кадров, то прочитайте часть туториала про Blueprints. Мы разбираем её в разделе Независимость от частоты кадров.

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

Движение вдоль одной оси

Чтобы перемещать игрока, создайте нод AddActorWorldOffset. Измените значение Sweep на true, нажав на флажок.

Если попробовать соединить результат Float с входом Delta Location, то Unreal автоматически преобразует его в Vector.

Однако таким образом значение Float будет записано в компоненты X, Y и Z вектора. Для нашей игры движение вперёд должно выполняться только вдоль оси X. К счастью, можно разделить Vector на три компонента Float.

Убедитесь, что контакт Delta Location нода AddActorWorldOffset ни с чем не соединён. Нажмите правой клавишей мыши на контакт Delta Location и выберите Split Struct Pin.

Наконец, соедините всё следующим образом:

  1. В каждом кадре игра будет умножать ForwardSpeed и Delta Seconds, чтобы получать независимый от частоты кадров результат
  2. AddActorWorldOffset будет использовать этот результат для перемещения игрока вдоль оси X
  3. Поскольку Sweep включён, игрок будет прерывать движение вперёд, когда его что-то блокирует

Нажмите на Compile и вернитесь в основной редактор. Если нажать Play, то вы начнёте двигаться сквозь туннель.

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

Создание системы спауна туннелей

Перейдите в Content Browser и зайдите в папку Blueprints. Создайте новый Blueprint Class с родительским классом Actor. Назовите его BP_TunnelSpawner и откройте его.

Игра будет создавать туннели постоянно, поэтому неплохо было бы создать функцию для спауна. Перейдите в панель My Blueprint и создайте новую функцию SpawnTunnel. Задачей функции будет спаун туннеля в указанном местоположении.

Чтобы передавать функции местоположение, функции нужен входной параметр. Они будут отображаться при вызове функции как входные контакты.

Также они будут отображаться как выходные контакты нода Entry функции.

Давайте создадим входной параметр. Перейдите в граф функции SpawnTunnel. Выберите нод Entry и перейдите в панель Details. Нажмите на значок + рядом с разделом Inputs.

Переименуйте входной параметр в SpawnLocation и смените его тип на Vector.

Чтобы создать туннель, добавьте нод Spawn Actor From Class. Нажмите на раскрывающийся список, расположенный справа от контакта Class и выберите BP_Tunnel.

Чтобы задать местоположение спауна, нажмите правой клавишей на контакт Spawn Transform и выберите Split Struct Pin. Затем соедините нод Spawn Actor From Class с нодом Entry:

Теперь при вызове функции SpawnTunnel она будет спаунить экземпляр BP_Tunnel в переданном ей местоположении.

Давайте проверим, как это работает!

Проверка системы спауна туннелей

Переключитесь на Event Graph и найдите нод Event BeginPlay. Добавьте нод SpawnTunnel и соедините его с нодом Event BeginPlay.

В ноде SpawnTunnel задайте Spawn Location значение (2000, 0, 500).

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

Сначала удалите BP_Tunnel из уровня. Для этого щёлкните на BP_Tunnel в World Outliner. Затем нажмите на клавишу Delete, чтобы удалить его с уровня.

Затем перейдите в Content Browser. Перетащите левой клавишей мыши BP_TunnelSpawner во Viewport. Благодаря этому его экземпляр появится на уровне.

Если нажать на Play, то игра будет спаунить туннель сверху и перед игроком.

Закончив проверку, вернитесь к BP_TunnelSpawner. Сбросьте значения Spawn Location нода SpawnTunnel на (0, 0, 0).

После этого нажмите на Compile и вернитесь в основной редактор.

В следующем разделе мы настроим работу BP_Tunnel.

Настройка Blueprint туннеля

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

Во-вторых, он будет задавать точку спауна. После этого BP_TunnelSpawner будет использовать эту точку как следующее местоположение спауна.

Давайте начнём с создания зоны триггера.

Создание зоны триггера

Откройте BP_Tunnel и перейдите в панель Components. Добавьте компонент Box Collision и назовите его TriggerZone.

Пока область коллизии довольно мала. Перейдите в панель Details и найдите раздел Shape. Задайте свойству Box Extent значения (32, 500, 500).

Теперь задайте свойству Location значения (2532, 0, 0). Это разместит TriggerZone прямо в конец меша туннеля. Это значит, что новый туннель должен будет создаваться только когда игрок достигнет конца туннеля.

Теперь настало время создать точку спауна.

Создание точки спауна

Для задания местоположения точки спауна можно использовать компонент Scene. Эти компоненты идеально подходят для задания местоположений, потому что у них есть только Transform. Кроме того, они видимы во Viewport, поэтому вы можете видеть, где находится точка спауна.

Перейдите в панель Components и убедитесь, что ничего не выбрано. Добавьте компонент Scene и переименуйте его в SpawnPoint.

Меш туннеля имеет длину 2500 единиц по оси X, поэтому именно здесь должна быть точка присоединения. Перейдите в панель Details и задайте свойству Location значения (2500, 0, 0).

Следующее, что нужно сделать — создать функцию, которая спаунит туннель в SpawnPoint.

Создание туннелей в точке спауна

Нажмите на Compile и переключитесь на BP_TunnelSpawner.

Следующий BP_Tunnel должен спауниться в SpawnPoint самого дальнего туннеля. Благодаря этому туннель всегда будет продолжаться.

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

Откройте граф SpawnTunnel. Нажмите правой клавишей мыши на контакте Return Value нода Spawn Actor From Class. Выберите Promote to Variable и переименуйте переменную в NewestTunnel.

Теперь у нас всегда будет ссылка на самый дальний туннель.


Далее создайте новую функцию и назовите её SpawnTunnelAtSpawnPoint. Создайте следующий граф:

Эта схема будет получать самый новый туннель и местоположение его компонента SpawnPoint, после чего спаунить новый туннель в этом местоположении.

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

Создание ссылки на спаунер туннелей

Нажмите на Compile и закройте граф SpawnTunnelAtSpawnPoint. Переключитесь на BP_Tunnel.

Добавьте новую переменную и назовите её TunnelSpawner. В качестве Variable Type выберите BP_TunnelSpawner\Object Reference.

Нажмите на Compile и переключитесь на BP_TunnelSpawner.

Откройте граф SpawnTunnel и добавьте обозначенные ноды:

Теперь у каждого туннеля будет ссылка на BP_TunnelSpawner.

Далее нужно сообщить BP_TunnelSpawner о необходимости спауна следующего туннеля, когда игрок входит в TriggerZone.

Скриптинг зоны триггера

Нажмите на Compile и переключитесь на BP_Tunnel.

Перейдите в панель Components и нажмите правой клавишей на TriggerZone. Выберите Add Event\Add OnComponentBeginOverlap. Это добавит в Event Graph следующий нод:

Этот нод будет выполняться когда другой Actor касается TriggerZone.

Сначала нам нужно проверить, является ли Actor, касающийся TriggerZone, игроком.

Перетащите контакт Other Actor. Отпустите левую клавишу мыши в пустом пространстве и выберите в меню Cast to BP_Player.

Примечание: туннель спаунится в конце другого туннеля, поэтому он приведёт к срабатыванию триггера TriggerZone этого туннеля. Cast to BP_Player предотвращает выполнение всех дальнейших нодов, если Other Actor является туннелем.

Теперь добавим обозначенные ноды после нода Cast to BP_Player:

Давайте посмотрим, что здесь происходит пошагово:

  1. Когда Actor касается TriggerZone, выполняется нод On Component Begin Overlap (TriggerZone)
  2. Нод Cast to BP_Player проверяет, является ли касающийся актор игроком
  3. Если это игрок, то BP_TunnelSpawner создаст новый туннель. Его местоположение будет находится в компоненте SpawnPoint последнего созданного туннеля.
  4. Поскольку старый туннель уже не нужен, игра удаляет его с помощью нода DestroyActor

Нажмите на Compile, вернитесь в основной редактор и нажмите Play. Когда вы достигнете конца туннеля, игра создаст новый.

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

Создание нескольких туннелей

Первое, что нужно сделать — создать функцию, создающую определённое количество туннелей.

Откройте BP_TunnelSpawner и создайте новую функцию с названием SpawnInitialTunnels.

Чтобы спаунить определённое количество туннелей, можно использовать нод ForLoop. Этот нод будет выполнять соединённые с ним ноды указанное количество раз. Добавьте нод ForLoop и соедините его с нодом Entry.

Чтобы нод ForLoop выполнялся n раз, необходимо задать для Last Index значение n – 1.

В этом туториале мы будем спаунить три туннеля. Для выполнения трёх циклов задайте Last Index значение 2.

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

Создание первого туннеля

Чтобы определить, был ли создан первый туннель, мы можем проверить, задано ли NewestTunnel. Если нет, то это значит, что первый туннель ещё не создан, потому что NewestTunnel задаётся только после того, как игра создаст туннель.

Чтобы выполнить эту проверку, добавим нод IsValid (на котором есть знак вопроса) после нода ForLoop.

Затем получим ссылку на NewestTunnel и соединим её с контактом Input Object нода IsValid.

Если NewestTunnel не задан, то будет выполнен нод Is Not Valid, и наоборот.

Добавьте следующее и соедините ноды с контактом Is Not Valid нода IsValid:

Эта схема будет создавать туннель в местоположении Pawn игрока.

Затем нам нужно создать следующие туннели.

Создание следующих туннелей

Добавьте нод SpawnTunnelAtAttachPoint и соедините его с контактом Is Valid нода IsValid.

Вот как выглядит готовый граф:

  1. Нод ForLoop выполняется три раза
  2. В первом цикле он спаунит туннель в точке расположения игрока
  3. В последующих циклах он спаунит туннель в точке SpawnPoint самого нового туннеля

Теперь перейдите в Event Graph и удалите нод SpawnTunnel. Добавьте нод SpawnInitialTunnels после Event BeginPlay.

Нажмите на Compile, вернитесь в основной редактор и нажмите на Play. Теперь туннель стал гораздо длиннее!

Игра пока не очень сложна, так что давайте добавим препятствия.

Создание препятствий

Вот меши, которые мы будем использовать как препятствия:

Откройте BP_Tunnel и перейдите в панель Components. Добавьте компонент Static Mesh и назовите его WallMesh.

Перейдите в панель Details и измените его свойство Static Mesh на SM_Hole_01.

Затем задайте его свойству Location значение (2470, 0, 0), расположив его таким образом в конце туннеля.

Чтобы сделать игру интереснее, стены должны ещё и вращаться. Добавим новую переменную Float и назовём её RotateSpeed. Зададим Default Value значение 30.

Переключитесь в Event Graph и найдите нод Event Tick. Создайте следующую схему:

Это заставит WallMesh поворачиваться каждый кадр на заданную величину.

Нажмите на Compile и вернитесь к основному редактору. Нажмите на Play, чтобы увидеть, как поворачиваются стены.

Давайте сделаем игру ещё интереснее, добавив стенам вариативности.

Создание вариаций стен

Вместо создания нового Blueprint для каждой вариации, мы можем просто рандомизировать WallMesh.

Откройте BP_Tunnel и создайте новую функцию под названием RandomizeWall. Затем создайте следующий граф:

Как следует из названия, нод Set Static Mesh будет задавать WallMesh переданный меш.

Чтобы создать список статичных мешей, можно использовать нод Select.

Перетащите контакт New Mesh. Отпустите левую клавишу мыши на пустом пространстве и добавьте нод Select.

Нод Select позволяет задать список вариантов. Вход Index определяет, какой вариант будет выводить нод Select.


У нас есть четыре меша стен, поэтому нужно создать ещё два контакта Option. Это можно сделать правым щелчком на ноде Select, выбрав Add Option Pin. Повторяйте эту операцию, пока у вас не будет четыре контакта Option.

Теперь задайте каждому варианту следующие значения:

Теперь сделаем так, чтобы выбирался случайный вариант.

Рандомизация стен

Если вы столкнётесь со стеной. то перестанете двигаться вперёд. Однако если продолжите двигаться и пройдёте сквозь отверстие, то снова начнёте двигаться вперёд.

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

Обработка коллизий со стенами

Для включения и отключения движения вперёд можно использовать переменную Boolean. Она имеет всего два состояния: true и false.

Откройте BP_Player и создайте новую переменную Boolean под названием IsDead.

Перейдите к ноду Event Tick и создайте нод Branch.

Теперь получите ссылку на IsDead и соедините его с контактом Condition нода Branch.

Соедините нод Event Tick с нодом Branch. Затем соедините контакт False нода Branch с нодом AddActorWorldOffset.

Теперь когда IsDead равно true, игрок будет останавливаться.

Теперь нужно задавать переменную IsDead, когда игрок сталкивается со стеной.

Задание переменной IsDead

Нажмите на Compile и переключитесь на BP_Tunnel. В панели Components нажмите правой клавишей мыши на WallMesh и выберите Add Event\Add OnComponentHit. Это добавить в Event Graph следующий нод:

Этот нод будет выполняться при столкновении другого Actor с WallMesh.

Во-первых, нам нужно проверить, является ли игроком Actor, столкнувшийся с WallMesh.

Перетащите контакт Other Actor. Отпустите левую клавишу мыши на пустом пространстве и выберите в меню Cast to BP_Player.

Перетащите контакт BP_Player нода Cast to BP_Player. Отпустите левую клавишу на пустом пространстве и добавьте нод Set Is Dead.

Задайте IsDead значение true, поставив флажок.

Нажмите на Compile и вернитесь к основному редактору. Нажмите на Play и попробуйте столкнуться со стеной. Если вы переместитесь к отверстию, то не будете двигаться сквозь него дальше.

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

Отображение кнопки перезапуска

Виджет, который мы будем отображать, называется WBP_Restart. Его можно найти в папке UI. Вот как он выглядит:

Чтобы отобразить или скрыть виджет, нам нужна ссылка на него. Откройте BP_Player и создайте новую переменную RestartWidget. Измените Variable Type на WBP_Restart\Object Reference.

Затем перейдите в Event Graph и найдите нод Event BeginPlay.

Добавьте нод Create Widget и задайте Class значение WBP_Restart.

Теперь добавьте нод Set Restart Widget и соедините всё следующим образом:

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

Создание функции отображения

Создайте новую функцию и назовите её DisplayRestart. Сделав это, создайте следующий граф:

  1. Add to Viewport отображает RestartWidget на экране
  2. Set Input Mode UI Only позволяет игроку взаимодействовать только с UI. Мы делаем так, чтобы игрок не мог перемещаться, пока он мёртв.
  3. Как можно понять из названия, Set Show Mouse Cursor просто отображает курсор мыши

Для отображения кнопки перезапуска нам нужно просто вызывать DisplayRestart после столкновения игрока со стеной.

Вызов функции отображения

Закройте граф DisplayRestart и нажмите на Compile.

Переключитесь на BP_Tunnel и найдите нод On Component Hit (WallMesh).

Добавьте нод DisplayRestart в конец цепочки нодов.

Нажмите на Compile и закройте BP_Tunnel. Вернитесь к основному редактору и нажмите на Play. Когда игрок сталкивается со стеной, отображается кнопка перезапуска.

Последним шагом будет перезапуск игры при нажатии на кнопку.

Перезапуск игры

При перезапуске игра должна выполнять два действия:

  1. Сбрасывать состояние игрока. Это включает в себя и скрытие кнопки перезапуска с экрана.
  2. Повторно создавать туннели. Таким образом игрок стартует с начала туннеля.

Давайте начнём со сброса игрока.

Сброс игрока

Откройте BP_Player и создайте новую функцию RestartGame. Создайте следующий граф:

  1. Set Is Dead присваивает IsDead значение false. Это снова включает возможность движения вперёд.
  2. Remove From Parent удаляет с экрана RestartWidget
  3. Set Input Mode Game Only снова включает возможность управления в игре, чтобы игрок мог перемещаться
  4. Set Show Mouse Cursor скрывает курсор мыши

Теперь нам нужно снова создать туннели.

Повторное создание туннелей

Нажмите на Compile и закройте BP_Player.

Откройте BP_TunnelSpawner и перейдите в граф SpawnInitialTunnels.

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

Добавьте нод Sequence после нода Entry. Соедините контакт Then 1 с нодом ForLoop.

Примечание: нод Sequence выполняет свои выходы в последовательном порядке. Это отличный способ упорядочить граф вертикально, особенно когда цепочки нодов очень длинные.

Затем создайте следующие ноды:

Эта схема получит все существующие туннели и удалит их из игры.

Наконец, соединим контакт Then 0 нода Sequence с нодом Get All Actors of Class. Благодаря этому туннели удалятся до процесса создания.

Вот как выглядит конечный граф:

Последнее, что нужно сделать — обработать нажатие на кнопку.

Обработка нажатий на кнопку

Нажмите на Compile и закройте BP_TunnelSpawner.


Перейдите в Content Browser и найдите папку UI. Дважды щёлкните на WBP_Restart, чтобы открыть его.

Выберите RestartButton и перейдите к панели Details. Перейдите в раздел Events и нажмите на кнопку рядом с OnClicked.

Это создаст нод On Clicked (RestartButton). Этот нод выполняется, когда игрок нажимает на RestartButton.

Воссоздайте следующую схему:

  1. Get Owning Player Pawn возвращает Pawn, которым в текущий момент управляет игрок
  2. Cast to BP_Player проверяет, принадлежит ли Pawn к классу BP_Player
  3. Если это так, то он вызывает функцию RestartGame. Эта функция сбрасывает игрока и скрывает кнопку перезапуска.
  4. Get All Actors of Class и Get возвращает BP_TunnelSpawner и вызывает SpawnInitialTunnels. Эта функция удаляет все существующие туннели и спаунит новые.

Примечание: Вам может быть интересно, почему я не использовал переменную-ссылку для BP_TunnelSpawner. Главная причина заключается в том, что BP_Tunnel не связан с WBP_Restart. Для нашей простой игры проще реализовать такой способ, чем выяснять, где хранить переменную-ссылку.

Нажмите на Compile и закройте Blueprint editor. Нажмите на Play, чтобы проверить работу кнопки перезапуска!

Куда двигаться дальше?

Скачать готовый проект можно здесь.

Теперь, когда у нас есть простая игра, можно начать создавать на её основе что-то ещё. Попробуйте добавить счётчик очков, увеличивающийся, когда игрок избегает столкновения со стеной.

Попробуйте также реализовать простые классические игры типа Pong и Tetris. Механика этих игр проста, но может вызывать сложности в реализации.

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

posix_spawn создает процесс зомби и возвращает успех

Я пытаюсь породить дочерний процесс с posix_spawn() . Я даю имя исполняемого файла (который существует) , но posix_spawn() создает зомби процесс (я ищу процесс , ps и это показывает , как ). Даже когда я указать несуществующий имя исполняемого файла, процесс зомби создается.

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

Вот мой код (PS исполняемый файл «фиктивный» не существует):

При получении статуса:

Дочерний процесс является зомби означает , что он закончил / умер , и вы должны пожинать свой статус выхода с wait/waitpid .

Node.js v13.1.0 Documentation

Table of Contents

Child Process #

The child_process module provides the ability to spawn child processes in a manner that is similar, but not identical, to popen(3) . This capability is primarily provided by the child_process.spawn() function:

By default, pipes for stdin , stdout , and stderr are established between the parent Node.js process and the spawned child. These pipes have limited (and platform-specific) capacity. If the child process writes to stdout in excess of that limit without the output being captured, the child process will block waiting for the pipe buffer to accept more data. This is identical to the behavior of pipes in the shell. Use the < stdio: 'ignore' >option if the output will not be consumed.

The child_process.spawn() method spawns the child process asynchronously, without blocking the Node.js event loop. The child_process.spawnSync() function provides equivalent functionality in a synchronous manner that blocks the event loop until the spawned process either exits or is terminated.

For convenience, the child_process module provides a handful of synchronous and asynchronous alternatives to child_process.spawn() and child_process.spawnSync() . Each of these alternatives are implemented on top of child_process.spawn() or child_process.spawnSync() .

  • child_process.exec() : spawns a shell and runs a command within that shell, passing the stdout and stderr to a callback function when complete.
  • child_process.execFile() : similar to child_process.exec() except that it spawns the command directly without first spawning a shell by default.
  • child_process.fork() : spawns a new Node.js process and invokes a specified module with an IPC communication channel established that allows sending messages between parent and child.
  • child_process.execSync() : a synchronous version of child_process.exec() that will block the Node.js event loop.
  • child_process.execFileSync() : a synchronous version of child_process.execFile() that will block the Node.js event loop.

For certain use cases, such as automating shell scripts, the synchronous counterparts may be more convenient. In many cases, however, the synchronous methods can have significant impact on performance due to stalling the event loop while spawned processes complete.

Asynchronous Process Creation #

The child_process.spawn() , child_process.fork() , child_process.exec() , and child_process.execFile() methods all follow the idiomatic asynchronous programming pattern typical of other Node.js APIs.

Each of the methods returns a ChildProcess instance. These objects implement the Node.js EventEmitter API, allowing the parent process to register listener functions that are called when certain events occur during the life cycle of the child process.

The child_process.exec() and child_process.execFile() methods additionally allow for an optional callback function to be specified that is invoked when the child process terminates.

Spawning .bat and .cmd files on Windows #

The importance of the distinction between child_process.exec() and child_process.execFile() can vary based on platform. On Unix-type operating systems (Unix, Linux, macOS) child_process.execFile() can be more efficient because it does not spawn a shell by default. On Windows, however, .bat and .cmd files are not executable on their own without a terminal, and therefore cannot be launched using child_process.execFile() . When running on Windows, .bat and .cmd files can be invoked using child_process.spawn() with the shell option set, with child_process.exec() , or by spawning cmd.exe and passing the .bat or .cmd file as an argument (which is what the shell option and child_process.exec() do). In any case, if the script filename contains spaces it needs to be quoted.

child_process.exec(command[, options][, callback])[src] #

History

The windowsHide option is supported now.

    command The command to run, with space-separated arguments.
  • cwd Current working directory of the child process. Default: null .
  • env Environment key-value pairs. Default: process.env .
  • encoding Default: ‘utf8’
  • shell Shell to execute the command with. See Shell Requirements and Default Windows Shell. Default: ‘/bin/sh’ on Unix, process.env.ComSpec on Windows.
  • timeout Default: 0
  • maxBuffer Largest amount of data in bytes allowed on stdout or stderr. If exceeded, the child process is terminated and any output is truncated. See caveat at maxBuffer and Unicode. Default: 1024 * 1024 .
  • killSignal | Default: ‘SIGTERM’
  • uid Sets the user identity of the process (see setuid(2) ).
  • gid Sets the group identity of the process (see setgid(2) ).
  • windowsHide Hide the subprocess console window that would normally be created on Windows systems. Default: false .

callback called with the output when process terminates.

Spawns a shell then executes the command within that shell, buffering any generated output. The command string passed to the exec function is processed directly by the shell and special characters (vary based on shell) need to be dealt with accordingly:

Never pass unsanitized user input to this function. Any input containing shell metacharacters may be used to trigger arbitrary command execution.

If a callback function is provided, it is called with the arguments (error, stdout, stderr) . On success, error will be null . On error, error will be an instance of Error . The error.code property will be the exit code of the child process while error.signal will be set to the signal that terminated the process. Any exit code other than 0 is considered to be an error.

The stdout and stderr arguments passed to the callback will contain the stdout and stderr output of the child process. By default, Node.js will decode the output as UTF-8 and pass strings to the callback. The encoding option can be used to specify the character encoding used to decode the stdout and stderr output. If encoding is ‘buffer’ , or an unrecognized character encoding, Buffer objects will be passed to the callback instead.

If timeout is greater than 0 , the parent will send the signal identified by the killSignal property (the default is ‘SIGTERM’ ) if the child runs longer than timeout milliseconds.

Unlike the exec(3) POSIX system call, child_process.exec() does not replace the existing process and uses a shell to execute the command.

If this method is invoked as its util.promisify() ed version, it returns a Promise for an Object with stdout and stderr properties. The returned ChildProcess instance is attached to the Promise as a child property. In case of an error (including any error resulting in an exit code other than 0), a rejected promise is returned, with the same error object given in the callback, but with two additional properties stdout and stderr .

child_process.execFile(file[, args][, options][, callback])[src] #

History

Version Changes
v8.8.0

The windowsHide option is supported now.

  • file The name or path of the executable file to run.
  • args List of string arguments.
  • cwd Current working directory of the child process.
  • env Environment key-value pairs. Default: process.env .
  • encoding Default: ‘utf8’
  • timeout Default: 0
  • maxBuffer Largest amount of data in bytes allowed on stdout or stderr. If exceeded, the child process is terminated and any output is truncated. See caveat at maxBuffer and Unicode. Default: 1024 * 1024 .
  • killSignal | Default: ‘SIGTERM’
  • uid Sets the user identity of the process (see setuid(2) ).
  • gid Sets the group identity of the process (see setgid(2) ).
  • windowsHide Hide the subprocess console window that would normally be created on Windows systems. Default: false .
  • windowsVerbatimArguments No quoting or escaping of arguments is done on Windows. Ignored on Unix. Default: false .
  • shell | If true , runs command inside of a shell. Uses ‘/bin/sh’ on Unix, and process.env.ComSpec on Windows. A different shell can be specified as a string. See Shell Requirements and Default Windows Shell. Default: false (no shell).

callback Called with the output when process terminates.

The child_process.execFile() function is similar to child_process.exec() except that it does not spawn a shell by default. Rather, the specified executable file is spawned directly as a new process making it slightly more efficient than child_process.exec() .

The same options as child_process.exec() are supported. Since a shell is not spawned, behaviors such as I/O redirection and file globbing are not supported.


The stdout and stderr arguments passed to the callback will contain the stdout and stderr output of the child process. By default, Node.js will decode the output as UTF-8 and pass strings to the callback. The encoding option can be used to specify the character encoding used to decode the stdout and stderr output. If encoding is ‘buffer’ , or an unrecognized character encoding, Buffer objects will be passed to the callback instead.

If this method is invoked as its util.promisify() ed version, it returns a Promise for an Object with stdout and stderr properties. The returned ChildProcess instance is attached to the Promise as a child property. In case of an error (including any error resulting in an exit code other than 0), a rejected promise is returned, with the same error object given in the callback, but with two additional properties stdout and stderr .

If the shell option is enabled, do not pass unsanitized user input to this function. Any input containing shell metacharacters may be used to trigger arbitrary command execution.

child_process.fork(modulePath[, args][, options])[src] #

History

Version Changes
v8.8.0

The stdio option can now be a string.

The stdio option is supported now.

  • modulePath The module to run in the child.
  • args List of string arguments.
  • cwd Current working directory of the child process.
  • detached Prepare child to run independently of its parent process. Specific behavior depends on the platform, see options.detached ).
  • env Environment key-value pairs. Default: process.env .
  • execPath Executable used to create the child process.
  • execArgv List of string arguments passed to the executable. Default: process.execArgv .
  • silent If true , stdin, stdout, and stderr of the child will be piped to the parent, otherwise they will be inherited from the parent, see the ‘pipe’ and ‘inherit’ options for child_process.spawn() ‘s stdio for more details. Default: false .
  • stdio | See child_process.spawn() ‘s stdio . When this option is provided, it overrides silent . If the array variant is used, it must contain exactly one item with value ‘ipc’ or an error will be thrown. For instance [0, 1, 2, ‘ipc’] .
  • windowsVerbatimArguments No quoting or escaping of arguments is done on Windows. Ignored on Unix. Default: false .
  • uid Sets the user identity of the process (see setuid(2) ).
  • gid Sets the group identity of the process (see setgid(2) ).
  • Returns:
  • The child_process.fork() method is a special case of child_process.spawn() used specifically to spawn new Node.js processes. Like child_process.spawn() , a ChildProcess object is returned. The returned ChildProcess will have an additional communication channel built-in that allows messages to be passed back and forth between the parent and child. See subprocess.send() for details.

    Keep in mind that spawned Node.js child processes are independent of the parent with exception of the IPC communication channel that is established between the two. Each process has its own memory, with their own V8 instances. Because of the additional resource allocations required, spawning a large number of child Node.js processes is not recommended.

    By default, child_process.fork() will spawn new Node.js instances using the process.execPath of the parent process. The execPath property in the options object allows for an alternative execution path to be used.

    Node.js processes launched with a custom execPath will communicate with the parent process using the file descriptor (fd) identified using the environment variable NODE_CHANNEL_FD on the child process.

    Unlike the fork(2) POSIX system call, child_process.fork() does not clone the current process.

    The shell option available in child_process.spawn() is not supported by child_process.fork() and will be ignored if set.

    child_process.spawn(command[, args][, options])[src] #

    History

    Version Changes
    v8.0.0

    The windowsHide option is supported now.

    The argv0 option is supported now.

    The shell option is supported now.

    • command The command to run.
    • args List of string arguments.
    • cwd Current working directory of the child process.
    • env Environment key-value pairs. Default: process.env .
    • argv0 Explicitly set the value of argv[0] sent to the child process. This will be set to command if not specified.
    • stdio | Child’s stdio configuration (see options.stdio ).
    • detached Prepare child to run independently of its parent process. Specific behavior depends on the platform, see options.detached ).
    • uid Sets the user identity of the process (see setuid(2) ).
    • gid Sets the group identity of the process (see setgid(2) ).
    • shell | If true , runs command inside of a shell. Uses ‘/bin/sh’ on Unix, and process.env.ComSpec on Windows. A different shell can be specified as a string. See Shell Requirements and Default Windows Shell. Default: false (no shell).
    • windowsVerbatimArguments No quoting or escaping of arguments is done on Windows. Ignored on Unix. This is set to true automatically when shell is specified and is CMD. Default: false .
    • windowsHide Hide the subprocess console window that would normally be created on Windows systems. Default: false .
  • Returns:
  • The child_process.spawn() method spawns a new process using the given command , with command line arguments in args . If omitted, args defaults to an empty array.

    If the shell option is enabled, do not pass unsanitized user input to this function. Any input containing shell metacharacters may be used to trigger arbitrary command execution.

    A third argument may be used to specify additional options, with these defaults:

    Use cwd to specify the working directory from which the process is spawned. If not given, the default is to inherit the current working directory.

    Use env to specify environment variables that will be visible to the new process, the default is process.env .

    undefined values in env will be ignored.

    Example of running ls -lh /usr , capturing stdout , stderr , and the exit code:

    Example: A very elaborate way to run ps ax | grep ssh

    Example of checking for failed spawn :

    Certain platforms (macOS, Linux) will use the value of argv[0] for the process title while others (Windows, SunOS) will use command .

    Node.js currently overwrites argv[0] with process.execPath on startup, so process.argv[0] in a Node.js child process will not match the argv0 parameter passed to spawn from the parent, retrieve it with the process.argv0 property instead.

    options.detached #

    On Windows, setting options.detached to true makes it possible for the child process to continue running after the parent exits. The child will have its own console window. Once enabled for a child process, it cannot be disabled.

    On non-Windows platforms, if options.detached is set to true , the child process will be made the leader of a new process group and session. Child processes may continue running after the parent exits regardless of whether they are detached or not. See setsid(2) for more information.

    By default, the parent will wait for the detached child to exit. To prevent the parent from waiting for a given subprocess to exit, use the subprocess.unref() method. Doing so will cause the parent’s event loop to not include the child in its reference count, allowing the parent to exit independently of the child, unless there is an established IPC channel between the child and the parent.

    When using the detached option to start a long-running process, the process will not stay running in the background after the parent exits unless it is provided with a stdio configuration that is not connected to the parent. If the parent’s stdio is inherited, the child will remain attached to the controlling terminal.

    Example of a long-running process, by detaching and also ignoring its parent stdio file descriptors, in order to ignore the parent’s termination:

    Alternatively one can redirect the child process’ output into files:

    options.stdio #

    History

    Version Changes
    v8.8.0

    The value 0 is now accepted as a file descriptor.

    The options.stdio option is used to configure the pipes that are established between the parent and child process. By default, the child’s stdin, stdout, and stderr are redirected to corresponding subprocess.stdin , subprocess.stdout , and subprocess.stderr streams on the ChildProcess object. This is equivalent to setting the options.stdio equal to [‘pipe’, ‘pipe’, ‘pipe’] .

    For convenience, options.stdio may be one of the following strings:

    • ‘pipe’ : equivalent to [‘pipe’, ‘pipe’, ‘pipe’] (the default)
    • ‘ignore’ : equivalent to [‘ignore’, ‘ignore’, ‘ignore’]
    • ‘inherit’ : equivalent to [‘inherit’, ‘inherit’, ‘inherit’] or [0, 1, 2]

    Otherwise, the value of options.stdio is an array where each index corresponds to an fd in the child. The fds 0, 1, and 2 correspond to stdin, stdout, and stderr, respectively. Additional fds can be specified to create additional pipes between the parent and child. The value is one of the following:

    ‘pipe’ : Create a pipe between the child process and the parent process. The parent end of the pipe is exposed to the parent as a property on the child_process object as subprocess.stdio[fd] . Pipes created for fds 0, 1, and 2 are also available as subprocess.stdin , subprocess.stdout and subprocess.stderr , respectively.


    ‘ipc’ : Create an IPC channel for passing messages/file descriptors between parent and child. A ChildProcess may have at most one IPC stdio file descriptor. Setting this option enables the subprocess.send() method. If the child is a Node.js process, the presence of an IPC channel will enable process.send() and process.disconnect() methods, as well as ‘disconnect’ and ‘message’ events within the child.

    Accessing the IPC channel fd in any way other than process.send() or using the IPC channel with a child process that is not a Node.js instance is not supported.

    ‘ignore’ : Instructs Node.js to ignore the fd in the child. While Node.js will always open fds 0, 1, and 2 for the processes it spawns, setting the fd to ‘ignore’ will cause Node.js to open /dev/null and attach it to the child’s fd.

    ‘inherit’ : Pass through the corresponding stdio stream to/from the parent process. In the first three positions, this is equivalent to process.stdin , process.stdout , and process.stderr , respectively. In any other position, equivalent to ‘ignore’ .

    object: Share a readable or writable stream that refers to a tty, file, socket, or a pipe with the child process. The stream’s underlying file descriptor is duplicated in the child process to the fd that corresponds to the index in the stdio array. The stream must have an underlying descriptor (file streams do not until the ‘open’ event has occurred).

    Positive integer: The integer value is interpreted as a file descriptor that is currently open in the parent process. It is shared with the child process, similar to how objects can be shared. Passing sockets is not supported on Windows.

    null , undefined : Use default value. For stdio fds 0, 1, and 2 (in other words, stdin, stdout, and stderr) a pipe is created. For fd 3 and up, the default is ‘ignore’ .

    It is worth noting that when an IPC channel is established between the parent and child processes, and the child is a Node.js process, the child is launched with the IPC channel unreferenced (using unref() ) until the child registers an event handler for the ‘disconnect’ event or the ‘message’ event. This allows the child to exit normally without the process being held open by the open IPC channel.

    On Unix-like operating systems, the child_process.spawn() method performs memory operations synchronously before decoupling the event loop from the child. Applications with a large memory footprint may find frequent child_process.spawn() calls to be a bottleneck. For more information, see V8 issue 7381.

    Synchronous Process Creation #

    The child_process.spawnSync() , child_process.execSync() , and child_process.execFileSync() methods are synchronous and will block the Node.js event loop, pausing execution of any additional code until the spawned process exits.

    Blocking calls like these are mostly useful for simplifying general-purpose scripting tasks and for simplifying the loading/processing of application configuration at startup.

    child_process.execFileSync(file[, args][, options])[src] #

    History

    Version Changes
    v3.3.1

    The input option can now be any TypedArray or a DataView .

    The windowsHide option is supported now.

    The input option can now be a Uint8Array .

    The encoding option can now explicitly be set to buffer .

    Added in: v0.11.12

    • file The name or path of the executable file to run.
    • args List of string arguments.
    • cwd Current working directory of the child process.
    • input | | | The value which will be passed as stdin to the spawned process. Supplying this value will override stdio[0] .
    • stdio | Child’s stdio configuration. stderr by default will be output to the parent process’ stderr unless stdio is specified. Default: ‘pipe’ .
    • env Environment key-value pairs. Default: process.env .
    • uid Sets the user identity of the process (see setuid(2) ).
    • gid Sets the group identity of the process (see setgid(2) ).
    • timeout In milliseconds the maximum amount of time the process is allowed to run. Default: undefined .
    • killSignal | The signal value to be used when the spawned process will be killed. Default: ‘SIGTERM’ .
    • maxBuffer Largest amount of data in bytes allowed on stdout or stderr. If exceeded, the child process is terminated. See caveat at maxBuffer and Unicode. Default: 1024 * 1024 .
    • encoding The encoding used for all stdio inputs and outputs. Default: ‘buffer’ .
    • windowsHide Hide the subprocess console window that would normally be created on Windows systems. Default: false .
    • shell | If true , runs command inside of a shell. Uses ‘/bin/sh’ on Unix, and process.env.ComSpec on Windows. A different shell can be specified as a string. See Shell Requirements and Default Windows Shell. Default: false (no shell).
  • Returns: | The stdout from the command.
  • The child_process.execFileSync() method is generally identical to child_process.execFile() with the exception that the method will not return until the child process has fully closed. When a timeout has been encountered and killSignal is sent, the method won’t return until the process has completely exited.

    If the child process intercepts and handles the SIGTERM signal and does not exit, the parent process will still wait until the child process has exited.

    If the process times out or has a non-zero exit code, this method will throw an Error that will include the full result of the underlying child_process.spawnSync() .

    If the shell option is enabled, do not pass unsanitized user input to this function. Any input containing shell metacharacters may be used to trigger arbitrary command execution.

    child_process.execSync(command[, options])[src] #

    History

    Version Changes
    v10.10.0

    The input option can now be any TypedArray or a DataView .

    The windowsHide option is supported now.

    The input option can now be a Uint8Array .

    Added in: v0.11.12

      command The command to run.
    • cwd Current working directory of the child process.
    • input | | | The value which will be passed as stdin to the spawned process. Supplying this value will override stdio[0] .
    • stdio | Child’s stdio configuration. stderr by default will be output to the parent process’ stderr unless stdio is specified. Default: ‘pipe’ .
    • env Environment key-value pairs. Default: process.env .
    • shell Shell to execute the command with. See Shell Requirements and Default Windows Shell. Default: ‘/bin/sh’ on Unix, process.env.ComSpec on Windows.
    • uid Sets the user identity of the process. (See setuid(2) ).
    • gid Sets the group identity of the process. (See setgid(2) ).
    • timeout In milliseconds the maximum amount of time the process is allowed to run. Default: undefined .
    • killSignal | The signal value to be used when the spawned process will be killed. Default: ‘SIGTERM’ .
    • maxBuffer Largest amount of data in bytes allowed on stdout or stderr. If exceeded, the child process is terminated and any output is truncated. See caveat at maxBuffer and Unicode. Default: 1024 * 1024 .
    • encoding The encoding used for all stdio inputs and outputs. Default: ‘buffer’ .
    • windowsHide Hide the subprocess console window that would normally be created on Windows systems. Default: false .
  • Returns: | The stdout from the command.
  • The child_process.execSync() method is generally identical to child_process.exec() with the exception that the method will not return until the child process has fully closed. When a timeout has been encountered and killSignal is sent, the method won’t return until the process has completely exited. If the child process intercepts and handles the SIGTERM signal and doesn’t exit, the parent process will wait until the child process has exited.

    If the process times out or has a non-zero exit code, this method will throw. The Error object will contain the entire result from child_process.spawnSync() .

    Never pass unsanitized user input to this function. Any input containing shell metacharacters may be used to trigger arbitrary command execution.

    child_process.spawnSync(command[, args][, options])[src] #

    History

    Version Changes
    v10.10.0

    The input option can now be any TypedArray or a DataView .

    The windowsHide option is supported now.

    The input option can now be a Uint8Array .

    The encoding option can now explicitly be set to buffer .

    The shell option is supported now.

    Added in: v0.11.12

    • command The command to run.
    • args List of string arguments.
    • cwd Current working directory of the child process.
    • input | | | The value which will be passed as stdin to the spawned process. Supplying this value will override stdio[0] .
    • argv0 Explicitly set the value of argv[0] sent to the child process. This will be set to command if not specified.
    • stdio | Child’s stdio configuration.
    • env Environment key-value pairs. Default: process.env .
    • uid Sets the user identity of the process (see setuid(2) ).
    • gid Sets the group identity of the process (see setgid(2) ).
    • timeout In milliseconds the maximum amount of time the process is allowed to run. Default: undefined .
    • killSignal | The signal value to be used when the spawned process will be killed. Default: ‘SIGTERM’ .
    • maxBuffer Largest amount of data in bytes allowed on stdout or stderr. If exceeded, the child process is terminated and any output is truncated. See caveat at maxBuffer and Unicode. Default: 1024 * 1024 .
    • encoding The encoding used for all stdio inputs and outputs. Default: ‘buffer’ .
    • shell | If true , runs command inside of a shell. Uses ‘/bin/sh’ on Unix, and process.env.ComSpec on Windows. A different shell can be specified as a string. See Shell Requirements and Default Windows Shell. Default: false (no shell).
    • windowsVerbatimArguments No quoting or escaping of arguments is done on Windows. Ignored on Unix. This is set to true automatically when shell is specified and is CMD. Default: false .
    • windowsHide Hide the subprocess console window that would normally be created on Windows systems. Default: false .


    The child_process.spawnSync() method is generally identical to child_process.spawn() with the exception that the function will not return until the child process has fully closed. When a timeout has been encountered and killSignal is sent, the method won’t return until the process has completely exited. If the process intercepts and handles the SIGTERM signal and doesn’t exit, the parent process will wait until the child process has exited.

    If the shell option is enabled, do not pass unsanitized user input to this function. Any input containing shell metacharacters may be used to trigger arbitrary command execution.

    Class: ChildProcess #

    Instances of the ChildProcess represent spawned child processes.

    Instances of ChildProcess are not intended to be created directly. Rather, use the child_process.spawn() , child_process.exec() , child_process.execFile() , or child_process.fork() methods to create instances of ChildProcess .

    Event: ‘close’ #

    • code The exit code if the child exited on its own.
    • signal The signal by which the child process was terminated.

    The ‘close’ event is emitted when the stdio streams of a child process have been closed. This is distinct from the ‘exit’ event, since multiple processes might share the same stdio streams.

    Event: ‘disconnect’ #

    The ‘disconnect’ event is emitted after calling the subprocess.disconnect() method in parent process or process.disconnect() in child process. After disconnecting it is no longer possible to send or receive messages, and the subprocess.connected property is false .

    Event: ‘error’ #

    • err The error.

    The ‘error’ event is emitted whenever:

    1. The process could not be spawned, or
    2. The process could not be killed, or
    3. Sending a message to the child process failed.

    The ‘exit’ event may or may not fire after an error has occurred. When listening to both the ‘exit’ and ‘error’ events, guard against accidentally invoking handler functions multiple times.

    Event: ‘exit’ #

    • code The exit code if the child exited on its own.
    • signal The signal by which the child process was terminated.

    The ‘exit’ event is emitted after the child process ends. If the process exited, code is the final exit code of the process, otherwise null . If the process terminated due to receipt of a signal, signal is the string name of the signal, otherwise null . One of the two will always be non-null.

    When the ‘exit’ event is triggered, child process stdio streams might still be open.

    Node.js establishes signal handlers for SIGINT and SIGTERM and Node.js processes will not terminate immediately due to receipt of those signals. Rather, Node.js will perform a sequence of cleanup actions and then will re-raise the handled signal.

    Event: ‘message’ #

    • message A parsed JSON object or primitive value.
    • sendHandle A net.Socket or net.Server object, or undefined.

    The ‘message’ event is triggered when a child process uses process.send() to send messages.

    The message goes through serialization and parsing. The resulting message might not be the same as what is originally sent.

    subprocess.channel #

    • A pipe representing the IPC channel to the child process.

    The subprocess.channel property is a reference to the child’s IPC channel. If no IPC channel currently exists, this property is undefined .

    subprocess.connected #

    • Set to false after subprocess.disconnect() is called.

    The subprocess.connected property indicates whether it is still possible to send and receive messages from a child process. When subprocess.connected is false , it is no longer possible to send or receive messages.

    subprocess.disconnect() #

    Closes the IPC channel between parent and child, allowing the child to exit gracefully once there are no other connections keeping it alive. After calling this method the subprocess.connected and process.connected properties in both the parent and child (respectively) will be set to false , and it will be no longer possible to pass messages between the processes.

    The ‘disconnect’ event will be emitted when there are no messages in the process of being received. This will most often be triggered immediately after calling subprocess.disconnect() .

    When the child process is a Node.js instance (e.g. spawned using child_process.fork() ), the process.disconnect() method can be invoked within the child process to close the IPC channel as well.

    subprocess.kill([signal]) #

    The subprocess.kill() method sends a signal to the child process. If no argument is given, the process will be sent the ‘SIGTERM’ signal. See signal(7) for a list of available signals.

    The ChildProcess object may emit an ‘error’ event if the signal cannot be delivered. Sending a signal to a child process that has already exited is not an error but may have unforeseen consequences. Specifically, if the process identifier (PID) has been reassigned to another process, the signal will be delivered to that process instead which can have unexpected results.

    While the function is called kill , the signal delivered to the child process may not actually terminate the process.

    See kill(2) for reference.

    On Linux, child processes of child processes will not be terminated when attempting to kill their parent. This is likely to happen when running a new process in a shell or with the use of the shell option of ChildProcess :

    subprocess.killed #

    • Set to true after subprocess.kill() is used to successfully send a signal to the child process.

    The subprocess.killed property indicates whether the child process successfully received a signal from subprocess.kill() . The killed property does not indicate that the child process has been terminated.


    subprocess.pid #

    Returns the process identifier (PID) of the child process.

    subprocess.ref() #

    Calling subprocess.ref() after making a call to subprocess.unref() will restore the removed reference count for the child process, forcing the parent to wait for the child to exit before exiting itself.

    subprocess.send(message[, sendHandle[, options]][, callback]) #

    History

    Version Changes
    v10.10.0

    The options parameter, and the keepOpen option in particular, is supported now.

    This method returns a boolean for flow control now.

    The callback parameter is supported now.

    • message
    • sendHandle

    options The options argument, if present, is an object used to parameterize the sending of certain types of handles. options supports the following properties:

    • keepOpen A value that can be used when passing instances of net.Socket . When true , the socket is kept open in the sending process. Default: false .
  • callback
  • Returns:
  • When an IPC channel has been established between the parent and child ( i.e. when using child_process.fork() ), the subprocess.send() method can be used to send messages to the child process. When the child process is a Node.js instance, these messages can be received via the ‘message’ event.

    The message goes through serialization and parsing. The resulting message might not be the same as what is originally sent.

    For example, in the parent script:

    And then the child script, ‘sub.js’ might look like this:

    Child Node.js processes will have a process.send() method of their own that allows the child to send messages back to the parent.

    There is a special case when sending a message. Messages containing a NODE_ prefix in the cmd property are reserved for use within Node.js core and will not be emitted in the child’s ‘message’ event. Rather, such messages are emitted using the ‘internalMessage’ event and are consumed internally by Node.js. Applications should avoid using such messages or listening for ‘internalMessage’ events as it is subject to change without notice.

    The optional sendHandle argument that may be passed to subprocess.send() is for passing a TCP server or socket object to the child process. The child will receive the object as the second argument passed to the callback function registered on the ‘message’ event. Any data that is received and buffered in the socket will not be sent to the child.

    The optional callback is a function that is invoked after the message is sent but before the child may have received it. The function is called with a single argument: null on success, or an Error object on failure.

    If no callback function is provided and the message cannot be sent, an ‘error’ event will be emitted by the ChildProcess object. This can happen, for instance, when the child process has already exited.

    subprocess.send() will return false if the channel has closed or when the backlog of unsent messages exceeds a threshold that makes it unwise to send more. Otherwise, the method returns true . The callback function can be used to implement flow control.

    Example: sending a server object #

    The sendHandle argument can be used, for instance, to pass the handle of a TCP server object to the child process as illustrated in the example below:

    The child would then receive the server object as:

    Once the server is now shared between the parent and child, some connections can be handled by the parent and some by the child.

    While the example above uses a server created using the net module, dgram module servers use exactly the same workflow with the exceptions of listening on a ‘message’ event instead of ‘connection’ and using server.bind() instead of server.listen() . This is, however, currently only supported on Unix platforms.

    Example: sending a socket object #

    Similarly, the sendHandler argument can be used to pass the handle of a socket to the child process. The example below spawns two children that each handle connections with «normal» or «special» priority:

    The subprocess.js would receive the socket handle as the second argument passed to the event callback function:

    Once a socket has been passed to a child, the parent is no longer capable of tracking when the socket is destroyed. To indicate this, the .connections property becomes null . It is recommended not to use .maxConnections when this occurs.

    It is also recommended that any ‘message’ handlers in the child process verify that socket exists, as the connection may have been closed during the time it takes to send the connection to the child.

    subprocess.stderr #

    A Readable Stream that represents the child process’s stderr .

    If the child was spawned with stdio[2] set to anything other than ‘pipe’ , then this will be null .

    subprocess.stderr is an alias for subprocess.stdio[2] . Both properties will refer to the same value.

    subprocess.stdin #

    A Writable Stream that represents the child process’s stdin .

    If a child process waits to read all of its input, the child will not continue until this stream has been closed via end() .

    If the child was spawned with stdio[0] set to anything other than ‘pipe’ , then this will be null .

    subprocess.stdin is an alias for subprocess.stdio[0] . Both properties will refer to the same value.

    subprocess.stdio #

    A sparse array of pipes to the child process, corresponding with positions in the stdio option passed to child_process.spawn() that have been set to the value ‘pipe’ . subprocess.stdio[0] , subprocess.stdio[1] , and subprocess.stdio[2] are also available as subprocess.stdin , subprocess.stdout , and subprocess.stderr , respectively.

    In the following example, only the child’s fd 1 (stdout) is configured as a pipe, so only the parent’s subprocess.stdio[1] is a stream, all other values in the array are null .

    subprocess.stdout #

    A Readable Stream that represents the child process’s stdout .

    If the child was spawned with stdio[1] set to anything other than ‘pipe’ , then this will be null .

    Spawn создать процесс

    _spawn, _wspawn Functions

    Each of the _spawn functions creates and executes a new process:

    The letters at the end of the function name determine the variation.

    Version Changes
    v5.8.0
    Letter Variant
    e envp , array of pointers to environment settings, is passed to new process.
    l Command-line arguments are passed individually to _spawn function. This suffix is typically used when a number of parameters to a new process is known in advance.
    p PATH environment variable is used to find the file to execute.
    v argv , array of pointers to command-line arguments, is passed to _spawn function. This suffix is typically used when a number of parameters to a new process is variable.

    The _spawn functions each create and execute a new process. They automatically handle multibyte-character string arguments as appropriate, recognizing multibyte-character sequences according to the multibyte code page currently in use. The _wspawn functions are wide-character versions of the _spawn functions; they do not handle multibyte-character strings. Otherwise, the _wspawn functions behave identically to their _spawn counterparts.

    Generic-Text Routine Mappings

    Tchar.h routine _UNICODE and _MBCS not defined _MBCS defined _UNICODE defined
    _tspawnl _spawnl _spawnl _wspawnl
    _tspawnle _spawnle _spawnle _wspawnle
    _tspawnlp _spawnlp _spawnlp _wspawnlp
    _tspawnlpe _spawnlpe _spawnlpe _wspawnlpe
    _tspawnv _spawnv _spawnv _wspawnv
    _tspawnve _spawnve _spawnve _wspawnve
    _tspawnvp _spawnvp _spawnvp _wspawnvp
    _tspawnvpe _spawnvpe _spawnvpe _wspawnvpe

    Enough memory must be available for loading and executing the new process. The mode argument determines the action taken by the calling process before and during _spawn . The following values for mode are defined in Process.h:

    _P_OVERLAY Overlays a calling process with a new process, destroying the calling process (same effect as _exec calls).
    _P_WAIT Suspends a calling thread until execution of the new process is complete (synchronous _spawn ).
    _P_NOWAIT or _P_NOWAITO Continues to execute a calling process concurrently with the new process (asynchronous _spawn ).
    _P_DETACH Continues to execute the calling process; the new process is run in the background with no access to the console or keyboard. Calls to _cwait against the new process fail (asynchronous _spawn ).

    The cmdname argument specifies the file that is executed as the new process and can specify a full path (from the root), a partial path (from the current working directory), or just a file name. If cmdname does not have a file name extension or does not end with a period (.), the _spawn function first tries the .com file name extension and then the .exe file name extension, the .bat file name extension, and finally the .cmd file name extension.

    If cmdname has a file name extension, only that extension is used. If cmdname ends with a period, the _spawn call searches for cmdname with no file name extension. The _spawnlp , _spawnlpe , _spawnvp , and _spawnvpe functions search for cmdname (using the same procedures) in the directories specified by the PATH environment variable.

    If cmdname contains a drive specifier or any slashes (that is, if it is a relative path), the _spawn call searches only for the specified file; no path searching is done.

    In the past, some of these functions set errno to zero on success; the current behavior is to leave errno untouched on success, as specified by the C standard. If you need to emulate the old behavior, set errno to zero just before calling these functions.

    [!NOTE] To ensure proper overlay initialization and termination, do not use the setjmp or longjmp function to enter or leave an overlay routine.

    Arguments for the Spawned Process

    To pass arguments to the new process, give one or more pointers to character strings as arguments in the _spawn call. These character strings form the argument list for the spawned process. The combined length of the strings forming the argument list for the new process must not exceed 1024 bytes. The terminating null character (‘\0’) for each string is not included in the count, but space characters (automatically inserted to separate arguments) are included.

    [!NOTE] Spaces embedded in strings may cause unexpected behavior; for example, passing _spawn the string «hi there» will result in the new process getting two arguments, «hi» and «there» . If the intent was to have the new process open a file named «hi there», the process would fail. You can avoid this by quoting the string: «\»hi there\»» .

    [!IMPORTANT] Do not pass user input to _spawn without explicitly checking its content. _spawn will result in a call to CreateProcess so keep in mind that unqualified path names could lead to potential security vulnerabilities.

    You can pass argument pointers as separate arguments (in _spawnl , _spawnle , _spawnlp , and _spawnlpe ) or as an array of pointers (in _spawnv , _spawnve , _spawnvp , and _spawnvpe ). You must pass at least one argument, arg0 or argv [0], to the spawned process. By convention, this argument is the name of the program as you would type it on the command line. A different value does not produce an error.

    The _spawnl , _spawnle , _spawnlp , and _spawnlpe calls are typically used in cases where the number of arguments is known in advance. The arg0 argument is usually a pointer to cmdname . The arguments arg1 through argn are pointers to the character strings forming the new argument list. Following argn , there must be a NULL pointer to mark the end of the argument list.

    The _spawnv , _spawnve , _spawnvp , and _spawnvpe calls are useful when there is a variable number of arguments to the new process. Pointers to the arguments are passed as an array, argv . The argument argv [0] is usually a pointer to a path in real mode or to the program name in protected mode, and argv [1] through argv [ n ] are pointers to the character strings forming the new argument list. The argument argv [ n +1] must be a NULL pointer to mark the end of the argument list.

    Environment of the Spawned Process

    Files that are open when a _spawn call is made remain open in the new process. In the _spawnl , _spawnlp , _spawnv , and _spawnvp calls, the new process inherits the environment of the calling process. You can use the _spawnle , _spawnlpe , _spawnve , and _spawnvpe calls to alter the environment for the new process by passing a list of environment settings through the envp argument. The argument envp is an array of character pointers, each element (except the final element) of which points to a null-terminated string defining an environment variable. Such a string usually has the form NAME = value where NAME is the name of an environment variable and value is the string value to which that variable is set. (Note that value is not enclosed in double quotation marks.) The final element of the envp array should be NULL. When envp itself is NULL, the spawned process inherits the environment settings of the parent process.

    The _spawn functions can pass all information about open files, including the translation mode, to the new process. This information is passed in real mode through the C_FILE_INFO entry in the environment. The startup code normally processes this entry and then deletes it from the environment. However, if a _spawn function spawns a non-C process, this entry remains in the environment. Printing the environment shows graphics characters in the definition string for this entry because the environment information is passed in binary form in real mode. It should not have any other effect on normal operations. In protected mode, the environment information is passed in text form and therefore contains no graphics characters.

    You must explicitly flush (using fflush or _flushall ) or close any stream before calling a _spawn function.

    New processes created by calls to _spawn routines do not preserve signal settings. Instead, the spawned process resets signal settings to the default.

    If you are calling _spawn from a DLL or a GUI application and want to redirect the output to a pipe, you have two options:

    Use the Win32 API to create a pipe, then call AllocConsole, set the handle values in the startup structure, and call CreateProcess.

    Пример использования команды spawn()

    Доброго времени суток, не могли бы вы дать мне пример использования команды Spawn() для создания нового процесса. И по возможности описать аргументы, которые она принимает.

    Искал в интернете информацию, но пример не могу найти.

    15.11.2020, 19:06

    Пример использования свойства
    Приведите, пожалуйста, пример использования свойства all. Не могу найти,что это такое.

    Пример использования OemToChar.
    Создаю текстовый файл. В него все пишется в виндовой кодировке, а мне надо в DOS. Спасибо.

    Пример использования TExcelChart
    Если кто-нибудь когда-нибудь использовал этот компонент у себя, подскажите, пожалуйста, где можно.

    Пример использования CreatePipe
    всем привет, подскажите ктонибуть работал с функцией CreatePipe, это перенаправление ввода вывода .

    Пример использования Cookie
    Не получается. Пришлите пожалуйста хотя бы малюсенький примерчик использования Cookie. Но не.

    Илон Маск рекомендует:  Приложеhие доказательство декодиpующего неpавенства
    Понравилась статья? Поделиться с друзьями:
    Кодинг, CSS и SQL