time

Le package time fournit des fonctions et méthodes liées au temps et au calendrier.

La fonction time.Now() permet d'obtenir l'heure actuelle

func Now() Time

now := time.Now()
fmt.Println(now)
//2022-11-17 10:00:18.6983438 +0800 CST m=+0.007095001

Le type de données retourné est la structure Time, qui possède de nombreuses méthodes de manipulation du temps.

func (t *Time) nsec() int32 //nanosecondes

func (t *Time) sec() int64 //secondes

func (t *Time) unixSec() //retourne les secondes au format Unix

func (t *Time) addSec(d int64) //ajoute des secondes

func (t *Time) setLoc(loc *Location) //définit la localisation

func (t *Time) stripMono() //supprime la lecture de l'horloge monotone du temps

func (t Time) After(u Time) //vérifie si un temps est après un autre

func (t Time) Before(u Time) bool //vérifie si un temps est avant un autre

func (t Time) Equal(u Time) bool //vérifie si deux temps représentent le même instant

func (t Time) Sub(u Time) Duration //calcule la différence entre deux temps

func (t Time) Add(d Duration) Time //ajoute un intervalle de temps

Unités de temps

Le package time stocke des constantes d'unités de temps de base

const (
  minDuration Duration = -1 << 63
  maxDuration Duration = 1<<63 - 1
)

const (
  Nanosecond  Duration = 1
  Microsecond          = 1000 * Nanosecond
  Millisecond          = 1000 * Microsecond
  Second               = 1000 * Millisecond
  Minute               = 60 * Second
  Hour                 = 60 * Minute
)

Leur type est time.Duration, l'unité la plus petite est la nanoseconde, la plus grande est l'heure.

Formatage

Le type temps peut être formaté pour la sortie. Cependant, il faut noter qu'en Go, le modèle de formatage n'est pas le classique yyyy-mm-dd, mais utilise le temps de naissance de Go comme modèle. L'heure de naissance de Go est le 2 janvier 2006 à 15h04.

Exemple

now := time.Now()

Formatage de sortie 24 heures

fmt.Println(now.Format("2006-01-02 15:04:05 Monday Jan"))
//2022-11-17 10:44:48 Thursday Nov

Sortie de la date uniquement

fmt.Println(now.Format("2006-01-02"))
//2022-11-17

Sortie de l'heure en format 12 heures uniquement

fmt.Println(now.Format("15:04:05 PM"))
//10:48:47 AM

Analyse de temps

Nous avons souvent besoin de convertir une chaîne de temps en une structure de temps Go selon un certain format. C'est ce que nous allons faire maintenant.

func main() {
   location, err := time.LoadLocation("Asia/Shanghai")
   if err != nil {
      fmt.Println(err)
      return
   }

   inLocation, err := time.ParseInLocation("2006/01/02", "2012/10/12", location)
   if err != nil {
      fmt.Println(err)
      return
   }
   fmt.Println(inLocation.String())
}

Sortie finale

2012-10-12 00:00:00 +0800 CST

Timer

Timer est un minuteur qui expose un channel. Quand le temps spécifié est écoulé, le channel reçoit un message et se ferme.

func NewTimer(d Duration) *Timer

On peut créer un nouveau minuteur avec time.NewTimer()

func main() {
  timer := time.NewTimer(time.Second)
  defer timer.Stop()
  select {
  case t := <-timer.C:
    fmt.Println(t)
  }
}

2023-09-25 21:25:03.5696803 +0800 CST m=+1.007908001

Après avoir utilisé le timer, il faut le fermer en temps utile.

Ticker

Ticker est un minuteur répétitif. La différence avec timer est que timer est unique, tandis que Ticker se déclenche à intervalles réguliers.

func NewTicker(d Duration) *Ticker

On peut créer un nouveau ticker avec time.NewTicker()

func main() {
  ticker := time.NewTicker(time.Second)
  defer ticker.Stop()
  for i := 0; i < 3; i++ {
    select {
    case t := <-ticker.C:
      fmt.Println(t)
    }
  }
}

2023-09-25 21:29:20.4429256 +0800 CST m=+1.009508401
2023-09-25 21:29:21.4512075 +0800 CST m=+2.017790301
2023-09-25 21:29:22.4501592 +0800 CST m=+3.016742001

De même, après avoir utilisé le ticker, il faut le fermer en temps utile.

sleep

time.Sleep() peut mettre la goroutine actuelle en état de suspension pendant un certain temps. Pendant cette période, la goroutine sera bloquée jusqu'à ce qu'elle reprenne son état d'exécution.

func Sleep(d Duration)

func main() {
  start := time.Now()
  fmt.Println(start)
  time.Sleep(time.Second * 2)
  end := time.Now()
  fmt.Println(end)
}

2023-09-25 21:36:35.7229057 +0800 CST m=+0.001627901
2023-09-25 21:36:37.7347742 +0800 CST m=+2.013496401

Le programme ci-dessus bloquera pendant deux secondes après avoir affiché start, puis affichera end.