டைப்ஸ்கிரிப்ட் பிழை கையாளுதல்: விதிவிலக்கு வகை பாதுகாப்பு முறைகள்

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

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

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

அடித்தளம்: ஜாவாஸ்கிரிப்டின் பிழை பொருள் மற்றும் try...catch

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

ஜாவாஸ்கிரிப்டில் நிலையான பிழை வகைகள்

• Error: பொதுவான அடிப்படை பிழை பொருள். பெரும்பாலான தனிப்பயன் பிழைகள் இதை நீட்டிக்கின்றன.
• TypeError: ஒரு செயல்பாடு தவறான வகையின் மதிப்பில் செய்யப்பட்டது என்பதைக் குறிக்கிறது.
• ReferenceError: ஒரு தவறான குறிப்பு செய்யப்படும்போது வீசப்படுகிறது (எ.கா., அறிவிக்கப்படாத மாறியைப் பயன்படுத்த முயற்சித்தல்).
• RangeError: ஒரு எண் மாறி அல்லது அளவுரு அதன் செல்லுபடியாகும் வரம்பிற்கு வெளியே இருப்பதைக் குறிக்கிறது.
• SyntaxError: செல்லுபடியாகாத ஜாவாஸ்கிரிப்ட் குறியீட்டை பாகுபடுத்தும்போது ஏற்படுகிறது.
• URIError: encodeURI() அல்லது decodeURI() போன்ற செயல்பாடுகள் தவறாகப் பயன்படுத்தப்படும்போது வீசப்படுகிறது.
• EvalError: உலகளாவிய eval() செயல்பாட்டுடன் தொடர்புடையது (நவீன குறியீட்டில் குறைவாகவே காணப்படுகிறது).

அடிப்படை try...catch தொகுதிகள்

ஜாவாஸ்கிரிப்ட் (மற்றும் டைப்ஸ்கிரிப்ட்) இல் ஒத்திசைவான பிழைகளைக் கையாள்வதற்கான அடிப்படை வழி try...catch கூற்று ஆகும்:

            function divide(a: number, b: number): number {
    if (b === 0) {
        throw new Error("Division by zero is not allowed.");
    }
    return a / b;
}

try {
    const result = divide(10, 0);
    console.log(`Result: ${result}`);
} catch (error) {
    console.error("An error occurred:", error);
}

// Output:
// An error occurred: Error: Division by zero is not allowed.

            

              
                Copy
              
            
          

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

டைப்ஸ்கிரிப்டின் பரிணாமம்: Catch கிளாஸ்களில் unknown வகை

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

            try {
    throw "Oops, something went wrong!"; // Throwing a string, which is valid in JS
} catch (error) {
    // In TS 4.4+, 'error' is of type 'unknown'
    // console.log(error.message); // ERROR: 'error' is of type 'unknown'.
}

            

              
                Copy
              
            
          

இந்தக் கண்டிப்பு ஒரு அம்சம், ஒரு பிழை அல்ல. இது மிகவும் வலுவான பிழை-கையாளுதல் தர்க்கத்தை எழுத நம்மைத் தூண்டுகிறது, நாம் அடுத்து ஆராயப்போகும் வகை-பாதுகாப்பான முறைகளுக்கு அடித்தளம் அமைக்கிறது.

உலகளாவிய பயன்பாடுகளுக்கு பிழைகளில் வகை பாதுகாப்பு ஏன் முக்கியமானது

உலகளாவிய பயனர் தளத்திற்கு சேவை செய்யும் மற்றும் சர்வதேச குழுக்களால் உருவாக்கப்பட்ட பயன்பாடுகளுக்கு, நிலையான மற்றும் கணிக்கக்கூடிய பிழை கையாளுதல் மிக முக்கியமானது. பிழைகளில் வகை பாதுகாப்பு பல தனித்துவமான நன்மைகளை வழங்குகிறது:

1. மேம்படுத்தப்பட்ட நம்பகத்தன்மை மற்றும் நிலைத்தன்மை: பிழை வகைகளை வெளிப்படையாக வரையறுப்பதன் மூலம், ஒரு தவறான வடிவமைப்பு கொண்ட பிழை பொருளில் இல்லாத பண்புகளை அணுக முயற்சிப்பதால் ஏற்படக்கூடிய எதிர்பாராத இயக்க நேர செயலிழப்புகளைத் தடுக்கிறீர்கள். இது மிகவும் நிலையான பயன்பாடுகளுக்கு வழிவகுக்கிறது, இது செயலிழப்பு வெவ்வேறு சந்தைகளில் குறிப்பிடத்தக்க நிதி அல்லது நற்பெயர் செலவுகளை ஏற்படுத்தக்கூடிய சேவைகளுக்கு முக்கியமானது.
2. மேம்படுத்தப்பட்ட டெவலப்பர் அனுபவம் (DX) மற்றும் பராமரிப்புத்தன்மை: ஒரு செயல்பாடு என்ன பிழைகளை வீசலாம் அல்லது திரும்பப் பெறலாம் என்பதை டெவலப்பர்கள் தெளிவாகப் புரிந்து கொள்ளும்போது, அவர்கள் மிகவும் இலக்கு மற்றும் பயனுள்ள கையாளுதல் தர்க்கத்தை எழுத முடியும். இது அறிவாற்றல் சுமையைக் குறைக்கிறது, மேம்பாட்டை வேகப்படுத்துகிறது, மற்றும் குறியீட்டைப் பராமரிக்கவும் மறுசீரமைக்கவும் எளிதாக்குகிறது, குறிப்பாக வெவ்வேறு நேர மண்டலங்கள் மற்றும் கலாச்சார பின்னணிகளைக் கொண்ட பெரிய, விநியோகிக்கப்பட்ட குழுக்களில்.
3. கணிக்கக்கூடிய பிழை கையாளுதல் தர்க்கம்: வகை-பாதுகாப்பான பிழைகள் முழுமையான சரிபார்ப்பை அனுமதிக்கின்றன. நீங்கள் switch கூற்றுகள் அல்லது if/else if சங்கிலிகளை எழுதலாம், அவை சாத்தியமான அனைத்து பிழை வகைகளையும் உள்ளடக்கியது, எந்த பிழையும் கையாளப்படாமல் போவதை உறுதி செய்கிறது. இந்த கணிக்கக்கூடிய தன்மை கடுமையான சேவை நிலை ஒப்பந்தங்கள் (SLAs) அல்லது உலகெங்கிலும் உள்ள ஒழுங்குமுறை இணக்கத் தரங்களுக்கு இணங்க வேண்டிய அமைப்புகளுக்கு இன்றியமையாதது.
4. சிறந்த பிழைத்திருத்தம் மற்றும் சரிசெய்தல்: பணக்கார மெட்டாடேட்டாவுடன் கூடிய குறிப்பிட்ட பிழை வகைகள் பிழைத்திருத்தத்தின் போது விலைமதிப்பற்ற சூழலை வழங்குகின்றன. ஒரு பொதுவான "ஏதோ தவறு நடந்துவிட்டது" என்பதற்கு பதிலாக, நீங்கள் NetworkError உடன் statusCode: 503 போன்ற துல்லியமான தகவலைப் பெறுவீர்கள், அல்லது ValidationError உடன் தவறான புலங்களின் பட்டியலைப் பெறுவீர்கள். இந்தத் தெளிவு சிக்கல்களைக் கண்டறியும் நேரத்தை வியத்தகு முறையில் குறைக்கிறது, இது பல்வேறு புவியியல் இடங்களில் பணிபுரியும் செயல்பாட்டுக் குழுக்களுக்கு ஒரு பெரிய நன்மை.
5. தெளிவான API ஒப்பந்தங்கள்: APIகள் அல்லது மறுபயன்பாட்டு தொகுதிகளை வடிவமைக்கும்போது, வீசப்படக்கூடிய பிழைகளின் வகைகளை வெளிப்படையாகக் கூறுவது செயல்பாட்டின் ஒப்பந்தத்தின் ஒரு பகுதியாகிறது. இது ஒருங்கிணைப்புப் புள்ளிகளை மேம்படுத்துகிறது, மற்ற சேவைகள் அல்லது குழுக்கள் உங்கள் குறியீட்டுடன் மிகவும் கணிக்கக்கூடியதாகவும் பாதுகாப்பாகவும் தொடர்பு கொள்ள அனுமதிக்கிறது.
6. பிழை செய்திகளின் சர்வதேசமயமாக்கலை எளிதாக்குகிறது: நன்கு வரையறுக்கப்பட்ட பிழை வகைகளுடன், வெவ்வேறு மொழிகள் மற்றும் கலாச்சாரங்களில் உள்ள பயனர்களுக்கு உள்ளூர்மயமாக்கப்பட்ட செய்திகளுக்கு குறிப்பிட்ட பிழைக் குறியீடுகளை நீங்கள் வரைபடமாக்கலாம். ஒரு UserNotFoundError ஆங்கிலத்தில் "User not found", பிரெஞ்சு மொழியில் "Utilisateur introuvable", அல்லது ஸ்பானிஷ் மொழியில் "Usuario no encontrado" என்று வழங்கலாம், இது அடிப்படை பிழை கையாளுதல் தர்க்கத்தை மாற்றாமல் உலகளவில் பயனர் அனுபவத்தை மேம்படுத்துகிறது.

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

முறை 1: இயக்க நேர வகை சரிபார்ப்பு (unknown பிழைகளைக் குறைத்தல்)

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

instanceof Error ஐப் பயன்படுத்துதல்

ஒரு unknown பிழையைக் குறைப்பதற்கான மிகவும் பொதுவான மற்றும் நேரடியான வழி, அது உள்ளமைக்கப்பட்ட Error வகுப்பின் (அல்லது TypeError, ReferenceError, போன்ற அதன் வழித்தோன்றல் வகுப்புகளில் ஒன்று) ஒரு நிகழ்வா என்பதைச் சரிபார்ப்பதாகும்.

            function riskyOperation(): void {
    // Simulate different types of errors
    const rand = Math.random();
    if (rand < 0.3) {
        throw new Error("Generic error occurred!");
    } else if (rand < 0.6) {
        throw new TypeError("Invalid data type provided.");
    } else {
        throw { code: 500, message: "Internal Server Error" }; // Non-Error object
    }
}

try {
    riskyOperation();
} catch (error: unknown) {
    if (error instanceof Error) {
        console.error(`Caught an Error object: ${error.message}`);
        // You can also check for specific Error subclasses
        if (error instanceof TypeError) {
            console.error("Specifically, a TypeError was caught.");
        }
    } else if (typeof error === 'string') {
        console.error(`Caught a string error: ${error}`);
    } else if (typeof error === 'object' && error !== null && 'message' in error) {
        // Handle custom objects that have a 'message' property
        console.error(`Caught a custom error object with message: ${(error as { message: string }).message}`);
    } else {
        console.error("An unexpected type of error occurred:", error);
    }
}

            

              
                Copy
              
            
          

இந்த அணுகுமுறை அடிப்படை வகை பாதுகாப்பை வழங்குகிறது, இது நிலையான Error பொருட்களின் message மற்றும் name பண்புகளை அணுக உங்களை அனுமதிக்கிறது. இருப்பினும், மேலும் குறிப்பிட்ட பிழை சூழ்நிலைகளுக்கு, நீங்கள் பணக்கார தகவலை விரும்புவீர்கள்.

குறிப்பிட்ட பிழைப் பொருட்களுக்கான தனிப்பயன் வகை காவலர்கள்

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

            // 1. Define custom error interfaces/types
interface NetworkError {
    name: "NetworkError";
    message: string;
    statusCode: number;
    url: string;
}

interface ValidationError {
    name: "ValidationError";
    message: string;
    fields: { [key: string]: string };
}

// 2. Create type guards for each custom error
function isNetworkError(error: unknown): error is NetworkError {
    return (
        typeof error === 'object' &&
        error !== null &&
        'name' in error &&
        (error as { name: string }).name === "NetworkError" &&
        'message' in error &&
        'statusCode' in error &&
        'url' in error
    );
}

function isValidationError(error: unknown): error is ValidationError {
    return (
        typeof error === 'object' &&
        error !== null &&
        'name' in error &&
        (error as { name: string }).name === "ValidationError" &&
        'message' in error &&
        'fields' in error &&
        typeof (error as { fields: unknown }).fields === 'object'
    );
}

// 3. Example usage in a 'try...catch' block
function fetchData(url: string): Promise<any> {
    return new Promise((resolve, reject) => {
        // Simulate an API call that might throw different errors
        const rand = Math.random();
        if (rand < 0.4) {
            reject(new Error("Something unexpected happened."));
        } else if (rand < 0.7) {
            reject({ 
                name: "NetworkError", 
                message: "Failed to fetch data", 
                statusCode: 503, 
                url 
            } as NetworkError);
        } else {
            reject({ 
                name: "ValidationError", 
                message: "Invalid input data", 
                fields: { 'email': 'Invalid format' } 
            } as ValidationError);
        }
    });
}

async function processData() {
    const url = "https://api.example.com/data";
    try {
        const data = await fetchData(url);
        console.log("Data fetched successfully:", data);
    } catch (error: unknown) {
        if (isNetworkError(error)) {
            console.error(`Network Error from ${error.url}: ${error.message} (Status: ${error.statusCode})`);
            // Specific handling for network issues, e.g., retry logic or user notification
        } else if (isValidationError(error)) {
            console.error(`Validation Error: ${error.message}`);
            console.error("Invalid fields:", error.fields);
            // Specific handling for validation errors, e.g., display errors next to form fields
        } else if (error instanceof Error) {
            console.error(`Standard Error: ${error.message}`);
        } else {
            console.error("An unknown or unexpected error type occurred:", error);
            // Fallback for truly unexpected errors
        }
    }
}

processData();

            

              
                Copy
              
            
          

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

முறை 2: தனிப்பயன் பிழை வகுப்புகள்

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

உள்ளமைக்கப்பட்ட Error வகுப்பை நீட்டித்தல்

டைப்ஸ்கிரிப்ட் (மற்றும் ஜாவாஸ்கிரிப்ட்) இல் தனிப்பயன் பிழைகளுக்கான சிறந்த நடைமுறை அடிப்படை Error வகுப்பை நீட்டிப்பதாகும். இது உங்கள் தனிப்பயன் பிழைகள் message மற்றும் stack போன்ற பண்புகளைத் தக்கவைத்துக்கொள்வதை உறுதி செய்கிறது, இது பிழைத்திருத்தம் மற்றும் பதிவு செய்வதற்கு இன்றியமையாதது.

            // Base Custom Error
class CustomApplicationError extends Error {
    constructor(message: string, public code: string = 'GENERIC_ERROR') {
        super(message);
        this.name = this.constructor.name; // Sets the error name to the class name
        // Preserve stack trace for better debugging
        if (Error.captureStackTrace) {
            Error.captureStackTrace(this, this.constructor);
        }
    }
}

// Specific Custom Errors
class DatabaseConnectionError extends CustomApplicationError {
    constructor(message: string, public databaseName: string, public connectionString?: string) {
        super(message, 'DB_CONN_ERROR');
    }
}

class UserAuthenticationError extends CustomApplicationError {
    constructor(message: string, public userId?: string, public reason: 'INVALID_CREDENTIALS' | 'SESSION_EXPIRED' | 'FORBIDDEN' = 'INVALID_CREDENTIALS') {
        super(message, 'AUTH_ERROR');
    }
}

class DataValidationFailedError extends CustomApplicationError {
    constructor(message: string, public invalidFields: { [key: string]: string }) {
        super(message, 'VALIDATION_ERROR');
    }
}

            

              
                Copy
              
            
          

தனிப்பயன் பிழை வகுப்புகளின் நன்மைகள்

1. சொற்பொருள் பொருள்: பிழை வகுப்பு பெயர்கள் சிக்கலின் தன்மையைப் பற்றிய உடனடி நுண்ணறிவை வழங்குகின்றன (எ.கா., DatabaseConnectionError தெளிவாக ஒரு தரவுத்தள சிக்கலைக் குறிக்கிறது).
2. விரிவாக்கத்தன்மை: நீங்கள் ஒவ்வொரு பிழை வகைக்கும் குறிப்பிட்ட பண்புகளைச் சேர்க்கலாம் (எ.கா., statusCode, userId, fields), அவை அந்த குறிப்பிட்ட பிழை சூழலுக்குப் பொருத்தமானவை, பிழைத்திருத்தம் மற்றும் கையாளுதலுக்கான பிழைத் தகவலை வளப்படுத்துகின்றன.
3. instanceof உடன் எளிதான அடையாளம்: வெவ்வேறு தனிப்பயன் பிழைகளைப் பிடிப்பது மற்றும் வேறுபடுத்துவது instanceof ஐப் பயன்படுத்தி அற்பமாகிவிடுகிறது, இது துல்லியமான பிழை கையாளுதல் தர்க்கத்தை அனுமதிக்கிறது.
4. பராமரிப்புத்தன்மை: பிழை வரையறைகளை மையப்படுத்துவது உங்கள் குறியீட்டுத் தளத்தைப் புரிந்துகொள்வதற்கும் நிர்வகிப்பதற்கும் எளிதாக்குகிறது. ஒரு பிழையின் பண்புகள் மாறினால், நீங்கள் ஒரு வகுப்பு வரையறையைப் புதுப்பிக்கிறீர்கள்.
5. கருவி ஆதரவு: தனித்தனி பிழை வகுப்புகளைக் கையாளும்போது IDEகள் மற்றும் லின்டர்கள் பெரும்பாலும் சிறந்த பரிந்துரைகளையும் எச்சரிக்கைகளையும் வழங்க முடியும்.

தனிப்பயன் பிழை வகுப்புகளைக் கையாளுதல்

            function performDatabaseOperation(query: string): any {
    const rand = Math.random();
    if (rand < 0.4) {
        throw new DatabaseConnectionError("Failed to connect to primary DB", "users_db");
    } else if (rand < 0.7) {
        throw new UserAuthenticationError("User session expired", "user123", 'SESSION_EXPIRED');
    } else {
        throw new DataValidationFailedError("User input invalid", { 'name': 'Name is too short', 'email': 'Invalid email format' });
    }
}

try {
    performDatabaseOperation("SELECT * FROM users");
} catch (error: unknown) {
    if (error instanceof DatabaseConnectionError) {
        console.error(`Database Error: ${error.message}. DB: ${error.databaseName}. Code: ${error.code}`);
        // Logic to attempt reconnect or notify ops team
    } else if (error instanceof UserAuthenticationError) {
        console.warn(`Authentication Error (${error.reason}): ${error.message}. User ID: ${error.userId || 'N/A'}`);
        // Logic to redirect to login page or refresh token
    } else if (error instanceof DataValidationFailedError) {
        console.error(`Validation Error: ${error.message}. Invalid fields: ${JSON.stringify(error.invalidFields)}`);
        // Logic to display validation messages to the user
    } else if (error instanceof Error) {
        console.error(`An unexpected standard error occurred: ${error.message}`);
    } else {
        console.error("A truly unexpected error occurred:", error);
    }
}

            

              
                Copy
              
            
          

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

முறை 3: முடிவு/எய்தர் மோனாட் முறை (வெளிப்படையான பிழை கையாளுதல்)

தனிப்பயன் பிழை வகுப்புகளுடன் try...catch விதிவிலக்குகளுக்கு வலுவான கையாளுதலை வழங்கினாலும், சில செயல்பாட்டு நிரலாக்க முன்னுதாரணங்கள் விதிவிலக்குகள் கட்டுப்பாட்டின் இயல்பான ஓட்டத்தை உடைக்கின்றன மற்றும் குறியீட்டைப் பற்றி பகுத்தறிவு செய்வதை கடினமாக்கும் என்று வாதிடுகின்றன, குறிப்பாக ஒத்திசைவற்ற செயல்பாடுகளைக் கையாளும்போது. "முடிவு" அல்லது "எய்தர்" மோனாட் முறை ஒரு மாற்றீட்டை வழங்குகிறது, ஒரு செயல்பாட்டின் திரும்பும் வகையில் வெற்றி மற்றும் தோல்வியை வெளிப்படையாக்கி, அழைப்பாளரை கட்டுப்பாட்டு ஓட்டத்திற்கு `try/catch` ஐ நம்பாமல் இரண்டு விளைவுகளையும் கையாளும்படி கட்டாயப்படுத்துகிறது.

முடிவு/எய்தர் முறை என்றால் என்ன?

ஒரு பிழையை வீசுவதற்குப் பதிலாக, தோல்வியடையக்கூடிய ஒரு செயல்பாடு ஒரு சிறப்பு வகையை (பெரும்பாலும் Result அல்லது Either என்று அழைக்கப்படுகிறது) திருப்பித் தருகிறது, இது ஒரு வெற்றிகரமான மதிப்பை (Ok அல்லது Right) அல்லது ஒரு பிழையை (Err அல்லது Left) உள்ளடக்கியது. இந்த முறை ரஸ்ட் (Result<T, E>) மற்றும் ஸ்காலா (Either<L, R>) போன்ற மொழிகளில் பொதுவானது.

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

ஒரு எளிய Result வகையை செயல்படுத்துதல்

            type Result<T, E> = { success: true; value: T } | { success: false; error: E };

// Helper functions to create Ok and Err results
const ok = <T, E>(value: T): Result<T, E> => ({ success: true, value });
const err = <T, E>(error: E): Result<T, E> => ({ success: false, error });

interface User {
    id: string;
    name: string;
    email: string;
}

// Custom errors for this pattern (can still use classes)
class UserNotFoundError extends Error {
    constructor(userId: string) {
        super(`User with ID '${userId}' not found.`);
        this.name = 'UserNotFoundError';
    }
}

class DatabaseReadError extends Error {
    constructor(message: string, public details?: string) {
        super(message);
        this.name = 'DatabaseReadError';
    }
}

// Function that returns a Result type
function getUserById(id: string): Result<User, UserNotFoundError | DatabaseReadError> {
    // Simulate database operation
    const rand = Math.random();

    if (rand < 0.3) {
        return err(new UserNotFoundError(id)); // Return an error result
    } else if (rand < 0.6) {
        return err(new DatabaseReadError("Failed to read from DB", "Connection timed out")); // Return a database error
    } else {
        return ok({
            id: id,
            name: "John Doe",
            email: `john.${id}@example.com`
        }); // Return a success result
    }
}

// Consuming the Result type
const userResult = getUserById("user-123");

if (userResult.success) {
    console.log(`User found: ${userResult.value.name}, Email: ${userResult.value.email}`);
} else {
    // TypeScript knows userResult.error is of type UserNotFoundError | DatabaseReadError
    if (userResult.error instanceof UserNotFoundError) {
        console.error(`Application Error: ${userResult.error.message}`);
        // Logic for user not found, e.g., display a message to the user
    } else if (userResult.error instanceof DatabaseReadError) {
        console.error(`System Error: ${userResult.error.message}. Details: ${userResult.error.details}`);
        // Logic for database issue, e.g., retry or alert system administrators
    } else {
        // Exhaustive check or fallback for other potential errors
        console.error("An unexpected error occurred:", userResult.error);
    }
}

            

              
                Copy
              
            
          

இந்த முறை தோல்வியடையக்கூடிய செயல்பாடுகளை சங்கிலிப்படுத்தும் போது குறிப்பாக சக்திவாய்ந்ததாக இருக்கும், ஏனெனில் நீங்கள் map, flatMap (அல்லது andThen), மற்றும் பிற செயல்பாட்டுக் கட்டமைப்புகளை ஒவ்வொரு படியிலும் வெளிப்படையான if/else சோதனைகள் இல்லாமல் Result ஐச் செயலாக்க பயன்படுத்தலாம், பிழை கையாளுதலை ஒரு ஒற்றைப் புள்ளிக்கு ஒத்திவைக்கலாம்.

முடிவு முறையின் நன்மைகள்

1. வெளிப்படையான பிழை கையாளுதல்: செயல்பாடுகள் தங்கள் வகை கையொப்பத்தில் என்ன பிழைகளைத் திருப்பித் தரலாம் என்பதை வெளிப்படையாக அறிவிக்கின்றன, அழைப்பாளரை சாத்தியமான அனைத்து தோல்வி நிலைகளையும் ஒப்புக்கொண்டு கையாளும்படி கட்டாயப்படுத்துகின்றன. இது "மறக்கப்பட்ட" விதிவிலக்குகளை நீக்குகிறது.
2. குறிப்பு வெளிப்படைத்தன்மை: விதிவிலக்குகளை கட்டுப்பாட்டு ஓட்ட பொறிமுறையாகத் தவிர்ப்பதன் மூலம், செயல்பாடுகள் மிகவும் கணிக்கக்கூடியதாகவும் சோதிக்க எளிதாகவும் ஆகின்றன.
3. மேம்படுத்தப்பட்ட வாசிப்புத்தன்மை: வெற்றி மற்றும் தோல்விக்கான குறியீட்டுப் பாதை தெளிவாக வரையறுக்கப்பட்டுள்ளது, இது தர்க்கத்தைப் பின்பற்றுவதை எளிதாக்குகிறது.
4. கலவைத்தன்மை: முடிவு வகைகள் செயல்பாட்டு நிரலாக்க நுட்பங்களுடன் நன்றாக இணைகின்றன, இது நேர்த்தியான பிழைப் பரவல் மற்றும் மாற்றத்தை அனுமதிக்கிறது.
5. try...catch கொதிகலன் குறியீடு இல்லை: பல சூழ்நிலைகளில், இந்த முறை try...catch தொகுதிகளின் தேவையை குறைக்க முடியும், குறிப்பாக பல தவறான செயல்பாடுகளை உருவாக்கும்போது.

கருத்தில் கொள்ள வேண்டியவை மற்றும் வர்த்தக பரிமாற்றங்கள்

• சொல்லாடல்: எளிய செயல்பாடுகளுக்கு அல்லது செயல்பாட்டுக் கட்டமைப்புகளை திறம்படப் பயன்படுத்தாதபோது அதிக சொல்லாடல் கொண்டதாக இருக்கலாம்.
• கற்றல் வளைவு: செயல்பாட்டு நிரலாக்கம் அல்லது மோனாட்களுக்கு புதிய டெவலப்பர்கள் ஆரம்பத்தில் இந்த முறையை சிக்கலானதாகக் காணலாம்.
• ஒத்திசைவற்ற செயல்பாடுகள்: பொருந்தும் என்றாலும், தற்போதுள்ள வாக்குறுதி-அடிப்படையிலான ஒத்திசைவற்ற குறியீட்டுடன் ஒருங்கிணைக்க கவனமாக உறையிடுதல் அல்லது மாற்றம் தேவைப்படுகிறது. neverthrow அல்லது fp-ts போன்ற நூலகங்கள் டைப்ஸ்கிரிப்ட்டிற்கு ஏற்றவாறு மிகவும் அதிநவீன `Either`/`Result` செயலாக்கங்களை வழங்குகின்றன, பெரும்பாலும் சிறந்த ஒத்திசைவு ஆதரவுடன்.

முடிவு/எய்தர் முறை வெளிப்படையான பிழை கையாளுதல், செயல்பாட்டுத் தூய்மை மற்றும் அனைத்து εκτέλεση பாதைகளிலும் வகை பாதுகாப்பிற்கு வலுவான முக்கியத்துவம் கொடுக்கும் பயன்பாடுகளுக்கு ஒரு சிறந்த தேர்வாகும். ஒவ்வொரு சாத்தியமான தோல்வி முறையும் வெளிப்படையாகக் கணக்கிடப்பட வேண்டிய பணி-முக்கியமான அமைப்புகளுக்கு இது குறிப்பாகப் பொருத்தமானது.

முறை 4: மையப்படுத்தப்பட்ட பிழை கையாளுதல் உத்திகள்

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

உலகளாவிய பிழை கையாளுபவர்கள்

பிழை கையாளுதலை மையப்படுத்துவது உங்களை அனுமதிக்கிறது:

• பிழைகளை ஒரு கண்காணிப்பு அமைப்புக்கு (எ.கா., சென்ட்ரி, டேட்டாடாக்) சீராகப் பதிவு செய்யுங்கள்.
• அறியப்படாத பிழைகளுக்கு பொதுவான, பயனர் நட்பு பிழைச் செய்திகளை வழங்குங்கள்.
• அறிவிப்புகளை அனுப்புதல், பரிவர்த்தனைகளைத் திரும்பப் பெறுதல் அல்லது சர்க்யூட் பிரேக்கர்களைத் தூண்டுதல் போன்ற பயன்பாடு தழுவிய கவலைகளைக் கையாளுங்கள்.
• தனிப்பட்ட முறையில் அடையாளம் காணக்கூடிய தகவல் (PII) அல்லது முக்கியமான தரவு தரவு தனியுரிமை விதிமுறைகளை (எ.கா., GDPR, CCPA) மீறி பயனர்களுக்கான பிழைச் செய்திகளிலோ அல்லது பதிவுகளிலோ வெளிப்படுத்தப்படவில்லை என்பதை உறுதி செய்யுங்கள்.

பின்னணி (Node.js/Express) எடுத்துக்காட்டு

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

            import express, { Request, Response, NextFunction } from 'express';

// Assume these are our custom error classes
class APIError extends Error {
    constructor(message: string, public statusCode: number = 500) {
        super(message);
        this.name = 'APIError';
    }
}

class UnauthorizedError extends APIError {
    constructor(message: string = 'Unauthorized') {
        super(message, 401);
        this.name = 'UnauthorizedError';
    }
}

class BadRequestError extends APIError {
    constructor(message: string = 'Bad Request') {
        super(message, 400);
        this.name = 'BadRequestError';
    }
}

const app = express();

app.get('/api/users/:id', (req: Request, res: Response, next: NextFunction) => {
    const userId = req.params.id;
    if (userId === 'admin') {
        return next(new UnauthorizedError('Access denied for admin user.'));
    }
    if (!/^[a-z0-9]+$/.test(userId)) {
        return next(new BadRequestError('Invalid user ID format.'));
    }

    // Simulate a successful operation or another unexpected error
    const rand = Math.random();
    if (rand < 0.5) {
        // Successfully fetch user
        res.json({ id: userId, name: 'Test User' });
    } else {
        // Simulate an unexpected internal error
        next(new Error('Failed to retrieve user data due to an unexpected issue.'));
    }
});

// Type-safe error handling middleware
app.use((err: unknown, req: Request, res: Response, next: NextFunction) => {
    // Log the error for internal monitoring
    console.error(`[ERROR] ${new Date().toISOString()} - ${req.method} ${req.originalUrl} -`, err);

    if (err instanceof APIError) {
        // Specific handling for known API errors
        return res.status(err.statusCode).json({
            status: 'error',
            message: err.message,
            code: err.name // Or a specific application-defined error code
        });
    } else if (err instanceof Error) {
        // Generic handling for unexpected standard errors
        return res.status(500).json({
            status: 'error',
            message: 'An unexpected server error occurred.',
            // In production, avoid exposing detailed internal error messages to clients
            detail: process.env.NODE_ENV === 'development' ? err.message : undefined
        });
    } else {
        // Fallback for truly unknown error types
        return res.status(500).json({
            status: 'error',
            message: 'An unknown server error occurred.',
            detail: process.env.NODE_ENV === 'development' ? String(err) : undefined
        });
    }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});

// Example cURL commands:
// curl http://localhost:3000/api/users/admin
// curl http://localhost:3000/api/users/invalid-id!
// curl http://localhost:3000/api/users/valid-id

            

              
                Copy
              
            
          

முகப்பு (React) எடுத்துக்காட்டு: பிழை எல்லைகள்

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

            import React, { Component, ErrorInfo, ReactNode } from 'react';

interface ErrorBoundaryProps {
    children: ReactNode;
    fallback?: ReactNode; // Optional custom fallback UI
}

interface ErrorBoundaryState {
    hasError: boolean;
    error: Error | null;
    errorInfo: ErrorInfo | null;
}

class AppErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
    public state: ErrorBoundaryState = {
        hasError: false,
        error: null,
        errorInfo: null,
    };

    // This static method is called after an error has been thrown by a descendant component.
    static getDerivedStateFromError(_: Error): ErrorBoundaryState {
        // Update state so the next render will show the fallback UI.
        return { hasError: true, error: _, errorInfo: null };
    }

    // This method is called after an error has been thrown by a descendant component.
    componentDidCatch(error: Error, errorInfo: ErrorInfo) {
        // You can also log the error to an error reporting service here
        console.error("Uncaught error in AppErrorBoundary:", error, errorInfo);
        this.setState({ errorInfo: errorInfo, error: error });
    }

    public render() {
        if (this.state.hasError) {
            // You can render any custom fallback UI
            if (this.props.fallback) {
                return this.props.fallback;
            }
            return (
                <div style={{ padding: '20px', border: '1px solid red', borderRadius: '5px' }}>
                    <h2>Oops! Something went wrong.</h2>
                    <p>We're sorry for the inconvenience. Please try refreshing the page or contact support.</p>
                    {this.state.error && (
                        <details style={{ whiteSpace: 'pre-wrap', color: '#666' }}>
                            <summary>Error Details</summary>
                            <p>{this.state.error.message}</p>
                            {this.state.errorInfo && (
                                <p>Component Stack:<br/>{this.state.errorInfo.componentStack}</p>
                            )}
                        </details>
                    )}
                </div>
            );
        }

        return this.props.children;
    }
}

// How to use it:
// function App() {
//   return (
//     <AppErrorBoundary>
//       <SomePotentiallyFailingComponent />
//     </AppErrorBoundary>
//   );
// }

            

              
                Copy
              
            
          

செயல்பாட்டு மற்றும் புரோகிராமர் பிழைகளை வேறுபடுத்துதல்

மையப்படுத்தப்பட்ட பிழை கையாளுதலின் ஒரு முக்கிய அம்சம் இரண்டு முக்கிய வகை பிழைகளுக்கு இடையில் வேறுபடுத்துவதாகும்:

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

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

வகை-பாதுகாப்பான பிழை கையாளுதலுக்கான சிறந்த நடைமுறைகள்

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

1. catch தொகுதிகளில் எப்போதும் unknown ஐக் குறுகலாக்குங்கள்: டைப்ஸ்கிரிப்ட் 4.4+ முதல், catch மாறி unknown ஆகும். பிழை பண்புகளைப் பாதுகாப்பாக அணுகுவதற்கு இயக்க நேர வகை சோதனைகளை (எ.கா., instanceof Error, தனிப்பயன் வகை காவலர்கள்) எப்போதும் செய்யுங்கள். இது பொதுவான இயக்க நேரப் பிழைகளைத் தடுக்கிறது.
2. பொருளுள்ள தனிப்பயன் பிழை வகுப்புகளை வடிவமைத்தல்: குறிப்பிட்ட, சொற்பொருள் நிறைந்த பிழை வகைகளை உருவாக்க அடிப்படை Error வகுப்பை நீட்டிக்கவும். பிழைத்திருத்தம் மற்றும் கையாளுதலில் உதவ பொருத்தமான சூழல்-சார்ந்த பண்புகளை (எ.கா., statusCode, errorCode, invalidFields, userId) சேர்க்கவும்.
3. பிழை ஒப்பந்தங்கள் பற்றி வெளிப்படையாக இருங்கள்: ஒரு செயல்பாடு வீசக்கூடிய அல்லது திரும்பப் பெறக்கூடிய பிழைகளை ஆவணப்படுத்துங்கள். முடிவு முறையைப் பயன்படுத்தினால், இது திரும்பப் பெறும் வகை கையொப்பத்தால் கட்டாயப்படுத்தப்படுகிறது. `try/catch` க்கு, தெளிவான JSDoc கருத்துகள் அல்லது சாத்தியமான விதிவிலக்குகளைத் தெரிவிக்கும் செயல்பாடு கையொப்பங்கள் மதிப்புமிக்கவை.
4. பிழைகளை விரிவாகப் பதிவு செய்யுங்கள்: ஒரு கட்டமைக்கப்பட்ட பதிவு அணுகுமுறையைப் பயன்படுத்தவும். முழுமையான பிழை ஸ்டாக் ட்ரேஸ், அத்துடன் ஏதேனும் தனிப்பயன் பிழை பண்புகள் மற்றும் சூழல் சார்ந்த தகவல்களைப் (எ.கா., கோரிக்கை ஐடி, பயனர் ஐடி, நேரமுத்திரை, சூழல்) பிடிக்கவும். முக்கியமான பயன்பாடுகளுக்கு, ஒரு மையப்படுத்தப்பட்ட பதிவு மற்றும் கண்காணிப்பு அமைப்புடன் (எ.கா., ELK ஸ்டாக், ஸ்ப்ளங்க், டேட்டாடாக், சென்ட்ரி) ஒருங்கிணைக்கவும்.
5. பொதுவான string அல்லது object வகைகளை வீசுவதைத் தவிர்க்கவும்: ஜாவாஸ்கிரிப்ட் அதை அனுமதித்தாலும், மூல சரங்கள், எண்கள் அல்லது வெற்றுப் பொருட்களை வீசுவது வகை-பாதுகாப்பான பிழை கையாளுதலை சாத்தியமற்றதாக்குகிறது மற்றும் உடையக்கூடிய குறியீட்டிற்கு வழிவகுக்கிறது. எப்போதும் Error அல்லது தனிப்பயன் பிழை வகுப்புகளின் நிகழ்வுகளை வீசுங்கள்.
6. முழுமையான சரிபார்ப்புக்கு never ஐப் பயன்படுத்துங்கள்: தனிப்பயன் பிழை வகைகளின் ஒரு யூனியனுடன் கையாளும்போது (எ.கா., ஒரு switch அறிக்கையில் அல்லது if/else if தொடரில்), இறுதி else தொகுதிக்கு `never` வகைக்கு வழிவகுக்கும் ஒரு வகை காவலரைப் பயன்படுத்தவும். இது ஒரு புதிய பிழை வகை அறிமுகப்படுத்தப்பட்டால், டைப்ஸ்கிரிப்ட் கையாளப்படாத வழக்கைக் கொடியிடும் என்பதை உறுதி செய்கிறது.

            type SpecificError = DatabaseConnectionError | UserAuthenticationError | DataValidationFailedError;

function handleSpecificError(error: SpecificError) {
    if (error instanceof DatabaseConnectionError) {
        // ...
    } else if (error instanceof UserAuthenticationError) {
        // ...
    } else if (error instanceof DataValidationFailedError) {
        // ...
    } else {
        // This line should ideally be unreachable. If it is, a new error type was added
        // to SpecificError but not handled here, causing a TS error.
        const exhaustiveCheck: never = error; // TypeScript will flag this if 'error' is not 'never'
    }
}

            

              
                Copy
              
            
          

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

இந்த நடைமுறைகளைக் கடைப்பிடிப்பது உங்கள் டைப்ஸ்கிரிப்ட் பயன்பாடுகளை வெறும் செயல்பாட்டு நிலையிலிருந்து வலுவான, நம்பகமான மற்றும் மிகவும் பராமரிக்கக்கூடியதாக உயர்த்தும், இது உலகெங்கிலும் உள்ள பல்வேறு பயனர் தளங்களுக்கு சேவை செய்யும் திறன் கொண்டது.

பொதுவான ஆபத்துகள் மற்றும் அவற்றை எவ்வாறு தவிர்ப்பது

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

1. catch தொகுதிகளில் unknown வகையைப் புறக்கணித்தல்:

   ஆபத்து: ஒரு catch தொகுதியில் error இன் வகையை குறுகலாக்காமல் நேரடியாக அனுமானித்தல்.

               try {
       throw new Error("Oops");
   } catch (error) {
       // Type 'unknown' is not assignable to type 'Error'.
       // Property 'message' does not exist on type 'unknown'.
       // console.error(error.message); // This will be a TypeScript error!
   }
   
               
   
                 
                   Copy
                 
               
             

   தவிர்ப்பு: வகையைக் குறுகலாக்க எப்போதும் instanceof Error அல்லது தனிப்பயன் வகை காவலர்களைப் பயன்படுத்தவும்.

               try {
       throw new Error("Oops");
   } catch (error: unknown) {
       if (error instanceof Error) {
           console.error(error.message);
       } else {
           console.error("A non-Error type was thrown:", error);
       }
   }
   
               
   
                 
                   Copy
                 
               
             

2. catch தொகுதிகளை மிகை-பொதுமைப்படுத்துதல்:

   ஆபத்து: நீங்கள் ஒரு குறிப்பிட்ட தனிப்பயன் பிழையை மட்டுமே கையாள விரும்பும்போது Error ஐப் பிடித்தல். இது அடிப்படைச் சிக்கல்களை மறைக்கக்கூடும்.

               // Assume a custom APIError
   class APIError extends Error { /* ... */ }
   
   function fetchData() {
       throw new APIError("Failed to fetch");
   }
   
   function processData() {
       try {
           fetchData();
       } catch (error: unknown) {
           // This catches APIError, but also *any* other Error that might be thrown
           // by fetchData or other code in the try block, potentially masking bugs.
           if (error instanceof Error) {
               console.error("Caught a generic error:", error.message);
           }
       }
   }
   
               
   
                 
                   Copy
                 
               
             

   தவிர்ப்பு: முடிந்தவரை குறிப்பாக இருங்கள். நீங்கள் குறிப்பிட்ட தனிப்பயன் பிழைகளை எதிர்பார்த்தால், அவற்றை முதலில் பிடிக்கவும். பொதுவான Error அல்லது unknown க்கு ஒரு பின்னடைவைப் பயன்படுத்தவும்.

               try {
       fetchData();
   } catch (error: unknown) {
       if (error instanceof APIError) {
           // Handle APIError specifically
           console.error("API Error:", error.message);
       } else if (error instanceof Error) {
           // Handle other standard errors
           console.error("Unexpected standard Error:", error.message);
       } else {
           // Handle truly unknown errors
           console.error("Truly unexpected error:", error);
       }
   }
   
               
   
                 
                   Copy
                 
               
             

3. குறிப்பிட்ட பிழைச் செய்திகள் மற்றும் சூழல் இல்லாமை:

   ஆபத்து: பயனுள்ள சூழலை வழங்காமல் "ஒரு பிழை ஏற்பட்டது" போன்ற பொதுவான செய்திகளை வீசுவது, பிழைத்திருத்தத்தைக் கடினமாக்குகிறது.

               throw new Error("Something went wrong."); // Not very helpful
   
               
   
                 
                   Copy
                 
               
             

   தவிர்ப்பு: பிழைச் செய்திகள் விளக்கமாகவும், தொடர்புடைய தரவுகளை (எ.கா., அளவுரு மதிப்புகள், கோப்புப் பாதைகள், ஐடிகள்) உள்ளடக்கியதாகவும் இருப்பதை உறுதி செய்யுங்கள். குறிப்பிட்ட பண்புகளைக் கொண்ட தனிப்பயன் பிழை வகுப்புகள் இதற்குச் சிறந்தவை.

               throw new DatabaseConnectionError("Failed to connect to DB", "users_db", "mongodb://localhost:27017");
   
               
   
                 
                   Copy
                 
               
             

4. பயனர்-சார்ந்த மற்றும் உள் பிழைகளுக்கு இடையில் வேறுபடுத்தாமல் இருப்பது:

   ஆபத்து: மூல தொழில்நுட்ப பிழைச் செய்திகளை (எ.கா., ஸ்டாக் ட்ரேஸ்கள், தரவுத்தள வினவல் பிழைகள்) நேரடியாக இறுதிப் பயனர்களுக்குக் காண்பித்தல்.

               // Bad: Exposing internal details to the user
   catch (error: unknown) {
       if (error instanceof Error) {
           res.status(500).send(`<h1>Server Error</h1><p>${error.stack}</p>`);
       }
   }
   
               
   
                 
                   Copy
                 
               
             

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

               // Good: User-friendly message for client, detailed log for developers
   catch (error: unknown) {
       // ... logging for developers ...
       res.status(500).send("<h1>We're sorry!</h1><p>An unexpected error occurred. Please try again later.</p>");
   }
   
               
   
                 
                   Copy
                 
               
             

5. பிழைப் பொருட்களை மாற்றுதல்:

   ஆபத்து: ஒரு `catch` தொகுதிக்குள் error பொருளை நேரடியாக மாற்றுவது, குறிப்பாக அது மீண்டும் வீசப்பட்டாலோ அல்லது மற்றொரு கையாளுபவருக்கு அனுப்பப்பட்டாலோ. இது எதிர்பாராத பக்க விளைவுகளுக்கு அல்லது அசல் பிழைச் சூழலை இழக்க வழிவகுக்கும்.

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

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

முடிவுரை

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

நாம் பல சக்திவாய்ந்த முறைகளை ஆராய்ந்தோம்:

• இயக்க நேர வகை சரிபார்ப்பு: catch தொகுதிகளில் unknown பிழைகளை instanceof Error மற்றும் தனிப்பயன் வகை காவலர்களைப் பயன்படுத்தி பாதுகாப்பாகக் குறுகலாக்குதல், பிழை பண்புகளுக்கு கணிக்கக்கூடிய அணுகலை உறுதி செய்தல்.
• தனிப்பயன் பிழை வகுப்புகள்: அடிப்படை Error ஐ நீட்டிக்கும் சொற்பொருள் பிழை வகைகளின் ஒரு படிநிலையை வடிவமைத்தல், பணக்கார சூழல் தகவல்களை வழங்குதல் மற்றும் instanceof சோதனைகளுடன் துல்லியமான கையாளுதலை எளிதாக்குதல்.
• முடிவு/எய்தர் மோனாட் முறை: செயல்பாடு திரும்பும் வகைகளில் வெற்றி மற்றும் தோல்வியை வெளிப்படையாகக் குறியாக்கும் ஒரு மாற்று செயல்பாட்டு அணுகுமுறை, அழைப்பாளர்களை இரண்டு விளைவுகளையும் கையாளும்படி கட்டாயப்படுத்துதல் மற்றும் பாரம்பரிய விதிவிலக்கு வழிமுறைகள் மீதான சார்பைக் குறைத்தல்.
• மையப்படுத்தப்பட்ட பிழை கையாளுதல்: உலகளாவிய பிழை கையாளுபவர்களை (எ.கா., மிடில்வேர், பிழை எல்லைகள்) செயல்படுத்துதல், முழு பயன்பாடு முழுவதும் நிலையான பதிவு, கண்காணிப்பு மற்றும் பயனர் பின்னூட்டத்தை உறுதி செய்தல், செயல்பாட்டு மற்றும் புரோகிராமர் பிழைகளுக்கு இடையில் வேறுபடுத்துதல்.

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

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