db, _ := gorm.Open("mysql", "user:password@/dbname?charset=utf8&parseTime=True&loc=Local")

I18n := i18n.New(
    database.New(&db), // load translations from the database
    yaml.New(filepath.Join(config.Root, "config/locales")), // load translations from the YAML files in directory `config/locales`
)

en-US:
  demo:
    hello: "Hello, world"

I18n.T("en-US", "demo.greeting") // Not exist at first
I18n.T("en-US", "demo.hello") // Exists in the yml file

locpool.Resources["en"] = map[string]string{
    // Page title
    "Hello": "Hello!",

    // {N} is the number of messages
    "YouHaveNMessages": "You have {N} {N_PLURAL:message|messages}",
}

package main

import (
    "github.com/iafan/Plurr/go/plurr"
    "github.com/iafan/go-l10n/loc"
)

// Create a global localization pool which will be populated
// by resource files; use English as a default (fallback) language
var locpool = loc.NewPool("en")

func main() {
  // Get Russian localization context
  lc := locpool.GetContext("ru")

  // Get translation by key name:
  name := lc.Tr("Hello")

  // get translation by key name, then format it using Plurr:
  hello := lc.Format("YouHaveNMessages", plurr.Params{"N": 5})

  ...
}

fmt.Println(gettext.Gettext("Hello, world!"))

package main

import (
	"fmt"

	"github.com/gosexy/gettext"
)

func main() {
	textDomain := "default"

	gettext.BindTextdomain(textDomain, "path/to/domains")
	gettext.Textdomain(textDomain)

	gettext.SetLocale(gettext.LcAll, "es_MX.utf8")

	fmt.Println(gettext.Gettext("Hello, world!"))
}

i18n.Message{
    ID: "PersonCats",
    One: "{{.Name}} has {{.Count}} cat.",
    Other: "{{.Name}} has {{.Count}} cats.",
}

# active.en.toml
[PersonCats]
description = "The number of cats a person has"
one = "{{.Name}} has {{.Count}} cat."
other = "{{.Name}} has {{.Count}} cats."

import （
	"fmt"

	"github.com/nicksnyder/go-i18n/v2/i18n"
）

func main() {
	bundle := i18n.NewBundle(language.English)
    bundle.RegisterUnmarshalFunc("toml", toml.Unmarshal)
	bundle.LoadMessageFile("es.toml")
    localizer := i18n.NewLocalizer(bundle, lang, accept)
    helloPersonMessage := &i18n.Message{
        ID:    "HelloPerson",
        Other: "Hello {{.Name}}!",
	}

    fmt.Println(localizer.MustLocalize(&i18n.LocalizeConfig{
        DefaultMessage: helloPersonMessage,
        TemplateData:   map[string]string{"Name": "Nick"},
    }))
}

message.SetString(language.Dutch, "You have chosen to play %m.", "U heeft ervoor gekozen om %m te spelen.")
message.SetString(language.Dutch, "basketball", "basketbal")
message.SetString(language.Dutch, "hockey", "ijshockey")
message.SetString(language.Dutch, "soccer", "voetbal")
message.SetString(language.BritishEnglish, "soccer", "football")

for _, sport := range []string{"soccer", "basketball", "hockey"} {
    for _, lang := range []string{"en", "en-GB", "nl"} {
        p := message.NewPrinter(language.Make(lang))
        fmt.Printf("%-6s %s\n", lang, p.Sprintf("You have chosen to play %m.", sport))
    }
    fmt.Println()
}

ast.Inspect(f, func(n ast.Node) bool {
    call, ok := n.(*ast.CallExpr)
    if !ok {
        return true
    }
    fn, ok := call.Fun.(*ast.SelectorExpr)
    if !ok {
        return true
    }
    pack, ok := fn.X.(*ast.Ident)
    if !ok {
        return true
    }
    if pack.Name != "i18n" {
        return true
    }
    if len(call.Args) == 0 {
        return true
    }
    str, ok := call.Args[0].(*ast.BasicLit)
    if !ok {
        return true
    }

    // Keep this for later debug usage.
    // log.Printf("%v", str.Value)
    data[str.Value] = str.Value
    return true
})

import (
    "github.com/Xuanwo/go-locale"
)

func main() {
	tag, err := locale.Detect()
    if err != nil {
        log.Fatal(err)
    }
    // Have fun with language.Tag!
}

func newMatcher(t []language.Tag) *matcher {
	tags := &matcher{make(map[language.Tag]int)}
	for i, tag := range t {
		ct, err := language.All.Canonicalize(tag)
		if err != nil {
			ct = tag
		}
		tags.index[ct] = i
	}
	return tags
}

type matcher struct {
	index map[language.Tag]int
}

func (m matcher) Match(want ...language.Tag) (language.Tag, int, language.Confidence) {
	for _, t := range want {
		ct, err := language.All.Canonicalize(t)
		if err != nil {
			ct = t
		}
		conf := language.Exact
		for {
			if index, ok := m.index[ct]; ok {
				return ct, index, conf
			}
			if ct == language.Und {
				break
			}
			ct = ct.Parent()
			conf = language.High
		}
	}
	return language.Und, 0, language.No
}

// Init will init i18n support via input language.
func Init(lang language.Tag) {
	tag, _, _ := supported.Match(lang)
	switch tag {
	case language.AmericanEnglish, language.English:
		initEnUS(lang)
	case language.SimplifiedChinese, language.Chinese:
		initZhCN(lang)
	default:
		initEnUS(lang)
	}
}

i18n.Printf("File <%s> copied to <%s>.\n", t.GetSourcePath(), t.GetDestinationPath())