Cómo comparar dos NSDates: ¿Cuál es más reciente?

Estoy tratando de lograr una sincronización dropBox y necesito comparar las fechas de dos archivos. Uno está en mi cuenta de dropBox y el otro está en mi iPhone.

Se me ocurrió lo siguiente, pero obtengo resultados inesperados. Supongo que estoy haciendo algo fundamentalmente incorrecto al comparar las dos fechas. Simplemente usé los operadores> <, pero supongo que esto no es bueno ya que estoy comparando dos cadenas NSDate. Aquí vamos:

NSLog(@"dB...lastModified: %@", dbObject.lastModifiedDate); 
NSLog(@"iP...lastModified: %@", [self getDateOfLocalFile:@"NoteBook.txt"]);

if ([dbObject lastModifiedDate] < [self getDateOfLocalFile:@"NoteBook.txt"]) {
    NSLog(@"...db is more up-to-date. Download in progress...");
    [self DBdownload:@"NoteBook.txt"];
    NSLog(@"Download complete.");
} else {
    NSLog(@"...iP is more up-to-date. Upload in progress...");
    [self DBupload:@"NoteBook.txt"];
    NSLog(@"Upload complete.");
}

Esto me dio el siguiente resultado (aleatorio e incorrecto):

2011-05-11 14:20:54.413 NotePage[6918:207] dB...lastModified: 2011-05-11 13:18:25 +0000
2011-05-11 14:20:54.414 NotePage[6918:207] iP...lastModified: 2011-05-11 13:20:48 +0000
2011-05-11 14:20:54.415 NotePage[6918:207] ...db is more up-to-date.

o este que resulta ser correcto:

2011-05-11 14:20:25.097 NotePage[6903:207] dB...lastModified: 2011-05-11 13:18:25 +0000
2011-05-11 14:20:25.098 NotePage[6903:207] iP...lastModified: 2011-05-11 13:19:45 +0000
2011-05-11 14:20:25.099 NotePage[6903:207] ...iP is more up-to-date.

Asumamos dos fechas:

NSDate *date1;
NSDate *date2;

Entonces la siguiente comparación dirá cuál es anterior / posterior / igual:

if ([date1 compare:date2] == NSOrderedDescending) {
    NSLog(@"date1 is later than date2");
} else if ([date1 compare:date2] == NSOrderedAscending) {
    NSLog(@"date1 is earlier than date2");
} else {
    NSLog(@"dates are the same");
}

Consulte la documentación de la clase NSDate para obtener más detalles.

Tarde a la fiesta, pero otra forma fácil de comparar objetos NSDate es convertirlos en tipos primitivos que permitan un uso fácil de '>' '<' '==' etc.

p.ej.

if ([dateA timeIntervalSinceReferenceDate] > [dateB timeIntervalSinceReferenceDate]) {
    //do stuff
}

timeIntervalSinceReferenceDateconvierte la fecha en segundos desde la fecha de referencia (1 de enero de 2001, GMT). Como timeIntervalSinceReferenceDatedevuelve un NSTimeInterval (que es un typedef doble), podemos usar comparadores primitivos.

En Swift, puede sobrecargar los operadores existentes:

func > (lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs.timeIntervalSinceReferenceDate > rhs.timeIntervalSinceReferenceDate
}

func < (lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs.timeIntervalSinceReferenceDate < rhs.timeIntervalSinceReferenceDate
}

A continuación, puede comparar directamente con NSDates <, >y ==(ya es compatible).

NSDate Tiene una función de comparación.

compare:Devuelve un NSComparisonResultvalor que indica el orden temporal del receptor y otra fecha dada.

(NSComparisonResult)compare:(NSDate *)anotherDate

Parámetros : anotherDate la fecha con la que se compara el receptor. Este valor no debe ser nulo. Si el valor es nulo, el comportamiento es indefinido y puede cambiar en futuras versiones de Mac OS X.

Valor de retorno:

• Si el receptor y otro DateDate son exactamente iguales entre sí, NSOrderedSame
• Si el receptor llega más tarde que otroDate, NSOrderedDescending
• Si el receptor es anterior en el tiempo que anotherDate, NSOrderedAscending.

Desea utilizar la comparación NSDate :, laterDate :, beforeDate :, o isEqualToDate: métodos. Usar los operadores <y> en esta situación es comparar los punteros, no las fechas

- (NSDate *)earlierDate:(NSDate *)anotherDate

Esto devuelve el anterior del receptor y otroDate. Si ambos son iguales, se devuelve el receptor.

Algunas utilidades de fechas, incluidas las comparaciones EN INGLÉS, lo cual es bueno:

#import <Foundation/Foundation.h>


@interface NSDate (Util)

-(BOOL) isLaterThanOrEqualTo:(NSDate*)date;
-(BOOL) isEarlierThanOrEqualTo:(NSDate*)date;
-(BOOL) isLaterThan:(NSDate*)date;
-(BOOL) isEarlierThan:(NSDate*)date;
- (NSDate*) dateByAddingDays:(int)days;

@end

La implementación:

#import "NSDate+Util.h"


@implementation NSDate (Util)

-(BOOL) isLaterThanOrEqualTo:(NSDate*)date {
    return !([self compare:date] == NSOrderedAscending);
}

-(BOOL) isEarlierThanOrEqualTo:(NSDate*)date {
    return !([self compare:date] == NSOrderedDescending);
}
-(BOOL) isLaterThan:(NSDate*)date {
    return ([self compare:date] == NSOrderedDescending);

}
-(BOOL) isEarlierThan:(NSDate*)date {
    return ([self compare:date] == NSOrderedAscending);
}

- (NSDate *) dateByAddingDays:(int)days {
    NSDate *retVal;
    NSDateComponents *components = [[NSDateComponents alloc] init];
    [components setDay:days];

    NSCalendar *gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];
    retVal = [gregorian dateByAddingComponents:components toDate:self options:0];
    return retVal;
}

@end

Deberías usar :

- (NSComparisonResult)compare:(NSDate *)anotherDate

para comparar fechas. No hay sobrecarga del operador en el objetivo C.

¿Por qué no usan estos NSDatemétodos de comparación?

- (NSDate *)earlierDate:(NSDate *)anotherDate;
- (NSDate *)laterDate:(NSDate *)anotherDate;

Me he encontrado con casi la misma situación, pero en mi caso estoy verificando si el número de días es diferente

NSCalendar *cal = [NSCalendar currentCalendar];
NSDateComponents *compDate = [cal components:NSDayCalendarUnit fromDate:fDate toDate:tDate options:0];
int numbersOfDaysDiff = [compDate day]+1; // do what ever comparison logic with this int.

Útil cuando necesita comparar NSDate en días / mes / año

Puedes comparar dos fechas por este método también

        switch ([currenttimestr  compare:endtimestr])
        {
            case NSOrderedAscending:

                // dateOne is earlier in time than dateTwo
                break;

            case NSOrderedSame:

                // The dates are the same
                break;
            case NSOrderedDescending:

                // dateOne is later in time than dateTwo


                break;

        }

Lo he intentado espero que funcione para ti

NSCalendar *gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];      
int unitFlags =NSDayCalendarUnit;      
NSDateFormatter *dateFormatter = [[[NSDateFormatter alloc] init] autorelease];     
NSDate *myDate; //= [[NSDate alloc] init];     
[dateFormatter setDateFormat:@"dd-MM-yyyy"];   
myDate = [dateFormatter dateFromString:self.strPrevioisDate];     
NSDateComponents *comps = [gregorian components:unitFlags fromDate:myDate toDate:[NSDate date] options:0];   
NSInteger day=[comps day];

Use esta función simple para comparar fechas

-(BOOL)dateComparision:(NSDate*)date1 andDate2:(NSDate*)date2{

BOOL isTokonValid;

if ([date1 compare:date2] == NSOrderedDescending) {
    NSLog(@"date1 is later than date2");
    isTokonValid = YES;
} else if ([date1 compare:date2] == NSOrderedAscending) {
    NSLog(@"date1 is earlier than date2");
    isTokonValid = NO;
} else {
    isTokonValid = NO;
    NSLog(@"dates are the same");
}

return isTokonValid;}