j'ai essayé

var timer = NSTimer()
timer(timeInterval: 0.01, target: self, selector: update, userInfo: nil, repeats: false)

Mais j'ai une erreur en disant

'(timeInterval: $T1, target: ViewController, selector: () -> (), userInfo: NilType, repeats: Bool) -> $T6' is not identical to 'NSTimer'

Cela fonctionnera:

override func viewDidLoad() {
    super.viewDidLoad()
    // Swift block syntax (iOS 10+)
    let timer = Timer(timeInterval: 0.4, repeats: true) { _ in print("Done!") }
    // Swift >=3 selector syntax
    let timer = Timer.scheduledTimer(timeInterval: 0.4, target: self, selector: #selector(self.update), userInfo: nil, repeats: true)
    // Swift 2.2 selector syntax
    let timer = NSTimer.scheduledTimerWithTimeInterval(0.4, target: self, selector: #selector(MyClass.update), userInfo: nil, repeats: true)
    // Swift <2.2 selector syntax
    let timer = NSTimer.scheduledTimerWithTimeInterval(0.4, target: self, selector: "update", userInfo: nil, repeats: true)
}

// must be internal or public. 
@objc func update() {
    // Something cool
}

Pour Swift 4, la méthode dont vous voulez obtenir le sélecteur doit être exposée à Objective-C, donc l' @objcattribut doit être ajouté à la déclaration de méthode.

Événement répété

Vous pouvez utiliser une minuterie pour effectuer une action plusieurs fois, comme illustré dans l'exemple suivant. Le minuteur appelle une méthode pour mettre à jour une étiquette toutes les demi-secondes.

Voici le code pour cela:

import UIKit

class ViewController: UIViewController {

    var counter = 0
    var timer = Timer()

    @IBOutlet weak var label: UILabel!

    // start timer
    @IBAction func startTimerButtonTapped(sender: UIButton) {
        timer.invalidate() // just in case this button is tapped multiple times

        // start the timer
        timer = Timer.scheduledTimer(timeInterval: 0.5, target: self, selector: #selector(timerAction), userInfo: nil, repeats: true)
    }

    // stop timer
    @IBAction func cancelTimerButtonTapped(sender: UIButton) {
        timer.invalidate()
    }

    // called every time interval from the timer
    func timerAction() {
        counter += 1
        label.text = "\(counter)"
    }
}

Événement retardé

Vous pouvez également utiliser une minuterie pour planifier un événement unique pendant un certain temps dans le futur. La principale différence avec l'exemple ci-dessus est que vous utilisez repeats: falseau lieu de true.

timer = Timer.scheduledTimer(timeInterval: 2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false)

L'exemple ci-dessus appelle une méthode nommée delayedActiondeux secondes après le réglage du temporisateur. Il n'est pas répété, mais vous pouvez toujours appeler timer.invalidate()si vous devez annuler l'événement avant qu'il ne se produise.

Remarques

• S'il y a une chance de démarrer plusieurs fois votre instance de minuteur, assurez-vous d'invalider d'abord l'ancienne instance de minuteur. Sinon, vous perdez la référence à la minuterie et vous ne pouvez plus l'arrêter. (voir cette Q&R )
• N'utilisez pas de minuteries lorsqu'elles ne sont pas nécessaires. Consultez la section des minuteries du Guide d'efficacité énergétique pour les applications iOS .

en relation

• Comment travailler avec les dates et l'heure dans Swift

Mise à jour vers Swift 4, exploitant userInfo:

class TimerSample {

    var timer: Timer?

    func startTimer() {
        timer = Timer.scheduledTimer(timeInterval: 5.0,
                                     target: self,
                                     selector: #selector(eventWith(timer:)),
                                     userInfo: [ "foo" : "bar" ],
                                     repeats: true)
    }

    // Timer expects @objc selector
    @objc func eventWith(timer: Timer!) {
        let info = timer.userInfo as Any
        print(info)
    }

}

Depuis iOS 10, il existe également une nouvelle méthode d'usine de minuterie basée sur des blocs qui est plus propre que l'utilisation du sélecteur:

    _ = Timer.scheduledTimer(withTimeInterval: 5, repeats: false) { timer in
        label.isHidden = true
    }

Swift 3, pré iOS 10

func schedule() {
    DispatchQueue.main.async {
      self.timer = Timer.scheduledTimer(timeInterval: 20, target: self,
                                   selector: #selector(self.timerDidFire(timer:)), userInfo: nil, repeats: false)
    }
  }

  @objc private func timerDidFire(timer: Timer) {
    print(timer)
  }

Swift 3, iOS 10+

DispatchQueue.main.async {
      self.timer = Timer.scheduledTimer(withTimeInterval: 20, repeats: false) { timer in
        print(timer)
      }
    }

Remarques

• Il doit être dans la file d'attente principale
• La fonction de rappel peut être publique, privée, ...
• La fonction de rappel doit être @objc

Vérifier avec:

Swift 2

var timer = NSTimer.scheduledTimerWithTimeInterval(0.01, target: self, selector: Selector("update"), userInfo: nil, repeats: true)

Swift 3, 4, 5

var timer = Timer.scheduledTimer(timeInterval: 0.01, target: self, selector: #selector(self.update), userInfo: nil, repeats: true)

Vous devrez utiliser Timer au lieu de NSTimer dans Swift 3.

Voici un exemple:

Timer.scheduledTimer(timeInterval: 1, 
    target: self, 
    selector: #selector(YourController.update), 
    userInfo: nil, 
    repeats: true)

// @objc selector expected for Timer
@objc func update() {
    // do what should happen when timer triggers an event
}

Swift 5

Personnellement, je préfère la minuterie avec fermeture de bloc:

    Timer.scheduledTimer(withTimeInterval: 1, repeats: false) { (_) in
       // TODO: - whatever you want
    }

pour swift 3 et Xcode 8.2 (agréable d'avoir des blocs, mais si vous compilez pour iOS9 ET voulez userInfo):

...

        self.timer = Timer(fireAt: fire,
                           interval: deltaT,
                           target: self,
                           selector: #selector(timerCallBack(timer:)),
                           userInfo: ["custom":"data"],
                           repeats: true)

        RunLoop.main.add(self.timer!, forMode: RunLoopMode.commonModes)
        self.timer!.fire()
}

func timerCallBack(timer: Timer!){
        let info = timer.userInfo
        print(info)
    }

SimpleTimer (Swift 3.1)

Pourquoi?

Il s'agit d'une classe de minuteur simple en swift qui vous permet de:

• Minuterie locale
• Chaînable
• Une doublure
• Utiliser des rappels réguliers

Usage:

SimpleTimer(interval: 3,repeats: true){print("tick")}.start()//Ticks every 3 secs

Code:

class SimpleTimer {/*<--was named Timer, but since swift 3, NSTimer is now Timer*/
    typealias Tick = ()->Void
    var timer:Timer?
    var interval:TimeInterval /*in seconds*/
    var repeats:Bool
    var tick:Tick

    init( interval:TimeInterval, repeats:Bool = false, onTick:@escaping Tick){
        self.interval = interval
        self.repeats = repeats
        self.tick = onTick
    }
    func start(){
        timer = Timer.scheduledTimer(timeInterval: interval, target: self, selector: #selector(update), userInfo: nil, repeats: true)//swift 3 upgrade
    }
    func stop(){
        if(timer != nil){timer!.invalidate()}
    }
    /**
     * This method must be in the public or scope
     */
    @objc func update() {
        tick()
    }
}

timer = Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(createEnemy), userInfo: nil, repeats: true)

Et créez du plaisir par le nom createEnemy

fund createEnemy ()
{
do anything ////
}

Déclarez d'abord votre chronomètre

var timer: Timer?

Ensuite, ajoutez la ligne dans viewDidLoad () ou dans n'importe quelle fonction que vous souhaitez démarrer la minuterie

timer = Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(action), userInfo: nil, repeats: false)

C'est le func que vous le rappellerez pour faire quelque chose qu'il doit être @objc

@objc func action () {
print("done")
}

Dans Swift 3, quelque chose comme ça avec @objc:

func startTimerForResendingCode() {
    let timerIntervalForResendingCode = TimeInterval(60)
    Timer.scheduledTimer(timeInterval: timerIntervalForResendingCode,
                         target: self,
                         selector: #selector(timerEndedUp),
                         userInfo: nil,
                         repeats: false)
}




@objc func timerEndedUp() {
    output?.timerHasFinishedAndCodeMayBeResended()
}

Si vous lancez la méthode de la minuterie

let timer = Timer(timeInterval: 3, target: self, selector: #selector(update(_:)), userInfo: [key : value], repeats: false)

func update(_ timer : Timer) {

}

puis ajoutez-le à la boucle en utilisant la méthode autre sélecteur ne sera pas appelé

RunLoop.main.add(timer!, forMode: .defaultRunLoopMode)

REMARQUE: Si vous souhaitez que cela se répète, effectuez des répétitions vraies et conservez la référence du minuteur, sinon la méthode de mise à jour ne sera pas appelée.

Si vous utilisez cette méthode.

Timer.scheduledTimer(timeInterval: seconds, target: self, selector: #selector(update(_:)), userInfo: nil, repeats: true)

conserver une référence pour une utilisation ultérieure si les répétitions sont vraies.

J'ai essayé de faire dans une classe NSObject et cela a fonctionné pour moi:

DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(300)) {  
print("Bang!") }

NSTimer a été renommé Timer dans Swift 4.2. cette syntaxe fonctionnera en 4.2:

let timer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(UIMenuController.update), userInfo: nil, repeats: true)