मैं अपने ऐप को एक निश्चित बिंदु पर रोकना चाहता हूं। दूसरे शब्दों में, मैं चाहता हूं कि मेरा ऐप कोड को निष्पादित करे, लेकिन फिर एक निश्चित बिंदु पर, 4 सेकंड के लिए रुकें, और फिर बाकी कोड के साथ जारी रखें। मैं यह कैसे कर सकता हूँ?
मैं स्विफ्ट का इस्तेमाल कर रहा हूं।
जवाबों:
एक नींद के बजाय, जो आपके प्रोग्राम को लॉक कर देगा यदि यूआई थ्रेड से कॉल किया जाता है, तो उपयोग करने NSTimerया प्रेषण टाइमर पर विचार करें ।
लेकिन, अगर आपको वास्तव में मौजूदा धागे में देरी की जरूरत है:
do {
sleep(4)
}यह sleepUNIX से फ़ंक्शन का उपयोग करता है ।
dispatch_afterब्लॉक का उपयोग करना ज्यादातर मामलों में बेहतर होता है sleep(time)क्योंकि जिस धागे पर नींद का प्रदर्शन किया जाता है वह अन्य काम करने से अवरुद्ध होता है। जब dispatch_afterउस थ्रेड का उपयोग किया जाता है जिस पर काम नहीं किया जाता है, तो यह अवरुद्ध नहीं होता है, इसलिए यह इस बीच अन्य काम कर सकता है।
यदि आप अपने एप्लिकेशन के मुख्य थ्रेड पर काम कर रहे हैं, तो sleep(time)आपके ऐप के उपयोगकर्ता अनुभव के लिए उपयोग करना बुरा है क्योंकि उस समय के दौरान UI अप्रतिसादी होता है।
थ्रेड को फ्रीज करने के बजाय कोड के एक ब्लॉक के निष्पादन के कार्यक्रम के बाद डिस्पैच करें:
let seconds = 4.0
DispatchQueue.main.asyncAfter(deadline: .now() + seconds) {
// Put your code which should be executed with a delay here
}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
}.now() + .seconds(4)त्रुटि देता है:expression type is ambiguous without more context
.now() + .seconds(5)इसे जोड़ने की आवश्यकता नहीं है.now() + 5
स्विफ्ट 3.0 में विभिन्न दृष्टिकोणों के बीच तुलना
1. नींद
इस विधि में कॉल बैक नहीं है। इस पंक्ति के 4 सेकंड में निष्पादित होने के बाद सीधे कोड रखें। यह उपयोगकर्ता को परीक्षण बटन जैसे UI तत्वों के साथ पुनरावृत्ति करने से रोक देगा जब तक कि समय समाप्त नहीं हो जाता। यद्यपि बटन सोते समय जम जाता है, लेकिन गतिविधि संकेतक जैसे अन्य तत्व अभी भी बिना ठंड के घूम रहे हैं। आप इस क्रिया को नींद के दौरान फिर से ट्रिगर नहीं कर सकते।
sleep(4)
print("done")//Do stuff here
2. डिस्पैच, प्रदर्शन और टाइमर
ये तीन तरीके समान रूप से काम करते हैं, ये सभी बैकग्राउंड थ्रेड पर कॉल बैक के साथ चल रहे हैं, बस अलग-अलग सिंटैक्स और थोड़े अलग फीचर्स के साथ।
डिस्पैच का उपयोग आमतौर पर बैकग्राउंड थ्रेड पर कुछ चलाने के लिए किया जाता है। यह फ़ंक्शन कॉल के भाग के रूप में कॉलबैक है
DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(4), execute: {
print("done")
})प्रदर्शन वास्तव में एक सरलीकृत टाइमर है। यह देरी के साथ एक टाइमर सेट करता है, और फिर चयनकर्ता द्वारा फ़ंक्शन को ट्रिगर करता है।
perform(#selector(callback), with: nil, afterDelay: 4.0)
func callback() {
print("done")
}}और अंत में, टाइमर कॉलबैक को दोहराने की क्षमता भी प्रदान करता है, जो इस मामले में उपयोगी नहीं है
Timer.scheduledTimer(timeInterval: 4, target: self, selector: #selector(callback), userInfo: nil, repeats: false)
func callback() {
print("done")
}}इन तीनों विधि के लिए, जब आप उन्हें ट्रिगर करने के लिए बटन पर क्लिक करते हैं, तो UI फ्रीज नहीं होगा और आपको फिर से उस पर क्लिक करने की अनुमति होगी। यदि आप फिर से बटन पर क्लिक करते हैं, तो एक और टाइमर सेट किया जाता है और कॉलबैक को दो बार ट्रिगर किया जाएगा।
निष्कर्ष के तौर पर
चार में से कोई भी विधि सिर्फ अपने आप से अच्छा काम नहीं करती है। sleepउपयोगकर्ता इंटरैक्शन को अक्षम कर देगा, इसलिए स्क्रीन " फ्रीज " (वास्तव में नहीं) और खराब उपयोगकर्ता अनुभव का परिणाम है। अन्य तीन विधियां स्क्रीन को फ्रीज नहीं करेंगी, लेकिन आप उन्हें कई बार ट्रिगर कर सकते हैं, और अधिकांश बार, आप तब तक इंतजार करना चाहते हैं जब तक आप उपयोगकर्ता को फिर से कॉल करने की अनुमति देने से पहले कॉल वापस नहीं ले लेते।
तो एक बेहतर डिजाइन स्क्रीन अवरोधन के साथ तीन async विधियों में से एक का उपयोग किया जाएगा। जब उपयोगकर्ता बटन पर क्लिक करता है, तो शीर्ष पर कताई गतिविधि संकेतक के साथ कुछ पारभासी दृश्य के साथ पूरी स्क्रीन को कवर करें, उपयोगकर्ता को यह बताते हुए कि बटन क्लिक को संभाला जा रहा है। फिर कॉल बैक फ़ंक्शन में दृश्य और संकेतक को हटा दें, उपयोगकर्ता को बता रहा है कि कार्रवाई ठीक से नियंत्रित की गई है, आदि।
@objcलिए कॉलबैक फ़ंक्शन के सामने जोड़ना होगा perform(...)। जैसे:@objc func callback() {
मैं पाले से सहमत हूं कि यहां प्रयोग dispatch_afterकरना एक अच्छा विकल्प है। लेकिन आपको शायद जीसीडी कॉल पसंद नहीं है क्योंकि वे लिखने के लिए काफी परेशान हैं । इसके बजाय आप इस सहायक को जोड़ सकते हैं :
public func delay(bySeconds seconds: Double, dispatchLevel: DispatchLevel = .main, closure: @escaping () -> Void) {
let dispatchTime = DispatchTime.now() + seconds
dispatchLevel.dispatchQueue.asyncAfter(deadline: dispatchTime, execute: closure)
}
public enum DispatchLevel {
case main, userInteractive, userInitiated, utility, background
var dispatchQueue: DispatchQueue {
switch self {
case .main: return DispatchQueue.main
case .userInteractive: return DispatchQueue.global(qos: .userInteractive)
case .userInitiated: return DispatchQueue.global(qos: .userInitiated)
case .utility: return DispatchQueue.global(qos: .utility)
case .background: return DispatchQueue.global(qos: .background)
}
}
}अब आप अपने कोड को इस तरह से बैकग्राउंड थ्रेड में देरी करते हैं :
delay(bySeconds: 1.5, dispatchLevel: .background) {
// delayed code that will run on background thread
}मुख्य धागे पर विलंब कोड भी सरल है:
delay(bySeconds: 1.5) {
// delayed code, by default run in main thread
}यदि आप एक ऐसी फ्रेमवर्क पसंद करते हैं जिसमें कुछ अधिक उपयोगी विशेषताएं हैं, तो हैंडवाइस लिफ्ट चेकआउट करें । आप इसे Carthage या Accio के माध्यम से अपनी परियोजना में जोड़ सकते हैं, फिर इसे ऊपर दिए गए उदाहरणों की तरह उपयोग कर सकते हैं:
import HandySwift
delay(by: .seconds(1.5)) {
// delayed code
}DispatchTimeSwift 2 में उपलब्ध नहीं होने से पहले टाइप रूपांतरण की आवश्यकता थी। यह let dispatchTime = dispatch_time(DISPATCH_TIME_NOW, Int64(seconds * Double(NSEC_PER_SEC)))पहले था ।
आप स्विफ्ट 3 के साथ भी ऐसा कर सकते हैं।
देरी के बाद फ़ंक्शन निष्पादित करें।
override func viewDidLoad() {
super.viewDidLoad()
self.perform(#selector(ClassName.performAction), with: nil, afterDelay: 2.0)
}
@objc func performAction() {
//This function will perform after 2 seconds
print("Delayed")
}स्विफ्ट 4.2 और एक्सकोड 10.1 में
आपके पास देरी करने के लिए कुल 4 तरीके हैं। इन विकल्पों में से 1 कुछ समय के बाद किसी फ़ंक्शन को कॉल या निष्पादित करने के लिए बेहतर है। नींद () प्रयोग में कम से कम मामला है।
विकल्प 1।
DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
self.yourFuncHere()
}
//Your function here
func yourFuncHere() {
}विकल्प 2।
perform(#selector(yourFuncHere2), with: nil, afterDelay: 5.0)
//Your function here
@objc func yourFuncHere2() {
print("this is...")
}विकल्प 3।
Timer.scheduledTimer(timeInterval: 5.0, target: self, selector: #selector(yourFuncHere3), userInfo: nil, repeats: false)
//Your function here
@objc func yourFuncHere3() {
}विकल्प 4।
sleep(5)यदि आप किसी कार्य को करने के लिए कुछ समय के बाद किसी फ़ंक्शन को कॉल करना चाहते हैं तो नींद का उपयोग न करें ।
@Nneonneo द्वारा उत्तर का उपयोग करने का सुझाव दिया, NSTimerलेकिन यह नहीं दिखाया कि यह कैसे करना है। यह मूल वाक्यविन्यास है:
let delay = 0.5 // time in seconds
NSTimer.scheduledTimerWithTimeInterval(delay, target: self, selector: #selector(myFunctionName), userInfo: nil, repeats: false)यहाँ यह दिखाने के लिए एक बहुत ही सरल परियोजना है कि इसका उपयोग कैसे किया जा सकता है। जब एक बटन दबाया जाता है तो यह एक टाइमर शुरू करता है जो आधे सेकंड की देरी के बाद फ़ंक्शन को कॉल करेगा।
import UIKit
class ViewController: UIViewController {
var timer = NSTimer()
let delay = 0.5
// start timer when button is tapped
@IBAction func startTimerButtonTapped(sender: UIButton) {
// cancel the timer in case the button is tapped multiple times
timer.invalidate()
// start the timer
timer = NSTimer.scheduledTimerWithTimeInterval(delay, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false)
}
// function to be called after the delay
func delayedAction() {
print("action has started")
}
}का उपयोग करना dispatch_time( पल्ले के जवाब में ) एक और वैध विकल्प है। हालांकि, इसे रद्द करना कठिन है । साथ NSTimer, एक देरी घटना को रद्द करने से पहले ऐसा होता है, तुम सब करने की जरूरत है कॉल है
timer.invalidate()उपयोग करने sleepकी अनुशंसा नहीं की जाती है, विशेष रूप से मुख्य धागे पर, क्योंकि यह धागे पर किए जा रहे सभी काम को रोक देता है।
मेरे फुलर जवाब के लिए यहां देखें ।
आप विलंब फ़ंक्शन को आसानी से उपयोग करने के लिए एक्सटेंशन बना सकते हैं (सिंटैक्स: स्विफ्ट 4.2+)
extension UIViewController {
func delay(_ delay:Double, closure:@escaping ()->()) {
DispatchQueue.main.asyncAfter(
deadline: DispatchTime.now() + Double(Int64(delay * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC), execute: closure)
}
}UIViewController में उपयोग कैसे करें
self.delay(0.1, closure: {
//execute code
})यदि आपका कोड पहले से ही बैकग्राउंड थ्रेड में चल रहा है, तो फाउंडेशन में इस विधि का उपयोग करके थ्रेड को रोकें :Thread.sleep(forTimeInterval:)
उदाहरण के लिए:
DispatchQueue.global(qos: .userInitiated).async {
// Code is running in a background thread already so it is safe to sleep
Thread.sleep(forTimeInterval: 4.0)
}(सुझाव के लिए अन्य उत्तर देखें जब आपका कोड मुख्य धागे पर चल रहा हो।)
एक सरल समय देरी बनाने के लिए, आप डार्विन को आयात कर सकते हैं और फिर देरी करने के लिए नींद (सेकंड) का उपयोग कर सकते हैं। हालांकि, केवल पूरे सेकंड लगते हैं, इसलिए अधिक सटीक माप के लिए आप डार्विन को आयात कर सकते हैं और बहुत सटीक माप के लिए usleep (सेकंड का मिलियन) का उपयोग कर सकते हैं। यह परीक्षण करने के लिए, मैंने लिखा:
import Darwin
print("This is one.")
sleep(1)
print("This is two.")
usleep(400000)
print("This is three.")कौन सा प्रिंट करता है, फिर 1 सेकंड और प्रिंट के लिए इंतजार करता है, फिर 0.4 सेकंड के लिए इंतजार करता है। सभी ने उम्मीद के मुताबिक काम किया।
यह सबसे सरल है
delay(0.3, closure: {
// put her any code you want to fire it with delay
button.removeFromSuperview()
})