Like this: sunshinejr/SwiftyUserDefaults#75

PR-s welcome.

How to stop started timer ?
can you add name of timer so we can also stop by name

I was wondering if you can clarify what the difference is between

NSTimer.every(0.7.seconds) {
    println(self.status)
}

and

let timer = NSTimer.new(every: 1.second) {
    println(self.status)
}

Your fire function should be marked as @objc, not as dynamic. This happens to work because dynamic implies @objc, but you don't actually want any of the guarantees of dynamic beyond that of @objc.

Extending Int and Double with properties second, seconds, minute, etc. seems like a rather bad idea. There's two problems with this:

1. Anyone using your code in a project with other 3rd-party code that wants to do something similar will have a compile-time naming collision, making it impossible to use either one.
2. It's weakly-typed. You're still taking NSTimeInterval as your actual time type, and all it takes is for someone to accidentally leave off the .minutes and they'll get the wrong time. This isn't a huge issue, as NSTimeInterval is used everywhere to mean seconds and people are used to it, but we can still do better.

The better approach is to use an actual Duration type that requires the user to type the unit as part of the constructor. With the ruby-like approach you can just say NSTimer.after(1) { ... } but with a proper strong type there's no way to do this. I'd suggest something like

/// A type that represents a given duration.
public struct Duration: Comparable, Hashable, Printable, DebugPrintable {
    /// The time interval of the `Duration`, in seconds.
    let seconds: NSTimeInterval
    /// The time interval of the `Duration`, in minutes.
    var minutes: NSTimeInterval {
        return seconds / 60
    }
    /// The time interval of the `Duration`, in hours.
    var hours: NSTimeInterval {
        return seconds / 3600
    }
    /// The time interval of the `Duration`, in milliseconds.
    /// Sub-millisecond values are truncated.
    var milliseconds: Int64 {
        return Int64(seconds * 1_000)
    }
    /// The time interval of the `Duration`, in microseconds.
    /// Sub-microsecond values are truncated.
    var microseconds: Int64 {
        return Int64(seconds * 1_000_000)
    }
    /// The time interval of the `Duration`, in nanoseconds.
    var nanoseconds: Int64 {
        return Int64(seconds * 1_000_000_000)
    }

    /// Construct a `Duration` for a given number of seconds.
    public init(seconds: NSTimeInterval) {
        self.seconds = seconds
    }
    /// Construct a `Duration` for a given number of minutes.
    public init(minutes: NSTimeInterval) {
        self.init(seconds: minutes * 60)
    }
    /// Construct a `Duration` for a given number of hours.
    public init(hours: NSTimeInterval) {
        self.init(seconds: hours * 3600)
    }
    /// Construct a `Duration` for a given number of milliseconds.
    // Use Int64 because milliseconds are generally not floating-point
    // values
    public init(milliseconds: Int64) {
        self.init(seconds: NSTimeInterval(milliseconds) / 1_000)
    }
    /// Construct a `Duration` for a given number of microseconds.
    public init(microseconds: Int64) {
        self.init(seconds: NSTimeInterval(microseconds) / 1_000_000)
    }
    /// Constructs a `Duration` for a given number of nanoseconds.
    // How much tolerance does a timer actually support?
    public init(nanoseconds: Int64) {
        self.init(seconds: NSTimeInterval(nanoseconds) / 1_000_000_000)
    }

    public var description: String {
        // TODO: Display human-readable string with multiple units
        return toString(seconds)
    }

    public var debugDescription: String {
        return "Duration(\(seconds))"
    }

    public var hashValue: Int {
        return seconds.hashValue
    }
}

public func +(lhs: Duration, rhs: Duration) -> Duration {
    return Duration(seconds: lhs.seconds + rhs.seconds)
}
public func -(lhs: Duration, rhs: Duration) -> Duration {
    return Duration(seconds: lhs.seconds - rhs.seconds)
}
// NB: Don't implement multiplication/division, that doesn't make any sense for
// durations. As such, we don't conform to IntegerArithmeticType either.
public func <(lhs: Duration, rhs: Duration) -> Bool {
    return lhs.seconds < rhs.seconds
}
public func ==(lhs: Duration, rhs: Duration) -> Bool {
    return lhs.seconds == rhs.seconds
}

This way you can then say NSTimer.after(Duration(seconds: 1)) { ... }. You could also experiment with replacing all those initializers with static functions instead (e.g. static func seconds(seconds: NSTimeInterval)) so that way you can say NSTimer.after(.seconds(1)) { ... }.

Hello!

I want to make a function that starts the timer unless there is a bool true in params (e.g. animateStatusIcon(stop: true)) - in that case I want to stop the timer. Does anyone have an idea what's going on here?

The timer starts but no matter what I do it wont stop.

func animateStatusIcon(stop: Bool? = nil){
        
        let icon = NSImage(named: "statusIcon")
        let iconActive = NSImage(named: "statusIconActive")
        
        let timer = Timer.every(0.4.seconds) {
            self.statusItem.image = icon
            Timer.after(0.2.seconds) {
                self.statusItem.image = iconActive
            }
        }
            
        if(stop == true){
            print(stop!)
            print("should stop now")
            timer.invalidate()
        } else  {
            print(stop)
            print("start")
            timer.start()
        }
        
    }

I haven't perused the source fully, but I would imagine there is no reason that 10.11 is the deployment target for this. I'm wanting to use it in a project that needs to support mavericks.
My guess is it was an oversight, as it was in my project file.

Please make it support for Swift 5

PR-s appreciated.

Thanks for sharing your work. Trying to do something apparently simple but I see nothing on the console and breakpoints don't stop there. What am I getting wrong?

let backgroundQueue = DispatchQueue(label: "1sec",
    qos: .background,
    target: nil)

backgroundQueue.async {
    Timer.every(1.seconds) {
        self.log.debug("Timer tick at \(Date())")
    }
}

Cheers

The following code worked with 1.3.0 but crashes with 1.4.0:

let timer = NSTimer.every(1) { 
            print("do something!")
        }
timer.fire()

The internal refactoring of not using NSTimer initializers might be the problem.

Example:

NSTimer.new(every: 1.0) {
    let num = random() % 5
    if num == 3 {
        // I want to stop timer according to this condition
    }
}

@radex Now that Xcode 8 is out, it would be awesome to have an official pod version in the trunk.

You can avoid using private class with CFRunLoopTimerCreateWithHandler

I am trying to use the below in my applicationDidEnterBackground in my AppDelegate.

Timer.after(5.seconds) {
            print ("This is after 5 seconds")
        }

just to test if it works and nothing gets printed out. I want to have a function run after 5 seconds of the app being in the background.

To kiedy możemy się spodziewać wersji na 4.0?

What are your thoughts about including the timer object in the block?

public class func every(interval: NSTimeInterval, _ block: NSTimer -> Void) -> NSTimer {}

Otherwise I need to declare the variable separately like this:

var timer: NSTimer?
timer = NSTimer.every(5.seconds) {
    timer?.invalidate()
}

When I call a NSTimer.after and pass a function, it doesn't have a argument name for second argument. This feels not natural for me regarding that all other functions usually used default or external names.

  NSTimer.after(1.second, close)

Using default names don't change the nice trailing closure syntax

public class func after(interval: NSTimeInterval, block: () -> Void) -> NSTimer 
...
NSTimer.after(1.second) {
  print("done")
}

If you agree I can make a PR :)

PR-s appreciated.

Show in PNG.
Use Xcode 8 and swift 2.3.
I use cocoa pods.
I'm a novice , please tell me detail.
swiftyTimer Version : 1.4.1
Thank you~ 🤗

Non-scheduling initializers are currently defined as static methods because there was a bug in Foundation causing a crash.

I believe it was fixed, but I don't remember when exactly — it's possible it was only iOS 9/El Capitan, and it still won't work on iOS 8 etc.

If someone could verify this, we could add initializers that are appropriately marked as @available.

PR-s appreciated.

Is there a way to add userinfo to nstimer ? so i can access a specific timer when making multiple timers dynamically ?