countries

You can access country constants directly (e.g., countries.Japan) or use lookup functions like ByName and ByNumeric.

Once you have a country object, you can retrieve various ISO and regional data using method calls. The package also provides an .Info() method that returns a struct containing most of these fields for easier access to non-method properties.

// Accessing via constants and methods
countryJapan := countries.Japan
fmt.Printf("Name: %v\n", countryJapan)                   // Japan
fmt.Printf("Alpha-2: %v\n", countryJapan.Alpha2())    // JP
fmt.Printf("Capital: %v\n", countryJapan.Capital())   // Tokyo

// Accessing via Info() struct
japanInfo := countries.Japan.Info()
fmt.Printf("Name: %v\n", japanInfo.Name)               // Japan
fmt.Printf("Alpha-2: %v\n", japanInfo.Alpha2)        // JP

Install the countries package using go get to access ISO standards, country codes, subdivisions, and currency data in Go.

go get github.com/biter777/countries

The package is compatible with Databases, JSON, BSON, GOB, and XML. You can use countries.CountryCode and countries.CurrencyCode as types within your database models (e.g., GORM structs) to store country and currency information efficiently.

type User struct {
	gorm.Model
	Name     string
	Country  countries.CountryCode
	Currency countries.CurrencyCode
}

user := &User{Name: "Helen", Country: countries.Slovenia, Currency: countries.CurrencyEUR}
// ... save user to DB

You can derive currency information from a country object using .Currency(). This returns a currency object which provides its own metadata (Alpha code, emoji, etc.) and allows you to find which countries use that specific currency via .Countries().

currencyJapan := countries.Japan.Currency()
fmt.Printf("Currency Name: %v\n", currencyJapan)      // Yen
fmt.Printf("Currency Alpha: %v\n", currencyJapan.Alpha()) // JPY
fmt.Printf("Currency Emoji: %v\n", currencyJapan.Emoji()) // 💴

// Find all countries using this currency
fmt.Printf("Countries: %v\n", currencyJapan.Countries())

Use the following functions to find a country object based on different identifiers:

• ByName(name string): Look up by English name or ISO Alpha-2/Alpha-3 code.
• ByNumeric(code int): Look up by ISO 3166-1 numeric code.

// Lookup by name
country := countries.ByName("angola")

// Lookup by Alpha-2 code
country = countries.ByName("AO")

// Lookup by numeric code
country = countries.ByNumeric(24)

The CallCodeInfo struct implements the database/sql/driver.Valuer and database/sql.Scanner interfaces. This allows you to store CallCodeInfo directly in database columns as JSON.

• Value(): Marshals the CallCodeInfo to JSON.
• Scan(src interface{}): Unmarshals JSON from the database back into a CallCodeInfo struct.

You can generate Unicode flag emojis directly from a CountryCode using:

• .Emoji(): Returns the flag based on the ISO Alpha-2 code.
• .Emoji3(): Returns a flag representation based on the ISO Alpha-3 code.

country := countries.Japan
fmt.Println(country.Emoji())  // 🇯🇵
fmt.Println(country.Emoji3()) // 🇯🇵

The CallCode type represents a country's calling phone code. It is an int64 type, making it compatible with database/sql drivers. You can convert a CallCode to its string representation (e.g., +44) using the .String() method.

// Example: Converting a CallCode to a string
var code countries.CallCode = countries.CallCode44
fmt.Println(code.String()) // Output: +44

The Domain struct implements standard Go database interfaces, allowing it to be used directly in SQL queries with database/sql:

• Value(): Implements driver.Valuer by marshaling the Domain struct to JSON.
• Scan(src interface{}): Implements sql.Scanner to allow scanning database values (as *Domain or Domain) back into the struct.

// Example: Scanning a domain from a database row
var d countries.Domain
err := row.Scan(&d)
if err != nil {
    // handle error
}

The RegionCodeByName function allows you to resolve a RegionCode from a string. The lookup is case-insensitive and supports various aliases and abbreviations.

Example lookups:

• "EU" or "Europe" $\rightarrow$ RegionEU
• "AF" or "Africa" $\rightarrow$ RegionAF
• "NONE" or "XX" $\rightarrow$ RegionNone

regionEU := countries.RegionCodeByName("europe")
regionAF := countries.RegionCodeByName("AF")

if regionEU.IsValid() {
    fmt.Println("Found region:", regionEU.String())
}