Comment utiliser le temps.Fonctionne maintenant dans Golang - Exemples

GO Language de programmation offre plusieurs fonctions intégrées pour gérer le temps et parmi ces fonctions, le temps.Maintenant() est le largement utilisé. Il vous permet de récupérer l'heure locale actuelle dans le fuseau horaire de votre système. La fonction renvoie un Temps struct, qui comprend la date et l'heure actuelles. Après cela, vous pouvez effectuer plusieurs opérations sur la structure pour obtenir la sortie souhaitée.

Suivez ce tutoriel pour apprendre l'utilisation de temps.Maintenant() Fonctionne dans Go avec quelques exemples de base pour une meilleure compréhension.

Comment utiliser le temps.Fonction maintenant () dans Golang - Exemples

Avant de se diriger vers l'utilisation du temps.Maintenant() Fonction Dans la programmation GO, vous devez apprendre la syntaxe de base pour cette fonction, qui est donnée ci-dessous:

func maintenant () heure

Le temps.Maintenant() La fonction ne prend aucun argument et renvoie l'heure locale actuelle en tant que Temps valeur. Vous pouvez utiliser cette valeur pour effectuer une variété d'opérations liées au temps dans votre code, comme la mise en forme du temps ou le calcul du temps écoulé entre deux événements.

Note: Le temps.Maintenant() s'appuiera sur l'horloge système de la machine exécutant votre code, vous devez donc vous assurer que l'horloge système est correctement définie pour obtenir des mesures de temps précises.

Implémentation étape par étape du temps.Fonction maintenant () à Golang

Voici une implémentation étape par étape à utiliser temps.Maintenant() Fonction dans Go:

Étape 1: Importez d'abord le package d'heure avant de démarrer la fonction principale.

Étape 2: Puis appelez le temps.Maintenant() fonction dans la fonction principale et stocke la valeur actuelle du temps dans une variable.

Étape 3: Puis imprimez la valeur variable pour obtenir le temps souhaité.

L'exemple de code sous-écrit illustre le fonctionnement de temps.Maintenant() Fonction dans Go:

package principal
Importer "FMT"
importer "temps"
func main ()
Temps: = temps.Maintenant()
fmt.Printf ("L'heure actuelle est:% s", heure)

Dans le code ci-dessus, nous avons utilisé le temps.Maintenant() Fonction pour trouver la date et l'heure. Ensuite, nous avons utilisé le fmt.Printf () fonction pour imprimer la variable de temps à la console.

Sortir

Le temps.Maintenant() Renvoie la valeur du temps dans le fuseau horaire local; Ici, il renvoie l'heure dans UTC car le fuseau horaire actuel de mon serveur est UTC. Dans la sortie ci-dessus, vous verrez également la valeur M = qui est une horloge monotonique utilisée pour mesurer les différences de temps pour vérifier toute modification de la date et de l'heure de l'appareil.

Vous pouvez également ajouter une durée à l'heure actuelle en utilisant temps.Maintenant() La fonction et le code pour un tel scénario sont donnés ci-dessous:

package principal
Importer "FMT"
importer "temps"
func main ()
Maintenant: = temps.Maintenant()
avenir: = maintenant.Ajouter (24 * fois.Heure)
fmt.Println ("Future Heure:", Future)

Le code ci-dessus récupère l'heure actuelle en utilisant le temps.Maintenant() fonction, puis y ajoute 24 heures en utilisant le Méthode Add () de la Temps taper. Après cela, il imprime la sortie finale de la console via le fmt.Println () fonction.

Sortir

Vous pouvez également utiliser le temps.Maintenant() Fonctionne pour identifier séparément l'année en cours, le mois, le jour, les heures, les minutes et les secondes.

Le code suivant est utilisé pour le scénario précédent.

package principal
importer (
"FMT"
"temps"
)
func main ()
Temps: = temps.Maintenant()
fmt.Println ("L'heure actuelle est:", heure)
fmt.Println ("L'année est:", le temps.Année())
fmt.Println ("Le mois est:", le temps.Mois())
fmt.Println ("Le jour est:", heure.Jour())
fmt.Println ("L'heure est:", le temps.Heure())
fmt.Println ("La minute est:", le temps.Heure())
fmt.Println ("Second est:", le temps.Deuxième())

Le programme ci-dessus extrait et imprime l'année en cours, mois, jour, heure, minute et deuxième en appelant les fonctions pertinentes sur l'objet Time Retourné par temps.Maintenant() fonction.

Sortir

Fin de compte

Les opérations liées au temps sont essentielles dans la plupart des langages de programmation, et Golang ne fait pas exception. Le temps.Maintenant() La fonction est une puissante fonction intégrée qui peut être utilisée pour récupérer le temps local actuel et effectuer une variété d'opérations liées au temps à Go. En suivant l'implémentation étape par étape fournie dans ce guide, vous pouvez facilement utiliser cette fonction pour récupérer l'heure actuelle ou y ajouter une durée, ou extraire des composants temporels spécifiques.