Wie kann man feststellen, ob ein NSDate heute ist?

Wie überprüfe ich, ob ein NSDatezu heute gehört?

Ich habe es mit den ersten 10 Zeichen von überprüft [aDate description]. [[aDate description] substringToIndex:10]Gibt einen String wie folgt zurück, "YYYY-MM-DD"also habe ich den String mit dem von zurückgegebenen String verglichen [[[NSDate date] description] substringToIndex:10].

Gibt es eine schnellere und / oder sauberere Möglichkeit zur Überprüfung?

Vielen Dank.

In macOS 10.9+ und iOS 8+ gibt es eine Methode in NSCalendar / Calendar, die genau dies tut!

- (BOOL)isDateInToday:(NSDate *)date 

Also würdest du es einfach tun

Ziel c:

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

Swift 3:

let today = Calendar.current.isDateInToday(date)

Sie können Datumskomponenten vergleichen:

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
}

Bearbeiten:

Ich mag die Methode von stefan mehr, ich denke, sie sorgt für eine sauberere und verständlichere if-Aussage:

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, ich habe deinen Vorschlag aufgenommen. Ich musste nachsehen, was Ära war, also unterscheidet es für alle anderen, die es nicht wissen, zwischen BC und AD. Dies ist für die meisten Menschen wahrscheinlich unnötig, aber es ist leicht zu überprüfen und bietet eine gewisse Sicherheit, daher habe ich es aufgenommen. Wenn Sie auf Geschwindigkeit setzen, ist dies wahrscheinlich sowieso keine gute Methode.

HINWEIS Wie bei vielen Antworten auf SO ist dies nach 7 Jahren völlig veraltet. In Swift jetzt einfach verwenden.isDateInToday

Dies ist ein Ableger Ihrer Frage, aber wenn Sie ein NSDate mit "Heute" oder "Gestern" drucken möchten, verwenden Sie die Funktion

- (void)setDoesRelativeDateFormatting:(BOOL)b

für NSDateFormatter

Ich würde versuchen, das heutige Datum auf Mitternacht und das zweite Datum auf Mitternacht zu normalisieren und dann zu vergleichen, ob es dasselbe NSDate ist.

Anhand eines Apple-Beispiels können Sie das heutige Datum auf Mitternacht normalisieren. Machen Sie dasselbe für das zweite Datum und vergleichen Sie:

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

Working Swift 3 & 4 Erweiterung des Vorschlags von Catfish_Man:

extension Date {

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

}

Sie müssen nicht mit Komponenten, Epochen und anderen Dingen jonglieren.

NSCalendar bietet eine Methode, um den Beginn einer bestimmten Zeiteinheit für ein vorhandenes Datum abzurufen.

Dieser Code beginnt am heutigen Tag und an einem anderen Datum und vergleicht das. Wenn es ausgewertet wird, NSOrderedSamesind beide Daten am selben Tag - also heute.

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
}

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)
}

Arbeitete für mich an Swift 2.0

Schnelle Version der besten Antwort:

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
}

Weitere Informationen finden Sie im Dokumentationseintrag von Apple mit dem Titel "Durchführen von Kalenderberechnungen" [Link] .

Listing 13 auf dieser Seite schlägt vor, dass Sie zur Bestimmung der Anzahl der Mitternächte zwischen den Tagen Folgendes verwenden:

- (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;
}

Sie können dann mithilfe dieser Methode feststellen, ob zwei Tage gleich sind, und prüfen, ob 0 zurückgegeben wird oder nicht.

Sie können auch das Zeitintervall zwischen dem Datum und dem aktuellen Datum überprüfen:

[myDate timeIntervalSinceNow]

Dadurch erhalten Sie das Zeitintervall in Sekunden zwischen myDate und dem aktuellen Datum / der aktuellen Uhrzeit.

Link .

Bearbeiten: Hinweis an alle: Mir ist klar, dass [myDate timeIntervalSinceNow] nicht eindeutig bestimmt, ob myDate heute ist.

Ich lasse diese Antwort so, wie sie ist. Wenn jemand nach etwas Ähnlichem sucht und [myDate timeIntervalSinceNow] nützlich ist, kann er es hier finden.

Schnelle Erweiterung basierend auf den besten Antworten:

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)
    }
}

Wenn Sie viele dieser Datumsvergleiche haben, nehmen die Anrufe calendar:components:fromDateviel Zeit in Anspruch. Nach einigen Profilen, die ich erstellt habe, scheinen sie ziemlich teuer zu sein.

Angenommen, Sie versuchen zu bestimmen, welche Daten aus einer Reihe von Daten NSArray *datesToComparebeispielsweise am selben Tag wie ein bestimmter Tag liegen NSDate *baseDate, dann können Sie Folgendes verwenden (teilweise angepasst aus einer Antwort oben):

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]);
    }
}

Ausgabe:

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

Es gibt einen einfacheren Weg als viele der oben genannten Antworten!

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

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

Dies könnte wahrscheinlich als NSDate-Kategorie überarbeitet werden, aber ich habe verwendet:

// 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 );
}

(Der Vergleich der beiden Datumszeichenfolgen wie in der ursprünglichen Frage fühlt sich jedoch fast "sauberer" an.)

für iOS7 und früher:

//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 :-)");

Überprüfen Sie unsere Erica Sadun großartig NSDate extension. Sehr einfach zu bedienen. Fein es hier:

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

Es ist bereits in diesem Beitrag enthalten: https://stackoverflow.com/a/4052798/362310

Die richtige und sichere Lösung ohne gewaltsames Auspacken unter Swift 2.2 und vor 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
}

Hier ist meine 2-Cent-Antwort, die auf der akzeptierten Antwort aufbaut, aber auch die neuere API unterstützt. Hinweis: Ich verwende den Gregorianischen Kalender, da die meisten Zeitstempel GMT sind, aber ändern Sie Ihren nach Belieben

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
}

Meine Lösung besteht darin, zu berechnen, wie viele Tage seit 1970 nach Division vergangen sind, und den ganzzahligen Teil zu vergleichen

#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);
}

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;  
}