अनुकूलन

अनुकूलन

> लीकस्क्रिप्ट ट्यूटोरियल

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

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

यदि आपने पहले से ऐसा नहीं किया है, तो मैं आपको लीकस्क्रिप्ट ट्यूटोरियल लेख पढ़ने के लिए आमंत्रित करता हूं: ऑपरेशंस।

अच्छा सजगता

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

उदाहरण के लिए, केवल एक बार बुलाए जाने वाले फ़ंक्शन पर 500 ऑपरेशंस को सहेजना केवल 500 ऑपरेशंस को बचाएगा। (तर्क) दूसरी ओर, लूप के लूप के लूप में कहे जाने वाले फ़ंक्शन पर एकल ऑपरेशन की बचत कई दसियों हज़ार ऑपरेशनों के संचालन में लागत को कम कर सकती है।

जो मुझे दूसरे बिंदु पर लाता है:

• पहचानें कि यह कहाँ महंगा है!

एक कोड को अनुकूलित करने का आधा काम केवल यह देखना है कि संचालन कहाँ समाप्त होता है (फिर आपको जोर से चिल्लाना होगा और उन्हें वापस आने के लिए कहना होगा)। कोड में महंगा क्या है?

उसके लिए, कोई रहस्य नहीं, हम नापेंगे!

हमारे शस्त्रागार में, लीकस्क्रिप्ट एक फ़ंक्शन प्रदान करता है जो बहुत उपयोगी साबित होगा: getOperations। यह फ़ंक्शन कोड में अब तक किए गए संचालन की संख्या जानने की अनुमति देता है।

किसी फ़ंक्शन की लागत को मापने के लिए एक सरल उपकरण का उदाहरण:

वैश्विक __डीबग_ऑपरेशन; फ़ंक्शन स्टार्टऑप () { __debug_operation = getOperations (); } फ़ंक्शन स्टॉपऑप (शीर्षक) { चलो ऑप्स = getOperations()-__debug_operation - 3; डिबग ("संचालन (" + शीर्षक + "):" + ऑप्स); }

स्टार्टऑप (); स्टॉपऑप ("खाली परीक्षण"); // खाली परीक्षण: 0

स्टार्टऑप (); कहो ("हैलो वर्ल्ड"); स्टॉपऑप ("हैलो वर्ल्ड"); // हैलो वर्ल्ड: 30

हम इस प्रकार पुष्टि कर सकते हैं कि प्रलेखन द्वारा घोषित लागत 30 संचालन है।

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

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

उन लूपों को हटाना जो नहीं बदलेंगे

निम्नलिखित कोड की कल्पना करो:

चलो टीपी = getTP ();

// दुश्मन पर जितनी बार संभव हो गोली मारो! for (var i = 0; i <floor(TP / getWeaponCost(getWeapon())); i++) { हथियार का उपयोग करें (getNearestEnemy ()); }

getNearestEnemy फ़ंक्शन लूप के प्रत्येक पुनरावृत्ति पर कॉल किया जाएगा जबकि यह हमेशा एक ही परिणाम लौटाएगा! इससे बचने के लिए, परिणाम को फ़ंक्शन से पहले एक चर में रखें। हम मंजिल (टीपी / getWeaponCost (getWeapon ())) के लिए वही काम करते हैं जिसका मूल्यांकन प्रत्येक पुनरावृत्ति पर भी किया जाता है। जो देता है:

चलो टीपी = getTP ();

// दुश्मन पर जितनी बार संभव हो गोली मारो! var दुश्मन = getNearestEnemy (); वर nbShots = मंजिल (टीपी / getWeaponCost (getWeapon ())); // वर्तमान हथियार के साथ संभावित शॉट्स की संख्या के लिए (var i = 0; i <nbShots; i++) { हथियार (दुश्मन) का उपयोग करें; }

लीक वार्स फीचर जो महंगे हैं

inArray, inArray व्यावहारिक है, यह वही करता है जो हम चाहते हैं, लेकिन इसमें संचालन में एक महत्वपूर्ण लागत शामिल होती है जिसे हम पहली नज़र में जरूरी नहीं देखते हैं। वास्तव में, इसके अंदर ऐसा दिखता है:

फ़ंक्शन इनएरे (तत्व, सरणी) { के लिए (सरणी में var मान) अगर (मान == आइटम) वापसी सच; विवरण झूठा है; }

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