Here is my answer for Swift 2:

func daysBetweenDates(startDate: NSDate, endDate: NSDate) -> Int

{

    let calendar = NSCalendar.currentCalendar()



    let components = calendar.components([.Day], fromDate: startDate, toDate: endDate, options: )



    return components.day

}

I see a couple Swift3 answers so I'll add my own:

public static func daysBetween(start: Date, end: Date) -> Int {

    return Calendar.current.dateComponents([.day], from: start, to: end).day!

}

The naming feels more Swifty, it's one line, and using the latest dateComponents() method.

I translated my Objective-C answer

let start = "2010-09-01"

let end = "2010-09-05"



let dateFormatter = NSDateFormatter()

dateFormatter.dateFormat = "yyyy-MM-dd"



let startDate:NSDate = dateFormatter.dateFromString(start)

let endDate:NSDate = dateFormatter.dateFromString(end)



let cal = NSCalendar.currentCalendar()





let unit:NSCalendarUnit = .Day



let components = cal.components(unit, fromDate: startDate, toDate: endDate, options: nil)





println(components)

result

<NSDateComponents: 0x10280a8a0>

     Day: 4

The hardest part was that the autocompletion insists fromDate and toDate would be NSDate?, but indeed they must be NSDate! as shown in the reference.

I don't see how a good solution with an operator would look like, as you want to specify the unit differently in each case. You could return the time interval, but than won't you gain much.

Here is very nice, Date extension to get difference between dates in years, months, days, hours, minutes, seconds

extension Date {



    func years(sinceDate: Date) -> Int? {

        return Calendar.current.dateComponents([.year], from: sinceDate, to: self).year

    }



    func months(sinceDate: Date) -> Int? {

        return Calendar.current.dateComponents([.month], from: sinceDate, to: self).month

    }



    func days(sinceDate: Date) -> Int? {

        return Calendar.current.dateComponents([.day], from: sinceDate, to: self).day

    }



    func hours(sinceDate: Date) -> Int? {

        return Calendar.current.dateComponents([.hour], from: sinceDate, to: self).hour

    }



    func minutes(sinceDate: Date) -> Int? {

        return Calendar.current.dateComponents([.minute], from: sinceDate, to: self).minute

    }



    func seconds(sinceDate: Date) -> Int? {

        return Calendar.current.dateComponents([.second], from: sinceDate, to: self).second

    }



}

Update for Swift 3 iOS 10 Beta 4

func daysBetweenDates(startDate: Date, endDate: Date) -> Int {

    let calendar = Calendar.current

    let components = calendar.dateComponents([Calendar.Component.day], from: startDate, to: endDate)

    return components.day!

}

Here is the answer for Swift 3 (tested for IOS 10 Beta)

func daysBetweenDates(startDate: Date, endDate: Date) -> Int

{

    let calendar = Calendar.current

    let components = calendar.components([.day], from: startDate, to: endDate, options: )

    return components.day!

}

Then you can call it like this

let pickedDate: Date = sender.date

let NumOfDays: Int = daysBetweenDates(startDate: pickedDate, endDate: Date())

    print("Num of Days: (NumOfDays)")

Swift 3. Thanks to Emin Buğra Saral above for the startOfDay suggestion.

extension Date {



    func daysBetween(date: Date) -> Int {

        return Date.daysBetween(start: self, end: date)

    }



    static func daysBetween(start: Date, end: Date) -> Int {

        let calendar = Calendar.current



        // Replace the hour (time) of both dates with 00:00

        let date1 = calendar.startOfDay(for: start)

        let date2 = calendar.startOfDay(for: end)



        let a = calendar.dateComponents([.day], from: date1, to: date2)

        return a.value(for: .day)!

    }

}

Usage:

let dateFormatter = DateFormatter()

dateFormatter.dateFormat = "yyyy-MM-dd"

let start = dateFormatter.date(from: "2017-01-01")!

let end = dateFormatter.date(from: "2018-01-01")!



let diff = Date.daysBetween(start: start, end: end) // 365

The things built into swift are still very basic. As they should be at this early stage. But you can add your own stuff with the risk that comes with overloading operators and global domain functions. They will be local to your module though.

let now = NSDate()

let seventies = NSDate(timeIntervalSince1970: 0)



// Standard solution still works

let days = NSCalendar.currentCalendar().components(.CalendarUnitDay, 

           fromDate: seventies, toDate: now, options: nil).day



// Flashy swift... maybe...

func -(lhs:NSDate, rhs:NSDate) -> DateRange {

    return DateRange(startDate: rhs, endDate: lhs)

}



class DateRange {

    let startDate:NSDate

    let endDate:NSDate

    var calendar = NSCalendar.currentCalendar()

    var days: Int {

        return calendar.components(.CalendarUnitDay, 

               fromDate: startDate, toDate: endDate, options: nil).day

    }

    var months: Int {

        return calendar.components(.CalendarUnitMonth, 

               fromDate: startDate, toDate: endDate, options: nil).month

    }

    init(startDate:NSDate, endDate:NSDate) {

        self.startDate = startDate

        self.endDate = endDate

    }

}



// Now you can do this...

(now - seventies).months

(now - seventies).days

Here is my answer for Swift 3:

func daysBetweenDates(startDate: NSDate, endDate: NSDate, inTimeZone timeZone: TimeZone? = nil) -> Int {

    var calendar = Calendar.current

    if let timeZone = timeZone {

        calendar.timeZone = timeZone

    }

    let dateComponents = calendar.dateComponents([.day], from: startDate.startOfDay, to: endDate.startOfDay)

    return dateComponents.day!

}

There's hardly any Swift-specific standard library yet; just the lean basic numeric, string, and collection types.

It's perfectly possible to define such shorthands using extensions, but as far as the actual out-of-the-box APIs goes, there is no "new" Cocoa; Swift just maps directly to the same old verbose Cocoa APIs as they already exist.

I'm going to add my version even though this thread is a year old. My code looks like this:

    var name = txtName.stringValue // Get the users name



    // Get the date components from the window controls

    var dateComponents = NSDateComponents()

    dateComponents.day = txtDOBDay.integerValue

    dateComponents.month = txtDOBMonth.integerValue

    dateComponents.year = txtDOBYear.integerValue



    // Make a Gregorian calendar

    let calendar = NSCalendar(identifier: NSCalendarIdentifierGregorian)



    // Get the two dates we need

    var birthdate = calendar?.dateFromComponents(dateComponents)

    let currentDate = NSDate()



    var durationDateComponents = calendar?.components(NSCalendarUnit.CalendarUnitDay, fromDate: birthdate!, toDate: currentDate, options: nil)



    let numberOfDaysAlive = durationDateComponents?.day



    println("(numberOfDaysAlive!)")



    txtGreeting.stringValue = "Hello (name), You have been alive for (numberOfDaysAlive!) days."

I hope it helps someone.

Cheers,

Erin's method updated to Swift 3, This shows days from today (disregarding time of day)

func daysBetweenDates( endDate: Date) -> Int 

    let calendar: Calendar = Calendar.current 

    let date1 = calendar.startOfDay(for: Date()) 

    let date2 = calendar.startOfDay(for: secondDate) 

    return calendar.dateComponents([.day], from: date1, to: date2).day! 

}

Swift 3.2

extension DateComponentsFormatter {

    func difference(from fromDate: Date, to toDate: Date) -> String? {

        self.allowedUnits = [.year,.month,.weekOfMonth,.day]

        self.maximumUnitCount = 1

        self.unitsStyle = .full

        return self.string(from: fromDate, to: toDate)

    }

}

All answer is good. But for Localizations we need calculates a number of decimal days in between two dates. so we can provide the sustainable decimal format.

// This method returns the fractional number of days between to dates

func getFractionalDaysBetweenDates(date1: Date, date2: Date) -> Double {



    let components = Calendar.current.dateComponents([.day, .hour], from: date1, to: date2)



    var decimalDays = Double(components.day!)

    decimalDays += Double(components.hour!) / 24.0



    return decimalDays

}

Swift 3 - Days from today until date

func daysUntilDate(endDateComponents: DateComponents) -> Int

    {

        let cal = Calendar.current

        var components = cal.dateComponents([.era, .year, .month, .day], from: NSDate() as Date)

        let today = cal.date(from: components)

        let otherDate = cal.date(from: endDateComponents)



        components = cal.dateComponents([Calendar.Component.day], from: (today! as Date), to: otherDate!)

        return components.day!

    }

Call function like this

// Days from today until date

   var examnDate = DateComponents()

   examnDate.year = 2016

   examnDate.month = 12

   examnDate.day = 15

   let daysCount = daysUntilDate(endDateComponents: examnDate)

easier option would be to create a extension on Date

public extension Date {



        public var currentCalendar: Calendar {

            return Calendar.autoupdatingCurrent

        }



        public func daysBetween(_ date: Date) -> Int {

            let components = currentCalendar.dateComponents([.day], from: self, to: date)

            return components.day!

        }

    }

  func completeOffset(from date:Date) -> String? {



    let formatter = DateComponentsFormatter()

    formatter.unitsStyle = .brief



    return  formatter.string(from: Calendar.current.dateComponents([.year,.month,.day,.hour,.minute,.second], from: date, to: self))









}

if you need year month days and hours as string use this

var tomorrow = Calendar.current.date(byAdding: .day, value: 1, to: Date())!

let dc = tomorrow.completeOffset(from: Date())

Nice handy one liner :

extension Date {

  var daysFromNow: Int {

    return Calendar.current.dateComponents([.day], from: Date(), to: self).day!

  }

}

This returns an absolute difference in days between some Date and today:

extension Date {

  func daysFromToday() -> Int {

    return abs(Calendar.current.dateComponents([.day], from: self, to: Date()).day!)

  }

}

and then use it:

if someDate.daysFromToday() >= 7 {

  // at least a week from today

}

Swift 4

 func getDateHeader(indexPath: Int) -> String {

    let formatter2 = DateFormatter()

    formatter2.dateFormat = "MM-dd-yyyy"

    var dateDeadline : Date?



    dateDeadline = formatter2.date(from: arrCompletedDate[indexPath] as! String)



    let currentTime = dateDeadline?.unixTimestamp

    let calendar = NSCalendar.current



    let date = NSDate(timeIntervalSince1970: Double(currentTime!))

    if calendar.isDateInYesterday(date as Date) { return "Yesterday" }

    else if calendar.isDateInToday(date as Date) { return "Today" }

    else if calendar.isDateInTomorrow(date as Date) { return "Tomorrow" }

    else {

        let startOfNow = calendar.startOfDay(for: NSDate() as Date)

        let startOfTimeStamp = calendar.startOfDay(for: date as Date)

        let components = calendar.dateComponents([.day], from: startOfNow, to: startOfTimeStamp)

        let day = components.day!

        if day < 1 { return "(abs(day)) days ago" }

        else { return "In (day) days" }

    }

}

let calendar = NSCalendar.currentCalendar();

let component1 = calendar.component(.Day, fromDate: fromDate)

let component2 = calendar.component(.Day, fromDate: toDate)

let difference  = component1 - component2

2017 version, copy and paste

func simpleIndex(ofDate: Date) -> Int {



    // index here just means today 0, yesterday -1, tomorrow 1 etc.



    let c = Calendar.current

    let todayRightNow = Date()



    let d = c.date(bySetting: .hour, value: 13, of: ofDate)

    let t = c.date(bySetting: .hour, value: 13, of: todayRightNow)



    if d == nil || today == nil {



        print("weird problem simpleIndex#ofDate")

        return 0

    }



    let r = c.dateComponents([.day], from: today!, to: d!)

    // yesterday is negative one, tomorrow is one



    if let o = r.value(for: .day) {



        return o

    }

    else {



        print("another weird problem simpleIndex#ofDate")

        return 0

    }

}