Wie Sie feststellen, ob ein NSDate heute?

Question

Wie kann man überprüfen, ob ein NSDate bis heute gehört?

Ich benutzte es, um zu überprüfen ersten 10 Zeichen von [aDate description] verwenden. [[aDate description] substringToIndex:10] kehrt String wie "YYYY-MM-DD" so dass ich die Zeichenfolge mit der Zeichenfolge verglichen mit [[[NSDate date] description] substringToIndex:10] zurückgegeben.

Gibt es mehr schnell und / oder nette Art und Weise zu überprüfen?

Danke.

Answer 1

In macOS 10.9+ & iOS 8+, gibt es eine Methode auf NSCalendar / Kalender, der tut genau dies!

- (BOOL)isDateInToday:(NSDate *)date 

So würden Sie tun einfach

Objective-C:

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

Swift 3:

let today = Calendar.current.isDateInToday(date)

Answer 2

Sie können Datum Komponenten 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
}

Edit:

I wie stefan Methode mehr, ich denke, es macht für eine sauberere und verständlich, wenn 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 Ihren Vorschlag aufgenommen. Ich musste sehen, was Zeit war, so dass für alle anderen, die nicht weiß, es zwischen BC und AD unterscheidet. Dies ist wahrscheinlich nicht notwendig für die meisten Menschen, aber es ist leicht zu überprüfen und fügt eine gewisse Sicherheit, so dass ich es aufgenommen haben. Wenn Sie Geschwindigkeit gehen, ist dies wahrscheinlich nicht eine gute Methode sowieso.

---

Hinweis wie bei vielen Antworten auf SO, nach 7 Jahren ist dies völlig veraltet. In Swift verwenden jetzt nur .isDateInToday

Answer 3

Dies ist ein Ableger auf Ihre Frage, aber wenn Sie ein NSDate mit „Today“ drucken möchten oder „Yesterday“, verwenden Sie die Funktion

- (void)setDoesRelativeDateFormatting:(BOOL)b

für NSDateFormatter

Answer 4

Ich würde versuchen, das heutige Datum normalisiert bis Mitternacht und dem zweiten Zeitpunkt zu erhalten, zu normalisieren, um Mitternacht dann vergleichen, wenn sie die gleiche NSDate ist.

Von ein Apple Beispiel hier, wie Sie normalisieren bis heute ist Mitternacht heute, tun das gleiche für das zweite Datum und vergleichen:

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

Answer 5

Arbeiten Swift 3 & 4 Erweiterung der Vorschlag von Catfish_Man:

extension Date {

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

}

Answer 6

Keine Notwendigkeit, jonglieren mit Komponenten, Epochen und -material.

NSCalendar ein Verfahren stellt den Beginn einer bestimmten Zeiteinheit für ein bestehendes Datum zu erhalten.

Dieser Code wird den Beginn von heute bekommen und einem anderen Datum und vergleichen Sie das. Wenn es NSOrderedSame auswertet, beiden Termine sind am selben Tag -. So 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
}

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

Für mich arbeiten auf Swift 2.0

Answer 8

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

Answer 9

Siehe Apples Dokumentation Eintrag Titel "Performing Kalender Berechnungen" [link] .

13 Eintrag auf dieser Seite lässt vermuten, dass die Anzahl der midnights zwischen den Tagen, um zu bestimmen, verwenden Sie:

- (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 bestimmen, ob 2 Tage gleich sind, indem diese Methode verwenden und sehen, ob es 0 zurück oder nicht.

Answer 10

Sie können auch das Zeitintervall zwischen dem Zeitpunkt, überprüfen Sie haben, und das aktuelle Datum:

[myDate timeIntervalSinceNow]

Dies gibt Ihnen das Zeitintervall in Sekunden zwischen myDate und der aktuellen Datum / Uhrzeit.

Link .

Edit: Hinweis an alle:. Ich bin mir bewusst, dass [myDate timeIntervalSinceNow] nicht eindeutig bestimmen, ob myDate heute

Ich verlasse diese Antwort als ist, so dass, wenn jemand sucht nach etwas ähnlich und [myDate timeIntervalSinceNow] ist nützlich, sie es hier finden.

Answer 11

Swift-Erweiterung auf der Grundlage der 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)
    }
}

Answer 12

Wenn Sie eine Menge dieser Zeitpunkt Vergleiche haben, dann beginnen die Anrufe zu calendar:components:fromDate eine Menge Zeit in Anspruch zu nehmen. Nach einigen Profilierungs ich getan habe, scheinen sie recht teuer zu sein.

sagen Sie zu bestimmen versuchen, welche von einer Reihe von Terminen, sagen sie NSArray *datesToCompare, sind am selben Tag wie ein Tag gegeben, sagt NSDate *baseDate, dann können Sie so etwas wie die folgende (zum Teil aus einer Antwort angepasst oben) verwenden:

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

Answer 13

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
}

Answer 14

Dies ist wahrscheinlich als NSDate Kategorie nachgearbeitet werden könnte, aber ich verwenden:

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

(Vergleicht man jedoch die beiden Datumsstrings wie in der ursprünglichen Frage fast fühlt sich ‚sauberere‘ ..)

Answer 15

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

Answer 16

Schauen Sie sich unseren Erica Sadun des großen NSDate extension. Sehr einfach zu bedienen. Feines es hier:

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

Es ist schon da in diesem Beitrag: https://stackoverflow.com/a/4052798/362310

Answer 17

Die richtige und sichere Lösung ohne Kraft-auspackt, arbeitet an 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
}

Answer 18

Hier sind meine 2 Cent Antwort Gebäude auf der akzeptierten Antwort, aber die neuere API als auch zu unterstützen. Hinweis: Ich verwende den gregorianischen Kalender, da die meisten Zeitmarken sind GMT aber ändern Sie, wie Sie sehen, passen

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

Meine Lösung ist berechnen, wie viele Tage seit 1970 durch Teilung geführt und vergleichen den ganzzahligen Teil

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