From 83b055d6dfcc77c8d22f5f7a1e4683e6ead3eb33 Mon Sep 17 00:00:00 2001 From: Foolin Date: Fri, 6 Jul 2018 17:32:31 +0800 Subject: [PATCH 1/3] add chinese lang --- translations/zh/zh.go | 1361 ++++++++++++++++++++++++++++++++++++ translations/zh/zh_test.go | 634 +++++++++++++++++ 2 files changed, 1995 insertions(+) create mode 100644 translations/zh/zh.go create mode 100644 translations/zh/zh_test.go diff --git a/translations/zh/zh.go b/translations/zh/zh.go new file mode 100644 index 0000000..b88b9da --- /dev/null +++ b/translations/zh/zh.go @@ -0,0 +1,1361 @@ +package en + +import ( + "fmt" + "log" + "reflect" + "strconv" + "strings" + "time" + + "github.com/go-playground/locales" + "github.com/go-playground/universal-translator" + "gopkg.in/go-playground/validator.v9" +) + +// RegisterDefaultTranslations registers a set of default translations +// for all built in tag's in validator; you may add your own as desired. +func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (err error) { + + translations := []struct { + tag string + translation string + override bool + customRegisFunc validator.RegisterTranslationsFunc + customTransFunc validator.TranslationFunc + }{ + { + tag: "required", + translation: "{0}为必填字段", + override: false, + }, + { + tag: "len", + customRegisFunc: func(ut ut.Translator) (err error) { + + if err = ut.Add("len-string", "{0}长度必须为{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("len-string-character", "{0}字符", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("len-string-character", "{0}字符", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("len-number", "{0}必须等于{1}", false); err != nil { + return + } + + if err = ut.Add("len-items", "{0}必须包含{1}", false); err != nil { + return + } + //if err = ut.AddCardinal("len-items-item", "{0}项", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("len-items-item", "{0}项", locales.PluralRuleOther, false); err != nil { + return + } + + return + + }, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + var err error + var t string + + var digits uint64 + var kind reflect.Kind + + if idx := strings.Index(fe.Param(), "."); idx != -1 { + digits = uint64(len(fe.Param()[idx+1:])) + } + + f64, err := strconv.ParseFloat(fe.Param(), 64) + if err != nil { + goto END + } + + kind = fe.Kind() + if kind == reflect.Ptr { + kind = fe.Type().Elem().Kind() + } + + switch kind { + case reflect.String: + + var c string + + c, err = ut.C("len-string-character", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("len-string", fe.Field(), c) + + case reflect.Slice, reflect.Map, reflect.Array: + var c string + + c, err = ut.C("len-items-item", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("len-items", fe.Field(), c) + + default: + t, err = ut.T("len-number", fe.Field(), ut.FmtNumber(f64, digits)) + } + + END: + if err != nil { + fmt.Printf("警告: 翻译字段错误: %s", err) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "min", + customRegisFunc: func(ut ut.Translator) (err error) { + + if err = ut.Add("min-string", "{0}长度最小只能为{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("min-string-character", "{0}个字符", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("min-string-character", "{0}个字符", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("min-number", "{0}必须大于或者等于{1}", false); err != nil { + return + } + + if err = ut.Add("min-items", "{0}必须最少包含{1}", false); err != nil { + return + } + //if err = ut.AddCardinal("min-items-item", "{0}项", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("min-items-item", "{0}项", locales.PluralRuleOther, false); err != nil { + return + } + + return + + }, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + var err error + var t string + + var digits uint64 + var kind reflect.Kind + + if idx := strings.Index(fe.Param(), "."); idx != -1 { + digits = uint64(len(fe.Param()[idx+1:])) + } + + f64, err := strconv.ParseFloat(fe.Param(), 64) + if err != nil { + goto END + } + + kind = fe.Kind() + if kind == reflect.Ptr { + kind = fe.Type().Elem().Kind() + } + + switch kind { + case reflect.String: + + var c string + + c, err = ut.C("min-string-character", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("min-string", fe.Field(), c) + + case reflect.Slice, reflect.Map, reflect.Array: + var c string + + c, err = ut.C("min-items-item", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("min-items", fe.Field(), c) + + default: + t, err = ut.T("min-number", fe.Field(), ut.FmtNumber(f64, digits)) + } + + END: + if err != nil { + fmt.Printf("警告: 翻译字段错误: %s", err) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "max", + customRegisFunc: func(ut ut.Translator) (err error) { + + if err = ut.Add("max-string", "{0}长度最大只能为{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("max-string-character", "{0}个字符", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("max-string-character", "{0}个字符", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("max-number", "{0}必须小于或者等于{1}", false); err != nil { + return + } + + if err = ut.Add("max-items", "{0}包含最大数量为{1}", false); err != nil { + return + } + //if err = ut.AddCardinal("max-items-item", "{0}项", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("max-items-item", "{0}项", locales.PluralRuleOther, false); err != nil { + return + } + + return + + }, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + var err error + var t string + + var digits uint64 + var kind reflect.Kind + + if idx := strings.Index(fe.Param(), "."); idx != -1 { + digits = uint64(len(fe.Param()[idx+1:])) + } + + f64, err := strconv.ParseFloat(fe.Param(), 64) + if err != nil { + goto END + } + + kind = fe.Kind() + if kind == reflect.Ptr { + kind = fe.Type().Elem().Kind() + } + + switch kind { + case reflect.String: + + var c string + + c, err = ut.C("max-string-character", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("max-string", fe.Field(), c) + + case reflect.Slice, reflect.Map, reflect.Array: + var c string + + c, err = ut.C("max-items-item", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("max-items", fe.Field(), c) + + default: + t, err = ut.T("max-number", fe.Field(), ut.FmtNumber(f64, digits)) + } + + END: + if err != nil { + fmt.Printf("警告: 翻译字段错误: %s", err) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "eq", + translation: "{0}不等于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + fmt.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "ne", + translation: "{0}不能等于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + fmt.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "lt", + customRegisFunc: func(ut ut.Translator) (err error) { + + if err = ut.Add("lt-string", "{0}长度必须小于{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("lt-string-character", "{0}个字符", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("lt-string-character", "{0}个字符", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("lt-number", "{0}必须小于{1}", false); err != nil { + return + } + + if err = ut.Add("lt-items", "{0}包含最小数量为{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("lt-items-item", "{0}项", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("lt-items-item", "{0}项", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("lt-datetime", "{0}必须小于当前日期和时间", false); err != nil { + return + } + + return + + }, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + var err error + var t string + var f64 float64 + var digits uint64 + var kind reflect.Kind + + fn := func() (err error) { + + if idx := strings.Index(fe.Param(), "."); idx != -1 { + digits = uint64(len(fe.Param()[idx+1:])) + } + + f64, err = strconv.ParseFloat(fe.Param(), 64) + + return + } + + kind = fe.Kind() + if kind == reflect.Ptr { + kind = fe.Type().Elem().Kind() + } + + switch kind { + case reflect.String: + + var c string + + err = fn() + if err != nil { + goto END + } + + c, err = ut.C("lt-string-character", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("lt-string", fe.Field(), c) + + case reflect.Slice, reflect.Map, reflect.Array: + var c string + + err = fn() + if err != nil { + goto END + } + + c, err = ut.C("lt-items-item", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("lt-items", fe.Field(), c) + + case reflect.Struct: + if fe.Type() != reflect.TypeOf(time.Time{}) { + err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag()) + } + + t, err = ut.T("lt-datetime", fe.Field()) + + default: + err = fn() + if err != nil { + goto END + } + + t, err = ut.T("lt-number", fe.Field(), ut.FmtNumber(f64, digits)) + } + + END: + if err != nil { + fmt.Printf("警告: 翻译字段错误: %s", err) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "lte", + customRegisFunc: func(ut ut.Translator) (err error) { + + if err = ut.Add("lte-string", "{0}长度不能超过{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("lte-string-character", "{0} character", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("lte-string-character", "{0}字符", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("lte-number", "{0}必须小于或者等于{1}", false); err != nil { + return + } + + if err = ut.Add("lte-items", "{0}最大数不能超过{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("lte-items-item", "{0} item", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("lte-items-item", "{0} items", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("lte-datetime", "{0}小于或者等于当前日期和时间", false); err != nil { + return + } + + return + }, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + var err error + var t string + var f64 float64 + var digits uint64 + var kind reflect.Kind + + fn := func() (err error) { + + if idx := strings.Index(fe.Param(), "."); idx != -1 { + digits = uint64(len(fe.Param()[idx+1:])) + } + + f64, err = strconv.ParseFloat(fe.Param(), 64) + + return + } + + kind = fe.Kind() + if kind == reflect.Ptr { + kind = fe.Type().Elem().Kind() + } + + switch kind { + case reflect.String: + + var c string + + err = fn() + if err != nil { + goto END + } + + c, err = ut.C("lte-string-character", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("lte-string", fe.Field(), c) + + case reflect.Slice, reflect.Map, reflect.Array: + var c string + + err = fn() + if err != nil { + goto END + } + + c, err = ut.C("lte-items-item", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("lte-items", fe.Field(), c) + + case reflect.Struct: + if fe.Type() != reflect.TypeOf(time.Time{}) { + err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag()) + } + + t, err = ut.T("lte-datetime", fe.Field()) + + default: + err = fn() + if err != nil { + goto END + } + + t, err = ut.T("lte-number", fe.Field(), ut.FmtNumber(f64, digits)) + } + + END: + if err != nil { + fmt.Printf("警告: 翻译字段错误: %s", err) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "gt", + customRegisFunc: func(ut ut.Translator) (err error) { + + if err = ut.Add("gt-string", "{0}长度必须大于{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("gt-string-character", "{0}个字符", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("gt-string-character", "{0}个字符", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("gt-number", "{0}必须大于{1}", false); err != nil { + return + } + + if err = ut.Add("gt-items", "{0}数量必须大于{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("gt-items-item", "{0}项", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("gt-items-item", "{0}项", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("gt-datetime", "{0}必须大于当前日期和时间", false); err != nil { + return + } + + return + }, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + var err error + var t string + var f64 float64 + var digits uint64 + var kind reflect.Kind + + fn := func() (err error) { + + if idx := strings.Index(fe.Param(), "."); idx != -1 { + digits = uint64(len(fe.Param()[idx+1:])) + } + + f64, err = strconv.ParseFloat(fe.Param(), 64) + + return + } + + kind = fe.Kind() + if kind == reflect.Ptr { + kind = fe.Type().Elem().Kind() + } + + switch kind { + case reflect.String: + + var c string + + err = fn() + if err != nil { + goto END + } + + c, err = ut.C("gt-string-character", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("gt-string", fe.Field(), c) + + case reflect.Slice, reflect.Map, reflect.Array: + var c string + + err = fn() + if err != nil { + goto END + } + + c, err = ut.C("gt-items-item", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("gt-items", fe.Field(), c) + + case reflect.Struct: + if fe.Type() != reflect.TypeOf(time.Time{}) { + err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag()) + } + + t, err = ut.T("gt-datetime", fe.Field()) + + default: + err = fn() + if err != nil { + goto END + } + + t, err = ut.T("gt-number", fe.Field(), ut.FmtNumber(f64, digits)) + } + + END: + if err != nil { + fmt.Printf("警告: 翻译字段错误: %s", err) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "gte", + customRegisFunc: func(ut ut.Translator) (err error) { + + if err = ut.Add("gte-string", "{0}长度只能大于或者等于{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("gte-string-character", "{0}个字符", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("gte-string-character", "{0}个字符", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("gte-number", "{0}必须大于或者等于{1}", false); err != nil { + return + } + + if err = ut.Add("gte-items", "{0}必须大于或者等于{1}", false); err != nil { + return + } + + //if err = ut.AddCardinal("gte-items-item", "{0}项", locales.PluralRuleOne, false); err != nil { + // return + //} + + if err = ut.AddCardinal("gte-items-item", "{0}项", locales.PluralRuleOther, false); err != nil { + return + } + + if err = ut.Add("gte-datetime", "{0}必须大于或者等于当前日期和时间", false); err != nil { + return + } + + return + }, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + var err error + var t string + var f64 float64 + var digits uint64 + var kind reflect.Kind + + fn := func() (err error) { + + if idx := strings.Index(fe.Param(), "."); idx != -1 { + digits = uint64(len(fe.Param()[idx+1:])) + } + + f64, err = strconv.ParseFloat(fe.Param(), 64) + + return + } + + kind = fe.Kind() + if kind == reflect.Ptr { + kind = fe.Type().Elem().Kind() + } + + switch kind { + case reflect.String: + + var c string + + err = fn() + if err != nil { + goto END + } + + c, err = ut.C("gte-string-character", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("gte-string", fe.Field(), c) + + case reflect.Slice, reflect.Map, reflect.Array: + var c string + + err = fn() + if err != nil { + goto END + } + + c, err = ut.C("gte-items-item", f64, digits, ut.FmtNumber(f64, digits)) + if err != nil { + goto END + } + + t, err = ut.T("gte-items", fe.Field(), c) + + case reflect.Struct: + if fe.Type() != reflect.TypeOf(time.Time{}) { + err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag()) + } + + t, err = ut.T("gte-datetime", fe.Field()) + + default: + err = fn() + if err != nil { + goto END + } + + t, err = ut.T("gte-number", fe.Field(), ut.FmtNumber(f64, digits)) + } + + END: + if err != nil { + fmt.Printf("警告: 翻译字段错误: %s", err) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "eqfield", + translation: "{0}必须等于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "eqcsfield", + translation: "{0}必须等于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "necsfield", + translation: "{0}不能等于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "gtcsfield", + translation: "{0}必须大于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "gtecsfield", + translation: "{0}必须大于或者等于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "ltcsfield", + translation: "{0}必须小于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "ltecsfield", + translation: "{0}必须小于或者等于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "nefield", + translation: "{0}不能等于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "gtfield", + translation: "{0}必须大于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "gtefield", + translation: "{0} must be greater than or equal to {1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "ltfield", + translation: "{0}必须小于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "ltefield", + translation: "{0}必须小于或者等于{1}", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "alpha", + translation: "{0}只能包含字母", + override: false, + }, + { + tag: "alphanum", + translation: "{0}只能包含字母和数字", + override: false, + }, + { + tag: "numeric", + translation: "{0}必须是一个有效的数值", + override: false, + }, + { + tag: "number", + translation: "{0}必须是一个有效的数字", + override: false, + }, + { + tag: "hexadecimal", + translation: "{0}必须是一个有效的十六进制", + override: false, + }, + { + tag: "hexcolor", + translation: "{0}必须是一个有效的十六进制颜色", + override: false, + }, + { + tag: "rgb", + translation: "{0}必须是一个有效的RGB颜色", + override: false, + }, + { + tag: "rgba", + translation: "{0} 必须是一个有效的RGBA颜色", + override: false, + }, + { + tag: "hsl", + translation: "{0}必须是一个有效的HSL颜色", + override: false, + }, + { + tag: "hsla", + translation: "{0}必须是一个有效的HSLA颜色r", + override: false, + }, + { + tag: "email", + translation: "{0}必须是一个有效的邮箱", + override: false, + }, + { + tag: "url", + translation: "{0}必须是一个有效的URL", + override: false, + }, + { + tag: "uri", + translation: "{0}必须是一个有效的URI", + override: false, + }, + { + tag: "base64", + translation: "{0}必须是一个有效的Base64字符串", + override: false, + }, + { + tag: "contains", + translation: "{0}必须包含文本'{1}'", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "containsany", + translation: "{0}必须包含至少一个以下字符'{1}'", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "excludes", + translation: "{0}不能包含文本'{1}'", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "excludesall", + translation: "{0}不能包含以下任何字符'{1}'", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "excludesrune", + translation: "{0}不能包含'{1}'", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t + }, + }, + { + tag: "isbn", + translation: "{0}必须是有效的ISBN编号", + override: false, + }, + { + tag: "isbn10", + translation: "{0}必须是有效的ISBN-10编号", + override: false, + }, + { + tag: "isbn13", + translation: "{0}必须是有效的ISBN-13编号", + override: false, + }, + { + tag: "uuid", + translation: "{0}必须是有效的UUID", + override: false, + }, + { + tag: "uuid3", + translation: "{0}必须是有效的版本V3 UUID", + override: false, + }, + { + tag: "uuid4", + translation: "{0}必须是有效的版本V4 UUID", + override: false, + }, + { + tag: "uuid5", + translation: "{0}必须是有效的版本V5 UUID", + override: false, + }, + { + tag: "ascii", + translation: "{0}必须只包含ascii字符", + override: false, + }, + { + tag: "printascii", + translation: "{0}必须只包含可打印的ascii字符", + override: false, + }, + { + tag: "multibyte", + translation: "{0}必须包含多字节字符", + override: false, + }, + { + tag: "datauri", + translation: "{0}必须包含有效的数据URI", + override: false, + }, + { + tag: "latitude", + translation: "{0}必须包含有效的纬度坐标", + override: false, + }, + { + tag: "longitude", + translation: "{0}必须包含有效的经度坐标", + override: false, + }, + { + tag: "ssn", + translation: "{0}必须是一个有效的社会安全号码(SSN)", + override: false, + }, + { + tag: "ipv4", + translation: "{0}必须是一个有效的IPv4地址", + override: false, + }, + { + tag: "ipv6", + translation: "{0}必须是一个有效的IPv6地址", + override: false, + }, + { + tag: "ip", + translation: "{0}必须是一个有效的IP地址", + override: false, + }, + { + tag: "cidr", + translation: "{0}必须是一个有效的无类别域间路由(CIDR)", + override: false, + }, + { + tag: "cidrv4", + translation: "{0}必须是一个包含IPv4地址的有效无类别域间路由(CIDR)", + override: false, + }, + { + tag: "cidrv6", + translation: "{0}必须是一个包含IPv6地址的有效无类别域间路由(CIDR)", + override: false, + }, + { + tag: "tcp_addr", + translation: "{0}必须是一个有效的TCP地址", + override: false, + }, + { + tag: "tcp4_addr", + translation: "{0}必须是一个有效的IPv4 TCP地址", + override: false, + }, + { + tag: "tcp6_addr", + translation: "{0}必须是一个有效的IPv6 TCP地址", + override: false, + }, + { + tag: "udp_addr", + translation: "{0}必须是一个有效的UDP地址", + override: false, + }, + { + tag: "udp4_addr", + translation: "{0}必须是一个有效的IPv4 UDP地址", + override: false, + }, + { + tag: "udp6_addr", + translation: "{0}必须是一个有效的IPv6 UDP地址", + override: false, + }, + { + tag: "ip_addr", + translation: "{0}必须是一个有效的IP地址", + override: false, + }, + { + tag: "ip4_addr", + translation: "{0}必须是一个有效的IPv4地址", + override: false, + }, + { + tag: "ip6_addr", + translation: "{0}必须是一个有效的IPv6地址", + override: false, + }, + { + tag: "unix_addr", + translation: "{0}必须是一个有效的UNIX地址", + override: false, + }, + { + tag: "mac", + translation: "{0}必须是一个有效的MAC地址", + override: false, + }, + { + tag: "iscolor", + translation: "{0}必须是一个有效的颜色", + override: false, + }, + { + tag: "oneof", + translation: "{0}必须是[{1}]的其中一个", + override: false, + customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { + s, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + return s + }, + }, + } + + for _, t := range translations { + + if t.customTransFunc != nil && t.customRegisFunc != nil { + + err = v.RegisterTranslation(t.tag, trans, t.customRegisFunc, t.customTransFunc) + + } else if t.customTransFunc != nil && t.customRegisFunc == nil { + + err = v.RegisterTranslation(t.tag, trans, registrationFunc(t.tag, t.translation, t.override), t.customTransFunc) + + } else if t.customTransFunc == nil && t.customRegisFunc != nil { + + err = v.RegisterTranslation(t.tag, trans, t.customRegisFunc, translateFunc) + + } else { + err = v.RegisterTranslation(t.tag, trans, registrationFunc(t.tag, t.translation, t.override), translateFunc) + } + + if err != nil { + return + } + } + + return +} + +func registrationFunc(tag string, translation string, override bool) validator.RegisterTranslationsFunc { + + return func(ut ut.Translator) (err error) { + + if err = ut.Add(tag, translation, override); err != nil { + return + } + + return + + } + +} + +func translateFunc(ut ut.Translator, fe validator.FieldError) string { + + t, err := ut.T(fe.Tag(), fe.Field()) + if err != nil { + log.Printf("警告: 翻译字段错误: %#v", fe) + return fe.(error).Error() + } + + return t +} diff --git a/translations/zh/zh_test.go b/translations/zh/zh_test.go new file mode 100644 index 0000000..7bd0cb6 --- /dev/null +++ b/translations/zh/zh_test.go @@ -0,0 +1,634 @@ +package en + +import ( + "testing" + "time" + + zhongwen "github.com/go-playground/locales/zh" + "github.com/go-playground/universal-translator" + . "gopkg.in/go-playground/assert.v1" + "gopkg.in/go-playground/validator.v9" +) + +func TestTranslations(t *testing.T) { + + zh := zhongwen.New() + uni := ut.New(zh, zh) + trans, ok := uni.GetTranslator("zh") + + validate := validator.New() + + err := RegisterDefaultTranslations(validate, trans) + Equal(t, err, nil) + + type Inner struct { + EqCSFieldString string + NeCSFieldString string + GtCSFieldString string + GteCSFieldString string + LtCSFieldString string + LteCSFieldString string + } + + type Test struct { + Inner Inner + RequiredString string `validate:"required"` + RequiredNumber int `validate:"required"` + RequiredMultiple []string `validate:"required"` + LenString string `validate:"len=1"` + LenNumber float64 `validate:"len=1113.00"` + LenMultiple []string `validate:"len=7"` + MinString string `validate:"min=1"` + MinNumber float64 `validate:"min=1113.00"` + MinMultiple []string `validate:"min=7"` + MaxString string `validate:"max=3"` + MaxNumber float64 `validate:"max=1113.00"` + MaxMultiple []string `validate:"max=7"` + EqString string `validate:"eq=3"` + EqNumber float64 `validate:"eq=2.33"` + EqMultiple []string `validate:"eq=7"` + NeString string `validate:"ne="` + NeNumber float64 `validate:"ne=0.00"` + NeMultiple []string `validate:"ne=0"` + LtString string `validate:"lt=3"` + LtNumber float64 `validate:"lt=5.56"` + LtMultiple []string `validate:"lt=2"` + LtTime time.Time `validate:"lt"` + LteString string `validate:"lte=3"` + LteNumber float64 `validate:"lte=5.56"` + LteMultiple []string `validate:"lte=2"` + LteTime time.Time `validate:"lte"` + GtString string `validate:"gt=3"` + GtNumber float64 `validate:"gt=5.56"` + GtMultiple []string `validate:"gt=2"` + GtTime time.Time `validate:"gt"` + GteString string `validate:"gte=3"` + GteNumber float64 `validate:"gte=5.56"` + GteMultiple []string `validate:"gte=2"` + GteTime time.Time `validate:"gte"` + EqFieldString string `validate:"eqfield=MaxString"` + EqCSFieldString string `validate:"eqcsfield=Inner.EqCSFieldString"` + NeCSFieldString string `validate:"necsfield=Inner.NeCSFieldString"` + GtCSFieldString string `validate:"gtcsfield=Inner.GtCSFieldString"` + GteCSFieldString string `validate:"gtecsfield=Inner.GteCSFieldString"` + LtCSFieldString string `validate:"ltcsfield=Inner.LtCSFieldString"` + LteCSFieldString string `validate:"ltecsfield=Inner.LteCSFieldString"` + NeFieldString string `validate:"nefield=EqFieldString"` + GtFieldString string `validate:"gtfield=MaxString"` + GteFieldString string `validate:"gtefield=MaxString"` + LtFieldString string `validate:"ltfield=MaxString"` + LteFieldString string `validate:"ltefield=MaxString"` + AlphaString string `validate:"alpha"` + AlphanumString string `validate:"alphanum"` + NumericString string `validate:"numeric"` + NumberString string `validate:"number"` + HexadecimalString string `validate:"hexadecimal"` + HexColorString string `validate:"hexcolor"` + RGBColorString string `validate:"rgb"` + RGBAColorString string `validate:"rgba"` + HSLColorString string `validate:"hsl"` + HSLAColorString string `validate:"hsla"` + Email string `validate:"email"` + URL string `validate:"url"` + URI string `validate:"uri"` + Base64 string `validate:"base64"` + Contains string `validate:"contains=purpose"` + ContainsAny string `validate:"containsany=!@#$"` + Excludes string `validate:"excludes=text"` + ExcludesAll string `validate:"excludesall=!@#$"` + ExcludesRune string `validate:"excludesrune=☻"` + ISBN string `validate:"isbn"` + ISBN10 string `validate:"isbn10"` + ISBN13 string `validate:"isbn13"` + UUID string `validate:"uuid"` + UUID3 string `validate:"uuid3"` + UUID4 string `validate:"uuid4"` + UUID5 string `validate:"uuid5"` + ASCII string `validate:"ascii"` + PrintableASCII string `validate:"printascii"` + MultiByte string `validate:"multibyte"` + DataURI string `validate:"datauri"` + Latitude string `validate:"latitude"` + Longitude string `validate:"longitude"` + SSN string `validate:"ssn"` + IP string `validate:"ip"` + IPv4 string `validate:"ipv4"` + IPv6 string `validate:"ipv6"` + CIDR string `validate:"cidr"` + CIDRv4 string `validate:"cidrv4"` + CIDRv6 string `validate:"cidrv6"` + TCPAddr string `validate:"tcp_addr"` + TCPAddrv4 string `validate:"tcp4_addr"` + TCPAddrv6 string `validate:"tcp6_addr"` + UDPAddr string `validate:"udp_addr"` + UDPAddrv4 string `validate:"udp4_addr"` + UDPAddrv6 string `validate:"udp6_addr"` + IPAddr string `validate:"ip_addr"` + IPAddrv4 string `validate:"ip4_addr"` + IPAddrv6 string `validate:"ip6_addr"` + UinxAddr string `validate:"unix_addr"` // can't fail from within Go's net package currently, but maybe in the future + MAC string `validate:"mac"` + IsColor string `validate:"iscolor"` + StrPtrMinLen *string `validate:"min=10"` + StrPtrMaxLen *string `validate:"max=1"` + StrPtrLen *string `validate:"len=2"` + StrPtrLt *string `validate:"lt=1"` + StrPtrLte *string `validate:"lte=1"` + StrPtrGt *string `validate:"gt=10"` + StrPtrGte *string `validate:"gte=10"` + OneOfString string `validate:"oneof=red green"` + OneOfInt int `validate:"oneof=5 63"` + } + + var test Test + + test.Inner.EqCSFieldString = "1234" + test.Inner.GtCSFieldString = "1234" + test.Inner.GteCSFieldString = "1234" + + test.MaxString = "1234" + test.MaxNumber = 2000 + test.MaxMultiple = make([]string, 9) + + test.LtString = "1234" + test.LtNumber = 6 + test.LtMultiple = make([]string, 3) + test.LtTime = time.Now().Add(time.Hour * 24) + + test.LteString = "1234" + test.LteNumber = 6 + test.LteMultiple = make([]string, 3) + test.LteTime = time.Now().Add(time.Hour * 24) + + test.LtFieldString = "12345" + test.LteFieldString = "12345" + + test.LtCSFieldString = "1234" + test.LteCSFieldString = "1234" + + test.AlphaString = "abc3" + test.AlphanumString = "abc3!" + test.NumericString = "12E.00" + test.NumberString = "12E" + + test.Excludes = "this is some test text" + test.ExcludesAll = "This is Great!" + test.ExcludesRune = "Love it ☻" + + test.ASCII = "ｶﾀｶﾅ" + test.PrintableASCII = "ｶﾀｶﾅ" + + test.MultiByte = "1234feerf" + + s := "toolong" + test.StrPtrMaxLen = &s + test.StrPtrLen = &s + + err = validate.Struct(test) + NotEqual(t, err, nil) + + errs, ok := err.(validator.ValidationErrors) + Equal(t, ok, true) + + tests := []struct { + ns string + expected string + }{ + { + ns: "Test.IsColor", + expected: "IsColor必须是一个有效的颜色", + }, + { + ns: "Test.MAC", + expected: "MAC必须是一个有效的MAC地址", + }, + { + ns: "Test.IPAddr", + expected: "IPAddr必须是一个有效的IP地址", + }, + { + ns: "Test.IPAddrv4", + expected: "IPAddrv4必须是一个有效的IPv4地址", + }, + { + ns: "Test.IPAddrv6", + expected: "IPAddrv6必须是一个有效的IPv6地址", + }, + { + ns: "Test.UDPAddr", + expected: "UDPAddr必须是一个有效的UDP地址", + }, + { + ns: "Test.UDPAddrv4", + expected: "UDPAddrv4必须是一个有效的IPv4 UDP地址", + }, + { + ns: "Test.UDPAddrv6", + expected: "UDPAddrv6必须是一个有效的IPv6 UDP地址", + }, + { + ns: "Test.TCPAddr", + expected: "TCPAddr必须是一个有效的TCP地址", + }, + { + ns: "Test.TCPAddrv4", + expected: "TCPAddrv4必须是一个有效的IPv4 TCP地址", + }, + { + ns: "Test.TCPAddrv6", + expected: "TCPAddrv6必须是一个有效的IPv6 TCP地址", + }, + { + ns: "Test.CIDR", + expected: "CIDR必须是一个有效的无类别域间路由(CIDR)", + }, + { + ns: "Test.CIDRv4", + expected: "CIDRv4必须是一个包含IPv4地址的有效无类别域间路由(CIDR)", + }, + { + ns: "Test.CIDRv6", + expected: "CIDRv6必须是一个包含IPv6地址的有效无类别域间路由(CIDR)", + }, + { + ns: "Test.SSN", + expected: "SSN必须是一个有效的社会安全号码(SSN)", + }, + { + ns: "Test.IP", + expected: "IP必须是一个有效的IP地址", + }, + { + ns: "Test.IPv4", + expected: "IPv4必须是一个有效的IPv4地址", + }, + { + ns: "Test.IPv6", + expected: "IPv6必须是一个有效的IPv6地址", + }, + { + ns: "Test.DataURI", + expected: "DataURI必须包含有效的数据URI", + }, + { + ns: "Test.Latitude", + expected: "Latitude必须包含有效的纬度坐标", + }, + { + ns: "Test.Longitude", + expected: "Longitude必须包含有效的经度坐标", + }, + { + ns: "Test.MultiByte", + expected: "MultiByte必须包含多字节字符", + }, + { + ns: "Test.ASCII", + expected: "ASCII必须只包含ascii字符", + }, + { + ns: "Test.PrintableASCII", + expected: "PrintableASCII必须只包含可打印的ascii字符", + }, + { + ns: "Test.UUID", + expected: "UUID必须是一个有效的UUID", + }, + { + ns: "Test.UUID3", + expected: "UUID3必须是一个有效的V3 UUID", + }, + { + ns: "Test.UUID4", + expected: "UUID4必须是一个有效的V4 UUID", + }, + { + ns: "Test.UUID5", + expected: "UUID5必须是一个有效的V5 UUID", + }, + { + ns: "Test.ISBN", + expected: "ISBN必须是一个有效的ISBN号码", + }, + { + ns: "Test.ISBN10", + expected: "ISBN10必须是一个有效的ISBN-10号码", + }, + { + ns: "Test.ISBN13", + expected: "ISBN13必须是一个有效的ISBN-13号码", + }, + { + ns: "Test.Excludes", + expected: "Excludes不能包含文本'text'", + }, + { + ns: "Test.ExcludesAll", + expected: "ExcludesAll不能包含以下任何字符'!@#$'", + }, + { + ns: "Test.ExcludesRune", + expected: "ExcludesRune不能包含'☻'", + }, + { + ns: "Test.ContainsAny", + expected: "ContainsAny必须包含至少一个以下字符'!@#$'", + }, + { + ns: "Test.Contains", + expected: "Contains必须包含的文本'purpose'", + }, + { + ns: "Test.Base64", + expected: "Base64必须是一个有效的Base64字符串", + }, + { + ns: "Test.Email", + expected: "Email必须是一个有效的邮箱地址", + }, + { + ns: "Test.URL", + expected: "URL必须是一个有效的URL", + }, + { + ns: "Test.URI", + expected: "URI必须是一个有效的URI", + }, + { + ns: "Test.RGBColorString", + expected: "RGBColorString必须是一个有效的RGB颜色", + }, + { + ns: "Test.RGBAColorString", + expected: "RGBAColorString必须是一个有效的RGBA颜色", + }, + { + ns: "Test.HSLColorString", + expected: "HSLColorString必须是一个有效的HSL颜色", + }, + { + ns: "Test.HSLAColorString", + expected: "HSLAColorString必须是有效的HSLA颜色", + }, + { + ns: "Test.HexadecimalString", + expected: "HexadecimalString must be a valid hexadecimal", + }, + { + ns: "Test.HexColorString", + expected: "HexColorString must be a valid HEX color", + }, + { + ns: "Test.NumberString", + expected: "NumberString must be a valid number", + }, + { + ns: "Test.NumericString", + expected: "NumericString must be a valid numeric value", + }, + { + ns: "Test.AlphanumString", + expected: "AlphanumString can only contain alphanumeric characters", + }, + { + ns: "Test.AlphaString", + expected: "AlphaString can only contain alphabetic characters", + }, + { + ns: "Test.LtFieldString", + expected: "LtFieldString must be less than MaxString", + }, + { + ns: "Test.LteFieldString", + expected: "LteFieldString must be less than or equal to MaxString", + }, + { + ns: "Test.GtFieldString", + expected: "GtFieldString must be greater than MaxString", + }, + { + ns: "Test.GteFieldString", + expected: "GteFieldString must be greater than or equal to MaxString", + }, + { + ns: "Test.NeFieldString", + expected: "NeFieldString cannot be equal to EqFieldString", + }, + { + ns: "Test.LtCSFieldString", + expected: "LtCSFieldString must be less than Inner.LtCSFieldString", + }, + { + ns: "Test.LteCSFieldString", + expected: "LteCSFieldString must be less than or equal to Inner.LteCSFieldString", + }, + { + ns: "Test.GtCSFieldString", + expected: "GtCSFieldString must be greater than Inner.GtCSFieldString", + }, + { + ns: "Test.GteCSFieldString", + expected: "GteCSFieldString must be greater than or equal to Inner.GteCSFieldString", + }, + { + ns: "Test.NeCSFieldString", + expected: "NeCSFieldString cannot be equal to Inner.NeCSFieldString", + }, + { + ns: "Test.EqCSFieldString", + expected: "EqCSFieldString must be equal to Inner.EqCSFieldString", + }, + { + ns: "Test.EqFieldString", + expected: "EqFieldString must be equal to MaxString", + }, + { + ns: "Test.GteString", + expected: "GteString must be at least 3 characters in length", + }, + { + ns: "Test.GteNumber", + expected: "GteNumber must be 5.56 or greater", + }, + { + ns: "Test.GteMultiple", + expected: "GteMultiple must contain at least 2 items", + }, + { + ns: "Test.GteTime", + expected: "GteTime must be greater than or equal to the current Date & Time", + }, + { + ns: "Test.GtString", + expected: "GtString must be greater than 3 characters in length", + }, + { + ns: "Test.GtNumber", + expected: "GtNumber must be greater than 5.56", + }, + { + ns: "Test.GtMultiple", + expected: "GtMultiple must contain more than 2 items", + }, + { + ns: "Test.GtTime", + expected: "GtTime must be greater than the current Date & Time", + }, + { + ns: "Test.LteString", + expected: "LteString must be at maximum 3 characters in length", + }, + { + ns: "Test.LteNumber", + expected: "LteNumber must be 5.56 or less", + }, + { + ns: "Test.LteMultiple", + expected: "LteMultiple must contain at maximum 2 items", + }, + { + ns: "Test.LteTime", + expected: "LteTime must be less than or equal to the current Date & Time", + }, + { + ns: "Test.LtString", + expected: "LtString must be less than 3 characters in length", + }, + { + ns: "Test.LtNumber", + expected: "LtNumber must be less than 5.56", + }, + { + ns: "Test.LtMultiple", + expected: "LtMultiple must contain less than 2 items", + }, + { + ns: "Test.LtTime", + expected: "LtTime must be less than the current Date & Time", + }, + { + ns: "Test.NeString", + expected: "NeString should not be equal to ", + }, + { + ns: "Test.NeNumber", + expected: "NeNumber should not be equal to 0.00", + }, + { + ns: "Test.NeMultiple", + expected: "NeMultiple should not be equal to 0", + }, + { + ns: "Test.EqString", + expected: "EqString is not equal to 3", + }, + { + ns: "Test.EqNumber", + expected: "EqNumber is not equal to 2.33", + }, + { + ns: "Test.EqMultiple", + expected: "EqMultiple is not equal to 7", + }, + { + ns: "Test.MaxString", + expected: "MaxString must be a maximum of 3 characters in length", + }, + { + ns: "Test.MaxNumber", + expected: "MaxNumber must be 1,113.00 or less", + }, + { + ns: "Test.MaxMultiple", + expected: "MaxMultiple must contain at maximum 7 items", + }, + { + ns: "Test.MinString", + expected: "MinString must be at least 1 character in length", + }, + { + ns: "Test.MinNumber", + expected: "MinNumber must be 1,113.00 or greater", + }, + { + ns: "Test.MinMultiple", + expected: "MinMultiple must contain at least 7 items", + }, + { + ns: "Test.LenString", + expected: "LenString长度必须是1个字符", + }, + { + ns: "Test.LenNumber", + expected: "LenNumber must be equal to 1,113.00", + }, + { + ns: "Test.LenMultiple", + expected: "LenMultiple must contain 7 items", + }, + { + ns: "Test.RequiredString", + expected: "RequiredString is a required field", + }, + { + ns: "Test.RequiredNumber", + expected: "RequiredNumber is a required field", + }, + { + ns: "Test.RequiredMultiple", + expected: "RequiredMultiple is a required field", + }, + { + ns: "Test.StrPtrMinLen", + expected: "StrPtrMinLen must be at least 10 characters in length", + }, + { + ns: "Test.StrPtrMaxLen", + expected: "StrPtrMaxLen must be a maximum of 1 character in length", + }, + { + ns: "Test.StrPtrLen", + expected: "StrPtrLen must be 2 characters in length", + }, + { + ns: "Test.StrPtrLt", + expected: "StrPtrLt must be less than 1 character in length", + }, + { + ns: "Test.StrPtrLte", + expected: "StrPtrLte must be at maximum 1 character in length", + }, + { + ns: "Test.StrPtrGt", + expected: "StrPtrGt must be greater than 10 characters in length", + }, + { + ns: "Test.StrPtrGte", + expected: "StrPtrGte must be at least 10 characters in length", + }, + { + ns: "Test.OneOfString", + expected: "OneOfString must be one of [red green]", + }, + { + ns: "Test.OneOfInt", + expected: "OneOfInt must be one of [5 63]", + }, + } + + for _, tt := range tests { + + var fe validator.FieldError + + for _, e := range errs { + if tt.ns == e.Namespace() { + fe = e + break + } + } + + NotEqual(t, fe, nil) + Equal(t, tt.expected, fe.Translate(trans)) + } + +} From 801b2c40bcbacbd196e7beec39f738efb9765551 Mon Sep 17 00:00:00 2001 From: Foolin Date: Mon, 9 Jul 2018 10:41:30 +0800 Subject: [PATCH 2/3] update --- translations/zh/zh.go | 54 +++++++-------- translations/zh/zh_test.go | 132 ++++++++++++++++++------------------- 2 files changed, 93 insertions(+), 93 deletions(-) diff --git a/translations/zh/zh.go b/translations/zh/zh.go index b88b9da..9133bb9 100644 --- a/translations/zh/zh.go +++ b/translations/zh/zh.go @@ -41,7 +41,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er // return //} - if err = ut.AddCardinal("len-string-character", "{0}字符", locales.PluralRuleOther, false); err != nil { + if err = ut.AddCardinal("len-string-character", "{0}个字符", locales.PluralRuleOther, false); err != nil { return } @@ -136,11 +136,11 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er return } - if err = ut.Add("min-number", "{0}必须大于或者等于{1}", false); err != nil { + if err = ut.Add("min-number", "{0}必须大于或等于{1}", false); err != nil { return } - if err = ut.Add("min-items", "{0}必须最少包含{1}", false); err != nil { + if err = ut.Add("min-items", "{0}必须至少包含{1}", false); err != nil { return } //if err = ut.AddCardinal("min-items-item", "{0}项", locales.PluralRuleOne, false); err != nil { @@ -227,7 +227,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er return } - if err = ut.Add("max-number", "{0}必须小于或者等于{1}", false); err != nil { + if err = ut.Add("max-number", "{0}必须小于或等于{1}", false); err != nil { return } @@ -464,15 +464,15 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er // return //} - if err = ut.AddCardinal("lte-string-character", "{0}字符", locales.PluralRuleOther, false); err != nil { + if err = ut.AddCardinal("lte-string-character", "{0}个字符", locales.PluralRuleOther, false); err != nil { return } - if err = ut.Add("lte-number", "{0}必须小于或者等于{1}", false); err != nil { + if err = ut.Add("lte-number", "{0}必须小于或等于{1}", false); err != nil { return } - if err = ut.Add("lte-items", "{0}最大数不能超过{1}", false); err != nil { + if err = ut.Add("lte-items", "{0}最多只能包含{1}", false); err != nil { return } @@ -480,11 +480,11 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er // return //} - if err = ut.AddCardinal("lte-items-item", "{0} items", locales.PluralRuleOther, false); err != nil { + if err = ut.AddCardinal("lte-items-item", "{0}项", locales.PluralRuleOther, false); err != nil { return } - if err = ut.Add("lte-datetime", "{0}小于或者等于当前日期和时间", false); err != nil { + if err = ut.Add("lte-datetime", "{0}小于或等于当前日期和时间", false); err != nil { return } @@ -591,7 +591,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er return } - if err = ut.Add("gt-items", "{0}数量必须大于{1}", false); err != nil { + if err = ut.Add("gt-items", "{0}必须大于{1}", false); err != nil { return } @@ -694,7 +694,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er tag: "gte", customRegisFunc: func(ut ut.Translator) (err error) { - if err = ut.Add("gte-string", "{0}长度只能大于或者等于{1}", false); err != nil { + if err = ut.Add("gte-string", "{0}长度必须至少为{1}", false); err != nil { return } @@ -706,11 +706,11 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er return } - if err = ut.Add("gte-number", "{0}必须大于或者等于{1}", false); err != nil { + if err = ut.Add("gte-number", "{0}必须大于或等于{1}", false); err != nil { return } - if err = ut.Add("gte-items", "{0}必须大于或者等于{1}", false); err != nil { + if err = ut.Add("gte-items", "{0}必须至少包含{1}", false); err != nil { return } @@ -722,7 +722,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er return } - if err = ut.Add("gte-datetime", "{0}必须大于或者等于当前日期和时间", false); err != nil { + if err = ut.Add("gte-datetime", "{0}必须大于或等于当前日期和时间", false); err != nil { return } @@ -871,7 +871,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er }, { tag: "gtecsfield", - translation: "{0}必须大于或者等于{1}", + translation: "{0}必须大于或等于{1}", override: false, customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { @@ -901,7 +901,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er }, { tag: "ltecsfield", - translation: "{0}必须小于或者等于{1}", + translation: "{0}必须小于或等于{1}", override: false, customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { @@ -946,7 +946,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er }, { tag: "gtefield", - translation: "{0} must be greater than or equal to {1}", + translation: "{0}必须大于或等于{1}", override: false, customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { @@ -976,7 +976,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er }, { tag: "ltefield", - translation: "{0}必须小于或者等于{1}", + translation: "{0}必须小于或等于{1}", override: false, customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { @@ -1026,7 +1026,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er }, { tag: "rgba", - translation: "{0} 必须是一个有效的RGBA颜色", + translation: "{0}必须是一个有效的RGBA颜色", override: false, }, { @@ -1036,7 +1036,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er }, { tag: "hsla", - translation: "{0}必须是一个有效的HSLA颜色r", + translation: "{0}必须是一个有效的HSLA颜色", override: false, }, { @@ -1136,37 +1136,37 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er }, { tag: "isbn", - translation: "{0}必须是有效的ISBN编号", + translation: "{0}必须是一个有效的ISBN编号", override: false, }, { tag: "isbn10", - translation: "{0}必须是有效的ISBN-10编号", + translation: "{0}必须是一个有效的ISBN-10编号", override: false, }, { tag: "isbn13", - translation: "{0}必须是有效的ISBN-13编号", + translation: "{0}必须是一个有效的ISBN-13编号", override: false, }, { tag: "uuid", - translation: "{0}必须是有效的UUID", + translation: "{0}必须是一个有效的UUID", override: false, }, { tag: "uuid3", - translation: "{0}必须是有效的版本V3 UUID", + translation: "{0}必须是一个有效的V3 UUID", override: false, }, { tag: "uuid4", - translation: "{0}必须是有效的版本V4 UUID", + translation: "{0}必须是一个有效的V4 UUID", override: false, }, { tag: "uuid5", - translation: "{0}必须是有效的版本V5 UUID", + translation: "{0}必须是一个有效的V5 UUID", override: false, }, { diff --git a/translations/zh/zh_test.go b/translations/zh/zh_test.go index 7bd0cb6..da38a37 100644 --- a/translations/zh/zh_test.go +++ b/translations/zh/zh_test.go @@ -308,15 +308,15 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.ISBN", - expected: "ISBN必须是一个有效的ISBN号码", + expected: "ISBN必须是一个有效的ISBN编号", }, { ns: "Test.ISBN10", - expected: "ISBN10必须是一个有效的ISBN-10号码", + expected: "ISBN10必须是一个有效的ISBN-10编号", }, { ns: "Test.ISBN13", - expected: "ISBN13必须是一个有效的ISBN-13号码", + expected: "ISBN13必须是一个有效的ISBN-13编号", }, { ns: "Test.Excludes", @@ -336,7 +336,7 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.Contains", - expected: "Contains必须包含的文本'purpose'", + expected: "Contains必须包含文本'purpose'", }, { ns: "Test.Base64", @@ -344,7 +344,7 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.Email", - expected: "Email必须是一个有效的邮箱地址", + expected: "Email必须是一个有效的邮箱", }, { ns: "Test.URL", @@ -368,191 +368,191 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.HSLAColorString", - expected: "HSLAColorString必须是有效的HSLA颜色", + expected: "HSLAColorString必须是一个有效的HSLA颜色", }, { ns: "Test.HexadecimalString", - expected: "HexadecimalString must be a valid hexadecimal", + expected: "HexadecimalString必须是一个有效的十六进制", }, { ns: "Test.HexColorString", - expected: "HexColorString must be a valid HEX color", + expected: "HexColorString必须是一个有效的十六进制颜色", }, { ns: "Test.NumberString", - expected: "NumberString must be a valid number", + expected: "NumberString必须是一个有效的数字", }, { ns: "Test.NumericString", - expected: "NumericString must be a valid numeric value", + expected: "NumericString必须是一个有效的数值", }, { ns: "Test.AlphanumString", - expected: "AlphanumString can only contain alphanumeric characters", + expected: "AlphanumString只能包含字母和数字", }, { ns: "Test.AlphaString", - expected: "AlphaString can only contain alphabetic characters", + expected: "AlphaString只能包含字母", }, { ns: "Test.LtFieldString", - expected: "LtFieldString must be less than MaxString", + expected: "LtFieldString必须小于MaxString", }, { ns: "Test.LteFieldString", - expected: "LteFieldString must be less than or equal to MaxString", + expected: "LteFieldString必须小于或等于MaxString", }, { ns: "Test.GtFieldString", - expected: "GtFieldString must be greater than MaxString", + expected: "GtFieldString必须大于MaxString", }, { ns: "Test.GteFieldString", - expected: "GteFieldString must be greater than or equal to MaxString", + expected: "GteFieldString必须大于或等于MaxString", }, { ns: "Test.NeFieldString", - expected: "NeFieldString cannot be equal to EqFieldString", + expected: "NeFieldString不能等于EqFieldString", }, { ns: "Test.LtCSFieldString", - expected: "LtCSFieldString must be less than Inner.LtCSFieldString", + expected: "LtCSFieldString必须小于Inner.LtCSFieldString", }, { ns: "Test.LteCSFieldString", - expected: "LteCSFieldString must be less than or equal to Inner.LteCSFieldString", + expected: "LteCSFieldString必须小于或等于Inner.LteCSFieldString", }, { ns: "Test.GtCSFieldString", - expected: "GtCSFieldString must be greater than Inner.GtCSFieldString", + expected: "GtCSFieldString必须大于Inner.GtCSFieldString", }, { ns: "Test.GteCSFieldString", - expected: "GteCSFieldString must be greater than or equal to Inner.GteCSFieldString", + expected: "GteCSFieldString必须大于或等于Inner.GteCSFieldString", }, { ns: "Test.NeCSFieldString", - expected: "NeCSFieldString cannot be equal to Inner.NeCSFieldString", + expected: "NeCSFieldString不能等于Inner.NeCSFieldString", }, { ns: "Test.EqCSFieldString", - expected: "EqCSFieldString must be equal to Inner.EqCSFieldString", + expected: "EqCSFieldString必须等于Inner.EqCSFieldString", }, { ns: "Test.EqFieldString", - expected: "EqFieldString must be equal to MaxString", + expected: "EqFieldString必须等于MaxString", }, { ns: "Test.GteString", - expected: "GteString must be at least 3 characters in length", + expected: "GteString长度必须至少为3个字符", }, { ns: "Test.GteNumber", - expected: "GteNumber must be 5.56 or greater", + expected: "GteNumber必须大于或等于5.56", }, { ns: "Test.GteMultiple", - expected: "GteMultiple must contain at least 2 items", + expected: "GteMultiple至少要包含2项", }, { ns: "Test.GteTime", - expected: "GteTime must be greater than or equal to the current Date & Time", + expected: "GteTime必须大于或等于当前日期和时间", }, { ns: "Test.GtString", - expected: "GtString must be greater than 3 characters in length", + expected: "GtString长度必须大于3个字符", }, { ns: "Test.GtNumber", - expected: "GtNumber must be greater than 5.56", + expected: "GtNumber必须大于5.56", }, { ns: "Test.GtMultiple", - expected: "GtMultiple must contain more than 2 items", + expected: "GtMultiple必须大于2项", }, { ns: "Test.GtTime", - expected: "GtTime must be greater than the current Date & Time", + expected: "GtTime必须大于当前日期和时间", }, { ns: "Test.LteString", - expected: "LteString must be at maximum 3 characters in length", + expected: "LteString长度不能超过3个字符", }, { ns: "Test.LteNumber", - expected: "LteNumber must be 5.56 or less", + expected: "LteNumber必须小于或等于5.56", }, { ns: "Test.LteMultiple", - expected: "LteMultiple must contain at maximum 2 items", + expected: "LteMultiple最多只能包含2项", }, { ns: "Test.LteTime", - expected: "LteTime must be less than or equal to the current Date & Time", + expected: "LteTime必须小于或等于当前日期和时间", }, { ns: "Test.LtString", - expected: "LtString must be less than 3 characters in length", + expected: "LtString长度必须小于3个字符", }, { ns: "Test.LtNumber", - expected: "LtNumber must be less than 5.56", + expected: "LtNumber必须小于5.56", }, { ns: "Test.LtMultiple", - expected: "LtMultiple must contain less than 2 items", + expected: "LtMultiple只能包含小于2项", }, { ns: "Test.LtTime", - expected: "LtTime must be less than the current Date & Time", + expected: "LtTime必须小于当前日期和时间", }, { ns: "Test.NeString", - expected: "NeString should not be equal to ", + expected: "NeString不应该等于 ", }, { ns: "Test.NeNumber", - expected: "NeNumber should not be equal to 0.00", + expected: "NeNumber不应该等于0.00", }, { ns: "Test.NeMultiple", - expected: "NeMultiple should not be equal to 0", + expected: "NeMultiple不应该等于0", }, { ns: "Test.EqString", - expected: "EqString is not equal to 3", + expected: "EqString不等于3", }, { ns: "Test.EqNumber", - expected: "EqNumber is not equal to 2.33", + expected: "EqNumber不等于2.33", }, { ns: "Test.EqMultiple", - expected: "EqMultiple is not equal to 7", + expected: "EqMultiple不等于7", }, { ns: "Test.MaxString", - expected: "MaxString must be a maximum of 3 characters in length", + expected: "MaxString长度不能超过3个字符", }, { ns: "Test.MaxNumber", - expected: "MaxNumber must be 1,113.00 or less", + expected: "MaxNumber必须小于或等于1,113.00", }, { ns: "Test.MaxMultiple", - expected: "MaxMultiple must contain at maximum 7 items", + expected: "MaxMultiple最多只能包含7项", }, { ns: "Test.MinString", - expected: "MinString must be at least 1 character in length", + expected: "MinString长度必须至少为1个字符", }, { ns: "Test.MinNumber", - expected: "MinNumber must be 1,113.00 or greater", + expected: "MinNumber最小只能为1,113.00", }, { ns: "Test.MinMultiple", - expected: "MinMultiple must contain at least 7 items", + expected: "MinMultiple至少要包含7项", }, { ns: "Test.LenString", @@ -560,59 +560,59 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.LenNumber", - expected: "LenNumber must be equal to 1,113.00", + expected: "LenNumber必须等于1,113.00", }, { ns: "Test.LenMultiple", - expected: "LenMultiple must contain 7 items", + expected: "LenMultiple必须包含7项", }, { ns: "Test.RequiredString", - expected: "RequiredString is a required field", + expected: "RequiredString是一个必填的字段", }, { ns: "Test.RequiredNumber", - expected: "RequiredNumber is a required field", + expected: "RequiredNumber是一个必填的字段", }, { ns: "Test.RequiredMultiple", - expected: "RequiredMultiple is a required field", + expected: "RequiredMultiple是一个必填的字段", }, { ns: "Test.StrPtrMinLen", - expected: "StrPtrMinLen must be at least 10 characters in length", + expected: "StrPtrMinLen长度必须至少为10个字符", }, { ns: "Test.StrPtrMaxLen", - expected: "StrPtrMaxLen must be a maximum of 1 character in length", + expected: "StrPtrMaxLen长度必须最大为1个字符", }, { ns: "Test.StrPtrLen", - expected: "StrPtrLen must be 2 characters in length", + expected: "StrPtrLen长度必须是2个字符", }, { ns: "Test.StrPtrLt", - expected: "StrPtrLt must be less than 1 character in length", + expected: "StrPtrLt长度必须小于1个字符", }, { ns: "Test.StrPtrLte", - expected: "StrPtrLte must be at maximum 1 character in length", + expected: "StrPtrLte长度必须最大为1个字符", }, { ns: "Test.StrPtrGt", - expected: "StrPtrGt must be greater than 10 characters in length", + expected: "StrPtrGt长度必须大于10个字符", }, { ns: "Test.StrPtrGte", - expected: "StrPtrGte must be at least 10 characters in length", + expected: "StrPtrGte长度必须至少为10个字符", }, { ns: "Test.OneOfString", - expected: "OneOfString must be one of [red green]", + expected: "OneOfString必须是[red green]中的一个", }, { ns: "Test.OneOfInt", - expected: "OneOfInt must be one of [5 63]", + expected: "OneOfInt必须是[5 63]中的一个", }, } From d1a82a6cdc04ce1c53c6f263aabae410cbe43925 Mon Sep 17 00:00:00 2001 From: Foolin Date: Mon, 9 Jul 2018 11:35:10 +0800 Subject: [PATCH 3/3] add chinese translations --- translations/zh/zh.go | 16 ++++++++-------- translations/zh/zh_test.go | 22 +++++++++++----------- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/translations/zh/zh.go b/translations/zh/zh.go index 9133bb9..69d8a43 100644 --- a/translations/zh/zh.go +++ b/translations/zh/zh.go @@ -33,7 +33,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er tag: "len", customRegisFunc: func(ut ut.Translator) (err error) { - if err = ut.Add("len-string", "{0}长度必须为{1}", false); err != nil { + if err = ut.Add("len-string", "{0}长度必须是{1}", false); err != nil { return } @@ -124,7 +124,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er tag: "min", customRegisFunc: func(ut ut.Translator) (err error) { - if err = ut.Add("min-string", "{0}长度最小只能为{1}", false); err != nil { + if err = ut.Add("min-string", "{0}长度必须至少为{1}", false); err != nil { return } @@ -136,7 +136,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er return } - if err = ut.Add("min-number", "{0}必须大于或等于{1}", false); err != nil { + if err = ut.Add("min-number", "{0}最小只能为{1}", false); err != nil { return } @@ -215,7 +215,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er tag: "max", customRegisFunc: func(ut ut.Translator) (err error) { - if err = ut.Add("max-string", "{0}长度最大只能为{1}", false); err != nil { + if err = ut.Add("max-string", "{0}长度不能超过{1}", false); err != nil { return } @@ -231,7 +231,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er return } - if err = ut.Add("max-items", "{0}包含最大数量为{1}", false); err != nil { + if err = ut.Add("max-items", "{0}最多只能包含{1}", false); err != nil { return } //if err = ut.AddCardinal("max-items-item", "{0}项", locales.PluralRuleOne, false); err != nil { @@ -352,7 +352,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er return } - if err = ut.Add("lt-items", "{0}包含最小数量为{1}", false); err != nil { + if err = ut.Add("lt-items", "{0}必须包含少于{1}", false); err != nil { return } @@ -484,7 +484,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er return } - if err = ut.Add("lte-datetime", "{0}小于或等于当前日期和时间", false); err != nil { + if err = ut.Add("lte-datetime", "{0}必须小于或等于当前日期和时间", false); err != nil { return } @@ -1296,7 +1296,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er }, { tag: "oneof", - translation: "{0}必须是[{1}]的其中一个", + translation: "{0}必须是[{1}]中的一个", override: false, customTransFunc: func(ut ut.Translator, fe validator.FieldError) string { s, err := ut.T(fe.Tag(), fe.Field(), fe.Param()) diff --git a/translations/zh/zh_test.go b/translations/zh/zh_test.go index da38a37..855a17f 100644 --- a/translations/zh/zh_test.go +++ b/translations/zh/zh_test.go @@ -452,7 +452,7 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.GteMultiple", - expected: "GteMultiple至少要包含2项", + expected: "GteMultiple必须至少包含2项", }, { ns: "Test.GteTime", @@ -500,7 +500,7 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.LtMultiple", - expected: "LtMultiple只能包含小于2项", + expected: "LtMultiple必须包含少于2项", }, { ns: "Test.LtTime", @@ -508,15 +508,15 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.NeString", - expected: "NeString不应该等于 ", + expected: "NeString不能等于", }, { ns: "Test.NeNumber", - expected: "NeNumber不应该等于0.00", + expected: "NeNumber不能等于0.00", }, { ns: "Test.NeMultiple", - expected: "NeMultiple不应该等于0", + expected: "NeMultiple不能等于0", }, { ns: "Test.EqString", @@ -552,7 +552,7 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.MinMultiple", - expected: "MinMultiple至少要包含7项", + expected: "MinMultiple必须至少包含7项", }, { ns: "Test.LenString", @@ -568,15 +568,15 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.RequiredString", - expected: "RequiredString是一个必填的字段", + expected: "RequiredString为必填字段", }, { ns: "Test.RequiredNumber", - expected: "RequiredNumber是一个必填的字段", + expected: "RequiredNumber为必填字段", }, { ns: "Test.RequiredMultiple", - expected: "RequiredMultiple是一个必填的字段", + expected: "RequiredMultiple为必填字段", }, { ns: "Test.StrPtrMinLen", @@ -584,7 +584,7 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.StrPtrMaxLen", - expected: "StrPtrMaxLen长度必须最大为1个字符", + expected: "StrPtrMaxLen长度不能超过1个字符", }, { ns: "Test.StrPtrLen", @@ -596,7 +596,7 @@ func TestTranslations(t *testing.T) { }, { ns: "Test.StrPtrLte", - expected: "StrPtrLte长度必须最大为1个字符", + expected: "StrPtrLte长度不能超过1个字符", }, { ns: "Test.StrPtrGt",