Node.js நிரலுக்கு கட்டளை வரி வாதங்களை அனுப்புதல்

கட்டளை வரி வாதங்களுடன் Node.js சேவையகத்தைத் தொடங்குதல்

Node.js என்பது வலை சேவையகங்கள் மற்றும் பயன்பாடுகளை உருவாக்குவதற்கான ஒரு சக்திவாய்ந்த தளமாகும். ஒரு பொதுவான தேவை ஒரு Node.js சேவையகத்தை குறிப்பிட்ட அளவுருக்கள் அல்லது கோப்புறையைக் குறிப்பிடுவது போன்ற வாதங்களுடன் தொடங்குவது. சர்வர் ஸ்கிரிப்டை இயக்கும்போது கட்டளை வரி வாதங்களை அனுப்புவதன் மூலம் இதை அடையலாம்.

உங்கள் Node.js குறியீட்டில் இந்த வாதங்களை எவ்வாறு அணுகுவது என்பதைப் புரிந்துகொள்வது, பயனர் உள்ளீடு அல்லது உள்ளமைவு அமைப்புகளின் அடிப்படையில் உங்கள் சேவையகத்தின் நடத்தையைத் தனிப்பயனாக்குவதற்கு முக்கியமானது. இந்த வழிகாட்டி Node.js நிரலில் கட்டளை வரி வாதங்களை எவ்வாறு திறம்பட அனுப்புவது மற்றும் மீட்டெடுப்பது என்பதைக் காண்பிக்கும்.

கட்டளை	விளக்கம்
process.argv	Node.js செயல்முறைக்கு அனுப்பப்பட்ட கட்டளை வரி வாதங்களைக் கொண்ட வரிசை.
require('http')	இணைய சேவையகங்களை உருவாக்குவதற்கான உள்ளமைக்கப்பட்ட HTTP தொகுதியை இறக்குமதி செய்கிறது.
require('url')	URL தீர்மானம் மற்றும் பாகுபடுத்தலுக்கான உள்ளமைக்கப்பட்ட URL தொகுதியை இறக்குமதி செய்கிறது.
require('fs')	கோப்பு முறைமையுடன் தொடர்புகொள்வதற்காக உள்ளமைக்கப்பட்ட கோப்பு முறைமை தொகுதியை இறக்குமதி செய்கிறது.
require('path')	கோப்பு மற்றும் அடைவு பாதைகளுடன் பணிபுரிய உள்ளமைக்கப்பட்ட பாதை தொகுதியை இறக்குமதி செய்கிறது.
url.parse()	URL பண்புகளைக் கொண்ட பொருளில் URL சரத்தை பாகுபடுத்துகிறது.
path.join()	பிளாட்ஃபார்ம்-குறிப்பிட்ட பிரிப்பானைப் பிரிப்பானாகப் பயன்படுத்தி கொடுக்கப்பட்ட அனைத்து பாதைப் பிரிவுகளையும் ஒன்றாக இணைக்கிறது.
fs.readFile()	ஒரு கோப்பின் முழு உள்ளடக்கத்தையும் ஒத்திசைவின்றி படிக்கிறது.

Node.js கட்டளை வரி வாதங்களைப் புரிந்துகொள்வது

வழங்கப்பட்ட ஸ்கிரிப்ட்களில், Node.js நிரலில் கட்டளை வரி வாதங்களை எவ்வாறு அனுப்புவது மற்றும் அணுகுவது என்பதை நாங்கள் விளக்குகிறோம். சர்வர் ஸ்கிரிப்ட் பல Node.js தொகுதிகளைப் பயன்படுத்துகிறது, இதில் அடங்கும் , , , மற்றும் require('path'). இந்த தொகுதிகள் ஒரு எளிய HTTP சேவையகத்தை உருவாக்குவதற்கும், URLகளை பாகுபடுத்துவதற்கும், கோப்பு முறைமையை கையாளுவதற்கும் மற்றும் கோப்பு பாதைகளுடன் வேலை செய்வதற்கும் அவசியம். போன்ற கட்டளையுடன் சேவையகம் தொடங்கப்படும் போது , கோப்புறை வாதம் வழியாக ஸ்கிரிப்ட்டுக்கு அனுப்பப்படுகிறது வரிசை. இந்த வரிசையில் அனைத்து கட்டளை வரி வாதங்களும் உள்ளன 'முனை' இருப்பது, process.argv[1] ஸ்கிரிப்ட் பாதை, மற்றும் அடுத்தடுத்த கூறுகள் கூடுதல் வாதங்கள்.

ஸ்கிரிப்ட் முதலில் கோப்புறை வாதம் வழங்கப்பட்டுள்ளதா என்பதைச் சரிபார்க்கிறது . இல்லையெனில், அது ஒரு பிழை செய்தியை பதிவுசெய்து வெளியேறும். வாதம் இருந்தால், சர்வர் பயன்படுத்தி உருவாக்கப்படும் . சேவையகம் கோரப்பட்ட URL ஐப் படித்து, அதைப் பயன்படுத்தி வழங்கப்பட்ட கோப்புறை பாதையுடன் இணைக்கிறது , மற்றும் பயன்படுத்தி தொடர்புடைய கோப்பை படிக்க முயற்சிக்கிறது fs.readFile(). கோப்பு கண்டுபிடிக்கப்பட்டால், அது கோப்பு உள்ளடக்கத்தை மறுமொழியாக அனுப்புகிறது; இல்லையெனில், அது 404 பிழையை வழங்குகிறது. இந்த அணுகுமுறை, சர்வர் குறிப்பிட்ட கோப்புறையிலிருந்து கோப்புகளை வழங்குவதை உறுதிசெய்கிறது, சர்வர் நடத்தையை மாறும் வகையில் தனிப்பயனாக்க கட்டளை வரி வாதங்களை எவ்வாறு கையாள்வது என்பதை விளக்குகிறது.

// server.js
const http = require('http');
const url = require('url');
const fs = require('fs');
const path = require('path');

// Get the folder from the command line arguments
const folder = process.argv[2];

// Check if the folder argument is provided
if (!folder) {
  console.error('Please provide a folder path');
  process.exit(1);
}

const server = http.createServer((req, res) => {
  const parsedUrl = url.parse(req.url);
  let pathname = path.join(folder, parsedUrl.pathname);

  fs.readFile(pathname, (err, data) => {
    if (err) {
      res.statusCode = 404;
      res.end(`File not found: ${pathname}`);
    } else {
      res.statusCode = 200;
      res.end(data);
    }
  });
});

server.listen(3000, () => {
  console.log('Server listening on port 3000');
  console.log(`Serving files from ${folder}`);
});

# Launch the server with the specified folder
$ node server.js path/to/your/folder

// process.argv is an array containing command line arguments
// process.argv[0] is 'node'
// process.argv[1] is the path to the script being executed
// process.argv[2] and beyond are the additional command line arguments
console.log(process.argv);

/* Output when running 'node server.js folder':
  [
    '/usr/local/bin/node',
    '/path/to/server.js',
    'folder'
  ]
*/

Node.js இல் கட்டளை வரி வாதங்களை விரிவுபடுத்துகிறது

கட்டளை வரி வாதங்களை அனுப்புதல் மற்றும் மீட்டெடுப்பதற்கான அடிப்படைகளுக்கு அப்பால், Node.js இல் கருத்தில் கொள்ள வேண்டிய பிற மேம்பட்ட நுட்பங்கள் மற்றும் சிறந்த நடைமுறைகள் உள்ளன. அத்தகைய ஒரு நுட்பம் நூலகங்களைப் பயன்படுத்தி கட்டளை வரி வாதங்களைப் பாகுபடுத்துவதை உள்ளடக்கியது அல்லது . இந்த நூலகங்கள் வாதங்களைக் கையாள மிகவும் பயனர் நட்பு வழியை வழங்குகின்றன, விருப்பங்களை வரையறுக்கவும், இயல்புநிலை மதிப்புகளை அமைக்கவும் மற்றும் தேவையான வாதங்களைச் செயல்படுத்தவும் உங்களை அனுமதிக்கிறது. உதாரணமாக, உடன் , நீங்கள் வாதங்களை ஒரு பொருளில் அலசலாம், அவற்றை அணுகுவதையும் நிர்வகிப்பதையும் எளிதாக்குகிறது. உள்ளமைவு மற்றும் நடத்தையில் கட்டளை வரி வாதங்கள் முக்கிய பங்கு வகிக்கும் பெரிய பயன்பாடுகளில் இது மிகவும் பயனுள்ளதாக இருக்கும்.

மற்றொரு முக்கியமான அம்சம் வாதங்களுக்கு வெவ்வேறு தரவு வகைகளைக் கையாள்வது. முன்னிருப்பாக, அனைத்து கட்டளை வரி வாதங்களும் சரங்களாகக் கருதப்படுகின்றன. போன்ற நூலகங்களைப் பயன்படுத்துதல் அல்லது , ஒரு வாதத்தை எண், பூலியன் அல்லது சரமாக பாகுபடுத்த வேண்டுமா என்பதை நீங்கள் குறிப்பிடலாம். உங்கள் பயன்பாடு வாதங்களை சரியாக விளக்குகிறது என்பதை இது உறுதி செய்கிறது. கூடுதலாக, இந்த நூலகங்கள் வாதங்களுக்கு மாற்றுப்பெயர்களை அமைக்க உங்களை அனுமதிக்கின்றன, இதனால் கட்டளை வரி இடைமுகம் பயனர்களுக்கு மிகவும் உள்ளுணர்வுடன் இருக்கும். இந்த நடைமுறைகளைச் செயல்படுத்துவது உங்கள் Node.js பயன்பாடுகளின் வலிமையை மேம்படுத்துவது மட்டுமல்லாமல் தெளிவான மற்றும் நெகிழ்வான கட்டளை வரி விருப்பங்களை வழங்குவதன் மூலம் பயனர் அனுபவத்தை மேம்படுத்துகிறது.

1. Node.js இல் கட்டளை வரி வாதங்களை எவ்வாறு அணுகுவது?
2. இதைப் பயன்படுத்தி கட்டளை வரி வாதங்களை அணுகலாம் வரிசை.
3. என்ன பயன் கட்டளை வரி வாதங்களைக் கையாள்வதில்?
4. கட்டளை வரி வாதங்களை மிகவும் நிர்வகிக்கக்கூடிய பொருள் வடிவத்தில் பாகுபடுத்த உதவும் ஒரு நூலகம்.
5. கட்டளை வரி மதிப்புருக்களுக்கு இயல்புநிலை மதிப்புகளை அமைக்க முடியுமா?
6. ஆம், நூலகங்கள் போன்றவை மற்றும் வாதங்களுக்கு இயல்புநிலை மதிப்புகளை அமைக்க அனுமதிக்கவும்.
7. தேவையான வாதங்களை நான் எவ்வாறு செயல்படுத்துவது?
8. போன்ற நூலகங்களைப் பயன்படுத்துதல் , எந்த வாதங்கள் தேவை என்பதை நீங்கள் வரையறுக்கலாம் மற்றும் அவை விடுபட்டிருந்தால் பிழை செய்திகளை வழங்கலாம்.
9. கட்டளை வரி வாதங்களுக்கு வெவ்வேறு தரவு வகைகளை எவ்வாறு கையாள்வது?
10. போன்ற நூலகங்களுடன் எண், பூலியன் அல்லது சரம் போன்ற வாத வகைகளை நீங்கள் குறிப்பிடலாம்.
11. வாதம் மாற்றுப்பெயர்கள் என்றால் என்ன, அவை எவ்வாறு பயனுள்ளதாக இருக்கும்?
12. ஆர்குமென்ட் மாற்றுப்பெயர்கள் கட்டளை வரி விருப்பங்களுக்கான மாற்று பெயர்கள், இது CLI ஐ மிகவும் பயனர் நட்புடன் ஆக்குகிறது. போன்ற நூலகங்களைப் பயன்படுத்தி மாற்றுப்பெயர்களை அமைக்கலாம் .
13. பல வாதங்களை ஒன்றாக இணைக்க முடியுமா?
14. ஆம், வாதத்தை பாகுபடுத்தும் நூலகங்களைப் பயன்படுத்துவதன் மூலம், நீங்கள் பல வாதங்களை ஒருங்கிணைத்து அவற்றை ஒரே கட்டமைப்பு பொருளாகக் கையாளலாம்.
15. கட்டளை வரி வாதத்தை பாகுபடுத்துவதில் பிழைகளை எவ்வாறு கையாள்வது?
16. நூலகங்கள் போன்றவை பயனர் நட்பு பிழை செய்திகளைக் காண்பிக்க உள்ளமைக்கப்பட்ட பிழை கையாளும் வழிமுறைகளை வழங்கவும்.
17. கட்டளை வரி வாதங்களுடன் சூழல் மாறிகளை நான் பயன்படுத்தலாமா?
18. ஆம், Node.js பயன்பாடுகளை உள்ளமைக்க சூழல் மாறிகள் மற்றும் கட்டளை வரி வாதங்கள் இரண்டையும் பயன்படுத்துவது பொதுவானது.

Node.js இல் கட்டளை வரி வாதங்களை எவ்வாறு கடந்து செல்வது மற்றும் அணுகுவது என்பதைப் புரிந்துகொள்வது நெகிழ்வான மற்றும் மாறும் பயன்பாடுகளை உருவாக்குவதற்கு முக்கியமானது. உள்ளமைக்கப்பட்ட தொகுதிகள் மற்றும் மூன்றாம் தரப்பு நூலகங்களை மேம்படுத்துவதன் மூலம், டெவலப்பர்கள் திறமையாக வாதங்களைக் கையாளலாம், இயல்புநிலைகளை அமைக்கலாம் மற்றும் தேவைகளைச் செயல்படுத்தலாம். இந்த அறிவு குறியீட்டு வலிமையை மேம்படுத்துவது மட்டுமல்லாமல் தெளிவான மற்றும் நிர்வகிக்கக்கூடிய கட்டளை வரி விருப்பங்களை வழங்குவதன் மூலம் பயனர் அனுபவத்தை மேம்படுத்துகிறது. இந்த நுட்பங்களில் தேர்ச்சி பெறுவது, உள்ளமைக்கக்கூடிய மற்றும் அளவிடக்கூடிய பயன்பாடுகளை உருவாக்குவதை நோக்கமாகக் கொண்ட எந்தவொரு Node.js டெவலப்பருக்கும் மதிப்புமிக்க திறமையாகும்.