Lorsque votre application démarre à grande échelle, l'augmentation du nombre d'utilisateurs augmentera. Ce qui est très probable, c'est que l'emplacement de l'utilisateur ne se trouve pas seulement dans la même zone, il peut également se trouver dans une autre zone ayant un fuseau horaire différent. Ainsi, en tant que développeur Backend, il est très important de prendre en compte les éléments liés à la gestion des différences de fuseau horaire.

J'ai récemment rencontré un problème concernant les fuseaux horaires. Soyons honnêtes, la gestion des dates et des heures est l'un des domaines les plus compliqués auxquels un être humain doit faire face. Et cela a été l'occasion pour moi d'apprendre à bien gérer les dates et heures côté serveur.

Dans cet article, je partagerai mon expérience sur la façon dont je gère les différences de fuseau horaire côté serveur en tant que développeur Backend. Peut-être que si quelqu'un est prêt à corriger et à fournir des informations supplémentaires, cela me serait précieux.

À propos du fuseau horaire

Les fuseaux horaires sont un système standard de division du temps utilisé dans le monde entier pour organiser et standardiser la mesure du temps. Ce concept a émergé en réponse au besoin de coordination mondiale du temps, en particulier parallèlement aux développements des technologies de communication et de transport.

Le principe de base des fuseaux horaires est la division de la Terre en 24 zones. Chaque fuseau horaire est généralement différent d’une heure du fuseau qui lui est voisin. La référence principale pour les fuseaux horaires est le temps moyen de Greenwich (GMT) ou le temps universel coordonné (UTC), qui se situe sur la ligne de longitude zéro degré qui traverse Greenwich, en Angleterre.

Illustration de Hellerick de Wikimedia Commons

Un petit exemple est que lorsque l'horloge indique midi à Jakarta, à New York, l'heure indique 00h00 ou minuit. Cela signifie que pendant que les Jakartans déjeunent, les New-Yorkais commencent tout juste leur nouvelle journée. À partir de là, vous pouvez certainement imaginer l'importance de gérer correctement les fuseaux horaires lors de la création d'une application.

Gestion des fuseaux horaires côté serveur

Après avoir vu l'explication ci-dessus, nous allons maintenant aborder les points qui peuvent être effectués lorsque notre application serveur reçoit une requête d'un client qui accède à notre API pour gérer son fuseau horaire.

Dans cet article, je discuterai de plusieurs approches de gestion des fuseaux horaires côté serveur. Ici, j'utiliserai des exemples de code dans le langage Golang (Go). Golang dispose d'un package temporel pour travailler avec des données liées au temps qui est considéré comme assez complet. Voici quelques points que nous aborderons :

• Comment enregistrer la date dans la base de données
• Conversion de l'heure locale de l'utilisateur
• Tests et validation

Comment enregistrer la date dans la base de données

La première chose dont nous discuterons est du temps que nous allons gagner dans la base de données, par exemple nous avons une application de commerce électronique qui fait des ventes flash, où notre application est déjà à l'échelle internationale.

Lorsqu'un utilisateur traite une transaction d'achat en Amérique ou s'il se trouve en Indonésie, l'utilisateur enverra son heure locale différente au serveur. La question est : notre base de données stockera-t-elle les données horaires en fonction de l'heure locale de l'utilisateur ? Si la réponse est oui, il s'agit probablement d'un problème compliqué lorsque nous voulons récupérer les données ou, par exemple, que l'administrateur souhaite effectuer le traitement des données, quel utilisateur effectue la transaction la plus ancienne.

Pour surmonter ce problème, la meilleure pratique consiste à stocker les heures de transaction dans le fuseau horaire UTC (temps universel coordonné), qui est la principale norme horaire pour les horloges et les paramètres horaires. Voici l'application de l'heure à UTC.

package main

import (
    "fmt"
    "time"
)

func main() {

    now := time.Now()
    fmt.Printf("Local time: %s\n", now)

    nowInUTC := now.UTC()
    fmt.Printf("UTC time: %s\n", nowInUTC)

}

Voyons la signification du code ci-dessus.

Tout d'abord, dans la ligne de code now := time.Now(), cette ligne utilise la fonction Now() du package time pour obtenir l'heure actuelle en fonction du fuseau horaire local du système. Le résultat est stocké dans la variable actuelle.

Ensuite, dans la ligne nowInUTC := now.UTC(), nous convertissons ici l'heure locale (maintenant) en heure UTC à l'aide de la méthode UTC(). Les résultats sont stockés dans une nouvelle variable nowInUTC et cette fois peuvent être stockés sur le serveur, où l'on espère que les développeurs pourront éviter toute ambiguïté et les erreurs pouvant survenir en raison des différences de fuseau horaire entre les serveurs et les utilisateurs dans diverses régions avec des fuseaux horaires différents.

Voici les résultats si nous exécutons le code ci-dessus :

Mais ce n'est pas toujours la meilleure solution que vous devriez utiliser. Il peut y avoir certains points que vous pouvez garder à l'esprit dans certains cas d'utilisation, notamment : est-il vrai que nos utilisateurs viennent de fuseaux horaires différents ? Si ce n'est pas possible, stocker l'heure en UTC ajoutera peut-être de la complexité à votre code.

Changer l'heure en fonction des paramètres régionaux de l'utilisateur

Au point de discussion ci-dessus, nous avons convenu de stocker les données de temps utilisateur dans un seul emplacement, à savoir UTC. Maintenant, comment les utilisateurs peuvent voir l’heure précise en fonction de leur emplacement. Un exemple de la discussion ci-dessus est une vente flash sur une application de commerce électronique que nous avons, où les utilisateurs souhaitent également connaître des informations sur l'utilisateur qui a effectué la première transaction. Ainsi, à ce stade, la conversion de l'heure que nous stockons dans la base de données en heure locale de l'utilisateur est une autre chose importante que nous ne devons pas ignorer.

L'approche que j'adopte est que le côté serveur demande toujours au client d'envoyer le fuseau horaire côté utilisateur. Cela peut être fait du côté de la demande, où le client envoie un en-tête avec le fuseau horaire clé et possède la valeur du fuseau horaire de l'utilisateur. Par exemple, l'Indonésie compte 3 divisions de fuseaux horaires, à savoir WIT (9), WITA (8), WIB (7). Où chaque zone a une différence de 1 heure. Si auparavant sur notre serveur nous stockions l'heure UTC à 00h00, alors du côté WIT, elle était à 09h00, puis du côté WITA, elle était à 08h00 et WIB à 07h00.

Voici un exemple de code pour gérer le cas ci-dessus :

package main

import (
    "fmt"
    "time"
)

func ParseTimezoneFromString(tz string) *time.Location {

    if len(tz) > 0 {

        t, err := time.Parse("2006 -07:00", fmt.Sprintf("2007 %s", tz))

        if err != nil {

            panic(err)

        } else {

            return t.Location()
        }
    }

    return time.Now().Location()
}

func main() {

    timeServerInUTC := "2024-08-04 00:00:00"
    nowInUTC, err := time.Parse("2006-01-02 15:04:05", timeServerInUTC)
    if err != nil {
        panic(err)
    }

    fmt.Printf("UTC time: %s\n", nowInUTC)

    witLocation := ParseTimezoneFromString(" 09:00")

    nowInWIT := nowInUTC.In(witLocation)
    fmt.Printf("WIT time: %s\n", nowInWIT)

    witaLocation := ParseTimezoneFromString(" 08:00")

    nowInWITA := nowInUTC.In(witaLocation)
    fmt.Printf("WITA time: %s\n", nowInWITA)

    wibLocation := ParseTimezoneFromString(" 07:00")

    nowInWIB := nowInUTC.In(wibLocation)
    fmt.Printf("WIB time: %s\n", nowInWIB)

}

crédit à dikac pour créer cette fonction ParseTimezoneFromString

Comprenons la signification du code ci-dessus :

Tout d'abord, nous créons une fonction ParseTimezoneFromString, où cette fonction est utilisée pour trouver l'emplacement horaire en fonction de l'argument tz ou du fuseau horaire de l'emplacement utilisateur donné. Si la valeur de chaîne tz est valide, nous convertirons le fuseau horaire de la chaîne à l'aide de la fonction time.Parse pour convertir la chaîne en un objet temporel, puis extrairons l'emplacement (fuseau horaire) de cet objet. Et nous gérons également si la chaîne est vide ou si l'analyse échoue, la fonction renvoie le fuseau horaire local du système.

func ParseTimezoneFromString(tz string) *time.Location {

    if len(tz) > 0 {

        t, err := time.Parse("2006 -07:00", fmt.Sprintf("2007 %s", tz))

        if err != nil {

            panic(err)

        } else {

            return t.Location()
        }
    }

    return time.Now().Location()
}

Ensuite, nous définissons également les données temporelles dans le format de chaîne suivant :

timeServerInUTC := "2024-08-04 00:00:00"

nowInUTC, err := time.Parse("2006-01-02 15:04:05", timeServerInUTC)
if err != nil {
    panic(err)
}

Vous pouvez considérer cela comme les données de synchronisation que nous obtenons du serveur. Et analysez-le dans un objet temporel.

Ensuite, nous essayons de trouver l'emplacement précis de l'utilisateur en fonction de la fonction ParseTimezoneFromString que nous avons précédemment créée en fonction de l'argument de chaîne que nous avons défini. Ce à quoi il faut prêter attention, c'est que cet argument de chaîne correspond à la valeur de l'en-tête de fuseau horaire envoyé par le client via la requête entrante.

Nous pouvons utiliser l'emplacement que nous obtenons de la fonction ParseTimezoneFromString pour convertir ou décaler l'heure que nous obtenons du serveur vers l'heure locale de l'utilisateur. Nous pouvons le faire en utilisant la fonction In qui est également incluse dans le package time que nous pouvons voir dans l'extrait de code suivant :

nowInWIT := nowInUTC.In(witLocation)
nowInWITA := nowInUTC.In(witaLocation)
nowInWIB := nowInUTC.In(wibLocation)

Si nous l'exécutons, nous obtiendrons l'heure qui correspond à l'emplacement du fuseau horaire que nous avons défini.

Tests et validation

Le dernier point n'est pas moins important, à savoir les tests et la validation. Lorsque le processus de développement amène souvent les développeurs à commettre des erreurs inattendues, les tests et la validation sont toujours importants.

Dans la discussion du point 2 ci-dessus, la fonction ParseTimezoneFromString a joué un rôle important dans la gestion de nos fuseaux horaires. Des tests et des validations répétés sont importants pour que nos applications obtiennent des résultats à la hauteur de nos attentes.

Pour les tests, il est recommandé d'utiliser des tests unitaires, où les tests seront effectués sur la plus petite unité avec plusieurs scénarios pouvant être ajoutés. Plus il y a de scénarios, moins il est probable que ces décalages horaires soient pris en compte.

Conclusion

La gestion des fuseaux horaires peut en effet être délicate pour les développeurs backend. Cependant, il est important de se rappeler que chaque tâche difficile que nous surmontons contribue à notre croissance et à l’amélioration de nos compétences. La gestion correcte des fuseaux horaires n'est pas seulement une nécessité technique, elle garantit la précision de la planification et offre une expérience fluide aux utilisateurs de nos applications dans différentes régions.

Les points partagés dans cet article sur le stockage des heures au format UTC, la conversion en heures locales de l'utilisateur et la mise en œuvre de fonctions de conversion robustes sont des points de départ pour aborder ce problème complexe. Cependant, je reconnais qu'il peut y avoir des lacunes ou des domaines à améliorer dans les approches discutées. C'est pourquoi les contributions et suggestions supplémentaires de la communauté des développeurs sont inestimables.

J'espère sincèrement que les informations et les exemples de code fournis dans cet article vous seront utiles à l'avenir lorsque vous rencontrerez des défis liés au fuseau horaire dans vos projets. N'oubliez pas que l'objectif est de créer des applications qui fonctionnent de manière transparente pour les utilisateurs, quelle que soit leur situation géographique.

Poursuivons cette discussion dans la section commentaires ci-dessous. J'aimerais connaître vos expériences en matière de gestion des fuseaux horaires, les défis que vous avez rencontrés ou les approches alternatives que vous avez trouvées efficaces. Vos idées pourraient être extrêmement précieuses pour moi et pour d’autres lecteurs confrontés à des problèmes similaires.

Merci d'avoir lu et j'espère que cet article s'avérera utile dans votre parcours de développement. Continuons à apprendre et à nous améliorer ensemble ! ?

Lecture des références

• Fuseau horaire
• Qu'est-ce qu'un fuseau horaire ?
• Comment gérer les fuseaux horaires et synchroniser votre logiciel avec les clients internationaux
• Gérer les fuseaux horaires dans le développement Web
• Travailler avec les dates et les heures dans Go : gestion des fuseaux horaires et du formatage