gotenv

README

gotenv

Load environment variables from .env or io.Reader in Go.

Usage

Put the gotenv package on your import statement:

import "subosito.com/go/gotenv"

To modify your app environment variables, gotenv expose 2 main functions:

• gotenv.Load
• gotenv.Apply

By default, gotenv.Load will look for a file called .env in the current working directory.

Behind the scene, it will then load .env file and export the valid variables to the environment variables. Make sure you call the method as soon as possible to ensure it loads all variables, say, put it on init() function.

Once loaded you can use os.Getenv() to get the value of the variable.

Let's say you have .env file:

APP_ID=1234567
APP_SECRET=abcdef

Here's the example of your app:

package main

import (
	"subosito.com/go/gotenv"
	"log"
	"os"
)

func init() {
	gotenv.Load()
}

func main() {
	log.Println(os.Getenv("APP_ID"))     // "1234567"
	log.Println(os.Getenv("APP_SECRET")) // "abcdef"
}

You can also load other than .env file if you wish. Just supply filenames when calling Load(). It will load them in order and the first value set for a variable will win.:

gotenv.Load(".env.production", "credentials")

While gotenv.Load loads entries from .env file, gotenv.Apply allows you to use any io.Reader:

gotenv.Apply(strings.NewReader("APP_ID=1234567"))

log.Println(os.Getenv("APP_ID"))
// Output: "1234567"

Both gotenv.Load and gotenv.Apply DO NOT overrides existing environment variables. If you want to override existing ones, you can see section below.

Environment Overrides

Besides above functions, gotenv also provides another functions that overrides existing:

• gotenv.OverLoad
• gotenv.OverApply

Here's the example of this overrides behavior:

os.Setenv("HELLO", "world")

// NOTE: using Apply existing value will be reserved
gotenv.Apply(strings.NewReader("HELLO=universe"))
fmt.Println(os.Getenv("HELLO"))
// Output: "world"

// NOTE: using OverApply existing value will be overridden
gotenv.OverApply(strings.NewReader("HELLO=universe"))
fmt.Println(os.Getenv("HELLO"))
// Output: "universe"

Throw a Panic

Both gotenv.Load and gotenv.OverLoad returns an error on something wrong occurred, like your env file is not exist, and so on. To make it easier to use, gotenv also provides gotenv.Must helper, to let it panic when an error returned.

err := gotenv.Load(".env-is-not-exist")
fmt.Println("error", err)
// error: open .env-is-not-exist: no such file or directory

gotenv.Must(gotenv.Load, ".env-is-not-exist")
// it will throw a panic
// panic: open .env-is-not-exist: no such file or directory

Another Scenario

Just in case you want to parse environment variables from any io.Reader, gotenv keeps its Parse and StrictParse function as public API so you can use that.

// import "strings"

pairs := gotenv.Parse(strings.NewReader("FOO=test\nBAR=$FOO"))
// gotenv.Env{"FOO": "test", "BAR": "test"}

pairs, err := gotenv.StrictParse(strings.NewReader(`FOO="bar"`))
// gotenv.Env{"FOO": "bar"}

Parse ignores invalid lines and returns Env of valid environment variables, while StrictParse returns an error for invalid lines.

Notes

The gotenv package is a Go port of dotenv project with some additions made for Go. For general features, it aims to be compatible as close as possible.

Documentation

Overview

Package gotenv provides functionality to dynamically load the environment variables

Index

• func Apply(r io.Reader) error
• func Load(filenames ...string) error
• func Marshal(env Env) (string, error)
• func Must(fn func(filenames ...string) error, filenames ...string)
• func OverApply(r io.Reader) error
• func OverLoad(filenames ...string) error
• func Write(env Env, filename string) error
• type Env
  • func Parse(r io.Reader) Env
  • func Read(filename string) (Env, error)
  • func StrictParse(r io.Reader) (Env, error)
  • func Unmarshal(str string) (Env, error)

Functions

func Apply

func Apply(r io.Reader) error

Apply is a function to load an io Reader then export the valid variables into environment variables if they do not exist.

func Load

func Load(filenames ...string) error

Load is a function to load a file or multiple files and then export the valid variables into environment variables if they do not exist. When it's called with no argument, it will load `.env` file on the current path and set the environment variables. Otherwise, it will loop over the filenames parameter and set the proper environment variables.

func Marshal

func Marshal(env Env) (string, error)

Marshal outputs the given environment as a env file. Variables will be sorted by name.

func Must

func Must(fn func(filenames ...string) error, filenames ...string)

Must is wrapper function that will panic when supplied function returns an error.

func OverApply

func OverApply(r io.Reader) error

OverApply is a function to load an io Reader then export and override the valid variables into environment variables.

func OverLoad

func OverLoad(filenames ...string) error

OverLoad is a function to load a file or multiple files and then export and override the valid variables into environment variables.

func Write

func Write(env Env, filename string) error

Write serializes the given environment and writes it to a file

Types

type Env

type Env map[string]string

Env holds key/value pair of valid environment variable

func Parse

func Parse(r io.Reader) Env

Parse is a function to parse line by line any io.Reader supplied and returns the valid Env key/value pair of valid variables. It expands the value of a variable from the environment variable but does not set the value to the environment itself. This function is skipping any invalid lines and only processing the valid one.

func Read

func Read(filename string) (Env, error)

Read is a function to parse a file line by line and returns the valid Env key/value pair of valid variables. It expands the value of a variable from the environment variable but does not set the value to the environment itself. This function is skipping any invalid lines and only processing the valid one.

func StrictParse

func StrictParse(r io.Reader) (Env, error)

StrictParse is a function to parse line by line any io.Reader supplied and returns the valid Env key/value pair of valid variables. It expands the value of a variable from the environment variable but does not set the value to the environment itself. This function is returning an error if there are any invalid lines.

func Unmarshal

func Unmarshal(str string) (Env, error)

Unmarshal reads a string line by line and returns the valid Env key/value pair of valid variables. It expands the value of a variable from the environment variable but does not set the value to the environment itself. This function is returning an error if there are any invalid lines.