Comparing two NSDates and ignoring the time component

What is the most efficient/recommended way of comparing two NSDates? I would like to be able to see if both dates are on the same day, irrespective of the time and have started writing some code that uses the timeIntervalSinceDate: method within the NSDate class and gets the integer of this value divided by the number of seconds in a day. This seems long winded and I feel like I am missing something obvious.

The code I am trying to fix is:

  • How to close an application programmatically when the user taps on a button
  • llvm-gcc-4.2: error
  • Handling an empty UITableView. Print a friendly message
  • What dpi resolution is used for an iPhone App?
  • iPhone how to get UITextField's text while typing?
  • How to do layout to handle in-call (double-height) status bar for custom presented view controller in iOS 8?
  • if (!([key compare:todaysDate] == NSOrderedDescending))
    {
        todaysDateSection = [eventSectionsArray count] - 1;
    }
    

    where key and todaysDate are NSDate objects and todaysDate is creating using:

    NSDate *todaysDate = [[NSDate alloc] init];
    

    Regards

    Dave

    16 Solutions Collect From Internet About “Comparing two NSDates and ignoring the time component”

    You set the time in the date to 00:00:00 before doing the comparison:

    unsigned int flags = NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay;
    NSCalendar* calendar = [NSCalendar currentCalendar];
    
    NSDateComponents* components = [calendar components:flags fromDate:date];
    
    NSDate* dateOnly = [calendar dateFromComponents:components];
    
    // ... necessary cleanup
    

    Then you can compare the date values. See the overview in reference documentation.

    I’m surprised that no other answers have this option for getting the “beginning of day” date for the objects:

    [[NSCalendar currentCalendar] rangeOfUnit:NSDayCalendarUnit startDate:&date1 interval:NULL forDate:date1];
    [[NSCalendar currentCalendar] rangeOfUnit:NSDayCalendarUnit startDate:&date2 interval:NULL forDate:date2];
    

    Which sets date1 and date2 to the beginning of their respective days. If they are equal, they are on the same day.

    Or this option:

    NSUInteger day1 = [[NSCalendar currentCalendar] ordinalityOfUnit:NSDayCalendarUnit inUnit:NSEraCalendarUnit forDate:date1];
    NSUInteger day2 = [[NSCalendar currentCalendar] ordinalityOfUnit:NSDayCalendarUnit inUnit:NSEraCalendarUnit forDate:date2];
    

    Which sets day1 and day2 to somewhat arbitrary values that can be compared. If they are equal, they are on the same day.

    There’s a new method that was introduced to NSCalendar with iOS 8 that makes this much easier.

    - (NSComparisonResult)compareDate:(NSDate *)date1 toDate:(NSDate *)date2 toUnitGranularity:(NSCalendarUnit)unit NS_AVAILABLE(10_9, 8_0);
    

    You set the granularity to the unit(s) that matter. This disregards all other units and limits comparison to the ones selected.

    For iOS8 and later, checking if two dates occur on the same day is as simple as:

    [[NSCalendar currentCalendar] isDate:date1 inSameDayAsDate:date2]
    

    See documentation

    This is a shorthand of all the answers:

    NSInteger interval = [[[NSCalendar currentCalendar] components: NSDayCalendarUnit
                                                                      fromDate: date1
                                                                        toDate: date2
                                                                       options: 0] day];
        if(interval<0){
           //date1<date2
        }else if (interval>0){
           //date2<date1
        }else{
           //date1=date2
        }
    

    I used the Duncan C approach, I have fixed some mistakes he made

    -(NSInteger) daysBetweenDate:(NSDate *)firstDate andDate:(NSDate *)secondDate { 
    
        NSCalendar *currentCalendar = [NSCalendar currentCalendar];
        NSDateComponents *components = [currentCalendar components: NSDayCalendarUnit fromDate: firstDate toDate: secondDate options: 0];
    
        NSInteger days = [components day];
    
        return days;
    }
    

    I use this little util method:

    -(NSDate*)normalizedDateWithDate:(NSDate*)date
    {
       NSDateComponents* components = [calendar components:(NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit)
                                                  fromDate: date];
       return [calendar_ dateFromComponents:components]; // NB calendar_ must be initialized
    }
    

    (You obviously need to have an ivar called calendar_ containing an NSCalendar.)

    Using this, it is easy to check if a date is today like this:

    [[self normalizeDate:aDate] isEqualToDate:[self normalizeDate:[NSDate date]]];
    

    ([NSDate date] returns the current date and time.)

    This is of course very similar to what Gregory suggests. The drawback of this approach is that it tends to create lots of temporary NSDate objects. If you’re going to process a lot of dates, I would recommend using some other method, such as comparing the components directly, or working with NSDateComponents objects instead of NSDates.

    The answer is simpler than everybody makes it out to be. NSCalendar has a method

    components:fromDate:toDate:options
    

    That method lets you calculate the difference between two dates using whatever units you want.

    So write a method like this:

    -(NSInteger) daysBetweenDate: (NSDate *firstDate) andDate: (NSDate *secondDate)
    {
      NSCalendar *currentCalendar = [NSCalendar currentCalendar];
      NSDateComponents components* = [currentCalendar components: NSDayCalendarUnit
        fromDate: firstDate 
        toDate: secondDate
        options: 0];
    
      NSInteger days = [components days];
      return days;
    }
    

    If the above method returns zero, the two dates are on the same day.

    From iOS 8.0 onwards, you can use:

    NSCalendar *calendar = [NSCalendar currentCalendar];
    NSComparisonResult dateComparison = [calendar compareDate:[NSDate date] toDate:otherNSDate toUnitGranularity:NSCalendarUnitDay];
    

    If the result is e.g. NSOrderedDescending, otherDate is before [NSDate date] in terms of days.

    I do not see this method in the NSCalendar documentation but it is in the iOS 7.1 to iOS 8.0 API Differences

    For developers coding in Swift 3

    if(NSCalendar.current.isDate(selectedDate, inSameDayAs: NSDate() as Date)){
         // Do something
    }
    
    int interval = (int)[firstTime timeIntervalSinceDate:secondTime]/(60*60*24);
    if (interval!=0){
       //not the same day;
    }
    

    my solution was two conversions with NSDateFormatter:

        NSDateFormatter *dateFormat = [[NSDateFormatter alloc] init];
        [dateFormat setDateFormat:@"yyyyMMdd"];
        [dateFormat setTimeZone:[NSTimeZone timeZoneWithName:@"GMT"]];
    
        NSDate *today = [NSDate dateWithTimeIntervalSinceNow:0];
        NSString *todayString=[dateFormat stringFromDate:today];
        NSDate *todayWithoutHour=[dateFormat dateFromString:todayString];
    
        if ([today compare:exprDate] == NSOrderedDescending)
        {
           //do  
        }
    

    The documentation regarding NSDate indicates that the compare: and isEqual: methods will both perform a basic comparison and order the results, albeit they still factor in time.

    Probably the simplest way to manage the task would be to create a new isToday method to the effect of the following:

    - (bool)isToday:(NSDate *)otherDate
    {
        currentTime = [however current time is retrieved]; // Pardon the bit of pseudo-code
    
        if (currentTime < [otherDate timeIntervalSinceNow])
        {
            return YES;
        }
        else
        {
            return NO;
        }
    }
    

    This is a particularly ugly cat to skin, but here’s another way to do it. I don’t say it’s elegant, but it’s probably as close as you can get with the date/time support in iOS.

    bool isToday = [[NSDateFormatter localizedStringFromDate:date dateStyle:NSDateFormatterFullStyle timeStyle:NSDateFormatterNoStyle] isEqualToString:[NSDateFormatter localizedStringFromDate:[NSDate date] dateStyle:NSDateFormatterFullStyle timeStyle:NSDateFormatterNoStyle]];
    
    NSUInteger unit = NSMonthCalendarUnit | NSDayCalendarUnit | NSHourCalendarUnit;
    NSDateComponents *comp = [cal components:unit
                                    fromDate:nowDate
                                      toDate:setDate
                                     options:0];
    
    NSString *dMonth;
    dMonth = [NSString stringWithFormat:@"%02ld",comp.month];
    NSString *dDay;
    dDay = [NSString stringWithFormat:@"%02ld",comp.day + (comp.hour > 0 ? 1 : 0)];
    

    compare hour as well to fix 1day difference

    With Swift 3, according to your needs, you can choose one of the two following patterns in order to solve your problem.


    #1. Using compare(_:to:toGranularity:) method

    Calendar has a method called compare(_:​to:​to​Granularity:​). compare(_:​to:​to​Granularity:​) has the following declaration:

    func compare(_ date1: Date, to date2: Date, toGranularity component: Calendar.Component) -> ComparisonResult
    

    Compares the given dates down to the given component, reporting them ordered​Same if they are the same in the given component and all larger components, otherwise either ordered​Ascending or ordered​Descending.

    The Playground code below shows hot to use it:

    import Foundation
    
    let calendar = Calendar.current
    let date1 = Date() // "Mar 31, 2017, 2:01 PM"
    let date2 = calendar.date(byAdding: .day, value: -1, to: date1)! // "Mar 30, 2017, 2:01 PM"
    let date3 = calendar.date(byAdding: .hour, value: 1, to: date1)! // "Mar 31, 2017, 3:01 PM"
    
    /* Compare date1 and date2 */
    do {
        let comparisonResult = calendar.compare(date1, to: date2, toGranularity: .day)
        switch comparisonResult {
        case ComparisonResult.orderedSame:
            print("Same day")
        default:
            print("Not the same day")
        }
        // Prints: "Not the same day"
    }
    
    /* Compare date1 and date3 */
    do {
        let comparisonResult = calendar.compare(date1, to: date3, toGranularity: .day)
        if case ComparisonResult.orderedSame = comparisonResult {
            print("Same day")
        } else {
            print("Not the same day")
        }
        // Prints: "Same day"
    }
    

    #2. Using dateComponents(_:from:to:)

    Calendar has a method called dateComponents(_:from:to:). dateComponents(_:from:to:) 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 shows hot to use it:

    import Foundation
    
    let calendar = Calendar.current
    let date1 = Date() // "Mar 31, 2017, 2:01 PM"
    let date2 = calendar.date(byAdding: .day, value: -1, to: date1)! // "Mar 30, 2017, 2:01 PM"
    let date3 = calendar.date(byAdding: .hour, value: 1, to: date1)! // "Mar 31, 2017, 3:01 PM"
    
    /* Compare date1 and date2 */
    do {
        let dateComponents = calendar.dateComponents([.day], from: date1, to: date2)
        switch dateComponents.day {
        case let value? where value < 0:
            print("date2 is before date1")
        case let value? where value > 0:
            print("date2 is after date1")
        case let value? where value == 0:
            print("date2 equals date1")
        default:
            print("Could not compare dates")
        }
        // Prints: date2 is before date1
    }
    
    /* Compare date1 and date3 */
    do {
        let dateComponents = calendar.dateComponents([.day], from: date1, to: date3)
        switch dateComponents.day {
        case let value? where value < 0:
            print("date2 is before date1")
        case let value? where value > 0:
            print("date2 is after date1")
        case let value? where value == 0:
            print("date2 equals date1")
        default:
            print("Could not compare dates")
        }
        // Prints: date2 equals date1
    }