¿Cómo escribo dispatch_after GCD en Swift 3 y 4?

En Swift 2, pude usar dispatch_after para retrasar una acción usando grand central dispatch:

 var dispatchTime: dispatch_time_t = dispatch_time(DISPATCH_TIME_NOW, Int64(0.1 * Double(NSEC_PER_SEC))) dispatch_after(dispatchTime, dispatch_get_main_queue(), { // your function here }) 

Pero esto ya no parece comstackrse en Swift 3 (o 4). ¿Cuál es la forma preferida de escribir esto en Swift 3 (utilizando la nueva API de despacho)?

La syntax es simple:

 // to run something in 0.1 seconds DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { // your code here } 

Tenga en cuenta que la syntax anterior de agregar seconds como un Double parece ser una fuente de confusión (especialmente porque estábamos acostumbrados a agregar nsec). Esa syntax de “agregar segundos como Double ” funciona porque el deadline es un tiempo de DispatchTime y, detrás de las escenas, hay un operador + que tomará un Double y agregará muchos segundos al tiempo de DispatchTime :

 public func +(time: DispatchTime, seconds: Double) -> DispatchTime 

Pero, si realmente desea agregar un número entero de msec, μs o nsec a DispatchTime , también puede agregar un DispatchTimeInterval a un DispatchTime . Eso significa que puedes hacer:

 DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(500)) { os_log("500 msec seconds later") } DispatchQueue.main.asyncAfter(deadline: .now() + .microseconds(1_000_000)) { os_log("1m μs seconds later") } DispatchQueue.main.asyncAfter(deadline: .now() + .nanoseconds(1_500_000_000)) { os_log("1.5b nsec seconds later") } 

Todo esto funciona sin problemas debido a este método de sobrecarga separado para el operador + en la clase DispatchTime .

 public func +(time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime 

Swift 4:

 DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(100)) { // Code } 

Para el tiempo .seconds(Int) , .microseconds(Int) and .nanoseconds(Int) también pueden ser utilizados.

Si solo quieres la función de retardo en

Swift 4

 func delay(delay: Double, closure: @escaping () -> ()) { DispatchQueue.main.asyncAfter(deadline: .now() + delay) { closure() } } 

Puedes usarlo como:

 delay(delay: 1) { print("Hi!") } 

después del lanzamiento de Swift 3, también se debe agregar el @escaping

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

Un sabor algo diferente de la Respuesta Aceptada.

Swift 4

 DispatchQueue.main.asyncAfter(deadline: .now() + 0.1 + .milliseconds(500) + .microseconds(500) + .nanoseconds(1000)) { print("Delayed by 0.1 second + 500 milliseconds + 500 microseconds + 1000 nanoseconds)") } 

llama a DispatchQueue.main.after(when: DispatchTime, execute: () -> Void)

Recomiendo encarecidamente utilizar las herramientas de Xcode para convertir a Swift 3 (Edición> Convertir> A syntax Swift actual). Me llamó la atención

Swift 4

Puede crear una extensión en DispatchQueue y agregar el retraso de la función que usa DispatchQueue asyncDespués de la función internamente

 extension DispatchQueue { static func delay(_ delay: DispatchTimeInterval, closure: @escaping () -> ()) { DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: closure) } } 

y use

 DispatchQueue.delay(.milliseconds(10)) { print("task to be done") } 

Esto funcionó para mí en Swift 3

 let time1 = 8.23 let time2 = 3.42 // Delay 2 seconds DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { print("Sum of times: \(time1 + time2)") } 

Puedes usar

 DispatchQueue.main.asyncAfter(deadline: .now() + .microseconds(100)) { // Code } 

prueba esto

 let when = DispatchTime.now() + 1.5 DispatchQueue.main.asyncAfter(deadline: when) { //some code } 

En Swift 4.1 y Xcode 9.4.1

La respuesta simple es …

 //To call function after 5 seconds time DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) { //Here call your function } 
    Intereting Posts