JavaScript இல் வரையறுக்கப்படாத பொருள் பண்புகளை சரிபார்க்கிறது

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

ஜாவாஸ்கிரிப்டில், பொருள்கள் மற்றும் அவற்றின் பண்புகளை கையாள்வது டெவலப்பர்களுக்கு ஒரு பொதுவான பணியாகும். ஒரு பொருளின் குறிப்பிட்ட சொத்து வரையறுக்கப்படாததா என்பதை தீர்மானிப்பது அடிக்கடி ஏற்படும் சவால்களில் ஒன்றாகும். டைனமிக் தரவு கட்டமைப்புகளுடன் பணிபுரியும் போது அல்லது சில மதிப்புகள் வெளிப்படையாக அமைக்கப்படாத போது இது நிகழலாம்.

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

ஸ்கிரிப்ட் செயல்பாட்டின் விரிவான விளக்கம்

முதல் ஸ்கிரிப்ட் உதாரணம், கிளையன்ட் பக்கத்தில் உள்ள ஜாவாஸ்கிரிப்டைப் பயன்படுத்தி ஒரு பொருளின் சொத்து வரையறுக்கப்படவில்லை என்பதை எவ்வாறு சரிபார்க்கலாம் என்பதை விளக்குகிறது. இது ஒரு மாதிரி பொருளை அறிமுகப்படுத்துகிறது person மற்றும் சொத்து உள்ளதா என சரிபார்க்கிறது address உள்ளது. தி in ஆபரேட்டர் இருப்பதை சரிபார்க்க பயன்படுத்தப்படுகிறது address பொருளில் உள்ள சொத்து, அதன் மதிப்பைப் பொருட்படுத்தாமல். சொத்து கண்டுபிடிக்கப்பட்டால், சொத்து இருப்பதாகக் கூறி கன்சோலில் ஒரு செய்தி பதிவு செய்யப்படும். இல்லையெனில், சொத்து வரையறுக்கப்படவில்லை என்று பதிவு செய்கிறது. ஸ்கிரிப்ட் ஒரு நேரடி ஒப்பீட்டையும் பயன்படுத்துகிறது undefined அதே காசோலையை அடைய, சொத்து அமைக்கப்படவில்லை அல்லது வெளிப்படையாக வரையறுக்கப்படவில்லை என்பதை உறுதிப்படுத்துகிறது. இந்த முறை நேரடியானது மற்றும் வாடிக்கையாளர் பக்க சரிபார்ப்புக்கு பயனுள்ளதாக இருக்கும்.

இரண்டாவது ஸ்கிரிப்ட் Node.js ஐப் பயன்படுத்தி சர்வர் பக்க அணுகுமுறைக்கு மாறுகிறது. இது ஒரு எளிய HTTP சேவையகத்தை உருவாக்குகிறது http.createServer மற்றும் போர்ட் 3000 இல் கேட்கிறது. சேவையகம் உள்வரும் கோரிக்கைகளை கையாளுகிறது மற்றும் JSON தரவுகளுடன் பதிலளிக்கிறது. அந்த பொருள் user உள்ளதா என சோதிக்கப்படுகிறது phone சொத்து பயன்படுத்தி hasOwnProperty, சொத்து என்பது பொருளின் நேரடி உறுப்பினர் மற்றும் பரம்பரை அல்ல என்பதை உறுதிப்படுத்தும் ஒரு முறை. சொத்து உள்ளதா என்பதைப் பொறுத்து, சேவையகம் வாடிக்கையாளருக்கு பொருத்தமான செய்தியை அனுப்புகிறது. இது ஒரு சர்வர் சூழலில் வரையறுக்கப்படாத பண்புகளை எவ்வாறு கையாள்வது என்பதை நிரூபிக்கிறது, இது பின்தள வளர்ச்சியில் வலுவான சரிபார்ப்பை வழங்குகிறது.

இறுதி ஸ்கிரிப்ட் TypeScript ஐப் பயன்படுத்தி விருப்பப் பண்புகளைக் கொண்ட ஒரு பொருளை வரையறுக்க உதவுகிறது interface. தி Car தேவையான இடைமுகம் மற்றும் விருப்ப பண்புகள் உட்பட year. என்பதை ஸ்கிரிப்ட் சரிபார்க்கிறது year விருப்பச் சங்கிலியைப் பயன்படுத்தி சொத்து வரையறுக்கப்படவில்லை ?.. இந்த தொடரியல் இயக்க நேர பிழைகளை ஏற்படுத்தாமல், வரையறுக்கப்படாத பண்புகளை பாதுகாப்பான அணுகலை அனுமதிக்கிறது, குறியீடு திறமையாகவும் பாதுகாப்பாகவும் இருப்பதை உறுதி செய்கிறது. என்றால் year சொத்து வரையறுக்கப்படவில்லை, ஒரு செய்தி கன்சோலில் உள்நுழைந்தது. இந்த அணுகுமுறை வகை பாதுகாப்பு மற்றும் கட்டமைக்கப்பட்ட பொருள் வரையறைகளுக்கான TypeScript இன் திறன்களை எடுத்துக்காட்டுகிறது, குறியீடு நம்பகத்தன்மையை மேம்படுத்துகிறது.

// Sample object
const person = {
  name: "Alice",
  age: 30,
};

// Method 1: Using 'in' operator
if ("address" in person) {
  console.log("Address exists in person object.");
} else {
  console.log("Address is undefined in person object.");
}

// Method 2: Using 'undefined' comparison
if (person.address === undefined) {
  console.log("Address is undefined in person object.");
} else {
  console.log("Address exists in person object.");
}

const http = require("http");

http.createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "application/json" });
  const user = {
    username: "bob",
    email: "bob@example.com",
  };

  // Method 3: Using 'hasOwnProperty'
  if (user.hasOwnProperty("phone")) {
    res.end(JSON.stringify({ message: "Phone number exists." }));
  } else {
    res.end(JSON.stringify({ message: "Phone number is undefined." }));
  }

}).listen(3000, () => {
  console.log("Server running at http://localhost:3000/");
});

interface Car {
  make: string;
  model: string;
  year?: number;
}

const car: Car = {
  make: "Toyota",
  model: "Corolla",
};

// Method 4: Optional chaining
if (car.year === undefined) {
  console.log("Year is undefined in car object.");
} else {
  console.log("Year exists in car object.");
}

ஜாவாஸ்கிரிப்டில் வரையறுக்கப்படாத பண்புகளைச் சரிபார்ப்பதற்கான கூடுதல் நுட்பங்கள்

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

கருத்தில் கொள்ள வேண்டிய மற்றொரு அம்சம் பயன்பாடு ஆகும் default parameters மற்றும் destructuring assignment இயல்புநிலை மதிப்புகளுடன். பொருள்களை வாதங்களாக ஏற்றுக்கொள்ளும் செயல்பாடுகளைக் கையாளும் போது, ​​வரையறுக்கப்படாத பண்புகளுக்கு இயல்புநிலை மதிப்புகளை வழங்கலாம். சில பண்புகள் விடுபட்டாலும், உங்கள் செயல்பாடு சரியாகச் செயல்படத் தேவையான அனைத்துத் தரவையும் கொண்டிருப்பதை இது உறுதி செய்கிறது. டிஸ்ட்ரக்சரிங் மற்றும் டிஃபால்ட் மதிப்புகளை இணைப்பது குறியீடு வாசிப்பை மேம்படுத்துகிறது மற்றும் வெளிப்படையான வரையறுக்கப்படாத காசோலைகளின் தேவையை குறைக்கிறது. இந்த கூடுதல் நுட்பங்களைப் புரிந்துகொண்டு செயல்படுத்துவது உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டின் வலிமையையும் பராமரிப்பையும் கணிசமாக மேம்படுத்தும்.

வரையறுக்கப்படாத பண்புகளை கையாள்வதற்கான இறுதி எண்ணங்கள்

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