Go 程序如何做国际化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package main
​
import (
    "fmt"
    "github.com/youthlin/t"
)
​
func main() {
    t.Load("./lang")
    fmt.Println(t.T("Hello, World"))
}

1
2
3

go get -u github.com/youthlin/t
# 国内镜像
go mod edit -replace github.com/youthlin/t@latest=gitee.com/youthlin/gottext@latest&&go mod tidy

1
2
3
4

import "github.com/youthlin/t"
​
t.Load("path/to/xx.po")
fmt.Println(t.T("Hello, World"))

1

‪xgettext -C --add-comments=TRANSLATORS: --force-po ‪-kT -kN:1,2 -kX:2,1c -kXN:2,3,1c  *.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

go install github.com/youthlin/t/cmd/xtemplate@latest
​
# 用法
xtemplate -h
# 输出
xtemplate -i 输入文件 -k 关键字 [-f 模版中函数] [-o 输出文件]
  -d    debug 模式
  -f string
        模板中用到的函数名
  -h    显示帮助信息
  -i string
        输入文件
  -k string
        关键字，例： gettext;T:1;N1,2;X:1c,2;XN:1c,2,3
  -left string
        左分隔符 (default "{{")
  -o string
        输出文件，- 表示标准输出
  -right string
        右分隔符 (default "}}")
  -v    显示版本号

1
2

$ go run .
你好，世界

1
2
3
4

t.T(msgID, args...)
t.N(msgID, msgIDPlural, n, args...) // N64
t.X(msgContext, msgID, args...)
t.XN(msgCtxt, msgID, msgPlural, n, args...) // XN64

1
2

t.T("Hello, %v", name) // 你好，name
t.N("One apple", "%d apples", n, n) // n 个苹果

1
2

t.X("droplist item", "Post") // 下拉列表中的项目，翻译为“文章”
t.X("button", "Post") // 按钮文字，翻译为“发表”

1
2
3
4
5

t.Bind("my-domain", "path/to/xxx.po") // 将翻译文件绑定到文本域
t.T("Hello") // 使用默认的文本域
t.SetDomain("my-domain") // 切换文本域
t.T("Hello") // 使用 my-domain 文本域
t.D("other-domain").T("Hello") // 临时切换文本域，如果找不到绑定，会直接返回原文

1
2

// t.SetLocale("zh_CN") // 这样会全局生效，影响其他用户
t.L("zh_CN").T("Hello") // t.L 会返回一个使用指定语言的新的实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 1 获取所有支持的语言（Load 翻译文件时会记录都加载了哪些语言）
langs := t.Locales()
// 2 判断用户偏好的语言
// Go 国际化和语言标识符
// EN: https://blog.golang.org/matchlang
// 中文: https://learnku.com/docs/go-blog/matchlang/6525
// 2.1 转为 language.Tag 结构 import "golang.org/x/text/language"
var supported []language.Tag
for _, lang =range langs{
    supported = append(supported, language.Make(lang))
}
// 2.2 匹配器
matcher := language.NewMatcher(supported)
// 2.3 用户接受的语言
userAccept, q, err :=language.ParseAcceptLanguage("zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6")
// 2.4 得到最匹配的语言
matchedTag, index, confidence := matcher.Match(userAccept...)
userLang := langs[index]
// 3 使用用户语言
t.L(userLang).T("Hello")

1
2
3

<p>
  {{ .t.T "Hello, World" }}
</p>

1
2
3

fmt.Printf(t.N("One apple", "%d apples", n), n)
// n == 1 时相当于
fmt.Printf("One apple", 1) // 有额外的参数

1
2

fmt.Printf("One apple", 1) // 输出 "One apple%!(EXTRA int=1)"
fmt.Printf("One apple%[2]s", 1, "") // 输出 "One apple" 这样，参数 1 虽然没有使用，但不会有额外输出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// Format format a string with args, like fmt.Sprintf,
// but if args tow many, not prints %!(EXTRA type=value);
// and if no args, will return original string,
// even it contains some verb(like %v/%d), it would not prints MISSING error.
// 格式化字符串，功能同 fmt.Sprintf, 但是当参数多于占位符时，
// 不会输出额外的 %!(EXTRA type=value)；
// 当 args 为空时直接返回原字符串（若包含格式化动词也原样返回而不会打印 MISSING 错误）
func Format(format string, args ...interface{}) string {
    var length = len(args)
    if length == 0 {
        return format
    }
    // 原理：使用索引指定参数位置，在 args 后拼接一个空白字符串，
    // 然后在格式化字符串上使用 %[n]s 输出拼接的空白字符串，这样就没有多余的参数了
    // see fmt 包注释，或中文文档 https://studygolang.com/static/pkgdoc/pkg/fmt.htm
    args = append(args, "")
    format = fmt.Sprintf("%s%%[%d]s", format, length+1)
    return fmt.Sprintf(format, args...)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

grammar plural;
​
// 关于复数表达式的官方描述：
// https://www.gnu.org/software/gettext/manual/html_node/Plural-forms.html#index-specifying-plural-form-in-a-PO-file
// plural 表达式是 C 语法的表达式，但不允许负数出现，而且只能出现整数，变量只允许 n。可以有空白，但不能反斜杠换行。
​
// 生成 Go 代码的命令 （在本目录下执行）： antlr4 -Dlanguage=Go plural.g4 -o parser
​
start: exp;
exp:
    primary
    | exp postfix = ('++' | '--')
    | prefix = ('+' | '-' | '++' | '--') exp
    | prefix = ('~' | '!') exp
    | exp bop = ('*' | '/' | '%') exp
    | exp bop = ('+' | '-') exp
    | exp bop = ('>>' | '<<') exp
    | exp bop = ('>' | '<') exp
    | exp bop = ('>=' | '<=') exp
    | exp bop = ('==' | '!=') exp
    | exp bop = '&' exp
    | exp bop = '^' exp
    | exp bop = '|' exp
    | exp bop = '&&' exp
    | exp bop = '||' exp
    | <assoc = right> exp bop = '?' exp ':' exp;
primary: '(' exp ')' | 'n' | INT;
INT: [0-9]+;
WS: [ \t]+ -> skip;
​

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package t

import (
	"io/fs"
	"os"
	"path/filepath"
)

// asFS path as FS. if path is dir return os.DirFS, or return singleFileFS
func asFS(path string) fs.FS {
	return pathFS(path)
}

type pathFS string

func (f pathFS) Open(name string) (fs.File, error) {
	path := string(f)
	// os.DirFS(path): Open(path + "/" + name)
	return os.Open(filepath.Join(path, name))
}