go - milisegundos - microsegundos a nanosegundos
Conversión de time.Duration tipo microsegundos valor a milisegundos (2)
Número a time.Duration
time.Duration es un tipo que tiene int64 como su tipo subyacente , que almacena la duración en nanosegundos.
Si conoce el valor pero desea otros nanosegundos, simplemente multiplique la unidad que desea, por ejemplo:
d := 100 * time.Microsecond
fmt.Println(d) // Output: 100µs
Lo anterior funciona porque 100 es una constant tipo, y se puede convertir automáticamente a tiempo. time.Duration que tiene un tipo subyacente int64 .
Tenga en cuenta que si tiene el valor como un valor escrito, tiene que usar la conversión de tipos explícita:
value := 100 // value is of type int
d2 := time.Duration(value) * time.Millisecond
fmt.Println(d2) // Output: 100ms
time.Duration al número
Así que el tiempo. La time.Duration es siempre los nanosegundos. Por ejemplo, si lo necesita en milisegundos, todo lo que debe hacer es dividir el time.Duration Valor de time.Duration con el número de nanosegundos en milisegundos:
ms := int64(d2 / time.Millisecond)
fmt.Println("ms:", ms) // Output: ms: 100
Otros ejemplos:
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
Prueba los ejemplos en el Go Playground .
Si su fluctuación (duración) es menor que la unidad a la que desea convertirla, necesita usar la división de punto flotante, de lo contrario, se realizará una división entera que corta la parte de la fracción. Para más detalles, ver: Golang Round to Nearest 0.05 .
Convierta tanto el jitter como la unidad a float64 antes de dividir:
d := 61 * time.Microsecond
fmt.Println(d) // Output: 61µs
ms := float64(d) / float64(time.Millisecond)
fmt.Println("ms:", ms) // Output: ms: 0.061
Salida (pruébalo en el Go Playground ):
61µs
ms: 0.061
Estoy utilizando la biblioteca go-ping ( https://github.com/sparrc/go-ping ) de golang para el ping ICMP sin privilegios.
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
Al ejecutar esto, obtengo latencia en milisegundos y fluctuación en microsegundos. Quiero la misma unidad para ambos, digamos milisegundos, así que cuando estoy haciendo jitter = stats.StdDevRtt/1000 o jitter = jitter/1000 (para convertir microsegundos a milisegundos), lo que estoy obteniendo es jitter en nanosegundos :(. ¿Hay alguna manera? para obtener la misma unidad en milisegundos para latencia y fluctuación.
El tipo de latency y las variables de jitter es el tiempo. La time.Duration según la time.Duration su tipo base es int64 y se expresa en nanosegundos.
Cuando utiliza las funciones de impresión, el método de tipo String time.Duration se invoca y utiliza notaciones h , s , m , µ , n al imprimir la duración, aquí está la documentación para String método 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.
Hay algunas time.Duration predefinidas en el paquete de tiempo que puede usar para convertir la variable de duración a su unidad de tiempo preferida, como esto:
latencyInMicroSeconds := int64(jitter / time.Microsecond)
Preste atención a que lo convertimos en un tipo int porque si no lo hace aún estaría en el time.Duration tipo de time.Duration y el valor de ese tipo se considera que está en una unidad nano-segunda, pero ahora es un segundo menor, lo que causa más problemas en los cálculos Si vas a usar las funciones del paquete horario.