14.5 Multi-language support

In the chapter where we introduced internationalization and localization, we developed the go-i18n library. In this section, we will see how this library is integrated into the Beego framework, and how it enables our Beego applications to support both internationalization and localization.

I18n integration

Beego first sets some global variables:

  1. Translation i18n.IL
  2. Lang string // set the language pack, zh, en
  3. LangPath string // set the language pack location

A multi-language initialization function is defined:

  1. func InitLang(){
  2.     beego.Translation:=i18n.NewLocale()
  3.     beego.Translation.LoadPath(beego.LangPath)
  4.     beego.Translation.SetLocale(beego.Lang)
  5. }

In order to facilitate multi-language calls in the template package directly, we designed three functions for handling multi-language responses:

  1. beegoTplFuncMap["Trans"] = i18n.I18nT
  2. beegoTplFuncMap["TransDate"] = i18n.I18nTimeDate
  3. beegoTplFuncMap["TransMoney"] = i18n.I18nMoney
  5. func I18nT(args ...interface{}) string {
  6.     ok := false
  7.     var s string
  8.     if len(args) == 1 {
  9.         s, ok = args[0].(string)
  10.     }
  11.     if !ok {
  12.         s = fmt.Sprint(args...)
  13.     }
  14.     return beego.Translation.Translate(s)
  15. }
  17. func I18nTimeDate(args ...interface{}) string {
  18.     ok := false
  19.     var s string
  20.     if len(args) == 1 {
  21.         s, ok = args[0].(string)
  22.     }
  23.     if !ok {
  24.         s = fmt.Sprint(args...)
  25.     }
  26.     return beego.Translation.Time(s)
  27. }    
  29. func I18nMoney(args ...interface{}) string {
  30.     ok := false
  31.     var s string
  32.     if len(args) == 1 {
  33.         s, ok = args[0].(string)
  34.     }
  35.     if !ok {
  36.         s = fmt.Sprint(args...)
  37.     }
  38.     return beego.Translation.Money(s)
  39. }

Multi-language development

  1. Setting the language and location of the language pack, then initialize i18n objects:

    1.  beego.Lang = "zh"
    2.  beego.LangPath = "views/lang"
    3.  beego.InitLang()

  2. Designing a multi-language package

    Above, we talked about how to initialize a multi-language package. Now, let’s look at how to design one. Multi-language packages are typically JSON files, as you’ve already seen in Chapter 10. We must provide translation files for languages we wish to support on our LangPath, such as the following: 

    1.  # zh.json
    3.  {
    4.  "zh": {
    5.      "submit": "提交",
    6.      "create": "创建"
    7.      }
    8.  }
    10.  # en.json
    12.  {
    13.  "en": {
    14.      "submit": "Submit",
    15.      "create": "Create"
    16.      }
    17.  }

  3. Using language packages

    We can call the controller to get the translated response in the desired language, like so:

    1.  func (this *MainController) Get() {
    2.      this.Data["create"] = beego.Translation.Translate("create")
    3.      this.TplNames = "index.tpl"
    4.  }

    We can also directly interpolate translated responses in our templates:

    1.  // Direct Text translation
    2.  {{.create | Trans}}
    4.  // Time to translate
    5.  {{.time | TransDate}}
    7.  // Currency translation
    8.  {{.money | TransMoney}}