env

Pros of Viper

• More comprehensive configuration management, supporting multiple config formats (JSON, YAML, TOML, etc.)
• Supports reading from config files, environment variables, command-line flags, and remote systems
• Offers live watching and re-reading of config files

Cons of Viper

• More complex setup and usage compared to env's simplicity
• Heavier dependency with more features that might not be needed for simpler projects
• Steeper learning curve for developers new to the library

Code Comparison

env:

type Config struct {
    Home   string `env:"HOME"`
    Port   int    `env:"PORT" envDefault:"3000"`
    IsProduction bool `env:"PRODUCTION"`
}

cfg := Config{}
if err := env.Parse(&cfg); err != nil {
    fmt.Printf("%+v\n", err)
}

Viper:

viper.SetConfigName("config")
viper.AddConfigPath(".")
err := viper.ReadInConfig()
if err != nil {
    panic(fmt.Errorf("Fatal error config file: %s \n", err))
}

port := viper.GetInt("port")
production := viper.GetBool("production")

Pros of godotenv

• Supports loading environment variables from .env files
• Provides a simple way to parse and set environment variables
• Includes a CLI tool for running commands with .env file support

Cons of godotenv

• Limited functionality for parsing complex data types
• Lacks built-in struct tag support for automatic mapping
• May require additional code for type conversion and validation

Code Comparison

godotenv:

import "github.com/joho/godotenv"

err := godotenv.Load()
if err != nil {
    log.Fatal("Error loading .env file")
}

env:

import "github.com/caarlos0/env/v6"

type config struct {
    Home string `env:"HOME"`
    Port int    `env:"PORT" envDefault:"3000"`
}

cfg := config{}
if err := env.Parse(&cfg); err != nil {
    fmt.Printf("%+v\n", err)
}

Summary

godotenv focuses on loading environment variables from .env files and provides a simple interface for parsing and setting them. It's particularly useful for projects that rely on .env files for configuration.

env, on the other hand, offers more advanced features for parsing environment variables directly into Go structs, with support for various data types, default values, and custom parsers. It's better suited for applications that require more complex configuration handling and type safety.

Choose godotenv for simpler .env file management, or env for more robust struct-based configuration parsing.

Pros of cleanenv

• Supports multiple configuration sources (environment variables, config files, flags)
• Provides validation and custom error messages for configuration fields
• Offers a more comprehensive set of features for complex configuration scenarios

Cons of cleanenv

• Slightly more complex setup and usage compared to env
• May have a steeper learning curve for beginners
• Less focused on simplicity and minimalism

Code Comparison

env:

type Config struct {
    Home   string `env:"HOME"`
    Port   int    `env:"PORT" envDefault:"3000"`
    IsProduction bool `env:"PRODUCTION"`
}

cfg := Config{}
if err := env.Parse(&cfg); err != nil {
    fmt.Printf("%+v\n", err)
}

cleanenv:

type Config struct {
    Home   string `env:"HOME" env-default:"/home/user"`
    Port   int    `env:"PORT" env-default:"3000"`
    IsProduction bool `env:"PRODUCTION" env-default:"false"`
}

var cfg Config
if err := cleanenv.ReadEnv(&cfg); err != nil {
    fmt.Printf("%+v\n", err)
}

Both libraries offer similar basic functionality for parsing environment variables into struct fields. However, cleanenv provides more advanced features and configuration options, while env focuses on simplicity and ease of use.

Pros of koanf

• Supports multiple configuration sources (environment variables, files, command-line flags)
• Offers advanced features like watching for file changes and merging configurations
• Provides type-safe parsing and unmarshaling of configuration data

Cons of koanf

• More complex setup and usage compared to env's simplicity
• Steeper learning curve due to its extensive feature set
• Potentially overkill for simple configuration needs

Code Comparison

env:

type Config struct {
    Home   string `env:"HOME"`
    Port   int    `env:"PORT" envDefault:"3000"`
    IsProduction bool `env:"PRODUCTION"`
}

cfg := Config{}
if err := env.Parse(&cfg); err != nil {
    fmt.Printf("%+v\n", err)
}

koanf:

var k = koanf.New(".")

k.Load(file.Provider("config.yml"), yaml.Parser())
k.Load(env.Provider("APP_", ".", func(s string) string {
    return strings.Replace(strings.ToLower(s), "_", ".", -1)
}), nil)

var config Config
if err := k.Unmarshal("", &config); err != nil {
    log.Fatalf("error unmarshalling config: %v", err)
}