пятница, 24 июля 2020 г.

Пакет time в Golang, методы типа Duration

Метод Hours

func (d Duration) Hours() float64

Hours возвращает продолжительность в виде количества часов числом с плавающей запятой.

Пример использования Hours

package main

import (
    "fmt"
    "time"
)

func main() {
    h, _ := time.ParseDuration("4h30m")
    fmt.Printf("Осталось %.1f часа до полудня.", h.Hours())
}

Вывод:

Осталось 4.5 часа до полудня.

Метод Microseconds

func (d Duration) Microseconds() int64

Microseconds возвращает длительность в виде целого числа микросекунд.

Пример использования Microseconds

package main

import (
    "fmt"
    "time"
)

func main() {
    u, _ := time.ParseDuration("1s")
    fmt.Printf("Одна секунда это %d микросекунд.\n", 
               u.Microseconds())
}

Вывод:

Одна секунда это 1000000 микросекунд.

Метод Milliseconds

func (d Duration) Milliseconds() int64

Milliseconds возвращает длительность в виде целого числа миллисекунд.

Пример использования Milliseconds

package main

import (
    "fmt"
    "time"
)

func main() {
    u, _ := time.ParseDuration("1s")
    fmt.Printf("Одна секунда это %d миллисекунд.\n", 
               u.Microseconds())
}

Вывод:

Одна секунда это 1000 миллисекунд.

Методы Minutes

func (d Duration) Minutes() float64

Minutes возвращает продолжительность в виде количества минут числом с плавающей точкой.

Пример использования Minutes

package main

import (
    "fmt"
    "time"
)

func main() {
    m, _ := time.ParseDuration("1h30m")
    fmt.Printf("Фильм длится %.0f минут.", m.Minutes())
}

Вывод:

Фильм длится 90 минут.

Метод Nanoseconds

func (d Duration) Nanoseconds() int64

Nanoseconds возвращает длительность в виде целого числа наносекунд.

Пример использования Nanoseconds

package main

import (
    "fmt"
    "time"
)

func main() {
    u, _ := time.ParseDuration("1µs")
    fmt.Printf("Одна микросекунда это %d наносекунд.\n", 
               u.Nanoseconds())
}

Вывод:

Одна микросекунда это 1000 наносекунд.

Метод Round (с версии Go 1.9)

func (d Duration) Round(m Duration) Duration

Round возвращает результат округления d до ближайшего кратного m. Поведение при округлении для значений на полпути заключается в округлении от нуля. Если результат превышает максимальное (или минимальное) значение, которое может быть сохранено в Duration, Round возвращает максимальную (или минимальную) продолжительность. Если m <= 0, Round возвращает d без изменений.

Пример использования Round

package main

import (
    "fmt"
    "time"
)

func main() {
    d, err := time.ParseDuration("1h15m30.918273645s")
    if err != nil {
        panic(err)
    }

    round := []time.Duration{
        time.Nanosecond,
        time.Microsecond,
        time.Millisecond,
        time.Second,
        2 * time.Second,
        time.Minute,
        10 * time.Minute,
        time.Hour,
    }

    for _, r := range round {
        fmt.Printf("d.Round(%6s) = %s\n", 
                   r, d.Round(r).String())
    }
}

Вывод:

d.Round(   1ns) = 1h15m30.918273645s
d.Round(   1µs) = 1h15m30.918274s
d.Round(   1ms) = 1h15m30.918s
d.Round(    1s) = 1h15m31s
d.Round(    2s) = 1h15m30s
d.Round(  1m0s) = 1h16m0s
d.Round( 10m0s) = 1h20m0s
d.Round(1h0m0s) = 1h0m0s

Метод Seconds

func (d Duration) Seconds() float64

Seconds возвращает продолжительность в виде количества секунд числом с плавающей запятой.

Пример использования Seconds

package main

import (
    "fmt"
    "time"
)

func main() {
    m, _ := time.ParseDuration("1m30s")
    fmt.Printf("Полторы минуты это %.0f секунд.", 
               m.Seconds())
}

Вывод:

Полторы минуты это 90 секунд.

Метод String

func (d Duration) String() string

String возвращает строку, представляющую продолжительность в форме "72h3m0.5s". Ведущие нулевые элементы опущены. В качестве особого случая для форматов длительностью менее одной секунды используется меньшая единица измерения (милли-, микро- или наносекунды), чтобы гарантировать, что начальная цифра не равна нулю. Нулевая длительность форматируется как 0s.

Пример использования String

package main

import (
    "fmt"
    "time"
)

func main() {
    t1 := time.Date(2016, time.August, 15, 0, 0, 0, 0, time.UTC)
    t2 := time.Date(2017, time.February, 16, 0, 0, 0, 0, time.UTC)
    fmt.Println(t2.Sub(t1).String())
}

Вывод:

4440h0m0s

Метод Truncate (с версии Go 1.9)

func (d Duration) Truncate(m Duration) Duration

Truncate возвращает результат округления d до нуля, кратный m. Если m <= 0, Truncate возвращает d без изменений.

Пример использования Truncate

package main

import (
    "fmt"
    "time"
)

func main() {
    d, err := time.ParseDuration("1h15m30.918273645s")
    if err != nil {
        panic(err)
    }

    trunc := []time.Duration{
        time.Nanosecond,
        time.Microsecond,
        time.Millisecond,
        time.Second,
        2 * time.Second,
        time.Minute,
        10 * time.Minute,
        time.Hour,
    }

    for _, t := range trunc {
        fmt.Printf("d.Truncate(%6s) = %s\n", 
                   t, d.Truncate(t).String())
    }
}

Вывод:

d.Truncate(   1ns) = 1h15m30.918273645s
d.Truncate(   1µs) = 1h15m30.918273s
d.Truncate(   1ms) = 1h15m30.918s
d.Truncate(    1s) = 1h15m30s
d.Truncate(    2s) = 1h15m30s
d.Truncate(  1m0s) = 1h15m0s
d.Truncate( 10m0s) = 1h10m0s
d.Truncate(1h0m0s) = 1h0m0s

Читайте также:


Labels:

Комментариев нет:

Отправить комментарий