Temps et durée
Représenter des instants et des intervalles
Temps et durée est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.
Le paquet time
Le paquet time de Go représente les instants et les durées qui les séparent.
time.Timereprésente un instant précis.time.Durationreprésente une durée.
package main
import (
"fmt"
"time"
)
func main() {
var d time.Duration = 2 * time.Second
fmt.Println(d)
}Obtenir l'heure actuelle
time.Now() renvoie l'instant actuel sous forme de time.Time. (Sa valeur exacte dépend du moment où le programme s'exécute.)
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println(now.Year())
}Construire un instant précis
time.Date construit un instant exact à partir de ses composantes : année, mois, jour, heure, minute, seconde, nanoseconde et emplacement.
package main
import (
"fmt"
"time"
)
func main() {
t := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
fmt.Println(t)
}Lire les composantes d'un instant
Un time.Time expose des méthodes telles que Year, Month, Day, Hour et Weekday.
package main
import (
"fmt"
"time"
)
func main() {
t := time.Date(2026, time.May, 30, 0, 0, 0, 0, time.UTC)
fmt.Println(t.Month(), t.Day(), t.Weekday())
}Constantes de durée
Construisez des durées en multipliant les constantes d'unité : time.Hour, time.Minute, time.Second, time.Millisecond.
package main
import (
"fmt"
"time"
)
func main() {
d := 1*time.Hour + 30*time.Minute
fmt.Println(d)
}Convertir des durées
Des méthodes comme Seconds(), Minutes() et Hours() renvoient la durée sous forme de float64 dans l'unité correspondante.
package main
import (
"fmt"
"time"
)
func main() {
d := 90 * time.Minute
fmt.Println(d.Hours())
fmt.Println(d.Seconds())
}Ajouter du temps
t.Add(d) renvoie un nouvel instant décalé d'une durée. La valeur d'origine reste inchangée, car time.Time est un type valeur.
package main
import (
"fmt"
"time"
)
func main() {
t := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
later := t.Add(2 * time.Hour)
fmt.Println(later.Hour())
}Ajouter des unités calendaires
t.AddDate(years, months, days) décale l'instant selon des unités calendaires, en gérant correctement la longueur des mois et les années bissextiles.
package main
import (
"fmt"
"time"
)
func main() {
t := time.Date(2026, time.January, 31, 0, 0, 0, 0, time.UTC)
next := t.AddDate(0, 1, 0)
fmt.Println(next.Month(), next.Day())
}Différence entre deux instants
t2.Sub(t1) renvoie la Duration entre deux instants. Un résultat négatif signifie que t2 est antérieur.
package main
import (
"fmt"
"time"
)
func main() {
a := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
b := time.Date(2026, time.May, 30, 12, 0, 0, 0, time.UTC)
fmt.Println(b.Sub(a))
}Comparer des instants
Utilisez Before, After et Equal pour comparer des instants. Évitez ==, car cet opérateur compare également le fuseau horaire interne.
package main
import (
"fmt"
"time"
)
func main() {
a := time.Date(2026, 5, 30, 9, 0, 0, 0, time.UTC)
b := time.Date(2026, 5, 30, 10, 0, 0, 0, time.UTC)
fmt.Println(a.Before(b))
}Horodatages Unix
t.Unix() renvoie le nombre de secondes écoulées depuis le 1er janvier 1970. time.Unix(sec, 0) effectue la conversion inverse vers un time.Time.
package main
import (
"fmt"
"time"
)
func main() {
t := time.Date(2026, 5, 30, 0, 0, 0, 0, time.UTC)
secs := t.Unix()
fmt.Println(time.Unix(secs, 0).UTC().Year())
}Vérification rapide
Que renvoie t2.Sub(t1) ?
Récapitulatif : temps et durée
Vous avez appris le modèle temporel de base :
time.Timereprésente un instant ;time.Durationreprésente une durée.- Créez des instants avec
NowetDate; décalez-les avecAddetAddDate. - Mesurez les écarts avec
Subet comparez les instants avecBefore/After.
package main
import (
"fmt"
"time"
)
func main() {
start := time.Date(2026, 5, 30, 8, 0, 0, 0, time.UTC)
end := start.Add(45 * time.Minute)
fmt.Println(end.Sub(start).Minutes(), "minutes")
}
Apprends Go avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 51
- Leçons
- 203
Questions Fréquemment Posées
La leçon « Temps et durée » est-elle gratuite ?
Oui — le texte complet de « Temps et durée » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Temps et durée » ?
Représenter des instants et des intervalles Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Go Academy ?
Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Temps et durée » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?
Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.