स्विफ्ट खेल का मैदान निष्पादन गति

Question

क्या खेल के मैदान की निष्पादन गति बढ़ाने का कोई तरीका है? मैं कई चक्रों को फिर से शुरू करना चाहता हूं और 10 मिनट का इंतजार नहीं करना चाहता हूं।

उदाहरण के लिए:

import UIKit 

var count = 0 
for var i = 0; i < 1000000000; i++ { 
    count++ 
} 

इस कोड को बहुत लंबा एक तरह से अमल होगा। लेकिन मैं त्वरित परिणाम प्राप्त करना चाहता हूं।

Answer 1

मुझे तुम्हारा दर्द महसूस होता है, मैं [Double] पर 2 डी कार्यों को प्रिंट करने के साथ खेल रहा था और फिर UIImageView में परिवर्तित हो रहा था। कदमों में से एक लाखों पिक्सेल से अधिक था, और यह हमेशा के लिए लिया गया।

कंप्यूटेशनल गहन, या दोहराव, या संभावित रूप से समय लेने वाला कुछ भी खेल के मैदान के "स्रोत" फ़ोल्डर में रखा जाना चाहिए। इस तरह आपके खेल का मैदान चलाने से पहले कोड प्रीकंपल किया गया है। उस सार्वजनिक फ़ंक्शन में for लूप का आउटपुट रखें जिसे आप खेल के मैदान से कॉल कर सकते हैं। तो आपको for लूप के माध्यम से हर बार खेल के मैदान की गिनती देखने के लिए वहां बैठना नहीं होगा।

Answer 2

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

नोट: खुली कक्षाओं का उपयोग करना न भूलें।

Answer 3

सबसे बड़ा प्रदर्शन हत्यारा खेल मैदान के दाहिने तरफ आउटपुट है। अब मैं आपको दिखाऊंगा कि इस आउटपुट को कम करने के लिए कैसे।

अपने उदाहरण कोड के अंत में देखें।

---

सर्वश्रेष्ठ प्रदर्शन के

सबसे शक्तिशाली तरीका खेल के मैदान में Sources फ़ोल्डर के अंदर एक .swift फ़ाइल में सभी प्रदर्शन महत्वपूर्ण कोड बनाने के लिए है।

नोट: आदेश Sources फ़ोल्डर आप उन्हें public चिह्नित करने के लिए है से काम करता है, कक्षाएं, गुण और तरीकों का उपयोग करने के लिए। यदि आप किसी वर्ग को उप-वर्ग करना चाहते हैं तो उसे open चिह्नित करना होगा।

---

अच्छा प्रदर्शन लेकिन बदसूरत कोड

निम्न विधि (मुझे लगता है कि इस अधिकारी/इरादा नहीं है) उत्पादन खेल का मैदान निष्क्रिय करने के लिए इस्तेमाल किया जा सकता, लेकिन यह भी बदसूरत कोड होता है। हालांकि यह अस्थायी अक्षम करने के लिए अच्छा है।

दो मुख्य तरीकों से (और दो चाल) (यदि आप एक बेहतर तरीका हमें पता है मिल जाए ) उत्पादन की न्यूनतम राशि प्राप्त करने के लिए कर रहे हैं:

1. कोष्ठक उपयोग Void (या Void?) के आसपास असाइनमेंट जैसे अभिव्यक्ति (आमतौर पर कोई आउटपुट नहीं होता है, यह भी देखें 3.)।

   var x = 0  // output: 0 
   (x = 1)   // NO output 
   (x = 2 * x - 1) // NO output 
   (x.negate()) // NO output 
   

   नोट: स्विफ्ट में एक काम Void वापस आती है और optional chaining के मामले में यह Void? है।

   var x: (Int, Int)? = nil 
   if (x?.0 = 0) != nil { 
       // assignment was successful (x!=0 and now x=(0, x.1)) 
   } else { 
       // assignment was not successful (x==nil) 
   } 
   

2. वैरिएबल को अलग-अलग शुरू करें और घोषित करें।

   var x: Int // NO output 
   (x = 0) // NO output 
   

3. 1. ऊपर या () नीचे एक अतिरिक्त कोई सेशन (कोई आपरेशन) पंक्ति जोड़ने काम नहीं करता है।

   यह एकल लाइन बंद होने में क्या होता है (और शायद कुछ अन्य संदर्भों में) उदाहरण के लिए:

   [1, 4, 5, 6].mmap{ 
       () // without this line the line below would yield to an output 
       ($1 = $0 + 1) 
   } as [Int] 
   

4. इसके बजाय कोष्टक में हर पंक्ति लपेटकर के (नीचे भी कोड देखें) तुम भी की एक टपल उपयोग कर सकते हैं सभी भाव जो फिर एक चर को असाइन किया गया:

   var a: Any // this may be a useful definition in this context 
   var x: Int 
   var y: Int 
   (a = (x = 0, 
        y = 1, 
        x = y + 1, 
        y = x*x)) 
   

   हालांकि यह एक खरोज आपदा का कारण बन सकता ...

जहां यह काम नहीं करता है (मुझे आउटपुट को हटाने का कोई तरीका नहीं मिला है; इस सूची में शायद पूरा नहीं है): कार्यों में

1. return रों और संवृति
Optional चर के
2. घोषणा जैसे: var x: Int?

---

Sequence

पर एक नया map विधि का एक उदाहरण

उपयोग: प्वाइंट पर ऊपर देखें 3.

Sequence.map के हस्ताक्षर है

func map<T>(_ transform: (Self.Element) throws -> T) rethrows -> [T] 

जब से मैं एक तरह से कैसे return रों के उत्पादन में दूर करने के लिए एक एक inout तर्क के साथ एक बंद उपयोग कर सकते हैं (एक काम के साथ "वापसी" मूल्य प्राप्त) नहीं मिला है । एक संभावित हस्ताक्षर तो हो सकता है:

func mmap<U>(_ transform: (Element, inout U?) ->()) -> [U] 

तो हम inout बहस में nil पारित कर सकते हैं, क्योंकि यह U पर एक बाधा लगाने के बिना हर संभव U के लिए एक अच्छा डिफ़ॉल्ट जो एक उदाहरण जनरेटर की आवश्यकता हो सकती है (जैसे: init() { ... }) ।

दुर्भाग्य से स्विफ्ट को U का अनुमान लगाने में कठिन समय है, इसलिए आपको स्पष्ट प्रकार की टिप्पणियों के साथ कंपाइलर की सहायता करने की आवश्यकता होगी। इसके अलावा var newElement: U?साइडबार मेंnil लौटाता है।कोष्ठक के बिना

extension Sequence { 
    // ATTENTION: this is not as performant as the normal `map`! 
    func mmap<U>(transform: (Element, inout Any) ->()) -> [U] { 
     var result: [U] 
     (result = [U]()) 
     for element in self { 
      var newElement: Any 
      (newElement = 0) // some placeholder element 
      (transform(element, &newElement)) 
      // assume the inout element to be of type `U` 
      (result.append(newElement as! U)) 
     } 
     return result // the ONLY output in this method 
    } 
} 

---

आपका उदाहरण कोड

स्विफ्ट 4

var count = 0 
for i in 0..<1_000_000_000 { 
    (count += 1) 
    if count % 100_000 == 0 { 
     // print only every 100_000th loop iteration 
     print(count) 
    } 
} 

का उपयोग करना::

अब मैं Any बजाय U? का उपयोग करेगा प्रति सेकंड 10.000 के बारे में पाश पुनरावृत्तियों

ब्रांड्स के साथ: प्रति सेकंड लगभग 10.000.000 पाश पुनरावृत्तियों !!!