iPhone:Comment obtenir des millisecondes?

si vous cherchez à l'utiliser pour le timing relatif (par exemple pour les jeux ou l'animation) je préfère utiliser CACurrentMediaTime ()

double CurrentTime = CACurrentMediaTime();

qui est la méthode recommandée; NSDate tire de l'horloge de synchronisation en réseau et sera parfois hoquet lors de la re-synchronisation contre le réseau.

renvoie le temps absolu courant, en secondes.

si vous souhaitez seulement la partie décimale (souvent utilisé 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 iPad 3 (version construit). CACurrentMediaTime a le moins de frais généraux d'une petite marge. timeIntervalSince1970 est beaucoup plus lent que les autres, probablement en raison de NSDate instanciation overhead, mais il peut ne pas avoir d'importance pour de nombreux cas d'utilisation.

je vous recommande CACurrentMediaTime si vous voulez le moins de frais généraux et que vous voulez bien ajouter 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 son amende de travail 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), quand vous voulez effectuer une évaluation d'intervalle (par exemple, framerate, timing d'un cadre de rendu...):

#include <sys/time.h>
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 les CodeTimestamps, qui fournissent une enveloppe autour des fonctions de synchronisation basées sur mach. Cela vous donne des données de chronométrage à 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, chacun 1000x plus précis que le dernier.) Même si vous n'avez pas besoin de CodeTimestamps, vérifiez le code (c'est open source) pour voir comment ils utilisent mach pour obtenir les données de synchronisation. Ce serait utile quand vous avez besoin de plus précision et je veux un appel de méthode plus rapide que L'approche NSDate.

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

// Timestamp after converting to milliseconds.

NSString * timeInMS = [NSString stringWithFormat:@"%lld", [@(floor([date timeIntervalSince1970] * 1000)) longLongValue]];

j'avais besoin d'un NSNumber objet 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 objet NSDate , la performance n'était pas bonne.

donc pour obtenir le format que la fonction originale me donnait, essayez ceci:

#include <sys/time.h>
struct timeval tv;
gettimeofday(&tv,NULL);
double perciseTimeStamp = tv.tv_sec + tv.tv_usec * 0.000001;

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

CFAbsoluteTimeGetCurrent ()

le temps absolu est mesuré 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 avant. Par exemple, le temps absolu -32940326 est équivalent au 16 décembre 1999 à 17:54:34. Les appels répétés à cette fonction ne garantissent pas des résultats monotones croissants. L'heure du système peut diminuer en raison de la synchronisation avec le temps externe références ou explicite de l'utilisateur changement de l'horloge.

essayez ceci:

NSDate * timestamp = [NSDate dateWithTimeIntervalSince1970:[[NSDate date] timeIntervalSince1970]];

NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
[dateFormatter setDateFormat:@"YYYY-MM-dd HH:mm:ss.SSS"];

NSString *newDateString = [dateFormatter stringFromDate:timestamp];
timestamp = (NSDate*)newDateString;

dans cet exemple, la date du dernier intervalsince1970 est utilisée en combinaison avec le formatter @" AAAA-MM-JJ HH:mm:SS.SSS" qui retourne la date avec l'année, le mois, le jour et l'heure avec les heures, les minutes, les secondes et les millisecondes. Voir l'exemple : "2015-12-02 04:43:15.008". J'ai utilisé le NSString pour être sûr que le format sera déjà écrit.

c'est essentiellement la même réponse que celle Postée par @TristanLorach, juste recodée pour Swift 3:

   /// Method to get Unix-style time (Java variant), i.e., 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)")

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

pour obtenir des millisecondes pour la date courante.

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 voulez pas inclure le cadre de Quartz. Il renvoie 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;
/*** string ***/
NSString *timestampString = [NSString stringWithFormat:@"%ld%03d",digits ,decimalDigits];

utilisant cette méthode:

[[NSDate date] timeIntervalSince1970]*1000;

comme System.currentTimeMillis() en Java;