जावास्क्रिप्ट गाइड भाग 8: ES6 सुविधाओं का अवलोकन

आज, जावास्क्रिप्ट मैनुअल के अनुवाद के आठवें भाग में, हम उस भाषा की विशेषताओं की समीक्षा करेंगे जो ES6 मानक के रिलीज के बाद उसमें दिखाई दी थी। एक तरह से या किसी अन्य, हम इनमें से कई अवसरों से पहले आ चुके हैं, कहीं न कहीं उन पर अधिक विस्तार से, कहीं न कहीं लेने के लिए। गाइड के इस खंड का इरादा कुछ विषयों के प्रकटीकरण के साथ है, जिसे हमने पहले नहीं छुआ है, आधुनिक जावास्क्रिप्ट के क्षेत्र में एक नौसिखिया डेवलपर के ज्ञान को कारगर बनाने के लिए।

→ भाग 1: पहला कार्यक्रम, भाषा सुविधाएँ, मानक
→ भाग 2: कोड शैली और कार्यक्रम संरचना
→ भाग 3: चर, डेटा प्रकार, भाव, वस्तु
→ भाग 4: सुविधाएँ
→ भाग 5: सरणियाँ और लूप
→ भाग 6: अपवाद, अर्धविराम, वाइल्डकार्ड शाब्दिक
→ भाग 7: सख्त मोड, यह कीवर्ड, घटनाओं, मॉड्यूल, गणितीय गणना
→ भाग 8: ES6 सुविधाओं का अवलोकन
→ भाग 9: ES7, ES8 और ES9 मानकों का अवलोकन

ES6 के बारे में

ES6 मानक, जो ES2015 या ECMAScript 2015 को कॉल करने के लिए अधिक सही होगा (ये इसके आधिकारिक नाम हैं, हालांकि हर कोई इसे ES6 कहता है), पिछले मानक - ES5.1 की रिलीज के 4 साल बाद दिखाई दिया। ES5.1 मानक में चले गए सब कुछ को विकसित करने में लगभग दस साल लग गए। आजकल, इस मानक में दिखाई देने वाली सभी चीजें जेएस डेवलपर के सामान्य उपकरण बन गए हैं। यह ध्यान दिया जाना चाहिए कि ईएस 6 ने भाषा में बड़े बदलाव किए (जबकि इसके पिछले संस्करणों के साथ पिछड़े संगतता को बनाए रखा है)। इन परिवर्तनों की भयावहता की सराहना करने के लिए, यह ध्यान दिया जा सकता है कि ES5 मानक का वर्णन करने वाले दस्तावेज़ का आकार लगभग 250 पृष्ठ है, और मानक ES6 का वर्णन एक ऐसे दस्तावेज़ में किया गया है जिसमें पहले से ही लगभग 600 पृष्ठ हैं।

ES2015 मानक के सबसे महत्वपूर्ण नवाचारों की सूची में निम्नलिखित शामिल हो सकते हैं:

• तीर कार्य
• वादा
• जनरेटर
• कीवर्ड let और const
• कक्षाएं
• मॉड्यूल
• साँचा साक्षर समर्थन
• डिफ़ॉल्ट फ़ंक्शन मापदंडों के लिए समर्थन
• फैला हुआ संचालक
• विनाशकारी असाइनमेंट
• वस्तु साहित्य को बढ़ाना
• for...of पाश की
• Map और Set डेटा संरचनाओं के लिए समर्थन

इन संभावनाओं पर विचार करें।

तीर कार्य

एरो फ़ंक्शंस ने जावास्क्रिप्ट कोड का रूप और अनुभव बदल दिया है। उपस्थिति के संदर्भ में, उनका उपयोग फ़ंक्शन घोषणाओं को कम और आसान बनाता है। यहाँ एक नियमित कार्य की घोषणा है।

 const foo = function foo() { //... } 

लेकिन लगभग समान (हालांकि उपरोक्त के समान पूरी तरह से नहीं) तीर फ़ंक्शन।

 const foo = () => { //... } 

यदि तीर फ़ंक्शन के शरीर में केवल एक पंक्ति होती है, जिसके परिणाम को इस फ़ंक्शन से वापस किया जाना चाहिए, तो इसे और भी छोटा लिखा जाता है।

 const foo = () => doSomething() 

यदि तीर फ़ंक्शन केवल एक पैरामीटर लेता है, तो आप इसे निम्नानुसार लिख सकते हैं।

 const foo = param => doSomething(param) 

यह ध्यान दिया जाना चाहिए कि तीर कार्यों के आगमन के साथ, सामान्य कार्य गायब नहीं हुए हैं, उन्हें अभी भी कोड में उपयोग किया जा सकता है, वे पहले की तरह ही काम करते हैं।

एरो फ़ंक्शंस में यह कीवर्ड सुविधाएँ

एरो फ़ंक्शंस का अपना मूल्य नहीं है, वे इसे निष्पादन के संदर्भ से विरासत में लेते हैं।

यह समस्या को ठीक करता है, जिसके लिए, नियमित कार्यों का उपयोग करते समय, var that = this जैसे निर्माण का उपयोग करना आवश्यक था var that = this संदर्भ को संरक्षित करने के लिए। हालांकि, जैसा कि मैनुअल के पिछले हिस्सों में दिखाया गया था, यह परिवर्तन तीर के कार्यों के साथ काम करने की सुविधाओं और उनके आवेदन के दायरे को गंभीरता से प्रभावित करता है।

वादा

वादे आपको "कॉलबैक नरक" नामक प्रसिद्ध समस्या से छुटकारा पाने की अनुमति देते हैं, हालांकि उनका उपयोग जटिल संरचनाओं के उपयोग का अर्थ है। इस समस्या को एस्इंक्स / वेट निर्माण के आगमन के साथ ES2017 मानक में हल किया गया था, जो वादों पर आधारित है।

जावास्क्रिप्ट डेवलपर्स ने ES2015 के मानक के सामने आने से पहले वादों का इस्तेमाल किया, इसके लिए विभिन्न पुस्तकालयों का उपयोग किया (उदाहरण के लिए - jQuery, q, deferred.js, स्वर)। यह इस तंत्र के महत्व और प्रासंगिकता को इंगित करता है। विभिन्न पुस्तकालय इसे विभिन्न तरीकों से लागू करते हैं, इस क्षेत्र में एक मानक के उद्भव को एक बहुत ही सकारात्मक तथ्य माना जा सकता है।
यहां कॉलबैक फ़ंक्शंस (कॉलबैक) का उपयोग करके कोड लिखा गया है।

 setTimeout(function() { console.log('I promised to run after 1s') setTimeout(function() {   console.log('I promised to run after 2s') }, 1000) }, 1000) 

वादों का उपयोग करते हुए, इसे निम्नानुसार फिर से लिखा जा सकता है।

 const wait = () => new Promise((resolve, reject) => { setTimeout(resolve, 1000) }) wait().then(() => { console.log('I promised to run after 1s') return wait() }) .then(() => console.log('I promised to run after 2s')) 

जनरेटर

जनरेटर विशेष कार्य हैं जो अपने स्वयं के निष्पादन को रोक सकते हैं और इसे फिर से शुरू कर सकते हैं। यह एक अन्य कोड को निष्पादित करने की अनुमति देता है जबकि जनरेटर निष्क्रिय है।

जनरेटर अपने आप ही यह तय करता है कि उसे निष्पादित करने के लिए, अपनी बारी के लिए एक और कोड, "प्रतीक्षा" करने की अनुमति देनी होगी। उसी समय, जनरेटर के पास ऑपरेशन के बाद अपने निष्पादन को जारी रखने का अवसर होता है, जिसके परिणाम की प्रतीक्षा है, पूरा हो गया है।

यह सब एक सरल कीवर्ड yield लिए किया जाता है। जब यह कीवर्ड जनरेटर में पाया जाता है, तो इसका निष्पादन रोक दिया जाता है।
एक जनरेटर में इस कीवर्ड के साथ कई पंक्तियाँ हो सकती हैं, जो कई बार अपने निष्पादन को रोक देता है। जनरेटर *function निर्माण का उपयोग करके घोषित किए जाते हैं। शब्द function से पहले इस तारांकन को C, C ++ और Go जैसी भाषाओं में उपयोग किए जाने वाले पॉइंटर डेरेफेरिंग ऑपरेटर की तरह कुछ के लिए नहीं लिया जाना चाहिए।

जनरेटर एक नए जावास्क्रिप्ट प्रोग्रामिंग प्रतिमान के आगमन को चिह्नित करते हैं। विशेष रूप से, वे जनरेटर और अन्य कोड के बीच दो-तरफ़ा डेटा विनिमय सक्षम करते हैं, और लंबे समय तक रहने वाले छोरों के निर्माण की अनुमति देते हैं जो प्रोग्राम को "लटका" नहीं करते हैं।

जनरेटर के संचालन की सुविधाओं को दर्शाने वाले एक उदाहरण पर विचार करें। यहाँ पर ही जनरेटर है।

 function *calculator(input) {   var doubleThat = 2 * (yield (input / 2))   var another = yield (doubleThat)   return (input * doubleThat * another) } 

इस कमांड के साथ हम इसे इनिशियलाइज़ करते हैं।

 const calc = calculator(10) 

फिर हम इसके पुनरावृत्ति की ओर मुड़ते हैं।

 calc.next() 

यह कमांड एक पुनरावृत्ति शुरू करता है, यह इस तरह की वस्तु को लौटाता है।

 { done: false value: 5 } 

यहाँ निम्नलिखित होता है। जनरेटर जनरेटर को दिए गए input मूल्य का उपयोग करके कोड एक फ़ंक्शन को निष्पादित करता है। जनरेटर कोड तब तक निष्पादित किया जाता है जब तक कि yield कीवर्ड नहीं मिलता है। इस बिंदु पर, यह 2 input को विभाजित करने का परिणाम देता है, जो कि input 10 , 5 नंबर देता है। हमें यह संख्या इट्रेटर के लिए धन्यवाद मिलती है, और इसके साथ, एक संकेत है कि जनरेटर अभी तक पूरा नहीं हुआ है (इट्रेटर द्वारा लौटाए गए ऑब्जेक्ट में done गुण false सेट है), अर्थात, फ़ंक्शन केवल निलंबित कर दिया गया है।
अगली बार जब इटरेटर कहा जाता है, तो हम जनरेटर को 7 नंबर पास करते हैं।

 calc.next(7) 

इसके जवाब में, पुनरावृत्तिकर्ता हमें अगली वस्तु लौटाता है।

 { done: false value: 14 } 

यहां, doubleThat मान की गणना करने के लिए 7 नंबर का उपयोग किया गया था।

पहली नज़र में, ऐसा लग सकता है कि input / 2 कोड कुछ फ़ंक्शन के तर्क की तरह है, लेकिन यह केवल पहली पुनरावृत्ति पर लौटाया गया मान है। यहां हम इस मान को छोड़ देते हैं और नए इनपुट मान 7 उपयोग करते हैं, इसे 2 गुणा करते हैं। उसके बाद, हम दूसरे yield कीवर्ड पर जाते हैं, परिणामस्वरूप, दूसरी पुनरावृत्ति में प्राप्त मूल्य 14 ।

अगले पुनरावृत्ति पर, जो अंतिम है, हम जनरेटर को 100 नंबर पास करते हैं।

 calc.next(100) 

जवाब में, हमें निम्नलिखित वस्तु मिलती है।

 { done: true value: 14000 } 

पुनरावृति पूरा हो गया है ( yield कीवर्ड अब जनरेटर में नहीं पाया जाता है), अभिव्यक्ति का मूल्यांकन करने का परिणाम (input * doubleThat * another) ऑब्जेक्ट में लौटाया गया है, वह है - 10 * 14 * 100 और पूरा होने का संकेत सूचक ( done: true )।

कीवर्ड दें और कास्ट करें

जावास्क्रिप्ट ने हमेशा चर घोषित करने के लिए var कीवर्ड का उपयोग किया है। इस तरह के चर में एक कार्यात्मक गुंजाइश होती है। let और const कीवर्ड, क्रमशः, आपको वैरिएबल और कॉन्स्टेंट घोषित करने की अनुमति देते हैं, जिनमें ब्लॉक स्कोप होता है।

इसका मतलब है कि, उदाहरण के लिए, एक लूप में let कीवर्ड का उपयोग करते हुए घोषित किया गया एक आइकॉन if ब्लॉक के अंदर, या घुंघराले ब्रेसिज़ द्वारा सीमित एक नियमित कोड ब्लॉक के अंदर, इस ब्लॉक से आगे नहीं जाएगा। var साथ घोषित चर को ऐसे ब्लॉकों में आयोजित नहीं किया जाता है, जो वे घोषित किए गए स्तर पर फ़ंक्शन में उपलब्ध होते हैं।

const कीवर्ड let तरह ही काम करता है, लेकिन इसके साथ, स्थिरांक जो अपरिवर्तनीय होते हैं, घोषित किए जाते हैं।

आधुनिक JS कोड में, var कीवर्ड का उपयोग शायद ही कभी किया जाता है। इसने let और const कीवर्ड को रास्ता दिया। उसी समय, जो असामान्य लग सकता है, const कीवर्ड का उपयोग आज बहुत व्यापक रूप से किया जाता है, जो आधुनिक प्रोग्रामिंग में संस्थाओं की प्रतिरक्षा के विचारों की लोकप्रियता को इंगित करता है।

कक्षाएं

यह पता चला कि जावास्क्रिप्ट प्रोटोटाइप विरासत मॉडल का उपयोग करने वाली एकमात्र अत्यंत व्यापक भाषा थी। प्रोग्रामर जेएस को उन भाषाओं से स्विच कर रहे हैं जो क्लास-आधारित विरासत तंत्र को लागू करते हैं, ऐसे वातावरण में असहज महसूस करते हैं। ES2015 मानक ने जावास्क्रिप्ट में वर्ग समर्थन पेश किया। यह अनिवार्य रूप से प्रोटोटाइप का उपयोग करते हुए जेएस आंतरिक तंत्र के आसपास "सिंटैक्टिक शुगर" है। हालांकि, यह प्रभावित करता है कि जेएस आवेदन कैसे लिखते हैं।

जावास्क्रिप्ट इनहेरिटेंस मैकेनिज्म अब अन्य ऑब्जेक्ट-ओरिएंटेड भाषाओं में समान तंत्र की तरह दिखता है।

 class Person { constructor(name) {   this.name = name } hello() {   return 'Hello, I am ' + this.name + '.' } } class Actor extends Person { hello() {   return super.hello() + ' I am an actor.' } } var tomCruise = new Actor('Tom Cruise') console.log(tomCruise.hello()) 

यह कार्यक्रम पाठ को Hello, I am Tom Cruise. I am an actor प्रदर्शित करता है Hello, I am Tom Cruise. I am an actor कंसोल Hello, I am Tom Cruise. I am an actor Hello, I am Tom Cruise. I am an actor ।
जेएस कक्षाओं में, उदाहरण चर घोषित नहीं किए जा सकते, उन्हें निर्माणकर्ताओं में आरंभीकृत किया जाना चाहिए।

वर्ग निर्माता

कक्षाओं में एक विशेष विधि, constructor होता है, जिसे तब कहा जाता है जब new कीवर्ड का उपयोग करके कक्षा का एक उदाहरण बनाया जाता है।

Super कीवर्ड सुपर

super कीवर्ड आपको मूल वर्ग को वंशज कक्षाओं से एक्सेस करने की अनुमति देता है।

Sett गेटर्स एंड सेटर्स

संपत्ति के लिए गेट्टर को निम्नानुसार सेट किया जा सकता है।

 class Person { get fullName() {   return `${this.firstName} ${this.lastName}` } } 

सेटर को नीचे दिखाया गया है।

 class Person { set age(years) {   this.theAge = years } } 

वे गेटर्स और सेटर के साथ काम करते हैं जैसे कि वे कार्य नहीं थे, लेकिन वस्तुओं के सामान्य गुण।

मॉड्यूल

ES2015 मानक से पहले, मॉड्यूल के साथ काम करने के लिए कई प्रतिस्पर्धी दृष्टिकोण थे। विशेष रूप से, हम RequJS और CommonJS प्रौद्योगिकियों के बारे में बात कर रहे हैं। इस स्थिति ने जेएस डेवलपर्स के समुदाय में असहमति पैदा की।

आजकल, ES2015 में मॉड्यूल के मानकीकरण के लिए धन्यवाद, स्थिति धीरे-धीरे सामान्य हो रही है।

▍ आयात मॉड्यूल

मॉड्यूल आयात के एक निर्माण का उपयोग करके import...from... यहाँ कुछ उदाहरण हैं।

 import * as something from 'mymodule' import React from 'react' import { React, Component } from 'react' import React as MyLibrary from 'react' 

Modules मॉड्यूल का निर्यात

मॉड्यूल के आंतरिक तंत्र बाहरी दुनिया से बंद हैं, लेकिन मॉड्यूल से आप वह सब कुछ निर्यात कर सकते हैं जो यह अन्य मॉड्यूल की पेशकश कर सकता है। यह export कीवर्ड का उपयोग करके किया जाता है।

 export var foo = 2 export function bar() { /* ... */ } 

Als खाका शाब्दिक

टेम्पलेट शाब्दिक जावास्क्रिप्ट में तार का वर्णन करने का एक नया तरीका है। यहाँ है कि यह कैसा दिखता है।

 const aString = `A string` 

इसके अलावा, टेम्पलेट शाब्दिक के सिंटैक्स का उपयोग करके आप स्ट्रिंग में अभिव्यक्तियों को एम्बेड कर सकते हैं और उन्हें प्रक्षेपित कर सकते हैं। यह फॉर्म ${a_variable} निर्माण का उपयोग करके किया जाता है। यहाँ इसके उपयोग का एक सरल उदाहरण है:

 const v = 'test' const str = `something ${v}` //something test 

यहां एक अधिक जटिल उदाहरण है, किसी भी भाव का मूल्यांकन करने और एक स्ट्रिंग में उनके परिणामों को प्रतिस्थापित करने की क्षमता का चित्रण।

 const str = `something ${1 + 2 + 3}` const str2 = `something ${foo() ? 'x' : 'y' }` 

टेम्पलेट शाब्दिकों के उपयोग के लिए धन्यवाद, मल्टी-लाइन स्ट्रिंग्स को घोषित करना बहुत आसान हो गया है।

 const str3 = `Hey this string is awesome!` 

ES2015 से पहले भाषा में उपलब्ध सुविधाओं का उपयोग करते समय मल्टी-लाइन स्ट्रिंग्स का वर्णन करने के लिए आपको जो करना था, उससे इसकी तुलना करें।

 var str = 'One\n' + 'Two\n' + 'Three' 

डिफ़ॉल्ट फ़ंक्शन पैरामीटर

अब फ़ंक्शंस डिफ़ॉल्ट रूप से उपयोग किए जाने वाले मापदंडों का समर्थन करते हैं - उस स्थिति में जब फ़ंक्शन को कॉल करते समय संबंधित तर्क उन्हें पास नहीं किए जाते हैं।

 const foo = function(index = 0, testing = true) { /* ... */ } foo() 

फैला हुआ संचालक

प्रसार ऑपरेटर (विस्तार ऑपरेटर) आपको सरणियों, वस्तुओं या तारों का "विस्तार" करने की अनुमति देता है। यह ऑपरेटर तीन डॉट्स ( ... ) जैसा दिखता है। पहले, इसे एक सरणी उदाहरण के साथ विचार करें।

 const a = [1, 2, 3] 

इस सरणी के आधार पर एक नई सरणी बनाने का तरीका यहां बताया गया है।

 const b = [...a, 4, 5, 6] 

यहां ऐरे की कॉपी कैसे बनाएं।

 const c = [...a] 

यह ऑपरेटर वस्तुओं के साथ भी काम करता है। उदाहरण के लिए, यहां किसी ऑब्जेक्ट को क्लोन करने के लिए इसका उपयोग कैसे किया जाए।

 const newObj = { ...oldObj } 

प्रसार ऑपरेटर को एक स्ट्रिंग पर लागू करना, आप इसे एक सरणी में बदल सकते हैं, जिनमें से प्रत्येक तत्व में इस स्ट्रिंग से एक वर्ण होता है।

 const hey = 'hey' const arrayized = [...hey] // ['h', 'e', 'y'] 

यह ऑपरेटर, इसके एप्लिकेशन के उपरोक्त वेरिएंट के अलावा, उन कार्यों को कॉल करने के लिए उपयोग करना सुविधाजनक है जो सामान्य तर्क की सूची की अपेक्षा करते हैं, इन तर्कों के साथ एक सरणी पास करते हैं।

 const f = (foo, bar) => {} const a = [1, 2] f(...a) 

पहले, यह f.apply(null, a) फॉर्म के निर्माण का उपयोग करके किया गया था, लेकिन इस तरह के कोड को लिखना अधिक कठिन है, और यह कम पठनीय है।

विनाशकारी असाइनमेंट

विनाशकारी असाइनमेंट तकनीक की अनुमति देता है, उदाहरण के लिए, एक वस्तु लेने के लिए, इसमें से कुछ मान निकालें और उन्हें नामित चर या स्थिरांक में डाल दें।

 const person = { firstName: 'Tom', lastName: 'Cruise', actor: true, age: 54, } const {firstName: name, age} = person 

यहाँ, firstName और age गुण वस्तु से प्राप्त होते हैं। एक ही नाम के साथ निरंतर घोषित की गई age संपत्ति को लिखा जाता है, और firstName संपत्ति, निष्कर्षण के बाद, निरंतर name ।

विनाशकारी असाइनमेंट सरणियों के साथ काम करने के लिए भी उपयुक्त है।

 const a = [1,2,3,4,5] const [first, second, , , fifth] = a 

first , second और fifth स्थिरांक को क्रमशः सरणी के पहले, दूसरे और पांचवें तत्व मिलते हैं।

वस्तु साहित्य को बढ़ाना

ES2015 ने ऑब्जेक्ट शाब्दिक का उपयोग करके वस्तुओं का वर्णन करने की क्षमता का विस्तार किया है।

Inc वस्तुओं में चर के समावेश का सरलीकरण

पहले, किसी वस्तु की संपत्ति को एक चर सौंपने के लिए, निम्नलिखित निर्माण का उपयोग करना आवश्यक था।

 const something = 'y' const x = { something: something } 

अब ऐसा ही किया जा सकता है।

 const something = 'y' const x = { something } 

Es प्रोटोटाइप

ऑब्जेक्ट का प्रोटोटाइप अब निम्नलिखित निर्माण का उपयोग करके सेट किया जा सकता है।

 const anObject = { y: 'y' } const x = { __proto__: anObject } 

Super कीवर्ड सुपर

super कीवर्ड का उपयोग करके, ऑब्जेक्ट प्रोटोटाइप ऑब्जेक्ट तक पहुंच सकते हैं। उदाहरण के लिए, उनके तरीकों को कॉल करने के लिए जिनके पास इन वस्तुओं के तरीकों के समान नाम हैं।

 const anObject = { y: 'y', test: () => 'zoo' } const x = { __proto__: anObject, test() {   return super.test() + 'x' } } x.test() //zoox 

▍ संपत्ति के नाम की गणना

ऑब्जेक्ट प्रॉपर्टी के चरण में कंप्यूटेड प्रॉपर्टी के नाम बने हैं।

 const x = { ['a' + '_' + 'b']: 'z' } x.a_b //z 

के लिए ... पाश की

2009 में, forEach() मानक में, forEach() लूप दिखाई दिए। यह एक उपयोगी डिजाइन है, जिसका नुकसान यह है कि इस तरह के चक्रों को बाधित करने के लिए बहुत असुविधाजनक है। लूप के for क्लासिक उन स्थितियों में जहां आपको लूप के निष्पादन को बाधित करने की आवश्यकता होती है, इसके सामान्य पूर्ण होने से पहले एक अधिक उपयुक्त विकल्प है।

ES2015 में चक्र के for...of एक for...of प्रकट हुआ है, जो एक तरफ, अपने संक्षिप्त सिंटैक्स और सुविधा forEach द्वारा प्रतिष्ठित है, और दूसरी ओर, यह चक्र से जल्दी बाहर निकलने की संभावना का समर्थन करता है।

यहाँ पाश उदाहरण के for...of एक जोड़े हैं।

 //    for (const v of ['a', 'b', 'c']) { console.log(v); } //           entries() for (const [i, v] of ['a', 'b', 'c'].entries()) { console.log(i, v); } 

मानचित्र और डेटा संरचनाएँ सेट करें

ES2015 ने Map और Set डेटा स्ट्रक्चर्स (साथ ही उनके "कमजोर" संस्करणों WeakMap और WeakSet , जिसके उपयोग से "कचरा कलेक्टर" के प्रदर्शन में सुधार होता है - जेएस इंजन में मेमोरी के प्रबंधन के लिए जिम्मेदार तंत्र)। ये बहुत लोकप्रिय डेटा संरचनाएं हैं, जो कि उनके आधिकारिक कार्यान्वयन की उपस्थिति से पहले, उपलब्ध भाषा टूल का उपयोग करके नकल की जानी थी।

परिणाम

आज हमने ES2015 मानक की विशेषताओं की समीक्षा की, जिन्होंने भाषा की वर्तमान स्थिति को बहुत प्रभावित किया है। हमारा अगला विषय ES2016, ES2017 और ES2018 मानकों की विशेषताएं होंगी।

प्रिय पाठकों! ईएस 6 मानक के कौन से नवाचार आपको सबसे उपयोगी लगते हैं?