Implémentation de l'internationalisation des applications Web d'apprentissage Golang

Avec la tendance à la mondialisation, l'internationalisation est devenue de plus en plus importante et les applications Web ne font pas exception. Lors du développement d'applications Web, nous devons concevoir l'application pour prendre en charge différentes langues et cultures. C'est l'internationalisation. Plus précisément, lorsque les applications utilisent la même base de code dans différentes régions et cultures, elles peuvent automatiquement convertir le texte et la langue pour mieux s'adapter aux différents besoins des utilisateurs.

Golang, en tant que langage de programmation très populaire, peut également être utilisé pour mettre en œuvre l'internationalisation des applications Web. Dans cet article, je vais vous présenter comment utiliser Golang pour implémenter les fonctions d'internationalisation des applications Web.

Étape 1 : Installer les packages Golang nécessaires

Pour réaliser l'internationalisation des applications Web, nous devons installer certains packages Golang nécessaires. Le package le plus important est le package « i18n », qui constitue le cœur de l’internationalisation. Vous pouvez installer ce package à l'aide de la commande suivante :

go get github.com/astaxie/beego/i18n

Étape 2 : Configurer le package i18n

Ensuite, nous devons configurer le package i18n dans l'application. Dans cette application, nous devons configurer le package i18n afin qu'il puisse convertir correctement le texte et la langue dans différentes langues. Vous pouvez utiliser le code suivant pour configurer le package i18n :

import (
    "github.com/astaxie/beego"
    "github.com/astaxie/beego/i18n"
)
var LangTypes []string //支持的语言列表const (
    LANG_ENGLISH = "en-US"
    LANG_CHINA   = "zh-CN"
)
func SetUpI18n() {
    langs := beego.AppConfig.String("langs")
    LangTypes = strings.Split(langs, "|")
    for _, lang := range LangTypes {
        if lang == "en-US" {
            err := i18n.SetMessage(lang, "conf/locale_en-US.ini")
            if err != nil {
                beego.Error(err)
                continue
            }
            continue
        }
        if lang == "zh-CN" {
            err := i18n.SetMessage(lang, "conf/locale_zh-CN.ini")
            if err != nil {
                beego.Error(err)
                continue
            }
            continue
        }
    }
}

Dans ce code, nous obtenons d'abord la liste des langues prises en charge dans le système via beego.AppConfig. Ensuite, nous parcourons toutes les langues et chargeons les fichiers de langue correspondants pour chaque langue. Dans cet exemple, nous fournissons uniquement les langues « en-US » et « zh-CN ».

Étape 3 : Écrire un modèle

Avec le package i18n et les fichiers de langue, nous pouvons commencer à écrire des applications Web. Dans cette application, nous devons écrire des modèles afin de pouvoir basculer facilement entre différentes langues. Voici un exemple de modèle :

{{.i18n "welcome"}}, {{.i18n "userName"}}!

Dans le code du modèle ci-dessus, {{.i18n "welcome"}} et {{.i18n "userName"}} sont les textes que nous souhaitons traduire. Voici l'implémentation de la fonction de traduction fournie dans le package i18n :

func (c *LangController) Lang() {
    lang := c.Ctx.Input.Param(":lang")
    if lang == "" {
        lang = "en-US"
    }
    c.SetLang(lang)
    c.Redirect("/", 302)
}
func (c *LangController) SetLang(lang string) {
    beego.Trace(lang)
    if lang != "" {
        c.Ctx.SetCookie("lang", lang, 1<<31-1, "/")
    } else {
        c.Ctx.SetCookie("lang", "", -1, "/")
    }
    c.Data["Lang"] = lang
}
func (c *BaseController) Prepare() {
    lang := c.Ctx.GetCookie("lang")

    if lang == "" {
        lang = LANG_ENGLISH
        c.SetLang(lang)
    }

    c.Data["Lang"] = lang
    trans := i18n.GetLangByType(lang)
    c.Data["i18n"] = trans
}

Dans le code ci-dessus, nous définissons un LangController pour changer de langue, une fonction SetLang pour définir la langue et un BaseController pour définir les paramètres régionaux. Grâce à ces fonctions, nous pouvons facilement changer et définir les paramètres régionaux.

Étape 4 : Exécuter l'application Web

Enfin, nous devons exécuter l'application Web afin qu'elle puisse prendre en charge correctement différentes langues. Nous pouvons utiliser la commande suivante pour exécuter l'application web :

bee run

Cette commande démarrera l'application web et par défaut elle écoutera sur le port 8080 les requêtes HTTP. Nous pouvons tester si l'application a traduit correctement le texte en visitant http://localhost:8080/en-US/welcome ou http://localhost:8080/zh-CN/welcome dans le navigateur.

Conclusion

Dans cet article, nous avons présenté comment utiliser Golang pour implémenter les fonctions d'internationalisation des applications Web. Grâce aux packages i18n et aux fichiers de langue, nous pouvons facilement mettre en œuvre l'internationalisation pour mieux nous adapter aux différents besoins des utilisateurs. Si vous développez une application Web, nous vous recommandons fortement d'utiliser Golang pour implémenter des fonctionnalités d'internationalisation afin d'améliorer l'expérience utilisateur de votre application.

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!