env: github.com/caarlos0/env Index | Examples | Files

package env

import "github.com/caarlos0/env"

Index

Examples

Package Files

env.go

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

func Parse Uses

func Parse(v interface{}) error

Parse parses a struct containing `env` tags and loads its values from environment variables.

Code:

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 ParseWithFuncs Uses

func ParseWithFuncs(v interface{}, funcMap map[reflect.Type]ParserFunc) error

ParseWithFuncs is the same as `Parse` except it also allows the user to pass in custom parsers.

Code:

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

type ParserFunc Uses

type ParserFunc func(v string) (interface{}, error)

ParserFunc defines the signature of a function that can be used within `CustomParsers`

Package env imports 9 packages (graph) and is imported by 90 packages. Updated 2019-09-17. Refresh now. Tools for package owners.