Comment régler l'heure en Golang

Dans notre processus de programmation, nous utilisons souvent diverses exigences de service liées au temps. Voici quelques utilisations de base du temps dans golang.

Golang peut utiliser l'heure du package date et heure pour définir l'heure. Comment utiliser l'heure du package date et heure de Golang :

1. Le package time contient l'objet time.Time et certains. méthodes pour construire cet objet temporel. Méthodes (time.Unix(), time.Parse())

2 Golang peut être précis à la nanoseconde, donc la valeur de retour de la fonction ou les paramètres correspondants sont tous en nanosecondes. peut utiliser time.ParseDuration (durationString string) génération conviviale de valeur de plage de temps de mesure en nanosecondes

3. La mise en page de la chaîne de format d'heure de Golang est fixée au 2006-01-02 15:04:05

4 . golang est utilisé par défaut. Local est le fuseau horaire local. Vous pouvez définir le fuseau horaire via time.LoadLoad(zoneName string) (*Location, error)

Chaîne de modèle de construction/formatage du fuseau horaire

time .LoadLocation peut charger et renvoyer une variable de fuseau horaire

golang utilise 2006-01-02 15:04:05 comme chaîne de format Certaines personnes disent que c'est l'heure de naissance. de golang, et certains disent qu'il est basé sur le mois/jour/heure/minute/secondes/année soit 01/02/03(15-12)/04/05/06(2006), vous pouvez le comprendre par vous-même

// 构建时区
var timeLocation *time.Location
timeLocation, _ = time.LoadLocation("")              //UTC
timeLocation, _ = time.LoadLocation("UTC")           //UTC
timeLocation, _ = time.LoadLocation("Local")         //Local
timeLocation, _ = time.LoadLocation("Asia/Shanghai") //使用时区码
//golang的时间格式化pattern
var timeLayout = "2006-01-02 15:04:05"

Objet heure actuelle

Utilisez la méthode time.Now() pour obtenir l'objet heure actuelle. L'objet heure définit le fuseau horaire via time.Now(). Méthode In(). Vous pouvez également générer un fuseau horaire correspondant via timer.Local()/timer.UTC() Nouvel objet horaire.

// 获取当前时间对象
var timer time.Time
timer = time.Now()

// 为时间设定时区 可以通过 timer.Local()/timer.UTC() 快速设定时区
timer.In(timeLocation)

Obtenir un horodatage de deuxième niveau/un horodatage de niveau nanoseconde

// 获取当前秒级时间戳
var curTimestamp int64
curTimestamp = timer.Unix()
println("current timestamp:" + strconv.FormatInt(curTimestamp, 10))

// 获取当前纳秒及时间戳 1秒=1000毫秒=1000,000微妙=1000,000,000纳秒
var curNanoTimestamp int64
curNanoTimestamp = timer.UnixNano()
println("current nano timestamp:" + strconv.FormatInt(curNanoTimestamp, 10))

Obtenir le fuseau horaire de l'heure locale/heure standard CST/format personnalisé

// 获取本地时间的时区/快速获取时区时间/自定义格式
timeZone, _ := timer.Zone()
fmt.Printf("time zone: %s\n", timeZone)
fmt.Printf("time location: %s\n", timer.Location())
fmt.Printf("time in local zone: %s\n", timer.Local().String())
fmt.Printf("time in utc zone: %s\n", timer.UTC().String())
fmt.Printf("time: %s\n", timer.String())
fmt.Printf("time formatted: %s\n", timer.Format("2006-01-02 15:04:05")

Obtenir l'année/mois/jour en cours heure:minute:seconde nanoseconde

// 获取当前的年/月/日 时:分:秒 纳秒
fmt.Printf("current year: %d\n", timer.Year())
fmt.Printf("current month: %d %s\n", timer.Month(), timer.Month()) //返回的Month对象
fmt.Printf("current day: %d\n", timer.Day())
fmt.Printf("current hour: %d\n", timer.Hour())
fmt.Printf("current minute: %d\n", timer.Minute())
fmt.Printf("current second: %d\n", timer.Second())
fmt.Printf("current nanosecond: %d\n", timer.Nanosecond())

Obtenir l'heure/date actuelle

// 获取当前时间/日期
curHour, curMinute, curSecond := timer.Clock()
fmt.Printf("current clock: %d:%02d:%02d\n", curHour, curMinute, curSecond)
curYear, curMonth, curDay := timer.Date()
fmt.Printf("current date: %d-%02d-%02d\n", curYear, curMonth, curDay)

Modifier l'heure/trouver le décalage horaire entre deux dates

time.ParseDuration(durationString string) nous permet d'utiliser la sémantique pour construire une valeur d'intervalle de temps, et l'unité de valeur est la nanoseconde, par exemple comme :

timeDuration, _ := time.ParseDuration("24h")

timeDuration, _ := time.ParseDuration("12m")

timeDuration, _ : = time. ParseDuration("6s")

timeDuration, _ := time.ParseDuration("1ms")

timeDuration, _ := time.ParseDuration("1us")

timeDuration, _ := time.ParseDuration("1ns")

// 已当前时间为基增长年/月/日后的时间对象
timerAdded := timer.AddDate(1, 2, 3)
curYear, curMonth, curDay = timerAdded.Date()
fmt.Printf("current date: %d-%02d-%02d\n", curYear, curMonth, curDay)

// 以当前时间为基增长N纳秒后的时间对象 比如增长了一天
timeDuration, _ := time.ParseDuration("24h")
timerAdded = timer.Add(timeDuration)
// 计算两个时间的差值 返回的是纳秒 按需求自行计算其他单位
// Duration is type of int64 and nanoseconds
timeDuration = timerAdded.Sub(timer)
fmt.Printf("days duration between %s~%s: %d\n",
    timerAdded.Format(timeLayout),
    timer.Format(timeLayout),
    timeDuration/1000/1000/1000/24/60/60)

Utiliser la chaîne de temps/Unix Timestamp pour construire un objet temporel

// 使用时间串获取时间对象
timer, _ = time.Parse(timeLayout, "2018-08-08 08:08:08")
// 使用时间串获取时间对象 并设定时区
timer, _ = time.ParseInLocation(timeLayout, "2018-08-08 08:08:08", timeLocation)
// 使用Unix时间戳构建时间对象
timer = time.Unix(1552368806, 0) //2019-03-12 13:33:26的Unix时间戳
fmt.Println(timer.Format(timeLayout))

Obtenez l'heure actuelle est le jour de l'année et le jour de la semaine

Notez que le numéro du jour de la semaine du dimanche est 0

// 获取当前时间是本年第几天 本周第几天
fmt.Printf("year day: %d, week day: %d\n", timer.YearDay(), timer.Weekday())

Utilisez la chaîne de représentation pour convertir l'intervalle de temps

// 使用表征字符串转换时间跨度
timeDuration, _ = time.ParseDuration("300s")
fmt.Printf("nanosecond: %d\n", timeDuration)
timeDuration, _ = time.ParseDuration("300us")
fmt.Printf("nanosecond: %d\n", timeDuration)

Pour plus de connaissances sur le golang, veuillez faire attention à la colonne tutoriel golang.

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!