Home-theater-designers
ES6 என்பது ECMA ஸ்கிரிப்ட் நிரலாக்க மொழியின் பதிப்பு 6 ஐக் குறிக்கிறது. ECMA ஸ்கிரிப்ட் என்பது ஜாவாஸ்கிரிப்டுக்கான தரப்படுத்தப்பட்ட பெயர், மற்றும் பதிப்பு 6 பதிப்பு 5 க்குப் பிறகு அடுத்த பதிப்பாகும், இது 2011 இல் வெளியிடப்பட்டது. இது ஜாவாஸ்கிரிப்ட் மொழிக்கு ஒரு முக்கிய மேம்பாடு ஆகும், மேலும் பெரிய அளவிலான மென்பொருள் மேம்பாட்டை எளிதாக்க இன்னும் பல அம்சங்களைச் சேர்க்கிறது .
ECMAScript, அல்லது ES6, ஜூன் 2015 இல் வெளியிடப்பட்டது. அது பின்னர் ECMAScript 2015 என மறுபெயரிடப்பட்டது. முழு மொழிக்கான வலை உலாவி ஆதரவு இன்னும் முழுமையடையவில்லை, இருப்பினும் முக்கிய பகுதிகள் ஆதரிக்கப்படுகின்றன. முக்கிய வலை உலாவிகள் ES6 இன் சில அம்சங்களை ஆதரிக்கின்றன. இருப்பினும், ஒரு எனப்படும் மென்பொருளைப் பயன்படுத்த முடியும் ஆட்டக்காரர் ES6 குறியீட்டை ES5 ஆக மாற்ற, இது பெரும்பாலான உலாவிகளில் சிறப்பாக ஆதரிக்கப்படுகிறது.
ஜாவாஸ்கிரிப்டில் ES6 கொண்டு வரும் சில முக்கிய மாற்றங்களை இப்போது பார்க்கலாம்.
1. மாறிலிகள்
இறுதியாக மாறிலிகளின் கருத்து அதை ஜாவாஸ்கிரிப்ட்டாக மாற்றியுள்ளது! மாறிலிகள் என்பது ஒரு முறை மட்டுமே வரையறுக்கக்கூடிய மதிப்புகள் (ஒரு நோக்கம், நோக்கம் கீழே விளக்கப்பட்டுள்ளது). அதே நோக்கத்திற்குள் ஒரு மறு-வரையறை ஒரு பிழையைத் தூண்டுகிறது.
const JOE = 4.0
JOE= 3.5
// results in: Uncaught TypeError: Assignment to constant variable.
நீங்கள் ஒரு மாறியைப் பயன்படுத்தக்கூடிய எல்லா இடங்களிலும் நீங்கள் மாறிலியைப் பயன்படுத்தலாம் ( எங்கே )
console.log('Value is: ' + joe * 2)
// prints: 8
2. பிளாக்-ஸ்கோப் செய்யப்பட்ட மாறிகள் மற்றும் செயல்பாடுகள்
21 ஆம் நூற்றாண்டுக்கு வரவேற்கிறோம், ஜாவாஸ்கிரிப்ட்! ES6 உடன், மாறிகள் பயன்படுத்தி அறிவிக்கப்பட்டன அனுமதிக்க (மற்றும் மேலே விவரிக்கப்பட்டுள்ள மாறிலிகள்) ஜாவா, சி ++ போன்றவற்றில் உள்ளதைப் போல் தொகுதி ஸ்கோப்பிங் விதிகளைப் பின்பற்றவும் (மேலும் அறிய, ஜாவாஸ்கிரிப்ட்டில் மாறிகளை எவ்வாறு அறிவிப்பது என்று பார்க்கவும்.
இந்த புதுப்பிப்புக்கு முன், ஜாவாஸ்கிரிப்டில் உள்ள மாறிகள் செயல்பாட்டு நோக்கம் கொண்டவை. அதாவது, ஒரு மாறிக்கு உங்களுக்கு ஒரு புதிய நோக்கம் தேவைப்படும்போது, நீங்கள் அதை ஒரு செயல்பாட்டிற்குள் அறிவிக்க வேண்டும்.
தொகுதியின் இறுதி வரை மாறிகள் மதிப்பைத் தக்கவைத்துக்கொள்கின்றன. தொகுதிக்குப் பிறகு, வெளிப்புறத் தொகுதியில் உள்ள மதிப்பு (ஏதேனும் இருந்தால்) மீட்டமைக்கப்படும்.
கூகுள் பிளே சேவைகளை எவ்வாறு புதுப்பிப்பது
{
let x = 'hello';
{
let x = 'world';
console.log('inner block, x = ' + x);
}
console.log('outer block, x = ' + x);
}
// prints
inner block, x = world
outer block, x = hello
அத்தகைய தொகுதிகளுக்குள் நீங்கள் மாறிலிகளையும் மறுவரையறை செய்யலாம்.
{
let x = 'hello';
{
const x = 4.0;
console.log('inner block, x = ' + x);
try {
x = 3.5
} catch(err) {
console.error('inner block: ' + err);
}
}
x = 'world';
console.log('outer block, x = ' + x);
}
// prints
inner block, x = 4
inner block: TypeError: Assignment to constant variable.
outer block, x = world
3. அம்பு செயல்பாடுகள்
ES6 அறிமுகப்படுத்துகிறது அம்பு செயல்பாடுகள் ஜாவாஸ்கிரிப்டுக்கு. (இவை பாரம்பரிய செயல்பாடுகளுக்கு ஒத்தவை, ஆனால் எளிமையான தொடரியல் உள்ளது.) பின்வரும் எடுத்துக்காட்டில், எக்ஸ் என்ற அளவுருவை ஏற்றுக்கொள்ளும் செயல்பாடு ஆகும் க்கு மற்றும் அதன் அதிகரிப்பைத் தருகிறது:
var x = a => a + 1;
x(4) // returns 5
இந்த தொடரியலைப் பயன்படுத்தி, செயல்பாடுகளில் வாதங்களை எளிதாக வரையறுத்து அனுப்பலாம்.
A உடன் பயன்படுத்துதல் ஒவ்வொரு() :
[1, 2, 3, 4].forEach(a => console.log(a + ' => ' + a*a))
// prints
1 => 1
2 => 4
3 => 9
4 => 16
அடைப்புக்குறிக்குள் இணைப்பதன் மூலம் பல வாதங்களை ஏற்று செயல்பாடுகளை வரையறுக்கவும்:
[22, 98, 3, 44, 67].sort((a, b) => a - b)
// returns
[3, 22, 44, 67, 98]
4. இயல்புநிலை செயல்பாட்டு அளவுருக்கள்
செயல்பாட்டு அளவுருக்கள் இப்போது இயல்புநிலை மதிப்புகளுடன் அறிவிக்கப்படலாம். பின்வருபவை, எக்ஸ் இரண்டு அளவுருக்கள் கொண்ட ஒரு செயல்பாடு ஆகும் க்கு மற்றும் b . இரண்டாவது அளவுரு b இன் இயல்புநிலை மதிப்பு கொடுக்கப்பட்டுள்ளது 1 .
var x = (a, b = 1) => a * b
x(2)
// returns 2
x(2, 2)
// returns 4
சி ++ அல்லது பைதான் போன்ற பிற மொழிகளைப் போலல்லாமல், இயல்புநிலை மதிப்புகள் கொண்ட அளவுருக்கள் இயல்புநிலை இல்லாதவர்களுக்கு முன் தோன்றலாம். இந்த செயல்பாடு ஒரு தொகுதி என வரையறுக்கப்படுகிறது என்பதை நினைவில் கொள்க திரும்ப விளக்கத்தின் மூலம் மதிப்பு.
var x = (a = 2, b) => { return a * b }
எனினும் வாதங்கள் இடமிருந்து வலமாக பொருந்துகின்றன. கீழே உள்ள முதல் அழைப்பில், b உள்ளது வரையறுக்கப்படாத இருந்தாலும் மதிப்பு க்கு இயல்புநிலை மதிப்புடன் அறிவிக்கப்பட்டுள்ளது. நிறைவேற்றப்பட்ட வாதம் பொருந்துகிறது க்கு மாறாக b . செயல்பாடு திரும்பும் NaN .
x(2)
// returns NaN
x(1, 3)
// returns 3
நீங்கள் வெளிப்படையாக உள்ளே செல்லும்போது வரையறுக்கப்படாத ஒரு வாதமாக, இயல்புநிலை மதிப்பு ஒன்று இருந்தால் பயன்படுத்தப்படுகிறது.
x(undefined, 3)
// returns 6
5. ஓய்வு செயல்பாடு அளவுருக்கள்
ஒரு செயல்பாட்டைத் தூண்டும்போது, சில நேரங்களில் தன்னிச்சையான எண்ணிக்கையிலான வாதங்களை அனுப்பவும், இந்த வாதங்களை செயல்பாட்டிற்குள் செயல்படுத்தவும் ஒரு தேவை எழுகிறது. இந்த தேவை கையாளப்படுகிறது ஓய்வு செயல்பாடு அளவுருக்கள் தொடரியல். கீழே காட்டப்பட்டுள்ள தொடரியலைப் பயன்படுத்தி வரையறுக்கப்பட்ட வாதங்களுக்குப் பிறகு மீதமுள்ள வாதங்களைப் பிடிக்க இது ஒரு வழியை வழங்குகிறது. இந்த கூடுதல் வாதங்கள் ஒரு வரிசையில் பிடிக்கப்படுகின்றன.
var x = function(a, b, ...args) { console.log('a = ' + a + ', b = ' + b + ', ' + args.length + ' args left'); }
x(2, 3)
// prints
a = 2, b = 3, 0 args left
x(2, 3, 4, 5)
// prints
a = 2, b = 3, 2 args left
6. சரம் வார்ப்பு
ஸ்ட்ரிங் டெம்ப்ளேட்டிங் என்பது பெர்ல் அல்லது ஷெல் போன்ற தொடரியல் பயன்படுத்தி மாறிகள் மற்றும் வெளிப்பாடுகளை சரங்களாக இணைப்பதை குறிக்கிறது. ஒரு சரம் வார்ப்புரு பின்-டிக் எழுத்துக்களில் இணைக்கப்பட்டுள்ளது ( ' ) மாறாக ஒற்றை மேற்கோள்கள் ( ' ) அல்லது இரட்டை மேற்கோள்கள் ( ' ) சாதாரண சரங்களைக் குறிக்கவும். டெம்ப்ளேட்டின் உள்ளே வெளிப்பாடுகள் இடையில் குறிக்கப்பட்டுள்ளன $ { மற்றும் } . இங்கே ஒரு உதாரணம்:
var name = 'joe';
var x = `hello ${name}`
// returns 'hello joe'
நிச்சயமாக, மதிப்பீட்டிற்கு நீங்கள் தன்னிச்சையான வெளிப்பாட்டைப் பயன்படுத்தலாம்.
// define an arrow function
var f = a => a * 4
// set a parameter value
var v = 5
// and evaluate the function within the string template
var x = `hello ${f(v)}`
// returns 'hello 20'
சரங்களை வரையறுப்பதற்கான இந்த தொடரியல் பல-வரி சரங்களை வரையறுக்கவும் பயன்படுத்தப்படலாம்.
var x = `hello world
next line`
// returns
hello world
next line
7. பொருள் பண்புகள்
ES6 எளிமைப்படுத்தப்பட்ட பொருள் உருவாக்கம் தொடரியலைக் கொண்டுவருகிறது. கீழே உள்ள உதாரணத்தைப் பாருங்கள்:
var x = 'hello world', y = 25
var a = { x, y }
// is equivalent to the ES5:
{x: x, y: y}
கணக்கிடப்பட்ட சொத்து பெயர்களும் மிகவும் நிஃப்டி. ES5 மற்றும் அதற்கு முன்னதாக, கணக்கிடப்பட்ட பெயருடன் ஒரு பொருள் சொத்தை அமைக்க, நீங்கள் இதை செய்ய வேண்டும்:
var x = 'hello world', y = 25
var a = {x: x, y: y}
a['joe' + y] = 4
// a is now:
{x: 'hello world', y: 25, joe25: 4}
இப்போது நீங்கள் அனைத்தையும் ஒரே வரையறையில் செய்யலாம்:
var a = {x, y, ['joe' + y]: 4}
// returns
{x: 'hello world', y: 25, joe25: 4}
நிச்சயமாக, முறைகளை வரையறுக்க, நீங்கள் அதை பெயருடன் வரையறுக்கலாம்:
var a = {x, y, ['joe' + y]: 4, foo(v) { return v + 4 }}
a.foo(2)
// returns
6
8. முறையான வகுப்பு வரையறை தொடரியல்
வகுப்பு வரையறை
இறுதியாக, ஜாவாஸ்கிரிப்ட் முறையான வகுப்பு வரையறை தொடரியல் பெறுகிறது. ஏற்கனவே கிடைக்கும் புரோடைடைப் அடிப்படையிலான வகுப்புகளில் இது வெறும் தொடரியல் சர்க்கரையாக இருந்தாலும், அது குறியீடு தெளிவை அதிகரிக்க உதவுகிறது. அதாவது இது செய்கிறது இல்லை ஒரு புதிய பொருள் மாதிரி அல்லது அது போன்ற ஆடம்பரமான எதையும் சேர்க்கவும்.
class Circle {
constructor(radius) {
this.radius = radius
}
}
// use it
var c = new Circle(4)
// returns: Circle {radius: 4}
அறிவிக்கும் முறைகள்
ஒரு முறையை வரையறுப்பது மிகவும் எளிது. அங்கு ஆச்சரியங்கள் இல்லை.
class Circle {
constructor(radius) {
this.radius = radius
}
computeArea() { return Math.PI * this.radius * this.radius }
}
var c = new Circle(4)
c.computeArea()
// returns: 50.26548245743669
பெறுபவர்கள் மற்றும் அமைப்பவர்கள்
தொடரியலுக்கான எளிய புதுப்பிப்புடன் எங்களிடம் இப்போது பெறுபவர்கள் மற்றும் செட்டர்கள் உள்ளன. நாம் மறுவரையறை செய்வோம் வட்டம் ஒரு வகுப்பு பகுதி சொத்து
class Circle {
constructor(radius) {
this.radius = radius
}
get area() { return Math.PI * this.radius * this.radius }
}
var c = new Circle(4)
// returns: Circle {radius: 4}
c.area
// returns: 50.26548245743669
இப்போது ஒரு செட்டரைச் சேர்ப்போம். வரையறுக்க முடியும் ஆரம் சரிசெய்யக்கூடிய சொத்தாக, நாம் உண்மையான புலத்தை மறுவரையறை செய்ய வேண்டும் ரேடியஸ் அல்லது செட்டருடன் மோதாத ஒன்று. இல்லையெனில் ஸ்டாக் வழிதல் பிழையை நாங்கள் சந்திக்கிறோம்.
இங்கே மறுவரையறை வகுப்பு:
class Circle {
constructor(radius) {
this._radius = radius
}
get area() { return Math.PI * this._radius * this._radius }
set radius(r) { this._radius = r }
}
var c = new Circle(4)
// returns: Circle {_radius: 4}
c.area
// returns: 50.26548245743669
c.radius = 6
c.area
// returns: 113.09733552923255
மொத்தத்தில், இது பொருள் சார்ந்த ஜாவாஸ்கிரிப்டுக்கு ஒரு நல்ல கூடுதலாகும்.
பரம்பரை
பயன்படுத்தி வகுப்புகளை வரையறுப்பதுடன் வர்க்கம் முக்கிய சொல், நீங்கள் இதைப் பயன்படுத்தலாம் நீட்டிக்கிறது சூப்பர் வகுப்புகளிலிருந்து பெற வேண்டிய முக்கிய சொல். ஒரு உதாரணத்துடன் இது எப்படி வேலை செய்கிறது என்று பார்ப்போம்.
class Ellipse {
constructor(width, height) {
this._width = width;
this._height = height;
}
get area() { return Math.PI * this._width * this._height; }
set width(w) { this._width = w; }
set height(h) { this._height = h; }
}
class Circle extends Ellipse {
constructor(radius) {
super(radius, radius);
}
set radius(r) { super.width = r; super.height = r; }
}
// create a circle
var c = new Circle(4)
// returns: Circle {_width: 4, _height: 4}
c.radius = 2
// c is now: Circle {_width: 2, _height: 2}
c.area
// returns: 12.566370614359172
c.radius = 5
c.area
// returns: 78.53981633974483
ஜாவாஸ்கிரிப்ட் ES6 இன் சில அம்சங்களுக்கு இது ஒரு சிறிய அறிமுகம்.
அடுத்தது: பழகுவது சில முக்கியமான ஜாவாஸ்கிரிப்ட் வரிசை முறைகள் மற்றும் ஒரு குரல் உணர்திறன் ரோபோ அனிமேஷன் ஸ்கிரிப்டிங்! மேலும், Vue என்று அழைக்கப்படும் ஒரு சிறந்த முன்-இறுதி கட்டமைப்பைப் பற்றி அறியவும்.
படக் கடன்: மைக்ரோலோஜியா/ வைப்புத்தொகைகள்
பகிர் பகிர் ட்வீட் மின்னஞ்சல் கேனான் எதிராக நிகான்: எந்த கேமரா பிராண்ட் சிறந்தது?கேனான் மற்றும் நிகான் கேமரா துறையில் இரண்டு பெரிய பெயர்கள். ஆனால் எந்த பிராண்ட் கேமராக்கள் மற்றும் லென்ஸ்களின் சிறந்த வரிசையை வழங்குகிறது?
உங்கள் பின்னணியாக ஒரு gif ஐ அமைப்பது எப்படிஅடுத்து படிக்கவும் தொடர்புடைய தலைப்புகள்
- நிரலாக்க
- ஜாவாஸ்கிரிப்ட்
எங்கள் செய்திமடலுக்கு குழுசேரவும்
தொழில்நுட்ப குறிப்புகள், மதிப்புரைகள், இலவச மின் புத்தகங்கள் மற்றும் பிரத்யேக ஒப்பந்தங்களுக்கு எங்கள் செய்திமடலில் சேரவும்!
குழுசேர இங்கே சொடுக்கவும்