Bir NSDate'in bugün olup olmadığını nasıl belirleyebilirim?

NSDateBugünün ait olup olmadığını nasıl kontrol edebilirim ?

İlk 10 karakterini kullanarak kontrol ederdim [aDate description]. [[aDate description] substringToIndex:10]dize "YYYY-MM-DD"tarafından döndürülen dize ile karşılaştırıldığında ben dize döndürür [[[NSDate date] description] substringToIndex:10].

Kontrol etmenin daha hızlı ve / veya temiz bir yolu var mı?

Teşekkürler.

MacOS 10.9+ ve iOS 8+ sürümlerinde NSCalendar / Calendar'da tam olarak bunu yapan bir yöntem vardır!

- (BOOL)isDateInToday:(NSDate *)date 

Yani basitçe yapardın

Objective-C:

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

Hızlı 3:

let today = Calendar.current.isDateInToday(date)

Tarih bileşenlerini karşılaştırabilirsiniz:

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
}

Düzenle:

Stefan'ın yöntemini daha çok seviyorum, daha temiz ve daha anlaşılır bir if ifadesi yapar:

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, önerinizi ekledim. Dönemin ne olduğunu araştırmak zorunda kaldım, bu yüzden bilmeyen herkes için BC ve AD arasında ayrım yapar. Bu muhtemelen çoğu insan için gereksizdir, ancak kontrol edilmesi kolaydır ve biraz kesinlik ekler, bu yüzden dahil ettim. Hız için gidiyorsanız, bu muhtemelen iyi bir yöntem değildir.

NOT SO'daki birçok cevapta olduğu gibi, 7 yıl sonra bu tamamen güncel değil. Swift'te şimdi sadece.isDateInToday

Bu, sorunuzun bir bölümüdür, ancak "Bugün" veya "Dün" ile bir NSDate yazdırmak istiyorsanız, işlevi kullanın

- (void)setDoesRelativeDateFormatting:(BOOL)b

NSDateFormatter için

Bugünün tarihini gece yarısına ve ikinci tarihe normalleştirmeye, gece yarısına normalleşmeye ve aynı NSDate olup olmadığını karşılaştırmaya çalışacağım.

Gönderen bir Apple Örneğin burada ikinci tarih ve karşılaştırmak için nasıl normal hale gece yarısı bugünün tarihine yapmak aynı şey:

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

Catfish_Man tarafından yapılan önerinin çalışma Swift 3 ve 4 uzantısı :

extension Date {

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

}

Bileşenler, dönemler ve diğer şeylerle dengelemeye gerek yok.

NSCalendar, mevcut bir tarih için belirli bir zaman biriminin başlangıcını almak için bir yöntem sağlar.

Bu kod bugünün başlangıcını ve başka bir tarihi alır ve karşılaştırır. Değerlendirilirse NSOrderedSame, her iki tarih de aynı gündür - bugün.

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

Swift 2.0'da benim için çalıştı

En iyi cevabın hızlı versiyonu:

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
}

Apple'ın "Takvim Hesaplamaları Gerçekleştirme" [link] başlıklı belge girişine bakın .

Bu sayfadaki 13 numaralı liste, günler arasındaki gece yarısı sayısını belirlemenizi önerir:

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

Daha sonra, bu yöntemi kullanarak ve 0 döndürüp döndürmediğini görerek iki günün aynı olup olmadığını belirleyebilirsiniz.

Ayrıca, sahip olduğunuz tarih ile geçerli tarih arasındaki zaman aralığını da kontrol edebilirsiniz:

[myDate timeIntervalSinceNow]

Bu, myDate ile geçerli tarih / saat arasındaki zaman aralığını saniye cinsinden verecektir.

bağlantı .

Düzenleme: Not herkese: Ben de [myDate timeIntervalSinceNow] açıkça myDate bugün olup olmadığını belirlemek olmadığını biliyorum.

Birisi benzer bir şey arıyorsa ve [myDate timeIntervalSinceNow] faydalıysa, bu yanıtı bırakıyorum.

En iyi yanıtlara dayalı Swift Uzantısı:

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

Bu tarih karşılaştırmalarının çoğuna sahipseniz, çağrılar calendar:components:fromDateçok zaman almaya başlar. Yaptığım bazı profillemelere göre oldukça pahalı görünüyorlar.

Diyelim ki, belirli bir tarih dizisinden hangilerinin NSArray *datesToComparebelirli bir günle aynı gün olduğunu belirlemeye çalışıyorsunuz , diyelim ki NSDate *baseDate, aşağıdaki gibi bir şey kullanabilirsiniz (yukarıdaki cevaba kısmen uyarlanmış):

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

Çıktı:

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

Yukarıdaki cevapların çoğundan daha kolay bir yolu var!

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

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

Bu muhtemelen bir NSDate kategorisi olarak elden geçirilmiş olabilir, ancak kullandım:

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

(Bununla birlikte, orijinal tarihte olduğu gibi iki tarih dizesini karşılaştırmak neredeyse 'daha temiz' hisseder ..)

iOS7 ve öncesi için:

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

Erica Sadun'umuzu kontrol et NSDate extension. Kullanımı çok basit. Burada gayet iyi:

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

Bu yayında zaten var: https://stackoverflow.com/a/4052798/362310

Zorla açmadan, Swift 2.2 ve iOS 8'den önce çalışan doğru ve güvenli çözüm:

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
}

İşte benim kabul edilen yanıta dayalı, ancak daha yeni API'yı destekleyen 2 sentlik yanıtım. Not: Çoğu zaman damgası GMT olduğu için Gregoryen takvimini kullanıyorum, ancak uygun gördüğünüzde kendinizinkini değiştiriyorum

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
}

Benim çözümüm 1970'den bu yana kaç gün geçtiğini hesaplamak ve tamsayı kısmını karşılaştırmak.

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