Duração do tempo de Golang

O tempo é um fator muito importante para os programadores. Não apenas permite determinar como e quando uma ação é executada, mas nos permite governar quanto tempo uma operação leva e até manter registros de várias atividades no programa.

GO nos fornece o pacote de tempo para lidar com o tempo e a data relacionados. Neste artigo, abordaremos como medir o tempo decorrido entre as duas instâncias.

Tempo.Duração

A duração refere-se ao tempo decorrido entre objetos duas vezes como uma contagem de nanossegundos INT64. Se definirmos a duração para 1000000000 nanossegundos, isso representa 1 segundo ou 1000 milissegundos. A duração máxima que podemos representar (para INT64) é de 290 anos.

A seguir, a definição de sintaxe para a duração no pacote de tempo.

Duração do tipo Int64

As durações definidas no pacote de tempo incluem:

const (
Duração de nanossegundos = 1
Microssegundo = 1000 * nanossegundos
Milissegundo = 1000 * microssegundo
Segundo = 1000 * milissegundos
Minuto = 60 * segundo
Hora = 60 * minuto
)

Observe que os valores acima são constantes.

No pacote de tempo, podemos usar a seguinte função para retornar uma duração:

Tempo.Sub()

A sintaxe da função é como mostrado:

Func (T Time) Sub (U Time) Duração

Retorna a duração T-U.

Tempo.Desde()

A sintaxe para o método desde () é como mostrado:

Func desde (T Hora)

Esta função retorna a duração passada desde T.

Tempo.Até()

A sintaxe é como mostrado:

funcione até a duração (t)

Retorne a duração até t. Pense nisso como uma taquigrafia para o tempo.Sub (tempo.Agora()).

Tempo.Duração

Esta função retorna a duração em nanossegundos. A sintaxe é como mostrado:

func (duração d) milissegundos () int64

Exemplo

O código a seguir ilustra como calcular a duração.

Pacote principal
importação (
"FMT"
"tempo"
)
func main ()
// Defina a duração
Tempo de duração do VAR.Duração = 1000000000
// em horas
fmt.Println (duração.Horas())
// minutos
fmt.Println (duração.Minutos())
// segundos
fmt.Println (duração.Segundos ()))
// milissegundos
fmt.Println (duração.Milissegundos ())
// microssegundos
fmt.Println (duração.Microssegundos ())
// Usando o Sub Method
agora: = tempo.Agora()
tempo.Sono (1000)
diff: = agora.Sub (tempo.Agora())
fmt.Println ("segundos decorridos:", diff.Segundos ()))

Na primeira seção do programa, criamos uma duração e a configuramos como 1000000000 nanossegundos. Em seguida, usamos os métodos do pacote de tempo para convertê -lo em vários formatos.

Na segunda seção, usamos o método sub () para calcular a diferença de horário após uma operação do sono.

O código acima deve retornar:

$ Go Run Duração.ir
0.0002777777777777778
0.016666666666666666
1
1000
1000000
Segundos decorridos: -0.0072517

Conclusão

Este artigo o orienta a trabalhar com durações no idioma go, conforme fornecido pelo pacote de tempo. Para informações adicionais, considere a documentação.