L'heure et la date sont des composants cruciaux de nombreux logiciels, des utilitaires de gestion du temps aux applications Web. En tant que programmeur, vous devez savoir comment manipuler l'heure et la date dans la langue que vous utilisez.
Au Go, le temps package regroupe les fonctions de manipulation de l'heure et de la date. Vous pouvez accéder à ces fonctions dans n'importe quel fichier source en important ce package.
Alors, que signifie manipuler l'heure et la date, et comment pouvez-vous manipuler l'heure et la date dans Go ?
Qu'est-ce que la manipulation de l'heure et de la date ?
Selon les exigences de votre programme, il peut être nécessaire de contrôler, gérer ou ajuster le comportement ou la représentation des heures et des dates.
Différents langages de programmation ont leurs propres fonctions pour la manipulation de l'heure et de la date. Le langage Go a des capacités étendues, utiles à cette fin.
La manipulation de l'heure et de la date peut inclure :
- Obtenir l'heure actuelle d'un lieu ou d'un fuseau horaire.
- Effectuer des opérations arithmétiques sur les heures et les dates.
- Modification du format d'entrée/sortie des heures et des dates.
Pour commencer à manipuler l'heure et la date dans vos applications Go, importez le temps package aux côtés des autres packages que vous utilisez.
importer (
"fmt"
"temps"
)Comment obtenir l'heure et la date actuelles dans Go
Un cas d'utilisation courant pour la manipulation de l'heure consiste à obtenir l'heure locale actuelle ou l'heure actuelle d'un fuseau horaire ou d'un emplacement spécifique.
Pour obtenir l'heure et la date dans votre heure locale ou dans un fuseau horaire ou un lieu spécifique, vous pouvez utiliser le temps. À présent() et temps. ChargerEmplacement() les fonctions:
fonction principale(){
// Récupère l'heure et la date actuelles en heure locale
monHeure := ime. À présent()
fmt. Imprimerln("Heure actuelle à ", mon temps. Emplacement(), " est: ", mon temps)// Une autre façon d'obtenir l'heure locale
lieu, _ := heure. ChargerEmplacement("Local") // ou l'heure. ChargerEmplacement("")
fmt. Imprimerln("Heure actuelle à ", emplacement, " est: ", temps. Maintenant().Dans (emplacement))// autre emplacement
emplacement, _ = heure. ChargerEmplacement("Amérique/New_York")
fmt. Imprimerln("Heure actuelle à ", emplacement, " est: ", mon temps. Dans (lieu))
// obtenir l'heure actuelle dans le fuseau horaire des Rocheuses (MST)
emplacement, _ = heure. ChargerEmplacement("MST")
fmt. Imprimerln("Heure actuelle à ", emplacement, " est: ", mon temps. Dans (lieu))
}
Exécuter le programme ci-dessus avec allez exécuter filename.go produit la sortie suivante dans le terminal :
La méthode LoadLocation ne prend pas en charge toutes les abréviations d'emplacement et de fuseau horaire. Selon le Accéder à la documentation, il ne prend en charge que les emplacements dans Base de données IANA.org.
Comment obtenir des composants séparés à partir d'une date donnée
Vous pouvez obtenir chaque composant de l'horodatage séparément, ce qui est similaire à quand travailler avec l'heure et les dates en JavaScript.
Il existe de nombreuses façons d'accomplir cela en utilisant Go temps les fonctions. Cette section illustre chaque méthode.
Vous pouvez utiliser le Date() fonction pour obtenir le jour, le mois et l'année, et le L'horloge() fonction pour obtenir l'heure, les minutes et les secondes. Par exemple:
fonctionprincipale() {
monHeure := heure. À présent();
année, mois, jour := monHeure. Date()
fmt. Println("Année :", année)
fmt. Println("Mois :", mois)
fmt. Println("Jour :", jour)
heure, min, sec := monHeure. L'horloge()
fmt. Println("Heure :", heure)
fmt. Println("Minute :", min)
fmt. Println("Secondes :", sec)
}
La sortie illustre les différentes parties de l'horodatage :
Vous pouvez également obtenir des unités de l'horodatage individuellement avec le temps fonctions pour chacun d'eux :
fonctionprincipale() {
monHeure := heure. À présent()
// récupère chaque unité de l'année à la nanoseconde
fmt. Println("Année :", monHeure. An())
fmt. Println("Mois :", monHeure. Mois())
fmt. Println("Jour :", monHeure. Jour())
fmt. Println("Heure :", monHeure. Heure())
fmt. Println("Minute :", monHeure. Minute())
fmt. Println("Secondes :", monHeure. Deuxième())
fmt. Println("Nanoseconde :", monHeure. Nanoseconde())
}
Comme l'illustre la sortie, cela vous donne également accès aux nanosecondes :
Les exemples jusqu'à présent se sont concentrés sur l'obtention d'unités d'horodatage à partir de l'heure actuelle. Vous pouvez effectuer le même type d'action sur un horodatage qui n'est pas temps. À présent().
Vous pouvez extraire l'année, le mois, le jour, l'heure, la minute et la seconde d'une date donnée. Pour ce faire, vous devez soit initialiser un nouvel objet date, soit analyser la date à partir d'une chaîne :
fonctionprincipale() {
// obtenir des composants individuels du temps de l'année à la nanoseconde
// à partir d'une date précise
votreHeure := heure. Date(2020, 07, 1, 06, 32, 10, 0, temps. UTC)
fmt. Println("Année :", votreHeure. An())
fmt. Println("Mois :", votreHeure. Mois())
fmt. Println("Jour :", votreHeure. Jour())
fmt. Println("Heure :", votreHeure. Heure())
fmt. Println("Minute :", votreHeure. Minute())
fmt. Println("Secondes :", votreHeure. Deuxième())
fmt. Println("Nanoseconde :", votreHeure. Nanoseconde())
// utilisation de la fonction Clock() pour obtenir l'heure, la minute et la seconde
votreHeure, votreMin, votreSec := votreHeure. L'horloge()
fmt. Println("Heure :", votreHeure)
fmt. Println("Minute :", votreMin)
fmt. Println("Secondes :", votreSec)
// récupère l'heure et la date de la chaîne
dateString := "2020-07-0106:32:10"
mise en page := "2006-01-0215:04:05" // votre format de sortie souhaité
votreHeure, _ = heure. Analyser (mise en page, dateString)
fmt. Println("Votre heure est: ", votreHeure)
fmt. Println("Année :", votreHeure. An())
fmt. Println("Mois :", votreHeure. Mois())
fmt. Println("Jour :", votreHeure. Jour())
fmt. Println("Heure :", votreHeure. Heure())
fmt. Println("Minute :", votreHeure. Minute())
fmt. Println("Secondes :", votreHeure. Deuxième())
}
Ce code produit la sortie suivante :
Notez que Parse() utilise UTC par défaut si vous ne spécifiez pas de fuseau horaire dans la chaîne de date.
Comment effectuer des opérations arithmétiques avec la date et l'heure
Les opérations arithmétiques sont un autre type de manipulation que vous pouvez effectuer sur l'heure et la date dans Go. Des opérations simples comme l'addition, la soustraction et la différence de temps sont toutes possibles.
Go vous permet de définir temps. Durée valeurs avec toutes les unités de temps à partir de temps. Heure à temps. Nanoseconde. Vous pouvez utiliser ces valeurs pour ajouter ou soustraire du temps à l'aide de Ajouter(). Il y a aussi un AjouterDate() fonction prenant en compte 3 paramètres: années, mois et jours pour effectuer une addition ou une soustraction.
Le code suivant illustre l'utilisation de ces fonctions :
fonctionprincipale() {
curTime := temps. À présent()
curTime = curTime. Ajouter du temps. Heure) // ajoute une heure
fmt. Println("L'heure actuelle est: ", heure_actuelle)
demain := curTime. Ajouter du temps. Heure * 24)
fmt. Println("A cette heure demain c'est: ", demain)
nextWeek := curTime. Ajouter du temps. Heure * 24 * 7)
fmt. Println("Cette heure la semaine prochaine est: ", semaine prochaine)
// en utilisant AddDate (a, m, j)
nextTomorrow := curTime. AjouterDate(0, 0, 2)
fmt. Println("Cette fois, demain prochain est: ", demain suivant)
nextMonth := curTime. AjouterDate(0, 1, 0)
fmt. Println("Cette fois le mois prochain est: ", nextMonth)
fiveYearsAndOneMonthAfter := curTime. AjouterDate(5, 1, 0)
fmt. Println("Cette fois cinq ans et un mois après est: ", fiveYearsAndOneMonthAfter)
}
Ce qui produit la sortie suivante :
Vous pouvez également soustraire du temps avec Ajouter() et AjouterDate() en passant des paramètres négatifs. Par exemple:
fonctionprincipale() {
curTime := temps. À présent()// soustraire un jour en utilisant AddDate()
hier := curTime. AjouterDate(0, 0, -1)
fmt. Println("Hier à cette heure c'était: ", hier)
// soustraire un mois en utilisant Add()
lastMonth := curTime. Ajouter du temps. Heure * -24 * 30)
fmt. Println("Cette fois le mois dernier était: ", lastMonth)
}
Produit cette sortie :
Bien que vous puissiez utiliser Ajouter() et AjouterDate() pour trouver la distinction entre les dates, Go a un Sous() fonction qui fonctionne un peu différemment :
fonctionprincipale() {
curTime = temps. À présent()
passé := temps. Date(2022, temps. Décembre, 25, 12, 0, 0, 0, temps. UTC)
diff := passé. Sous (curTime)
fmt. Println("La différence entre maintenant et le passé est: ", diff)
// obtenir la différence en différentes unités
ans := entier(diff. Heures() / 24 / 365)
fmt. Println("Années: ", années)
mois := entier(diff. Heures() / 24 / 30)
fmt. Println("Mois: ", mois)
jours := entier(diff. Heures() / 24)
fmt. Println("Jours: ", jours)
heures := entier(diff. Heures())
fmt. Println("Heures: ", heures)
// diff. Minutes(), diff. Secondes(), diff. Millisecondes(), diff. Les nanosecondes() renvoient également leurs unités
}
Ce code produit la sortie suivante :
Comment obtenir l'heure et la date dans différents formats
Vous pouvez également obtenir des sorties d'heure et de date dans plusieurs formats à l'aide de Format() fonction. Voici quelques styles de mise en forme courants :
fonctionprincipale() {
curTime = temps. À présent()
// styles de formatage standard intégrés
fmt. Println("L'heure actuelle est: ", heure_actuelle)
fmt. Println("L'heure actuelle au format RFC3339 est: ", curTime. Format (heure. RFC3339))
fmt. Println("L'heure actuelle au format RFC3339Nano est: ", curTime. Format (heure. RFC3339Nano))
fmt. Println("L'heure actuelle au format RFC1123 est: ", curTime. Format (heure. RFC1123))
fmt. Println("L'heure actuelle au format RFC1123Z est: ", curTime. Format (heure. RFC1123Z))
fmt. Println("L'heure actuelle au format RFC822 est: ", curTime. Format (heure. RFC822))
fmt. Println("L'heure actuelle au format RFC822Z est: ", curTime. Format (heure. RFC822Z))
fmt. Println("L'heure actuelle au format RFC850 est: ", curTime. Format (heure. RFC850))
fmt. Println("L'heure actuelle au format ANSIC est: ", curTime. Format (heure. ANSIC))
fmt. Println("L'heure actuelle au format Unix est: ", curTime. Format (heure. UnixDate))
// styles de formatage personnalisés
// JJ-MM-AAAA HH: MM: SS
fmt. Println("L'heure actuelle au format personnalisé est: ", curTime. Format("02-01-200615:04:05"))
// MM-JJ-AAAA HH: MM: SS
fmt. Println("L'heure actuelle au format personnalisé est: ", curTime. Format("01-02-200615:04:05"))
// AAAA-MM-JJ HH: MM: SS
fmt. Println("L'heure actuelle au format personnalisé est: ", curTime. Format("2006-01-0215:04:05"))
// JJ.MM.AAAA
fmt. Println("L'heure actuelle au format personnalisé est: ", curTime. Format("02.01.2006"))
// JJ/MM/AAAA
fmt. Println("L'heure actuelle au format personnalisé est: ", curTime. Format("02/01/2006"))
// 01 février 2006
fmt. Println("L'heure actuelle au format personnalisé est: ", curTime. Format("02 Jan 2006"))
// 01 février 2006 lundi
fmt. Println("L'heure actuelle au format personnalisé est: ", curTime. Format("02 Février 2006 Lundi"))
// 01 février 2006 lun 15:04:05
fmt. Println("L'heure actuelle au format personnalisé est: ", curTime. Format("02 Février 2006 Lun 15:04:05"))
}
Ces différents types de formatage produisent la sortie suivante :
Manipulation de l'heure et de la date dans Go
La liste des manipulations que vous pouvez effectuer sur les heures et les dates est presque interminable. Selon la portée de votre application, vous devrez peut-être effectuer de nombreuses opérations de date/heure diverses.
Pour tout cas d'utilisation que vous pourriez avoir, le temps package est très fonctionnel et possède de nombreuses méthodes intégrées.
Vous pouvez utiliser la manipulation de la date et de l'heure pour créer une simple application de planification quotidienne ou de planification de tâches.
