JavaScript 1999 (ES3)

JavaScript க்கான முதல் திருத்தத்தைக் கற்றுக்கொள்ளுங்கள்

ECMAScript 3 (1999)

JavaScript க்கான முதல் திருத்தம்.

ECMAScript 1999 ES3 என்றும் அறியப்படுகிறது.

📜 வரலாற்று முக்கியத்துவம்:

ES3 என்பது JavaScript இன் வளர்ச்சியில் ஒரு முக்கியமான புள்ளியாகும். இது ஒரு முதிர்ந்த மொழி விவரக்குறிப்பை வழங்கியது மற்றும் பல ஆண்டுகளுக்கு தரநிலையாக இருந்தது.

ES3 அம்சங்கள்

அம்சம் விளக்கம்
Regular expressions தேடல் வடிவத்தை உருவாக்கும் எழுத்துகளின் வரிசை
Error handling (try...catch) பிழையின் விஷயத்தில் சோதிக்கப்பட வேண்டிய குறியீடு தொகுதிகளை வரையறுக்கும் அறிக்கை
The switch keyword நிபந்தனைகளின் அடிப்படையில் செயல்படுத்தப்பட வேண்டிய குறியீடு தொகுதிகளைத் தேர்ந்தெடுக்கிறது
The do...while loop while loop இன் மாறுபாடு

⚠️ குறிப்பு:

ES3 விவரக்குறிப்பு JavaScript க்கான முதல் முதிர்ந்த விவரக்குறிப்பாக இருந்தது மற்றும் பல ஆண்டுகளாக நடைமுறை தரநிலையாக இருந்தது.

உலாவி ஆதரவு

JavaScript 1999 அனைத்து உலாவிகளிலும் ஆதரிக்கப்படுகிறது:

Chrome IE/Edge Firefox Safari Opera
ஆதரிக்கிறது ஆதரிக்கிறது ஆதரிக்கிறது ஆதரிக்கிறது ஆதரிக்கிறது

🌐 உலகளாவிய இணக்கத்தன்மை:

ES3 அம்சங்கள் கிட்டத்தட்ட அனைத்து உலாவிகளிலும் ஆதரிக்கப்படுவதால், பழைய உலாவிகளுக்கு இணக்கமான பயன்பாடுகளை உருவாக்குவதற்கு இது இன்றும் முக்கியமானது.

Regular Expressions

தேடல் வடிவத்தை உருவாக்கும் எழுத்துகளின் வரிசை.

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

ஒரு சரத்தில் "w3schools" க்கு case-insensitive தேடலைச் செய்யுங்கள்:

let text = "Visit W3Schools";
let n = text.search(/w3schools/i);

Regular Expressions இன் பிற எடுத்துக்காட்டுகள்:

// எண்களைக் கண்டறிதல்
let pattern = /\d+/;
let result = "Hello 123 World".match(pattern); // ["123"]

// மின்னஞ்சல் சரிபார்ப்பு
let emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
let isValid = emailPattern.test("test@example.com"); // true

// சரத்தில் அனைத்து எண்களையும் மாற்றுதல்
let text = "Price: $100, Discount: $20";
let newText = text.replace(/\d+/g, "NUM"); // "Price: $NUM, Discount: $NUM"

🔍 Regular Expressions பயன்கள்:

Regular expressions தரவு சரிபார்ப்பு, சரம் கையாளுதல், தேடல் மற்றும் மாற்றுதல், மற்றும் வடிவங்களைப் பிரித்தெடுத்தல் ஆகியவற்றிற்கு பரவலாகப் பயன்படுத்தப்படுகின்றன.

Error Handling (try...catch)

பிழையின் விஷயத்தில் சோதிக்கப்பட வேண்டிய குறியீடு தொகுதிகளை வரையறுக்கும் அறிக்கை.

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

இல்லாத மாறியைப் பயன்படுத்த முடியாது:

let x = 5;

try {
  x = y + 1;
} catch(err) {
  let text = err.name;
}

மேம்பட்ட Error Handling:

// finally தொகுதியுடன்
try {
  // குறியீடு சோதனை
  let result = riskyOperation();
} catch(error) {
  // பிழையைக் கையாளுதல்
  console.error("An error occurred:", error.message);
} finally {
  // எப்போதும் இயக்கப்படும்
  console.log("Operation completed");
}

// பல வகையான பிழைகளைக் கையாளுதல்
try {
  let data = JSON.parse(invalidJson);
} catch(error) {
  if (error instanceof SyntaxError) {
    console.log("JSON பாகுபடுத்தும் பிழை");
  } else if (error instanceof TypeError) {
    console.log("வகை பிழை");
  } else {
    console.log("மற்ற பிழை:", error);
  }
}

💡 Error Handling முக்கியத்துவம்:

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

switch Keyword

ஒரு நிபந்தனையின் அடிப்படையில், switch ஒன்று அல்லது அதற்கு மேற்பட்ட குறியீடு தொகுதிகளைச் செயல்படுத்தத் தேர்ந்தெடுக்கிறது.

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

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

switch (new Date().getDay()) {
  case 0:
    day = "Sunday";
    break;
  case 1:
    day = "Monday";
    break;
  case 2:
     day = "Tuesday";
    break;
  case 3:
    day = "Wednesday";
    break;
  case 4:
    day = "Thursday";
    break;
  case 5:
    day = "Friday";
    break;
  case 6:
    day = "Saturday";
}

Switch Statement இன் பிற பயன்பாடுகள்:

// பல case களுக்கு ஒரே குறியீடு
let grade = 'B';
let result;

switch(grade) {
  case 'A':
  case 'B':
  case 'C':
    result = "Pass";
    break;
  case 'D':
  case 'F':
    result = "Fail";
    break;
  default:
    result = "Invalid grade";
}

// default case
let fruit = "apple";
switch(fruit) {
  case "banana":
    console.log("Yellow fruit");
    break;
  case "apple":
    console.log("Red fruit");
    break;
  default:
    console.log("Unknown fruit");
}

do...while Loop

do while குறைந்தபட்சம் ஒருமுறையாவது இயங்கும், நிபந்தனை ஆரம்பத்திலிருந்து false ஆக இருந்தாலும் கூட.

இது நிபந்தனை சோதிக்கப்படுவதற்கு முன் குறியீடு தொகுதி செயல்படுத்தப்படுவதால்.

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

do {
  text += "The number is " + i;
  i++;
}
while (i < 10);

do...while vs while:

do...while loop

let i = 0;
do {
  console.log(i);
  i++;
} while (i < 5);
// Output: 0 1 2 3 4

சிறப்பியல்பு: குறைந்தபட்சம் ஒருமுறை இயங்கும்

while loop

let i = 0;
while (i < 5) {
  console.log(i);
  i++;
}
// Output: 0 1 2 3 4

சிறப்பியல்பு: நிபந்தனை true ஆக இருந்தால் மட்டுமே இயங்கும்

⚠️ கவனிக்க:

நிபந்தனையில் பயன்படுத்தப்படும் மாறியை அதிகரிக்க மறக்காதீர்கள், இல்லையெனில் loop ஒருபோதும் முடிவடையாது!

நடைமுறை எடுத்துக்காட்டு:

// பயனர் உள்ளீட்டைச் சரிபார்க்க do...while பயன்படுத்துதல்
let userInput;
let isValid = false;

do {
  userInput = prompt("ஒரு எண்ணை உள்ளிடவும் (1-10):");
  let num = parseInt(userInput);
  
  if (num >= 1 && num <= 10 && !isNaN(num)) {
    isValid = true;
    console.log("சரியான உள்ளீடு: " + num);
  } else {
    console.log("தவறான உள்ளீடு. மீண்டும் முயற்சிக்கவும்.");
  }
} while (!isValid);

ES3 சூழல் மற்றும் பாரம்பரியம்

ES3 JavaScript மொழியின் வளர்ச்சியில் ஒரு முக்கிய மைல்கல்லைக் குறிக்கிறது:

முதல் முதிர்ந்த தரநிலை: ES3 JavaScript க்கான முதல் முழுமையான, முதிர்ந்த விவரக்குறிப்பாக இருந்தது
நீண்ட கால ஆதரவு: ES3 அம்சங்கள் பல ஆண்டுகளாக அனைத்து பெரிய உலாவிகளிலும் ஆதரிக்கப்பட்டன
அடிப்படை மொழி கட்டமைப்புகள்: Regular expressions, error handling, மற்றும் கட்டுப்பாட்டு கட்டமைப்புகள் போன்ற முக்கிய அம்சங்களை அறிமுகப்படுத்தியது
பின்னோக்கு இணக்கத்தன்மை: ES3 அம்சங்கள் பின்னால் வரும் அனைத்து ES பதிப்புகளிலும் ஆதரிக்கப்படுகின்றன

🏛️ வரலாற்று சூழல்:

ES3 1999 இல் வெளியிடப்பட்டது மற்றும் 2009 இல் ES5 வெளியிடப்படும் வரை 10 ஆண்டுகளுக்கு JavaScript க்கான முதன்மை தரநிலையாக இருந்தது. இது வலை மேம்பாட்டின் ஆரம்ப காலங்களில் முக்கியமான பங்கு வகித்தது.

JavaScript 1999 (ES3) பயிற்சி

ES3 இல் கற்றுக்கொண்ட அம்சங்களைச் சோதிக்க இந்தப் பயிற்சியை முயற்சிக்கவும்.

ES3 இல் அறிமுகப்படுத்தப்பட்ட பின்வரும் எந்த loop குறைந்தபட்சம் ஒருமுறை இயங்கும், நிபந்தனை ஆரம்பத்திலிருந்து false ஆக இருந்தாலும் கூட?

while loop
✗ தவறு! while loop நிபந்தனை true ஆக இருந்தால் மட்டுமே இயங்கும்
for loop
✗ தவறு! for loop ஒரு குறிப்பிட்ட எண்ணிக்கையிலான முறை மட்டுமே இயங்கும்
for...in loop
✗ தவறு! for...in loop பொருளின் பண்புகள் வழியாக மட்டுமே சுழலும்
do...while loop
✓ சரி! do...while loop குறைந்தபட்சம் ஒருமுறை இயங்கும், நிபந்தனை ஆரம்பத்திலிருந்து false ஆக இருந்தாலும் கூட, ஏனெனில் குறியீடு நிபந்தனை சோதிக்கப்படுவதற்கு முன் இயக்கப்படுகிறது