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 1999 இல் வெளியிடப்பட்டது மற்றும் 2009 இல் ES5 வெளியிடப்படும் வரை 10 ஆண்டுகளுக்கு JavaScript க்கான முதன்மை தரநிலையாக இருந்தது. இது வலை மேம்பாட்டின் ஆரம்ப காலங்களில் முக்கியமான பங்கு வகித்தது.
JavaScript 1999 (ES3) பயிற்சி
ES3 இல் கற்றுக்கொண்ட அம்சங்களைச் சோதிக்க இந்தப் பயிற்சியை முயற்சிக்கவும்.