yanlele/golang-index

Hey 👋🏽, I'm Yanlele

About me

• Web Development Engineer
• Currently working with JavaScript and TypeScript
• Continuous learning: Desktop, mobile, fronted, backend, devOps, games, designer

Blogs 🌱

Languages and Tools...

Here are some technologies I use at work

Other Languages I know

My contributions to open-source:

golang-index's Issues

读取配置文件方式

• 配置方式一：yaml
• 配置方式二：ini
• 配置方式三：viper
  • 最基础的使用
  • 使用结构体
  • 使用环境变量来读取不同的配置
• 参考文档

配置方式一：yaml

首先装包 go get -u gopkg.in/yaml.v2

写配置文件： config.yaml

addr: :8080

dsn: "root:123456@tcp(127.0.0.1:3306)/gorm_example?charset=utf8&parseTime=True&loc=Local"
max_idle_conn: 100

读取配置：config.og

package config

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

type Config struct {
	Addr 			string		`yaml:"addr"`
	DSN				string		`yaml:"dsn"`
	MaxIdleConn		int			`yaml:"max_idle_conn"`
}

var config *Config

func init() {
	// 加载配置
	err := load("config/config.yaml")
	if err != nil {
		fmt.Println("Failed to load configuration")
		return
	}
}

func load(path string) error {
	result, err := ioutil.ReadFile(path)
	if err != nil {
		return err
	}

	return yaml.Unmarshal(result, &config)
}

func Get() *Config {
	return config
}

使用：

config.Get().DSN

优点：简单好用

配置方式二：ini

安装依赖包： go get -u github.com/go-ini/ini

添加配置文件：app.ini

# debug or release
RUN_MODE = debug

[app]
PageSize = 10
JwtSecret = 233

RuntimeRootPath = runtime/

ImagePrefixUrl = http://127.0.0.1:8000
ImageSavePath = upload/images/
# MB
ImageMaxSize = 5
ImageAllowExts = .jpg,.jpeg,.png

LogSavePath = logs/
LogSaveName = log
LogFileExt = log
TimeFormat = 20060102

[server]
RunMode = debug
HttpPort = 8080
ReadTimeout = 60
WriteTimeout = 60

[database]
Type = mysql
User = root
Password = 123456
#127.0.0.1:3306
Host = 127.0.0.1:3306
Name = blog
TablePrefix = blog_

解析配置文件： setting.go

package setting

import (
	"github.com/go-ini/ini"
	"log"
	"time"
)

var (
	Cig          *ini.File
	RunMode      string
	HTTPPort     int
	ReadTimeout  time.Duration
	WriteTimeout time.Duration
	PageSize     int
	JwtSecret    string
)

func init() {
	var err error
	Cig, err = ini.Load("conf/app.ini")
	if err != nil {
		log.Fatalf("加载初始化文件 'conf/app.ini' 文件失败: %v", err)
	}
}

func LoadBase() {
	RunMode = Cig.Section("").Key("RUN_MODE").MustString("debug")
}

func LoadServer() {
	sec, err := Cig.GetSection("server")
	if err != nil {
		log.Fatalf("Fail to get section 'server': %v", err)
	}
	HTTPPort = sec.Key("HTTP_PORT").MustInt(8000)
	ReadTimeout = time.Duration(sec.Key("READ_TIMEOUT").MustInt(60)) * time.Second
	WriteTimeout = time.Duration(sec.Key("WRITE_TIMEOUT").MustInt(60)) * time.Second
}

func LoadApp() {
	sec, err := Cig.GetSection("app")
	if err != nil {
		log.Fatalf("Fail to get section 'app': %v", err)
	}
	JwtSecret = sec.Key("JWT_SECRET").MustString("!@)*#)!@U#@*!@!)")
	PageSize = sec.Key("PAGE_SIZE").MustInt(10)
}

设置方式2：
把配置直接使用 mapTo 到一个结构体里面

package setting

import (
	"github.com/go-ini/ini"
	"log"
	"time"
)

type App struct {
	JwtSecret       string
	PageSize        int
	RuntimeRootPath string

	ImagePrefixUrl string
	ImageSavePath  string
	ImageMaxSize   int
	ImageAllowExts []string

	LogSavePath string
	LogSaveName string
	LogFileExt  string
	TimeFormat  string
}

var AppSetting = &App{}

type Server struct {
	RunMode      string
	HttpPort     int
	ReadTimeout  time.Duration
	WriteTimeout time.Duration
}

var ServerSetting = &Server{}

type Database struct {
	Type        string
	User        string
	Password    string
	Host        string
	Name        string
	TablePrefix string
}

var DatabaseSetting = &Database{}

func Setup() {
	appConfig, err := ini.Load("conf/app.ini")
	if err != nil {
		log.Fatalf("加载初始化文件 'conf/app.ini' 文件失败: %v", err)
	}

	err = appConfig.Section("app").MapTo(AppSetting)
	if err != nil {
		log.Fatalf("config mapTo AppSetting err : %v", err)
	}
	AppSetting.ImageMaxSize = AppSetting.ImageMaxSize * 1024 * 1024

	err = appConfig.Section("server").MapTo(ServerSetting)
	if err != nil {
		log.Fatalf("config mapTo ServerSetting err: %v", err)
	}
	ServerSetting.ReadTimeout = ServerSetting.ReadTimeout * time.Second
	ServerSetting.WriteTimeout = ServerSetting.WriteTimeout * time.Second

	err = appConfig.Section("database").MapTo(DatabaseSetting)
	if err != nil {
		log.Fatalf("config mapTo DatabaseSetting err: %v", err)
	}
}

使用：
方式一

setting.PageSize

方式2：

sec, err := setting.Cig.GetSection("database")
if err != nil {
    log.Fatalf("Fail to get section 'databse': %v", err)
}
//dbType = sec.Key("TYPE").MustString("mysql")
dbName = sec.Key("NAME").MustString("blog")
user = sec.Key("USER").MustString("root")
password = sec.Key("PASSWORD").String()
host = sec.Key("HOST").String()
tablePrefix = sec.Key("TABLE_PREFIX").String()

方式3：

dbName = setting.DatabaseSetting.Name

配置方式三：viper

首先需要本地装包： go get github.com/spf13/viper

最基础的使用

package main

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

func main() {
	// 获取项目目录
	workDir, _ := os.Getwd()
	
	v := viper.New()
	v.SetConfigFile(path.Join(workDir, "src/config.yaml"))
	if err := v.ReadInConfig(); err != nil {
		fmt.Println("配置文件读取失败: ", err)
		return
	}
	fmt.Println(v.Get("name"))
}

其中 src/config.yaml 文件配置如下：

name: "test"

使用结构体

package main

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

type ServerConfig struct {
	Name string `json:"name"`
}

func main() {
	// 获取项目目录
	workDir, _ := os.Getwd()

	v := viper.New()
	v.SetConfigFile(path.Join(workDir, "src/config.yaml"))
	if err := v.ReadInConfig(); err != nil {
		fmt.Println("配置文件读取失败: ", err)
		return
	}

	serverConfig := ServerConfig{}
	if err := v.Unmarshal(&serverConfig); err != nil {
		fmt.Println("解析结构体失败", err)
		return
	}

	fmt.Println("结构体： ", serverConfig.Name)
	fmt.Println(v.Get("name"))
}

使用环境变量来读取不同的配置

获取环境变量的方式：

package main

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

// 这两种方式都可以获取环境变量
func getEnvInfo(env string) interface{} {
	viper.AutomaticEnv()
	return viper.Get(env)
}

// 这两种方式都可以获取环境变量
func getEnv(env string) string  {
	return os.Getenv(env)
}

func main() {
	fmt.Println("getEnvInfo: ", getEnvInfo("IS_DEV"))
	fmt.Println("getEnv: ", getEnv("IS_DEV"))
}

运行：

$ IS_DEV=123 go run main.go
getEnvInfo:  123
getEnv:  123

参考文档

• go项目中环境变量的配置

exec 库基础知识

在 Go 语言中，exec 是一个标准库，用于在程序中执行外部命令。它提供了一组函数来创建和执行其他程序，并与其进行交互。

exec 包主要提供以下功能：

1. 执行外部命令：exec.Command() 函数用于创建一个表示外部命令的 Cmd 结构体，然后可以通过该结构体的方法执行该命令。
2. 设置命令的标准输入、输出和错误流：Cmd 结构体提供了 Stdin、Stdout 和 Stderr 字段，可以用来设置命令的标准输入、输出和错误流。
3. 执行命令：Cmd.Run() 方法用于同步执行命令，它会阻塞当前 goroutine 直到命令执行完毕。Cmd.Start() 和 Cmd.Wait() 方法可以分别异步启动命令和等待命令执行完毕。
4. 传递命令参数：Cmd 结构体的 Args 字段用于设置命令的参数。
5. 设置命令的工作目录、环境变量等：Cmd 结构体还提供了一些方法和字段，用于设置命令的工作目录、环境变量等。

exec 包的使用可以方便地在 Go 程序中执行外部命令，获取命令执行的结果，并进行相应的处理。 以下是一个简单的示例，展示了如何使用 exec 执行外部命令：

package main

import (
	"fmt"
	"os/exec"
)

func main() {
	cmd := exec.Command("ls", "-l")
	output, err := cmd.Output()
	if err != nil {
		fmt.Println("命令执行失败:", err)
		return
	}

	fmt.Println("命令执行结果:")
	fmt.Println(string(output))
}

上述代码使用 exec.Command() 创建了一个 Cmd 结构体，用于执行 ls -l 命令。然后使用 cmd.Output() 方法执行命令，并获取命令的输出结果。最后将输出结果打印出来。

通过 exec 包，我们可以在 Go 程序中方便地执行外部命令，并得到命令的执行结果，从而实现与外部环境的交互。

exec.LookPath()

exec.LookPath() 是 Go 语言 exec 包中的一个函数，用于查找可执行程序的路径。它会根据给定的可执行文件名，在系统的 PATH 环境变量中查找并返回该可执行文件的完整路径。

LookPath() 函数的原型如下：

func LookPath(file string) (string, error)

函数接收一个字符串参数 file，表示要查找的可执行文件名。它会在系统的 PATH 环境变量中搜索该文件，并返回一个字符串表示的完整路径。

如果找到了可执行文件，则返回完整路径和 nil 的错误；如果未找到文件，则返回空字符串和一个非空的错误。

下面是一个例子，演示了如何使用 LookPath() 函数查找可执行文件的完整路径：

package main

import (
	"fmt"
	"os/exec"
)

func main() {
	path, err := exec.LookPath("ls")
	if err != nil {
		fmt.Println("未找到可执行文件:", err)
		return
	}

	fmt.Println("ls 可执行文件的完整路径:", path)
}

上述代码使用 LookPath() 函数查找 ls 可执行文件的完整路径。如果找到了 ls 可执行文件，则打印其完整路径；如果未找到，则打印相应的错误信息。

LookPath() 函数在编写需要执行外部命令的程序时非常有用，可以确保要执行的命令在系统中存在，并返回其完整路径，以便后续的命令执行操作。

os.Args 是什么

在 Go 语言中，os.Args 是一个字符串切片（slice），用于获取和处理命令行参数。它存储了程序启动时传递给程序的所有命令行参数，包括程序本身的名称。

os.Args 的定义如下：

var Args []string

其中 Args 是一个字符串切片，用于存储命令行参数。

os.Args 切片的第一个元素 os.Args[0] 是程序本身的名称，后续元素是传递给程序的命令行参数。

通过遍历 os.Args 切片，可以获取和处理命令行参数。

下面是一个简单的例子，展示了如何使用 os.Args 获取命令行参数：

package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Println("程序名称:", os.Args[0])

	if len(os.Args) > 1 {
		fmt.Println("传递的参数:")
		for _, arg := range os.Args[1:] {
			fmt.Println(arg)
		}
	} else {
		fmt.Println("没有传递参数")
	}
}

假设编译并运行上述代码的命令为 go run main.go arg1 arg2，则输出结果为：

程序名称: main
传递的参数:
arg1
arg2

因此，os.Args 是一个方便获取和处理命令行参数的变量，在 Go 语言中使用十分常见。

path/filePath 中有哪些 api

函数名	描述
Abs(path string)	返回路径的绝对路径。
Base(path string)	返回路径的最后一个元素，即文件名或目录名。
Clean(path string)	返回经过规范化的路径，清除不必要的分隔符和.、..元素。
Dir(path string)	返回路径的目录部分。
Ext(path string)	返回路径的扩展名部分。
FromSlash()	将斜杠分隔符替
IsAbs(path string)	判断路径是否为绝对路径。
Match(pattern, name string)	判断文件或目录名称name是否匹配模式pattern。
SplitList(path string)	将路径列表字符串按分隔符分割为多个路径，并返回它们。
Walk(root string, walkFn WalkFunc) error	遍历指定根目录下的所有文件和目录，对每个文件和目录执行指定的函数。
Glob(pattern string)	返回所有匹配模式的文件或目录的名称列表。
HasPrefix(p, prefix string)	判断路径p是否以prefix开头。
Join(elem ...string)	将任意数量的路径元素连接成单个路径，并返回连接后的路径。
Match(pattern, name string)	判断文件或目录名称name是否匹配模式pattern。
Rel(basepath, targpath string)	返回从basepath到targpath的相对路径。
Split(path string)	将路径path分割为目录和文件名，并返回它们。
ToSlash(path string)	将路径中的反斜杠分隔符替换为斜杠分隔符。
VolumeName(path string)	返回路径中的卷名。

这些API也是golang中filepath包中的一部分。它们提供了更多的路径处理功能，比如获取绝对路径、获取文件名或目录名、规范化路径等。另外，Walk函数还可以用于递归遍历文件系统。