जावास्क्रिप्ट गाइड भाग 9: ES7, ES8 और ES9 मानकों का अवलोकन

आज, जावास्क्रिप्ट मैनुअल के अनुवाद के नौवें भाग में, ES7, ES8 और ES9 मानकों के लिए भाषा में प्रकट होने वाली विशेषताओं का अवलोकन किया जाएगा।

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

ईएस 7 मानक

ES7 मानक, जिसे आधिकारिक शब्दावली के अनुसार, ES2016 कहा जाता है, 2016 की गर्मियों में जारी किया गया था। वह, ES6 की तुलना में, भाषा में लाया गया, ज्यादा नया नहीं है। विशेष रूप से, हम निम्नलिखित के बारे में बात कर रहे हैं:

• Array.prototype.includes() विधि।
• यययय ययय ययय ययययय।

▍ विधि Array.prototype.includes ()

सरणी में एक तत्व की उपस्थिति के लिए Array.prototype.includes() विधि को जांचने के लिए डिज़ाइन किया गया है। सरणी में वांछित खोजना, यह true , false । ES7 से पहले, indexOf() विधि का उपयोग उसी ऑपरेशन को करने के लिए किया गया था, जो रिटर्न करता है, यदि कोई तत्व पाया जाता है, तो पहला सूचकांक जिसके द्वारा यह सरणी में पाया जा सकता है। यदि indexOf() तत्व नहीं मिला, तो यह नंबर -1 लौटाता है।

जावास्क्रिप्ट प्रकार रूपांतरण नियमों के अनुसार, नंबर -1 true परिवर्तित हो जाता true । परिणामस्वरूप, indexOf() के संचालन के परिणामों की जांच करने के लिए indexOf() किसी को निम्नलिखित रूप के विशेष रूप से सुविधाजनक निर्माण का उपयोग नहीं करना चाहिए।

 if ([1,2].indexOf(3) === -1) { console.log('Not found') } 

यदि एक समान स्थिति में, यह मानकर कि indexOf() , एक तत्व को खोजने के बिना, false रिटर्न करता है, तो नीचे दिखाए गए जैसे कुछ का उपयोग करें, कोड सही ढंग से काम नहीं करेगा।

 if (![1,2].indexOf(3)) { // console.log('Not found') } 

इस मामले में, यह पता चला है कि निर्माण ![1,2].indexOf(3) false देता false ।

includes() विधि का उपयोग करते हुए, ऐसी तुलनाएं अधिक तार्किक लगती हैं।

 if (![1,2].includes(3)) { console.log('Not found') } 

इस स्थिति में, निर्माण [1,2].includes(3) false , यह मान एक ऑपरेटर है ! यह true जाता true और कंसोल को एक संदेश मिलता है जिसमें कहा गया है कि सरणी में आइटम नहीं मिला।

▍ घातांक संचालक

प्रतिपादक ऑपरेटर Math.pow() विधि के समान कार्य करता है, लेकिन लाइब्रेरी फ़ंक्शन की तुलना में इसका उपयोग करना अधिक सुविधाजनक है, क्योंकि यह भाषा का हिस्सा है।

 Math.pow(4, 2) == 4 ** 2 //true 

इस ऑपरेटर को जेएस के लिए एक सुखद जोड़ माना जा सकता है, जो कुछ गणना करने वाले अनुप्रयोगों में उपयोगी है। एक समान ऑपरेटर अन्य प्रोग्रामिंग भाषाओं में मौजूद है।

ईएस 8 मानक

ईएस 8 स्टैंडर्ड (ES2017) 2017 में जारी किया गया था। वह, ES7 की तरह, भाषा के लिए बहुत कुछ नहीं लाया। अर्थात्, हम निम्नलिखित विशेषताओं के बारे में बात कर रहे हैं:

• दी गई लंबाई में तार जोड़ना।
• विधि Object.values() ।
• विधि Object.entries() ।
• विधि Object.getOwnPropertyDescriptors() ।
• फ़ंक्शन मापदंडों में ट्रेलिंग कॉमा।
• अतुल्यकालिक कार्य।
• साझा मेमोरी और परमाणु संचालन के साथ काम करें।

.Adding लाइनें दी गई लंबाई के लिए

ES8 ने दो नई String ऑब्जेक्ट विधियाँ पेश कीं - padStart() और padEnd() ।

padStart() विधि वर्तमान रेखा को दूसरी पंक्ति से भरती है जब तक कि अंतिम पंक्ति वांछित लंबाई तक नहीं पहुंच जाती। लाइन (बाएं) की शुरुआत में भरना होता है। यहाँ इस विधि का उपयोग करने का तरीका बताया गया है।

 str.padStart(targetLength [, padString]) 

यहाँ str वर्तमान लाइन है, targetLength अंतिम लाइन की लंबाई है (यदि यह वर्तमान लाइन की लंबाई से कम है, तो यह रेखा बिना किसी बदलाव के वापस आ जाएगी), padString एक वैकल्पिक पैरामीटर है - वर्तमान लाइन को भरने के लिए उपयोग की जाने वाली लाइन। यदि padString निर्दिष्ट नहीं है, padString वर्तमान लाइन को निर्दिष्ट लंबाई तक padString करने के लिए एक अंतरिक्ष वर्ण का उपयोग किया जाता है।

padEnd() विधि padEnd() समान है, लेकिन लाइन दाईं ओर भरी गई है।

इन विधियों का उपयोग करने के उदाहरणों पर विचार करें।

 const str = 'test'.padStart(10) const str1 = 'test'.padEnd(10,'*') console.log(`'${str}'`) //'      test' console.log(`'${str1}'`) //'test******' 

यहां, परिणामी स्ट्रिंग की केवल वांछित लंबाई के साथ padStart() का उपयोग करते समय, मूल स्ट्रिंग की शुरुआत में रिक्त स्थान जोड़े गए थे। अंतिम पंक्ति की लंबाई और इसे भरने के लिए लाइन के साथ padEnd() का उपयोग करते padEnd() , मूल पंक्ति के अंत में * अक्षर जोड़े गए।

▍ विधि Object.values ​​()

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

यहाँ इसका उपयोग कैसे करना है।

 const person = { name: 'Fred', age: 87 } const personValues = Object.values(person) console.log(personValues) // ['Fred', 87] 

यह विधि सरणियों पर भी लागू होती है।

▍ विधि Object.entries ()

यह विधि एक सरणी देता है, जिसमें से प्रत्येक तत्व भी एक सरणी युक्त होता है, प्रारूप में [key, value] , ऑब्जेक्ट की अपनी गुणों की कुंजी और मान।

 const person = { name: 'Fred', age: 87 } const personValues = Object.entries(person) console.log(personValues) // [['name', 'Fred'], ['age', 87]] 

सरणियों में इस विधि को लागू करते समय, तत्वों के सूचकांकों को कुंजियों के रूप में प्रदर्शित किया जाता है, और संबंधित सूचकांकों पर सरणी में जो संग्रहीत किया जाता है उसे मूल्यों के रूप में प्रदर्शित किया जाता है।

▍ getOwnPropertyDescriptors () विधि

यह विधि ऑब्जेक्ट के सभी गुणों के बारे में जानकारी देती है। विशेषता सेट (विवरणकर्ता) ऑब्जेक्ट गुणों से जुड़े होते हैं। विशेष रूप से, हम निम्नलिखित विशेषताओं के बारे में बात कर रहे हैं:

• value - वस्तु की संपत्ति का मूल्य।
• writable - अगर संपत्ति को बदला जा सकता true तो यह true ।
• get - में संपत्ति के साथ जुड़ा हुआ एक गेटर फ़ंक्शन होता है, या, यदि ऐसा कोई फ़ंक्शन नहीं है, undefined ।
• set - इसमें संपत्ति या undefined लिए सेटर फ़ंक्शन होता है।
• configurable - यदि यह false - संपत्ति को हटाया नहीं जा सकता है, तो इसके गुणों को मूल्य के अलावा नहीं बदला जा सकता है।
• enumerable - यदि इस गुण में सत्य निहित है - enumerable है।

यहाँ इस विधि का उपयोग करने का तरीका बताया गया है।

 Object.getOwnPropertyDescriptors(obj) 

यह एक ऐसी वस्तु लेता है जिसकी संपत्ति की जानकारी आपको पता करने की आवश्यकता होती है, और इस जानकारी से युक्त एक वस्तु देता है।

 const person = { name: 'Fred', age: 87 } const propDescr = Object.getOwnPropertyDescriptors(person) console.log(propDescr) /* { name:  { value: 'Fred',    writable: true,    enumerable: true,    configurable: true }, age:  { value: 87,    writable: true,    enumerable: true,    configurable: true } } */ 

इस पद्धति की आवश्यकता क्यों है? तथ्य यह है कि यह आपको अन्य संपत्तियों, गेटर्स और सेटर्स के अलावा, वस्तुओं की छोटी प्रतियां बनाने की अनुमति देता है। ऑब्जेक्ट को कॉपी करने के लिए ES6 मानक में दिखाई देने वाली Object.assign() पद्धति का उपयोग करके ऐसा नहीं किया जा सकता है।

निम्न उदाहरण में एक सेटर के साथ एक ऑब्जेक्ट होता है जो प्रदर्शित करता है, console.log() का उपयोग करके, जो वे इसकी संबंधित संपत्ति को लिखने की कोशिश कर रहे हैं।

 const person1 = { set name(newName) {     console.log(newName) } } person1.name = 'x' // x 

आइए assign() विधि का उपयोग करके इस ऑब्जेक्ट को कॉपी करने का प्रयास करें।

 const person2 = {} Object.assign(person2, person1) person2.name = 'x' //     ,    

जैसा कि आप देख सकते हैं, यह दृष्टिकोण काम नहीं करता है। name संपत्ति, जो मूल ऑब्जेक्ट में सेटर थी, अब एक नियमित संपत्ति के रूप में दर्शायी जाती है।

अब हम Object.defineProperties() (यह ES5.1 में दिखाई दिया) और Object.getOwnPropertyDescriptors() का उपयोग करते हुए ऑब्जेक्ट को कॉपी करेंगे।

 const person3 = {} Object.defineProperties(person3, Object.getOwnPropertyDescriptors(person1)) person3.name = 'x' //x 

यहां, ऑब्जेक्ट की कॉपी में सेटर रहता है।

यह ध्यान दिया जाना चाहिए कि Object.assign() लिए विशिष्ट प्रतिबंध भी Object.create() को Object.create() के लिए Object.create() विधि की विशेषता है।

समारोह मापदंडों में ▍Completion कॉमा

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

 const doSomething = ( var1, var2, ) => { //... } doSomething( 'test1', 'test2', ) 

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

▍एसिन्क्रोनस फ़ंक्शंस

ES2017 मानक में async/await निर्माण दिखाई दिया है, जिसे भाषा के इस संस्करण का सबसे महत्वपूर्ण नवाचार माना जा सकता है।

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

जब ES2015 मानक में वादे दिखाई दिए, तो उन्हें अतुल्यकालिक कोड के साथ मौजूदा समस्याओं को हल करने के लिए डिज़ाइन किया गया था, जो उन्होंने किया था। लेकिन ES2015 और ES2017 मानकों को साझा करने वाले दो वर्षों में, यह स्पष्ट हो गया कि वादों को इन समस्याओं का अंतिम समाधान नहीं माना जा सकता है।

विशेष रूप से, वादे "कॉलबैक नरक" समस्या को हल करने के उद्देश्य से थे, लेकिन, इस समस्या को हल करने के बाद, उन्होंने स्वयं उस कोड की जटिलता के कारण अपना सर्वश्रेष्ठ पक्ष नहीं दिखाया जिसमें वे उपयोग किए जाते हैं। तथ्य की बात के रूप में, async/await निर्माण वादों की समस्या को हल करता है और अतुल्यकालिक कोड की प्रयोज्यता में सुधार करता है।

एक उदाहरण पर विचार करें।

 function doSomethingAsync() { return new Promise((resolve) => {     setTimeout(() => resolve('I did something'), 3000) }) } async function doSomething() { console.log(await doSomethingAsync()) } console.log('Before') doSomething() console.log('After') 

यह कोड निम्नलिखित को कंसोल में आउटपुट करेगा।

 Before After I did something 

जैसा कि आप देख सकते हैं, कॉल करने के बाद doSomething() प्रोग्राम चलता रहता है, Before , After कंसोल में प्रदर्शित होता है, और तीन सेकंड बीतने के बाद, I did something ।

सीरियल अतुल्यकालिक फ़ंक्शन कॉल

यदि आवश्यक हो, तो अतुल्यकालिक फ़ंक्शन कॉल की श्रृंखलाओं की तरह कुछ बना सकते हैं। इस तरह के डिजाइन केवल इसी तरह के वादों के आधार पर बेहतर पठनीयता से अलग होते हैं। इसे निम्नलिखित उदाहरण में देखा जा सकता है।

 function promiseToDoSomething() { return new Promise((resolve)=>{     setTimeout(() => resolve('I did something'), 10000) }) } async function watchOverSomeoneDoingSomething() { const something = await promiseToDoSomething() return something + ' and I watched' } async function watchOverSomeoneWatchingSomeoneDoingSomething() { const something = await watchOverSomeoneDoingSomething() return something + ' and I watched as well' } watchOverSomeoneWatchingSomeoneDoingSomething().then((res) => { console.log(res) // I did something and I watched and I watched as well }) 

Ed साझा मेमोरी और परमाणु संचालन

यहां हम SharedArrayBuffer ऑब्जेक्ट के बारे में बात कर रहे हैं, जो हमें साझा मेमोरी क्षेत्रों, और एटॉमिक्स ऑब्जेक्ट का वर्णन करने की अनुमति देता है, जिसमें स्थिर तरीकों के रूप में परमाणु संचालन का एक सेट होता है। इन वस्तुओं को प्रोग्रामर को देने वाली संभावनाओं के बारे में विवरण यहाँ पाया जा सकता है ।

ES9 मानक

ES9 (ES2018) इस सामग्री के प्रकाशन के समय मानक का नवीनतम संस्करण है। यहाँ इसकी मुख्य विशेषताएं हैं:

• वस्तुओं पर स्प्रेड और बाकी स्टेटमेंट लागू करें।
• अतुल्यकालिक Iterators।
• विधि Promise.prototype.finally() ।
• नियमित अभिव्यक्ति में वृद्धि।

वस्तुओं के प्रसार और बाकी संचालकों का of आवेदन

हम पहले से ही बाकी और प्रसार ऑपरेटरों के बारे में बात कर चुके हैं जो ईएस 6 में दिखाई देते हैं और इसका उपयोग सरणियों के साथ काम करने के लिए किया जा सकता है। दोनों ही तीन डॉट्स जैसे दिखते हैं। बाकी संचालक, एक सरणी को नष्ट करने के निम्नलिखित उदाहरण में, आपको अपने पहले और दूसरे तत्व को first और second , और बाकी सभी को लगातार others ।

 const numbers = [1, 2, 3, 4, 5] const [first, second, ...others] = numbers console.log(first) //1 console.log(second) //2 console.log(others) //[ 3, 4, 5 ] 

spread ऑपरेटर आपको उन कार्यों के लिए सरणियाँ देने की अनुमति देता है जो नियमित पैरामीटर सूचियों की अपेक्षा करते हैं।

 const numbers = [1, 2, 3, 4, 5] const sum = (a, b, c, d, e) => a + b + c + d + e const res = sum(...numbers) console.log(res) //15 

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

 const { first, second, ...others } = { first: 1, second: 2, third: 3, fourth: 4, fifth: 5 } console.log(first) //1 console.log(second) //2 console.log(others) //{ third: 3, fourth: 4, fifth: 5 } 

यहाँ मौजूदा विवरण का उपयोग मौजूदा वस्तु के आधार पर एक नई वस्तु बनाते समय किया जाता है। यह उदाहरण पिछले एक को जारी रखता है।

 const items = { first, second, ...others } console.log(items) //{ first: 1, second: 2, third: 3, fourth: 4, fifth: 5 } 

▍एसिन्क्रोनस पुनरावृत्तियों

निर्माण की नई for-await-of आपको उन अतुल्यकालिक कार्यों को कॉल करने की अनुमति देती है जो लूप में वादे वापस करते हैं। इस तरह के लूप अगले चरण पर जाने से पहले वादे के संकल्प का इंतजार करते हैं। यहाँ है कि यह कैसा दिखता है।

 for await (const line of readLines(filePath)) { console.log(line) } 

इसी समय, यह ध्यान दिया जाना चाहिए कि इस तरह के छोरों को अतुल्यकालिक कार्यों में उपयोग किया जाना चाहिए - उसी तरह जब async/await निर्माण के साथ काम कर रहा हो।

▍ Promise.prototype.finally () विधि

यदि वादा सफलतापूर्वक हल हो जाता है, तो अगला then() विधि कहा जाता है। यदि कुछ गलत होता है, तो catch() विधि कहा जाता है। finally() विधि आपको कुछ कोड को निष्पादित करने की अनुमति देती है, भले ही पहले क्या हुआ हो।

 fetch('file.json') .then(data => data.json()) .catch(error => console.error(error)) .finally(() => console.log('finished')) 

▍ नियमित अभिव्यक्ति में सुधार

नियमित अभिव्यक्तियों में पूर्वव्यापी रूप से स्ट्रिंग को जांचने की क्षमता होती है ?<= ( ?<= )। यह आपको लाइनों में कुछ निर्माणों की खोज करने की अनुमति देता है जिसके पहले कुछ अन्य निर्माण हैं।

पूर्व ?= चेकों का उपयोग करने की क्षमता ?= निर्माण ES2018 मानक से पहले जावास्क्रिप्ट में लागू किए गए नियमित अभिव्यक्तियों में मौजूद था। इस तरह की जांच आपको बताती है कि क्या एक और टुकड़ा एक रेखा के एक निश्चित टुकड़े का अनुसरण करता है।

 const r = /Roger(?= Waters)/ const res1 = r.test('Roger is my dog') const res2 = r.test('Roger is my dog and Roger Waters is a famous musician') console.log(res1) //false console.log(res2) //true 

निर्माण ?! विपरीत ऑपरेशन करता है - एक मैच केवल तभी मिलेगा जब कोई अन्य दी गई लाइन का पालन नहीं करता है।

 const r = /Roger(?! Waters)/g const res1 = r.test('Roger is my dog') const res2 = r.test('Roger is my dog and Roger Waters is a famous musician') console.log(res1) //true console.log(res2) //false 

पूर्वव्यापी सत्यापन में, जैसा कि पहले ही उल्लेख किया गया है, निर्माण ?<= उपयोग किया जाता है।

 const r = /(?<=Roger) Waters/ const res1 = r.test('Pink Waters is my dog') const res2 = r.test('Roger is my dog and Roger Waters is a famous musician') console.log(res1) //false console.log(res2) //true 

वर्णित एक के विपरीत ऑपरेशन निर्माण का उपयोग करके किया जा सकता है ?<! ।

 const r = /(?<!Roger) Waters/ const res1 = r.test('Pink Waters is my dog') const res2 = r.test('Roger is my dog and Roger Waters is a famous musician') console.log(res1) //true console.log(res2) //false 

यूनिकोड रेगेक्स एस्केप सीक्वेंस

नियमित अभिव्यक्तियों में, आप किसी भी अंक से मेल खाने वाले \d वर्ग का उपयोग कर सकते हैं, किसी भी व्हाट्सएप चरित्र से मेल खाने वाला \w वर्ग, किसी भी अल्फ़ान्यूमेरिक वर्ण से मेल खाने वाला वर्ग, और इसी तरह। विचाराधीन सुविधा उन कक्षाओं के सेट को विस्तारित करती है जो नियमित अभिव्यक्तियों में उपयोग किए जा सकते हैं, जिससे आप यूनिकोड अनुक्रमों के साथ काम कर सकते हैं। हम वर्ग \p{} और वर्ग \P{} के व्युत्क्रम के बारे में बात कर रहे हैं।

यूनिकोड में, प्रत्येक वर्ण में गुणों का एक समूह होता है। ये गुण समूह \p{} ब्रेसिज़ में इंगित किए गए हैं। उदाहरण के लिए, Script प्रॉपर्टी उन भाषाओं के परिवार को निर्धारित करती है जिसमें एक चरित्र होता है, ASCII गुण, तार्किक, ASCII वर्णों के लिए true होता true , और इसी तरह। उदाहरण के लिए, हमें पता चलेगा कि कुछ पंक्तियों में केवल ASCII अक्षर हैं।

 console.log(r.test('abc')) //true console.log(r.test('ABC@')) //true console.log(r.test('ABC')) //false 

ASCII_Hex_Digit संपत्ति केवल उन वर्णों के लिए true है जिनका उपयोग हेक्साडेसिमल संख्या लिखने के लिए किया जा सकता है।

 const r = /^\p{ASCII_Hex_Digit}+$/u console.log(r.test('0123456789ABCDEF')) //true console.log(r.test('H')) //false 

कई अन्य समान गुण हैं जो ऊपर वर्णित के रूप में उसी तरह उपयोग किए जाते हैं। इनमें Uppercase , Lowercase , White_Space , Alphabetic , Emoji ।

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

 const r = /^\p{Script=Greek}+$/u console.log(r.test('ελληνικά')) //true console.log(r.test('hey')) //false 

इन संपत्तियों पर विवरण यहां पाया जा सकता है ।

नामित समूह

ES2018 में कैद चरित्र समूहों को नाम दिए जा सकते हैं। यहाँ है कि यह कैसा दिखता है।

 const re = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/ const result = re.exec('2015-01-02') console.log(result) /* [ '2015-01-02', '2015', '01', '02', index: 0, input: '2015-01-02', groups: { year: '2015', month: '01', day: '02' } ] */ 

नामित समूहों के उपयोग के बिना, एक ही डेटा केवल सरणी तत्वों के रूप में उपलब्ध होगा।

 const re = /(\d{4})-(\d{2})-(\d{2})/ const result = re.exec('2015-01-02') console.log(result) /* [ '2015-01-02', '2015', '01', '02', index: 0, input: '2015-01-02', groups: undefined ] */ 

रेगेक्स फ्लैग एस

s फ्लैग का उपयोग करने से वर्ण में परिणाम होता है . (डॉट), दूसरों के बीच, न्यूलाइन वर्ण से मेल खाता है। इस ध्वज के बिना, एक अवधि किसी भी चरित्र को एक नई रेखा को छोड़कर मेल खाती है।

 console.log(/hi.welcome/.test('hi\nwelcome')) // false console.log(/hi.welcome/s.test('hi\nwelcome')) // true 

परिणाम

इस सामग्री के साथ, हम इस जावास्क्रिप्ट मैनुअल के अनुवाद का प्रकाशन पूरा कर रहे हैं। हमें उम्मीद है कि इन प्रकाशनों ने उन लोगों की मदद की जिन्होंने इस भाषा में प्रोग्रामिंग में अपना पहला कदम उठाने से पहले जावास्क्रिप्ट के साथ काम नहीं किया था।

प्रिय पाठकों! यदि आपने पहले जेएस में नहीं लिखा है और इस गाइड में इस भाषा में महारत हासिल की है, तो कृपया अपने इंप्रेशन साझा करें।