ஜாவாஸ்கிரிப்ட்டில் ஒரு மாறி ஒரு சரமா என்பதை எவ்வாறு சரிபார்ப்பது

ஜாவாஸ்கிரிப்டில் மாறி வகைகளைப் புரிந்துகொள்வது

ஜாவாஸ்கிரிப்டில் ஒரு மாறியின் வகையைத் தீர்மானிப்பது டெவலப்பர்களுக்கான அடிப்படைத் திறனாகும். பல்வேறு தரவு வகைகளில், உரை மற்றும் எழுத்துக்களைக் கையாள்வதில் சரங்கள் முக்கியப் பங்கு வகிக்கின்றன.

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

ஜாவாஸ்கிரிப்டில் சரம் வகை சரிபார்ப்பை ஆய்வு செய்தல்

முதல் ஸ்கிரிப்ட் ஜாவாஸ்கிரிப்டைப் பயன்படுத்தி முன்பக்க செயலாக்கத்தில் கவனம் செலுத்துகிறது. இது இரண்டு முதன்மை முறைகளைப் பயன்படுத்துகிறது: typeof மற்றும் instanceof. தி typeof ஆபரேட்டர் என்பது ஒரு மாறியின் வகையை தீர்மானிக்க ஒரு நேரடியான வழியாகும். ஒரு மாறியில் பயன்படுத்தப்படும் போது, ​​அது 'ஸ்ட்ரிங்', 'எண்' அல்லது 'பூலியன்' போன்ற வகையைக் குறிக்கும் சரத்தை வழங்குகிறது. இந்த முறை எளிமையானது மற்றும் பழமையான சரம் மதிப்புகளுக்கு பயனுள்ளதாக இருக்கும். மறுபுறம், தி instanceof ஒரு பொருள் ஒரு குறிப்பிட்ட கட்டமைப்பாளரின் உதாரணமா என்பதை ஆபரேட்டர் சரிபார்க்கிறார். இதைப் பயன்படுத்தி உருவாக்கப்பட்ட சரம் பொருள்களுடன் பணிபுரியும் போது இது பயனுள்ளதாக இருக்கும் new String() கட்டமைப்பாளர். ஸ்கிரிப்ட் இரண்டு முறைகளையும் எடுத்துக்காட்டுகளுடன் விளக்குகிறது, இது பழமையான சரங்கள் மற்றும் சரம் பொருள்கள் இரண்டிற்கும் விரிவான வகை சரிபார்ப்பை உறுதி செய்கிறது.

இரண்டாவது ஸ்கிரிப்ட் Node.js ஐப் பயன்படுத்தி பின்தள சரிபார்ப்பைக் குறிக்கிறது. இது இறக்குமதி செய்வதன் மூலம் தொடங்குகிறது http தொகுதி மற்றும் ஒரு HTTP சேவையகத்தை உருவாக்குகிறது http.createServer() செயல்பாடு. சேவையகம் பயன்படுத்தும் URL பாதையிலிருந்து ஒரு மதிப்பைப் பிரித்தெடுக்கிறது req.url மற்றும் அது ஒரு சரமா என்பதை சரிபார்க்கிறது. தி typeof மதிப்பின் வகையைத் தீர்மானிக்க ஆபரேட்டர் இங்கே பயன்படுத்தப்படுகிறது. முடிவுகளின் அடிப்படையில், சேவையகம் பொருத்தமான செய்திகளுடன் பதிலளிக்கிறது. தி res.writeHead() நிலைக் குறியீடு மற்றும் உள்ளடக்க வகை உள்ளிட்ட பதில் தலைப்புகளை முறை அமைக்கிறது res.end() முறை இறுதி பதிலை வாடிக்கையாளருக்கு அனுப்புகிறது. போர்ட் 3000 இல் உள்வரும் கோரிக்கைகளை சர்வர் கேட்கிறது, இது பின்தள சூழலில் சரம் வகை சரிபார்ப்புக்கான நடைமுறை உதாரணத்தை வழங்குகிறது.

// Method 1: Using typeof
function isString(value) {
  return typeof value === 'string';
}
// Example usage
console.log(isString("Hello")); // true
console.log(isString(123)); // false

// Method 2: Using instanceof
function isString(value) {
  return value instanceof String || typeof value === 'string';
}
// Example usage
console.log(isString(new String("Hello"))); // true
console.log(isString("World")); // true
console.log(isString(123)); // false

const http = require('http');
// Create an HTTP server
const server = http.createServer((req, res) => {
  let value = req.url.substring(1); // Get value from URL path
  if (typeof value === 'string') {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('The value is a string');
  } else {
    res.writeHead(400, {'Content-Type': 'text/plain'});
    res.end('The value is not a string');
  }
});
server.listen(3000, () => {
  console.log('Server is running at http://localhost:3000');
});

ஜாவாஸ்கிரிப்டில் சரம் சரிபார்ப்புக்கான மேம்பட்ட முறைகள்

அடிப்படை தவிர typeof மற்றும் instanceof முறைகள், ஜாவாஸ்கிரிப்ட் சரம் சரிபார்ப்புக்கான பிற மேம்பட்ட நுட்பங்களை வழங்குகிறது. அத்தகைய ஒரு முறை பயன்படுத்தப்படுகிறது Object.prototype.toString.call() செயல்பாடு. இந்த அணுகுமுறை பயனுள்ளதாக இருக்கும், ஏனெனில் இது ஒரு மாறியின் சரியான வகையை தீர்மானிக்க மிகவும் நம்பகமான வழியை வழங்குகிறது. அழைப்பதன் மூலம் Object.prototype.toString.call(value), நீங்கள் சரம் மதிப்புகளுக்கு "[object String]" போன்ற ஒரு சரத்தைப் பெறுவீர்கள், பின்னர் மாறி ஒரு சரம் என்பதை உறுதிப்படுத்த ஒப்பிடலாம். மாறியின் வகை உடனடியாகத் தெரியாமல் இருக்கும் சிக்கலான கோட்பேஸ்களில் இந்த முறை மிகவும் பயனுள்ளதாக இருக்கும்.

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

ஜாவாஸ்கிரிப்டில் மாறி வகை சரிபார்ப்பை மூடுதல்

நம்பகமான மற்றும் திறமையான குறியீட்டை எழுதுவதற்கு ஜாவாஸ்கிரிப்டில் ஒரு மாறி ஒரு சரமா என்பதை தீர்மானிப்பது மிகவும் முக்கியமானது. போன்ற முறைகளைப் பயன்படுத்துதல் typeof, instanceof, மற்றும் மேம்பட்ட நுட்பங்கள் போன்றவை Object.prototype.toString.call() மற்றும் வழக்கமான வெளிப்பாடுகள் விரிவான சரிபார்ப்பை உறுதி செய்கிறது. இந்த உத்திகளைப் பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் மாறி வகைகளை நம்பிக்கையுடன் நிர்வகிக்கலாம், குறியீடு நிலைத்தன்மையை மேம்படுத்தலாம் மற்றும் இயக்க நேரப் பிழைகளைக் குறைக்கலாம்.