gookit/config alternatives and similar packages
Based on the "Configuration" category.
Alternatively, view gookit/config alternatives based on common mentions on social networks and blogs.
-
kelseyhightower/envconfig
Go library for managing configuration data from environment variables. -
konfig
Composable, observable and performant config handling for Go for the distributed processing era. -
koanf
Light weight, extensible library for reading config in Go applications. Built in support for JSON, TOML, YAML, env, command line. -
confita
Load configuration in cascade from multiple backends into a struct. -
config
JSON or YAML configuration wrapper with environment variables and flags parsing. -
cleanenv
Minimalistic configuration reader (from files, ENV, and wherever you want). -
hjson
Human JSON, a configuration file format for humans. Relaxed syntax, fewer mistakes, more comments. -
gcfg
read INI-style configuration files into Go structs; supports user-defined types and subsections -
joshbetz/config
A small configuration library for Go that parses environment variables, JSON files, and reloads automatically on SIGHUP. -
goConfig
Parse a struct as input and populates the fields of this struct with parameters fom command line, environment variables and configuration file. -
harvester
Harvester, a easy to use static and dynamic configuration package supportig seeding, env vars and Consul integration. -
onion
Layer based configuration for Go, Supports JSON, TOML, YAML, properties, etcd, env, and encryption using PGP. -
go-aws-ssm
Go package that fetches parameters from AWS System Manager -
configuro
opinionated configuration loading & validation framework from ENV and Files focused towards 12-Factor compliant applications. -
configure
Provides configuration through multiple sources, including JSON, flags and environment variables. -
configuration
Library for initializing configuration structs from env variables, files, flags and 'default' tag. -
go-up
A simple configuration library with recursive placeholders resolution and no magic. -
hocon
Configuration library for working with the HOCON(a human-friendly JSON superset) format, supports features like environment variables, referencing other values, comments and multiple files. -
Genv
Makes it easy to read and use environment variables in your projects -
CONFLATE
Library providing routines to merge and validate JSON, YAML and/or TOML files -
go-ssm-config
Go utility for loading configuration parameters from AWS SSM (Parameter Store). -
sprbox
Build-environment aware toolbox factory and agnostic config parser (YAML, TOML, JSON and Environment vars). -
swap
Instantiate/configure structs recursively, based on build environment. (YAML, TOML, JSON and env). -
typenv
Minimalistic, zero dependency, typed environment variables library. -
gonfig
Tag-based configuration parser which loads values from different providers into typesafe struct. -
nasermirzaei89/env
Simple useful package for read environment variables. -
gone/jconf
Modular JSON configuration. Keep you config structs along the code they configure and delegate parsing to submodules without sacrificing full config serialization. -
txgruppi-config
Quick and easy way to load config files based on a simple set of rules.
Scout APM - Leading-edge performance monitoring starting at $39/month
Do you think we are missing an alternative of gookit/config or a related project?
Popular Comparisons
README
Config
Golang's application config manage tool library.
[中文说明](README.zh-CN.md)
Features
- Support multi format:
JSON
(default),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.
- 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
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](_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)
// config.SetDecoder(config.Yaml, yaml.Decoder)
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())
}
Map Data To Structure
Note: The default binding mapping tag of a structure is
mapstructure
, which can be changed by settingOptions.TagName
user := struct {
Age int
Kye string
UserName string `mapstructure:"user_name"`
Tags []int
}{}
err = config.BindStruct("user", &user)
fmt.Println(user.UserName) // inhere
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_NAME"}, 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
TagName string
// the delimiter char for split key, when `FindByPath=true`. default is '.'
Delimiter byte
// default write format. default is JSON
DumpFormat string
// default input format. default is JSON
ReadFormat string
}
API Methods Refer
Load Config
LoadOSEnv(keys []string)
Load from os ENVLoadData(dataSource ...interface{}) (err error)
Load from struts or mapsLoadFlags(keys []string) (err error)
Load from CLI flagsLoadExists(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)
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{})
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.DataExists(key string, findByPath ...bool) bool
DumpTo(out io.Writer, format string) (n int64, err error)
BindStruct(key string, dst interface{}) error
Run Tests
go test -cover
// contains all sub-folder
go test -cover ./...
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
- Yaml parse go-yaml
- Toml parse go toml
- Data merge mergo
- Map structure mapstructure
License
MIT
*Note that all licence references and agreements mentioned in the gookit/config README section above
are relevant to that project's source code only.