JavaScript Error Statements

try அறிக்கை

JavaScript இல், try அறிக்கை குறியீட்டு இயக்கத்தின் போது ஏற்படக்கூடிய பிழைகளை (விதிவிலக்குகள் என்றும் அழைக்கப்படுகின்றன) கையாள பயன்படுத்தப்படுகிறது - முழு நிரலையும் நிறுத்தாமல்.

try அறிக்கை catch உடன் சேர்ந்து வேலை செய்கிறது.

சில நேரங்களில் இது finally உடன் வேலை செய்கிறது.

மற்றும் சில நேரங்களில் இது throw உடன் வேலை செய்கிறது.

Try தொகுதி

try தொகுதி பிழையை வீசக்கூடிய குறியீட்டைக் கொண்டுள்ளது.

பிழை எதுவும் ஏற்படாவிட்டால், catch தொகுதி தவிர்க்கப்படும்.

தொடரியல்

try {
  // பிழையை ஏற்படுத்தக்கூடிய குறியீடு
} catch (error) {
  // பிழையைக் கையாளும் குறியீடு
}

🛡️ பாதுகாப்பான குறியீட்டிற்கான Try:

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

Catch தொகுதி

try தொகுதியில் பிழை ஏற்பட்டால் மட்டுமே catch தொகுதி செயல்படுத்தப்படும்.

பிழை பொருள் என்ன தவறு நடந்தது என்பதைப் பற்றிய விவரங்களை வழங்குகிறது.

தொடரியல்

try {
  // பிழையை ஏற்படுத்தக்கூடிய குறியீடு
} catch (error) {
  // பிழையைக் கையாளும் குறியீடு
}

பிழை பொருள் பண்புகள்:

try {
  // பிழையை ஏற்படுத்தக்கூடிய குறியீடு
} catch (err) {
  console.log(err.name);     // பிழை வகை (எ.கா., "TypeError")
  console.log(err.message);  // பிழை செய்தி
  console.log(err.stack);    // குவிப்பு தடம் (debugging)
}

Finally தொகுதி (விருப்பத்தேர்வு)

finally தொகுதி try மற்றும் catch தொகுதிகளுக்குப் பிறகு, பிழை ஏற்பட்டாலும் இல்லையென்றாலும் செயல்படுத்தப்படுகிறது.

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

தொடரியல்

try {
  // பிழையை ஏற்படுத்தக்கூடிய குறியீடு
} catch (error) {
  // பிழையைக் கையாளும் குறியீடு
} finally {
  // எப்படியும் எப்போதும் இயங்கும் குறியீடு
}

💡 Finally இன் முக்கியத்துவம்:

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

JavaScript பிழைகளை வீசுகிறது

பிழை ஏற்பட்டால், JavaScript பொதுவாக நின்று ஒரு பிழை செய்தியை உருவாக்கும்.

இதற்கான தொழில்நுட்ப சொல்: JavaScript ஒரு விதிவிலக்கை வீசும் (பிழையை வீசும்).

JavaScript உண்மையில் இரண்டு பண்புகளுடன் ஒரு Error பொருளை உருவாக்கும்: name மற்றும் message.

// JavaScript தானாகவே பிழைகளை வீசுகிறது
let x = y;  // ReferenceError: y is not defined
let num = 5;
num.toUpperCase();  // TypeError: num.toUpperCase is not a function

throw அறிக்கை

throw அறிக்கை நீங்கள் ஒரு தனிப்பயன் பிழையை உருவாக்க அனுமதிக்கிறது.

தொழில்நுட்ப ரீதியாக நீங்கள் ஒரு விதிவிலக்கை வீசலாம் (பிழையை வீசலாம்).

விதிவிலக்கு ஒரு JavaScript String, Number, Boolean அல்லது Object ஆக இருக்கலாம்:

throw "Too big";    // உரையை வீசவும்
throw 500;          // எண்ணை வீசவும்
throw true;         // boolean ஐ வீசவும்
throw {name: "CustomError", message: "Something went wrong"};  // பொருளை வீசவும்

நீங்கள் throw ஐ try மற்றும் catch உடன் சேர்த்துப் பயன்படுத்தினால், நிரல் ஓட்டத்தைக் கட்டுப்படுத்தலாம் மற்றும் தனிப்பயன் பிழை செய்திகளை உருவாக்கலாம்.

உள்ளீட்டு சரிபார்ப்பு எடுத்துக்காட்டு

இந்த எடுத்துக்காட்டு உள்ளீட்டை ஆய்வு செய்கிறது. மதிப்பு தவறாக இருந்தால், ஒரு விதிவிலக்கு (err) வீசப்படுகிறது.

விதிவிலக்கு (err) catch அறிக்கையால் பிடிக்கப்படுகிறது மற்றும் ஒரு தனிப்பயன் பிழை செய்தி காட்டப்படுகிறது:

<!DOCTYPE html>
<html>
<body>

<p>Please input a number between 5 and 10:</p>

<input id="demo" type="text">
<button type="button" onclick="myFunction()">Test Input</button>
<p id="p01"></p>

<script>
function myFunction() {
  const message = document.getElementById("p01");
  message.innerHTML = "";
  let x = document.getElementById("demo").value;
  try {
    if(x.trim() == "") throw "empty";
    if(isNaN(x)) throw "not a number";
    x = Number(x);
    if(x < 5) throw "too low";
    if(x > 10) throw "too high";
  } catch(err) {
    message.innerHTML = "Input is " + err;
  }
}
</script>

</body>
</html>

விளக்கம்:

வெற்று சரிபார்ப்பு: if(x.trim() == "") throw "empty" - வெற்று உள்ளீட்டை சரிபார்க்கிறது

எண் சரிபார்ப்பு: if(isNaN(x)) throw "not a number" - எண் அல்லாத உள்ளீட்டை சரிபார்க்கிறது

மாற்றம்: x = Number(x) - சரத்தை எண்ணாக மாற்றுகிறது

வரம்பு சரிபார்ப்பு: if(x < 5) throw "too low" - குறைந்த வரம்பை சரிபார்க்கிறது

வரம்பு சரிபார்ப்பு: if(x > 10) throw "too high" - உயர் வரம்பை சரிபார்க்கிறது

HTML சரிபார்ப்பு

மேலே உள்ள குறியீடு ஒரு எடுத்துக்காட்டு மட்டுமே.

நவீன உலாவிகள் பெரும்பாலும் JavaScript மற்றும் உள்ளமைக்கப்பட்ட HTML சரிபார்ப்பு ஆகியவற்றின் கலவையைப் பயன்படுத்தும், HTML பண்புகளில் வரையறுக்கப்பட்ட முன்னரே வரையறுக்கப்பட்ட சரிபார்ப்பு விதிகளைப் பயன்படுத்தும்:

<input id="demo" type="number" min="5" max="10" step="1">

🌐 HTML5 சரிபார்ப்பு பண்புகள்:

HTML5 பல உள்ளமைக்கப்பட்ட சரிபார்ப்பு பண்புகளை வழங்குகிறது:

<input type="email" required>
<input type="number" min="1" max="100">
<input type="text" pattern="[A-Za-z]{3}">
<input type="url">
<input type="date" min="2023-01-01">

Finally எடுத்துக்காட்டு

finally அறிக்கை try மற்றும் catch க்குப் பிறகு, முடிவைப் பொருட்படுத்தாமல் குறியீட்டை இயக்க உங்களை அனுமதிக்கிறது:

தொடரியல்

try {
  // சோதிக்கப்பட வேண்டிய குறியீடு தொகுதி
} catch(err) {
  // பிழைகளைக் கையாளும் குறியீடு தொகுதி
} finally {
  // try / catch முடிவைப் பொருட்படுத்தாமல் இயக்கப்பட வேண்டிய குறியீடு தொகுதி
}

எடுத்துக்காட்டு

function myFunction() {
  const message = document.getElementById("p01");
  message.innerHTML = "";
  let x = document.getElementById("demo").value;
  try {
    if(x.trim() == "") throw "is empty";
    if(isNaN(x)) throw "is not a number";
    x = Number(x);
    if(x > 10) throw "is too high";
    if(x < 5) throw "is too low";
  } catch(err) {
    message.innerHTML = "Error: " + err + ".";
  } finally {
    document.getElementById("demo").value = "";
  }
}

🧹 Finally இன் நடைமுறை பயன்பாடுகள்:

finally தொகுதி பின்வரும் சூழ்நிலைகளில் பயனுள்ளதாக இருக்கும்:

// கோப்பு செயல்பாடுகள்
let file;
try {
  file = openFile("data.txt");
  processFile(file);
} catch(err) {
  console.error("File error:", err);
} finally {
  if(file) closeFile(file);  // எப்போதும் கோப்பை மூடவும்
}

// தரவுத்தள இணைப்புகள்
let connection;
try {
  connection = connectToDatabase();
  executeQuery(connection);
} catch(err) {
  logError(err);
} finally {
  if(connection) connection.close();  // எப்போதும் இணைப்பை மூடவும்
}

// UI லோடர்கள்
showLoader();
try {
  fetchData();
} catch(err) {
  showError(err);
} finally {
  hideLoader();  // எப்போதும் லோடரை மறைக்கவும்
}

Try-Catch-Finally ஓட்ட வரைபடம்

try தொகுதி தொடங்குகிறது

குறியீடு செயல்படுத்தப்படுகிறது

பிழை ஏற்பட்டால் → catch க்கு செல்லவும்

பிழை இல்லை என்றால் → finally க்கு செல்லவும்

catch தொகுதி (விருப்பம்)

try இல் பிழை ஏற்பட்டால் மட்டுமே இயங்கும்

பிழை விவரங்களைக் கையாளுகிறது

பின்னர் → finally க்கு செல்லவும்

finally தொகுதி (விருப்பம்)

எப்போதும் இயங்கும் (பிழை/இல்லை)

சுத்தம் செய்யும் பணிகளுக்கு

நிரல் தொடர்கிறது

மேலும் பார்க்க:

JavaScript Errors

பல்வேறு JavaScript பிழை வகைகள் பற்றி அறியவும்

JavaScript Silent Errors

விதிவிலக்குகளை வீசாத அமைதியான பிழைகள் பற்றி அறியவும்

JavaScript Error Object

Error பொருள் மற்றும் அதன் முறைகள் பற்றி அறியவும்

JavaScript Debugging

JavaScript பிழைகளைக் கண்டறிந்து சரிசெய்வது பற்றி அறியவும்

JavaScript Error Statements பயிற்சி

பிழை அறிக்கைகள் பற்றிய உங்கள் அறிவைச் சோதிக்க இந்தப் பயிற்சியை முயற்சிக்கவும்.

❓ பின்வரும் எந்த தொகுதி try...catch கட்டமைப்பில் எப்போதும் இயங்கும், பிழை ஏற்பட்டாலும் இல்லையென்றாலும்?

try தொகுதி

✗ தவறு! try தொகுதி பிழை ஏற்பட்டால் மட்டுமே இயங்கும் அல்லது நிற்கும்

catch தொகுதி

✗ தவறு! catch தொகுதி try தொகுதியில் பிழை ஏற்பட்டால் மட்டுமே இயங்கும்

finally தொகுதி

✓ சரி! finally தொகுதி எப்போதும் இயங்கும், try தொகுதியில் பிழை ஏற்பட்டாலும் இல்லையென்றாலும். இது சுத்தம் செய்யும் பணிகள் மற்றும் வள வெளியீட்டிற்கு பயன்படுத்தப்படுகிறது

throw அறிக்கை

✗ தவறு! throw அறிக்கை ஒரு பிழையை வீச பயன்படுகிறது, ஆனால் எப்போதும் இயங்காது