Documentation
¶
Overview ¶
Package env is a go port of the ruby dotenv library (https://github.com/bkeepers/dotenv)
Examples/readme can be found on the github page at https://github.com/joho/env
The TL;DR is that you make a .env file that looks something like
SOME_ENV_VAR=somevalue
and then in your go code you can call
env.Load()
and all the env vars declared in .env will be available through os.Getenv("SOME_ENV_VAR")
Index ¶
- Variables
- func Exec(filenames []string, cmd string, cmdArgs []string) error
- func Load(filenames ...string) (err error)
- func Marshal(envMap map[string]string) (string, error)
- func Overload(filenames ...string) (err error)
- func Parse(v interface{}, opts ...Options) error
- func ParseDotenv(r io.Reader) (envMap map[string]string, err error)
- func ParseWithFuncs(v interface{}, funcMap map[reflect.Type]ParserFunc, opts ...Options) error
- func Read(filenames ...string) (envMap map[string]string, err error)
- func Unmarshal(str string) (envMap map[string]string, err error)
- func Write(envMap map[string]string, filename string) error
- type Options
- type ParserFunc
Examples ¶
Constants ¶
This section is empty.
Variables ¶
var ( // ErrNotAStructPtr is returned if you pass something that is not a pointer to a // Struct to Parse ErrNotAStructPtr = errors.New("env: expected a pointer to a Struct") )
nolint: gochecknoglobals
Functions ¶
func Exec ¶
Exec loads env vars from the specified filenames (empty map falls back to default) then executes the cmd specified.
Simply hooks up os.Stdin/err/out to the command and calls Run()
If you want more fine grained control over your command it's recommended that you use `Load()` or `Read()` and the `os/exec` package yourself.
func Load ¶
Load will read your env file(s) and load them into ENV for this process.
Call this function as close as possible to the start of your program (ideally in main)
If you call Load without any args it will default to loading .env in the current path ¶
You can otherwise tell it which files to load (there can be more than one) like
env.Load("fileone", "filetwo")
It's important to note that it WILL NOT OVERRIDE an env variable that already exists - consider the .env file to set dev vars or sensible defaults
func Marshal ¶
Marshal outputs the given environment as a dotenv-formatted environment file. Each line is in the format: KEY="VALUE" where VALUE is backslash-escaped.
func Overload ¶
Overload will read your env file(s) and load them into ENV for this process.
Call this function as close as possible to the start of your program (ideally in main)
If you call Overload without any args it will default to loading .env in the current path ¶
You can otherwise tell it which files to load (there can be more than one) like
env.Overload("fileone", "filetwo")
It's important to note this WILL OVERRIDE an env variable that already exists - consider the .env file to forcefilly set all vars.
func Parse ¶
Parse parses a struct containing `env` tags and loads its values from environment variables.
Example ¶
type inner struct {
Foo string `env:"FOO" envDefault:"foobar"`
}
type config struct {
Home string `env:"HOME,required"`
Port int `env:"PORT" envDefault:"3000"`
IsProduction bool `env:"PRODUCTION"`
Inner inner
}
os.Setenv("HOME", "/tmp/fakehome")
var cfg config
if err := Parse(&cfg); err != nil {
fmt.Println("failed:", err)
}
fmt.Printf("%+v", cfg)
Output: {Home:/tmp/fakehome Port:3000 IsProduction:false Inner:{Foo:foobar}}
func ParseDotenv ¶
ParseDotenv reads an env file from io.Reader, returning a map of keys and values.
func ParseWithFuncs ¶
func ParseWithFuncs(v interface{}, funcMap map[reflect.Type]ParserFunc, opts ...Options) error
ParseWithFuncs is the same as `Parse` except it also allows the user to pass in custom parsers.
Example ¶
type thing struct {
desc string
}
type conf struct {
Thing thing `env:"THING"`
}
os.Setenv("THING", "my thing")
var c = conf{}
err := ParseWithFuncs(&c, map[reflect.Type]ParserFunc{
reflect.TypeOf(thing{}): func(v string) (interface{}, error) {
return thing{desc: v}, nil
},
})
if err != nil {
fmt.Println(err)
}
fmt.Println(c.Thing.desc)
Output: my thing
func Read ¶
Read all env (with same file loading semantics as Load) but return values as a map rather than automatically writing values into env
Types ¶
type Options ¶
type Options struct {
// Environment keys and values that will be accessible for the service.
Environment map[string]string
// TagName specifies another tagname to use rather than the default env.
TagName string
// contains filtered or unexported fields
}
Options for the parser.
type ParserFunc ¶
ParserFunc defines the signature of a function that can be used within `CustomParsers`
Source Files