Conversion du temps. Durée du type microsecondes en millisecondes

Je suis en utilisant aller-ping ( https://github.com/sparrc/go-ping )de la bibliothèque de golang pour les non-privilégiés ping ICMP.

timeout := time.Second*1000
interval := time.Second
count := 5
host := p.ipAddr
pinger, cmdErr := ping.NewPinger(host)

pinger.Count = count
pinger.Interval = interval
pinger.Timeout = timeout
pinger.SetPrivileged(false)
pinger.Run()
stats := pinger.Statistics()

latency = stats.AvgRtt  //stats.AvgRtt is time.Duration type
jitter = stats.StdDevRtt//stats.StdDevRtt is time.Duration type

De l'exécution de cet, je suis de latence en millisecondes et gigue en microsecondes. Je veux la même unité pour les deux disons milliseconde, donc, quand je fais jitter = stats.StdDevRtt/1000 ou jitter = jitter/1000 (pour convertir quelques microsecondes à quelques millisecondes), ce que je reçois est de la gigue en nanosecondes :(. Est-il possible d'obtenir les mêmes unité de millisecondes pour les deux temps de latence et de gigue.

source d'informationauteur supriya

  1. 37

    Nombre de time.Duration

    temps.Durée est un type ayant int64 comme son le type sous-jacentqui stocke la durée, en nanosecondes.

    Si vous connaissez la valeur, mais si vous voulez d'autres que nanosecondes, il suffit de multiplier l'unité que vous souhaitez, par exemple:

    d := 100 * time.Microsecond
fmt.Println(d) //Output: 100µs

    Les travaux ci-dessus parce que 100 est un non constantet il peut être converti automatiquement à time.Duration qui a int64 type sous-jacent.

    Notez que si vous avez de la valeur comme une valeur typée, vous devez utiliser explicite la conversion de type:

    value := 100 //value is of type int

d2 := time.Duration(value) * time.Millisecond
fmt.Println(d2) //Output: 100ms

    time.Duration nombre

    Donc time.Duration est toujours la nanosecondes. Si vous en avez besoin, en millisecondes, par exemple, tout ce que vous devez faire est de diviser le time.Duration de la valeur avec le nombre de nanosecondes en un millième de seconde:

    ms := int64(d2 / time.Millisecond)
fmt.Println("ms:", ms) //Output: ms: 100

    D'autres exemples:

    fmt.Println("ns:", int64(d2/time.Nanosecond))  //ns: 100000000
fmt.Println("µs:", int64(d2/time.Microsecond)) //µs: 100000
fmt.Println("ms:", int64(d2/time.Millisecond)) //ms: 100

    Essayer les exemples sur la Aller De L'Aire De Jeux.

    Si votre gigue (durée) est inférieur à l'unité que vous souhaitez convertir, vous devez utiliser floating point de la division, le reste d'une division entière sera effectué, qui permet de couper la partie fractionnaire. Pour plus de détails voir: Golang Tour la plus Proche de 0,05.

    Convertir à la fois la gigue et de l'unité de float64 avant division:

    d := 61 * time.Microsecond
fmt.Println(d) //Output: 61µs

ms := float64(d) / float64(time.Millisecond)
fmt.Println("ms:", ms) //Output: ms: 0.061

    De sortie (essayez sur la Aller De L'Aire De Jeux):

    61µs
ms: 0.061
  2. 4

    Le type de latency et jitter variables est time.Duration qui par définition sa base est de type int64 et est exprimé dans l'ordre de la nanoseconde.

    Lorsque vous utilisez les fonctions d'impression de la String méthode de type time.Duration est invoquée et l'utilisation hsmµn notations lors de l'impression de la durée, voici la documentation pour String méthode:

    //String returns a string representing the duration in the form "72h3m0.5s".
//Leading zero units are omitted. As a special case, durations less than one
//second format use a smaller unit (milli-, micro-, or nanoseconds) to ensure
//that the leading digit is non-zero. The zero duration formats as 0s.

    Il y a quelques pré-définies constantes dans le temps package que vous pouvez utiliser pour convertir la durée variable de votre choix, unité de temps, comme ceci:

    latencyInMicroSeconds := int64(jitter / time.Microsecond)

    Faire attention à ce que nous nous sommes convertis à un int type, car si vous ne croyez pas qu'il serait encore en time.Duration type et la valeur de ce type est considérée comme un nano seconde unité, mais maintenant, c'est la micro seconde qui causent le plus de problèmes dans les calculs si vous êtes en train d'utiliser des fonctions de package.