Getting the difference between two NSDates in (months/days/hours/minutes/seconds)

I am trying to get the difference between the current date as NSDate() and a date from a PHP time(); call for example: NSDate(timeIntervalSinceReferenceDate: 1417147270). How do I go about getting the difference in time between the two dates. I’d like to have a function that compares the two dates and if(seconds > 60) then it returns minutes, if(minutes > 60) return hours and if(hours > 24) return days and so on.

How should I go about this?

  • Alamofire and SwiftyJSON for Swift 2.0
  • How to convert array of dictionary to JSON?
  • Convert gregorian date to Hijri date
  • Using init() in map()
  • Fix warning “C-style for Statement is deprecated” in Swift 3
  • fatal error: swapping a location with itself is not supported with Swift 2.0
  • EDIT: The current accepted answer has done exactly what I’ve wanted to do. I recommend it for easy usage for getting the time between two dates in the form that that PHP time() function uses. If you aren’t particularly familiar with PHP, that’s the time in seconds from January 1st, 1970. This is beneficial for a backend in PHP. If perhaps you’re using a backend like NodeJS you might want to consider some of the other options you’ll find below.

    14 Solutions Collect From Internet About “Getting the difference between two NSDates in (months/days/hours/minutes/seconds)”

    Xcode 8.3 • Swift 3.1

    You can use Calendar to help you create an extension to do your date calculations as follow:

    extension Date {
        /// Returns the amount of years from another date
        func years(from date: Date) -> Int {
            return Calendar.current.dateComponents([.year], from: date, to: self).year ?? 0
        }
        /// Returns the amount of months from another date
        func months(from date: Date) -> Int {
            return Calendar.current.dateComponents([.month], from: date, to: self).month ?? 0
        }
        /// Returns the amount of weeks from another date
        func weeks(from date: Date) -> Int {
            return Calendar.current.dateComponents([.weekOfMonth], from: date, to: self).weekOfMonth ?? 0
        }
        /// Returns the amount of days from another date
        func days(from date: Date) -> Int {
            return Calendar.current.dateComponents([.day], from: date, to: self).day ?? 0
        }
        /// Returns the amount of hours from another date
        func hours(from date: Date) -> Int {
            return Calendar.current.dateComponents([.hour], from: date, to: self).hour ?? 0
        }
        /// Returns the amount of minutes from another date
        func minutes(from date: Date) -> Int {
            return Calendar.current.dateComponents([.minute], from: date, to: self).minute ?? 0
        }
        /// Returns the amount of seconds from another date
        func seconds(from date: Date) -> Int {
            return Calendar.current.dateComponents([.second], from: date, to: self).second ?? 0
        }
        /// Returns the a custom time interval description from another date
        func offset(from date: Date) -> String {
            if years(from: date)   > 0 { return "\(years(from: date))y"   }
            if months(from: date)  > 0 { return "\(months(from: date))M"  }
            if weeks(from: date)   > 0 { return "\(weeks(from: date))w"   }
            if days(from: date)    > 0 { return "\(days(from: date))d"    }
            if hours(from: date)   > 0 { return "\(hours(from: date))h"   }
            if minutes(from: date) > 0 { return "\(minutes(from: date))m" }
            if seconds(from: date) > 0 { return "\(seconds(from: date))s" }
            return ""
        }
    }
    

    Using Date Components Formatter

    let dateComponentsFormatter = DateComponentsFormatter()
    dateComponentsFormatter.allowedUnits = [.year,.month,.weekOfYear,.day,.hour,.minute,.second]
    dateComponentsFormatter.maximumUnitCount = 1
    dateComponentsFormatter.unitsStyle = .full
    dateComponentsFormatter.string(from: Date(), to: Date(timeIntervalSinceNow: 4000000))  // "1 month"
    

    let date1 = DateComponents(calendar: .current, year: 2014, month: 11, day: 28, hour: 5, minute: 9).date!
    let date2 = DateComponents(calendar: .current, year: 2015, month: 8, day: 28, hour: 5, minute: 9).date!
    
    let years = date2.years(from: date1)     // 0
    let months = date2.months(from: date1)   // 9
    let weeks = date2.weeks(from: date1)     // 39
    let days = date2.days(from: date1)       // 273
    let hours = date2.hours(from: date1)     // 6,553
    let minutes = date2.minutes(from: date1) // 393,180
    let seconds = date2.seconds(from: date1) // 23,590,800
    
    let timeOffset = date2.offset(from: date1) // "9M"
    
    let date3 = DateComponents(calendar: .current, year: 2014, month: 11, day: 28, hour: 5, minute: 9).date!
    let date4 = DateComponents(calendar: .current, year: 2015, month: 11, day: 28, hour: 5, minute: 9).date!
    
    let timeOffset2 = date4.offset(from: date3) // "1y"
    
    let date5 = DateComponents(calendar: .current, year: 2017, month: 4, day: 28).date!
    let now = Date()
    let timeOffset3 = now.offset(from: date5) // "1w"
    

    If someone would need to display all time units e.g “hours minutes seconds” not just “hours”. Let’s say the time difference between two dates is 1hour 59minutes 20seconds. This function will display “1h 59m 20s”.

    Here is my code:

    extension NSDate {
    
        func offsetFrom(date:NSDate) -> String {
    
            let dayHourMinuteSecond: NSCalendarUnit = [.Day, .Hour, .Minute, .Second]
            let difference = NSCalendar.currentCalendar().components(dayHourMinuteSecond, fromDate: date, toDate: self, options: [])
    
            let seconds = "\(difference.second)s"
            let minutes = "\(difference.minute)m" + " " + seconds
            let hours = "\(difference.hour)h" + " " + minutes
            let days = "\(difference.day)d" + " " + hours
    
            if difference.day    > 0 { return days }
            if difference.hour   > 0 { return hours }
            if difference.minute > 0 { return minutes }
            if difference.second > 0 { return seconds }
            return ""
        }
    
    }
    

    In Swift 3:

    extension Date {
    
        func offsetFrom(date: Date) -> String {
    
            let dayHourMinuteSecond: Set<Calendar.Component> = [.day, .hour, .minute, .second]
            let difference = NSCalendar.current.dateComponents(dayHourMinuteSecond, from: date, to: self);
    
            let seconds = "\(difference.second ?? 0)s"
            let minutes = "\(difference.minute ?? 0)m" + " " + seconds
            let hours = "\(difference.hour ?? 0)h" + " " + minutes
            let days = "\(difference.day ?? 0)d" + " " + hours
    
            if let day = difference.day, day          > 0 { return days }
            if let hour = difference.hour, hour       > 0 { return hours }
            if let minute = difference.minute, minute > 0 { return minutes }
            if let second = difference.second, second > 0 { return seconds }
            return ""
        }
    
    }
    

    You ask:

    I’d like to have a function that compares the two dates and if(seconds > 60) then it returns minutes, if(minutes > 60) return hours and if(hours > 24) return days and so on.

    I’m assuming that you’re trying to build a string representation of the elapsed time between two dates. Rather than writing your own code to do that, Apple already has a class designed to do precisely that. Namely, use DateComponentsFormatter, set allowedUnits to whatever values make sense to your app, set unitsStyle to whatever you want (e.g. .full), and then call string(from:to:).

    E.g. in Swift 3:

    let previousDate = ...
    let now = Date()
    
    let formatter = DateComponentsFormatter()
    formatter.unitsStyle = .full
    formatter.allowedUnits = [.month, .day, .hour, .minute, .second]
    formatter.maximumUnitCount = 2   // often, you don't care about seconds if the elapsed time is in months, so you'll set max unit to whatever is appropriate in your case
    
    let string = formatter.string(from: previousDate, to: now)
    

    This also will localize the string appropriate for the device in question.

    Or, in Swift 2.3:

    let previousDate = ...
    let now = NSDate()
    
    let formatter = NSDateComponentsFormatter()
    formatter.unitsStyle = .Full
    formatter.allowedUnits = [.Month, .Day, .Hour, .Minute, .Second]
    formatter.maximumUnitCount = 2
    
    let string = formatter.stringFromDate(previousDate, toDate: now)
    

    If you’re looking for the actual numeric values, just use dateComponents. E.g. in Swift 3:

    let components = Calendar.current.dateComponents([.month, .day, .hour, .minute, .second], from: previousDate, to: now)
    

    Or, in Swift 2.3:

    let components = NSCalendar.currentCalendar().components([.Month, .Day, .Hour, .Minute, .Second], fromDate: previousDate, toDate: now, options: [])
    
       func dateDiff(dateStr:String) -> String {
                var f:NSDateFormatter = NSDateFormatter()
                f.timeZone = NSTimeZone.localTimeZone()
                f.dateFormat = "yyyy-M-dd'T'HH:mm:ss.SSSZZZ"
    
                var now = f.stringFromDate(NSDate())
                var startDate = f.dateFromString(dateStr)
                var endDate = f.dateFromString(now)
                var calendar: NSCalendar = NSCalendar.currentCalendar()
    
                let calendarUnits = NSCalendarUnit.CalendarUnitWeekOfMonth | NSCalendarUnit.CalendarUnitDay | NSCalendarUnit.CalendarUnitHour | NSCalendarUnit.CalendarUnitMinute | NSCalendarUnit.CalendarUnitSecond
                let dateComponents = calendar.components(calendarUnits, fromDate: startDate!, toDate: endDate!, options: nil)
    
                let weeks = abs(dateComponents.weekOfMonth)
                let days = abs(dateComponents.day)
                let hours = abs(dateComponents.hour)
                let min = abs(dateComponents.minute)
                let sec = abs(dateComponents.second)
    
                var timeAgo = ""
    
                if (sec > 0){
                    if (sec > 1) {
                        timeAgo = "\(sec) Seconds Ago"
                    } else {
                        timeAgo = "\(sec) Second Ago"
                    }
                }
    
                if (min > 0){
                    if (min > 1) {
                        timeAgo = "\(min) Minutes Ago"
                    } else {
                        timeAgo = "\(min) Minute Ago"
                    }
                }
    
                if(hours > 0){
                    if (hours > 1) {
                        timeAgo = "\(hours) Hours Ago"
                    } else {
                        timeAgo = "\(hours) Hour Ago"
                    }
                }
    
                if (days > 0) {
                    if (days > 1) {
                        timeAgo = "\(days) Days Ago"
                    } else {
                        timeAgo = "\(days) Day Ago"
                    }
                }
    
                if(weeks > 0){
                    if (weeks > 1) {
                        timeAgo = "\(weeks) Weeks Ago"
                    } else {
                        timeAgo = "\(weeks) Week Ago"
                    }
                }
    
                print("timeAgo is===> \(timeAgo)")
                return timeAgo;
            }
    

    I added a “long” version to Leo Dabus’s asnwer in case you want to have a string that says something like “2 weeks ago” instead of just “2w”…

    extension Date {
        /// Returns the amount of years from another date
        func years(from date: Date) -> Int {
            return Calendar.current.dateComponents([.year], from: date, to: self).year ?? 0
        }
        /// Returns the amount of months from another date
        func months(from date: Date) -> Int {
            return Calendar.current.dateComponents([.month], from: date, to: self).month ?? 0
        }
        /// Returns the amount of weeks from another date
        func weeks(from date: Date) -> Int {
            return Calendar.current.dateComponents([.weekOfYear], from: date, to: self).weekOfYear ?? 0
        }
        /// Returns the amount of days from another date
        func days(from date: Date) -> Int {
            return Calendar.current.dateComponents([.day], from: date, to: self).day ?? 0
        }
        /// Returns the amount of hours from another date
        func hours(from date: Date) -> Int {
            return Calendar.current.dateComponents([.hour], from: date, to: self).hour ?? 0
        }
        /// Returns the amount of minutes from another date
        func minutes(from date: Date) -> Int {
            return Calendar.current.dateComponents([.minute], from: date, to: self).minute ?? 0
        }
        /// Returns the amount of seconds from another date
        func seconds(from date: Date) -> Int {
            return Calendar.current.dateComponents([.second], from: date, to: self).second ?? 0
        }
        /// Returns the a custom time interval description from another date
        func offset(from date: Date) -> String {
            if years(from: date)   > 0 { return "\(years(from: date))y"   }
            if months(from: date)  > 0 { return "\(months(from: date))M"  }
            if weeks(from: date)   > 0 { return "\(weeks(from: date))w"   }
            if days(from: date)    > 0 { return "\(days(from: date))d"    }
            if hours(from: date)   > 0 { return "\(hours(from: date))h"   }
            if minutes(from: date) > 0 { return "\(minutes(from: date))m" }
            if seconds(from: date) > 0 { return "\(seconds(from: date))s" }
            return ""
        }
    
        func offsetLong(from date: Date) -> String {
            if years(from: date)   > 0 { return years(from: date) > 1 ? "\(years(from: date)) years ago" : "\(years(from: date)) year ago" }
            if months(from: date)  > 0 { return months(from: date) > 1 ? "\(months(from: date)) months ago" : "\(months(from: date)) month ago" }
            if weeks(from: date)   > 0 { return weeks(from: date) > 1 ? "\(weeks(from: date)) weeks ago" : "\(weeks(from: date)) week ago"   }
            if days(from: date)    > 0 { return days(from: date) > 1 ? "\(days(from: date)) days ago" : "\(days(from: date)) day ago" }
            if hours(from: date)   > 0 { return hours(from: date) > 1 ? "\(hours(from: date)) hours ago" : "\(hours(from: date)) hour ago"   }
            if minutes(from: date) > 0 { return minutes(from: date) > 1 ? "\(minutes(from: date)) minutes ago" : "\(minutes(from: date)) minute ago" }
            if seconds(from: date) > 0 { return seconds(from: date) > 1 ? "\(seconds(from: date)) seconds ago" : "\(seconds(from: date)) second ago" }
            return ""
        }
    
    }
    

    Slightly modified code for Swift 3.0

    let calendar = NSCalendar.current as NSCalendar
    
    // Replace the hour (time) of both dates with 00:00
    let date1 = calendar.startOfDay(for: startDateTime)
    let date2 = calendar.startOfDay(for: endDateTime)
    
    let flags = NSCalendar.Unit.day
    let components = calendar.components(flags, from: date1, to: date2, options: [])
    
    return components.day!
    

    With Swift 3, according to your needs, you may choose one of the two following ways to solve your problem.


    1. Display the difference between two dates to the user

    You can use a DateComponentsFormatter to create strings for your app’s interface. DateComponentsFormatter has a maximumUnitCount property with the following declaration:

    var maximumUnitCount: Int { get set }
    

    Use this property to limit the number of units displayed in the resulting string. For example, with this property set to 2, instead of “1h 10m, 30s”, the resulting string would be “1h 10m”. Use this property when you are constrained for space or want to round up values to the nearest large unit.

    By setting maximumUnitCount‘s value to 1, you are guaranteed to display the difference in only one DateComponentsFormatter‘s unit (years, months, days, hours or minutes).

    The Playground code below shows how to display the difference between two dates:

    import Foundation
    
    let oldDate = Date(timeIntervalSinceReferenceDate: -16200)
    let newDate = Date(timeIntervalSinceReferenceDate: 0)
    
    let dateComponentsFormatter = DateComponentsFormatter()
    dateComponentsFormatter.allowedUnits = [NSCalendar.Unit.year, .month, .day, .hour, .minute]
    dateComponentsFormatter.maximumUnitCount = 1
    dateComponentsFormatter.unitsStyle = DateComponentsFormatter.UnitsStyle.full
    let timeDifference = dateComponentsFormatter.string(from: oldDate, to: newDate)
    
    print(String(reflecting: timeDifference)) // prints Optional("5 hours")
    

    Note that DateComponentsFormatter rounds up the result. Therefore, a difference of 4 hours and 30 minutes will be displayed as 5 hours.

    If you need to repeat this operation, you can refactor your code:

    import Foundation
    
    struct Formatters {
    
        static let dateComponentsFormatter: DateComponentsFormatter = {
            let dateComponentsFormatter = DateComponentsFormatter()
            dateComponentsFormatter.allowedUnits = [NSCalendar.Unit.year, .month, .day, .hour, .minute]
            dateComponentsFormatter.maximumUnitCount = 1
            dateComponentsFormatter.unitsStyle = DateComponentsFormatter.UnitsStyle.full
            return dateComponentsFormatter
        }()
    
    }
    
    extension Date {
    
        func offset(from: Date) -> String? {
            return Formatters.dateComponentsFormatter.string(from: oldDate, to: self)
        }
    
    }
    
    let oldDate = Date(timeIntervalSinceReferenceDate: -16200)
    let newDate = Date(timeIntervalSinceReferenceDate: 0)
    
    let timeDifference = newDate.offset(from: oldDate)
    print(String(reflecting: timeDifference)) // prints Optional("5 hours")
    

    2. Get the difference between two dates without formatting

    If you don’t need to display with formatting the difference between two dates to the user, you can use Calendar. Calendar has a method dateComponents(_:from:to:) that has the following declaration:

    func dateComponents(_ components: Set<Calendar.Component>, from start: Date, to end: Date) -> DateComponents
    

    Returns the difference between two dates.

    The Playground code below that uses dateComponents(_:from:to:) shows how to retrieve the difference between two dates by returning the difference in only one type of Calendar.Component (years, months, days, hours or minutes).

    import Foundation
    
    let oldDate = Date(timeIntervalSinceReferenceDate: -16200)
    let newDate = Date(timeIntervalSinceReferenceDate: 0)
    
    let descendingOrderedComponents = [Calendar.Component.year, .month, .day, .hour, .minute]
    let dateComponents = Calendar.current.dateComponents(Set(descendingOrderedComponents), from: oldDate, to: newDate)
    let arrayOfTuples = descendingOrderedComponents.map { ($0, dateComponents.value(for: $0)) }
    
    for (component, value) in arrayOfTuples {
        if let value = value, value > 0 {
            print(component, value) // prints hour 4
            break
        }
    }
    

    If you need to repeat this operation, you can refactor your code:

    import Foundation
    
    extension Date {
    
        func offset(from: Date) -> (Calendar.Component, Int)? {
            let descendingOrderedComponents = [Calendar.Component.year, .month, .day, .hour, .minute]
            let dateComponents = Calendar.current.dateComponents(Set(descendingOrderedComponents), from: from, to: self)
            let arrayOfTuples = descendingOrderedComponents.map { ($0, dateComponents.value(for: $0)) }
    
            for (component, value) in arrayOfTuples {
                if let value = value, value > 0 {
                    return (component, value)
                }
            }
    
            return nil
        }
    
    }
    
    let oldDate = Date(timeIntervalSinceReferenceDate: -16200)
    let newDate = Date(timeIntervalSinceReferenceDate: 0)
    
    if let (component, value) = newDate.offset(from: oldDate) {
        print(component, value) // prints hour 4
    }
    

    In Swift 2.2

        /// Returns the amount of years from another date
    func years(fromdate: NSDate) -> Int {
        return NSCalendar.currentCalendar().components([.Year], fromDate: fromdate, toDate: NSDate(), options: []).year ?? 0
    }
    /// Returns the amount of months from another date
    func months(fromdate: NSDate) -> Int {
        return NSCalendar.currentCalendar().components([.Month], fromDate: fromdate, toDate: NSDate(), options: []).month ?? 0
    }
    /// Returns the amount of weeks from another date
    func weeks(fromdate: NSDate) -> Int {
        return NSCalendar.currentCalendar().components([.WeekOfYear], fromDate: fromdate, toDate: NSDate(), options: []).weekOfYear ?? 0
    }
    /// Returns the amount of days from another date
    func days(fromdate: NSDate) -> Int {
        return NSCalendar.currentCalendar().components([.Day], fromDate: fromdate, toDate: NSDate(), options: []).day ?? 0
    }
    /// Returns the amount of hours from another date
    func hours(fromdate: NSDate) -> Int {
        return NSCalendar.currentCalendar().components([.Hour], fromDate: fromdate, toDate: NSDate(), options: []).hour ?? 0
    }
    /// Returns the amount of minutes from another date
    func minutes(fromdate: NSDate) -> Int {
        return NSCalendar.currentCalendar().components([.Minute], fromDate: fromdate, toDate: NSDate(), options: []).minute ?? 0
    }
    /// Returns the amount of seconds from another date
    func seconds(fromdate: NSDate) -> Int {
        return NSCalendar.currentCalendar().components(.Second, fromDate: fromdate, toDate: NSDate(), options: []).second ?? 0
    }
    

    combined Extension + DateComponentsFormatter from the answer of @leo-dabus

    Xcode 8.3 • Swift 3.1

    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)
        }
    }
    
    let dateComponentsFormatter = DateComponentsFormatter()
    dateComponentsFormatter.difference(from: Date(), to: Date(timeIntervalSinceNow: 4000000)) // "1 month"
    

    If your purpose is to get the exact day number between two dates, you can work around this issue like this:

    // Assuming that firstDate and secondDate are defined
    // ...
    
    var calendar: NSCalendar = NSCalendar.currentCalendar()
    
    // Replace the hour (time) of both dates with 00:00
    let date1 = calendar.startOfDayForDate(firstDate)
    let date2 = calendar.startOfDayForDate(secondDate)
    
    let flags = NSCalendarUnit.DayCalendarUnit
    let components = calendar.components(flags, fromDate: date1, toDate: date2, options: nil)
    
    components.day  // This will return the number of day(s) between dates
    

    This is the shorter version: Basically I try to get the difference between the post timestamp with the Date() now.

    // MARK: - UPDATE Time Stamp
    static func updateTimeStampPost(postTimeStamp: Date?, _ completion: (_ finalString: String?) -> Void) {
        // date in the current state
        let date = Date()
        let dateComponentFormatter = DateComponentsFormatter()
    
        // change the styling date, wether second minute or hour
        dateComponentFormatter.unitsStyle = .abbreviated
        dateComponentFormatter.allowedUnits = [.second, .minute, .hour, .day, .weekOfMonth]
        dateComponentFormatter.maximumUnitCount = 1
    
        // return the date new format as a string in the completion
        completion(dateComponentFormatter.string(from: postTimeStamp!, to: date))
    }
    

    Here is my answer for the Swift 3 answers above. This is current as of Nov 2016, Xcode release was 8.2 Beta (8C23). Used some of both Sagar and Emin suggestions above and sometimes had to let Xcode autocomplete to suggest the syntax. It seemed like the syntax really changed to this beta version. buyDate I got from a DatePicker:

    let calendar = NSCalendar.current as NSCalendar
    let currentDate = Date()
    let date1 = calendar.startOfDay(for: buyDate!)
    let date2 = calendar.startOfDay(for: currentDate)      
    let flags = NSCalendar.Unit.day
    let components = calendar.components(flags, from: date1, to: date2)
    NSLog(" day= \(components.day)")
    

    For XCode Version 8.3.3 & Swift 3.0:

        let dateFormatter = DateFormatter()
        dateFormatter.dateStyle = .medium
        dateFormatter.timeStyle = .short
    
        var beginDate = "2017-08-24 12:00:00"
        var endDate = "2017-09-07 12:00:00"
    
    
        let startDateTime = dateFormatter.date(from: beginDate) //according to date format your date string
        print(startDateTime ?? "") //Convert String to Date
    
        let endDateTime = dateFormatter.date(from: endDate) //according to date format your date string
        print(endDateTime ?? "") //Convert String to Date
    
        let dateComponentsFormatter = DateComponentsFormatter()
        dateComponentsFormatter.allowedUnits = [NSCalendar.Unit.minute,NSCalendar.Unit.hour,NSCalendar.Unit.day]
    
    
       let interval = endDateTime!.timeIntervalSince(startDateTime!)
       var diff = dateComponentsFormatter.string(from: interval)!
    
       print(diff)
    
       var day_i  = 0
       var hour_i = 0
       var min_i = 0
    
    
         if (diff.contains("d"))
           {
                  let day = diff.substring(to: (diff.range(of: "d")?.lowerBound)!)
    
                   day_i  = Int(day)!
                   print ("day --> \(day_i)")
    
                   diff = diff.substring(from:(diff.range(of : " ")?.upperBound )!)
                   print(diff)
           }
    
    
           let hour = diff.substring(to: (diff.range(of : ":")?.lowerBound )!)
           hour_i  = Int(hour)!
           print ("hour --> \(hour_i)")
    
           let min = diff.substring(from: (diff.range(of : ":")?.upperBound )!)
           min_i  = Int(min)!
           print ("min --> \(min_i)")
    

    A small addition to Leo Dabus’ answer to provide the plural versions and be more human readable.

    Swift 3

    extension Date {
    /// Returns the amount of years from another date
    func years(from date: Date) -> Int {
        return Calendar.current.dateComponents([.year], from: date, to: self).year ?? 0
    }
    /// Returns the amount of months from another date
    func months(from date: Date) -> Int {
        return Calendar.current.dateComponents([.month], from: date, to: self).month ?? 0
    }
    /// Returns the amount of weeks from another date
    func weeks(from date: Date) -> Int {
        return Calendar.current.dateComponents([.weekOfMonth], from: date, to: self).weekOfMonth ?? 0
    }
    /// Returns the amount of days from another date
    func days(from date: Date) -> Int {
        return Calendar.current.dateComponents([.day], from: date, to: self).day ?? 0
    }
    /// Returns the amount of hours from another date
    func hours(from date: Date) -> Int {
        return Calendar.current.dateComponents([.hour], from: date, to: self).hour ?? 0
    }
    /// Returns the amount of minutes from another date
    func minutes(from date: Date) -> Int {
        return Calendar.current.dateComponents([.minute], from: date, to: self).minute ?? 0
    }
    /// Returns the amount of seconds from another date
    func seconds(from date: Date) -> Int {
        return Calendar.current.dateComponents([.second], from: date, to: self).second ?? 0
    }
    /// Returns the a custom time interval description from another date
    func offset(from date: Date) -> String {
        if years(from: date)   == 1 { return "\(years(from: date)) year"   } else if years(from: date)   > 1 { return "\(years(from: date)) years"   }
        if months(from: date)  == 1 { return "\(months(from: date)) month"  } else if months(from: date)  > 1 { return "\(months(from: date)) month"  }
        if weeks(from: date)   == 1 { return "\(weeks(from: date)) week"   } else if weeks(from: date)   > 1 { return "\(weeks(from: date)) weeks"   }
        if days(from: date)    == 1 { return "\(days(from: date)) day"    } else if days(from: date)    > 1 { return "\(days(from: date)) days"    }
        if hours(from: date)   == 1 { return "\(hours(from: date)) hour"   } else if hours(from: date)   > 1 { return "\(hours(from: date)) hours"   }
        if minutes(from: date) == 1 { return "\(minutes(from: date)) minute" } else if minutes(from: date) > 1 { return "\(minutes(from: date)) minutes" }
        return ""
    }
    

    }