🚵🏽 🛴 👌🏽 जावास्क्रिप्ट। अनुकूलन: समय-परीक्षणित अनुभव 🐡 👨🏼‍🌾 ⏱️

प्रस्तावना

मैं लंबे समय से लिखना चाहता हूं। विचार हैं, एक इच्छा है, कोई समय नहीं है ... लेकिन यहाँ यह था, इसलिए नमस्ते, हब्र।
यहां मैंने उन सभी विचारों को एकत्र किया है जो मदद की है और वेब अनुप्रयोगों के विकास में मदद कर रहे हैं। सुविधा के लिए, मैंने उन्हें समूहों में विभाजित किया:

स्मृति
संचालन अनुकूलन
महत्वपूर्ण क्षेत्रों पर प्रकाश डाला
लूप्स और ऑब्जेक्ट गुण
डोम के बारे में थोड़ा सा
एक मध्यवर्ती बफर के रूप में DocumentFragment
वस्तुओं के रूपांतरण के बारे में
कोड तोड़ना
घटनाओं को खींचें और छोड़ें
अन्य टिप्स

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

स्मृति

हालाँकि इससे ग्राहक प्रोग्रामर को चिंता नहीं होनी चाहिए, लेकिन हम यह नहीं भूलते कि स्मृति अनंत नहीं है और किसी दिन समाप्त हो सकती है, उदाहरण के लिए, जब कई बड़े पैमाने पर कार्यक्रम चल रहे हों: कार्यालय, ग्राफिक संपादक, एक बड़े कार्यक्रम का संकलन आदि, इसके बावजूद। उपरोक्त उदाहरण तुच्छ है, यह वास्तव में मेरे साथ हुआ, हालांकि ब्राउज़र के कारण नहीं, लेकिन इसने भी एक भूमिका निभाई: 1.3 जीबी रैम (डिबगर, लगभग 30 टैब), ब्रेक ने ओपी के पन्नों को पेज फ़ाइल में फिर से लोड करना शुरू कर दिया।
स्मृति की खपत को कम करने के लिए, मैं कई तरीके सुझाता हूं:

1) स्थानीय चर की संख्या में कमी।
आप पूछते हैं कि इसका क्या मतलब है? मैं समझाता हूं, मेरे अभ्यास में मैंने देखा कि कैसे "कोड बंदर" छात्रों ने एक समान कोड लिखा:

(function init(){ //      - for(var i=0,n=1;i<10;i++) //      n+=n; alert(n); //  for(var i=0,m=1;i<10;i++) m*=m; alert(m); })();

हो सकता है कि आप तुरंत यह न देखें कि चाल क्या है, लेकिन: यदि हम पुराने चर हैं जिनका उपयोग किया जाता है और पहले से ही पूरी तरह से अनावश्यक मान संग्रहीत करते हैं तो नए चर क्यों बनाएं? इस उदाहरण में, एक सामान्य समाधान के लिए, सभी मीटर को n के साथ बदलना आवश्यक है, जो मेमोरी को बचाएगा।
यह विधि पुनरावर्ती कार्यों में खुद को सबसे अच्छी तरह से प्रकट करती है, क्योंकि इस तरह के एक फ़ंक्शन के लिए प्रत्येक कॉल सृजन को उत्तेजित करता है और, ध्यान दें, फ़ंक्शन के खत्म होने के बाद स्थानीय चर को हटाने, जिसमें प्रोसेसर समय और मेमोरी की भी आवश्यकता होती है।
दृश्य धारणा के लिए, हम लॉकर के साथ एक सादृश्य दे सकते हैं: आपके पास 6 लॉकर हैं, जिनमें से तीन भरे जा सकते हैं; फिर आपको तीन और लॉकर की आवश्यकता क्यों है, अगर इस मामले में आपको सभी 6 को खोलना है, और फिर सभी 6 को बंद करना है?

2) शॉर्ट सर्किट की संख्या में कमी।
क्लोजर एक ध्यान देने योग्य स्मृति खपत (क्रोम के लिए प्रति 1000 एमबी 3 वस्तुएं, संभवतः नए संस्करणों में एक अलग राशि) का कारण बनता है, इसलिए उन्हें जितना संभव हो उतना कम उपयोग करें। मैं उन्हें दो मामलों में उपयोग करता हूं:

कुछ इंटरफ़ेस के अंदर डेटा छिपाना आवश्यक है, बाहर से एक्सेस नहीं देना;
पुनरावृत्ति के दौरान, जब आपको एक सामान्य वस्तु में कुछ नोट्स बनाने की आवश्यकता होती है (उदाहरण के लिए, जब HTML को ट्रैवर्स करते हैं, तो उन सभी नोड्स को रखें जिनके पास कस्टम संपत्ति "ड्रैगड्रॉप" सरणी में है) यदि चयनकर्ताओं द्वारा चयन उपयुक्त नहीं है।

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

 (function init(){ var INTERNAL_NUMBER=0;//  return { get:function get(){return INTERNAL_NUMBER;},//,     set:function set(value){ //,        if(typeof value==”number”) INTERNAL_NUMBER=value; return INTERNAL_NUMBER; } } })();

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

 (function init(){ var found=[]; (function traverse(html){ for(var i=html.firstChild;i;i=i.nextSibling) arguments.callee(i); if(typeof html.dragndrop==”object”) found.push(html); })(document.body); return found; })();

जैसा कि आप उदाहरण से देख सकते हैं, पुनरावर्ती फ़ंक्शन में तीन (html, i, पाया) के बजाय 2 स्थानीय चर (html, i) शामिल हैं। व्यवहार में, गति में लाभ महत्वपूर्ण नहीं है (कम से कम केवल एक चर के बंद होने से), लेकिन स्मृति में लाभ खुद को महसूस करता है।
और, कृपया, अगली निंदाई के लिए दोष न दें, और अगली परिसमापन के लिए नहीं, सब कुछ मुख्य रूप से एक पुनरावर्ती कार्य के अंदर बंद करने के सार को स्पष्ट करने के लिए किया गया था।
ध्यान: चक्र के माध्यम से कभी भी बंद न करें - यह अत्यधिक मेमोरी खपत का कारण बनता है। अपवाद ऐसे मामले हैं जहां स्क्रिप्ट तर्क के लिए बिना शर्त डेटा छिपाने की आवश्यकता होती है (लेकिन किसी भी मामले में, अगर मेरे पास डिबगर है, तो क्या मैं वहां पहुंचूंगा?)। क्लोजर के दुरुपयोग का एक उदाहरण:

 function addEvents2(divs) { for(var i=0; i<divs.length; i++) { divs[i].innerHTML = i divs[i].onclick = function(x) { return function() { alert(x) } }(i); } }

हाँ, हाँ। क्लोजर के बारे में इलिया कांटोर के एक लेख से यह एक ही उदाहरण है। बिंदु को स्पष्ट करने के लिए, हां, यह सामान्य है, लेकिन व्यावहारिक उपयोग के लिए यह बिल्कुल गलत है: कई कार्य बनाए जाते हैं, प्रत्येक अपने स्वयं के बंद होने के साथ। ठीक है, अगर कुछ। लेकिन अगर वहाँ हजारों हैं ... इस मामले में सबसे अच्छा तरीका यह है कि बिना संपत्ति के केवल एक फ़ंक्शन बनाएं और इस संपत्ति का उपयोग करें:

 function addEvents2(divs) { var f=function f(){alert(this.$i)}; for(var i=0; i<divs.length; i++) { divs[i].innerHTML = i; divs[i].$i=i; divs[i].onclick = f; } }

और मूल तत्व पर एक हैंडलर का उपयोग करना सबसे अच्छा है ( ईगोरमिन टिप्पणी)।

संचालन अनुकूलन

मैंने एक बार इस बारे में लिखा था, लेकिन मैं फिर से दोहराता हूं: प्रत्येक प्रकार के ऑपरेशन के लिए, सभी संभावित विकल्पों में से, सबसे तेज है, जो उपयोग करने के लिए बेहतर है।
हमारे पास एक चर v है, जिसकी सामग्री विचार के संदर्भ पर निर्भर करती है; एक चर k भी है जिसका एक ही अर्थ है।

आपरेशन	स्रोत कोड	टिप्पणी
बुलियन तक लाना	!! v	शायद यह सभी जानते हैं।
पूर्णांक तक कास्टिंग	वी -0	बस शून्य घटाओ
एक भिन्नात्मक संख्या में कमी	v-0.0	छोटा लेकिन जीतने वाला
स्ट्रिंग करने के लिए	v + "	एक रिक्त रेखा जोड़ें
वस्तु निर्माण	{}	नए ऑपरेटर का उपयोग करने की तुलना में वास्तव में तेज़। लाभ गुणों को निर्दिष्ट करने की क्षमता है
ऐरे सृजन	[]	एक सरणी भी एक वस्तु है, यही वजह है कि ऐसी रचना तेजी से होती है
तुलना	v === के	जबरदस्ती के बिना तुलना (यदि स्क्रिप्ट का तर्क इसकी अनुमति देता है)
वृद्धिशीलता के साथ वृद्धि / क्षय संचालन, असाइनमेंट संचालन	v + = 1; v / = 5;	यह अजीब लग सकता है, लेकिन यह सिर्फ एक ऐसी विधि है जो तेज़ है, और सभी ब्राउज़रों में है
संख्या द्वारा विभाजन / गुणा का संचालन, जो दो की शक्ति है (टिप्पणी Dzuba )	v << 2	संचालन को बिटवाइज़ शिफ्ट द्वारा प्रतिस्थापित किया जाता है। जीतना अन्य भाषाओं की भी विशेषता है।

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

महत्वपूर्ण क्षेत्रों पर प्रकाश डाला

मैं सैद्धांतिक रूप से यह अनुमान लगाने की सलाह दूंगा कि किसी दिए गए दायरे के लिए एक दिया गया भाग (उदाहरण के लिए, एक चक्र) कितना महत्वपूर्ण होगा, अर्थात्। जैसा कि इस खंड के लिए पुनरावृत्तियों की संख्या बढ़ जाती है, इसका निष्पादन समय भी रैखिक रूप से बढ़ जाएगा या निर्भरता पहले से ही एक शक्ति फ़ंक्शन के रूप में होगी, जहां डिग्री एकता से अधिक है। और किसी दिए गए अनुभाग में सभी संचालन को अनुकूलित करने के बाद, अनुभाग को एक पूरे के रूप में अनुकूलित करना आवश्यक है, उदाहरण के लिए, एक अतिरिक्त चर पेश करें जो मध्यवर्ती परिणाम को एक से अधिक बार उपयोग करेगा।
सीधे शब्दों में कहें, एक महत्वपूर्ण खंड कोड है जो प्रोसेसर सबसे लंबे समय तक काम करेगा, और यह पृष्ठ के लिए ध्यान देने योग्य है। उदाहरण के लिए, 100k संचालन जब प्रक्षेपित होता है, अगर आवेदन गणित के लिए होता है।
उप-वर्गों में मैं एक उदाहरण दूंगा और संकेत करूंगा कि सार क्या है।

लूप्स और ऑब्जेक्ट गुण

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

 var arr=[]; arr.length=100500; for(var i=0;i<arr.length;i++) …;//-

यहां आपको ऑब्जेक्ट कॉल की अवधारणा को पेश करने की आवश्यकता है - यह वर्तमान ऑब्जेक्ट की निर्दिष्ट संपत्ति या किसी भी चर के मूल्य को प्राप्त या सेट कर रहा है।
इस प्रकार, उपरोक्त उदाहरण में, लूप के एक पुनरावृत्ति (लूप के अंदर की क्रियाओं को छोड़कर) में, 4 ऑब्जेक्ट कॉल होते हैं (i, गिरफ्तारी हो रही है, arr.length प्राप्त कर रहा है, i)। सबसे अच्छे रिटर्न पास में, इन 4 कॉल को एक से बदल दिया जाता है:

 for(var i=arr.length;i--;) …;//-

यह ध्यान देने योग्य है कि पोस्ट-डेक्रिमेंट ऑपरेटर तुरंत एक मूल्य लौटाता है, जिसके परिणामस्वरूप मुझे फिर से एक्सेस करने की कोई आवश्यकता नहीं है।
छोरों के तर्क के लिए, लूप को जितनी जल्दी हो सके समाप्त करने का प्रयास करें: उदाहरण के लिए, सरणी में प्रत्येक वस्तु की सच्चाई की जांच है (अनुमान के अनुसार, हर किसी को सच होना चाहिए); जैसे ही आप पहले असत्य तत्व तक पहुंचते हैं, ब्रेक करें।

डोम के बारे में थोड़ा सा

गीतात्मक विषयांतर: इस लेख को लिखने से पहले, मैंने यह देखने के लिए जाँच की कि क्या कोई हैं। यह पता चला कि वहाँ है । मैं पढ़ने गया था, और, भगवान, मैंने वहां क्या देखा:

 document.getElementById('elem').propertyOne = 'value of first property'; document.getElementById('elem').propertyTwo = 'value of second property'; document.getElementById('elem').propertyThree = 'value of third property';

और अब नीचे की रेखा: कभी भी पहले से तय किए गए कार्यों को दोहराएं, खासकर अगर वे डोम से संबंधित हैं!
इस मामले में की गई कार्रवाई से, मैं पहचानकर्ता द्वारा तत्व की प्राप्ति को समझता हूं। दस्तावेज़ जितना बड़ा होता है, खोज धीमी होती है, और इस मामले में, खोज तीन बार की जाती है। सही निर्णय:

 var item=document.getElementById('elem'); item.propertyOne = 'value of first property'; item.propertyTwo = 'value of second property'; item.propertyThree = 'value of third property';

सबसे पहले, प्रदर्शन बढ़ाया जाता है, और दूसरी बात, कोड कम हो जाता है। एक ही डिजाइन को साइकिल से खराब किया जा सकता है:

 for(var i=arr.length,c;i--;){ c=arr[i]; … }

---

लूप का विषय विकसित करना: किसी नोड के उप-तत्वों को हटाने का सबसे तेज़ तरीका क्या है, यह जानते हुए कि ऑब्जेक्ट कॉल हैं? यह सही है, इस तरह:

 var z,node=document.body; while(z=node.lastChild) node.removeChild(z);

वास्तव में, यह कोड फ़ंक्शन के अंदर एक महत्वपूर्ण खंड होगा, जो डोम ऑब्जेक्ट्स को बड़ी संख्या में कॉल के कारण होता है।
यह ध्यान देने योग्य है कि DOM इंटरफेस की तुलना में DOM इंटरफेस दसियों गुना धीमे होते हैं। इसलिए, जब डोम संपत्तियों पर कॉल निष्पादित करने की बात आती है, तो ऐसी कॉल की संख्या कम से कम होनी चाहिए, खासकर अगर वे एक लूप में होती हैं। पिछले उदाहरण में, लूप में केवल 2 DOM कॉल हैं: to the lastChild property और removeChild function; z और नोड पर कॉल यहां लागू नहीं होती हैं, क्योंकि ये साधारण चर हैं। लेकिन शायद मैं गलत हूं।
इसके अलावा, प्रदर्शन खो जाता है, यदि पिछले मामले में, DOM ईवेंट हैंडलर को दस्तावेज़ में रखा गया था। उन्हें यथासंभव कम व्यवस्थित करने की कोशिश करें और उन्हें यथासंभव सरल बनाएं। कुछ मामलों में, उनका कोड महत्वपूर्ण हो सकता है।

एक मध्यवर्ती बफर के रूप में DocumentFragment

यदि आपको एक-एक करके कई उप-तत्वों को एक तत्व में सम्मिलित करने की आवश्यकता है, तो इसे सीधे करने के लिए जल्दी मत करो। आखिरकार, प्रत्येक प्रविष्टि के साथ, एक DOM ईवेंट उत्पन्न होगा। इस समस्या को हल करने के लिए, एक DocumentFragment है - एक मध्यवर्ती बफर जो आपको तत्वों को इकट्ठा करने और उन्हें एक ही समय में सही जगह ONE में सम्मिलित करने की अनुमति देता है, जो प्रदर्शन में काफी सुधार करता है। इसे सत्यापित करने के लिए, का उपयोग करके और DocumentFragment का उपयोग किए बिना 200 तालिका बनाएं। इस अनुभव के लिए इलिया कैंटर का विशेष धन्यवाद।
और ऑब्जेक्ट्स पर सभी ऑपरेशन (क्लास असाइनमेंट, गो, सेटिंग एट्रिब्यूट्स) डॉक्यूमेंटफ्रेगमेंट में भी किए जाते हैं। यह दृष्टिकोण दस्तावेज़ के अंदर पहले से ही घटनाओं की पीढ़ी की अनुमति नहीं देता है, जो लोड का कारण नहीं बनता है।

वस्तुओं के रूपांतरण के बारे में

JSON डेटा की बड़ी मात्रा में, eval धीरे-धीरे काम करता है, लेकिन चूंकि अपरिभाषित मूल्य और फ़ंक्शन JSON में शामिल नहीं हैं, इसलिए आप केवल eval का उपयोग करके ऐसी कोई वस्तु बना सकते हैं।
एक सच्चे JSON प्रारूप के लिए, JSON.parse का उपयोग करें। लेकिन बाद का नुकसान यह है कि इसे JSON विनिर्देशन के पूर्ण अनुपालन की आवश्यकता है: कुंजी के लिए दोहरे उद्धरण, कोई टिप्पणी नहीं (हालांकि उन्हें होना चाहिए)।

कोड तोड़ना

नीचे दिए गए पाठ को समझने के लिए, आपको जेएस कॉल स्टैक ( स्पमट नोट ) के बारे में जानना होगा: मोटे तौर पर बोलना, यह स्टैक है, जहां कॉल के क्रम में वर्तमान में निष्पादित सभी कार्यों को रखा जाता है। स्टैक पर पहला फ़ंक्शन डालना कई तरीकों से कहा जा सकता है: 1) वैश्विक निष्पादन क्षेत्र से कॉल करके; 2) टाइमर / टाइमआउट द्वारा फ़ंक्शन शुरू करें; 3) एक कस्टम इवेंट हैंडलर का निष्पादन। जब कोई फ़ंक्शन अपना काम पूरा करता है, तो उसे स्टैक से हटा दिया जाता है। यदि यह संसाधित नहीं हुआ था, तो इसके अंदर कोई त्रुटि होने पर इसे स्टैक से भी हटा दिया जाता है।

लेकिन क्या आप जानते हैं कि एक दस्तावेज़ को फिर से लिखना (उदाहरण के लिए, जब आपने किसी तत्व की कुछ शैलियों को बदल दिया था) केवल तब होता है जब कॉल स्टैक साफ़ हो जाता है? अब आप निश्चित रूप से जानते हैं। जावास्क्रिप्ट प्रकार के निर्माण की अनुमति नहीं देता है (2000); प्रदर्शन का त्याग किए बिना समान फ़ंक्शन के कोड को जारी रखना। इसलिए, कोड को अलग-अलग कार्यों में विभाजित किया जाता है जो तत्वों को नियंत्रित करते हैं। सलाह यह है कि कार्यों में कोड के इस तरह के टूटने के साथ, विभिन्न कार्यों में लोड को समान रूप से वितरित करने का प्रयास करें। आखिरकार, यह पता चल सकता है कि एक फ़ंक्शन दस्तावेज़ के अधिकांश तत्वों की लगभग सभी शैलियों को बदल देता है, दूसरा एक जटिल गणितीय समस्या की गणना करता है, और शेष लगभग कुछ भी नहीं करता है, जिसके परिणामस्वरूप पृष्ठ "लटका" होता है।
निष्पादन अंतराल सेट करके एकरूपता प्राप्त की जा सकती है। प्रभावों के लिए, फ़ंक्शंस के लॉन्च के बीच अंतराल जितना लंबा होगा, दस्तावेज को फिर से तैयार करने और प्रोसेसर पर कम लोड होने में अधिक समय लगेगा। लेकिन अगर अंतराल बहुत लंबा है, तो "चिकोटी प्रभाव" ध्यान देने योग्य होगा। इष्टतम अंतराल 20ms है। ओपेरा (1 एमएस) और आईई (15 एमएस) को छोड़कर न्यूनतम अंतराल 4 एमएस है। यदि आप अंतराल को 0 पर सेट करते हैं, तब भी वास्तविक फ़ंक्शन कॉल न्यूनतम अंतराल के बाद भी होगा।

घटनाओं को खींचें और छोड़ें

ऐसे आयोजन महत्वपूर्ण होते हैं, क्योंकि ड्रैग का पता चलते ही उन्हें हर समय बुलाया जाता है। लोड को कम करने के लिए, टाइमआउट फ़ंक्शन के साथ एक क्लोजर ( ईगोरमिन टिप्पणी) का उपयोग करके उन्हें बदलना बेहतर है ...

 (function init(){//    ,        . //   var MODE_MOUSE_MOVE=true; var move_listener=function move_listener (evnt){ if(!MODE_MOUSE_MOVE) return; ev=evnt||window.event;//for IE8 timeout=setTimeout(move_handler,10); }, ev=null, move_handler=function move_handler(){ timeout=0; MODE_MOUSE_MOVE=true; if(typeof document.$onmousemove=="function") document.$onmousemove(ev); }, timeout=0; document.onmousemove=move_listener; })();

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

अन्य टिप्स

आवरण कार्यों का उपयोग करने का प्रयास करें: वे कोड में मॉड्यूलरिटी जोड़ते हैं और एक मॉड्यूल के स्थानीय चर को दूसरे मॉड्यूल के स्थानीय चर से अलग करते हैं। यह पहले से ही घोषित चर का उपयोग करने की संभावना को कम करता है जिसमें पहले से ही एक भूमिका है।
सिद्धांत रूप में, सब कुछ कहा जाता है। शायद केवल, न केवल कोड का अनुकूलन करें, बल्कि इसकी पठनीयता भी। गैर-अस्पष्ट स्रोतों में, कार्यों के नाम और उनके मापदंडों को तार्किक बनाते हैं, प्रकार के साथ उपसर्ग (s एक स्ट्रिंग है, n एक संख्या है, आदि)। मैं ऐसा करता हूं, और एक साल बाद भी कोड समझा जाता है।

अंतभाषण

मुझे खुशी है कि आपने यह लेख पढ़ा। मुझे उम्मीद है कि आपने प्रस्तुति और पहुंच के मामले में इसका आनंद लिया। यह बुरा हो सकता है कि लोकप्रिय पुस्तकालयों के साथ काम करने के कोई उदाहरण नहीं हैं, लेकिन मुझे लगता है कि आपको पुस्तकालयों के बिना जेएस का उपयोग करने में सक्षम होने की आवश्यकता है, खासकर यदि आप एक ग्राहक डेवलपर हैं।

हो सकता है कि अधिकांश युक्तियां आपके लिए पहले ही "वध" बन गई हों, लेकिन मुझे लगता है कि आप अभी भी यहां से कुछ उपयोगी लाए हैं। आपका धन्यवाद

UPD 1. टिप्पणियों में दिए गए सुझावों को देखते हुए, मैं सभी कमियों को ठीक करता हूं

जावास्क्रिप्ट। अनुकूलन: समय-परीक्षणित अनुभव