Config

Golang's application config manage tool library.

中文说明

Features

• Support multi format: JSON(default), JSON5, INI, YAML, TOML, HCL, ENV, Flags
  • JSON content support comments. will auto clear comments
  • Other drivers are used on demand, not used will not be loaded into the application.
    • Possibility to add custom driver for your specific format
• Support multi-file and multi-data loading
• Support loading configuration from os ENV
• Support for loading configuration data from remote URLs
• Support for setting configuration data from command line arguments(flags)
• Support data overlay and merge, automatically load by key when loading multiple copies of data
• Support for binding all or part of the configuration data to the structure
• Support get sub value by path, like map.key arr.2
• Support parse ENV name and allow with default value. like envKey: ${SHELL|/bin/bash} -> envKey: /bin/zsh
• Generic api Get Int Uint Int64 Float String Bool Ints IntMap Strings StringMap ...
• Complete unit test(code coverage > 95%)

Provide a sub-package dotenv that supports importing data from files (eg .env) to ENV

Only use INI

If you just want to use INI for simple config management, recommended use gookit/ini

GoDoc

• godoc for github

Usage

Here using the yaml format as an example(testdata/yml_other.yml):

name: app2
debug: false
baseKey: value2
shell: ${SHELL}
envKey1: ${NotExist|defValue}

map1:
    key: val2
    key2: val20

arr1:
    - val1
    - val21

Load data

examples code please see _examples/yaml.go:

package main

import (
    "github.com/gookit/config/v2"
    "github.com/gookit/config/v2/yaml"
)

// go run ./examples/yaml.go
func main() {
	config.WithOptions(config.ParseEnv)

	// add driver for support yaml content
	config.AddDriver(yaml.Driver)

	err := config.LoadFiles("testdata/yml_base.yml")
	if err != nil {
		panic(err)
	}

	// load more files
	err = config.LoadFiles("testdata/yml_other.yml")
	// can also load multi at once
	// err := config.LoadFiles("testdata/yml_base.yml", "testdata/yml_other.yml")
	if err != nil {
		panic(err)
	}

	// fmt.Printf("config data: \n %#v\n", config.Data())
}

Bind Structure

Note: The default binding mapping tag of a structure is mapstructure, which can be changed by setting the decoder's option options.DecoderConfig.TagName

user := struct {
    Age  int  `mapstructure:"age"`
    Key  string `mapstructure:"key"`
    UserName  string `mapstructure:"user_name"`
    Tags []int  `mapstructure:"tags"`
}{}

err = config.BindStruct("user", &user)

fmt.Println(user.UserName) // inhere

Change struct tag name

config.WithOptions(func(opt *Options) {
    options.DecoderConfig.TagName = "config"
})

Can use empty string for bind all config data to a struct:

config.BindStruct("", &myConf)

Direct Read data

• Get integer

age := config.Int("age")
fmt.Print(age) // 100

• Get bool

val := config.Bool("debug")
fmt.Print(val) // true

• Get string

name := config.String("name")
fmt.Print(name) // inhere

• Get strings(slice)

arr1 := config.Strings("arr1")
fmt.Printf("%#v", arr1) // []string{"val1", "val21"}

• Get string map

val := config.StringMap("map1")
fmt.Printf("%#v",val) // map[string]string{"key":"val2", "key2":"val20"}

• Value contains ENV var

value := config.String("shell")
fmt.Print(value) // "/bin/zsh"

• Get value by key path

// from array
value := config.String("arr1.0")
fmt.Print(value) // "val1"

// from map
value := config.String("map1.key")
fmt.Print(value) // "val2"

• Setting new value

// set value
config.Set("name", "new name")
name = config.String("name")
fmt.Print(name) // "new name"

Load from flags

Support simple flags parameter parsing, loading

// flags like: --name inhere --env dev --age 99 --debug

// load flag info
keys := []string{"name", "env", "age:int" "debug:bool"}
err := config.LoadFlags(keys)

// read
config.String("name") // "inhere"
config.String("env") // "dev"
config.Int("age") // 99
config.Bool("debug") // true

Load from ENV

// os env: APP_NAME=config APP_DEBUG=true
// load ENV info
config.LoadOSEnv([]string{"APP_NAME", "APP_DEBUG"}, true)

// read
config.Bool("app_debug") // true
config.String("app_name") // "config"

New Config Instance

You can create custom config instance

// create new instance, will auto register JSON driver
myConf := config.New("my-conf")

// create empty instance
myConf := config.NewEmpty("my-conf")

// create and with some options
myConf := config.NewWithOptions("my-conf", config.ParseEnv, config.ReadOnly)

Available Options

// Options config options
type Options struct {
	// parse env value. like: "${EnvName}" "${EnvName|default}"
	ParseEnv bool
	// config is readonly. default is False
	Readonly bool
	// enable config data cache. default is False
	EnableCache bool
	// parse key, allow find value by key path. default is True eg: 'key.sub' will find `map[key]sub`
	ParseKey bool
	// tag name for binding data to struct
	// Deprecated
	// please set tag name by DecoderConfig
	TagName string
	// the delimiter char for split key path, if `FindByPath=true`. default is '.'
	Delimiter byte
	// default write format
	DumpFormat string
	// default input format
	ReadFormat string
	// DecoderConfig setting for binding data to struct
	DecoderConfig *mapstructure.DecoderConfig
}

API Methods Refer

Load Config

• LoadOSEnv(keys []string) Load from os ENV
• LoadData(dataSource ...interface{}) (err error) Load from struts or maps
• LoadFlags(keys []string) (err error) Load from CLI flags
• LoadExists(sourceFiles ...string) (err error)
• LoadFiles(sourceFiles ...string) (err error)
• LoadRemote(format, url string) (err error)
• LoadSources(format string, src []byte, more ...[]byte) (err error)
• LoadStrings(format string, str string, more ...string) (err error)
• LoadFilesByFormat(format string, sourceFiles ...string) (err error)
• LoadExistsByFormat(format string, sourceFiles ...string) error

Getting Values

• Bool(key string, defVal ...bool) bool
• Int(key string, defVal ...int) int
• Uint(key string, defVal ...uint) uint
• Int64(key string, defVal ...int64) int64
• Ints(key string) (arr []int)
• IntMap(key string) (mp map[string]int)
• Float(key string, defVal ...float64) float64
• String(key string, defVal ...string) string
• Strings(key string) (arr []string)
• StringMap(key string) (mp map[string]string)
• Get(key string, findByPath ...bool) (value interface{})
• BindStruct(key string, dst interface{}) error

Setting Values

• Set(key string, val interface{}, setByPath ...bool) (err error)

Useful Methods

• Getenv(name string, defVal ...string) (val string)
• AddDriver(driver Driver)
• Data() map[string]interface{}
• SetData(data map[string]interface{}) set data to override the Config.Data
• Exists(key string, findByPath ...bool) bool
• DumpTo(out io.Writer, format string) (n int64, err error)

Run Tests

go test -cover
// contains all sub-folder
go test -cover ./...

Projects using config

Check out these projects, which use https://github.com/gookit/config :

• https://github.com/JanDeDobbeleer/oh-my-posh A prompt theme engine for any shell.
• + See More

Gookit packages

• gookit/ini Go config management, use INI files
• gookit/rux Simple and fast request router for golang HTTP
• gookit/gcli build CLI application, tool library, running CLI commands
• gookit/event Lightweight event manager and dispatcher implements by Go
• gookit/cache Generic cache use and cache manager for golang. support File, Memory, Redis, Memcached.
• gookit/config Go config management. support JSON, YAML, TOML, INI, HCL, ENV and Flags
• gookit/color A command-line color library with true color support, universal API methods and Windows support
• gookit/filter Provide filtering, sanitizing, and conversion of golang data
• gookit/validate Use for data validation and filtering. support Map, Struct, Form data
• gookit/goutil Some utils for the Go: string, array/slice, map, format, cli, env, filesystem, test and more
• More, please see https://github.com/gookit

See also

• Ini parse gookit/ini/parser
• Json5 parse json5
• Yaml parse go-yaml
• Toml parse go toml
• Data merge mergo
• Map structure mapstructure

License

MIT