golang régler l'heure

Comment régler l'heure avec Golang ?

Golang (également connu sous le nom de Go) est un nouveau langage de programmation populaire parmi les développeurs en raison de sa simplicité et de son efficacité. Dans Go, vous pouvez facilement définir et gérer les dates et les heures.

Dans cet article, nous présenterons comment régler l'heure à l'aide de Golang. Nous aborderons les sujets suivants :

1. Comment représenter l'heure dans Golang
2. Comment régler l'heure actuelle
3. Comment définir une date et une heure spécifiées
4. Comment effectuer des calculs de temps
5. Comment convertir l'heure en chaîne
6. Comment obtenir à partir d'une chaîne Analyser l'heure en
7. Comment représenter l'heure en Golang

Une façon courante de représenter l'heure en Golang est d'utiliser un horodatage, qui est le nombre de secondes depuis l'UTC le 1er janvier 1970 jusqu'à le présent. Dans Golang, l'horodatage est un entier de type int64 avec des unités de nanosecondes.

De plus, il existe un type time.Time dans Go, qui représente un moment précis dans le temps. Un moment spécifique peut être représenté en convertissant l’horodatage en un type d’heure.

2. Comment régler l'heure actuelle

Dans Go, la façon d'obtenir l'heure actuelle est d'utiliser la fonction time.Now(). Cette fonction renvoie une valeur de type time.Time, qui représente le moment actuel.

Voici un exemple d'utilisation de time.Now() :

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now)
}

Dans l'exemple ci-dessus, nous utilisons time.Now() pour obtenir l'heure actuelle, puis l'imprimer.

3. Comment définir la date et l'heure spécifiées

Pour définir la date et l'heure spécifiées, vous pouvez utiliser la fonction time.Date(). Cette fonction accepte sept paramètres : année, mois, jour, heure, minute, seconde et nanoseconde, et renvoie une valeur de type time.Time, qui représente le moment spécifié dans le temps.

Voici un exemple d'utilisation de time.Date() :

package main

import (
    "fmt"
    "time"
)

func main() {
    d := time.Date(2021, time.July, 14, 12, 0, 0, 0, time.UTC)
    fmt.Println(d)
}

Dans l'exemple ci-dessus, nous utilisons time.Date() pour définir une heure spécifique, qui est midi le 14 juillet 2021. Imprimez ensuite ce point temporel.

4. Comment calculer le temps

Dans Golang, vous pouvez utiliser les fonctions time.Add() et time.Sub() pour ajouter et soustraire du temps.

La fonction time.Add() accepte un paramètre de type Duration et renvoie une nouvelle valeur de type time.Time, qui représente le point temporel après l'ajout de Duration.

La fonction time.Sub() accepte un paramètre de type time.Time et renvoie une valeur de type Duration, qui représente la différence de temps entre deux instants.

Voici un exemple utilisant time.Add() et time.Sub() :

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now)
    
    future := now.Add(24 * time.Hour)
    fmt.Println(future)
    
    duration := future.Sub(now)
    fmt.Println(duration)
}

Dans l'exemple ci-dessus, nous utilisons time.Add() pour ajouter 24 heures à l'heure actuelle afin d'obtenir les prochaines 24 heures. . Utilisez ensuite time.Sub() pour calculer le décalage horaire entre l'heure actuelle et les prochaines 24 heures. Imprimez enfin les résultats.

5. Comment convertir l'heure en chaîne

Dans Golang, vous pouvez utiliser la fonction time.Format() pour convertir l'heure en chaîne. Cette fonction accepte un paramètre de type chaîne, qui représente le format de la sortie temporelle.

Voici un exemple d'utilisation de time.Format() :

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now.Format("2006-01-02 15:04:05"))
}

Dans l'exemple ci-dessus, nous utilisons time.Format() pour formater l'heure actuelle dans une chaîne. Le format de sortie de l'heure est "2006-01-02 15:04:05". Ce format est corrigé. Vous pouvez consulter la documentation du package d'heure pour plus d'informations.

6. Comment analyser le temps à partir d'une chaîne

Dans Golang, vous pouvez analyser le temps à partir d'une chaîne à l'aide de la fonction time.Parse(). Cette fonction accepte deux paramètres : un paramètre de type chaîne qui représente la forme de chaîne de l'heure et l'autre est un paramètre de type chaîne qui représente le format d'entrée de l'heure.

Voici un exemple d'utilisation de time.Parse() :

package main

import (
    "fmt"
    "time"
)

func main() {
    s := "2021-07-14 12:00:00"
    d, err := time.Parse("2006-01-02 15:04:05", s)
    if err != nil {
        fmt.Println("parse time error:", err)
    } else {
        fmt.Println(d)
    }
}

Dans l'exemple ci-dessus, nous utilisons time.Parse() pour analyser une chaîne "2021-07-14 12:00:00" à un instant donné. Le format de l'heure d'entrée est "2006-01-02 15:04:05", qui est le même format utilisé par la fonction time.Format(). Si une erreur d'analyse se produit, une erreur non nulle sera renvoyée. Si l’analyse réussit, une valeur de type time.Time sera renvoyée, représentant le point temporel analysé.

Résumé

Dans cet article, nous avons présenté comment régler l'heure à l'aide de Golang. Nous avons présenté comment représenter l'heure dans Golang, comment définir l'heure actuelle, comment définir une date et une heure spécifiées, comment effectuer des calculs de temps, comment convertir l'heure en chaîne et comment analyser l'heure à partir d'une chaîne. J'espère que cet article vous sera utile.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!