स्विफ्ट 3 में देरी का कार्यक्रम कैसे करें

Question

स्विफ्ट के पुराने संस्करणों में, कोई निम्नलिखित कोड के साथ देरी पैदा कर सकता है:

let time = dispatch_time(dispatch_time_t(DISPATCH_TIME_NOW), 4 * Int64(NSEC_PER_SEC))
dispatch_after(time, dispatch_get_main_queue()) {
    //put your code which should be executed with a delay here
}

लेकिन अब, स्विफ्ट 3 में, Xcode स्वचालित रूप से 6 अलग-अलग चीजों को बदल देता है, लेकिन फिर निम्न त्रुटि दिखाई देती है: " DispatchTime.nowअपेक्षित मान dispatch_time_taka में परिवर्तित नहीं हो सकता है UInt64।"

स्विफ्ट 3 में कोड के अनुक्रम को चलाने से पहले कोई देरी कैसे कर सकता है?

Answer 1

काफी खोजबीन के बाद आखिरकार मैंने इसका पता लगा लिया।

DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { // Change `2.0` to the desired number of seconds.
   // Code you want to be delayed
}

यह स्विफ्ट 3 और स्विफ्ट 4 में वांछित "प्रतीक्षा" प्रभाव पैदा करता है।

इस उत्तर के एक भाग से प्रेरित ।

Comments

उपयोगी योगदान, धन्यवाद! सबसे हालिया स्विफ्ट 3 के लिए अद्यतन:DispatchQueue.main.asyncAfter(deadline: when)

— 16

आप अपने कोड को "+ .seconds (2)" के साथ "+ 2" के स्थान पर थोड़ा और स्वाइप कर सकते हैं। या, स्वायत्तता में अंतिम के लिए, आप पहली पंक्ति को छोड़ सकते हैं और "समय सीमा:" को "समय सीमा: (.now) (.seconds (2)" के साथ बदल सकते हैं।

— रेनीपेट

@ OctavioAntonioCedeño मदद करने के लिए खुश। यह वास्तव में मुझे थोड़ी देर के लिए

— खराब कर गया

अभी भी 3/12/2017 से काम कर रहा हूं। इसके लिए बहुत बहुत धन्यवाद :)

— जॉन लियोनार्डो

शाब्दिक रूप से SO पर मेरी सबसे ज्यादा देखी जाने वाली पोस्ट है। इस पोस्ट को वास्तव में याद रखना या इसे अपने कोड में कहीं और ढूंढना आसान है;)

— barrylachapelle

Answer 2

मुझे GCD के लिए वन-लाइन नोटेशन पसंद है, यह अधिक सुरुचिपूर्ण है:

    DispatchQueue.main.asyncAfter(deadline: .now() + 42.0) {
        // do stuff 42 seconds later
    }

इसके अलावा, iOS 10 में हमारे पास नई टाइमर विधियां हैं, उदाहरण के लिए ब्लॉक इनिशलाइज़र:

(इसलिए विलंबित कार्रवाई रद्द की जा सकती है)

    let timer = Timer.scheduledTimer(withTimeInterval: 42.0, repeats: false) { (timer) in
        // do stuff 42 seconds later
    }

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

RunLoop.current.add(timer, forMode: .common)

इस ब्लॉग पोस्ट पर आप अधिक जानकारी पा सकते हैं।

Comments

अच्छी पकड़! मैंने यह अभी तक नहीं देखा था।

— julien_c

टाइमर की तुलना के लिए एक प्लस और मुख्य रनअप के बारे में अस्वीकरण!

— मार्टिन

अच्छा पकड़ा! यह इंजीनियरिंग है।

— ओनूर Onहिन्दुर

Answer 3

स्विफ्ट 3.0 और इसके बाद के संस्करण में लागू निम्नलिखित फ़ंक्शन का प्रयास करें

func delayWithSeconds(_ seconds: Double, completion: @escaping () -> ()) {
    DispatchQueue.main.asyncAfter(deadline: .now() + seconds) { 
        completion()
    }
}

प्रयोग

delayWithSeconds(1) {
   //Do something
}

Comments

आपने मूल रूप से इस उत्तर की नकल की है लेकिन हां यह अच्छा है, धन्यवाद।

— उल्लू

इसे कैसे रद्द करें?

— सौरव चंद्र

Answer 4

देरी के लिए नीचे दिए गए कोड का प्रयास करें

//MARK: First Way

func delayForWork() {
    delay(3.0) {
        print("delay for 3.0 second")
    }
}

delayForWork()

---

// MARK: Second Way

DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
    // your code here delayed by 0.5 seconds
}

Comments

पहले तरीके से प्रदर्शित होने में त्रुटि है "अनसुलझे पहचानकर्ता का उपयोग 'देरी'"

— जेरी चोंग

यह प्रोग्रामर अपने कोड बेस में एक सहायक विधि के साथ काम कर रहा है और लंबे समय से है। इतनी देरी कोड था जिसे उसने कुछ समय के लिए इस्तेमाल किया था, यह जानने के लिए कि यह एप्पल के एसडीके के अलावा नहीं है।

— निक पर्किंस

Answer 5

एक तरीका यह है DispatchQueue.main.asyncAfterकि बहुत से लोगों ने उत्तर दिया है।

दूसरा तरीका उपयोग करना है perform(_:with:afterDelay:)। अधिक जानकारी यहाँ

perform(#selector(delayedFunc), with: nil, afterDelay: 3)

@IBAction func delayedFunc() {
    // implement code
}

Answer 6

// एक्स सेकंड के बाद फ़ंक्शन चलाता है

public static func runThisAfterDelay(seconds: Double, after: @escaping () -> Void) {
    runThisAfterDelay(seconds: seconds, queue: DispatchQueue.main, after: after)
}

public static func runThisAfterDelay(seconds: Double, queue: DispatchQueue, after: @escaping () -> Void) {
    let time = DispatchTime.now() + Double(Int64(seconds * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC)
    queue.asyncAfter(deadline: time, execute: after)
}

//उपयोग:-

runThisAfterDelay(seconds: x){
  //write your code here
}