Node.js හි පිටවන්නේ කෙසේද?

පිටවීම සඳහා භාවිතා කරන විධානය කුමක්ද? (එනම් Node.js ක්‍රියාවලිය අවසන් කරන්න)

ගෝලීය processවස්තුවේ exitක්‍රමය අමතන්න :

process.exit()

ලියකියවිලි වලින්:

process.exit ([කේතය])

නිශ්චිතව දක්වා ඇති ක්‍රියාවලිය අවසන් කරයි code. ඉවත් කර ඇත්නම්, පිටවීම 'සාර්ථක' කේතය භාවිතා කරයි 0.

'අසාර්ථක' කේතයක් සමඟ පිටවීමට:

process.exit(1);

නෝඩ් ක්‍රියාත්මක කළ කවචය පිටවීමේ කේතය ලෙස දැකිය යුතුය 1.

භාවිතා කිරීම නිර්දේශිත නොවන බව සටහනක් පමණි .process.exit([number])

ඇමතුම් process.exit()තවමත් I / O මෙහෙයුම් ඇතුළුව එම තවමත් සම්පූර්ණයෙන්ම සම්පූර්ණ කර නැති තෙක් අසමමිතික මෙහෙයුම්, එහි දී පවා, හැකි තරම් ඉක්මනින් පිටවීම සඳහා මෙම ක්රියාවලිය බල කරනු ඇත process.stdoutහා process.stderr.

බොහෝ අවස්ථාවන්හීදී, process.exit()පැහැදිලිවම පැහැදිලිව ඇමතීම අවශ්‍ය නොවේ . සිදුවීම් ලූපයේ අමතර වැඩක් ඉතිරිව නොමැති නම් Node.js ක්‍රියාවලිය තනිවම පිටව යනු ඇත. මෙම process.exitCodeදේපල පිටවීම් කේතය යකා විට එම ක්රියාවලිය පිටවීම් දොරටු භාවිතා කිරීමට ඇති ක්රියාවලිය කියන්න සකස් කළ හැකි ය.

නිදසුනක් ලෙස, පහත දැක්වෙන උදාහරණයෙන් දැක්වෙන්නේ දත්ත මුද්‍රණය කර නැතිවී යාමට තුඩු දිය හැකි ක්‍රමවේදය අනිසි ලෙස භාවිතා කිරීමයි :process.exit()stdout

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

මෙය ගැටළු සහගත වීමට හේතුව වන්නේ process.stdoutNode.js හි ලිවීම සමහර විට අසමමුහුර්ත වන අතර Node.js සිදුවීම් පුඩුවේ බහුවිධ කිනිතුල්ලන් හරහා සිදුවිය හැකි බැවිනි. ඇමතුම් process.exit(), කෙසේ වෙතත්, මෙම ක්රියාවලිය පිටවීමේ කිරීමට එම අතිරේක මෙසේ ලියයි පෙර බලකරනු stdoutසිදු කළ හැකිය.

process.exit()කෙලින්ම ඇමතීම වෙනුවට , කේතය මඟින් සැකසිය යුතු process.exitCodeඅතර සිදුවීම් ලූපය සඳහා අමතර වැඩක් උපලේඛනගත කිරීමෙන් වැළකීමෙන් ක්‍රියාවලිය ස්වභාවිකව පිටවීමට ඉඩ දිය යුතුය :

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

නිල nodejs.org ප්‍රලේඛනයෙන්:

process.exit(code)

නිශ්චිත කේතය සමඟ ක්‍රියාවලිය අවසන් කරයි. ඉවත් කර ඇත්නම්, පිටවීම 'සාර්ථක' කේතය 0 භාවිතා කරයි.

'අසාර්ථක' කේතයක් සමඟ පිටවීමට:

process.exit(1);

ඔබ යුනික්ස් ටර්මිනල් හෝ වින්ඩෝස් විධාන රේඛාවක සිටින අතර නෝඩ් REPL වෙතින් පිටවීමට අවශ්‍ය නම් ...

• Ctrl+ Cදෙවරක් ඔබන්න , හෝ
• ටයිප් .exitකර Enter යතුර ඔබන්න, හෝ
• පේළියක ආරම්භයේ Ctrl+ ඔබන්න D(යුනික්ස් පමණි)

විධාන රේඛාවේ සිට .exitඔබට අවශ්‍ය දේ මෙයයි:

$ node
> .exit
$

එය REPL ලියකියවිලි වල ලේඛනගත කර ඇත . REPL (Read-Eval-Print-Loop) යනු නෝඩ් විධාන රේඛාව ලෙස හැඳින්වේ.

සාමාන්‍ය වැඩසටහනකින් භාවිතා කරන්න process.exit([code]).

එය ඔබ සතු පිට වීමේ node.js ක්රියාවලිය කිරීමට කැමති හේතුව මත රඳා පවතී, නමුත් කිසිදු අවස්ථාවක process.exit()තමයි සලකා අවසන් විකල්පය . ප්‍රලේඛනයෙන් උපුටා ගැනීමක්:

එය ඉල්ලා බව සටහන් කිරීම වැදගත් වේ process.exit()තවමත් I / O මෙහෙයුම් ඇතුළුව එම තවමත් සම්පූර්ණයෙන්ම සම්පූර්ණ කර නැති තෙක් අසමමිතික මෙහෙයුම්, එහි දී පවා, හැකි තරම් ඉක්මනින් පිටවීම සඳහා මෙම ක්රියාවලිය බල කරනු ඇත process.stdoutහා process.stderr.

බොහෝ අවස්ථාවන්හීදී, process.exit()පැහැදිලිවම පැහැදිලිව ඇමතීම අවශ්‍ය නොවේ . සිදුවීම් ලූපයේ අමතර වැඩක් නොමැති නම් Node.js ක්‍රියාවලිය තනිවම පිටව යනු ඇත. මෙම process.exitCodeදේපල පිටවීම් කේතය යකා විට එම ක්රියාවලිය පිටවීම් දොරටු භාවිතා කිරීමට ඇති ක්රියාවලිය කියන්න සකස් කළ හැකි ය.

ඔබ node.js ක්‍රියාවලියෙන් ඉවත් වීමට කැමති විය හැකි හේතු සහ ඔබ වැළකී සිටිය යුත්තේ ඇයිද යන්න අපි ආවරණය කරමු process.exit().

1 වන අවස්ථාව - ක්‍රියාත්මක කිරීම සම්පූර්ණයි (විධාන රේඛා පිටපත)

ස්ක්‍රිප්ට් එහි අවසානයට පැමිණ තිබේ නම් සහ නෝඩ් පරිවර්තකය පිටවන්නේ නැතිනම්, එයින් පෙන්නුම් කරන්නේ සමහර අසින්ක් මෙහෙයුම් තවමත් ඉතිරිව ඇති බවයි. process.exit()මෙම අවස්ථාවෙහිදී ක්‍රියාවලිය අවසන් කිරීමට බල කිරීම වැරදිය . අපේක්ෂිත ආකාරයෙන් පිටවීමෙන් ඔබේ පිටපත රඳවා තබා ගන්නේ කුමක් දැයි තේරුම් ගැනීමට උත්සාහ කිරීම වඩා හොඳය . ඔබ මෙය නිරාකරණය කළ විට, process.exitCodeඇමතුම් ක්‍රියාවලියට ඕනෑම ප්‍රති result ලයක් ලබා දීමට ඔබට භාවිතා කළ හැකිය .

2 වන අවස්ථාව - බාහිර සං signal ාව නිසා අවසන් කිරීම (SIGINT / SIGTERM / වෙනත්)

නිදසුනක් ලෙස, ඔබ සී express ්‍රගාමී යෙදුමක් මනාව වසා දැමීමට කැමති නම් . විධාන රේඛා ස්ක්‍රිප්ට් මෙන් නොව, සී express ්‍රගාමී යෙදුම නව ඉල්ලීම් එනතෙක් බලා සිටී. process.exit()මෙහි නරක විකල්පයක් වනු ඇත්තේ එය නල මාර්ගයේ ඇති සියලුම ඉල්ලීම් වලට බාධා කරන බැවිනි. ඔවුන්ගෙන් සමහරක් අවිනිශ්චිත නොවන අය විය හැකිය (UPDATE, DELETE). සේවාදායකයාගේ පැත්තේ එම ඉල්ලීම් සම්පුර්ණ වී ඇත්දැයි සේවාදායකයා කිසි විටෙකත් නොදන්නා අතර එය සේවාදායකයා සහ සේවාදායකයා අතර දත්ත නොගැලපීමට හේතුව විය හැකිය. එකම හොඳ විසඳුම වන්නේ නව ඉල්ලීම් පිළිගැනීම නවත්වන ලෙස http සේවාදායකයට පැවසීම සහ අපේක්ෂිත ඒවා අවසන් වන තෙක් බලා සිටීම server.close():

var express = require('express');
var app = express();
var server = app.listen(80);

process.on( 'SIGTERM', function () {
   server.close(function () {
     console.log("Finished all requests");
   });
});

එය තවමත් පිටව නොයන්නේ නම් - 1 වන අවස්ථාව බලන්න.

3 වන අවස්ථාව - අභ්‍යන්තර දෝෂයකි

එය සෑම විටම throwදෝෂයකට වඩා හොඳය , ඔබට මනාව හැඩගස්වා ඇති සිරස් හෝඩුවාවක් සහ දෝෂ පණිවිඩයක් ලැබෙනු ඇත. ඉහළ මට්ටමේ කේත සෑම විටම ඔවුන්ට දෝෂ ( catch) හැසිරවිය හැකිද යන්න තීරණය කළ හැකිය . අනෙක් පැත්තෙන් process.exit(1)නිහ ly ව ක්‍රියාවලිය අවසන් වන අතර මෙයින් සුවය ලැබීමට අවස්ථාවක් නොලැබෙනු ඇත. එය එකම “ප්‍රතිලාභය” විය process.exit()හැකිය, ක්‍රියාවලිය අවසන් වන බවට ඔබට සහතික විය හැකිය.

REPL (විධාන රේඛාව)

• දෙවරක් ඔබන්නctrl + c

• ටයිප් .exitකර enter ඔබන්න

ස්ක්‍රිප්ට් ගොනුව

process.exit(code)

තවත් අසින්ක් මෙහෙයුම් නොමැති විට නෝඩ් සාමාන්‍යයෙන් 0 කේතය සමඟ පිටවෙයි .

process.exit(1) අසාර්ථක කේතයක් සමඟ පිටවීම සඳහා භාවිතා කළ යුතුය. මෙය අපට නෝඩය මනාව වැසී නැති බවත් එය වසා දැමීමට බල කෙරුණු බවත් අනුමාන කිරීමට ඉඩ දෙයි.

වැනි වෙනත් පිටවීමේ කේත තිබේ

3 - අභ්‍යන්තර ජාවාස්ක්‍රිප්ට් විග්‍රහ කිරීමේ දෝෂය (ඉතා දුර්ලභයි)

5 - v8 javascript එන්ජිමේ මාරක දෝෂයකි

9 - වලංගු නොවන තර්කය

සම්පූර්ණ ලැයිස්තුව සඳහා නෝඩ් පිටවීමේ කේත බලන්න

මට අවශ්‍ය අයදුම්පතක් මා සතුව ඇත:

1. පරිශීලකයාට විද්‍යුත් තැපෑලක් යවන්න
2. දෝෂ කේතයක් සමඟ පිටවන්න

මට සිදුවීම් හසුරුවන්නෙකු සමඟ සම්බන්ධ process.exit(code)වීමට සිදු exitවිය, නැතහොත් process.exit(code)ඇමතුම අසමමුහුර්ත සිදුවීම් කෙලින්ම ills ාතනය කරන බැවින් තැපෑල යවනු නොලැබේ .

#!/usr/bin/nodejs
var mailer = require('nodemailer');
var transport = mailer.createTransport();
mail = {
  to: 'Dave Bowman',
  from: 'HAL 9000',
  subject: 'Sorry Dave',
  html: 'Im sorry, Dave. Im afraid I cant do <B>THAT</B>.'
}
transport.sendMail(mail);
//process.exit(1);
process.on('exit', function() { process.exit(1); });

@ ඩොමිනික් පෙන්වා දුන් පරිදි, ක්‍රියාවලි ඇමතීම වෙනුවට හඳුනා නොගත් දෝෂයක් විසි කිරීම වඩා හොඳ පුරුද්දකි. Exit ([කේතය]) :
process.exitCode = 1; throw new Error("my module xx condition failed");

පිටවීමට

let exitCode = 1;
process.exit(exitCode)

ප්‍රයෝජනවත් පිටවීමේ කේත

1 - සාමාන්‍ය දෝෂ සඳහා කැචල්
2 - ෂෙල් බිල්ඩින් වැරදි ලෙස භාවිතා කිරීම (බෑෂ් ප්‍රලේඛනයට අනුව)
126 - ආයාචිත විධානය ක්‍රියාත්මක කළ නොහැක
127 - “විධානය හමු නොවීය”
128 - පිටවීම සඳහා වලංගු නොවන තර්කය
128 + n - මාරාන්තික දෝෂ සං signal ාව “n”
130 - පාලක-සී විසින් පිටපත අවසන් කරන ලදි
255 \ * - පරාසය ඉක්මවා යන තත්වයෙන් ඉවත් වන්න

Ctrl + Cදෙවරක් ඔබන්න හෝ .exit.

> 
(To exit, press ^C again or type .exit)
> 

කේතයෙන් ඔබට විකල්ප පූර්ණ සංඛ්‍යාවක් ඇති process.exit([errorcode])තැන භාවිතා කළ හැකිය [errorcode]( 0සාර්ථකත්වය දැක්වීමට පෙරනිමිය වේ).

ඔබ Read Eval Print Loop (REPL) භාවිතා කරන්නේ නම්, ඔබට Ctrl+ Dහෝ ටයිප් කළ හැකිය.exit

විකල්පයක් ලෙස, වින්ඩෝස් හෝ ලිනක්ස් වල ඔබට Ctrl+ C, Ctrl+ භාවිතා කළ හැකියC

මැක්හි විධානය Ctrl+ Z, Ctrl+ වේZ

වින්ඩෝස් 10 හි ඇති Git Bash කවචයෙන් යතුරු ලියනය කිරීමෙන් මගේ සියලුම නෝඩ් ක්‍රියාවලි කෙලින්ම මිය යාමට මට හැකි විය taskkill -F -IM node.exe- මෙය මගේ පරිගණකයේ ඇති සියලුම නෝඩ් ක්‍රියාවලි එකවරම අවසන් කරයි. මටත් භාවිතා කළ හැකි බව මට පෙනී taskkill //F //IM node.exeගියේය. දෙකම -සහ //මෙම සන්දර්භය තුළ වැඩ කරන්නේ මන්දැයි නිශ්චිතවම කිව නොහැක. මෙය උපකාරී වේ යැයි සිතමු!

ක්‍රියාවලිය ගෝලීය වස්තුවක් බැවින් ඔබට කිසිදු මොඩියුලයක් ආනයනය කිරීමට අවශ්‍ය නොවේ. පහත දැක්වෙන ශ්‍රිතය වත්මන් නෝඩ් ක්‍රියාවලියෙන් ඉවත් වේ.

process.exit (කේතය)

process.kill (process.pid)

process.abort ()

නෝඩ් යෙදුම ක්‍රියාත්මක වන විධාන රේඛා පර්යන්තය විවෘත කර Ctrl + C ඔබන්න

ඔබට කේතයෙන් node js යෙදුමෙන් පිටවීමට අවශ්‍ය නම්,

process.exit(); // graceful termination 
process.exit(1); // non graceful termination 

නෝඩ් ජේඑස් හි පිටවීම ආකාර දෙකකින් සිදු කරයි:

• අමතන්න process.exit () පැහැදිලිවම.
• නැතහොත්, nodejs සිදුවීම් ලූපය සියලු කාර්යයන් සමඟ සිදු කර ඇත්නම් සහ කිරීමට කිසිවක් ඉතිරි නොවේ. එවිට, නෝඩ් යෙදුම ස්වයංක්‍රීයව පිටව යනු ඇත.

එය ක්‍රියාත්මක වන්නේ කෙසේද?

ක්‍රියාවලිය නැවැත්වීමට ඔබට ක්‍රියාත්මක කිරීමේ ලූපය බල කිරීමට අවශ්‍ය නම්, ඔබට EventEmitter හි උදාහරණයක් වන ගෝලීය විචල්‍ය ක්‍රියාවලිය භාවිතා කළ හැකිය . එබැවින් ඔබ process.exit () අමතන විට ඇත්ත වශයෙන්ම ඔබ අසමමුහුර්ත මෙහෙයුම් සිදු කර නොතිබුණද සියලු කාර්යයන් වහාම අවසන් කරන පිටවීමේ සිදුවීම විමෝචනය කරයි .

process.exit () පරාමිතියක් ලෙස පිටවීමේ කේතයක් (පූර්ණ සංඛ්‍යාවක්) ගනී. 0 කේතය පෙරනිමිය වන අතර එයින් අදහස් කරන්නේ එය 'සාර්ථකත්වය' සමඟ පිටවන බවයි. කේතය 1 යන්නෙන් අදහස් වන්නේ එය 'අසාර්ථකත්වය' සමඟ පිටවීමයි.

ඔබ වින්ඩෝස් හි සිටී නම්, කාර්ය කළමනාකරු වෙත යන්න, ඉන්පසු ක්‍රියාවලි වෙත ගොස්, "නෝඩ්" නම් ක්‍රියාවලියක් සොයන්න, ඉන්පසු ඔබේ මූසිකයේ දකුණු බොත්තම සමඟ එය මත ක්ලික් කර "ක්‍රියාවලිය අවසන් කරන්න" විකල්පය ක්ලික් කරන්න.

ඔබට node js යෙදුමෙන් පිටවීමට අවශ්‍ය නම් ලියන්න

process.exit(1)

ඔබේ කේතයේ

ඔබට process.exit ([code]) ශ්‍රිතය භාවිතා කළ හැකිය .

ඔබට 'අසමත් වීමක්' නොමැතිව පිටවීමට අවශ්‍ය නම්, ඔබ කේතය භාවිතා කරයි 0:

process.exit(0);

'අසාර්ථක' කේතයක් සමඟ පිටවීමට 1ඔබට ක්‍රියාත්මක විය හැකිය:

process.exit(1);

අසාර්ථකත්වයේ 'අසාර්ථක' කේතය යෙදුමට විශේෂිත වේ. එබැවින් ඔබට ඒ සඳහා ඔබේම සම්මුතීන් භාවිතා කළ හැකිය.