Documentation
¶
Overview ¶
Package display provides display names for languages, scripts and regions in a requested language.
The data is based on CLDR's localeDisplayNames. It includes the names of the draft level "contributed" or "approved". The resulting tables are quite large. The display package is designed so that users can reduce the linked-in table sizes by cherry picking the languages one wishes to support. There is a Dictionary defined for a selected set of common languages for this purpose.
Index ¶
Examples ¶
Constants ¶
const CLDRVersion = "32"
CLDRVersion is the CLDR version from which the tables in this package are derived.
const Version = "32"
Version is deprecated. Use CLDRVersion.
Variables ¶
var ( // Supported lists the languages for which names are defined. Supported language.Coverage // The set of all possible values for which names are defined. Note that not // all Namer implementations will cover all the values of a given type. // A Namer will return the empty string for unsupported values. Values language.Coverage )
Functions ¶
This section is empty.
Types ¶
type Dictionary ¶
type Dictionary struct {
// contains filtered or unexported fields
}
A Dictionary holds a collection of Namers for a single language. One can reduce the amount of data linked in to a binary by only referencing Dictionaries for the languages one needs to support instead of using the generic Namer factories.
Example ¶
ExampleDictionary shows how to reduce the amount of data linked into your binary by only using the predefined Dictionary variables of the languages you wish to support.
package main
import (
"fmt"
"golang.org/x/text/language"
"golang.org/x/text/language/display"
)
func main() {
tags := []language.Tag{
language.English,
language.German,
language.Japanese,
language.Russian,
}
dicts := []*display.Dictionary{
display.English,
display.German,
display.Japanese,
display.Russian,
}
m := language.NewMatcher(tags)
getDict := func(t language.Tag) *display.Dictionary {
_, i, confidence := m.Match(t)
// Skip this check if you want to support a fall-back language, which
// will be the first one passed to NewMatcher.
if confidence == language.No {
return nil
}
return dicts[i]
}
// The matcher will match Swiss German to German.
n := getDict(language.Make("gsw")).Languages()
fmt.Println(n.Name(language.German))
fmt.Println(n.Name(language.Make("de-CH")))
fmt.Println(n.Name(language.Make("gsw")))
}
Output: Deutsch Schweizer Hochdeutsch Schweizerdeutsch
var ( Afrikaans *Dictionary = &af // af Amharic *Dictionary = &am // am Arabic *Dictionary = &ar // ar ModernStandardArabic *Dictionary = Arabic // ar-001 Azerbaijani *Dictionary = &az // az Bulgarian *Dictionary = &bg // bg Bengali *Dictionary = &bn // bn Catalan *Dictionary = &ca // ca Czech *Dictionary = &cs // cs Danish *Dictionary = &da // da German *Dictionary = &de // de Greek *Dictionary = &el // el English *Dictionary = &en // en AmericanEnglish *Dictionary = English // en-US BritishEnglish *Dictionary = English // en-GB Spanish *Dictionary = &es // es EuropeanSpanish *Dictionary = Spanish // es-ES LatinAmericanSpanish *Dictionary = Spanish // es-419 Estonian *Dictionary = &et // et Persian *Dictionary = &fa // fa Finnish *Dictionary = &fi // fi Filipino *Dictionary = &fil // fil French *Dictionary = &fr // fr Gujarati *Dictionary = &gu // gu Hebrew *Dictionary = &he // he Hindi *Dictionary = &hi // hi Croatian *Dictionary = &hr // hr Hungarian *Dictionary = &hu // hu Armenian *Dictionary = &hy // hy Indonesian *Dictionary = &id // id Icelandic *Dictionary = &is // is Italian *Dictionary = &it // it Japanese *Dictionary = &ja // ja Georgian *Dictionary = &ka // ka Kazakh *Dictionary = &kk // kk Khmer *Dictionary = &km // km Kannada *Dictionary = &kn // kn Korean *Dictionary = &ko // ko Kirghiz *Dictionary = &ky // ky Lao *Dictionary = &lo // lo Lithuanian *Dictionary = < // lt Latvian *Dictionary = &lv // lv Macedonian *Dictionary = &mk // mk Malayalam *Dictionary = &ml // ml Mongolian *Dictionary = &mn // mn Marathi *Dictionary = &mr // mr Malay *Dictionary = &ms // ms Burmese *Dictionary = &my // my Nepali *Dictionary = &ne // ne Dutch *Dictionary = &nl // nl Norwegian *Dictionary = &no // no Punjabi *Dictionary = &pa // pa Polish *Dictionary = &pl // pl Portuguese *Dictionary = &pt // pt BrazilianPortuguese *Dictionary = Portuguese // pt-BR EuropeanPortuguese *Dictionary = &ptPT // pt-PT Romanian *Dictionary = &ro // ro Russian *Dictionary = &ru // ru Sinhala *Dictionary = &si // si Slovak *Dictionary = &sk // sk Slovenian *Dictionary = &sl // sl Albanian *Dictionary = &sq // sq Serbian *Dictionary = &sr // sr SerbianLatin *Dictionary = &srLatn // sr Swedish *Dictionary = &sv // sv Swahili *Dictionary = &sw // sw Tamil *Dictionary = &ta // ta Telugu *Dictionary = &te // te Thai *Dictionary = &th // th Turkish *Dictionary = &tr // tr Ukrainian *Dictionary = &uk // uk Urdu *Dictionary = &ur // ur Uzbek *Dictionary = &uz // uz Vietnamese *Dictionary = &vi // vi Chinese *Dictionary = &zh // zh SimplifiedChinese *Dictionary = Chinese // zh-Hans TraditionalChinese *Dictionary = &zhHant // zh-Hant Zulu *Dictionary = &zu // zu )
func (*Dictionary) Languages ¶
func (d *Dictionary) Languages() Namer
Languages returns a Namer for naming languages. It returns nil if there is no data for the given tag. The type passed to Name must be either language.Base or language.Tag. Note that the result may differ between passing a tag or its base language. For example, for English, passing "nl-BE" would return Flemish whereas passing "nl" returns "Dutch".
func (*Dictionary) Regions ¶
func (d *Dictionary) Regions() Namer
Regions returns a Namer for naming regions. It returns nil if there is no data for the given tag. The type passed to Name must be either a language.Region or a language.Tag. It will not attempt to infer a region for tags with an unspecified region.
func (*Dictionary) Scripts ¶
func (d *Dictionary) Scripts() Namer
Scripts returns a Namer for naming scripts. It returns nil if there is no data for the given tag. The type passed to Name must be either a language.Script or a language.Tag. It will not attempt to infer a script for tags with an unspecified script.
func (*Dictionary) Tags ¶
func (d *Dictionary) Tags() Namer
Tags returns a Namer for giving a full description of a tag. The names of scripts and regions that are not already implied by the language name will in appended within parentheses. It returns nil if there is not data for the given tag. The type passed to Name must be a tag.
type Formatter ¶
type Formatter struct {
// contains filtered or unexported fields
}
A Formatter formats a tag in the current language. It is used in conjunction with the message package.
Example ¶
package main
import (
"golang.org/x/text/language"
"golang.org/x/text/language/display"
"golang.org/x/text/message"
)
func main() {
message.SetString(language.Dutch, "In %v people speak %v.", "In %v spreekt men %v.")
fr := language.French
region, _ := fr.Region()
for _, tag := range []string{"en", "nl"} {
p := message.NewPrinter(language.Make(tag))
p.Printf("In %v people speak %v.", display.Region(region), display.Language(fr))
p.Println()
}
}
Output: In France people speak French. In Frankrijk spreekt men Frans.
func Language ¶
func Language(lang interface{}) Formatter
Language returns a Formatter that renders the name for lang in the the current language. x may be a language.Base or a language.Tag. It renders lang in the default language if no translation for the current language is supported.
func Region ¶
func Region(region interface{}) Formatter
Region returns a Formatter that renders the name for region in the current language. region may be a language.Region or a language.Tag. It renders region in the default language if no translation for the current language is supported.
func Script ¶
func Script(script interface{}) Formatter
Script returns a Formatter that renders the name for script in the current language. script may be a language.Script or a language.Tag. It renders script in the default language if no translation for the current language is supported.
type Namer ¶
type Namer interface {
// Name returns a display string for the given value. A Namer returns an
// empty string for values it does not support. A Namer may support naming
// an unspecified value. For example, when getting the name for a region for
// a tag that does not have a defined Region, it may return the name for an
// unknown region. It is up to the user to filter calls to Name for values
// for which one does not want to have a name string.
Name(x interface{}) string
}
A Namer is used to get the name for a given value, such as a Tag, Language, Script or Region.
Example ¶
package main
import (
"fmt"
"golang.org/x/text/language"
"golang.org/x/text/language/display"
)
func main() {
supported := []string{
"en-US", "en-GB", "ja", "zh", "zh-Hans", "zh-Hant", "pt", "pt-PT", "ko", "ar", "el", "ru", "uk", "pa",
}
en := display.English.Languages()
for _, s := range supported {
t := language.MustParse(s)
fmt.Printf("%-20s (%s)\n", en.Name(t), display.Self.Name(t))
}
}
Output: American English (American English) British English (British English) Japanese (日本語) Chinese (中文) Simplified Chinese (简体中文) Traditional Chinese (繁體中文) Portuguese (português) European Portuguese (português europeu) Korean (한국어) Arabic (العربية) Greek (Ελληνικά) Russian (русский) Ukrainian (українська) Punjabi (ਪੰਜਾਬੀ)
func Languages ¶
Languages returns a Namer for naming languages. It returns nil if there is no data for the given tag. The type passed to Name must be either language.Base or language.Tag. Note that the result may differ between passing a tag or its base language. For example, for English, passing "nl-BE" would return Flemish whereas passing "nl" returns "Dutch".
func Regions ¶
Regions returns a Namer for naming regions. It returns nil if there is no data for the given tag. The type passed to Name must be either a language.Region or a language.Tag. It will not attempt to infer a region for tags with an unspecified region.
func Scripts ¶
Scripts returns a Namer for naming scripts. It returns nil if there is no data for the given tag. The type passed to Name must be either a language.Script or a language.Tag. It will not attempt to infer a script for tags with an unspecified script.
func Tags ¶
Tags returns a Namer for giving a full description of a tag. The names of scripts and regions that are not already implied by the language name will in appended within parentheses. It returns nil if there is not data for the given tag. The type passed to Name must be a tag.
Example ¶
package main
import (
"fmt"
"golang.org/x/text/language"
"golang.org/x/text/language/display"
)
func main() {
n := display.Tags(language.English)
fmt.Println(n.Name(language.Make("nl")))
fmt.Println(n.Name(language.Make("nl-BE")))
fmt.Println(n.Name(language.Make("nl-CW")))
fmt.Println(n.Name(language.Make("nl-Arab")))
fmt.Println(n.Name(language.Make("nl-Cyrl-RU")))
}
Output: Dutch Flemish Dutch (Curaçao) Dutch (Arabic) Dutch (Cyrillic, Russia)
type SelfNamer ¶
type SelfNamer struct {
// Supported defines the values supported by this Namer.
Supported language.Coverage
}
A SelfNamer implements a Namer that returns the name of language in this same language. It provides a very compact mechanism to provide a comprehensive list of languages to users in their native language.
var ( // Self is a shared instance of a SelfNamer. Self *SelfNamer = &self )
Source Files