ஜாவாஸ்கிரிப்ட் ஆப்சனல் செயினிங் டீப் நெஸ்டிங்: பல-அடுக்கு பாதுகாப்பான அணுகல்

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

பிரச்சனை: பிழைகள் இல்லாமல் நெஸ்டட் டேட்டாவை கையாளுதல்

ஒரு சர்வதேச இ-காமர்ஸ் தளத்திலிருந்து பெறப்பட்ட தரவுகளுடன் நீங்கள் பணிபுரிகிறீர்கள் என்று கற்பனை செய்து கொள்ளுங்கள். இந்தத் தரவு பின்வருமாறு கட்டமைக்கப்பட்டிருக்கலாம்:

            const order = {
  id: 'ORD12345',
  customer: {
    profile: {
      name: 'Anya Sharma',
      contact: {
        email: 'anya.sharma@example.com',
        phoneNumbers: [
          { type: 'mobile', number: '+91 98765 43210' },
          { type: 'work', number: '+91 11 2345 6789' }
        ]
      }
    },
    preferences: {
      language: 'en-IN'
    }
  },
  items: [
    { productId: 'PROD001', quantity: 2, price: 50.00 },
    { productId: 'PROD002', quantity: 1, price: 120.50 }
  ],
  shippingAddress: {
    street: '123 Gandhi Road',
    city: 'Mumbai',
    country: 'India'
  }
};

            

              
                Copy
              
            
          

இப்போது, வாடிக்கையாளரின் மொபைல் ஃபோன் எண்ணைப் பெற விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். ஆப்சனல் செயினிங் இல்லாமல், நீங்கள் இப்படி எழுதலாம்:

            let mobileNumber;
if (order && order.customer && order.customer.profile && order.customer.profile.contact && order.customer.profile.contact.phoneNumbers) {
  mobileNumber = order.customer.profile.contact.phoneNumbers.find(phone => phone.type === 'mobile')?.number;
}
console.log(mobileNumber); // Output: '+91 98765 43210'

            

              
                Copy
              
            
          

இந்தக் குறியீடு வேலை செய்கிறது, ஆனால் இது நீளமானது. இடைநிலை பண்புகளில் (உதாரணமாக, contact அல்லது phoneNumbers) ஏதேனும் ஒன்று விடுபட்டிருந்தால் என்ன ஆகும்? இந்தக் குறியீடு ஒரு TypeError பிழையை ஏற்படுத்தும்: "Cannot read properties of undefined (reading '...')". இது பிழைகளின் பொதுவான மூலமாகும், குறிப்பாக பல்வேறு மூலங்களிலிருந்து வரும் அல்லது எப்போதும் முழுமையான தகவலைத் தராத API-களிலிருந்து வரும் தரவுகளைக் கையாளும் போது.

ஆப்சனல் செயினிங்கை (?.) அறிமுகப்படுத்துதல்

ஆப்சனல் செயினிங், நெஸ்டட் பண்புகளை அணுகுவதற்கு மிகவும் தெளிவான தொடரியலை வழங்குகிறது. ?. ஆபரேட்டர் null அல்லது undefined மதிப்பைக் கண்டறிந்தவுடன் மதிப்பீட்டை நிறுத்தி, பிழையை ஏற்படுத்துவதற்குப் பதிலாக undefined-ஐ வழங்கும்.

அடிப்படைப் பயன்பாடு

முந்தைய உதாரணத்தை ஆப்சனல் செயினிங்கைப் பயன்படுத்தி மீண்டும் எழுதுவோம்:

            const order = {
  id: 'ORD12345',
  customer: {
    profile: {
      name: 'Anya Sharma',
      contact: {
        email: 'anya.sharma@example.com',
        phoneNumbers: [
          { type: 'mobile', number: '+91 98765 43210' },
          { type: 'work', number: '+91 11 2345 6789' }
        ]
      }
    },
    preferences: {
      language: 'en-IN'
    }
  },
  items: [
    { productId: 'PROD001', quantity: 2, price: 50.00 },
    { productId: 'PROD002', quantity: 1, price: 120.50 }
  ],
  shippingAddress: {
    street: '123 Gandhi Road',
    city: 'Mumbai',
    country: 'India'
  }
};

const mobileNumber = order?.customer?.profile?.contact?.phoneNumbers?.find(phone => phone.type === 'mobile')?.number;

console.log(mobileNumber); // Output: '+91 98765 43210'

            

              
                Copy
              
            
          

இது கணிசமாக எளிதாகப் படிக்கக்கூடியது. சங்கிலியின் எந்தப் பகுதியும் (உதாரணமாக, order.customer.profile.contact) null அல்லது undefined ஆக இருந்தால், இந்த கோவை பிழைகள் இல்லாமல் undefined என மதிப்பிடப்படும்.

விடுபட்ட பண்புகளை நேர்த்தியாகக் கையாளுதல்

ஒரு வாடிக்கையாளருக்கு தொடர்பு எண் பட்டியலிடப்படாத சூழ்நிலையைக் கவனியுங்கள்:

            const orderWithoutContact = {
  id: 'ORD67890',
  customer: {
    profile: {
      name: 'Kenji Tanaka'
      // No contact information here
    }
  }
};

const mobileNumberForKenji = orderWithoutContact?.customer?.profile?.contact?.phoneNumbers?.find(phone => phone.type === 'mobile')?.number;

console.log(mobileNumberForKenji); // Output: undefined

            

              
                Copy
              
            
          

செயலிழப்பதற்குப் பதிலாக, குறியீடு நேர்த்தியாக undefined-ஐ வழங்குகிறது. இது இயல்புநிலை மதிப்புகளை வழங்க அல்லது தரவு இல்லாததை சரியான முறையில் கையாள நமக்கு உதவுகிறது.

டீப் நெஸ்டிங்: பல ஆப்சனல் ஆபரேட்டர்களை சங்கிலியாக்குதல்

பல அடுக்கு நெஸ்டிங்குடன் பணிபுரியும் போது ஆப்சனல் செயினிங்கின் சக்தி உண்மையில் பிரகாசிக்கிறது. சிக்கலான தரவுக் கட்டமைப்புகளைப் பாதுகாப்பாகக் கடக்க நீங்கள் பல ?. ஆபரேட்டர்களை சங்கிலியாக்கலாம்.

உதாரணம்: ஒரு நெஸ்டட் விருப்பத்தேர்வை அணுகுதல்

வாடிக்கையாளரின் விருப்பமான மொழியை அணுக முயற்சிப்போம், இது பல அடுக்குகளுக்குள் உள்ளது:

            const customerLanguage = order?.customer?.preferences?.language;
console.log(customerLanguage); // Output: 'en-IN'

            

              
                Copy
              
            
          

preferences ஆப்ஜெக்ட் விடுபட்டிருந்தால், அல்லது அதனுள் language பண்பு இல்லை என்றால், customerLanguage என்பது undefined ஆக இருக்கும்.

நெஸ்டட் கட்டமைப்புகளுக்குள் அரேக்களை கையாளுதல்

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

முதல் தொலைபேசி எண்ணின் வகையைப் பெறுவோம், அது இருப்பதாகக் கருதி:

            const firstPhoneNumberType = order?.customer?.profile?.contact?.phoneNumbers?.[0]?.type;
console.log(firstPhoneNumberType); // Output: 'mobile'

            

              
                Copy
              
            
          

இங்கே, ?.[0] என்பது phoneNumbers அரேவின் முதல் உறுப்பை பாதுகாப்பாக அணுகுகிறது. phoneNumbers என்பது null, undefined, அல்லது ஒரு வெற்று அரேவாக இருந்தால், அது undefined என மதிப்பிடப்படும்.

ஆப்சனல் செயினிங்கை நல்லிஷ் கோலெஸ்சிங் (??) உடன் இணைத்தல்

ஆப்சனல் செயினிங் பெரும்பாலும் நல்லிஷ் கோலெஸ்சிங் ஆபரேட்டர் (??) உடன் இணைந்து பயன்படுத்தப்படுகிறது, இது ஒரு பண்பு விடுபட்டாலோ அல்லது null/undefined ஆக இருந்தாலோ இயல்புநிலை மதிப்புகளை வழங்குகிறது.

வாடிக்கையாளரின் மின்னஞ்சலைப் பெற விரும்புகிறோம், அது கிடைக்கவில்லை என்றால், இயல்புநிலையாக "வழங்கப்படவில்லை" என்று அமைக்க வேண்டும் என்று வைத்துக்கொள்வோம்:

            const customerEmail = order?.customer?.profile?.contact?.email ?? 'Not provided';
console.log(customerEmail); // Output: 'anya.sharma@example.com'

// Example with missing email:
const orderWithoutEmail = {
  id: 'ORD11223',
  customer: {
    profile: {
      name: 'Li Wei',
      contact: {
        // No email property
      }
    }
  }
};

const liWeiEmail = orderWithoutEmail?.customer?.profile?.contact?.email ?? 'Not provided';
console.log(liWeiEmail); // Output: 'Not provided'

            

              
                Copy
              
            
          

?? ஆபரேட்டர் அதன் இடது கை ஆப்பராண்ட் null அல்லது undefined ஆக இருக்கும்போது அதன் வலது கை ஆப்பராண்டை வழங்குகிறது, இல்லையெனில் அதன் இடது கை ஆப்பராண்டை வழங்குகிறது. இது இயல்புநிலை மதிப்புகளை சுருக்கமாக அமைப்பதற்கு மிகவும் பயனுள்ளதாக இருக்கும்.

உலகளாவிய மேம்பாட்டில் பயன்பாட்டு வழக்குகள்

ஆப்சனல் செயினிங் மற்றும் நல்லிஷ் கோலெஸ்சிங் ஆகியவை உலகளாவிய பயன்பாடுகளில் பணிபுரியும் டெவலப்பர்களுக்கு விலைமதிப்பற்ற கருவிகளாகும்:

• சர்வதேசமயமாக்கப்பட்ட பயன்பாடுகள் (i18n): உள்ளூர்மயமாக்கப்பட்ட உள்ளடக்கம் அல்லது பயனர் விருப்பங்களைப் பெறும்போது, தரவுக் கட்டமைப்புகள் ஆழமாக நெஸ்ட் செய்யப்படலாம். ஆப்சனல் செயினிங் ஒரு குறிப்பிட்ட மொழி வளம் அல்லது அமைப்பு விடுபட்டாலும், பயன்பாடு செயலிழக்காது என்பதை உறுதி செய்கிறது. உதாரணமாக, ஒரு மொழிபெயர்ப்பை அணுகுவது இப்படி இருக்கலாம்: translations[locale]?.messages?.welcome ?? 'Welcome'.
• API ஒருங்கிணைப்புகள்: வெவ்வேறு வழங்குநர்கள் அல்லது பிராந்தியங்களில் இருந்து வரும் API-கள் மாறுபட்ட மறுமொழி கட்டமைப்புகளைக் கொண்டிருக்கலாம். சில புலங்கள் விருப்பத்திற்குட்பட்டதாகவோ அல்லது நிபந்தனையின் அடிப்படையில் இருக்கலாம். ஆப்சனல் செயினிங் விரிவான பிழை கையாளுதல் இல்லாமல் இந்த பன்முக API-களிலிருந்து தரவைப் பாதுகாப்பாகப் பிரித்தெடுக்க உங்களை அனுமதிக்கிறது.

  பல சேவைகளிலிருந்து பயனர் தரவைப் பெறுவதைக் கவனியுங்கள்:

              const userProfile = serviceA.getUser(userId)?.profile?.details ?? serviceB.getProfile(userId)?.data?.attributes;
  
              
  
                
                  Copy
                
              
            

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

விளிம்பு வழக்குகள் மற்றும் பரிசீலனைகள்

ஆப்சனல் செயினிங் எதிராக லாஜிக்கல் AND (&&)

ஆப்சனல் செயினிங்கிற்கு முன்பு, டெவலப்பர்கள் சோதனைகளுக்கு லாஜிக்கல் AND ஆபரேட்டரை அடிக்கடி பயன்படுத்தினர்:

            const userEmail = order && order.customer && order.customer.profile && order.customer.profile.contact && order.customer.profile.contact.email;

            

              
                Copy
              
            
          

இது வேலை செய்தாலும், இதில் ஒரு முக்கிய வேறுபாடு உள்ளது: && ஆபரேட்டர் கடைசி உண்மையுள்ள (truthy) ஆப்பராண்டின் மதிப்பையோ அல்லது முதல் பொய்யான (falsy) ஆப்பராண்டின் மதிப்பையோ வழங்குகிறது. அதாவது, order.customer.profile.contact.email என்பது ஒரு வெற்று ஸ்டிரிங்காக ('') இருந்தால், அது பொய்யானது என்பதால், முழு கோவையும் '' என மதிப்பிடப்படும். மறுபுறம், ஆப்சனல் செயினிங் குறிப்பாக null அல்லது undefined-ஐ சரிபார்க்கிறது. நல்லிஷ் கோலெஸ்சிங் ஆபரேட்டர் (??) இயல்புநிலைகளைக் கையாள நவீன, விரும்பப்படும் வழியாகும், ஏனெனில் அது null அல்லது undefined-க்கு மட்டுமே செயல்படும்.

செயல்பாடுகளில் ஆப்சனல் செயினிங்

ஆப்சனல் செயினிங் நிபந்தனையின் அடிப்படையில் செயல்பாடுகளை அழைக்கவும் பயன்படுத்தப்படலாம்:

            const userSettings = {
  theme: 'dark',
  updatePreferences: function(prefs) { console.log('Updating preferences:', prefs); }
};

// Safely call updatePreferences if it exists
userSettings?.updatePreferences?.({ theme: 'light' });

const noUpdateSettings = {};
noUpdateSettings?.updatePreferences?.({ theme: 'dark' }); // Does nothing, no error

            

              
                Copy
              
            
          

இங்கே, userSettings?.updatePreferences?.() முதலில் userSettings-ல் updatePreferences இருக்கிறதா என்று சோதிக்கிறது, பின்னர் அதன் விளைவு அழைக்கக்கூடிய ஒரு செயல்பாடா என்று சோதிக்கிறது. இது விருப்பத்திற்குட்பட்ட முறைகள் அல்லது கால்பேக்குகளுக்கு பயனுள்ளதாக இருக்கும்.

ஆப்சனல் செயினிங் மற்றும் `delete` ஆபரேட்டர்

ஆப்சனல் செயினிங் delete ஆபரேட்டருடன் தொடர்பு கொள்ளாது. ஒரு பண்பை நிபந்தனையின் அடிப்படையில் நீக்க நீங்கள் ?. ஐப் பயன்படுத்த முடியாது.

செயல்திறன் தாக்கங்கள்

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

டீப் நெஸ்டிங்கிற்கான சிறந்த நடைமுறைகள்

1. ?. ஐ தொடர்ந்து பயன்படுத்தவும்: நீங்கள் விடுபட வாய்ப்புள்ள ஒரு நெஸ்டட் பண்பை அணுகும்போதெல்லாம், ஆப்சனல் செயினிங் ஆபரேட்டரைப் பயன்படுத்தவும்.
2. இயல்புநிலைகளுக்கு ?? உடன் இணைக்கவும்: ஒரு பண்பு null அல்லது undefined ஆக இருக்கும்போது பொருத்தமான இயல்புநிலை மதிப்புகளை வழங்க நல்லிஷ் கோலெஸ்சிங் ஆபரேட்டரை (??) பயன்படுத்தவும்.
3. தேவையற்ற இடங்களில் அதிகப்படியான சங்கிலியைத் தவிர்க்கவும்: ஒரு பண்பு நிச்சயமாக உள்ளது என்று நீங்கள் உறுதியாக நம்பினால் (உதாரணமாக, கடுமையான சரிபார்ப்புடன் நீங்களே உருவாக்கிய ஒரு ஆழமான நெஸ்டட் ஆப்ஜெக்ட்டிற்குள் ஒரு பிரிமிட்டிவ் பண்பு), நீங்கள் ஒரு சிறிய செயல்திறன் ஆதாயத்திற்காக ஆப்சனல் செயினிங்கைத் தவிர்க்கலாம், ஆனால் இது எச்சரிக்கையுடன் செய்யப்பட வேண்டும்.
4. தெளிவற்றதை விட வாசிப்புத்தன்மை: ஆப்சனல் செயினிங் குறியீட்டை சுருக்கமாக மாற்றினாலும், அது புரிந்துகொள்ள கடினமாக இருக்கும் அளவிற்கு ஆழமாக சங்கிலியாக்குவதைத் தவிர்க்கவும். மிகவும் சிக்கலான சூழ்நிலைகளுக்கு டீஸ்ட்ரக்சரிங் அல்லது உதவி செயல்பாடுகளைக் கருத்தில் கொள்ளுங்கள்.
5. முழுமையாகச் சோதிக்கவும்: உங்கள் ஆப்சனல் செயினிங் தர்க்கம், குறிப்பாக வெளிப்புற அமைப்புகளுடன் ஒருங்கிணைக்கும்போது, தரவு விடுபட்டதற்கான அனைத்து எதிர்பார்க்கப்படும் நிகழ்வுகளையும் உள்ளடக்கியதா என்பதை உறுதிப்படுத்தவும்.
6. டைப்ஸ்கிரிப்டைக் கருத்தில் கொள்ளுங்கள்: பெரிய அளவிலான பயன்பாடுகளுக்கு, டைப்ஸ்கிரிப்ட் நிலையான டைப்பிங்கை வழங்குகிறது, இது மேம்பாட்டின் போது இந்த சாத்தியமான பிழைகள் பலவற்றைப் பிடிக்க முடியும், இது ஜாவாஸ்கிரிப்டின் இயக்கநேர பாதுகாப்பு அம்சங்களை நிறைவு செய்கிறது.

முடிவுரை

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