iPhone: comment obtenir les millisecondes actuelles?

Quelle est la meilleure façon d’obtenir les millisecondes de l’heure système actuelle?

[[NSDate date] timeIntervalSince1970]; 

Il renvoie le nombre de secondes depuis l’époque en double. Je suis presque sûr que vous pouvez accéder aux millisecondes de la partie fractionnaire.

Si vous envisagez d’utiliser ceci pour un timing relatif (par exemple pour les jeux ou l’animation), je préfère utiliser CACurrentMediaTime ()

 double CurrentTime = CACurrentMediaTime(); 

Quelle est la manière recommandée? NSDate s’inspire de l’horloge de synchronisation en réseau et se heurtera occasionnellement à une nouvelle synchronisation avec le réseau.

Il renvoie le temps absolu actuel, en secondes.


Si vous ne voulez que la partie décimale (souvent utilisée lors de la synchronisation des animations),

 let ct = CACurrentMediaTime().truncatingRemainder(dividingBy: 1) 

J’ai comparé toutes les autres réponses sur un iPhone 4S et un iPad 3 (versions compilées). CACurrentMediaTime a le moins de charge par une petite marge. timeIntervalSince1970 est beaucoup plus lent que les autres, probablement en raison de la NSDate instanciation NSDate , même si cela peut ne pas être important pour de nombreux cas d’utilisation.

Je recommande CACurrentMediaTime si vous voulez le moins possible et que cela ne vous dérange pas d’append la dépendance Quartz Framework. Ou gettimeofday si la portabilité est une priorité pour vous.

iphone 4s

 CACurrentMediaTime: 1.33 µs/call gettimeofday: 1.38 µs/call [NSDate timeIntervalSinceReferenceDate]: 1.45 µs/call CFAbsoluteTimeGetCurrent: 1.48 µs/call [[NSDate date] timeIntervalSince1970]: 4.93 µs/call 

iPad 3

 CACurrentMediaTime: 1.25 µs/call gettimeofday: 1.33 µs/call CFAbsoluteTimeGetCurrent: 1.34 µs/call [NSDate timeIntervalSinceReferenceDate]: 1.37 µs/call [[NSDate date] timeIntervalSince1970]: 3.47 µs/call 

Dans Swift nous pouvons faire une fonction et faire comme suit

 func getCurrentMillis()->Int64{ return Int64(NSDate().timeIntervalSince1970 * 1000) } var currentTime = getCurrentMillis() 

Bien que cela fonctionne bien dans Swift 3.0 mais nous pouvons modifier et utiliser la classe Date au lieu de NSDate dans 3.0

Swift 3.0

 func getCurrentMillis()->Int64 { return Int64(Date().timeIntervalSince1970 * 1000) } var currentTime = getCurrentMillis() 

Jusqu’à présent, j’ai trouvé gettimeofday une bonne solution sur iOS (iPad), lorsque vous souhaitez effectuer une évaluation d’intervalle (par exemple, framerate, synchronisation d’un cadre de rendu …):

 #include  struct timeval time; gettimeofday(&time, NULL); long millis = (time.tv_sec * 1000) + (time.tv_usec / 1000); 

Swift 2

 let seconds = NSDate().timeIntervalSince1970 let milliseconds = seconds * 1000.0 

Swift 3

 let currentTimeInMiliseconds = Date().timeIntervalSince1970.milliseconds 

Il peut être utile de connaître CodeTimestamps, qui fournit une enveloppe autour des fonctions de synchronisation basées sur les mach. Cela vous donne des données temporelles de résolution nanoseconde – 1000000x plus précises que des millisecondes. Oui, un million de fois plus précis. (Les préfixes sont milli, micro, nano, chaque 1000 fois plus précis que le précédent.) Même si vous n’avez pas besoin de CodeTimestamps, consultez le code (open source) pour voir comment utiliser mach pour obtenir les données de synchronisation. Cela serait utile lorsque vous avez besoin de plus de précision et que vous souhaitez un appel de méthode plus rapide que l’approche NSDate.

http://fra.pulse.me/line-by-line-speed-analysis-for-ios-apps/

 // Timestamp after converting to milliseconds. NSSsortingng * timeInMS = [NSSsortingng ssortingngWithFormat:@"%lld", [@(floor([date timeIntervalSince1970] * 1000)) longLongValue]]; 

J’avais besoin d’un object NSNumber contenant le résultat exact de [[NSDate date] timeIntervalSince1970] . Comme cette fonction a été appelée plusieurs fois et que je n’avais pas vraiment besoin de créer un object NSDate , les performances n’étaient pas très bonnes.

Donc, pour obtenir le format que la fonction d’origine me donnait, essayez ceci:

 #include  struct timeval tv; gettimeofday(&tv,NULL); double perciseTimeStamp = tv.tv_sec + tv.tv_usec * 0.000001; 

Ce qui devrait vous donner exactement le même résultat que [[NSDate date] timeIntervalSince1970]

CFAbsoluteTimeGetCurrent ()

La durée absolue est mesurée en secondes par rapport à la date de référence absolue du 1er janvier 2001 à 00:00:00 GMT. Une valeur positive représente une date après la date de référence, une valeur négative représente une date antérieure à celle-ci. Par exemple, l’heure absolue -32940326 équivaut au 16 décembre 1999 à 17:54:34. Les appels répétés à cette fonction ne garantissent pas des résultats monotoniquement croissants. L’heure du système peut diminuer en raison de la synchronisation avec des références de temps externes ou en raison d’un changement d’utilisateur explicite de l’horloge.

Essaye ça :

 NSDate * timestamp = [NSDate dateWithTimeIntervalSince1970:[[NSDate date] timeIntervalSince1970]]; NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init]; [dateFormatter setDateFormat:@"YYYY-MM-dd HH:mm:ss.SSS"]; NSSsortingng *newDateSsortingng = [dateFormatter ssortingngFromDate:timestamp]; timestamp = (NSDate*)newDateSsortingng; 

Dans cet exemple, dateWithTimeIntervalSince1970 est utilisé en combinaison avec le formateur @ “AAAA-MM-jj HH: mm: ss.SSS” qui renverra la date avec l’année, le mois, le jour et l’heure avec heures, minutes, secondes et millisecondes . Voir l’exemple: “2015-12-02 04: 43: 15.008”. J’ai utilisé NSSsortingng pour être sûr que le format sera écrit avant.

C’est fondamentalement la même réponse que celle postée par @TristanLorach, qui vient d’être enregistrée pour Swift 3:

  /// Method to get Unix-style time (Java variant), ie, time since 1970 in milliseconds. This /// copied from here: http://stackoverflow.com/a/24655601/253938 and here: /// http://stackoverflow.com/a/7885923/253938 /// (This should give good performance according to this: /// http://stackoverflow.com/a/12020300/253938 ) /// /// Note that it is possible that multiple calls to this method and computing the difference may /// occasionally give problematic results, like an apparently negative interval or a major jump /// forward in time. This is because system time occasionally gets updated due to synchronization /// with a time source on the network (maybe "leap second"), or user setting the clock. public static func currentTimeMillis() -> Int64 { var darwinTime : timeval = timeval(tv_sec: 0, tv_usec: 0) gettimeofday(&darwinTime, nil) return (Int64(darwinTime.tv_sec) * 1000) + Int64(darwinTime.tv_usec / 1000) } 
  func currentmicrotimeTimeMillis() -> Int64{ let nowDoublevaluseis = NSDate().timeIntervalSince1970 return Int64(nowDoublevaluseis*1000) 

}

C’est ce que j’ai utilisé pour Swift

 var date = NSDate() let currentTime = Int64(date.timeIntervalSince1970 * 1000) print("Time in milliseconds is \(currentTime)") 

utilisé ce site pour vérifier l’exactitude http://currentmillis.com/

Pour obtenir des millisecondes pour la date actuelle.

Swift 4:

 func currentTimeInMilliSeconds()-> Int { let currentDate = Date() let since1970 = currentDate.timeIntervalSince1970 return Int(since1970 * 1000) } 

[NSDate timeIntervalSinceReferenceDate] est une autre option si vous ne souhaitez pas inclure le framework Quartz. Il retourne un double, représentant les secondes.

 NSTimeInterval time = ([[NSDate date] timeIntervalSince1970]); //double long digits = (long)time; //first 10 digits int decimalDigits = (int)(fmod(time, 1) * 1000); //3 missing digits /*** long ***/ long timestamp = (digits * 1000) + decimalDigits; /*** ssortingng ***/ NSSsortingng *timestampSsortingng = [NSSsortingng ssortingngWithFormat:@"%ld%03d",digits ,decimalDigits]; 

En utilisant cette méthode:

 [[NSDate date] timeIntervalSince1970]*1000; 

Il aime System.currentTimeMillis() en Java;