जावास्क्रिप्ट में प्रतीक डेटा प्रकार का उपयोग करने की विशेषताएं

चरित्र आदिम ES6 मानक के नवाचारों में से एक है, जो कुछ मूल्यवान सुविधाओं को जावास्क्रिप्ट में लाया है। प्रतीक डेटा प्रकार द्वारा दर्शाए गए प्रतीक विशेष रूप से तब उपयोगी होते हैं जब उन्हें ऑब्जेक्ट गुणों के लिए पहचानकर्ता के रूप में उपयोग किया जाता है। उनके आवेदन के ऐसे परिदृश्य के संबंध में, सवाल उठता है कि वे क्या कर सकते हैं, लाइनें क्या नहीं कर सकती हैं।



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

प्रारंभिक जानकारी

जावास्क्रिप्ट में, वास्तव में, दो प्रकार के मूल्य हैं। पहला प्रकार - आदिम मूल्य, दूसरा - ऑब्जेक्ट (उनमें फ़ंक्शन भी शामिल हैं)। आदिम मूल्यों में संख्याओं की तरह सरल डेटा प्रकार शामिल होते हैं (इसमें पूर्णांक से लेकर फ्लोटिंग-पॉइंट संख्या, Infinity और NaN मान तक), तार्किक मूल्य, तार, undefined और null मान शामिल हैं। ध्यान दें कि typeof null === 'object' जाँच करते समय typeof null === 'object' पैदावार true , null एक आदिम मूल्य है।

आदिम मूल्य अपरिवर्तनीय हैं। उन्हें बदला नहीं जा सकता। बेशक, आप एक चर में एक आदिम मूल्य को संग्रहीत करने के लिए कुछ नया लिख ​​सकते हैं। उदाहरण के लिए, यह चर x लिए एक नया मान लिखता है:

 let x = 1; x++; 

लेकिन एक ही समय में, आदिम संख्यात्मक मूल्य 1 का कोई परिवर्तन (उत्परिवर्तन) नहीं है।

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

निम्नलिखित उदाहरण पर विचार करें:

 function primitiveMutator(val) { val = val + 1; } let x = 1; primitiveMutator(x); console.log(x); // 1 function objectMutator(val) { val.prop = val.prop + 1; } let obj = { prop: 1 }; objectMutator(obj); console.log(obj.prop); // 2 

आदिम मूल्य (रहस्यमय NaN के अपवाद के साथ, जो खुद के बराबर नहीं है) हमेशा अन्य आदिम मूल्यों के बराबर होने के लिए बाहर निकलते हैं जो खुद की तरह दिखते हैं। उदाहरण के लिए:

 const first = "abc" + "def"; const second = "ab" + "cd" + "ef"; console.log(first === second); // true 

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

 const obj1 = { name: "Intrinsic" }; const obj2 = { name: "Intrinsic" }; console.log(obj1 === obj2); // false //     .name   : console.log(obj1.name === obj2.name); // true 

ऑब्जेक्ट्स जावास्क्रिप्ट में एक मौलिक भूमिका निभाते हैं। वे हर जगह शाब्दिक रूप से उपयोग किए जाते हैं। उदाहरण के लिए, वे अक्सर कुंजी / मूल्य संग्रह के रूप में उपयोग किए जाते हैं। लेकिन Symbol डेटा प्रकार के आगमन से पहले, केवल स्ट्रिंग को ऑब्जेक्ट कुंजी के रूप में इस्तेमाल किया जा सकता है। यह संग्रह के रूप में वस्तुओं के उपयोग पर एक गंभीर सीमा थी। जब एक गैर-स्ट्रिंग मान को ऑब्जेक्ट कुंजी के रूप में निर्दिष्ट करने का प्रयास किया जाता है, तो यह मान स्ट्रिंग में डाला जाता है। आप इसे इसके द्वारा सत्यापित कर सकते हैं:

 const obj = {}; obj.foo = 'foo'; obj['bar'] = 'bar'; obj[2] = 2; obj[{}] = 'someobj'; console.log(obj); // { '2': 2, foo: 'foo', bar: 'bar',    '[object Object]': 'someobj' } 

वैसे, हालांकि यह हमें पात्रों के विषय से थोड़ा दूर ले जाता है, मैं यह नोट करना चाहता हूं कि Map डेटा संरचना उन स्थितियों में कुंजी / मूल्य डेटा स्टोर के उपयोग की अनुमति देने के लिए बनाई गई थी जहां कुंजी एक स्ट्रिंग नहीं है।

प्रतीक क्या है?

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

 const s1 = Symbol(); const s2 = Symbol(); console.log(s1 === s2); // false 

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

 const s1 = Symbol('debug'); const str = 'debug'; const s2 = Symbol('xxyy'); console.log(s1 === str); // false console.log(s1 === s2); // false console.log(s1); // Symbol(debug) 

वस्तुओं की संपत्ति की कुंजी के रूप में प्रतीक

प्रतीकों का उपयोग वस्तुओं के लिए संपत्ति की कुंजी के रूप में किया जा सकता है। यह बहुत महत्वपूर्ण है। यहाँ उन्हें इस तरह से उपयोग करने का एक उदाहरण दिया गया है:

 const obj = {}; const sym = Symbol(); obj[sym] = 'foo'; obj.bar = 'bar'; console.log(obj); // { bar: 'bar' } console.log(sym in obj); // true console.log(obj[sym]); // foo console.log(Object.keys(obj)); // ['bar'] 

कृपया ध्यान दें कि Object.keys() विधि Object.keys() है जब वर्णों द्वारा निर्दिष्ट कुंजी वापस नहीं Object.keys() । जेएस में पात्रों की उपस्थिति से पहले लिखा गया कोड उनके बारे में कुछ भी नहीं जानता है, परिणामस्वरूप, पात्रों द्वारा प्रस्तुत वस्तुओं की कुंजी के बारे में जानकारी प्राचीन Object.keys() विधि द्वारा वापस नहीं की जानी चाहिए।

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

दुर्भाग्य से, वस्तुओं के साथ काम करने वाला कोड स्वतंत्र रूप से अपनी स्ट्रिंग कुंजी तक पहुंच सकता है। कोड वर्णों द्वारा निर्दिष्ट कुंजियों तक भी पहुंच सकता है, इसके अलावा, भले ही जिस कोड से वे ऑब्जेक्ट के साथ काम करते हैं, उसके अनुरूप चरित्र तक पहुंच नहीं है। उदाहरण के लिए, Reflect.ownKeys() विधि का उपयोग करके, आप किसी ऑब्जेक्ट की सभी कुंजियों की एक सूची प्राप्त कर सकते हैं, जो दोनों तार हैं और जो वर्ण हैं:

 function tryToAddPrivate(o) { o[Symbol('Pseudo Private')] = 42; } const obj = { prop: 'hello' }; tryToAddPrivate(obj); console.log(Reflect.ownKeys(obj));       // [ 'prop', Symbol(Pseudo Private) ] console.log(obj[Reflect.ownKeys(obj)[1]]); // 42 

ध्यान दें कि वर्तमान में निजी संपत्तियों का उपयोग करने की क्षमता के साथ सुसज्जित कक्षाओं के लिए काम चल रहा है। इस सुविधा को निजी क्षेत्र कहा जाता है। सच है, यह पूरी तरह से सभी वस्तुओं को प्रभावित नहीं करता है, केवल उन लोगों को संदर्भित करता है जो पहले से तैयार कक्षाओं के आधार पर बनाए जाते हैं। Chrome ब्राउज़र संस्करण 72 और पुराने में निजी क्षेत्रों के लिए समर्थन पहले से ही उपलब्ध है।

ऑब्जेक्ट प्रॉपर्टी के नामों की टक्करों को रोकें

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

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

 function lib1tag(obj) { obj.id = 42; } function lib2tag(obj) { obj.id = 369; } 

यदि हम अपने उदाहरण में प्रतीकों का उपयोग करते हैं, तो प्रत्येक पुस्तकालय आरंभ कर सकता है, आरंभिक प्रतीकों पर। फिर इन प्रतीकों का उपयोग वस्तुओं को गुण प्रदान करने और इन गुणों तक पहुंचने के लिए किया जा सकता है।

 const library1property = Symbol('lib1'); function lib1tag(obj) { obj[library1property] = 42; } const library2property = Symbol('lib2'); function lib2tag(obj) { obj[library2property] = 369; } 

यह इस तरह के परिदृश्य को देखकर है कि आप जावास्क्रिप्ट में पात्रों की उपस्थिति से लाभ उठा सकते हैं।

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

 const library1property = uuid(); //       function lib1tag(obj) { obj[library1property] = 42; } const library2property = 'LIB2-NAMESPACE-id'; //     function lib2tag(obj) { obj[library2property] = 369; } 

सामान्य तौर पर, आप ऐसा कर सकते हैं। इसी तरह के दृष्टिकोण, वास्तव में, प्रतीकों का उपयोग करते समय क्या होता है के समान हैं। और अगर, यादृच्छिक पहचानकर्ताओं या नामस्थानों का उपयोग करते हुए, पुस्तकालयों के एक जोड़े को, संयोग से, समान संपत्ति के नाम उत्पन्न नहीं होंगे, तो नामों के साथ कोई समस्या नहीं होगी।

एक कसौटी पाठक अब यह कहेंगे कि वस्तु के गुणों के नामकरण पर विचार करने वाले दो दृष्टिकोण पूरी तरह से समतुल्य नहीं हैं। संपत्ति के नाम जो बेतरतीब ढंग से उत्पन्न होते हैं या नेमस्पेस का उपयोग करते हैं, उनमें एक खामी है: संबंधित कुंजियों को खोजना बहुत आसान है, खासकर यदि कोड ऑब्जेक्ट्स की कुंजियों को खोजता है या उन्हें अनुक्रमित करता है। निम्नलिखित उदाहरण पर विचार करें:

 const library2property = 'LIB2-NAMESPACE-id'; //    function lib2tag(obj) { obj[library2property] = 369; } const user = { name: 'Thomas Hunter II', age: 32 }; lib2tag(user); JSON.stringify(user); // '{"name":"Thomas Hunter II","age":32,"LIB2-NAMESPACE-id":369}' 

यदि इस स्थिति में कुंजी नाम के लिए एक प्रतीक का उपयोग किया गया था, तो ऑब्जेक्ट के JSON प्रतिनिधित्व में प्रतीक मान नहीं होगा। ऐसा क्यों है? तथ्य यह है कि जावास्क्रिप्ट में एक नया डेटा प्रकार दिखाई देने का तथ्य यह नहीं है कि JSON विनिर्देशन में परिवर्तन किए गए हैं। JSON संपत्ति कुंजी के रूप में, केवल तार का समर्थन करता है। किसी वस्तु को क्रमबद्ध करते समय, वर्णों को किसी विशेष तरीके से दर्शाने का कोई प्रयास नहीं किया जाता है।

ऑब्जेक्ट्स के JSON प्रतिनिधित्व में संपत्ति के नाम प्राप्त करने की विचारशील समस्या को Object.defineProperty() का उपयोग करके हल किया जा सकता है:

 const library2property = uuid(); //   function lib2tag(obj) { Object.defineProperty(obj, library2property, {   enumerable: false,   value: 369 }); } const user = { name: 'Thomas Hunter II', age: 32 }; lib2tag(user); // '{"name":"Thomas Hunter II",  "age":32,"f468c902-26ed-4b2e-81d6-5775ae7eec5d":369}' console.log(JSON.stringify(user)); console.log(user[library2property]); // 369 

स्ट्रिंग कुंजियाँ, जो enumerable द्वारा enumerable गई कुंजियों के समान उनके व्यवहार को वर्णन करने के लिए false व्यवहार के द्वारा "छिपी" होती हैं। Object.keys() कॉल करने पर दोनों को प्रदर्शित नहीं किया जाता है, और Reflect.ownKeys() का उपयोग करके दोनों का पता लगाया जा सकता है। यहाँ यह कैसा दिखता है:

 const obj = {}; obj[Symbol()] = 1; Object.defineProperty(obj, 'foo', { enumberable: false, value: 2 }); console.log(Object.keys(obj)); // [] console.log(Reflect.ownKeys(obj)); // [ 'foo', Symbol() ] console.log(JSON.stringify(obj)); // {} 

यहाँ, मुझे कहना होगा, हमने जेएस के अन्य साधनों का उपयोग करते हुए, प्रतीकों की संभावनाओं को लगभग पुनर्निर्मित किया। विशेष रूप से, प्रतीकों और निजी कुंजियों द्वारा दर्शाई गई दोनों कुंजियाँ किसी वस्तु के JSON प्रतिनिधित्व में नहीं आती हैं। Reflect.ownKeys() विधि का संदर्भ देकर दोनों को पहचाना जा सकता है। परिणामस्वरूप, उन दोनों को वास्तव में निजी नहीं कहा जा सकता है। यदि हम मानते हैं कि कुछ यादृच्छिक मान या लाइब्रेरी नेमस्पेस का उपयोग प्रमुख नामों को उत्पन्न करने के लिए किया जाता है, तो इसका मतलब है कि हमें नाम टकराव के जोखिम से छुटकारा मिल गया।

हालांकि, प्रतीक नाम और अन्य तंत्रों का उपयोग करके बनाए गए नामों का उपयोग करने के बीच एक छोटा अंतर है। चूंकि तार अपरिवर्तनीय हैं, और वर्ण अद्वितीय होने की गारंटी है, हमेशा संभावना है कि कोई व्यक्ति, किसी स्ट्रिंग में वर्णों के सभी संभावित संयोजनों से गुजरने के बाद, नाम टकराव का कारण बनेगा। गणितीय दृष्टिकोण से, इसका मतलब यह है कि अक्षर वास्तव में हमें एक मूल्यवान अवसर देते हैं जो तार नहीं होते हैं।

Node.js में, ऑब्जेक्ट्स की जांच करते समय (उदाहरण के लिए, console.log() का उपयोग करके), यदि inspect नामक एक ऑब्जेक्ट विधि inspect पता लगाया inspect है, तो इस विधि का उपयोग ऑब्जेक्ट के स्ट्रिंग प्रतिनिधित्व को प्राप्त करने के लिए किया जाता है और फिर इसे स्क्रीन पर प्रदर्शित किया जाता है। यह समझना आसान है कि बिल्कुल हर कोई इसे ध्यान में नहीं रख सकता है, इसलिए सिस्टम के इस तरह के व्यवहार से inspect ऑब्जेक्ट विधि के लिए कॉल हो सकता है, जो उन समस्याओं को हल करने के लिए डिज़ाइन किया गया है जो ऑब्जेक्ट के स्ट्रिंग प्रतिनिधित्व के गठन से संबंधित नहीं हैं। इस सुविधा को Node.js 10 में पदावनत किया गया है, संस्करण 11 में एक समान नाम वाले तरीकों को केवल अनदेखा किया गया है। अब, इस सुविधा को लागू करने के लिए, require('util').inspect.custom की require('util').inspect.custom । इसका अर्थ है कि कोई भी कभी भी inspect नामक एक वस्तु विधि बनाकर अनजाने में सिस्टम को बाधित नहीं कर सकेगा।

निजी गुणों का अनुकरण

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

प्रॉक्सी ऑब्जेक्ट ऑब्जेक्ट पर किए गए कार्यों को इंटरसेप्ट करने के लिए कई तरीके प्रदान करते हैं। हम किसी वस्तु की रीडिंग कीज़ के संचालन को नियंत्रित करने की क्षमता में रुचि रखते हैं। हम यहां छद्म वस्तुओं के बारे में विवरण में नहीं जाएंगे। यदि आप रुचि रखते हैं, तो इस प्रकाशन पर एक नज़र डालें।

हम प्रॉक्सी का उपयोग यह नियंत्रित करने के लिए कर सकते हैं कि ऑब्जेक्ट के गुण बाहर से दिखाई देते हैं। इस मामले में, हम एक प्रॉक्सी बनाना चाहते हैं जो हमारे द्वारा ज्ञात दो गुणों को छिपाती है। एक में स्ट्रिंग का नाम _favColor , और दूसरे में favBook चर के लिए लिखे गए चरित्र का प्रतिनिधित्व किया गया है:

 let proxy; { const favBook = Symbol('fav book'); const obj = {   name: 'Thomas Hunter II',   age: 32,   _favColor: 'blue',   [favBook]: 'Metro 2033',   [Symbol('visible')]: 'foo' }; const handler = {   ownKeys: (target) => {     const reportedKeys = [];     const actualKeys = Reflect.ownKeys(target);     for (const key of actualKeys) {       if (key === favBook || key === '_favColor') {         continue;       }       reportedKeys.push(key);     }     return reportedKeys;   } }; proxy = new Proxy(obj, handler); } console.log(Object.keys(proxy)); // [ 'name', 'age' ] console.log(Reflect.ownKeys(proxy)); // [ 'name', 'age', Symbol(visible) ] console.log(Object.getOwnPropertyNames(proxy)); // [ 'name', 'age' ] console.log(Object.getOwnPropertySymbols(proxy)); // [Symbol(visible)] console.log(proxy._favColor); // 'blue 

एक ऐसी संपत्ति से संबंधित जिसका नाम स्ट्रिंग द्वारा दर्शाया गया है _favColor मुश्किल नहीं है: बस स्रोत कोड पढ़ें। डायनामिक कीज़ (जैसे uuid कीज़ जिन्हें हमने ऊपर देखा था) को ब्रूट फोर्स के साथ मैच किया जा सकता है। लेकिन प्रतीक के संदर्भ के बिना, आप proxy ऑब्जेक्ट से Metro 2033 के मूल्य तक नहीं पहुंच सकते।

यह ध्यान दिया जाना चाहिए कि Node.js में एक विशेषता है जो प्रॉक्सी ऑब्जेक्ट्स की गोपनीयता का उल्लंघन करती है। यह सुविधा भाषा में ही मौजूद नहीं है, इसलिए यह अन्य जेएस रनटाइम के लिए प्रासंगिक नहीं है, जैसे कि ब्राउज़र। तथ्य यह है कि यह सुविधा आपको प्रॉक्सी ऑब्जेक्ट के पीछे छिपी वस्तु तक पहुंचने की अनुमति देती है, यदि आपके पास प्रॉक्सी ऑब्जेक्ट तक पहुंच है। यहाँ एक उदाहरण दिया गया है जो पिछले कोड स्निपेट में दिखाए गए तंत्र को बायपास करने की क्षमता प्रदर्शित करता है:

 const [originalObject] = process .binding('util') .getProxyDetails(proxy); const allKeys = Reflect.ownKeys(originalObject); console.log(allKeys[3]); // Symbol(fav book) 

अब, Node.js के एक विशिष्ट उदाहरण में इस सुविधा के उपयोग को रोकने के लिए, आपको या तो वैश्विक Reflect ऑब्जेक्ट या उपयोग प्रक्रिया के बंधन को संशोधित करना होगा। हालाँकि, यह एक और काम है। यदि आप रुचि रखते हैं, तो जावास्क्रिप्ट-आधारित एपीआई की सुरक्षा के बारे में इस पोस्ट पर एक नज़र डालें।

परिणाम

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

प्रिय पाठकों! क्या आप अपने जावास्क्रिप्ट प्रोजेक्ट्स में प्रतीकों का उपयोग करते हैं?