ECMAScript 2016
ECMAScript 2016 (ES7 எனவும் அழைக்கப்படுகிறது) என்பது ஜாவாஸ்கிரிப்ட் மொழிக்கான 7வது பதிப்பாகும். இது 2016 ஆம் ஆண்டில் வெளியிடப்பட்டது மற்றும் அதிவேக செயல்பாட்டு ஆபரேட்டர் மற்றும் Array.includes() முறை ஆகிய இரண்டு முக்கிய அம்சங்களை மட்டுமே அறிமுகப்படுத்தியது.
இந்த டுடோரியலில், ES2016 இல் அறிமுகப்படுத்தப்பட்ட அனைத்து அம்சங்களையும் நீங்கள் கற்றுக்கொள்வீர்கள்.
JavaScript 2016 இல் புதிய அம்சங்கள்
| அம்சம் | விளக்கம் |
|---|---|
| ** | முதல் செயலியை இரண்டாவது செயலியின் சக்தியாக உயர்த்துகிறது |
| **= | ஒரு மாறியின் மதிப்பை வலது செயலியின் சக்தியாக உயர்த்துகிறது |
| Array includes() | ஒரு உறுப்பு வரிசையில் உள்ளதா என சரிபார்க்கிறது |
குறிப்பு:
மார்ச் 2017 முதல் அனைத்து நவீன உலாவிகளிலும் ஆதரிக்கப்படுகிறது.
உலாவி ஆதரவு
JavaScript 2016 மார்ச் 2017 முதல் அனைத்து நவீன உலாவிகளிலும் ஆதரிக்கப்படுகிறது:
| Chrome | Edge | Firefox | Safari | Opera |
|---|---|---|---|---|
| 52 | 15 | 52 | 10.1 | 39 |
| ஜூலை 2016 | ஏப்ரல் 2017 | மார்ச் 2017 | மே 2017 | ஆகஸ்ட் 2016 |
முக்கிய குறிப்பு:
ES 2016 இன்டர்நெட் எக்ஸ்ப்ளோரரில் ஆதரிக்கப்படவில்லை.
Exponentiation Operator
அதிவேக செயல்பாட்டு ஆபரேட்டர் (**) முதல் செயலியை இரண்டாவது செயலியின் சக்தியாக உயர்த்துகிறது.
எடுத்துக்காட்டு
let x = 5;
let z = x ** 2;
x ** y Math.pow(x, y) போன்ற அதே முடிவை உருவாக்குகிறது:
எடுத்துக்காட்டு
let x = 5;
let z = Math.pow(x,2);
** vs Math.pow():
** ஆபரேட்டர் Math.pow() முறையை விட எளிமையானது மற்றும் மேலும் சுருக்கமானது. இது சிறிய கணக்கீடுகளுக்கு குறிப்பாக பயனுள்ளதாக இருக்கும்.
Exponentiation Assignment
அதிவேக ஒதுக்கீடு ஆபரேட்டர் (**=) ஒரு மாறியின் மதிப்பை வலது செயலியின் சக்தியாக உயர்த்துகிறது.
எடுத்துக்காட்டு
let x = 5;
x **= 2;
மேலே உள்ள குறியீடு பின்வரும் குறியீட்டிற்கு சமமானது:
let x = 5;
x = x ** 2;
ஒதுக்கீடு ஆபரேட்டர்கள்:
**= என்பது +=, -=, *=, /= போன்ற பிற ஒதுக்கீடு ஆபரேட்டர்களுடன் ஒத்துப்போகிறது. இது மாறிகளின் மதிப்புகளை மாற்றுவதற்கான ஒரு சுருக்கமான வழியை வழங்குகிறது.
JavaScript Array includes()
ECMAScript 2016 வரிசைகளுக்கு Array.includes ஐ அறிமுகப்படுத்தியது.
இது ஒரு உறுப்பு வரிசையில் உள்ளதா என சரிபார்க்க அனுமதிக்கிறது:
எடுத்துக்காட்டு
const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.includes("Mango");
Array.includes() விரிவான பயன்பாடு:
// ஒரு உறுப்பு வரிசையில் உள்ளதா என சரிபார்க்க
const numbers = [1, 2, 3, 4, 5];
console.log(numbers.includes(3)); // true
console.log(numbers.includes(6)); // false
// fromIndex அளவுருவுடன்
console.log(numbers.includes(2, 2)); // false (இந்தக்ஸ் 2 இல் இருந்து தேடுகிறது)
// சரங்களுடன் பயன்பாடு
const colors = ["red", "green", "blue"];
console.log(colors.includes("green")); // true
console.log(colors.includes("yellow")); // false
includes() vs indexOf():
Array.includes() Array.indexOf() ஐ விட மேம்பட்டது, ஏனெனில் இது NaN மதிப்புகளைக் கண்டறிய முடியும் மற்றும் இது கண்டுபிடிக்கப்பட்ட உறுப்பின் இடத்தை விட ஒரு பூலியன் மதிப்பை வழங்குகிறது, இது அதன் நோக்கத்தை தெளிவாக்குகிறது.
நடைமுறை எடுத்துக்காட்டுகள்
அதிவேக கணக்கீடுகள்:
// சதுரங்களைக் கணக்கிடுதல்
let side = 5;
let area = side ** 2; // 25
// கன சதுரங்களைக் கணக்கிடுதல்
let side2 = 3;
let volume = side2 ** 3; // 27
// அடுக்குகளுடன் வேலை
let base = 2;
let exponent = 8;
let result = base ** exponent; // 256
வரிசை சோதனைகள்:
// பயனர் அங்கீகாரத்தை சரிபார்க்க
const allowedUsers = ["admin", "manager", "editor", "viewer"];
function hasAccess(username) {
return allowedUsers.includes(username.toLowerCase());
}
console.log(hasAccess("Admin")); // true
console.log(hasAccess("guest")); // false
// தயாரிப்பு கிடைக்கும் தன்மையை சரிபார்க்க
const availableProducts = ["laptop", "phone", "tablet", "watch"];
function isProductAvailable(product) {
return availableProducts.includes(product.toLowerCase());
}
முந்தைய முறைகளுடன் ஒப்பீடு
** ஆபரேட்டர்
ES2016 முன்: Math.pow(5, 2)
ES2016 பிறகு: 5 ** 2
நன்மை: சுருக்கமான மற்றும் எளிதானது
Array.includes()
ES2016 முன்: arr.indexOf("value") !== -1
ES2016 பிறகு: arr.includes("value")
நன்மை: தெளிவான மற்றும் படிக்க எளிதானது
**= ஆபரேட்டர்
ES2016 முன்: x = Math.pow(x, 2)
ES2016 பிறகு: x **= 2
நன்மை: சுருக்கமான ஒதுக்கீடு
ECMAScript 2016 பயிற்சி
ES2016 இல் கற்றுக்கொண்ட அம்சங்களைச் சோதிக்க இந்தப் பயிற்சியை முயற்சிக்கவும்.