முதலில், ஒரு பிழை என்ன மற்றும் அதன் வகைகளை புரிந்து கொள்ள வேண்டும்.
பிழை வகைகள்
எந்தவொரு நிரலாக்க மொழியிலும் பணிபுரியும் போது பொதுவாக இரண்டு வகையான பிழைகள் ஏற்படலாம்:
செயல்பாட்டு பிழை
பயன்பாடு கையாளப்படாத விதிவிலக்கு அல்லது குறியீட்டில் ஏதேனும் சிக்கலை எதிர்கொள்ளும்போது செயல்பாட்டுப் பிழை ஏற்படுகிறது. இந்த வகை பிழையை கண்டறிவது கடினம், ஏனெனில் அதன் தோற்றத்திற்கு பல காரணங்கள் உள்ளன எ.கா. நினைவக கசிவு, முடிவில்லாத சுழல்கள், துல்லியமற்ற கணினி வடிவமைப்பு போன்றவை.
செயல்பாட்டுப் பிழைகளைச் சமாளிப்பதற்கான ஒரு திறமையான வழி, அதன் தோற்றத்தில் உள்ள பிழையைக் கண்டறிந்து, டெவலப்பருக்குத் தெரிவிக்க, சரியான நேரத்தில் அதைத் தீர்க்கக்கூடிய ஒரு சிறந்த பிழை-கையாளுதல் உத்தியைப் பயன்படுத்துவதாகும்.
செயல்பாட்டு பிழை
செயல்பாட்டுப் பிழைகள் என்பது பயன்பாட்டுக் குறியீட்டின் இயல்பான செயல்பாட்டை நிறுத்துவதாகும். இந்தப் பிழைகள் வித்தியாசமாகச் செயல்படுவதால், பயன்பாட்டின் வாழ்க்கைச் சுழற்சியின் போது அவை வித்தியாசமாக நடந்துகொள்ளக்கூடும் என்பதால், அவற்றின் தோற்றத்தைக் கண்டறிய அதிக மூளைச்சலவை தேவைப்படலாம்.
ஒரு எளிய வழக்கு, பயனர் தவறான தர்க்கத்தை செயல்படுத்திய ஒரு நிரலாக இருக்கலாம், இது முடிவில்லாத சுழற்சியை ஏற்படுத்தலாம் மற்றும் இறுதியில் நிரலை செயலிழக்கச் செய்யலாம்.
பிழைத்திருத்தம் மற்றும் தடயங்களை அடுக்கி வைப்பது போன்ற நுட்பங்களைப் பயன்படுத்தி சாத்தியமான செயல்பாட்டு பிழைகளை அடையாளம் காண டெவலப்பர்கள் கோட்பேஸில் ஆழமாக தோண்டி எடுக்க வேண்டும்.
எங்கள் குறியீடு ஸ்கிரிப்ட்டில் ஏற்படக்கூடிய பிழை வகையைப் பற்றி இப்போது நாம் அறிந்திருக்கிறோம், ஏன் பிழையைக் கையாள வேண்டும் என்பதைப் புரிந்துகொள்வது அவசியம்.
Node.js இல் உள்ள பிழைகளைக் கையாள வலியுறுத்துங்கள்
முயற்சி-பிடிப்பைப் பயன்படுத்தி Node.js இல் பிழைகளை எவ்வாறு கையாள்வது என்ற கருத்தை விளக்கும் முன்; பிழைகளைக் கையாள வேண்டிய அவசியம் ஏன் இருக்கிறது என்பதைப் புரிந்துகொள்வது அவசியம். பயனர்களுக்கான நம்பகமான மற்றும் மேம்பட்ட பயனர் அனுபவ பயன்பாட்டை நிறுவுவதற்கு பயன்பாட்டுக் குறியீட்டில் உள்ள பிழைகளைக் கையாள்வது மிகவும் முக்கியமானது.
பயனர் அனுபவத்தை மேம்படுத்துதல்
சிறந்த பயனர் அனுபவத்திற்காக பொதுவான செய்திகளைப் பயன்படுத்துவதைத் தவிர்ப்பது மற்றும் பயனர் நட்பு பிழை செய்திகளைக் காண்பிப்பது ஒரு நல்ல நடைமுறையாகும்.
வலுவான குறியீடு அறக்கட்டளையை உருவாக்குதல்
பிழைகள் சிறந்த முறையில் கையாளப்படும் போது, குறியீட்டின் அடித்தளம் மிகவும் யதார்த்தமாகத் தெரிகிறது. இது தேவையான பிழைகளை திறமையாகப் பிடிக்கிறது மற்றும் கையாளுகிறது, இதனால் பயன்பாட்டு செயலிழப்பு அபாயத்தைக் குறைக்கிறது.
பிழை கண்டறிதல்
பிழை கையாளுதல், வளர்ச்சி கட்டத்தில் பிழைகளைக் கண்டறிவதை எளிதாக்குகிறது மற்றும் முடிந்தவரை விரைவாக அவற்றை நீக்குகிறது. இது பயனர்கள் தங்கள் பயன்பாடுகளை டெவலப்மெண்ட் கட்டத்தில் மிகவும் துல்லியமாக மேம்படுத்த உதவுகிறது, இதனால் குறியீடு எந்த இடையூறும் இல்லாமல் செல்ல அனுமதிக்கிறது.
பயன்பாடு செயலிழப்பு
பிழைகளைக் கையாளாதது குறியீடு ஓட்டத்தில் திடீர் இடையூறு மற்றும் இறுதியில் பயன்பாட்டை செயலிழக்கச் செய்யலாம். ஒரு ' பயன்பாடு முயற்சி-பிடி ” பிளாக் பிழைகளை சீராக கையாள அனுமதிக்கிறது.
இப்போது, நமது குறியீட்டில் நாம் பயன்படுத்தவிருக்கும் டிரை-கேட்ச் பிளாக்கின் அமைப்பு/தொடரியலைப் பார்த்து ஆரம்பிக்கலாம்.
டிரை-கேட்ச் பிளாக்கின் அமைப்பு
டிரை-கேட்ச் பிளாக்கின் அமைப்பு மிகவும் எளிமையானது மற்றும் பிழைகளை திறம்பட கையாள இது அடிப்படை கருவியாகும்.
டிரை-கேட்ச் பிளாக்கின் அமைப்பு:
முயற்சி {} பிடி ( பிழை ) {
பணியகம். பிழை ( ) ;
} இறுதியாக {
}
மேலே உள்ள குறியீட்டின் செயல்பாடு:
- ' முயற்சி 'பிளாக் அனைத்து செயல்பாட்டுக் குறியீடுகளையும் கொண்டுள்ளது மற்றும் இந்தத் தொகுதியில் பிழைகள் ஏற்படலாம். இந்த பிளாக்கில் ஏதேனும் பிழை ஏற்பட்டால், '' பிடி ”தொகுதி.
- ' பிடி ” தொகுதி என்பது தேவையான அனைத்து பிழைகளும் கையாளப்படும் இடமாகும். பயனர்கள் அதன் பண்புகளை மாற்றியமைத்து விரும்பிய செயல்களைச் செய்யலாம்.
- ' இறுதியாக ” தொகுதி என்பது ஒரு விருப்பத் தொகுதி, மேலும் இது ஒவ்வொரு முறையும் பிழை ஏற்பட்டாலும் இல்லாவிட்டாலும் இயங்கும். இது சுத்தம் செய்யும் செயல்பாட்டைச் செய்கிறது.
ட்ரை-கேட்ச் பிளாக் பற்றிய புரிதலை நடைமுறையில் நாம் ஒரு கோப்பினை அணுக முயற்சிக்கும் அல்லது இல்லாத ஒரு கோப்பின் மூலம் புரிந்து கொள்ள முடியும். அது இல்லை என்றால் அது பிழையைக் கொடுக்கலாம், பிழையைத் தவிர்ப்பதற்காக, முயற்சி-பிடிப்பு கருத்தைப் பயன்படுத்தி பயனர் அதைக் கையாளலாம்.
Node.js இல் 'ட்ரை-கேட்ச்' பிளாக்கைப் பயன்படுத்தி கோப்பு கையாளுதல் பிழைகள்
முதலில், '' ஐப் பயன்படுத்தாமல் ஒரு சிக்கலைப் பார்ப்போம். முயற்சி-பிடி ”தொகுதி. கீழே உள்ள குறியீட்டு எடுத்துக்காட்டில், சரியான பிழை கையாளுதல் இல்லாமல் ஒரு கோப்பு திறக்கப்படுகிறது:
நிலையான fs = தேவை ( 'fs' ) ;நிலையான தகவல் = fs. readFileSync ( '/Users/Lenovo/file.txt' ) ;
பணியகம். பதிவு ( 'இறுதியில் இயக்கப்பட வேண்டிய முக்கியமான குறியீடு' ) ;
மேலே உள்ள குறியீட்டின் விளக்கம்:
- ' const fs = தேவை (‘fs’) ” Node.js ‘fs’ (கோப்பு முறைமை) தொகுதியை இறக்குமதி செய்கிறது, இது பயனரை கோப்பு முறைமையுடன் வேலை செய்ய அனுமதிக்கிறது, கோப்புகளைப் படிப்பது அல்லது எழுதுவது போன்ற அனைத்து கோப்பு செயல்பாடுகளும் அடங்கும்.
- ' நிலையான தரவு = fs.readFileSync(‘/பயனர்கள்/லெனோவா/file.txt’) ” குறிப்பிட்ட பாதையில் கோப்பின் உள்ளடக்கத்தைப் படிக்கிறது. ' readFileSync ” என்பது ஒரு ஒத்திசைவான செயல்பாடாகும், அதாவது கோப்பு குறிப்பிட்ட பாதையில் படிக்கப்பட்டு தகவல் சேமிக்கப்படும் வரை மேலும் குறியீடு செயல்படுத்தலை நிறுத்துகிறது. தகவல் ” மாறி.
- ' console.log('முக்கியமான குறியீடானது இறுதியில் இயக்கப்பட வேண்டும்') ” டெர்மினலில் ஒரு செய்தியை அச்சிடுகிறது ஆனால் முந்தைய படியில் கோப்பு படிக்கப்படாத வரை இந்த வரி செயல்படுத்தப்படாது.
வெளியீடு
மேலே உள்ள குறியீட்டின் விளைவாக ஏற்படும் பிழை பின்வருமாறு தோன்றும்:
சரியான பிழை கையாளுதல் இல்லாமல் இந்த குறியீட்டை இயக்குவது பிழைகளை விளைவிப்பதைக் காணலாம். இப்போது 'ட்ரை-கேட்ச்' பிளாக்கைப் பயன்படுத்தி மேலே உள்ள குறியீட்டை மறுசீரமைக்கவும்:
நிலையான fs = தேவை ( 'fs' ) ;முயற்சி {
நிலையான தகவல் = fs. readFileSync ( '/Users/Lenovo/file.txt' ) ;
பணியகம். பதிவு ( தகவல் ) ;
} பிடி ( பிழை ) {
பணியகம். பிழை ( ` பிழை கோப்பை வாசிப்பது : $ { பிழை. செய்தி } ` ) ;
}
மேலே உள்ள குறியீட்டின் செயல்பாடு:
- கோப்பு வாசிப்பு செயல்முறை ' முயற்சி ” தடு ஏனெனில் இங்கே பிழை ஏற்பட வாய்ப்பு உள்ளது.
- ' console.log(தகவல்) ” கோப்பின் உள்ளடக்கத்தை பதிவு செய்து கன்சோலில் அச்சிடுகிறது.
- ' பிடி 'பிளாக்' இல் ஏற்படக்கூடிய சாத்தியமான பிழையைப் பிடிக்கிறது முயற்சி ” குறியீடு செயல்படுத்தும் போது தடுக்கவும் மற்றும் பிழை செய்தியை முனையத்தில் பதிவு செய்யவும்.
- ' console.error(`கோப்பைப் படிப்பதில் பிழை: ${error.message}`) 'பிடிக்கப்பட்ட பிழையின் விளைவாக பெறப்பட்ட குறிப்பிட்ட பிழை செய்தியை பதிவு செய்கிறது.
வெளியீடு
திறம்பட மறுவடிவமைக்கப்பட்ட குறியீட்டின் வெளியீடு, இணைக்கப்பட்டுள்ள ஸ்கிரீன்ஷாட்டில் கீழே காட்டப்பட்டுள்ளபடி உகந்த பிழைச் செய்தியைக் காண்பிக்கும்:
ட்ரை-கேட்சைப் பயன்படுத்துவது, ஏற்படக்கூடிய சாத்தியமான பிழையைக் கையாள அனுமதிக்கிறது, ஆனால் சிறந்த புரிதலுக்காக, உதவியாக இருக்கும் சில திறமையான நடைமுறைகள் பட்டியலிடப்பட்டுள்ளன.
பிழை கையாளுதலுக்கான சிறந்த நடைமுறைகள்
பயனர் தங்கள் பயன்பாட்டுக் குறியீடுகளில் உள்ள பிழைகளைக் கையாள பின்வரும் நடைமுறைகளைப் பின்பற்றலாம்:
முயற்சி-பிடிப்பை புத்திசாலித்தனமாகப் பயன்படுத்துதல்
பயன்படுத்த வேண்டியது அவசியம் ' முயற்சி-பிடி 'அது வேலை செய்ய வேண்டிய இடத்தில் மட்டுமே, குறிப்பாக குறியீட்டின் முக்கியமான பகுதிகளில் சாத்தியமான பிழையின் அபாயம் உள்ளது. குறியீட்டில் அதிகமாகப் பயன்படுத்துவது குறியீட்டை சிக்கலாக்கும்.
ஒத்திசைவற்ற குறியீட்டைப் பயன்படுத்துதல்
குறியீட்டை ஒத்திசைவற்ற குறியீட்டைக் கையாளும் போது, '' ஐப் பயன்படுத்த முயற்சிக்கவும் முயற்சி-பிடி ” வாக்குறுதிகள் மற்றும் ஒத்திசைவு/பிழையை சிறந்த முறையில் கையாள காத்திருங்கள்.
பதிவு செய்து பிழைகளைப் புகாரளிக்கவும்
தெளிவான பிழை செய்திகள் பிழைகளின் மூல காரணத்தை கண்டறிய உதவுவதால், எப்போதும் குறிப்பிட்ட பிழையை கேட்ச் பிளாக்கில் சரியாக பதிவு செய்து புகாரளிக்கவும்.
சிக்கலைக் குறைத்தல்
பிழைகள் முக்கியமானதாக இல்லாத சூழ்நிலைகளைக் கையாளவும். குறிப்பிட்ட பகுதியை நீக்குவது (தேவையில்லை என்றால்) குறியீட்டின் சிக்கலைக் குறைக்கலாம்.
அமைதியான தவறுகளைத் தவிர்ப்பது
தேவைப்படும் இடங்களில் பிழைச் செய்தியைக் காட்டும் விதத்தில் குறியீட்டை எழுதுங்கள் இல்லையெனில் பிழைச் செய்தி குறிப்பிடப்படாவிட்டால், சரியான அடையாளம் இல்லாமல் பிழையைக் கையாள்வது சிக்கலாகிவிடும்.
ட்ரை-கேட்ச் பிளாக் செயல்பாட்டைப் பற்றியது மற்றும் Node.js இல் பிழைகளைக் கையாள அதை எவ்வாறு திறமையாகப் பயன்படுத்தலாம்.
முடிவுரை
Node.js இல் பிழைகளைக் கையாள்வதில் நிபுணத்துவம் பெறுவது வலுவான மற்றும் நிலையான பயன்பாடுகளை உருவாக்குவதற்கான அடிப்படை படியாகும். 'இன் உகந்த பயன்பாடு முயற்சி-பிடி ஒத்திசைவற்ற நுட்பங்கள் மற்றும் முறையான பிழை பதிவு போன்ற பல்வேறு நடைமுறைகளுடன் பிளாக் நிலையான மற்றும் பயனர் நட்பு Node.js பயன்பாடுகளை நிறுவ உதவும். இந்தக் கட்டுரையானது, பயனர் தேவைகளுக்கு ஏற்ப பயன்படுத்தக்கூடிய கட்டமைப்பு, நடைமுறை பயன்பாடு மற்றும் கையாளும் நடைமுறைகளை விளக்கியுள்ளது.