Comment créer un retard dans l'Swift?

Au lieu de sommeil, qui permet de verrouiller votre programme si elle est appelée à partir de la thread de l'INTERFACE utilisateur, pensez à utiliser NSTimer ou une expédition de la minuterie.

Mais, si vous avez vraiment besoin d'un retard dans le thread actuel:

... {
    sleep(4)
}

Il utilise le sommeil fonction d'UNIX.

Comparaison entre les différentes approches en swift 3.0

1. Sommeil

Cette méthode ne permet pas d'avoir un retour d'appel. Mettre les codes directement après cette ligne pour être exécuté dans les 4 secondes. Il va cesser d'utilisateur à partir de l'itération avec des éléments de l'INTERFACE utilisateur, comme le bouton test jusqu'à ce que le temps est passé. Bien que le bouton est une sorte de gelée quand le sommeil se met en marche, d'autres éléments comme l'indicateur d'activité est toujours en rotation, sans le figer. Vous ne pouvez pas déclencher à nouveau cette action pendant le sommeil.

sleep(4)
print("done")//Do stuff here

2. D'expédition, d'Effectuer et de la Minuterie

Ces trois méthodes fonctionnent de la même façon, ils sont tous en cours d'exécution sur le thread d'arrière-plan avec des blagues, juste avec une syntaxe différente et des caractéristiques légèrement différentes.

De l'expédition est couramment utilisé pour exécuter quelque chose sur le thread d'arrière-plan. Il a la fonction de rappel dans le cadre de l'appel de la fonction

DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(4), execute: {
    print("done")
})

Effectuer est en fait une simplification de la minuterie. Il met en place un timer avec du retard, puis déclencher la fonction par sélecteur.

perform(#selector(callback), with: nil, afterDelay: 4.0)

func callback() {
    print("done")
}}

Et enfin, la minuterie fournit également la capacité de répéter le rappel, qui n'est pas utile dans ce cas

Timer.scheduledTimer(timeInterval: 4, target: self, selector: #selector(callback), userInfo: nil, repeats: false)


func callback() {
    print("done")
}}

Pour chacun de ces trois méthode, lorsque vous cliquez sur le bouton pour déclencher l'INTERFACE utilisateur ne gèlera pas, et vous êtes autorisé à cliquer dessus à nouveau. Si vous cliquez sur le bouton de nouveau, un autre chronomètre est mis en place et le rappel sera déclenché deux fois.

En conclusion

Aucun des quatre méthode fonctionne assez bon juste par eux-mêmes. sleep va désactiver l'interaction de l'utilisateur, de sorte que l'écran "gèle"(pas fait) et les résultats de la qualité de l'expérience utilisateur. Les trois autres méthodes seront pas de gel de l'écran, mais vous pouvez les déclencher plusieurs fois, et la plupart du temps, vous voulez attendre jusqu'à ce que vous obtenir le retour d'appel avant de permettre à un utilisateur d'appeler à nouveau.

Donc une meilleure conception sera en utilisant une des trois méthodes asynchrones avec écran de blocage. Lorsque l'utilisateur clique sur le bouton, de couvrir la totalité de l'écran avec certains translucide vue avec une filature de l'indicateur d'activité sur le dessus, en disant à l'utilisateur que le bouton est en cours de traitement. Ensuite, retirer de la vue et de l'indicateur dans la fonction de rappel, en disant à l'utilisateur que l'action est correctement géré, etc.

Vous pouvez également le faire avec Swift 3.

Exécuter la fonction après le délai comme si.

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")
        }

Dans Swift Xcode 4.2 et 10.1

Vous avez tout à fait le 4 façons de retard. De tous les option 1 est préférable d'appeler ou d'exécuter une fonction après un certain temps. De tous les sleep() est moins le cas en cours d'utilisation.

L'Option 1.

DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
    self.yourFuncHere()
}
//Your function here    
func yourFuncHere() {

}

L'Option 2.

perform(#selector(yourFuncHere2), with: nil, afterDelay: 5.0)

//Your function here  
@objc func yourFuncHere2() {
    print("this is...")
}

Option 3.

Timer.scheduledTimer(timeInterval: 5.0, target: self, selector: #selector(yourFuncHere3), userInfo: nil, repeats: false)

//Your function here  
@objc func yourFuncHere3() {

}

Option 4.

sleep(5)

DispatchQueue.global(qos: .background).async {
    sleep(4)
    print("Active after 4 sec, and doesn't block main")
    DispatchQueue.main.async{
        //do stuff in the main thread here
    }
}

Vous pouvez créer une extension pour utiliser la fonction de délai facilement (Syntaxe: Swift 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)
    }
}

Comment utiliser dans UIViewController

self.delay(0.1, closure: {
   //execute code
})

Si votre code est déjà en cours d'exécution dans un thread d'arrière-plan, mettre en pause le thread à l'aide de cette méthode de Fondation: Thread.sleep(forTimeInterval:)

Par exemple:

DispatchQueue.global(qos: .userInitiated).async {

    //Code is running in a background thread already so it is safe to sleep
    Thread.sleep(forTimeInterval: 4.0)
}

(Voir les autres réponses pour des suggestions lorsque votre code est en cours d'exécution sur le thread principal.)