عرض مصدر Node.js/process

<noinclude>{{DISPLAYTITLE:الكائن Process}}</noinclude>

يكون الكائن <code>process</code> عامًا (<code>global</code>) والذي يزود معلومات عن عملية Node.js الحالية ورقابةً عليها، كونه كائنًا عامًا فهو متوافر دومًا لتطبيقات Node.js دون استخدام <code>()require</code>.

==أحداث Process==
الكائن <code>process</code> هو نسخة من [[Node.js/events#.D8.A7.D9.84.D8.B5.D9.86.D9.81: EventEmitter|EventEmitter]].

=== الحدث <code>'beforeExit'</code> ===
أُضيف في الإصدار: 0.11.12.

يُطلَق الحدث <code>'beforeExit'</code> عندما تفرغ Node.js من حلقة الأحداث (event loop) ولا يوجد عمل إضافي لجدولته. بشكل طبيعي، عملية Node.js سوف تنتهي عندما لا يكون هناك عمل مجدولٌ، لكن المُنصِت المسجِّل لحدث <code>'beforeExit'</code> يمكن أن يعمل استدعاءات غير متزامنة، وبذلك يسبب استمرار عملية Node.js .

تُستدعى دالة رد نداء المنصت مع قيمة [[Node.js/process#process.exitCode|process.exitCode]] المُمررة كوسيط وحيد.

لا يُطلَق الحدث <code>'beforeExit'</code> لأجل حالات تسبب إنهاء صريح، مثل استدعاء [[Node.js/process#process.exit.28.5Bcode.E2.80.8E.5D.E2.80.8E.29.E2.80.8E|()process.exit]] أو استثناءات غير مُلتقطة.

لا ينبغي أن يُستخدم 'beforeExit' كبديل للحدث <code>'exit'</code> إلّا إذا كان القصد هو جدولة عمل إضافي.
===الحدث <code>'disconnect'</code>===
أُضيف في الإصدار: 0.7.7.

إذا وُلِّدت عملية Node.js عبر قناة الاتصالات ما بين العمليات IPC (انظر توثيق [[Node.js/child process|Child Process]] و Cluster)، سوف يُطلَق الحدث <code>'disconnect'</code> عندما تُغلق قناة IPC.
===الحدث <code>'exit'</code>===
أُضيف في الإصدار: 0.1.7.
*<code>code</code>‏ ‎[[Javascript/integer|<integer>]]‎
يُطلَق الحدث <code>'exit'</code> عندما تكون عملية Node.js على وشك الخروج كنتيجة لأحد أمرين:
*استدعاء التابع <code>()process.exit</code> بشكل صريح؛
*لم تعد تحوي حلقة أحداث Node.js أي عمل إضافي ليُنجز.
لا توجد طريقة لمنع خروج حلقة الأحداث في هذه النقطة، وحالما ينتهي تنفيذ كل مُنصتات <code>'exit'</code> سوف تنتهي عملية Node.js.

تُستدعى دالة رد النداء مع حالة الخروج؛ إمّا بخاصية [[Node.js/process#process.exitCode|process.exitCode]] أو بوسيط <code>exitCode</code> المُمرر للتابع [[Node.js/process#process.exit.28.5Bcode.E2.80.8E.5D.E2.80.8E.29.E2.80.8E|process.exit(‎)‎]].<syntaxhighlight lang="javascript">
process.on('exit', (code) => {
  console.log(`About to exit with code: ${code}`);
});

</syntaxhighlight>دوال المُنصت يجب أن تُنجِز عمليات متزامنة فقط. سوف تنتهي عملية Node.js مباشرةً بعد استدعاء مُنصتات الحدث <code>'exit'</code> متسببًة بتجاهل أي عمل إضافي بقي في طابور حلقة الأحداث. في المثال التالي لن يُنفَّذ ما ضمن الدالة setTimeout:<syntaxhighlight lang="javascript">
process.on('exit', (code) => {
  setTimeout(() => {
    console.log('This will not run');
  }, 0);
});
</syntaxhighlight>
===الحدث 'message'===
أُضيف في الإصدار: 0.5.10.
*<code>message</code>‏ ‎[[JavaScript/Object|<Object>]] | [[JavaScript/Boolean|<boolean>]] | [[JavaScript/Number|<number>]] | [[JavaScript/String|<string>]] | [[JavaScript/null|<null>]]‎: كائن JASON مُحلل نحويًا أو قيمة أولية متسلسلة (serializable primitive value).

*<code>sendHandle</code>‏ ‎‎[[net.server|<‎net.Server‎>]] ‎| ‎[[net.socket|<net.Socket‎‎>]]‎ : كائن [[net.Server]] أو [[net.Socket]] أو undefined.
إذا وُلِّدت عملية Node.js عبر قناة الاتصالات ما بين العمليات IPC (انظر توثيق [[Node.js/child process|Child Process]] و [[Node.js/cluster|Cluster]])، يُطلِق الحدث <code>'message'</code> حالما تُستقبل الرسالة المُرسلة بواسطة العملية الأب باستخدام [[Node.js/child process#subprocess.send.28message.5B.2C sendHandle.5B.2C options.5D.5D.5B.2C callback.5D.29.E2.80.8E|()childprocess.send]] من قبل العملية الابن.

تمر الرسالة عبر مراحل التسلسل والتحليل النحوي، لذا قد لا تكون الرسالة الناتجة مثل الأصل الذي أُرسِل.
===الحدث 'rejectionHandled'===
أُضيف في الإصدار: 1.4.1.
*<code>promise</code>‏ ‏[[Node.js/Promise|<Promise>]]: الوعد المُعالج المتأخر.
يُطلَق الحدث <code>'rejectionHandled'</code> كلما رُفض الوعد <code>Promise</code> وأُرفق بمُعالج الأخطاء (على سبيل المثال، باستخدام [[Node.js/Promise#catch|()promise.catch]]) متأخرةً عن حلقة أحداث Node.js بدور واحد.

سيكون الكائن <code>Promise</code> مُطلَقًا سابقًا في الحدث <code>'unhandledRejection'</code>، لكن خلال دورة المعالجة حصل على مُعالِج الرفض.

لا يوجد دليل على مستوى عالي لأجل سلسلة <code>Promise</code> التي ستُعالج فيها المرفوضات دائمًا، كونها أصلاً غير متزامنة بطبيعتها، فيمكن أن يُعالج رفض <code>Promise</code> في نقطة مستقبلية في الزمن- ربما (المُعالجة) متأخرةً بكثير عن دور حلقة الأحداث الذي يأخذه حدث <code>'unhandledRejection'</code> ليُطلق.

طريقة ثانية للتعبير عن ذلك، غير شبيهة بالشيفرة المتزامنة و حيث يوجد لائحة متزايدة دومًا من الاستثناءات غير المُعالجة، في الوعود Promises يمكن أن يكون هناك لائحة متزايدة-و-متناقصة من الرفض غير المُعَالج.

في الشيفرة المتزامنة، يُطلَق الحدث <code>'uncaughtException'</code> عندما تزداد لائحة الاستثناءات غير المعالجة.

في الشيفرة غير المتزامنة يُطلَق الحدث <code>'unhandledRejection'</code> عندما تزداد لائحة المرفوضات غير المُعالجة، ويُطلَق الحدث <code>'rejectionHandled'</code> عندما تتناقص لائحة المرفوضات غير المُعالجة.<syntaxhighlight lang="javascript">
const unhandledRejections = new Map();
process.on('unhandledRejection', (reason, promise) => {
  unhandledRejections.set(promise, reason);
});
process.on('rejectionHandled', (promise) => {
  unhandledRejections.delete(promise);
});
</syntaxhighlight>في هذا المثال، سوف تزداد <code>Map</code> (خريطة) <code>unhandledRejections</code> وتتناقص بمرور الوقت، عاكسةً المرفوضات التي بدأت غير مُعالجة ثم أصبحت مُعالجة، من الممكن تسجيل مثل هذه الأخطاء في سجل أخطاء، إمّا دوريًا (والذي يبدو الأفضل من أجل التطبيقات طويلة التشغيل)أو عند خروج العملية (والذي يبدو الأنسب للبرامج النصية scripts).
===الحدث <code>'uncaughtException'</code>===
أُضيف في الإصدار: 0.1.18.

يُطلق الحدث <code>'uncaughtException'</code>  عندما تصعد استثناءات JavaScript غير المُلتقطة إلى حلقة الأحداث (event loop) في Node.js. بشكل افتراضي، تعالج Node.js مثل هذه الاستثناءات بطباعة التتبع التكديسي (stack trace) إلى مجرى الخطأ القياسي، <code>stderr</code> والخروج من العملية مع حالة الخروج 1. متجاوزةً أي تهيئة سابقة للخاصية [[Node.js/process#process.exitCode|process.exitCode]]. إضافة معالج للحدث <code>'uncaughtException'</code> يعيد تعريف سلوكه الافتراضي. قد تُغيِّر أنت أيضًا الخاصية [[Node.js/process#process.exitCode|process.exitCode]] في معالج <code>'uncaughtException'</code> مما سيؤدي إلى إنهاء العملية مع حالة الخروج المُحدَّدة، وإذا لم يوجد مثل هذا المعالج فسوف تخرج العملية مع حالة الخروج 0.

يُستدعى تابع المنصت مع الكائن <code>Error</code> المُمرر كوسيط وحيد.<syntaxhighlight lang="javascript">
process.on('uncaughtException', (err) => {
  fs.writeSync(1, `Caught exception: ${err}\n`);
});

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

// تسبب استثناء عمداَ ولكن لا تُمسكه
nonexistentFunc();
console.log('This will not run.');
</syntaxhighlight>
====تحذير: استخدام <code>'uncaughtException'</code> بشكل صحيح====
لاحظ أنّ <code>'uncaughtException'</code> هو آلية خام لمعالجة الاستثناء ويُعتمد استخدامها فقط كحل أخير. لا ينبغي أن يستخدم هذا الحدث كبديل لآلية <code>On Error Resume Next</code>. الاستثناءات غير المعالجة الموروثة تعني أن التطبيق في حالة غير مُعرّفة. السعي لاستئناف شيفرة التطبيق بدون الاستعادة الصحيحة من الاستثناء قد تسبب أمور إضافية طارئة ولا يمكن التنبؤ بها.

الاستثناءات المرمية من داخل مُعالج الأحداث لا يمكن التقاطها، عوضًا عن ذلك ستنتهي العملية بحالة خروج غير صفرية وسوف يُطبع نص تتبع المكدس. هذا من أجل تفادي التعاودية اللا متناهية.

محاولة الاستئناف الطبيعي بعد الاستثناء غير المُلتقط يمكن أن تكون شبيهة بسحب كبل الطاقة عند تحديث الحاسوب- تسعة مرات من عشرة لن يحصل شيء- لكن في المرة العاشرة، سيصبح النظام تالفًا.

الاستخدام الصحيح للحدث <code>'uncaughtException'</code> هو إجراء تنظيف متزامن للموارد المحجوزة (على سبيل المثال، واصفات الملفات، المُعالجات/المقابض، ...إلخ.) قبل إيقاف تشغيل العملية. '''ليس من الآمن استئناف عملية عادية بعد <code>'uncaughtException'</code>'''.

لإعادة تشغيل تطبيق معطّل بطريقة أكثر موثوقيةً، سواءً كان <code>'uncaughtException'</code> مُطلقًا أو لا، ينبغي توظيف مراقب خارجي في عملية منفصلة لكشف فشل التطبيق والاستعادة أو إعادة التشغيل حسب الحاجة.
===الحدث: <code>'unhandledRejection'</code>===
سجل التغييرات
{| class="wikitable"
!الإصدار
!التغييرات
|-
|7.0.0.
|أُهمِلَت مرفوضات <code>Promise</code> غير المُعالجة.
|-
|6.6.0.
|مرفوضات <code>Promise</code> غير المُعالجة سوف تبعث الآن تحذير process warning.
|-
|1.4.1.
|أُضيف في الإصدار 1.4.1.
|}يُبعث الحدث <code>'unhandledRejection'</code> كلّما رُفض وعد  <code>Promise</code> ولم يرفق معالج أخطاء بالوعد خلال دور من حلقة الأحداث. عند البرمجة مع الوعود، تُغلّف الاستثناءات "ك وعود مرفوضة". المرفوضات يمكن أن تُلتقط وتُعالج باستخدام [[Node.js/Promise#catch|()promise.catch]] وتُنشر خلال سلسلة <code>Promise</code>. الحدث <code>'unhandledRejection'</code> مفيد من أجل كشف و حفظ مسار الوعود التي رُفضت والتي لم تُعالَج مرفوضاتها بعد.

تُستدعى دالة المُنصت مع الوسائط التالية:
*<code>reason‏</code> ‏‎[[JavaScript/Error|<‎Error‎>]] ‎| ‎[[javascript/any|<any‎>]]‎: الكائن الذي رُفض الوعد معه (عادةً ما يكون كائن [[JavaScript/Error|Error]])

*<code>p</code> :الوعد <code>Promise</code> الذي رُفِض
<syntaxhighlight lang="javascript">
process.on('unhandledRejection', (reason, p) => {
  console.log('Unhandled Rejection at:', p, 'reason:', reason);
//تسجيل دخول محدد التطبيق ، راميًا خطأ أو منطق برمجي آخر هنا
});

somePromise.then((res) => {
  return reportToUser(JSON.pasre(res)); // (`pasre`) لاحظ الخطأ المطبعي
}); // `.catch()` أو `.then()`لا يوجد

</syntaxhighlight>ستؤدي الشيفرة الآتية إلى إطلاق الحدث <code>'unhandledRejection'</code>:<syntaxhighlight lang="javascript">
function SomeResource() {
// مبدئيًا يضبط الحالة المُحمّلة إلى وعد مرفوض
  this.loaded = Promise.reject(new Error('Resource not yet loaded!'));
}

const resource = new SomeResource();
//لدور واحد على الأقل resource.loaded‎ على catch أو .then ‎لايوجد

</syntaxhighlight>في حالة هذا المثال، يمكن تتبع الرفض كخطأ مطوِّر(developer error) كما تكون الحالة النموذجية لأحداث <code>'unhandledRejection'</code> الأخرى. لعنونة مثل هذا الفشل، يمكن أن يُرفق معالج [[node.js/Promise|‎‏‎‎‎‏‎.‎catch‎(() => { }‎)‎‎‎‎‎‎‎]] غير العملياتي

(non-operational ‎.‎catch‎(() => { }‎)‎‎‎‎‎‎‎‎) ب <code>resource.loaded</code> ، والذي سيمنع الحدث <code>'unhandledRejection'</code> من الإطلاق. بدلًا من ذلك، يمكن أن يُستخدم الحدث [[Node.js/process#.D8.A7.D9.84.D8.AD.D8.AF.D8.AB .27rejectionHandled.27|'rejectionHandled']].
===الحدث <code>'warning'</code>===
أُضيف في الإصدار: 6.0.0.
*<code>warning‏</code> [[JavaScript/Error|<Error>]]
الخصائص الرئيسة/المفتاحية للتحذير warning هي:
*<code>name‏</code> [[JavaScript/String|<string>]]: اسم التحذير. '''القيمة الافتراضية:'''<code>'Warning'</code> .

*<code>message</code>‏ [[JavaScript/String|<string>]]: توصيف مزوّد من قبل النظام عن التحذير.

*<code>stack</code>‏ [[JavaScript/String|<string>]]: المسار المُكدَّس/التتبع التكديسي للمكان في الشيفرة حيث أُصدر التحذير.
يُطلق الحدث <code>'warning'</code> كلّما أطلق Node.js تحذير عملية (process warning).

تحذير العملية (process warning) شبيهٌ بالخطأ في أنّه يوصّف ظروفًا استثنائيةً والتي تسترعي انتباه المستخدم. لكن التحذيرات ليست جزءًا من تدفق معالجة الأخطاء الطبيعي في Node.js و JavaScript. تستطيع Node.js إطلاق تحذيرات كلّما كشفت عن ممارسات شيفرة سيئة يمكن أن تقود إلى أداء تطبيق دون المستوى الأمثل، أو أخطاء، أو ثغرات أمنية.<syntaxhighlight lang="javascript">
process.on('warning', (warning) => {
  console.warn(warning.name);  //يطبع اسم التحذير
  console.warn(warning.message);   //يطبع رسالة التحذير
  console.warn(warning.stack);  //التتبع التكديسي‎ يطبع
});
</syntaxhighlight>افتراضيًا، سوف تطبع Node.js تحذيرات عمليات (process warning) إلى مجرى الخطأ القياسي <code>stderr</code>. يمكن أن يُستخدم خيار سطر الأوامر <code>‎-‎‎-‎no-‎warnings</code>‎ لكتم مخرجات console (وحدة التحكم) الافتراضية لكن الحدث <code>'warning'</code> سيبقى مُطلقًا من قبل الكائن <code>process</code>.

يوضّح المثال التالي التحذير الذي يُطبع إلى مجرى الخطأ القياسي <code>stderr</code> عندما تُضاف الكثير من المُنصتات إلى حدث ما:<syntaxhighlight lang="javascript">
$ node
> events.defaultMaxListeners = 1;
> process.on('foo', () => {});
> process.on('foo', () => {});
> (node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak
detected. 2 foo listeners added. Use emitter.setMaxListeners() to increase limit
</syntaxhighlight>بالمقابل، يطفئ المثال التالي خرج التحذير الافتراضي ويضيف مُعالج مخصص لحدث <code>'warning'</code>:<syntaxhighlight lang="javascript">
$ node --no-warnings
> const p = process.on('warning', (warning) => console.warn('Do not do that!'));
> events.defaultMaxListeners = 1;
> process.on('foo', () => {});
> process.on('foo', () => {});
> Do not do that!

</syntaxhighlight>يمكن أن يُستخدم خيار سطر الأوامر <code>‎-‎-‎trace-‎warnings‎</code> للحصول على خرج وحدة التحكم console الافتراضي للتحذيرات متضمنًا المسار المكدَّس/التتبع التكديسي الكامل للتحذير.

تشغيل Node.js باستخدام خيار سطر الأوامر <code>‎-‎-‎throw-‎deprecation</code>‎ سوف يسبب إلقاء تحذيرات مُهملة/منخفضة الأهمية مخصصة (custom deprecation warnings) كاستثناءات.

سيسبب استخدام خيار سطر الأوامر <code>‎-‎-‎trace-‎deprecation‎</code> طباعة التحذيرات المُهملة المخصصة إلى مجرى الخطأ القياسي <code>stderr</code> مع المسار المكدَّس/التتبع التكديسي.

سوف يكتم استخدام خيار سطر الأوامر ‎<code>-‎-‎no-‎deprecation</code>‎ كل التقارير عن التحذيرات المُهملة المخصصة.

ستؤثر خيارات سطر الأوامر ‎<code>*‎-‎deprecation</code>‎ فقط على التحذيرات التي تستخدم الاسم <code>'DeprecationWarning'</code>
====إصدار تحذيرات مخصصة====
انظر التابع [[Node.js/process#process.emitWarning.28warning.5B.2C type.5B.2C code.5D.5D.5B.2C ctor.E2.80.8E.5D.E2.80.8E.29.E2.80.8E|process.emitWarnin‎g()]]‎ لإصدار تحذيرات مُخصصة أو خاصة بالتطبيق.
===أحداث الإشارات (Signal Events)===
سوف تُطلق أحداث الإشارة عندما تستقبل عملية Node.js إشارةً، رجاءً راجع [[(signal(7|signal(7)]]‎ من أجل لائحة أسماء إشارات POSIX (واجهة نظام التشغيل المحمولة لأنظمة يونكس) القياسية مثل '<code>SIGINT</code>' و '<code>SIGHUP</code>'  ...إلخ.

سوف يستقبل مُعالج الإشارة اسم الاشارة (<code>'SIGINT'</code> أو <code>'SIGTERM'</code> أو ...إلخ.) كأول وسيط.

سيكون اسم كل حدث هو الاسم الشائع للحدث وبحالة الأحرف الكبيرة (مثال <code>'SIGINT'</code> من أجل إشارات <code>SIGINT</code>).<syntaxhighlight lang="javascript">
// لذلك لن تنتهي العملية stdin بدء القراءة من مجرى الدخل القياسي
process.stdin.resume();

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

//استخدام دالة وحيدة لمعالجة إشارات متعددة
function handle(signal) {
  console.log(`Received ${signal}`);
}

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

</syntaxhighlight><span> </span>
*<code>'SIGUSR1'</code>: محجوزة من قبل Node.js من أجل بدء المُنقّح ([[Node.js/debugger|debugger]])، من الممكن تنصيب مُنصت ولكن فعل ذلك قد يؤدي إلى تداخل مع المُنقّح.
*<code>'SIGTERM'</code> و <code>'SIGINT'</code>: تملك مُعالجات افتراضية على منصات غير ويندوز (أنظمة تشغيل مختلفة عن ويندوز) والتي ستعيد ضبط حالة الطرفية إلى حالتها الافتراضية قبل الخروج (العودة من الصدفة) بحالة خروج تساوي 128 + رقم الإشارة ‎(‎<code>128‎ +‎ signal‎ number‎</code>)‎‎. إذا كانت إحدى هذه الإشارات تمتلك مُنصتًا مُنصّبًا(موجودًا لتغيير آلية معالجة الإشارة)، سوف يُزال سلوكها الافتراضي (ولن تنتهي عملية Node.js حينئذٍ).

* <code>'SIGPIPE'</code>: مُهملة افتراضيًا، يمكن أن تملك مُنصتًا مُنصبًا (موجوداً لمعالجة الإشارة بآلية خاصة).
* <code>'SIGHUP'</code>: تُولّد في ويندوز عندما تُغلق نافذة الطرفية/وحدة التحكم console، وعلى المنصات الأخرى تحت ظروف شتى مشابهة، انظر [[(signal(7|signal(7)]]‎. يمكن أن تملك مُنصتًا منصبًا، ولكن Node.js سوف تُنهى بشكل غير مشروط من قبل ويندوز بعد حوالي 10 ثواني. على منصات غير ويندوز، السلوك الافتراضي للحدث <code>SIGHUP</code> هو إنهاء Node.js، لكن حالما يُنصّب المنصت سوف يُزال سلوكه الافتراضي.
* <code>'SIGTERM'</code>: ليست مدعومةً في ويندوز، يمكن الانصات عليها.
* <code>'SIGINT'</code>: مدعومة من قبل الطرفية على جميع المنصات، ويمكن توليدها عادة ب <code>‎<‎Ctrl>‎+‎C</code>‎ (بالرغم أن ذلك قد يكون قابلًا للضبط)، لا تُولّد عندما يكون النمط الخام للطرفية مفعلاً.
* <code>'SIGBREAK'</code>: تُرسل في ويندوز عندما يُضغط <code><Ctrl>+<Break></code>، على منصات غير ويندوز يمكن الاستماع لها، ولكن لا يوجد طريقة لإرسالها أو توليدها.
* <code>'SIGWINCH</code>': تُرسل عندما يُغيّر حجم الطرفية/وحدة التحكم console في الويندوز، سوف يحصل هذا فقط في الكتابة على وحدة التحكم عندما يُحرّك المؤشر، أو عندما تكون tty (الطرفية الوهمية التي ينشئها نظام التشغيل) القابلة للقراءة مُستخدمة في الوضع الخام.
* <code>'SIGKILL'</code>: لا يمكن أن تمتلك مُنصتًا مُنصّبًا (لمعالجة الإشارة بآلية خاصة)، سوف تُنهي Node.js بشكل غير مشروط على جميع المنصات.
* <code>'SIGSTOP'</code>: لا يمكن أن تمتلك مُنصتًا مُنصّبًا (لمعالجة الإشارة بآلية خاصة).
* <code>'SIGBUS '</code>و <code>'SIGFPE'</code> و<code>'SIGSEGV'</code> و <code>'SIGILL'</code>: عندما لا تُثار صناعيًا باستخدام [[kill(‎2‎‎)]]‎، تترك العملية بشكل متأصل في حالة ليس آمنًا منها محاولة استدعاء مُنصتات JS، القيام بذلك قد يقود إلى تعليق العملية في حلقة لا نهائية، بما أن المُنصتات المرفقة باستخدام <code>process.on(‎)‎</code> تُستدعى بشكل غير متزامن فهي غير قادرة على تصحيح المشكلة الأساسية.
لا يدعم ويندوز إرسال الإشارات، لكن Node.js توفر بعض المحاكاة مع التوابع [[Node.js/process#process.kill.28pid.5B.2C signal.E2.80.8E.5D.E2.80.8E.29.E2.80.8E|process.kill(‎)]]‎ و [[Node.js/child process#subprocess.kill.28.5Bsignal.5D.29.E2.80.8E|subprocess.kill(‎)]]‎. إرسال الإشارة <code>0</code> يمكن أن يُستخدم لاختبار وجود العملية. إرسال <code>SIGINT</code> و <code>SIGTERM</code> و <code>SIGKILL</code> يسبب انهاءً غير مشروطٍ للعملية الهدف.

== <code>process.abort(‎)‎</code> ==
أُضيف في الإصدار: 0.7.0.

يسبب التابع <code>process.abort(‎‎)‎</code> خروج عملية Node.js مباشرة وتوليد ملف نواة (core file).

هذه الميزة ليست متوفرة في خيوط [[Node.js/Worker|Worker]].

== <code>Process.arch</code> ==
أُضيفت في الإصدار: 0.5.0.
* [[JavaScript/String|<string>]]
تعيد الخاصية <code>process.arch</code> سلسلة نصية مُعرِّفةً البنية المعمارية لوحدة المعالجة المركزية CPU لنظام التشغيل والذي بُنيت فيه Node.js الثنائية.

القيم الحالية الممكنة هي:

<code>'arm'</code>، و<code>'arm64'</code>، و<code>'ia32'</code>، و<code>'mips'</code>، و<code>'mipsel'</code>، و<code>'ppc'</code>، و<code>'ppc64'</code>، و<code>'s390'</code>، و<code>'s390x'</code>، و<code>'x32'</code>، و<code>'x64'</code>.<syntaxhighlight lang="javascript">
console.log(`This processor architecture is ${process.arch}`);
</syntaxhighlight>

== <code>process.argv</code> ==
أُضيفت في الإصدار: 0.1.27.
* [[JavaScript/String|<string[]‎>]]
تعيد الخاصية <code>process.argv</code> مصفوفةً متضمنةً على وسطاء سطر الأوامر المُمررة عندما شُغّلت عملية Node.js. سيكون العنصر الأول process.execPath. انظر <code>process.argv0</code> إذا كان هناك حاجة للوصول إلى القيمة الأصلية للوسيط <code>argv[‎0‎]</code>‎. سوف يكون العنصر الثاني مسار إلى ملف JavaScript قيد التنفيذ. العناصر المتبقية ستكون أي وسطاء إضافية لسطر الأوامر.

على سبيل المثال، بافتراض السكربت التالي باسم <code>process-args.js</code>:<syntaxhighlight lang="javascript">
//يطبع process.argv
process.argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
});
</syntaxhighlight>تشغيل عملية Node.js مثلَ:<syntaxhighlight lang="javascript">
$ node process-args.js one two=three four
</syntaxhighlight>سيولّد الناتج الآتي:<syntaxhighlight lang="javascript">
0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four
</syntaxhighlight>

== <code>process.argv0</code> ==
أُضيفت في الإصدار: 6.4.0.
* [[JavaScript/String|<string>]]
تُخزِّن الخاصية <code>process.argv0</code> نسخة قابلة للقراءة فقط من القيم الأصلية للوسيط <code>argv[‎0‎]‎</code> مُمررةً عندما تبدأ Node.js.<syntaxhighlight lang="javascript">
$ bash -c 'exec -a customArgv0 ./node'
> process.argv[0]
'/Volumes/code/external/node/out/Release/node'
> process.argv0
'customArgv0'
</syntaxhighlight>

== <code>Process.channel</code> ==
أُضيفت في الإصدار: 7.1.0.
* [[JavaScript/Object|<Object>]]
إذا وُلِّدت عملية Node.js عبر قناة الاتصالات ما بين العمليات IPC (انظر توثيق العملية الابن Child Process) تكون الخاصية <code>process.channel</code> مرجعًا لقناة الاتصال ما بين العمليات IPC. إذا لم توجد قناة IPC، تكون هذه الخاصية غير معرّفة <code>undefined</code>.

== <code>process.chdir(directory‎)‎</code> ==
أُضيف في الإصدار: 0.1.17.  
* <code>directory</code> [[JavaScript/String|<string>‎]]
يغير التابع <code>process.chdir‎(‎)</code>‎ مجلد العمل الحالي لعملية Node.js أو يرمي استثناءً إذا فشل ذلك (على سبيل المثال، إذا كان <code>directory</code> المحدد غير موجود).<syntaxhighlight lang="javascript">
console.log(`Starting directory: ${process.cwd()}`);
try {
  process.chdir('/tmp');
  console.log(`New directory: ${process.cwd()}`);
} catch (err) {
  console.error(`chdir: ${err}`);
}

</syntaxhighlight>هذه الميزة غير متوافرة في خيوط [[node.js/worker|Worker]]‏‎.‏‎‎

== <code>process.config</code> ==
أُضيفت في الإصدار: 0.7.7.
* [[JavaScript/Object|<Object>]]
تعيد الخاصية <code>process.config</code> كائن <code>Object</code> حاوي على تمثيل JavaScript لخيارات التهيئة المستخدمة لبناء الملف التنفيدي لبرمجية Node.js الحالية القابلة للتنفيذ. وهذا مثل ملف <code>config.gypi</code> الذي يُنتج عند تشغيل سكربت الضبط (أي السكربت <code>‎/‎‎configure‎.</code>).

يبدو مثال عن المخرجات المحتملة مثل:<syntaxhighlight lang="javascript">
{
  target_defaults:
   { cflags: [],
     default_configuration: 'Release',
     defines: [],
     include_dirs: [],
     libraries: [] },
  variables:
   {
     host_arch: 'x64',
     node_install_npm: 'true',
     node_prefix: '',
     node_shared_cares: 'false',
     node_shared_http_parser: 'false',
     node_shared_libuv: 'false',
     node_shared_zlib: 'false',
     node_use_dtrace: 'false',
     node_use_openssl: 'true',
     node_shared_openssl: 'false',
     strict_aliasing: 'true',
     target_arch: 'x64',
     v8_use_snapshot: 'true'
   }
}

</syntaxhighlight>الخاصية <code>process.config</code> ليست للقراءة فقط وهناك وحدات موجودة في في النظام الذي توفره Node.js تُعرَّف للتوسّع أو التعديل أو تبديل كلي لقيمة <code>process.config</code>.

== <code>process.connected</code> ==
أُضيفت في الإصدار: 0.7.2.
* [[JavaScript/Boolean|<boolean>]]
إذا وُلِّدت عملية Node.js عبر قناة الاتصالات ما بين العمليات IPC (انظر توثيق [[Node.js/child process|Child Process]] و<nowiki/>[[Node.js/cluster|Cluster]]) سوف تعيد الخاصية <code>process.connected</code> القيمة <code>true</code> طالما كانت قناة IPC متصلة وستعيد القيمة <code>false</code> بعد أن يُستدعى التابع <code>process.disconnect(‎)‎</code>.

<span> </span>

حالما تصبح قيمة <code>process.connected</code> خطأ (<code>false</code>)، لا يعود من الممكن إرسال رسائل عبر قناة IPC باستخدام التابع <code>process.send(‎)</code>‎.

== <code>process.cpuUsage([previousValue‎]‎)‎</code> ==
أُضيف في الإصدار: 6.1.0.
* <code>previousValue‏</code> ‎:[[JavaScript/Object|<Object>]]‎ قيمة سابقة مُعادة من استدعاء التابع <code>process.cpuUsage(‎)</code>‎.
* القيمة المعادة: [[JavaScript/Object|<Object>]]
** <code>user</code>‏ [[javascript/integer|‎<integer>]]‎
** <code>system</code>‏ ‎[[javascript/integer|<integer>]]‎
يعيد التابع <code>process.cpuUsage(‎)</code>‎ وقت المُستخدِم ووقت نظام وحدة المعالجة المركزية CPU المُستخدم في العملية الحالية، في كائن مع الخاصيتين <code>user</code> و <code>system</code>، حيث قيمهما هي قيم بالميكرو ثانية (مليون من الثانية). تقيس هذه القيم الوقت المُنفق في شيفرة المستخدم والنظام على الترتيب، وقد تنتهي بكونه (الوقت) أكبر من الوقت الفعلي المنقضي إذا كانت وحدة معالجة مركزية متعددة النوى تنجز العمل لهذه العملية.

يمكن أن تُمرر نتيجة استدعاء سابق للتابع <code>process.cpuUsage(‎)</code>‎ كوسيط للدالة، للحصول على قراءة مختلفة.<syntaxhighlight lang="javascript">
const startUsage = process.cpuUsage();
// { user: 38579, system: 6986 }
//{ المستخدم: 38579, النظام: 6986 }


//جعل المعالج يدور ل 500 ميلي ثانية
const now = Date.now();
while (Date.now() - now < 500);

console.log(process.cpuUsage(startUsage));
// { user: 514883, system: 11226 }
// { المستخدم: 514883, النظام: 11226 }

</syntaxhighlight>

== <code>process.cwd(‎)</code>‎ ==
أُضيف في الإصدار: 0.1.8.
* القيمة المعادة: [[JavaScript/String|<string>]]
يعيد التابع <code>process.cwd(‎)‎</code> مجلد العمل الحالي لعملية Node.js.<syntaxhighlight lang="javascript">
console.log(`Current directory: ${process.cwd()}`);
</syntaxhighlight>

== <code>process.debugPort</code> ==
أُضيفت في الإصدار: 0.7.2.
* [[JavaScript/Number|<number>]]
المَنفذ المستخدم من قبل المُنقّح (debugger) الخاص ب Node.js عندما يُفعّل.<syntaxhighlight lang="javascript">
process.debugPort = 5858;
</syntaxhighlight>

== <code>process.disconnect(‎)‎</code> ==
أُضيف في الإصدار: 0.7.2.

إذا وُلِّدت عملية Node.js عبر قناة الاتصالات ما بين العمليات IPC (انظر توثيق [[Node.js/child process|Child Process]] و [[Node.js/cluster|Cluster]])، سيُغلِق التابع <code>process.disconnect(‎)‎</code> قناة IPC للعملية الأب، سامحةً للعملية الابن بالانتهاء بأمان حالما لا تتواجد أي اتصالات أخرى تبقيها حية.

تأثير استدعاء <code>process.disconnect‎(‎‎)‎‎</code> هو مثل استدعاء العملية الأب للتابع [[Node.js/child process#.D8.A7.D9.84.D8.AA.D8.A7.D8.A8.D8.B9 subprocess.disconnect.28.29.E2.80.8E|ChildProcess.disconnect(‎)]]‎.

إذا كانت عملية Node.js غير مُولَّدة بقناة الاتصال ما بين العمليات IPC، سيكون <code>process.disconnect‎(‎‎)</code>‎‎ غير معرّف <code>undefined</code>.

== <code>‎process.dlopen(module, filename[, flags‎]‎)‎</code> ==
سجل التغييرات

{| class="wikitable"
!الإصدار
!التغييرات
|-
|9.0.0.
|إضافة الدعم للوسيط  flags.
|-
|0.1.16.
|أُضيف في الإصدار 0.1.16.
|}
* <code>module</code>‏ ‎[[JavaScript/Object|<Object>]]‎
* <code>filename‏</code> [[JavaScript/String|<string>]]
* <code>flags‏</code> [[Node.js/os#dlopen Constants|‎<os.constants.dlopen>]]‎، '''القيمة الإفتراضية:''' <code>os.constants.dlopen.RTLD_LAZY</code>.
يسمح التابع <code>process.dlopen(‎)‎</code> بتحميل الكائنات المُشتركة المحلية ديناميكيًا. إنّه يُستخدم في الأصل من خلال <code>require(‎)‎</code> من أجل تحميل إضافات ++C، ولا ينبغي أن يُستخدم مباشرة، إلّا في حالات خاصة. بعبارة أخرى، ينبغي تفضيل [[Node.js/globals|require(‎)]]‎ على <code>process.dlopen(‎)‎</code>، مالم تكن هناك أسباب محددة.

الوسيط <code>flags</code> هو عدد صحيح يسمح بتحديد سلوك dlopen. انظر توثيق os.constants.dlopen للتفاصيل.

إذا كان هناك أسباب محددة لاستخدام <code>process.dlopen(‎)‎</code> (على سبيل المثال، لضبط رايات dlopen)، فمن المفيد غالبًا استخدام [[Node.js/modules#require.28.29.E2.80.8E|require.resolve(‎)]]‎ للبحث عن مسار الوحدة.

هنالك عائق مهم عند استدعاء <code>process.dlopen(‎)</code>‎ هو أن نسخة من الكائن/الصنف <code>module</code> يجب أن تُمرر. سيكون الوصول إلى التوابع المُصدّرة من قبل إضافات C+‎+‎ ممكنًا عبر <code>module.exports</code>.

يعرض المثال في الأسفل كيفية تحميل إضافة C+‎+‎. مسماة <code>binding</code>، وتُصدّر كدالة <code>foo</code>. سوف تُحمّل كل الرموز قبل عودة الاستدعاء، عبر تمرير الثابت <code>RTLD_NOW</code>. يُفترَض في هذا المثال أن يكون الثابت <code>RTLD_NOW</code> متوافرًا:<syntaxhighlight lang="javascript">
const os = require('os');
process.dlopen(module, require.resolve('binding'),
               os.constants.dlopen.RTLD_NOW);
module.exports.foo();
</syntaxhighlight>

== <code>process.emitWarning(warning[, options]‎)‎</code> ==
أُضيف في الإصدار: 8.0.0.
* <code>warning</code>‏ ‎[[JavaScript/String|<string>]] | [[JavaScript/Error|<Error>]]‎‎: التحذير الذي سيُطلق

* <code>options</code>‏ [[JavaScript/Object|‎<Object>]]‎
** <code>type‏</code> ‎[[JavaScript/String|<string>]]‎: عندما يكون التحذير <code>warning</code> هو سلسلة نصية <code>String</code>، يكون النوع <code>type</code> هو الاسم المُستخدم لنوع التحذير الذي يُطلق. '''القيمة الافتراضية:''' <code>'Warning'</code>.
** <code>code</code>‏ ‎[[JavaScript/String|<string>]]‎: مُعرِّف فريد لنسخة التحذير التي ستُطلق.
** <code>ctor</code>‏ ‎[[JavaScript/Function|<Function>]]‎: عندما يكون <code>warning</code> هو سلسلة نصية <code>String</code>، يكون <code>ctor</code> تابع اختياري يُستخدم للحد من المسار التتبع التكديسي المتولد. '''القيمة الإفتراضية:''' <code>process.emitWarning</code>.
** <code>detail</code>‏ ‎[[JavaScript/String|<string>]]‎: نص إضافي ليدرج مع الخطأ.
يمكن أن يُستخدم التابع <code>process.emitWarning(‎)‎</code> لإطلاق تحذيرات عمليات (process warnings) مُحددة التطبيق أو مخصصة. يمكن الإنصات إليها بإضافة معالج إلى حدث [[Node.js/process#.D8.A7.D9.84.D8.AD.D8.AF.D8.AB .27warning.27|'warning']].<syntaxhighlight lang="javascript">
// إطلاق تحذير مع رمز وتفاصيل أخرى
process.emitWarning('Something happened!', {
  code: 'MY_WARNING',
  detail: 'This is some additional information'
});
//تطلق:‏
// (node:56338) [MY_WARNING] Warning: Something happened!
// This is some additional information هذه بعض المعلومات الإضافية

</syntaxhighlight>في هذا المثال، وُلِّد كائن خطأ <code>Error</code> داخليًا من قبل التابع <code>process.emitWarning(‎)</code>‎ و مُرر إلى معالج [[Node.js/process#.D8.A7.D9.84.D8.AD.D8.AF.D8.AB .27warning.27|'warning']]<syntaxhighlight lang="javascript">
process.on('warning', (warning) => {

  console.warn(warning.name);    // 'Warning'

  console.warn(warning.message); // 'Something happened!'

  console.warn(warning.code);    // 'MY_WARNING'

  console.warn(warning.stack);  //التتبع التكديسي‎

  console.warn(warning.detail);  // 'This is some additional information'

});


</syntaxhighlight>

إذا مُرر التحذير <code>warning</code> ككائن <code>Error</code> ، يُهمل الوسيط <code>options</code>.

== <code>process.emitWarning(warning[, type[, code]][, ctor‎]‎)</code>‎ ==

أُضيف في الإصدار: 6.0.0.
* <code>warning</code>‏‎[[JavaScript/String|<string>]] | [[JavaScript/Error|<Error>]] ‎‎: التحذير الذي سيُطلق.
* <code>type</code>‏ ‎[[JavaScript/String|<string>]]‎: عندما يكون التحذير <code>warning</code>  هو سلسلة نصية <code>String</code>، يكون <code>type</code> هو الاسم المُستخدم لنوع التحذير الذي يُطلق. '''القيمة الإفتراضية:''' <code>'Warning'</code>
* <code>code</code>‏ ‎[[JavaScript/String|<string>]]‎: مُعرِّف فريد لنسخة التحذير الذي يُطلق.

* <code>ctor</code>‏ ‎[[JavaScript/Function|<Function>]]‎: عندما يكون التحذير <code>warning</code> هو سلسلة نصية <code>String</code>، يُستخدم<code>ctor</code> كتابع اختياري للحد من التتبع التكديسي المتولّد. '''القيمة الإفتراضية:''' <code>process.emitWarning</code>.
يمكن أن يُستخدم التابع <code>process.emitWarning(‎)</code>‎ لإطلاق تحذيرات عمليات (process warnings) محددة التطبيق أو مخصصة. يمكن الإنصات إليها بإضافة معالج إلى حدث [[Node.js/process#.D8.A7.D9.84.D8.AD.D8.AF.D8.AB .27warning.27|'warning']].<syntaxhighlight lang="javascript">

//إطلاق تحذير باستخدام سلسلة
process.emitWarning('Something happened!');
// Emits: (node: 56338) Warning: Something happened!
// تطلق :(node: 56338) التحذير: Something happened!
// .تطلق تحذير باستخدام سلسلة ونوع
process.emitWarning('Something Happened!', 'CustomWarning');
// Emits: (node:56338) CustomWarning: Something Happened!
//تطلق:(node:56338) CustomWarning:Something Happened!
process.emitWarning('Something happened!', 'CustomWarning', 'WARN001');
// Emits: (node:56338) [WARN001] CustomWarning: Something happened!
// تطلق: (node:56338) [WARN001] CustomWarning: Something happened!

</syntaxhighlight>في كل من الأمثلة السابقة، يُولّد كائن <code>Error</code> داخليًا من قبل التابع <code>process.emitWarning(‎)</code>‎ ويُمرر عبرها إلى معالج [[Node.js/process#.D8.A7.D9.84.D8.AD.D8.AF.D8.AB .27warning.27|'warning']].<syntaxhighlight lang="javascript">
process.on('warning', (warning) => {
  console.warn(warning.name);
  console.warn(warning.message);
  console.warn(warning.code);
  console.warn(warning.stack);
});
</syntaxhighlight>إذا مُرر التحذير <code>warning</code> ككائن <code>Error</code>، سوف يُمرر عبر معالج الحدث <code>'warning'</code> غير معدلٍ (وسوف تُهمل الوسطاء الإختيارية <code>type</code> و <code>code</code> و <code>ctor</code>):<syntaxhighlight lang="javascript">
// Error إطلاق تحذير باستخدام كائن 
const myWarning = new Error('Something happened!');
//  لتحديد اسم النوع Error استخدام خاصية اسم الكائن
myWarning.name = 'CustomWarning';
myWarning.code = 'WARN001';

process.emitWarning(myWarning);
// Emits: (node:56338) [WARN001] CustomWarning: Something happened!
//تطلق: (node:56338) [WARN001] CustomWarning: Something happened!

</syntaxhighlight>يرمى خطأ مطبعي <code>TypeError</code> إذا كان التحذير <code>warning</code> هو أي شيء غير السلسلة النصية أو كائن <code>Error</code>.

لاحظ أنّه بينما تستخدم تحذيرات العمليات (process warning) كائنات <code>Error</code>، آلية تحذير العمليات '''ليست''' بديلة لآلية معالجة الأخطاء العادية.

تُنفذ المعالجة الإضافية التالية إذا كان نوع (<code>type</code>) التحذير هو <code>'DeprecationWarning'</code>:
* إذا استُخدِم خيار سطر الأوامر <code>‎-‎-‎throw‎-‎deprecation‎</code>، سيُلقى التحذير المُهمل كاستثناء بدلًا من إطلاقه كحدث.
* إذا استُخدِم خيار سطر الأوامر ‎<code>-‎-‎no‎-‎deprecation</code>‎، سيُكبت التحذير المُهمل.
* إذا استُخدم خيار سطر الأوامر <code>‎-‎-‎trace‎-‎deprecation‎</code> ، سيُطبَع التحذير المُهمل إلى مجرى الخطأ القياسي <code>stderr</code> مع التتبع التكديسي الكامل.

=== تجنب التحذيرات المُكرّرة (Avoiding duplicate warnings) ===
من المستحسن أن تُطلق التحذيرات مرة فقط لكل العملية. لفعل ذلك، يُنصح بوضع التابع <code>emitWarning(‎)</code>‎ بعد اختبارٍ منطقيٍ بسيط كما هو موضح في المثال أدناه:<syntaxhighlight lang="javascript">
function emitMyWarning() {
  if (!emitMyWarning.warned) {
    emitMyWarning.warned = true;
    process.emitWarning('Only warn once!');
  }
}
emitMyWarning();
// Emits: (node: 56339) Warning: Only warn once!
//تطلق: (node: 56339) Warning: Only warn once!
emitMyWarning();
// Emits nothing
// تطلق لاشيء

</syntaxhighlight>

== <code>process.env</code> ==
سجل التغييرات
{| class="wikitable"
!الإصدار
!التغييرات
|-
|10.0.0.
|أُهمل التحويل الضمني لقيمة المتحول إلى سلسلة نصية
|-
|0.1.27.
|أُضيفت في الإصدار 0.1.27
|}
* [[JavaScript/Object|<Object>]]
ستعيد الخاصية <code>process.env</code> كائنًا حاويًا على بيئة المستخدم. انظر [[environ(‎7‎)‎]] .

يبدو مثالٌ عن الكائن شبيهًا بالكائن الآتي:

<syntaxhighlight lang="javascript">
{
  TERM: 'xterm-256color',
  SHELL: '/usr/local/bin/bash',
  USER: 'maciej',
  PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
  PWD: '/Users/maciej',
  EDITOR: 'vim',
  SHLVL: '1',
  HOME: '/Users/maciej',
  LOGNAME: 'maciej',
  _: '/usr/local/bin/node'
}
</syntaxhighlight>يمكن تعديل هذا الكائن، ولكن مثل هذه التعديلات لن تنعكس خارج عملية Node.js . بعبارة أخرى، المثال التالي لن يعمل:<syntaxhighlight lang="javascript">
$ node -e 'process.env.foo = "bar"' && echo $foo
</syntaxhighlight>بينما سيعمل المثال التالي:<syntaxhighlight lang="javascript">
process.env.foo = 'bar';
console.log(process.env.foo);

</syntaxhighlight>إسناد الخاصية <code>process.env</code> سوف يحول القيمة ضمنيًا إلى سلسلة نصية، '''أُهمل هذا السلوك'''. سترمي النسخ المستقبلية من Node.js خطأً عندما لا تكون القيمة سلسلة نصية أو عدد أو قيمة منطقية.

مثال:<syntaxhighlight lang="javascript">
process.env.test = null;
console.log(process.env.test);
// => 'null'
process.env.test = undefined;
console.log(process.env.test);
// => 'undefined'

</syntaxhighlight>استخدم المعامل <code>delete</code> لحذف خاصية من <code>process.env</code>. 

مثال:<syntaxhighlight lang="javascript">
process.env.TEST = 1;
delete process.env.TEST;
console.log(process.env.TEST);
// => undefined
//=> غير معرّف

</syntaxhighlight>في نظام التشغيل ويندوز، تكون متغيرات البيئة غير حساسة لحالة الأحرف. مثال:<syntaxhighlight lang="javascript">
process.env.TEST = 1;
console.log(process.env.test);
// => 1
</syntaxhighlight>الخاصية <code>process.env</code> قابلة للقراءة فقط في خيوط [[node.js/Worker|Worker]].

== <code>process.execArgv</code> ==
أُضيفت في الإصدار: 0.7.7.
* [[JavaScript/String|‎<‎string‎[‎]‎>]]‎‎‎
تعيد الخاصية <code>process.execArgv</code> مجموعة من خيارات سطر الأوامر الخاصة ببيئة Node.js والمُمرَّرة عندما تُشغّل عملية Node.js. لا تظهر هذه الخيارات في المصفوفة المُعادة من قبل الخاصية process.argv، ولا تتضمن هذه المصفوفة اسم الملف التنفيذي لبيئة Node.js، ولا اسم السكربت المُشغَّل، ولا أيّ خيارات تلي اسم السكربت. هذه الخيارات مفيدة من أجل توليد عملية ابن بنفس بيئة التنفيذ للعملية الأب.<syntaxhighlight lang="javascript">
$ node --harmony script.js --version

</syntaxhighlight>يُنتِج ما سبق القيمة الآتية المخزّنة في الخاصية <code>process.execArgv</code>:<syntaxhighlight lang="javascript">
['--harmony']
</syntaxhighlight>وفي <code>process.argv</code>:<syntaxhighlight lang="javascript">
['/usr/local/bin/node', 'script.js', '--version']

</syntaxhighlight>

== <code>process.execPath</code> ==
أُضيفت في الإصدار: 0.1.100.
* [[JavaScript/String|<string>]]
تعيد الخاصية <code>process.execPath</code> المسار المطلق للملف التنفيذي الذي يبدأ عملية Node.js:<syntaxhighlight lang="javascript">
'/usr/local/bin/node'
</syntaxhighlight>

== <code>process.exit([code‎]‎)‎</code> ==
أُضيف في الإصدار: 0.1.13.
* ‎[[javascript/integer|<integer>]]‎ <code>code</code>: حالة الخروج. '''القيمة الإفتراضية:''' <code>0</code>
التابع <code>process.exit(‎)‎</code> يأمر Node.js إنهاء العملية بشكل متزامن مع حالة الخروج <code>code</code>. إذا حُذف <code>code</code>، يستخدم الخروج إمّا حالة النجاح '‎‎success‎‎' وقيمته <code>0</code> أو قيمة الخاصية <code>process.exitCode</code> إذا ضُبطت. لن تنتهي Node.js حتى تُستدعى جميع مُنصتات الحدث [[Node.js/process#.D8.A7.D9.84.D8.AD.D8.AF.D8.AB .27exit.27|'exit']].

للانهاء مع حالة الفشل 'failure' :<syntaxhighlight lang="javascript">
process.exit(1);
</syntaxhighlight>ينبغي أن ترى الصدفة التي نفّذت Node.js حالة الخروج ‎.<code>‎1</code>

استدعاء <code>process.exit(‎)</code>‎ سيجبر العملية على الانتهاء بأقصى سرعة ممكنة حتى لو بقيت هناك عمليات (operations) غير متزامنة معلّقة ولم تنته بالكامل بعد. متضمنةً عمليات الدخل والخرج I/O إلى <code>process.stdout</code> و <code>process.stderr</code>.

في معظم الحالات، ليس من الضروري فعليًا الاستدعاء الصريح للتابع <code>process.exit(‎)‎</code>. سوف تنتهي عملية Node.js من تلقاء نفسها إذا لم يوجد أي عمل إضافي مُعلّق في حلقة الأحداث. يمكن أن تُضبط الخاصية <code>process.exitCode</code> لتُعلِم العملية أي حالة خروج عليها أن تُستخدَم عندما تنتهي العملية بأمان.

على سبيل المثال، يوضّح المثال التالي سوء استخدام للطريقة <code>process.exit(‎)‎</code> والذي يمكن أن يقود إلى تقطيع وضياع البيانات المطبوعة إلى مجرى الخرج القياسي stdout.<syntaxhighlight lang="javascript">
// :هذا مثال على ما *لا* يجب فعله
if (someConditionNotMet()) {
  printUsageToStdout();
  process.exit(1);
}

</syntaxhighlight>الدافع إلى هذه الإشكالية هو بسبب أنّ الكتابة إلى <code>process.stdout</code> في Node.js تكون أحيانًا غير متزامنة ويمكن أن تحدث خلال عدة وحدات لحلقة أحداث Node.js. لكن استدعاء <code>process.exit(‎)‎</code> يجبر العملية على الانتهاء ''قبل'' أن تُنجز تلك الكتابة الإضافية إلى مجرى الخرج القياسي <code>stdout</code>.

بدلًا من استدعاء <code>process.exit(‎)‎</code> مباشرةً، ينبغي ضبط رمز <code>process.exitCode</code> والسماح للعملية بإنهاء طبيعي من خلال تجنب جدولة أي عمل إضافي لحلقة الأحداث.<syntaxhighlight lang="javascript">
// كيف تُجهِّز حالة الخروج/الانتهاء بشكل صحيح بينما تسمح للعملية بالانتهاء بسلام
if (someConditionNotMet()) {
  printUsageToStdout();
  process.exitCode = 1;
}

</syntaxhighlight>إذا كان من الضروري إنهاء عملية Node.js بسبب حالة خطأ، فإنّ إلقاء خطأ غير مُلتقط والسماح للعملية بالإنهاء وفق ذلك هو أكثر أمانًا من استدعاء <code>process.exit(‎)‎</code>.

في خيوط [[Node.js/Worker|Worker]]، توقف هذه الدالة الخيط الحالي بدلًا من العملية الحالية.

== <code>process.exitCode</code> ==
أُضيفت في الإصدار: 0.11.8.
* [[javascript/integer|<integer>]]
الرقم الذي سيكون حالة الخروج للعملية، إمّا عندما تنتهي العملية بسلام أو تُنهى بواسطة التابع [[Node.js/process#process.exit.28.5Bcode.E2.80.8E.5D.E2.80.8E.29.E2.80.8E|process.exit(‎)]]‎ بدون تحديد حالة خروج.

تعيين حالة خروج للتابع [[Node.js/process#process.exit.28.5Bcode.E2.80.8E.5D.E2.80.8E.29.E2.80.8E|process.exit(‎code‎)‎]] سوف يتجاوز أي إعدادٍ سابق للخاصية <code>process.exitCode</code>.

== <code>process.getegid(‎)‎</code> ==
أُضيف في الإصدار: 2.0.0.

يُعيد التابع <code>process.getegid(‎)</code>‎ المُعرِّف الرقمي للمجموعة الفعالة لعمليةNode.js ‎ (انظر [[‎getegid(2‎)‎‎]])<syntaxhighlight lang="javascript">
if (process.getegid) {
  console.log(`Current gid: ${process.getegid()}`);
}
</syntaxhighlight>تتوافر هذه الدالة فقط على منصات POSIX ( أي ليست ويندوز أو أندرويد).

== <code>process.geteuid(‎)‎</code> ==
أُضيف هذا التابع في الإصدار: 2.0.0.
* القيمة المعادة: [[JavaScript/Object|<Object>]]
يعيد التابع <code>process.geteuid(‎)</code>‎ المُعرِّف الرقمي للمستخدم الفعّال للعملية. ‎‎(انظر ‎ ([[geteuid‎(‎2‎‎‎‎)]]‎‎<syntaxhighlight lang="javascript">
if (process.geteuid) {
  console.log(`Current uid: ${process.geteuid()}`);
}

</syntaxhighlight>تتوافر هذه الدالة فقط على منصات POSIX (أي ليست ويندوز أو أندرويد).

== <code>process.getgid(‎)‎</code> ==
أُضيف في الإصدار: 0.1.31.
* القيمة المعادة: [[JavaScript/Object|<Object>]].
يعيد التابع <code>process.getgid(‎)‎</code> المُعرِّف الرقمي للمجموعة المالكة لعملية‎ .‎Node.js‎ ‎(انظر ‎([[getgid‎(‎‎2‎‎)]]‎.<syntaxhighlight lang="javascript">
if (process.getgid) {
  console.log(`Current gid: ${process.getgid()}`);
}

</syntaxhighlight>تتوافر هذه الدالة فقط على منصات POSIX (أي ليست ويندوز أو أندرويد).

== <code>process.getgroups(‎)‎</code> ==
أُضيف في الإصدار: 0.9.4.

القيمة المعادة: [[javascript/integer|<[]integer>]].

يعيد التابع <code>process.getgroups(‎)</code>‎ مصفوفةً مع المُعرِّف الرقمي للمجموعة المساعدة. تتركها POSIX غير محددة إذا كان معرّف المجموعة الفعّالة مُضمّنًا ولكن Node.js تضمن ذلك دائمًا.

تتوافر هذه الدالة فقط على منصات POSIX ( أي ليست ويندوز أو أندرويد).

== <code>process.getuid(‎)‎</code> ==
أُضيف في الإصدار: 0.1.28.

القيمة المعادة: [[javascript/integer|<integer>]].

يعيد التابع <code>process.getuid(‎)‎</code> المعرّف الرقمي لمستخدم العملية. (انظر<nowiki/>[[javascript/integer|(getuid(2]]).<syntaxhighlight lang="javascript">
if (process.getuid) {
  console.log(`Current uid: ${process.getuid()}`);
}
</syntaxhighlight>تتوافر هذه الدالة فقط على منصات POSIX ( أي ليست ويندوز أو أندرويد).

== <code>process.hasUncaughtExceptionCaptureCallback‎(‎)‎</code> ==
أُضيف في الإصدار: 9.3.0.
* القيمة المعادة: [[JavaScript/Boolean|<boolean>]].
يحدد فيما إذا ضُبطت دالة رد النداء باستخدام [[Node.js/process#process.setUncaughtExceptionCaptureCallback.28fn.E2.80.8E.29.E2.80.8E|process.setUncaughtExceptionCaptureCallback(‎)‎]].

== <code>process.hrtime([time‎]‎)‎</code> ==
أُضيف في الإصدار: 0.7.6.
* ‎‎[[javascript/integer|<‎integer[]‎>]]‎‎ <code>time</code>: نتيجة الاستدعاء السابق للتابع <code>process.hrtime(‎)</code>‎.
* القيمة المعادة: [[javascript/integer|<integer‎[‎]‎>]].
هذا هو الإصدار القديم من ‎[[Node.js/process#process.hrtime.bigint.28.E2.80.8E.29.E2.80.8E|process.hrtime.bigint(‎)]]‎ قبل أن تُدخل <code>bigint</code> في JavaScript.

يعيد التابع <code>process.hrtime(‎)</code>‎ الزمن الحقيقي الحالي عالي الدقة على شكل مصفوفة <code>Array</code> بالصيغة <code>[seconds, nanoseconds]</code>، إذ إنَّ <code>nanoseconds</code> هو الجزء المتبقي من الزمن الحقيقي والذي لا يمكن تمثيله بدِقة الثواني.

<code>time</code> هو معامل اختياري والذي يجب أن يكون نتيجة الاستدعاء السابق للتابع <code>process.hrtime(‎)</code>‎ ليختلف عن الزمن الحالي. إذا لم يكن المعامل المُمرر مصفوفة غير قابلة للتعديل <code>Array</code>، سوف يُلقى خطأ مطبعي (<code>TypeError</code>). التمرير في مصفوفة معرّفة من قبل المستخدم بدلًا من نتيجة الاستدعاء السابق للتابع <code>process.hrtime(‎)</code>‎ سوف يقود إلى سلوك غير معرّف.

هذا الزمن هو نسبي إلى زمن اعتباطي في الماضي، وليس مرتبطًا بزمن اليوم ولذلك لا يخضع لحركة الساعة. الاستخدام الأساسي هو قياس الأداء بين الفترات:<syntaxhighlight lang="javascript">
const NS_PER_SEC = 1e9;
const time = process.hrtime();
// [ 1800216, 25 ]

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

  console.log(`Benchmark took ${diff[0] * NS_PER_SEC + diff[1]} nanoseconds`);
  // benchmark took 1000000552 nanoseconds //أخذ قياس الأداء 1000000552 نانو ثانية
}‎,‎ 1000‎)‎;‎
</syntaxhighlight>

== <code>process.hrtime.bigint(‎)‎</code> ==
أُضيف في الإصدار: 10.7.0.
* القيمة المعادة: [https://github.com/tc39/proposal-bigint <bigint>]
إصدار <code>bigint</code> من التابع [[Node.js/process#process.hrtime.28.5Btime.E2.80.8E.5D.E2.80.8E.29.E2.80.8E|process.hrtime(‎)]]‎ يعيد الزمن الحقيقي الحالي عالي الدقة في <code>bigint</code>.

غير شبيهٍ ب [[Node.js/process#process.hrtime.28.5Btime.E2.80.8E.5D.E2.80.8E.29.E2.80.8E|process.hrtime(‎)‎]]، لايدعم وسيط <code>time</code> إضافي إذ يمُكن أن يُحسب الفرق مباشرةَ بمجرد طرح القيمة المُعادة من التابع <code>bigint</code> المستدعى مرتين.<syntaxhighlight lang="javascript">
const start = process.hrtime.bigint();
//نانوثانية ‎191051479007711

setTimeout(() => {
  const end = process.hrtime.bigint();
//نانوثانية ‎191052633396993 

  console.log(`Benchmark took ${end - start} nanoseconds`);
 //أخذ قياس الأداء 1154389282 نانو ثانية
}‎,‎ 1000‎)‎;‎
</syntaxhighlight>

== <code>process.initgroups(user, extraGroup)</code>‎ ==
أُضيف في الإصدار: 0.9.4.
* ‎‎‎[[JavaScript/String|<string‎‎>]]‎‎ |‎ ‎‎[[JavaScript/Number|<number‎>]]‎ <code>user</code>: اسم المستخدم أو مُعرِّفه الرقمي.
* ‎[[JavaScript/String|<‎string‎>]]‎ | [[JavaScript/Number|<number>]]‎ <code>extraGroup</code>: اسم المجموعة أو معرّفها الرقمي.
يقرأ التابع <code>process.initgroups(‎)</code>‎ الملف ‎<code>/‎etc‎/‎group</code>‎ وينشئ لائحة وصول المجموعات، مستخدمًا كل المجموعات التي يكون فيها المستخدم عضواً. هذه عملية ذات امتيازات وتتطلب أن تملك عملية Node.js وصول الجذر <code>root</code> أو صلاحيات <code>CAP_SETGID</code>.

لاحظ أنّه يجب توخي الحذر عند حذف الإمتيازات. مثال:<syntaxhighlight lang="javascript">
console.log(process.getgroups());         // [ 0 ]
process.initgroups('bnoordhuis', 1000);  //تبديل المستخدم
console.log(process.getgroups());         // [ 27, 30, 46, 1000, 0 ]
process.setgid(1000);                     // للجذر gid‎‎ حذف 
console.log(process.getgroups());         // [ 27, 30, 46, 1000 ]

</syntaxhighlight>تتوافر هذه الدالة فقط على منصات POSIX (أي ليست ويندوز أو أندرويد). هذه الميزة ليست متوافرة في خيوط [[node.js/worker|Worker]] .

== <code>process.kill(pid[, signal‎]‎)‎</code> ==
أُضيف في الإصدار: 0.0.6.
* ‎[[JavaScript/Number|<‎number>]]‎ <code>pid</code>: معرّف العملية
* ‎[[JavaScript/String|<‎string>]]‎ |‎ [[JavaScript/Number|<number>]] ‎<code>signal</code>: الإشارة التي ستُرسَل إلى العملية، إمّا أن تكون سلسلة أو رقم. '''القيمة الإفتراضية:''' <code>'SIGTERM'</code>
يرسل التابع <code>process.kill(‎)‎</code> الإشارة <code>signal</code> إلى العملية ذات المُعرِّف <code>pid</code>.

أسماء الإشارات هي سلاسل نصية مثل: <code>'SIGINT'</code> أو <code>'SIGHUP'</code>. انظر [[Node.js/process#.D8.A3.D8.AD.D8.AF.D8.A7.D8.AB .D8.A7.D9.84.D8.A5.D8.B4.D8.A7.D8.B1.D8.A7.D8.AA .28Signal Events.29|Signal Events]] و [[kill(‎2‎‎)]]‎ للمزيد من المعلومات.

سيرمي هذا التابع خطأ إذا لم يكن مُعرِّف<code>pid</code> الهدف موجودًا. كحالة خاصة، يمكن أن تُستخدم الإشارة <code>0</code> لاختبار وجود عملية. سترمي منصات الويندوز خطأ إذا استُخدِم <code>pid</code> لقتل مجموعة العملية.

بالرغم من أن اسم هذه الدالة هو <code>process.kill(‎)‎</code>، هي في الواقع مرسلَة إشارة فقط، مثل نداء النظام <code>kill</code>. قد تفعل الإشارة المرسلة أشياء غير قتل العملية الهدف.<syntaxhighlight lang="javascript">
process.on('SIGHUP', () => {
  console.log('Got SIGHUP signal.');
});

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

process.kill(process.pid, 'SIGHUP');
</syntaxhighlight>عندما تُستقبل <code>SIGUSR1</code> من قبل عملية Node.js، سوف تبدأ Node.js المُنقِحَ (debugger)، انظر [[Node.js/process#.D8.A3.D8.AD.D8.AF.D8.A7.D8.AB .D8.A7.D9.84.D8.A5.D8.B4.D8.A7.D8.B1.D8.A7.D8.AA .28Signal Events.29|أحداث الإشارات]].

== <code>process.mainModule</code> ==
أُضيفت في الإصدار: 0.1.17.
* [[JavaScript/Object|<Object>]].
تقدم الخاصية <code>process.mainModule</code> طريقةً بديلةً لاستعادة [[Node.js/modules#.D8.A7.D9.84.D9.88.D8.B5.D9.88.D9.84 .D8.A5.D9.84.D9.89 .D8.A7.D9.84.D9.88.D8.AD.D8.AF.D8.A9 .D8.A7.D9.84.D8.B1.D8.A6.D9.8A.D8.B3.D9.8A.D8.A9|require.main]]. الاختلاف هو إذا كانت الوحدة الرئيسة تتغير في وقت التنفيذ، قد تبقى [[Node.js/modules#.D8.A7.D9.84.D9.88.D8.B5.D9.88.D9.84 .D8.A5.D9.84.D9.89 .D8.A7.D9.84.D9.88.D8.AD.D8.AF.D8.A9 .D8.A7.D9.84.D8.B1.D8.A6.D9.8A.D8.B3.D9.8A.D8.A9|require.main]] مشيرةً إلى الوحدة الأساسية الأصلية في وحدات طُلبت قبل حدوث التغييرات. عمومًا. من الآمن افتراض أن الاثنتين تشيران إلى الوحدة ذاتها.

مع [[Node.js/modules#.D8.A7.D9.84.D9.88.D8.B5.D9.88.D9.84 .D8.A5.D9.84.D9.89 .D8.A7.D9.84.D9.88.D8.AD.D8.AF.D8.A9 .D8.A7.D9.84.D8.B1.D8.A6.D9.8A.D8.B3.D9.8A.D8.A9|require.main]]، ستكون <code>process.mainModule</code> غير معرّفة <code>undefined</code> إذا لم يكن هناك سكربت مَدخِل (entry script).

== <code>process.memoryUsage(‎)</code>‎ ==
سجل التغييرات

{| class="wikitable"
!الإصدار
!التغييرات
|-
|7.2.0.
|أُضيفت الخاصية <code>external</code> إلى لكائن المُعاد.
|-
|0.1.16.
|أُضيفت في الإصدار 0.1.16.
|}
* القيمة المعادة: [[JavaScript/Object|<Object>]]
** ‎[[javascript/integer|<‎integer>]]‎ <code>rss</code>
** [[javascript/integer|‎<integer>]]‎ <code>heapTotal</code>
** ‎[[javascript/integer|<integer>]]‎ <code>heapUsed‎</code>
** [[javascript/integer|‎<integer>]]‎ <code>external</code>
يعيد التابع <code>process.memoryUsage(‎)</code>‎ كائن يوصّف استخدام الذاكرة في عملية Node.js مقاسًا بالبايتات.

على سبيل المثال، الشيفرة التالية:<syntaxhighlight lang="javascript">
console.log(process.memoryUsage());
</syntaxhighlight>سوف تولّد:<syntaxhighlight lang="javascript">
{
  rss: 4935680,
  heapTotal: 1826816,
  heapUsed: 650472,
  external: 49879
}


</syntaxhighlight>تشير <code>heapTotal</code> و <code>heapUsed</code> إلى استخدام ذاكرة V8. تشير <code>external</code> إلى استخدام الذاكرة لكائنات C+‎+‎ المرتبطة بكائنات JavaScript المُدارة من قبل V8.

<code>Rss</code>، أي Resident Set Size (حجم المجموعة المشغولة)، هو كمية الفراغ المشغول في جهاز الذاكرة الرئيسي (والذي هو مجموعة جزئية من الذاكرة المخصصة الكلية) للعملية، والذي يتضمن الكومة heap، ومقطع الشيفرة code segment، والمكدّس stack.

الكومة heap هي حيث تُخزّن الكائنات والسلاسل النصية و التعابير المغلقة (closures). تخزّن المتحولات في المكدّس stack وتبقى شيفرة JavaScript الفعلية في مقطع الشيفرة (code segment).

عند استخدام خيوط Worker، ستكون <code>rss</code> قيمة متاحة لكامل العملية، بينما ستشير الحقول الأخرى للخيط الحالي فقط.

== process.nextTick(callback[, ...args]‎)‎ ==
سجل التغييرات

{| class="wikitable"
!الإصدار
!التغييرات
|-
|1.8.1.
|دُعِمت الآن وسائط إضافية بعد <code>callback</code>.
|-
|0.1.26.
|أُضيفت في 0.1.26.
|}
* ‎[[JavaScript/Function|<Function‎>]]‎‎ <code>callback</code>.
* ‎[[javascript/any|<‎any>]]‎‎ <code>args</code>: وسائط إضافية لتُمرر عند استدعاء callback.
يضيف التابع <code>process.nextTick(‎)</code>‎ دالة رد النداء (callback) إلى "رتل النبضة التالية" "next tick queue". حالما يكتمل الدور الحالي من أدوار حلقة الأحداث، سوف تُستدعى كل دوال رد النداء الحالية (callbacks) في رتل النبضة التالية.

هذا ليس بديلاً بسيطًا للتابع [[Node.js/timers#setTimeout.28callback.2C delay.5B.2C ...args.5D.29.E2.80.8E|setTimeout(fn, 0‎)]]‎. إنّه أكثر فاعلية بكثير. فهو يعمل قبل أن تنطلق أي أحداث دخل وخرج إضافية (متضمنة المؤقتات) في النبضات اللاحقة لحلقة الأحداث.<syntaxhighlight lang="javascript">
console.log('start');
process.nextTick(() => {
  console.log('nextTick callback');
});
console.log('scheduled');
// Output://‎المخرجات:‏‎‎
// start //البدء
// scheduled //المجدول
// nextTick callback //دالة رد النداء في اللحظة التالية
</syntaxhighlight>هذا مهم في تطوير الواجهات البرمجية API من أجل إعطاء فرصة للمستخدم لإسناد معالج للأحداث بعد بناء كائن ولكن قبل أن تحدث أي عمليات دخل وخرج I/O. <syntaxhighlight lang="javascript">
function MyThing(options) {
  this.setupOptions(options);

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

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


// الآن وليس من قبل thing.startDoingStuff()‎ تُستدعى 

</syntaxhighlight>من المهم جدًا للواجهات البرمجية API أن تكون إمّا متزامنة 100% أوغير متزامنة 100%. تأمّل هذا المثال:<syntaxhighlight lang="javascript">
//تحذير: لا تستخدمه! مخاطرة سيئة غير آمنة!
function maybeSync(arg, cb) {
  if (arg) {
    cb();
    return;
  }

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

</syntaxhighlight>هذه الواجهة البرمجية API خطيرة بسبب الحالة التالية:<syntaxhighlight lang="javascript">
const maybeTrue = Math.random() > 0.5;

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

bar();
</syntaxhighlight>ليس واضحًا أي من <code>foo(‎)</code>‎ أو <code>bar(‎)</code>‎ سوف يُستدعى أولًا.

النهج التالي أفضل بكثير:<syntaxhighlight lang="javascript">
function definitelyAsync(arg, cb) {
  if (arg) {
    process.nextTick(cb);
    return;
  }

  fs.stat('file', cb);
}
</syntaxhighlight>يكون رتل النبضة التالية مُستنزَفًا كليًا كل عبور لحلقة الأحداث قبل أن تُعالج عمليات دخل وخرج إضافية. بالنتيجة، سوف يَحظُرُ الضبط التكراري لتابع رد النداء <code>nextTick(‎)</code>‎ أي عمليات دخل وخرج من الحدوث، تمامًا مثل حلقة <code>while(true‎)‎;</code>‎.

== <code>process.noDeprecation</code> ==
أُضيفت في الإصدار: 0.8.0.
* [[JavaScript/Boolean|<boolean>]]
تحدد الخاصية <code>process.noDeprecation</code> فيما إذا كانت راية ‎<code>-‎-‎no‎-‎deprecation‎</code> مضبوطة في عملية Node.js الحالية. انظر توثيق 'warning' event و emitWarning() method للمزيد من المعلومات حول سلوك هذه الراية.

== <code>process.pid</code> ==
أُضيفت في الإصدار: 0.1.15.
* <integer>
تعيد الخاصية <code>process.pid</code> معرّف العملية (PID) للعملية الحالية.<syntaxhighlight lang="javascript">
console.log(`This process is pid ${process.pid}`);
</syntaxhighlight>

== <code>process.platform</code> ==
أُضيفت في الإصدار: 0.1.16.
* <string>
تعيد الخاصية process.platform سلسلة نصية مُعرِّفةً منصة نظام التشغيل التي تُشغّل عليها عملية Node.js.

القيم الحالية الممكنة هي:
* <code>'aix'</code>
* <code>'darwin'</code>
* <code>'freebsd'</code>
* <code>'linux'</code>
* <code>'openbsd'</code>
* <code>'sunos'</code>
* <code>'win32'</code>
<syntaxhighlight lang="javascript">
console.log(`This platform is ${process.platform}`);

</syntaxhighlight>قد تُعاد أيضًا القيمة <code>'android'</code> إذا بُنيت Node.js على نظام تشغيل أندرويد. لكن، دعم الأندرويد في Node.js هو تجريبي is experimental.

== <code>process.ppid</code> ==
أُضيفت في الإصدار: 9.2.0.
* <integer>
تعيد الخاصية <code>process.ppid</code> معرّف العملية PID لعملية الأب الحالية.<syntaxhighlight lang="javascript">
console.log(`The parent process is pid ${process.ppid}`);

</syntaxhighlight>

== <code>process.release</code> ==
سجل التغييرات

{| class="wikitable"
!الإصدار
!التغييرات
|-
|4.2.0.
|دُعمت الخاصية lts الآن.
|-
|3.0.0.
|أُضيفت في 3.0.0.
|}
* <Object>
تعيد الخاصية <code>process.release</code> كائنًا (<code>Object</code>) حاويًا على البيانات الوصفية المتعلقة بالإصدار الحالي، متضمنةً عناوين URL لأرشيفات tar المصدرية وأرشيفات الترويسات البرمجية فقط.

تضم <code>process.release</code> الخاصيات التالية:
* ‎<‎string‎>‎‎ <code>‎name</code> ‎: ستكون القيمة دائمًا عقدة <code>'node'</code> من أجل Node.js. من أجل الإصدارات القديمة من io.js، ستكون <code>'io.js'</code>.
* ‎<‎string‎>‎‎ <code>sourceUrl</code>: عنوان URL مطلق مشير إلى ملف <code>‎.‎tar.gz</code> الحاوي على الشيفرة المصدرية للإصدار الحالي.
* ‎<‎string‎>‎ <code>headersUrl‎</code>: عنوان مطلق مُشير إلى ملف <code>‎.‎tar.gz</code> الحاوي فقط على ملفات الترويسات البرمجية المصدرية للإصدار الحالي. هذه الملفات أصغر بشكل ملحوظ من الملفات المصدرية الكاملة ويمكن أن تُستخدم  لتصريف (compile) الإضافات الأصلية لبيئة Node.js.
* ‎<‎string‎><code>‎‎‎libUrl</code>: عنوان مطلق يشير إلى ملف <code>node.lib</code> المطابق للبنية المعمارية والإصدار الحالي. يُستخدم هذا الملف لتصريف (compile) إضافات Node.js أصلية. ه''ذه الخاصية حاضرة فقط لبيئة Node.js المبنية على ويندوز وسوف تكون مفقودة على جميع المنصات الأخرى.''
* ‎‎<‎‎string‎‎>‎‎‎‎ <code>lts</code>: لافتة نصية معرِّفة للافتة LTS (أي Long Term Support، وهي الإصدارات طويلة الدعم) لهذا الإصدار. هذه الخاصية موجودة فقط من أجل إصدارات LTS وهي غير معرّفة  <code>undefined</code> من أجل كل أنواع الإصدارات الأخرى متضمنةً الإصدارات الحالية (Current releases). القيم المتوافرة حاليًا تكون:

* <code>'Argon'</code>  من أجل خط الدعم طويل الأمد 4‎.‎x‎ LTS‎ البادئ مع 4.2.0.
* <code>'Boron'</code> من أجل خط الدعم طويل الأمد ‎6‎.x‎ LTS‎  البادئ مع 6.9.0.
* <code>'Boron'</code>  من أجل خط الدعم طويل الأمد ‎8‎‎.‎x‎ LTS‎ البادئ مع 8.9.1.
<syntaxhighlight lang="javascript">
{
  name: 'node',
  lts: 'Argon',
  sourceUrl: 'https://nodejs.org/download/release/v4.4.5/node-v4.4.5.tar.gz',
  headersUrl: 'https://nodejs.org/download/release/v4.4.5/node-v4.4.5-headers.tar.gz',
  libUrl: 'https://nodejs.org/download/release/v4.4.5/win-x64/node.lib'
}

</syntaxhighlight>في بُنى مخصصة من الإصدارات التي ليست ضمن قائمة الإصدارات لشجرة المصدر، قد تكون الخاصية <code>name</code> حاضرةً فقط، لا ينبغي الاعتماد على وجود بقية الخاصيات.

== <code>process.send(message[, sendHandle[, options]][, callback‎]‎)‎</code> ==
أُضيف في الإصدار: 0.5.9.
* ‎‎Object‎‎‎>‎‎‎ <code>message</code>>
* ‎net.Server>‎ | ‎<‎net.Socket‎>‎‎ <code>sendHandle</code>>
* ‎<‎Object‎‎>‎‎ <code>options‎</code>   
* ‎Function‎>‎‎ <code>callback</code>>
* ‎ القيمة المُعادة: <boolean>
إذا وُلِّدت عملية Node.js عبر قناة الاتصالات ما بين العمليات IPC ، يمكن أن يُستخدم التابع <code>process.send(‎)‎</code> لإرسال رسائل للعملية الأب. ستُستقبل الرسائل كحدث 'message' في كائن ChildProcess الخاص بالأب.

إذا لم تكن Node.js مُولَّدة بقناة الاتصال ما بين العمليات IPC، سوف تكون <code>process.send(‎)</code>‎ غير معرّفة <code>undefined</code>.

ستمر الرسالة عبر التسلسل والتحليل النحوي، قد لا تكون الرسالة الناتجة تمامًا كالأصلية المرسلة.

== <code>process.setegid(id‎)‎</code> ==
أُضيف في الإصدار: 2.0.0.
* ‎<‎string‎>‎ | ‎‎<number‎>‎‎ <code>id</code> ‎: اسم المجموعة أو معرّفها.
يضبط التابع <code>process.setegid(‎)</code>‎ هوية المجموعة الفعّالة للعملية. (انظر setegid‎(‎2‎)‎). يمكن أن يُمرر <code>id</code> إمّا كمعرّف رقمي أو سلسلة اسم المجموعة. إذا كان اسم المجموعة مُحددًا، ينحظر هذا التابع أثناء استبيان (resolving) المعرّف الرقمي المزوّد (the associated a numeric ID).<syntaxhighlight lang="javascript">
if (process.getegid && process.setegid) {
  console.log(`Current gid: ${process.getegid()}`);
  try {
    process.setegid(501);
    console.log(`New gid: ${process.getegid()}`);
  } catch (err) {
    console.log(`Failed to set gid: ${err}`);
  }
}
</syntaxhighlight>هذه الدالة متوافرة فقط على منصات POSIX ( أي ليست ويندوز أو أندرويد). هذه الميزة ليست متوافرة في خيوط Worker.

== <code>process.seteuid(id‎)‎</code> ==
أُضيف في الإصدار: 2.0.0.
* ‎<string> | <number> <code>id</code>:  اسم المستخدم أو معرّفه.
يهيئ التابع <code>process.seteuid(‎)</code>‎ معرّف المستخدم الفعّال للعملية .(انظر seteuid(2‎‎)‎) يمكن أن يُمرر <code>id</code> إمّا كمعرّف رقمي أو سلسلة نصية لاسم المجموعة. إذا كان اسم المستخدم محددًا، ينحظر هذا التابع أثناء استبيان (resolving) المعرّف الرقمي المزوّد (the associated a numeric ID).<syntaxhighlight lang="javascript">
if (process.geteuid && process.seteuid) {
  console.log(`Current uid: ${process.geteuid()}`);
  try {
    process.seteuid(501);
    console.log(`New uid: ${process.geteuid()}`);
  } catch (err) {
    console.log(`Failed to set uid: ${err}`);
  }
}

</syntaxhighlight>هذه الدالة متوافرة فقط على منصات POSIX (أي ليست ويندوز أو أندرويد). هذه الميزة ليست متوافرة في خيوط Worker.

== <code>process.setgid‎(‎id‎)‎</code> ==
أُضيف في الإصدار: 0.1.31.
* ‎<string> | <number> <code>id</code>: اسم المجموعة أو معرّفها.
يهيئ التابع <code>process.setgid‎()‎</code> معرّف المجموعة للعملية. (انظر setgid(2‎‎)‎) يمكن أن يُمرر <code>id</code> إمّا كمعرّف رقمي أو سلسلة نصية لاسم المجموعة. إذا كان اسم المجموعة محددًا، ينحظر هذا التابع أثناء استبيان (resolving) المعرّف الرقمي المزوّد (the associated a numeric ID).<syntaxhighlight lang="javascript">
if (process.getgid && process.setgid) {
  console.log(`Current gid: ${process.getgid()}`);
  try {
    process.setgid(501);
    console.log(`New gid: ${process.getgid()}`);
  } catch (err) {
    console.log(`Failed to set gid: ${err}`);
  }
}
</syntaxhighlight>هذه الدالة متوافرة فقط على منصات POSIX (أي ليست ويندوز أو أندرويد). هذه الميزة ليست متوافرة في خيوط Worker.

== <code>process.setgroups(groups)‎</code> ==
أُضيف في الإصدار: 0.9.4.
* ‎integer‎[]‎>‎‎ <code>groups</code>>.
يهيء التابع <code>process.setgroups(‎)</code>‎ معرّفات المجموعات المساعدة لعملية Node.js. هذه عملية ذات امتياز والتي تتطلب أن تمتلك عملية Node.js امتيازات الجذر (<code>root</code>) أو الصلاحية <code>CAP_SETGID</code>.

يمكن أن تحتوي المصفوفة <code>groups</code> المعرّفات الرقمية للمجموعات أو أسماء المجموعات أو الاثنتين.

هذه الدالة متوافرة فقط على منصات POSIX (أي ليست ويندوز أو أندرويد). هذه الميزة ليست متوافرة في خيوط Worker.

== <code>process.setuid(id)‎</code> ==
أُضيف في الإصدار: 0.1.28.

يضبط التابع <code>process.setuid()</code>‎ معرّف المستخدم للعملية. (انظر setuid(2‎‎)‎). يمكن أن يُمرر <code>id</code> إمّا كمعرِّف رقمي أو سلسلة اسم مستخدم. إذا كان اسم المستخدم مُحددًا، ينحظر هذا التابع أثناء استبيان (resolving) المعرّف الرقمي المزوّد (the associated a numeric ID).<syntaxhighlight lang="javascript">
if (process.getuid && process.setuid) {
  console.log(`Current uid: ${process.getuid()}`);
  try {
    process.setuid(501);
    console.log(`New uid: ${process.getuid()}`);
  } catch (err) {
    console.log(`Failed to set uid: ${err}`);
  }
}

</syntaxhighlight>هذه الدالة متوافرة فقط على منصات POSIX (أي ليست ويندوز أو أندرويد). هذه الميزة ليست متوافرة في خيوط Worker.

== <code>process.setUncaughtExceptionCaptureCallback(fn‎)‎</code> ==
أُضيف في الإصدار: 9.3.0.
* ‎<Function‎> | ‎<null‎> ‎‎<code>fn</code>
يهيء التابعُ <code>process.setUncaughtExceptionCaptureCallback(‎)</code>‎ التابعَ الذي سيُستدعى عندما يحصل استثناء غير مُلتقط، والذي سيستقبل قيمة الاستثناء نفسها كوسيطه الأول.

إذا هُيئ مثل هذا التابع، لن يُطلق الحدث 'uncaughtException'. ولن تتوقف العملية إذا مُرر ‎<code>-‎-‎abort-‎on-‎uncaught-‎exception</code>‎ من سطر الأوامر أو هُيء من خلال v8.setFlagsFromString(‎)‎.

لإزالة تهيئة تابع الالتقاط، يمكن أن يُستخدم <code>process.setUncaughtExceptionCaptureCallback(null)</code>‎. إنّ استدعاء هذا التابع مع وسائط غير معدومة non-<code>null</code> بينما يُهيأ تابع التقاط آخر قد يرمي خطأً.

استخدام هذا التابع لا يعتمد على استخدام الوحدة المدمجة المُهملة domain.

== <code>process.stderr</code> ==
* <Stream>
تعيد الخاصية <code>process.stderr</code> مجرى متصل إلى ‎<code>stderr‎</code> [واصف الملفات ‎(‎fd <code>2</code>‎)‎]. إنّها net.Socket (والتي هي مجرى مزدوج‎‎(‎‎Duplex)‎‎  ‎) إلّا إذا أشار ‎[واصف الملفات (fd <code>2</code>)] إلى ملف، في تلك الحالة تكون مجرى Writable.

تختلف <code>process.stderr</code> عن باقي مجاري Node.js في نواحي مهمة، انظر ملاحظة على عمليات الدخل والخرج للمزيد من المعلومات.

هذه الميزة ليست متوافرة في خيوط Worker.

== <code>process.stdin</code> ==
* <Stream>
تعيد الخاصية <code>process.stdin</code> مجرى متصل إلى <code>stdin</code>‏ [واصف الملفات ‎‎[‎(fd ‎<code>0</code>‎)‎. هي net.Socket (والتي هي مجرى مزدوج (Duplex)) إلّا إذا كان [واصف الملفات  ‎‎[‎(fd <code>‎0</code>‎)‎ يشير إلى ملف. في تلك الحالة تكون مجرى Readable.<syntaxhighlight lang="javascript">
process.stdin.setEncoding('utf8');

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

process.stdin.on('end', () => {
  process.stdout.write('end');
});
</syntaxhighlight>بما أنّها مجرى مزدوج (Duplex)، يمكن أن تُستخدم <code>process.stdin</code> في النمط "old" أيضًا والذي يكون متوافقًا مع السكربتات المكتوبة من أجل إصدارات Node.js قبل ‎0‎.‎10‎‎. للمزيد من المعلومات انظر توافق المجاري (Stream compatibility).

مجرى الدخل القياسي <code>stdin</code> متوقف افتراضيًا في نمط المجاري "old". لذلك يجب على الفرد استدعاء <code>process.stdin.resume(‎)</code>‎ للقراءة منه. لاحظ أيضًا أنّ استدعاء <code>process.stdin.resume(‎)</code>‎ بحد ذاته سوف يحول المجرى إلى النمط القديم "old" .

هذه الميزة ليست متوافرة في خيوط Worker.

== <code>process.stdout</code> ==
* <Stream>
تعيد الخاصية <code>process.stdout</code> مجرى متصل إلى <code>stdout</code> [واصف الملفات ‏‎(fd <code>1</code>)‎]. هي net.Socket (والتي هي مجرى مزدوج (Duplex)) إلّا إذا كان [واصف الملفات ‏‎(fd <code>1</code>)‎] يشير إلى ملف، في هذه الحالة هو مجرى كتابة Writable.

على سبيل المثال، لنسخ <code>process.stdin</code> إلى <code>process.stdout</code>:<syntaxhighlight lang="javascript">
process.stdin.pipe(process.stdout);

</syntaxhighlight>تختلف <code>process.stdout</code> عن باقي مجاري Node.js في نواحي مهمة، انظر ملاحظة على عمليات الدخل والخرج للمزيد من المعلومات.

هذه الميزة ليست متوافرة في خيوط Worker.

=== ملاحظة على عمليات الدخل والخرج ===
تختلف <code>process.stdout</code> و <code>process.stderr</code> عن باقي مجاري Node.js في نواحي مهمة:
# تُستخدم داخليًا من قبل console.log(‎)‎ و console.error(‎)‎، على التوالي وبالترتيب.
# لا يمكن غلقُه ا(سوف تُرمى end(‎)‎).
# لن تطلق الحدث 'finish' أبدًا.
# يمكن أن تكون الكتابة متزامنةً اعتمادًا على ما يرتبط به المجرى وإذا كان النظام ويندوز أو يونكس (أي متوافق مع POSIX)
#* الملفات: متزامنة على ويندوز و POSIX
#* الطرفية الوهمية التي ينشئها نظام التشغيل TTYs: غير متزامنة على ويندوز ، متزامنة على POSIX.
#* الأنابيب Pipes (والمقابس sockets): متزامنة على ويندوز، غير متزامنة على POSIX
يعزى بعض هذا السلوك لأسباب تاريخية، كما أنّ تغييرها قد يخلق عدم توافق مع الإصدارات السابقة، ولكنه أيضًا مُتوقع من قبل بعض المستخدمين.

تُجنِّب الكتابة المتزامنة المشاكل مثل التداخل غير المتوقع للخرج المكتوب باستخدام <code>console.log(‎)‎</code> أو <code>console.error(‎)</code>‎. أو لا تُكتَب نهائيًا إذا استدعي <code>process.exit(‎)</code>‎ قبل أن تنتهي الكتابة غير المتزامنة. انظر process.exit(‎)‎ للمزيد من المعلومات.

تحذير: تَحظرُ الكتابة المتزامنة حلقة الأحداث حتى تكتمل الكتابة. يمكن أن يكون هذا الحظر لحظيًا تقريبًا في حالة الخرج إلى ملف، ولكن تحت تحميل نظام عالي، فالأنابيب (pipes) التي لا تُقرأ في طرف الاستقبال، أو في الطرفيات البطيئة أو أنظمة الملفات، قد تؤدي إلى حظر حلقة الأحداث في أحيانٍ كثيرةٍ وبطولٍ كافٍ للحصول على تأثير أداء شديد السلبية. قد لا تكون (الكتابة المتزامنة) مشكلة عند الكتابة إلى جلسة طرفية تفاعلية، ولكن انظر لذلك بحذر خاص عند تسجيل الناتج إلى مجاري خرج العمليات.

لتتَحقّق إذا كان هناك مجرى متصل بسياق الطرفية الوهمية التي ينشئها نظام التشغيل (TTY)، تحقق من الخاصية <code>isTTY</code>.

على سبيل المثال:<syntaxhighlight lang="javascript">
$ node -p "Boolean(process.stdin.isTTY)"
true
$ echo "foo" | node -p "Boolean(process.stdin.isTTY)"
false
$ node -p "Boolean(process.stdout.isTTY)"
true
$ node -p "Boolean(process.stdout.isTTY)" | cat
false
</syntaxhighlight>انظر توثيق TTY للمزيد من المعلومات.

== <code>process.throwDeprecation</code> ==
أُضيفت في الإصدار: 0.9.12.
* <boolean>
تبيّن الخاصية <code>process.throwDeprecation</code> فيما إذا كانت الراية ‎<code>--throw-deprecation</code> مضبوطة في عملية Node.js الحالية. انظر توثيق 'warning' event و emitWarning() method للمزيد من المعلومات عن سلوك هذه الراية.

== <code>process.title</code> ==
أُضيفت في الإصدار: 0.1.104.
* <string>
تعيد الخاصية <code>process.title</code> عنوان العملية الحالية (بعبارة أخرى تعيد قيمة <code>ps</code> الحالية). إسناد قيمة جديدة إلى <code>process.title</code> يعدّل قيمة <code>ps</code> الحالية.

عندما تُسند قيمة جديدة، ستفرض المنصات المختلفة قيودًا مختلفة على حد الطول الأقصى للعنوان. عادة تكون مثل هذه القيود محدودة للغاية. على سبيل المثال، في أنظمة لينُكس وماك ، يكون <code>process.title</code> محدودًا بحجم الاسم الثنائي زائداً طول وسطاء سطر الأوامر. لأن إعدادات <code>process.title</code> تعيد كتابة ذاكرة <code>argv</code> للعملية. يسمح الإصدار 0.8 لبيئة Node.js بسلاسل عناوين عمليات أطول بواسطة إعادة كتابة ذاكرة <code>environ</code> ولكن من المحتمل أن يكون ذلك غير آمن ومربك في بعض الحالات (الغامضة إلى حد ما).

== <code>process.traceDeprecation</code> ==
أُضيفت في الإصدار: 0.8.0.
* <boolean>
تبين الخاصية <code>process.traceDeprecation</code> فيما إذا كانت راية <code>‎-‎-trace-‎deprecation</code>‎ مضبوطةً في عملية Node.js الحالية. انظر توثيق 'warning' event و emitWarning() method للمزيد من المعلومات حول سلوك هذه الراية.

== <code>process.umask([mask]‎)‎</code> ==
أُضيف في الإصدار: 0.1.19.
* ‎‎<‎number‎‎>‎‎ <code>mask</code>
يُجهِّز أو يُعيِد التابع <code>process.umask(‎)</code>‎ قناع أذونات الملفات المُنشَأة من عملية Node.js. ترث العملية الابن القناع من العملية الأب. إذا استدعي هذا التابع دون وسائط يُعاد القناع الحالي، وإلّا فسيضبط umask بقيمة الوسيط ويعاد القناع السابق.<syntaxhighlight lang="javascript">
const newmask = 0o022;
const oldmask = process.umask(newmask);
console.log(
  `Changed umask from ${oldmask.toString(8)} to ${newmask.toString(8)}`
);

</syntaxhighlight>هذه الميزة ليست متوافرة في خيوط Worker.

== <code>process.uptime(‎)</code>‎ ==
أُضيف في الإصدار: 0.5.0.
* القيمة المعادة:<number>
يعيد التابع <code>process.uptime(‎)</code>‎ عدد الثواني التي مضت منذ بدء العملية الحالية.

القيمة المُعادة تتضمن أجزاءً من الثواني. استخدم <code>Math.floor(‎)</code>‎ للحصول على ثوانٍ كاملةٍ.

== <code>process.version</code> ==
أُضيفت في الإصدار: 0.1.3.
* <string>
تعيد الخاصية <code>process.version</code> سلسلةً نصيةً تحتوي إصدار Node.js.<syntaxhighlight lang="javascript">
console.log(`Version: ${process.version}`);
</syntaxhighlight>

== <code>process.versions</code> ==
سجل التغييرات

{| class="wikitable"
!الإصدار
!التغييرات
|-
|9.0.0.
|تتضمن الخاصية v8 الآن لواحق Node.js محدّدة (specific suffix).
|-
|4.2.0.
|دُعمت الخاصية icu الآن.
|-
|0.2.0.
|أُضيفت في الإصدار 0.2.0.
|}
* <Object>
تعيد الخاصية <code>process.versions</code> كائن مُجدوِل لسلسلة إصدرات Node.js واعتماديتها. تبيّن <code>process.versions.modules</code> إصدار ABI الحالي، والذي يزداد كلما تغيرت واجهات C+‎+‎ البرمجية C++ API. سترفض Node.js تحميل وحدات مُصرَّفة (compiled) مع إصدار ABI مختلف.<syntaxhighlight lang="javascript">
console.log(process.versions);
</syntaxhighlight>سوف تولّد كائن مشابهًا إلى:<syntaxhighlight lang="javascript">
{ http_parser: '2.7.0',
  node: '8.9.0',
  v8: '6.3.292.48-node.6',
  uv: '1.18.0',
  zlib: '1.2.11',
  ares: '1.13.0',
  modules: '60',
  nghttp2: '1.29.0',
  napi: '2',
  openssl: '1.0.2n',
  icu: '60.1',
  unicode: '10.0',
  cldr: '32.0',
  tz: '2016b' }
</syntaxhighlight>

== حالات الخروج (Exit Codes) ==
سوف تنتهي Node.js عادةً بحالة الخروج 0 عندما لا يكون هناك المزيد من العمليات غير المتزامنة المعلّقة. تُستخدم شيفرات الحالة التالية في ظروف أخرى:
* <code>1</code> '''Uncaught Fatal Exception''' (استثناء قاتل غير مُلتقط) - يوجد استثناء غير مُلتقط، ولم يعُالج من قبل النطاق (domain) أو معالج الأحداث 'uncaughtException'.

* <code>2</code> - Unused غير مُستخدمة (محجوزة من قبل Bash من أجل سوء الاستخدام الضمني)

* <code>3</code> '''Internal JavaScript Parse Error''' (خطأ إعراب/تحليل JavaScript داخلي)
تسببت شيفرة JavaScript المصدرية الداخلية بخطأ تحليلي في عملية تمهيد تشغيل Node.js. هذا نادر للغاية، وعمومًا يمكن أن يحدث فقط خلال تطوير Node.js نفسها.
* <code>4</code> '''Internal JavaScript Evaluation Failure''' (فشل تقييم JavaScript داخلي)
تفشل شيفرة JavaScript المصدرية الداخلية بإعادة قيمة تابع عند التقييم في عملية تمهيد تشغيل Node.js. هذا نادر للغاية، وعمومًا يمكن أن يحدث فقط خلال تطوير Node.js نفسها.
* <code>5</code> <code>Fatal Error</code> (خطأ قاتل)
وجِد خطأ قاتل لا يمكن إصلاحه في V8. نموذجيًا سوف تُطبع رسالة إلى مجرى الخطأ القياسي stderr مع البادئة <code>FATAL ERROR</code>.
* <code>6</code> '''Non-function Internal Exception Handler''' (معالج الاستثناءات الداخلي منعدم الدالة)
وجِد استثناء غير مُلتقط، ولكن بطريقة ما ضُبطت دالة معالج الاستثناءات القاتلة الداخلية إلى منعدم-دالة، ولا يمكن استدعائها.
* <code>7</code> '''Internal Exception Handler Run-Time Failure''' (فشل وقت التشغيل لمعالج
الاستثناء الداخلي)

وُجِد استثناء غير مُلتقط، ورمت دالة معالجة الاستثناءات القاتلة الداخلية بنفسها خطأً عند محاولة معالجته [الخطأ الأول]. يمكن أن يحصل هذا، على سبيل المثال، إذا رمى معالج 'uncaughtException' أو <code>domain.on('error‎'‎)</code>‎ خطأً.
* <code>8</code> - Unused. غير مستخدمة
في الإصدارات السابقة من Node.js كانت حالة الخروج 8 تُعبّر أحيانًا عن استثناء غير مُلتقط.
* <code>9</code> - '''Invalid Argument''' (وسيط غير صالح)
إمّا أنه حُدد خيار غير معروف أو أنّ الخيار الذي يتطلب قيمة زُوِد بدون قيمة.
* <code>10</code> '''Internal JavaScript Run-Time Failure''' (فشل JavaScript داخلي وقت التشغيل)
ترمي شيفرة JavaScript المصدرية الداخلية خطأً عند استدعاء دالة تمهيد التشغيل في عملية تمهيد تشغيل Node.js. هذا نادر للغاية، وعمومًا يمكن أن يحصل فقط خلال تطوير Node.js نفسها.
* <code>12</code> '''Invalid Debug Argument''' (وسيط تنقيح غير صالح)
تُجهّز الخيارات <code>‎-‎‎-‎‎inspect‎‎</code> أو/و <code>‎-‎‎-‎‎inspect-‎‎brk‎‎</code> ، لكن رقم المنفذ المختار غير صالح أو غير متوافر.
* <code>>128</code> Signal Exits مخارج الإشارات
إذا تلقّت Node.js إشارةً قاتلةً مثل <code>SIGKILL</code> أو <code>SIGHUP</code>، عندها ستكون حالة الخروج تساوي <code>128</code> إضافةً إلى قيمة شيفرة الإشارة. هذه ممارسة POSIX قياسية، منذ أن عُرِّفت حالات الخروج لتكون عدد صحيح ذو 7 بتات، ومخارج الإشارات تضع البت الأعلى ترتيبًا، ومن ثم تُضَمِّن قيمة شيفرة الإشارة، على سبيل المثال، قيمة الإشارة <code>SIGABRT</code> هي <code>6</code>، لذلك ستكون حالة الخروج هي <code>128+6</code>، أو <code>134</code>.

== مصادر ==
* [https://nodejs.org/dist/latest-v10.x/docs/api/process.html صفحة Process في توثيق Node.js الرسمي.]
[[تصنيف:Node.js]]