Comment comparer deux NSDates: Qui est la plus récente?

Je suis en train de réaliser un dropBox sync et de la nécessité de comparer les dates des deux fichiers. L'un est sur mon compte dropBox et est sur mon iPhone.

Je suis venu avec la suite, mais j'obtiens des résultats inattendus. Je suppose que je suis en train de faire quelque chose de fondamentalement mauvais lorsque l'on compare les deux dates. J'ai simplement utilisé le > < les opérateurs, mais je suppose que ce n'est pas bon comme je suis de la comparaison de deux NSDate cordes. Nous y voilà:

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.");
}

Cela m'a donné la suivante (random & faux) sortie:

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.

ou ce qui arrive à être correct:

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.

Doublons: 1 2 3 4 5 6 &c.
si c'est un vrai doublon, pourquoi ne pas les fusionner? Vous l'avez fait avant...
Seul le diamant modérateurs peuvent effectuer une opération de fusion, @Yar.

InformationsquelleAutor n.evermind | 2011-05-11

646

Supposons deux dates:
```
NSDate *date1;
NSDate *date2;
```
Puis la comparaison suivante sera de dire qui est plus tôt/tard/même:
```
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");
}
```
Veuillez vous référer à la NSDate de documentation de classe pour plus de détails.
- Très joli! Beats vous embêter avec [date1 earlierDate:date2] etc... Merci - pour une raison que je n'avais jamais pensé à l'utiliser de comparer: avant.
- J'aime me reposer sur le fait que NSOrderedAscending < 0 et NSOrderedDescending > 0. Qui rend la comparaison plus facile à lire: [date1 comparer:date2] < 0 /* date1 < date2 */ et évite l' (facile à faire) erreur @albertamg souligné. 😉
- Bien que la méthode de comparaison est sujet aux erreurs comme tout-en-un d'erreurs. Ainsi, vous devez utiliser (NSDate *)laterDate:(NSDate *)anotherDate qui sera de retour à la date ultérieure de deux. il vous suffit de le comparer votre résultat prévu et vous avez terminé! Pas de bidouiller avec "Waaait descendant / ascendant ?!"
- Que foiré m'ainsi, il semble qu'Apple veut que vous pensez du résultat que date1 -> date2 est l'ordre croissant/décroissant (et donc date1 est postérieure ou antérieure, respectivement).
- c'est une manière plus abstraite, sans numéros de magie(-1,0,1) pour les algorithmes de tri pour mettre les éléments dans l'ordre. Vous pouvez également redéfinir ces constantes de vous-même avec un plus un nom lisible. Ma réponse est en train de faire le travail, mais n'est pas le gagnant de la récompense de code lisible. Faites défiler vers le bas, il y a d'autres bons.
- Ces est un problème grave avec ce que j'ai trouvé aujourd'hui, si vous comparez les deux mêmes dates, mais avec des temps différents, les résultats varient, e.g Si je compare la date d'aujourd'hui '2017-03-27 14:26:38 +0000' avec '2017-03-27 10:16:14 +0000' pour NSOrderedDescending le résultat sera VRAI, alors que si je compare aujourd'hui les dates de l''2017-03-27 00:00:01 +0000' avec '2017-03-27 10:07:29 +0000' le résultat sera FAUX. Ne pas dire la réponse est fausse, mais pour quelqu'un qui veut comparer simplement les dates, cela ne devrait pas être utilisé.
- NSDate objets encapsulent un seul point dans le temps.
InformationsquelleAutor Nick Weaver
48

La fin de la partie, mais un autre moyen facile de comparer NSDate objets est de les convertir dans le type primitif qui permet l'utilisation facile de "> ""< "'= = ' etc

par exemple.
```
if ([dateA timeIntervalSinceReferenceDate] > [dateB timeIntervalSinceReferenceDate]) {
    //do stuff
}
```
timeIntervalSinceReferenceDate convertit la date en secondes depuis la date de référence (1er janvier 2001, GMT). Comme timeIntervalSinceReferenceDate renvoie une NSTimeInterval (qui est un double typedef), nous pouvons utiliser les primitives de comparaison.
- Un peu plus intuitive que (NSComparisonResult)compare:(NSDate *) mais toujours assez détaillées pour cette simple opération... (comme d'habitude)
- pouvez également faire [dateA timeIntervalSinceDate:dateB] > 0
InformationsquelleAutor So Over It
14

Dans Swift, vous pouvez surcharger les opérateurs existants:
```
func > (lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs.timeIntervalSinceReferenceDate > rhs.timeIntervalSinceReferenceDate
}

func < (lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs.timeIntervalSinceReferenceDate < rhs.timeIntervalSinceReferenceDate
}
```
Ensuite, vous pouvez comparer NSDates directement avec <, >, et == (déjà pris en charge).
- Si j'essaie de faire une extension de cela, je reçois "les Opérateurs sont uniquement autorisés à portée globale", des suggestions?
- vous ne pouvez pas le mettre à l'intérieur d'une extension. Je l'avais mis dans le même fichier que l'extension, mais en dehors de la { ... }
InformationsquelleAutor Andrew
13

NSDate a une fonction de comparaison.

compare: Retourne un NSComparisonResult valeur qui indique l'ordre temporel du récepteur et l'autre date donnée.
```
(NSComparisonResult)compare:(NSDate *)anotherDate
```
Paramètres: anotherDate
La date à laquelle comparer le récepteur.
Cette valeur ne doit pas être nul. Si la valeur est nulle, le comportement est indéfini, et peut changer dans les futures versions de Mac OS X.

Valeur De Retour:
- Si le récepteur et anotherDate sont exactement égaux les uns aux autres, NSOrderedSame
- Si le récepteur est plus tard dans le temps que anotherDate, NSOrderedDescending
- Si le récepteur est plus tôt que le anotherDate, NSOrderedAscending.
- est-il un moyen de comparer deux NSDate les objets dont seule la composante temporelle est différente? Pour quelque raison, la méthode ci-dessus ne fonctionne pas.
InformationsquelleAutor Gary
12

Vous souhaitez utiliser le NSDate comparer:, laterDate:, earlierDate: ou isEqualToDate: méthodes. En utilisant le < et > les opérateurs dans cette situation est de comparer les pointeurs, pas les dates

InformationsquelleAutor Dan F
11
```
- (NSDate *)earlierDate:(NSDate *)anotherDate
```
Renvoie le plus tôt du récepteur et anotherDate. Si les deux sont les mêmes, le récepteur est retourné.
- Notez que la sauvegarde de l'objet de la NSDates peut être optimisé sur les versions 64 bits de votre code compilé telles que les dates qui représentent le même temps, ont la même adresse. Ainsi, si cDate = [aDate earlierDate:bDate] puis cDate == aDate et cDate == bDate peut à la fois être vrai. Trouvé ce faire certains travaux sur iOS 8.
- À l'inverse, sur les plates-formes 32 bit, si les dates ne sont pas les mêmes, -earlierDate: (et -laterDate:) peut retourner ni le récepteur, ni l'argument.
InformationsquelleAutor

Certains datent de services publics, y compris des comparaisons EN ANGLAIS, ce qui est agréable:

#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 mise en œuvre:

#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

Ou simplement l'utiliser: github.com/erica/NSDate-Extensions
Veuillez noter: Si la date est nul comparer n'est pas défini

InformationsquelleAutor Dan Rosenstark

6

Vous devez utiliser :
```
- (NSComparisonResult)compare:(NSDate *)anotherDate
```
de comparer des dates. Il n'y a pas de surcharge d'opérateur en objective C.

InformationsquelleAutor Joris Mans
6

Pourquoi ne pas vous les gars utiliser ces NSDate comparer les méthodes:
```
- (NSDate *)earlierDate:(NSDate *)anotherDate;
- (NSDate *)laterDate:(NSDate *)anotherDate;
```
InformationsquelleAutor justicepenny
4

J'ai rencontre presque la même situation, mais dans mon cas, je suis de vérifier si le nombre de jours de différence
```
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.
```
Utile lorsque vous avez besoin de comparer NSDate dans les Jours/Mois/Année unité
- NSDayCalendarUnit est obsolète donc de l'utiliser au lieu NSCalendarUnitDay
InformationsquelleAutor Andy

Vous pouvez comparer les deux de la date, par cette méthode, également

        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;

        }

InformationsquelleAutor kapil

Je l'ai essayé, j'espère que ça fonctionne pour vous

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

InformationsquelleAutor Concept Infoway

Utiliser cette fonction pour la date de comparaison

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

InformationsquelleAutor Akhtar

Vous devez vous connecter pour publier un commentaire.