web-dev-qa-db-fra.com

Conversion de la valeur en microsecondes du type time.Duration en millisecondes

J'utilise go-ping ( https://github.com/sparrc/go-ping ) bibliothèque de golang pour un ping ICMP non privilégié.

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

En exécutant ceci, j'obtiens une latence en millisecondes et une instabilité en microsecondes. Je veux la même unité pour les deux disons milliseconde alors quand je fais jitter = stats.StdDevRtt/1000 ou jitter = jitter/1000 (pour convertir des microsecondes en millisecondes), ce que j'obtiens est une gigue en nanosecondes :(. Y a-t-il un moyen d'obtenir la même unité en millisecondes pour la latence et la gigue.

gotime
31
supriya

Numéro à time.Duration

time.Duration est un type ayant int64 comme son type sous-jacent , qui stocke la durée en nanosecondes.

Si vous connaissez la valeur mais que vous voulez autre que des nanosecondes, il vous suffit de multiplier l'unité souhaitée, par exemple:

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

Ce qui précède fonctionne parce que 100 est un constante non typé, et il peut être converti automatiquement en time.Duration qui a int64 type sous-jacent.

Notez que si vous avez la valeur sous forme de valeur typée, vous devez utiliser explicit conversion de type :

value := 100 // value is of type int

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

time.Duration au numéro

Alors time.Duration est toujours les nanosecondes. Si vous en avez besoin en millisecondes par exemple, il vous suffit de diviser le time.Duration valeur avec le nombre de nanosecondes en millisecondes:

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

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

Essayez les exemples sur le Go Playground .

Si votre jitter (durée) est inférieur à l'unité que vous souhaitez convertir, vous devez utiliser la division en virgule flottante, sinon une division entière sera effectuée pour couper la partie de fraction. Pour plus de détails, voir: arrondi de Golang à 0,05 près .

Convertit la gigue et l’unité en float64 avant de diviser:

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

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

Sortie (essayez-le sur le Go Playground ):

61µs
ms: 0.061
83
icza

Le type de variables latency et jitter est time.Duration qui, par définition , son type de base est int64 et est exprimé en nanoseconde.

Lorsque vous utilisez les fonctions d’impression, la méthode String ‍‍‍‍ of de type time.Duration est appelé et utilise h, s, m, µ, n notations lors de l’impression de la durée, voici la documentation pour la méthode String:

// 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 paquets constantes in prédéfinis que vous pouvez utiliser pour convertir la variable de durée en votre unité de temps préférée, comme ceci:

latencyInMicroSeconds := int64(jitter / time.Microsecond)

Faites attention à ce que nous l'ayons converti en un type int car sinon, il serait toujours en time.Duration type et la valeur de ce type sont considérées comme étant en nanosecondes, mais c’est maintenant la micro-seconde, ce qui pose un problème supplémentaire dans les calculs si vous souhaitez utiliser les fonctions de package temporel.

4
sepehr