Comment déterminer si un NSDate est aujourd'hui?

Question

Comment vérifier si un NSDate appartient aujourd'hui?

Je l'habitude de le vérifier en utilisant 10 premiers caractères de [aDate description]. [[aDate description] substringToIndex:10] retourne la chaîne comme "YYYY-MM-DD" donc je compare la chaîne avec la chaîne retournée par [[[NSDate date] description] substringToIndex:10].

Y at-il plus rapide et / ou belle façon de vérifier?

Merci.

Answer 1

Dans macOS 10.9+ & iOS 8+, il y a une méthode sur NSCalendar / Calendrier qui fait exactement cela!

- (BOOL)isDateInToday:(NSDate *)date 

Vous voulez simplement faire

Objective-C:

BOOL today = [[NSCalendar currentCalendar] isDateInToday:date];

Swift 3:

let today = Calendar.current.isDateInToday(date)

Answer 2

Vous pouvez comparer les composants de date:

NSDateComponents *otherDay = [[NSCalendar currentCalendar] components:NSCalendarUnitEra | NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay fromDate:aDate];
NSDateComponents *today = [[NSCalendar currentCalendar] components:NSCalendarUnitEra | NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay fromDate:[NSDate date]];
if([today day] == [otherDay day] &&
   [today month] == [otherDay month] &&
   [today year] == [otherDay year] &&
   [today era] == [otherDay era]) {
    //do stuff
}

Edit:

J'aime la méthode de stefan plus, je pense qu'il fait un plus propre et plus compréhensible si la déclaration:

NSCalendar *cal = [NSCalendar currentCalendar];
NSDateComponents *components = [cal components:(NSCalendarUnitEra | NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay) fromDate:[NSDate date]];
NSDate *today = [cal dateFromComponents:components];
components = [cal components:(NSCalendarUnitEra | NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay) fromDate:aDate];
NSDate *otherDate = [cal dateFromComponents:components];

if([today isEqualToDate:otherDate]) {
    //do stuff
}

Chris, j'ai intégré votre suggestion. Je devais regarder quelle époque était, donc pour quelqu'un d'autre qui ne sait pas, il établit une distinction entre BC et AD. Ceci est probablement inutile pour la plupart des gens, mais il est facile de vérifier et ajoute une certaine certitude, donc je l'ai inclus. Si vous allez pour la vitesse, ce qui est probablement pas une bonne méthode de toute façon.

---

NOTE comme avec beaucoup de réponses sur SO, après 7 ans ce qui est totalement obsolète. Dans Swift maintenant il suffit d'utiliser .isDateInToday

Answer 3

Ceci est un rejeton à votre question, mais si vous voulez imprimer une NSDate avec « Aujourd'hui » ou « Yesterday », utilisez la fonction

- (void)setDoesRelativeDateFormatting:(BOOL)b

pour NSDateFormatter

Answer 4

Je voudrais essayer d'obtenir la date d'aujourd'hui normalisée à minuit et la deuxième date, normaliser à minuit puis comparer si elle est la même NSDate.

un exemple d'Apple voici comment vous normalisez à minuit la date d'aujourd'hui, faire la même chose pour la deuxième date et comparer:

NSCalendar * gregorian = [[NSCalendar alloc]
                               initWithCalendarIdentifier:NSGregorianCalendar];
NSDateComponents * components =
    [gregorian components:
                 (NSYearCalendarUnit|NSMonthCalendarUnit|NSDayCalendarUnit)
                 fromDate:[NSDate date]];
NSDate * today = [gregorian dateFromComponents:components];

Answer 5

travail Swift 3 et 4 extension de la suggestion faite par Catfish_Man:

extension Date {

    func isToday() -> Bool {
        return Calendar.current.isDateInToday(self)
    }

}

Answer 6

Pas besoin de jongler avec des composants, des époques et des choses.

NSCalendar fournit une méthode pour obtenir le début d'une certaine unité de temps pour une date existante.

Ce code va se BEGIN d'aujourd'hui et une autre date et les comparer. Si l'évaluation NSOrderedSame, les deux dates sont le même jour - donc aujourd'hui

.

NSDate *today = nil;
NSDate *beginningOfOtherDate = nil;

NSDate *now = [NSDate date];
[[NSCalendar currentCalendar] rangeOfUnit:NSDayCalendarUnit startDate:&today interval:NULL forDate:now];
[[NSCalendar currentCalendar] rangeOfUnit:NSDayCalendarUnit startDate:&beginningOfOtherDate interval:NULL forDate:beginningOfOtherDate];

if([today compare:beginningOfOtherDate] == NSOrderedSame) {
    //otherDate is a date in the current day
}

Answer 7

extension NSDate {
  func isToday() -> Bool {
    let cal = NSCalendar.currentCalendar()
    var components = cal.components([.Era, .Year, .Month, .Day], fromDate:NSDate())
    let today = cal.dateFromComponents(components)!

    components = cal.components([.Era, .Year, .Month, .Day], fromDate:self)
    let otherDate = cal.dateFromComponents(components)!

    return today.isEqualToDate(otherDate)
}

A travaillé pour moi sur Swift 2.0

Answer 8

Version Swift de la meilleure réponse:

let cal = NSCalendar.currentCalendar()
var components = cal.components([.Era, .Year, .Month, .Day], fromDate:NSDate())
let today = cal.dateFromComponents(components)!

components = cal.components([.Era, .Year, .Month, .Day], fromDate:aDate);
let otherDate = cal.dateFromComponents(components)!

if(today.isEqualToDate(otherDate)) {
    //do stuff
}

Answer 9

Reportez-vous à l'entrée de la documentation d'Apple intitulée "Calculs Calendrier" [link] .

Liste 13 sur cette page suggère que, pour déterminer le nombre de jours entre minuits, vous utilisez:

- (NSInteger)midnightsFromDate:(NSDate *)startDate toDate:(NSDate *)endDate
{
    NSCalendar *calendar = [NSCalendar autoupdatingCurrentCalendar];
    NSInteger startDay = [calendar ordinalityOfUnit:NSDayCalendarUnit
                                             inUnit:NSEraCalendarUnit
                                            forDate:startDate];
    NSInteger endDay = [calendar ordinalityOfUnit:NSDayCalendarUnit
                                           inUnit:NSEraCalendarUnit
                                          forDate:endDate];
    return endDay - startDay;
}

Vous pouvez alors déterminer si deux jours sont les mêmes en utilisant cette méthode et de voir si elle retourne 0 ou non.

Answer 10

Vous pouvez également vérifier l'intervalle de temps entre la date que vous avez, et la date courante:

[myDate timeIntervalSinceNow]

Cela vous donnera l'intervalle de temps, en secondes, entre myDate et la date / heure.

Lien .

Edit: Note à tout le monde. Je suis bien conscient du fait que [myDate timeIntervalSinceNow] ne permet pas de déterminer clairement si myDate est aujourd'hui

Je quitte cette réponse comme c'est que si quelqu'un cherche quelque chose de similaire et [myDate timeIntervalSinceNow] est utile, ils peuvent le trouver ici.

Answer 11

Extension Swift basée sur les meilleures réponses:

extension NSDate {
    func isToday() -> Bool {
        let cal = NSCalendar.currentCalendar()
        if cal.respondsToSelector("isDateInToday:") {
            return cal.isDateInToday(self)
        }
        var components = cal.components((.CalendarUnitEra | .CalendarUnitYear | .CalendarUnitMonth | .CalendarUnitDay), fromDate:NSDate())
        let today = cal.dateFromComponents(components)!

        components = cal.components((.CalendarUnitEra | .CalendarUnitYear | .CalendarUnitMonth | .CalendarUnitDay), fromDate:self);
        let otherDate = cal.dateFromComponents(components)!
        return today.isEqualToDate(otherDate)
    }
}

Answer 12

Si vous avez beaucoup de ces comparaisons de dates, puis les appels à calendar:components:fromDate commencent à prendre beaucoup de temps. Selon certains profils, je l'ai fait, ils semblent être assez cher.

Dites que vous essayez de déterminer qui d'une certaine série de dates, disons NSArray *datesToCompare, sont le même jour que un jour donné, par exemple NSDate *baseDate, vous pouvez alors utiliser quelque chose comme ce qui suit (en partie adaptée d'une réponse ci-dessus):

NSDate *baseDate = [NSDate date];

NSArray *datesToCompare = [NSArray arrayWithObjects:[NSDate date], 
                           [NSDate dateWithTimeIntervalSinceNow:100],
                           [NSDate dateWithTimeIntervalSinceNow:1000],
                           [NSDate dateWithTimeIntervalSinceNow:-10000],
                           [NSDate dateWithTimeIntervalSinceNow:100000],
                           [NSDate dateWithTimeIntervalSinceNow:1000000],
                           [NSDate dateWithTimeIntervalSinceNow:50],
                           nil];

// determine the NSDate for midnight of the base date:
NSCalendar* calendar = [NSCalendar currentCalendar];
NSDateComponents* comps = [calendar components:(NSYearCalendarUnit|NSMonthCalendarUnit|NSDayCalendarUnit) 
                                       fromDate:baseDate];
NSDate* theMidnightHour = [calendar dateFromComponents:comps];

// set up a localized date formatter so we can see the answers are right!
NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
[dateFormatter setDateStyle:NSDateFormatterMediumStyle];
[dateFormatter setTimeStyle:NSDateFormatterMediumStyle];

// determine which dates in an array are on the same day as the base date:
for (NSDate *date in datesToCompare) {
    NSTimeInterval interval = [date timeIntervalSinceDate:theMidnightHour];
    if (interval >= 0 && interval < 60*60*24) {
        NSLog(@"%@ is on the same day as %@", [dateFormatter stringFromDate:date], [dateFormatter stringFromDate:baseDate]);
    }
    else {
        NSLog(@"%@ is NOT on the same day as %@", [dateFormatter stringFromDate:date], [dateFormatter stringFromDate:baseDate]);
    }
}

Sortie:

Nov 23, 2011 1:32:00 PM is on the same day as Nov 23, 2011 1:32:00 PM
Nov 23, 2011 1:33:40 PM is on the same day as Nov 23, 2011 1:32:00 PM
Nov 23, 2011 1:48:40 PM is on the same day as Nov 23, 2011 1:32:00 PM
Nov 23, 2011 10:45:20 AM is on the same day as Nov 23, 2011 1:32:00 PM
Nov 24, 2011 5:18:40 PM is NOT on the same day as Nov 23, 2011 1:32:00 PM
Dec 5, 2011 3:18:40 AM is NOT on the same day as Nov 23, 2011 1:32:00 PM
Nov 23, 2011 1:32:50 PM is on the same day as Nov 23, 2011 1:32:00 PM

Answer 13

Il y a un moyen plus facile que la plupart des réponses ci-dessus!

NSDate *date = ... // The date you wish to test
NSCalendar *calendar = [NSCalendar currentCalendar];

if([calendar isDateInToday:date]) {
    //do stuff
}

Answer 14

Cela pourrait probablement être retravaillé en tant que catégorie NSDate, mais j'utilisé:

// Seconds per day (24h * 60m * 60s)
#define kSecondsPerDay 86400.0f

+ (BOOL) dateIsToday:(NSDate*)dateToCheck
{
    // Split today into components
    NSCalendar* gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];
    NSDateComponents* comps = [gregorian components:(NSYearCalendarUnit|NSMonthCalendarUnit|NSDayCalendarUnit|NSHourCalendarUnit|NSMinuteCalendarUnit|NSSecondCalendarUnit) 
                                        fromDate:[NSDate date]];

    // Set to this morning 00:00:00
    [comps setHour:0];
    [comps setMinute:0];
    [comps setSecond:0];
    NSDate* theMidnightHour = [gregorian dateFromComponents:comps];
    [gregorian release];

    // Get time difference (in seconds) between date and then
    NSTimeInterval diff = [dateToCheck timeIntervalSinceDate:theMidnightHour];
    return ( diff>=0.0f && diff<kSecondsPerDay );
}

(Cependant, en comparant les deux chaînes de date comme dans la question initiale se sent presque 'plus propre' ..)

Answer 15

pour iOS 7 et versions antérieures:

//this is now => need that for the current date
NSDate * now = [NSDate date];

NSCalendar *calendar = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];
[calendar setTimeZone:[NSTimeZone systemTimeZone]];

NSDateComponents * components = [calendar components:( NSYearCalendarUnit|    NSMonthCalendarUnit | NSDayCalendarUnit | NSHourCalendarUnit | NSMinuteCalendarUnit | NSSecondCalendarUnit) fromDate: now];

[components setMinute:0];
[components setHour:0];
[components setSecond:0];

//this is Today's Midnight
NSDate *todaysMidnight = [calendar dateFromComponents: components];



//now timeIntervals since Midnight => in seconds
NSTimeInterval todayTimeInterval = [now timeIntervalSinceDate: todaysMidnight];

//now timeIntervals since OtherDate => in seconds
NSTimeInterval otherDateTimeInterval = [now timeIntervalSinceDate: otherDate];

if(otherDateTimeInterval > todayTimeInterval) //otherDate is not in today
{
    if((otherDateTimeInterval - todayTimeInterval) <= 86400) //86400 == a day total seconds
    {
        @"yesterday";
    }
    else
    {
        @"earlier";
    }
}
else
{
    @"today";
}


now = nil;
calendar = nil;
components = nil;
todaysMidnight = nil;

NSLog("Thank you :-)");

Answer 16

Vérifier grand NSDate extension de notre Erica Sadun. Très simple à utiliser. Amende ici:

http://github.com/erica/NSDate-Extensions

Il est déjà là dans ce message: https://stackoverflow.com/a/4052798/362310

Answer 17

La solution correcte et sûre sans force dépliage, travaillant sur Swift 2.2 et avant iOS 8:

func isToday() -> Bool {
    let calendar = NSCalendar.currentCalendar()
    if #available(iOS 8.0, *) {
        return calendar.isDateInToday(self)
    }

    let todayComponents = calendar.components([.Era, .Year, .Month, .Day], fromDate:NSDate())
    let dayComponents = calendar.components([.Era, .Year, .Month, .Day], fromDate:self)

    guard let today = calendar.dateFromComponents(todayComponents),
        day = calendar.dateFromComponents(dayComponents) else {
        return false
    }

    return today.compare(day) == .OrderedSame
}

Answer 18

Voici mon 2 cent bâtiment de réponse sur la réponse acceptée, mais supportant l'API plus récente ainsi. Note: J'utilise le calendrier grégorien comme la plupart des horodateurs sont au format GMT, mais changer la vôtre comme bon vous semble

func isDateToday(date: NSDate) -> Bool {
    let calendar = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)!
    if calendar.respondsToSelector("isDateInToday:") {
        return calendar.isDateInToday(date)
    }
    let dateComponents = NSCalendarUnit.CalendarUnitYear | NSCalendarUnit.CalendarUnitMonth | NSCalendarUnit.CalendarUnitDay
    let today = calendar.dateFromComponents(calendar.components(dateComponents, fromDate: NSDate()))!
    let dateToCompare = calendar.dateFromComponents(calendar.components(dateComponents, fromDate: date))!

    return dateToCompare == today
}

Answer 19

Ma solution est de calculer combien jours écoulés depuis 1970 par division et comparer la partie entière

#define kOneDay (60*60*24)
- (BOOL)isToday {
  NSInteger offset = [[NSTimeZone defaultTimeZone] secondsFromGMT];

  NSInteger days =[self timeIntervalSince1970] + offset;
  NSInteger currentDays = [[NSDate date] timeIntervalSince1970] + offset;
  return (days / kOneDay == currentDays / kOneDay);
}

Answer 20

NSDate *dateOne = yourDate;
NSDate *dateTwo = [NSDate date];  

switch ([dateOne compare:dateTwo])
{  
    case NSOrderedAscending:  
        NSLog(@”NSOrderedAscending”);  
        break;  

    case NSOrderedSame: 
        NSLog(@”NSOrderedSame”);  
        break;

    case NSOrderedDescending:  
        NSLog(@”NSOrderedDescending”);  
        break;  
}