使用標(biāo)準(zhǔn)庫的encoding/json包讀取JSON配置文件；2. 使用gopkg.in/yaml.v3庫讀取YAML格式配置；3. 結(jié)合os.Getenv或godotenv庫使用環(huán)境變量覆蓋文件配置；4. 使用Viper庫支持多格式配置、環(huán)境變量、自動重載等高級功能；必須定義結(jié)構(gòu)體保證類型安全，妥善處理文件和解析錯(cuò)誤，正確使用結(jié)構(gòu)體標(biāo)籤映射字段，避免硬編碼路徑，生產(chǎn)環(huán)境推薦使用環(huán)境變量或安全配置存儲，可從簡單的JSON開始，需求復(fù)雜時(shí)遷移到Viper。

Reading configuration from files in Go is a common requirement for applications that need to be flexible across environments like development, staging, and production. There are several ways to do this depending on the file format (JSON, YAML, TOML, etc.) and whether you want to use third-party libraries or stick to the standard library.

Here's how you can read configuration from files in Go:

1. Using JSON configuration with the standard library

JSON is widely used and supported natively by Go's encoding/json package.

config.json

 {
  "port": 8080,
  "database_url": "localhost:5432",
  "debug": true
}

main.go

 package main

import (
    "encoding/json"
    "fmt"
    "os"
)

type Config struct {
    Port int `json:"port"`
    DatabaseURL string `json:"database_url"`
    Debug bool `json:"debug"`
}

func main() {
    file, err := os.Open("config.json")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    decoder := json.NewDecoder(file)
    var config Config
    err = decoder.Decode(&config)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Config: % v\n", config)
}

This approach uses only the standard library and works well for simple setups.

2. Using YAML with a third-party library (eg, gopkg.in/yaml.v3 )

YAML is popular for its readability, especially in configuration files.

Install the library:

 go get gopkg.in/yaml.v3

config.yaml

 port: 8080
database_url: localhost:5432
debug: true

main.go

 package main

import (
    "fmt"
    "io/ioutil"
    "gopkg.in/yaml.v3"
)

type Config struct {
    Port int `yaml:"port"`
    DatabaseURL string `yaml:"database_url"`
    Debug bool `yaml:"debug"`
}

func main() {
    data, err := ioutil.ReadFile("config.yaml")
    if err != nil {
        panic(err)
    }

    var config Config
    err = yaml.Unmarshal(data, &config)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Config: % v\n", config)
}

Note: ioutil.ReadFile is deprecated as of Go 1.16. Use os.ReadFile instead:

 data, err := os.ReadFile("config.yaml")

3. Using environment variables with defaults

It's common to allow environment variables to override file settings.

You can combine file reading with os.Getenv :

 port := os.Getenv("PORT")
if port == "" {
    port = "8080" // default or from config file
}

Or use a library like godotenv to load .env files during development.

Install:

 go get github.com/joho/godotenv

.env

 PORT=9000
DEBUG=true

Load it:

 import "github.com/joho/godotenv"

// Load .env file
if err := godotenv.Load(); err != nil {
    // log or ignore if not in dev
}

port := os.Getenv("PORT")

4. Using a configuration library (eg, Viper)

Viper is a powerful library that supports multiple formats (JSON, YAML, TOML, env vars, flags) and automatic reloading.

Install:

 go get github.com/spf13/viper

config.yaml

 port: 8080
database_url: localhost:5432
debug: true

main.go

 package main

import (
    "fmt"
    "github.com/spf13/viper"
)

func main() {
    viper.SetConfigName("config")
    viper.SetConfigType("yaml")
    viper.AddConfigPath(".")

    if err := viper.ReadInConfig(); err != nil {
        panic(err)
    }

    port := viper.GetInt("port")
    dbURL := viper.GetString("database_url")
    debug := viper.GetBool("debug")

    fmt.Printf("Port: %d, DB: %s, Debug: %v\n", port, dbURL, debug)
}

Viper also supports:

• Reading from environment variables ( viper.AutomaticEnv() )
• Watching config changes
• Nested keys with viper.Get("database.host")

Key Tips

• Define a struct that mirrors your config file structure for type safety.
• Always handle file not found and parsing errors gracefully.
• Use tags ( json:"..." , yaml:"..." ) to map fields correctly.
• Avoid hardcoding paths; allow config file location to be set via flag or env.
• For production apps, prefer reading from environment variables or secure config stores.

Basically, you can start simple with JSON and encoding/json , then move to Viper if you need more flexibility. It's not complex, but easy to get wrong if error handling or type mismatches are ignored.

以上是如何從Golang中的文件中讀取配置的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！