Go 1.19.4 命令调用、日志、包管理、反射-Day 17

1. 系统命令调用

所谓的命令调用,就是通过os,找到系统中编译好的可执行文件,然后加载到内存中,变成进程。

1.1 exec.LookPath(寻找命令)

作用:

        exec.LookPath 函数用于在系统的环境变量中搜索可执行文件的路径。这个函数属于 os/exec 包,通常用于查找并执行系统命令。

语法:

        func exec.LookPath(file string) (string, error)
参数:
        file string:要查找的可执行文件的名称。

返回值:

        string:该返回值是可执行文件的完整路径,如果找到了的话。

        error:该返回值是一个错误对象,如果搜索过程中出现错误,则返回非 nil 值。

package main

import (
	"fmt"
	"os/exec"
)

func main() {
	// 通过LookPath,在系统PATH中找命令
	s, err := exec.LookPath("git")
	if err != nil {
		panic(err)
	} else {
		fmt.Println("命令在path中找到!")
	}
}
==========调试结果==========
命令在path中找到!

1.2 exec.Command(构造要执行的命令)

作用:

        exec.Command 函数用于创建一个要执行的命令的 *exec.Cmd 结构体(但并不执行)。

语法:

        func exec.Command(name string, arg ...string) *exec.Cmd

参数:

        name string:要执行的可执行文件的名称。如果该文件不在系统的 PATH 环境变量中,你需要提供完整的路径。

        arg ...string:一个字符串切片,表示传递给命令的参数。第一个参数通常是子命令或命令的主要用途,后续参数是该命令的其他选项或参数。

返回值:

        *exec.Cmd:返回一个 *exec.Cmd 结构体,它表示要执行的命令。

package main

import (
	"fmt"
	"os/exec"
)

func main() {
	// 通过LookPath,在系统PATH中找命令
	s, err := exec.LookPath("git")
	if err != nil {
		panic(err)
	}

	// 构造要执行的命令
	// c := exec.Command(s, "-v") // git -v
	// 或者还可以这样
	c := exec.Command(s, []string{"-v"}...)
	fmt.Println(c)      // 打印执行的命令
	fmt.Println(c.Args) // 打印命令的参数列表
}
========调试结果========
D:\软件安装\Git\Git\cmd\git.exe -v
[D:\软件安装\Git\Git\cmd\git.exe -v]

1.3 Output(执行命令,并输出结果)

作用:

        Output 方法用于执行命令并捕获其标准输出。这个方法会启动命令,等待命令完成,并返回命令的输出。

语法:

        func (*exec.Cmd).Output() ([]byte, error)


返回值:

        []byte:输出结果。

        error:如果执行过程中遇到错误,会返回错误信息。

package main

import (
	"fmt"
	"os/exec"
)

func main() {
	// 通过LookPath,在系统PATH中找命令
	s, err := exec.LookPath("git")
	if err != nil {
		panic(err)
	}

	// 构造要执行的命令
	c := exec.Command(s, "-v") // git -v
	// 或者还可以这样
	// c := exec.Command(s, []string{"-v"}...)
	fmt.Println(c)      // 打印执行的命令
	fmt.Println(c.Args) // 打印命令的参数列表

	// 执行命令,并输出结果
	b, err2 := c.Output()
	if err2 != nil {
		panic(err2)
	}
	fmt.Println(b)
	fmt.Printf("b=%v\nstring(b)=%v", b, string(b))
}
===========调试结果===========
D:\软件安装\Git\Git\cmd\git.exe -v
[D:\软件安装\Git\Git\cmd\git.exe -v]
[103 105 116 32 118 101 114 115 105 111 110 32 50 46 52 52 46 48 46 119 105 110 100 111 119 115 46 49 10]
b=[103 105 116 32 118 101 114 115 105 111 110 32 50 46 52 52 46 48 46 119 105 110 100 111 119 115 46 49 10]
string(b)=git version 2.44.0.windows.1

2. 日志

2.1 log包

Go标准库中有log包,提供了简单的日志功能。

日志输出需要使用日志记录器Logger。

2.1.1 log.Print

作用:

        输出日志信息。

语法:

        func log.Print(v ...any)

参数:

        v ...any:表示接受任意数量的参数,并且每个参数可以是任何类型,多参数用逗号分隔。

package main

import (
	"fmt"
	"log"
)

func main() {
	log.Print("xxxxx")
	fmt.Println("xxxx")
}

这里在ide看的比较明显,log.Print默认打印出来的是含年月日,时分秒的,且是红色字体,这是因为它用的是stderr,标准错误输出。

而fmt.Print是标准输出stdout,所以是蓝色字体。

但是颜色仅仅在ide有显示,编译后执行或linux系统中是无颜色的。

2.1.2 log.Fatal

作用:

        用于输出日志信息,并且在输出日志信息后,调用 os.Exit(1)终止程序的运行

语法:

        func log.Fatal(v ...any)


参数:

        v ...any:任意数量,任意类型的参数,多个参数用逗号分隔。

2.1.3 log.Panic

作用:

        用于输出日志信息,并在输出后触发一个 panic,这会导致程序立即停止运行,并开始 panic 恢复机制。

语法:

        func log.Panic(v ...any)


参数:同上。

package main

import (
	"log"
)

func main() {
	log.Panic("log.Panic test!!!")
}

2.2 log.Print系列源码讲解

2.2.1 日志记录器(Logger)

var std = New(os.Stderr, "", LstdFlags),注意这个std虽然是个全局变量,但小写包外不可见的。

上面我们用的log.Print系列,都是调用的这个std对象,但该std既不是标准输出也不是标准错误输出,而是一个标准logger。

因为日志的输出,是需要使用日志记录器(Logger)的,通过Logger才能输出日志,并不是直接print就行了。

Logger日志记录器也叫缺省日志记录器。

var std = New(os.Stderr, "", LstdFlags)含义:

(1)New:这是 log 包中的一个函数,用于创建一个新的 log.Logger 对象,logger实际是一个结构体。

(2)os.Stderr:这是标准库 os 包中的一个变量,表示标准错误输出(stderr)。日志信息会被输出到这个标准错误流。

(3)"":这是 New 函数的第二个参数,表示日志消息前缀。这里传入空字符串,意味着日志消息前不会有额外的前缀。

(4)LstdFlags:这是 log 包中定义的一组日志标志位,用于控制日志输出的格式。LstdFlags 通常包括时间戳、日志级别等信息。

这里注意LstdFlags,点击它看下源码:

const (
	// 将日志的日期设置为当地时间,格式为 2009/01/23。这是通过左移操作符(<<)和 iota 关键字实现
	Ldate         = 1 << iota     // the date in the local time zone: 2009/01/23
	
	// 将日志的时间设置为当地时间,格式为 01:23:23。
	Ltime                         // the time in the local time zone: 01:23:23
	
	// 在时间中包含微秒,格式为 01:23:23.123123,这个选项假设 Ltime 已经被设置。
	Lmicroseconds                 // microsecond resolution: 01:23:23.123123.  assumes Ltime.
	
	// 在日志中包含完整的文件名和行号,例如 /a/b/c/d.go:23。
	Llongfile                     // full file name and line number: /a/b/c/d.go:23
	
	// 在日志中包含文件名的最后一个元素和行号,例如 d.go:23。如果设置了这个选项,它会覆盖 Llongfile。
	Lshortfile                    // final file name element and line number: d.go:23. overrides Llongfile
	
	// 如果设置了 Ldate 或 Ltime,使用协调世界时(UTC)而不是本地时区。
	LUTC                          // if Ldate or Ltime is set, use UTC rather than the local time zone
	
	// 将日志前缀从行的开始移动到消息之前。
	Lmsgprefix                    // move the "prefix" from the beginning of the line to before the message
	
	// 是一个组合标志,设置了日志的初始值,这里组合了 Ldate 和 Ltime。
	LstdFlags     = Ldate | Ltime // initial values for the standard logger
)

上表列出的方法底层都使用std.Output输出日志内容。而std本质上是使用了标准错误输出、无前缀、 LstdFlags标准标记的记录器Logger实例。

2.3 std(标准输出)使用

package main

import (
	"log"
)

func main() {
	log.Print("log.Print")
	log.Printf("log.Printf")
	log.Println("log.Println")

	// 等价于log.Print("log.Fatal");os.Exit(1)
	log.Fatal("log.Fatal")

	// 等价于log.Println("xxx"); panic(),panic的退出状态码为2
	log.Panicln("log.Panicln") 
}
=======调试结果=======
2024/09/29 11:44:14 log.Print
2024/09/29 11:44:14 log.Printf
2024/09/29 11:44:14 log.Println
2024/09/29 11:44:14 log.Fatal

2.4 自定义Logger

2.4.1 标准输出

package main

import (
	"log"
	"os"
)

func main() {
	// stdout: 标准输出
	logger := log.New(os.Stdout, "", log.LstdFlags)

	logger.Println("这是自定义的标准日志输出")
}
======调试结果======
2024/09/29 13:56:22 这是自定义的标准日志输出

2.4.2 标准错误输出

package main

import (
	"log"
	"os"
)

func main() {
	// stderr: 标准错误输出
	// log.LstdFlags: 年月日时分秒
	// log.Lshortfile:在日志中包含完整的文件名和行号
	logger1 := log.New(os.Stderr, "日志前缀:", log.LstdFlags|log.Lshortfile)

	// Fatalln: Println+os.Exit(1)
	logger1.Fatalln("自定义的标准错误输出。")
}
======调试结果======
日志前缀:2024/09/29 14:03:21 main.go:15: 自定义的标准错误输出。
Process 3312 has exited with status 1

这里注意两个地方:

(1)日志前缀:2024/09/29 14:03:21 main.go:15: 自定义的标准错误输出。

这里明确的显示了错误的地方在main.go:15。

(2)status 1

退出状态码为1。

然后还可以配置flag,调整日志前缀的位置。

package main

import (
	"log"
	"os"
)

func main() {
	// stderr: 标准错误输出
	// log.LstdFlags: 年月日时分秒
	// log.Lshortfile:在日志中包含完整的文件名和行号
	logger1 := log.New(os.Stderr, "日志前缀:", log.LstdFlags|log.Lshortfile)

	// Fatalln: Println+os.Exit(1)
	logger1.Println("自定义的标准错误输出。")

	logger2 := log.New(os.Stderr, "日志前缀:", log.LstdFlags|log.Lshortfile|log.Lmsgprefix)
	logger2.Fatalln("自定义的标准错误输出。")
}
=========调试结果=========
日志前缀:2024/09/29 14:23:42 main.go:15: 自定义的标准错误输出。
2024/09/29 14:23:42 main.go:18: 日志前缀:自定义的标准错误输出。

2.5 日志持久化

package main

import (
	"log"
	"os"
)

func main() {
	logfile := "D:/个人/学习/Go/文件与目录操作/test.log"

	f, err := os.OpenFile(logfile, os.O_APPEND|os.O_WRONLY|os.O_CREATE, os.ModePerm)
	if err != nil {
		log.Panic(err)
	}
	defer f.Close()

	l := log.New(f, "", log.LstdFlags|log.Lshortfile)
	l.Println("日志持久化文件测试!")
}

3. zerolog

官网:https://zerolog.io/

上面介绍的log模块太简陋了,实际使用并不方便。
 

常用的三方日志模块如下:

(1)logrus有日志级别、Hook机制、日志格式输出,很好用。

(2)zap是Uber的开源高性能日志库。

(3)zerolog更注重开发体验,高性能、有日志级别、链式API,json格式日志记录,号称0内存分配。

3.1 下载

go get -u github.com/rs/zerolog/log

3.2 简单日志示例

对于简单的日志记录,导入全局记录器包github.com/rs/zerolog/log

package main

// 注意这个包的自动引入的话,需要先zerolog,等import "github.com/rs/zerolog出来后,再自动补充后面的/log
import "github.com/rs/zerolog/log"

func main() {
	log.Print("zerolog/log Print test")
	log.Fatal().Msg("zerolog/log Fatal test")// 这个也是 os.Exit(1)
}
=====调试结果=====
{"level":"debug","time":"2024-09-29T17:28:09+08:00","message":"zerolog/log Print test"}
{"level":"fatal","time":"2024-09-29T17:28:09+08:00","message":"zerolog/log Fatal test"}

3.3 日志级别

zerolog提供以下级别(从高到底)

  • panic (zerolog.PanicLevel, 5)
  • fatal (zerolog.FatalLevel, 4)
  • error (zerolog.ErrorLevel, 3)
  • warn (zerolog.WarnLevel, 2)
  • info (zerolog.InfoLevel, 1)
  • debug (zerolog.DebugLevel, 0)
  • trace (zerolog.TraceLevel, -1)


且级别还分为:

  • gLevel全局级别。
    zerolog.SetGlobalLevel(级别数字或常量) 来设置全局级别。
    zerolog.GlobalLevel() 获取当前全局级别。
  • 每个Logger的级别(日志记录器级别)。
  • 消息的级别(Msg)。
package main

import (
	"github.com/rs/zerolog/log"
)

func main() {
	// debug级别的消息,相当于log.Debug().Msg()
	log.Print("zerolog/log Print test")

	// fatal级别的消息,结合了os.Exit(1)
	log.Fatal().Msg("zerolog/log Fatal test")

	// Panic级别的消息
	log.Panic().Msg("zerolog/log Panic test")
}

3.3.1 尝试先理解“级别”

首先是我们使用的Zeerolog包中的log.xxx这种,它其实是一个缺省(默认的)的logger,比如log.Print,点这个Print看下源码:

func Print(v ...interface{}) {
	Logger.Debug().CallerSkipFrame(1).Msg(fmt.Sprint(v...))
}

然后再点击Logger,跳转到下一层源码:

var Logger = zerolog.New(os.Stderr).With().Timestamp().Logger()

可以看到,这里定义了一个全局的且包外可见的Logger,我们之前使用的zerrolog包中的log.xxx,实际调用的都是这个缺省Logger。

我们可以尝试着调用一下这个Logger:

package main

import (
	"fmt"

	"github.com/rs/zerolog/log"
)

func main() {
	fmt.Println(log.Logger)
}
======调试结果======
{{0xc00000a020} -1 <nil> [123] [{}] false <nil>}

可以看到,log.Logger(缺省logger)的默认级别为 -1 trace

那可以尝试自定义一下这个默认的Logger(日志记录器)级别:

package main

import (
	"fmt"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	fmt.Println(log.Logger)

	// 自定义Logger级别(记录器级别)
	log1 := log.Logger.Level(zerolog.InfoLevel)
	fmt.Println(log1)


}
========调试结果========
{{0xc00000a020} -1 <nil> [123] [{}] false <nil>}
{{0xc00000a020} 1 <nil> [123] [{}] false <nil>}

可以看到,上面自定义的级别,已经从原来的-1变成1了。

接下来试试,-1和1在一起打印。

package main

import (
	"fmt"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	fmt.Println(log.Logger)

	// 自定义Logger级别(记录器级别)
	log1 := log.Logger.Level(zerolog.InfoLevel)
	fmt.Println(log1)

	log.Debug().Msg("log.Debug相当于是log.Print") // 缺省logger

	// 这一条不会打印
    // 该消息是debug级别,通过log1这个日志记录器输出
	log1.Debug().Msg("自定义日志级别的logger")
}
=======调试结果=======
{{0xc00000a020} -1 <nil> [123] [{}] false <nil>}
{{0xc00000a020} 1 <nil> [123] [{}] false <nil>}
{"level":"debug","time":"2024-09-30T15:10:15+08:00","message":"log.Debug相当于是log.Print"}

为什么log1.Debug().Msg("自定义日志级别的logger"),没有打印?


这里就涉及到另一个级别了,“消息级别”。

级别,分为“记录器级别”和“消息级别(Logger)”,我们使用log.xxx,输出的都是“消息级别”,那为啥上面的log1没有打印出来呢?

输出成功的前提:消息级别必须 >= 日志记录器级别

我们在log1中自定义的级别是记录器级别,记录器级别为info,但log1的消息级别为debug,所以输出不了。

所以这里尝设置log1的消息级别为Info,这样消息级别和记录器级别就相等了。

package main

import (
	"fmt"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	fmt.Println(log.Logger)

	// 自定义记录器日志级别
	log1 := log.Logger.Level(zerolog.InfoLevel)
	fmt.Println(log1)

	// 缺省logger的消息级别为debug
	log.Debug().Msg("log.Debug相当于是log.Print")

	// 这一条不会打印,因为log1的记录器日志级别为Info
	log1.Debug().Msg("自定义日志级别的logger")

	log1.Info().Msg("调整log1的消息级别为Info")
}
========调试结果========
{{0xc00000a020} -1 <nil> [123] [{}] false <nil>}
{{0xc00000a020} 1 <nil> [123] [{}] false <nil>}
{"level":"debug","time":"2024-09-30T15:41:36+08:00","message":"log.Debug相当于是log.Print"}
{"level":"info","time":"2024-09-30T15:41:36+08:00","message":"调整log1的消息级别为Info"}

可以看到,调整log1消息级别为Info后,终于输出了。

3.3.2 zerolog

package main

import (
	"fmt"

	"github.com/rs/zerolog"
)

func main() {
	fmt.Println(zerolog.GlobalLevel())
}
========调试结果========
trace

可以看到,zerolog默认的级别为trace,也就是-1。

调整默认级别:

package main

import (
	"fmt"

	"github.com/rs/zerolog"
)

func main() {
	// 3 Error
	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
	fmt.Println(zerolog.GlobalLevel())
}
=========调试结果=========
error

然后,我们结合之前的代码:

package main

import (
	"fmt"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	// 3 Error
	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
	fmt.Println(zerolog.GlobalLevel())

	fmt.Println(log.Logger)

	log1 := log.Logger.Level(zerolog.InfoLevel)
	fmt.Println(log1)

	log.Debug().Msg("log.Debug相当于是log.Print")

	log1.Debug().Msg("自定义日志级别的logger")

	log1.Info().Msg("调整log1的消息级别为Info")

	log1.Error().Msg("调整log1的消息级别为Error")
}
======调试结果======
error
{{0xc00000a020} -1 <nil> [123] [{}] false <nil>}
{{0xc00000a020} 1 <nil> [123] [{}] false <nil>}
{"level":"error","time":"2024-09-30T17:02:21+08:00","message":"调整log1的消息级别为Error"}

根据上述代码发现,zerolog.SetGlobalLevel(zerolog.ErrorLevel)后,原来log和log1的debug和info级别的消息都不打印了,只有log1的error级别打印。

这说明SetGlobalLevel,控制所有Logger的输出级别只有>=GlobalLevel的消息级别,才能输出。

那也就是说,消息级别 >= MAX(Logger(记录器), GlobalLevel),才能最终输出。

3.3.3  消息与日志记录器

首先消息需要通过日志记录器才能输出,不管是输出到屏幕还是文件。
 

如:log1.Info().Msg()。
消息(Msg()),是Info级别(Info())的,通过log1这个日志记录器输出。

但消息输出的前提:消息级别 >= MAX(Logger(记录器,此处是log1自己), GlobalLevel),才能最终输出。

3.4 上下文

zerolog是以Json对象格式输出的,还可以自定义一些键值对字段增加到上下文中以输出。

3.4.1 自定义字段 

package main

import (
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	zerolog.SetGlobalLevel(zerolog.InfoLevel)

	log.Info().Msg("")
}
============调试结果============
{"level":"info","time":"2024-10-08T11:45:25+08:00"}

从上面的输出可以看到,Msg为空,实际打印出来的消息体中也没有mssage。

那我们尝试着自定义一下:

package main

import (
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	zerolog.SetGlobalLevel(zerolog.InfoLevel)

	log.Info().Str("School", "magedu.com").Msg("")

	log.Info().Str("School", "magedu.com").Bool("Address", true).Msg("")
}
============调试结果============
{"level":"info","School":"magedu.com","time":"2024-10-08T14:31:34+08:00"}
{"level":"info","School":"magedu.com","Address":true,"time":"2024-10-08T14:31:34+08:00"}

可以看到,可以通过Str来自定义内容,且Str可以多个(还可以使用其他数据类型)。

3.5 错误日志

package main

import (
	"errors"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	zerolog.SetGlobalLevel(zerolog.InfoLevel)

	err := errors.New("test error")
	log.Error().Msg(err.Error())
	log.Error().Err(err).Msg("")
	log.Error().Err(err).Send()
	log.Fatal().Err(err).Send()
	log.Panic().Err(err).Send()
}
======调试结果======
{"level":"error","time":"2024-10-09T10:29:59+08:00","message":"test error"}
{"level":"error","error":"test error","time":"2024-10-09T10:29:59+08:00"}
{"level":"error","error":"test error","time":"2024-10-09T10:29:59+08:00"}
{"level":"fatal","error":"test error","time":"2024-10-09T10:29:59+08:00"}
package main

import (
	"errors"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log" // 全局logger
)

func main() {
	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix // 自定义time字段时间的格式,TimeFormatUnix时间戳
	// zerolog.ErrorFieldName = "err" // 修改日志Json中的缺省字段名error
	// 错误日志
	err := errors.New("自定义的错误")
	log.Error(). // 错误级别消息
			Err(err). // err字段,错误消息内容
			Send()    // 有错误消息了,message可以省略
	log.Fatal(). // fatal级别
			Err(err).
			Send()
}

3.6 自定义全局logger

3.6.1 全局logger

// Logger is the global logger.
var Logger = zerolog.New(os.Stderr).With().Timestamp().Logger()

 默认使用是这样的:

package main

import (
	"github.com/rs/zerolog/log"
)

func main() {

	log.Debug().Msg("debug")
	log.Error().Msg("Error")
}
============调试结果============
{"level":"debug","time":"2024-10-09T10:44:33+08:00","message":"debug"}
{"level":"error","time":"2024-10-09T10:44:33+08:00","message":"Error"}

3.6.2自定义全局Logger

不建议直接修改默认的全局logger,如果有需求,最好自定义一个。

package main

import (
	"github.com/rs/zerolog/log"
)

func main() {
	log.Logger = log.With().Str("School", "haha").Logger()
	log.Debug().Msg("debug")
	log.Error().Msg("Error")
}
========调试结果========
{"level":"debug","School":"haha","time":"2024-10-09T10:46:11+08:00","message":"debug"}
{"level":"error","School":"haha","time":"2024-10-09T10:46:11+08:00","message":"Error"}
package main

import (
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
	logger := log.With(). // With()返回基于全局Logger的子logger
				Str("School", "Magedu").
				Caller(). // 增加日志调用的位置信息字段
				Logger()  // 返回Logger
	logger.Info().Send() // {"level":"info","School":"Magedu","time":1223947070}
	log.Info().Send()    // {"level":"info","time":1223947070} 全局Logger
}
package main

import (
	"fmt"
	"os"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
	logger := zerolog.New(os.Stdout). // 不基于全局Logger,重新构造了一个Logger
						With().Str("School", "Magedu").
						Caller().                 // 调用者信息:增加日志函数调用的位置信息字段
						Logger().                 // 返回Logger
						Level(zerolog.ErrorLevel) // 重新定义Logger级别为3 error,返回Logger
	fmt.Println(logger.GetLevel())
	logger.Info().Send() // {"level":"info","School":"Magedu","time":1223947070}看颜色区别
	logger.Error().Send()
	log.Info().Send() // {"level":"info","time":1223947070} 全局Logger
}

3.7 写入日志文件

3.7.1 只写入文件

package main

import (
	"fmt"
	"os"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	f, err := os.OpenFile("D:/个人/学习/Go/文件与目录操作/test.log", os.O_WRONLY|os.O_APPEND|os.O_CREATE, os.ModePerm)
	if err != nil {
		log.Panic().Err(err).Send()
	}
	defer f.Close()

	log1 := zerolog.New(f)
	log1.Info().Msg("测试写入")
}

3.7.2 写入文件,并输出到控制台

package main

import (
	"os"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	f, err := os.OpenFile("D:/个人/学习/Go/文件与目录操作/test.log", os.O_WRONLY|os.O_APPEND|os.O_CREATE, os.ModePerm)
	if err != nil {
		log.Panic().Err(err).Send()
	}
	defer f.Close()

	// log1 := zerolog.New(f)
	// log1.Info().Msg("测试写入")

	// 一分为二,一边写文件,一边控制台输出
	lw := zerolog.MultiLevelWriter(f, os.Stdout)
	log := zerolog.New(lw).With().Timestamp().Str("school", "haha").Logger().Level(zerolog.InfoLevel)

	log.Info().Send()
}
=======调试结果=======
{"level":"info","school":"haha","time":"2024-10-09T17:46:17+08:00"}

4. 包管理

用任何语言来开发,如果软件规模扩大,会编写大量的函数、结构体、接口等代码,这些代码不可能写在一个文件中,这就会产生大量的文件。

如果这些文件杂乱无章,就会造成名称冲突、重复定义、难以检索、无法引用、共享不便、版本管理等一系列问题。

如:有一些功能模块如何复用,如何共享方便其他项目使用。

所以,一定要有模块化(包)管理,解决以上诸多问题。

4.1 包

  • 包由多个文件和目录组成。
  • 使用 package <包名> 来定义包名。
  • 包名一般都采用小写,符合标识符要求。
  • 当前目录名和 package <包名> 中的包名不需要一致,但最好保持一致。
  • 同级文件归属一个包,就是说每个包目录的当前目录中,只能统一使用同一个package的包名,否则编译出错。

一般来说,开发项目时,可以把相关功能的代码集中放在某个包里面,例如在main包目录中新建一个calc包,将所有计算函数都放在其中,以供别的代码调用。
 

同一个目录就是同一个包,该包内go文件里的变量、函数、结构体互相可见,可以直接使用。
 

跨目录就是跨包,使用时需要导入别的包,导入需要指定该包的路径。

4.1.1 包内可见演示

先在main.go文件中定义2个全局变量:

package main

// 定义一个小写全局变量,包内(main包内)可见
var a = 100

// 大写全局变量,包外(main包外)可见
var B = 200

func main() {

}

再在main.go文件同级目录中,创建一个x.go文件,并调用a和B变量:

package main

import "fmt"

// 这个test函数,也属于包内可见函数,如果首字母大写,那就是包外可见
func test() {
	fmt.Println(a, B)// 因为该文件也是属于main包的,所以可以调用aB变量
}

回到main.go文件中,调用test函数:

package main

// 定义一个小写全局变量,包内(main包内)可见
var a = 100

// 大写全局变量,包外(main包外)可见
var B = 200

func main() {
	test()
}
=====调试结果=====
100 200

4.2 包管理的发展历程

4.2.1 GOPATH

Go 1.11版本之前,项目依赖包存于GOPATH。GOPATH是一个环境变量,指向一个目录,其中存放项 目依赖包的源码。

GOPATH默认值是 家目录/go 。

开发的代码放在 GOPATH/src 目录中,编译这个目录的代码,生成的二进制文件放到 GOPATH/bin 目录 下。

这会有以下问题:

  • GOPATH不区分项目,代码中任何import的路径均从GOPATH作为根目录开始。如果有多个项目,不同项目依赖不同库的不同版本,这就很难解决了。
  • 所有项目的依赖都放在GOPATH中,很难知道当前项目的依赖项是哪些。

4.2.2 GOPATH + vendor机制

Go1.5引入vendor机制。
vendor:将项目依赖包复制到项目下的vendor目录,在编译时使用项目下的vendor目录的包进行编译。
但依然不能解决不同项目依赖不同包版本问题。

该方式下的包搜索顺序

在当前包vendor目录查找向上级目录查找,直到GOPATH/src/vendor目录
在GOPATH目录查找
在GOROOT目录查找标准库

4.2.3 Go Modules(官方解决方案)

Go Modules是从Go 1.11版本引入,到1.13版本之后已经成熟,Go Modules成为官方的依赖包管理解决方案。

优势:

  • 不受GOPATH限制,代码可放在任意目录。
  • 自动管理和下载依赖,且可以控制使用版本。
  • 不允许使用相对导入。
4.2.3.1 go modules 初始化

之前也演示过,我们最开始写好代码后,需要执行一段命令,来初始化我们的代码:

go mod init 自定义模块名

执行完后,会在当前目录下生成一个go.mod文件,且里面会包含我们使用的第三方库。这样每个目录都有自己的go.mod,就不用担心冲突啥的。

如果想改模块名,可以手动修改,然后当前目录下所有文件都属于该模块。

5. Module模式

5.1 go mod命令

在Go1.11开始引入,可以在任何目录使用go.mod创建项目。

  • go mod init name 命令,在当前文件夹下初始化一个新的module, 创建go.mod文件。
  • go mod tidy 命令自动分析依赖,下载缺失的模块,移除未使用的模块,并更新go.mod文件。

5.1.1 go mod tidy演示

比如我下面这个代码,引入了一些包:

在go.mod中就是这样的:

包括还有go.sum中也会生成内容:

那如果我们不需要这些东西了,该怎么办呢?可以如下操作。

5.1.1.1 清理无用依赖

执行go mod tidy

5.1.1.2 恢复依赖

上面的报错是说,这个包还在,但是go.mod中没有,所以没有办法使用。

解决办法如下:

上面没有//indirect的是直接依赖,有//indirect的是间接依赖,就是直接依赖需要的依赖包。

5.2 导入子包

5.2.1 创建子目录和文件

package calc // 这个包名可以自定义,但是建议和目录名一致。

import "fmt"

// 注意首字母大写,才能包外可见
func Add(x, y int) int {
	fmt.Printf("这是calc.go里面打印的!")
	return x + y
}

这里注意,同一级目录中的.go文件,package名必须一致。

5.2.2 在main包中调用calc.go中的Add函数

package main

import (
	// 注意这个test,一定要是go.mod中的module name
	"test/calc"
)

func main() {
	calc.Add(1, 2)
}
===========调试结果===========
这是calc.go里面打印的!

5.2.3 在子包中创建子包

在子目录中创建子目录和代码文件

5.2.4 调用子包中的子包

5.3 import导入包

5.3.1 绝对导入

就是下面这种,包都是绝对路径的。

package main

import (
	// 注意这个test,一定要是go.mod中的module name
	"test/calc"
	"test/calc/minus"
)

5.3.2 别名导入

如果有两个导入的包冲突时,可以重命名包来避免冲突

import m "magedu.com/tools/calc/minus"

// 使用举例
m.Minus()

5.3.3 相对导入

不建议使用

import "./calc"

5.3.4 匿名导入

import _ "magedu.com/tools/calc/minus"

 使用下划线作为别名,就意味着无法使用了,那其目的何在?

这种情况下,只能执行导入的包内的所有init函数了。主要作用是做包的初始化用。

5.4 导入本地私有包到其它项目

就是自己写的包,想在其他项目用,可以按照如下步骤进行导入。

5.4.1 创建模拟用的本地私有包

比如说我在这个目录下创建了新的代码文件:

然后写了新的代码

package calc

import "fmt"

func Multply(x, y int) int {
	fmt.Println("这是新的私有的calc包!!!")
	return x * y
}

5.4.2 在mian.go中使用新的这个calc包

先在main.go中定义导入的包,可以随便写一个包名:

package main

import (
	"tools/abcd" // 随便写
)

修改go.mod


但此时注意,module test这里报错了:

意思是在新的这个包路径中,找不到go.mod,所以需要初始化一下。

PS D:\个人\学习\Go\私有包\calc> go mod init calc
go: creating new go.mod: module calc
go: to add module requirements and sums:
        go mod tidy

在main.go中使用这个新的私有包

package main

import (
	c "tools/abcd" // c相当于是包的别名
)

func main() {
	c.Multply(2, 3)
}
========调试结果========
这是新的私有的calc包!!!

5.5 导入第三方包

这个不做演示了,官放文档都有,直接go get -u下载就行了。前面的文章也有演示,百度也大把。

6. init函数

6.1 init函数的作用

init函数主要是配合匿名导入使用,目的不是为了让你使用包内的资源,而是运行该包所有的init。

所有的包中,都可以定义init函数。

注意:

  • init函数在本包内可以有n多个,但是每个.go文件中只能有1个。
  • 同一个包内的多个init函数,执行顺序是没有办法保证的。
  • 不同包的init函数的执行顺序由导入顺序决定
  • init函数,无参无返回值,不能被其他函数调用。
  • 包中的init函数将在main函数之前自动执行。

6.2 代码演示

6.2.1 在子包中创建init函数

6.2.1.1 minus.go

6.2.1.2 calc.go

6.2.2 在main.go中调用

package main

import (
	"fmt"
	_ "test/calc"
	_ "test/calc/minus"
)

func main() {
	fmt.Println("这是main.go中的init函数测试!!!")
}
=========调试结果=========
这是calc/calc.go中的init函数!!!
这是calc/minus/minus.go中的init函数!!!
这是main.go中的init函数测试!!!

7.  反射

反射有很大的弊端,这里略过了。

反射的弊端:

  • 代码难以阅读,难以维护。
  • 编译期间不能发现类型错误,覆盖测试难度很大,有些Bug需要线上运行时才可能发现,并造成严 重后果。
  • 反射性能很差,通常比正常代码慢一到两个数量级。如果性能要求高时,或反复调用的代码块里建 议不要使用反射。

反射主要应用场合就是写库或框架,一般用不到,再一个面试时候极低概率被问到。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/897277.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

2024年中国工业大模型行业发展研究报告|附43页PDF文件下载

工业大模型伴随着大模型技术的发展&#xff0c;逐渐渗透至工业&#xff0c;处于萌芽阶段。 就大模型的本质而言&#xff0c;是由一系列参数化的数学函数组成的计算系统&#xff0c;且是一个概率模型&#xff0c;其工作机制是基于概率和统计推动进行的&#xff0c;而非真正的理解…

C++ 进阶:类相关特性的深入探讨

⭐在对C 中类的6个默认成员函数有了初步了解之后&#xff0c;现在我们进行对类相关特性的深入探讨&#xff01; &#x1f525;&#x1f525;&#x1f525;【C】类的默认成员函数&#xff1a;深入剖析与应用&#xff08;上&#xff09; 【C】类的默认成员函数&#xff1a;深入剖…

SpringBoot使用RestTemplate实现发送HTTP请求

Java 实现发送 HTTP 请求&#xff0c;系列文章&#xff1a; 《Java使用原生HttpURLConnection实现发送HTTP请求》 《Java使用HttpClient5实现发送HTTP请求》 《SpringBoot使用RestTemplate实现发送HTTP请求》 1、RestTemplate 的介绍 RestTemplate 是 Spring 框架提供的一个用…

【java】抽象类和接口(了解,进阶,到全部掌握)

各位看官早安午安晚安呀 如果您觉得这篇文章对您有帮助的话 欢迎您一键三连&#xff0c;小编尽全力做到更好 欢迎您分享给更多人哦 大家好我们今天来学习Java面向对象的的抽象类和接口&#xff0c;我们大家庭已经来啦~ 一&#xff1a;抽象类 1.1:抽象类概念 在面向对象的概念中…

12寸FAB厂试产到量产实现无纸化要素之软硬件

在12寸先进封装半导体车间从试产到量产的过程中&#xff0c;实现生产过程无纸化&#xff0c;需要综合考虑软硬件的配置。以下是一些关键的规划建议&#xff1a; 1、生产文档管理系统&#xff08;PDM&#xff09;&#xff1a; 采用基于SOLIDWORKS PDM开发的无纸化方案&#xf…

uniapp 整合 OpenLayers - 加载Geojson数据(在线、离线)

Geojson数据是矢量数据&#xff0c;主要是点、线、面数据集合 Geojson数据获取&#xff1a;DataV.GeoAtlas地理小工具系列 实现代码如下&#xff1a; <template><!-- 监听变量 operation 的变化&#xff0c;operation 发生改变时&#xff0c;调用 openlayers 模块的…

Java面试场景题(1)---如何使用redis记录上亿用户连续登陆天数

感谢uu们的观看&#xff0c;话不多说开始~ 对于这个问题&#xff0c;我们需要先来了解一下~ 海量数据都可以用bitmap来存储&#xff0c;因为占得内存小&#xff0c;速度也很快 我大概计算了一下~ 完全够&#xff1a;String类型512M 1byte 8个bit位 8个状态 512M1024byt…

数据库性能测试报告总结模板

1计划概述 目的&#xff1a;找出系统潜在的性能缺陷 目标&#xff1a;从安全&#xff0c;可靠&#xff0c;稳定的角度出发&#xff0c;找出性能缺陷&#xff0c;并且找出系统最佳承受并发用户数&#xff0c;以及并发用户数下长时间运行的负载情况&#xff0c;如要并发100用户&a…

CTFHUB技能树之SQL——字符型注入

开启靶场&#xff0c;打开链接&#xff1a; 直接指明是SQL字符型注入&#xff0c;但还是来判断一下 &#xff08;1&#xff09;检查是否存在注入点 1 and 11# 返回正确 1 and 12# 返回错误 说明存在SQL字符型注入 &#xff08;2&#xff09;猜字段数 1 order by 2# 1 order…

颠覆编程!通义灵码、包阅AI、CodeGeeX三大AI助手解锁无限潜力!

随着科技的疾速前行&#xff0c;人工智能&#xff08;AI&#xff09;辅助编程工具已跃然成为软件开发领域及编程爱好者群体中不可或缺的得力助手。这些融入了尖端智能化算法的工具&#xff0c;不仅深刻改变了编程工作的面貌&#xff0c;通过自动化和优化手段显著提升了编程效率…

GJS-WCP

不懂的就问&#xff0c;但我也是二把手......哭死 web GJS-ezssti 很常规的ssti模板注入&#xff0c;只过滤了"/","flag"。 过滤了/,flag 可以利用bash的特性绕过&#xff0c;如字符串截取&#xff0c;环境变量等等。payload1: {{url_for.__globals__[…

柔性数组的使用

//柔性数组的使用 #include<stdio.h> #include<stdlib.h> #include<errno.h> struct s {int i;int a[]; }; int main() {struct s* ps (struct s*)malloc(sizeof(struct s) 20 * sizeof(int));if (ps NULL){perror("malloc");return 1;}//使用这…

react18中在列表项中如何使用useRef来获取每项的dom对象

在react中获取dom节点都知道用ref&#xff0c;但是在一个列表循环中&#xff0c;这样做是行不通的&#xff0c;需要做进一步的数据处理。 实现效果 需求&#xff1a;点击每张图片&#xff0c;当前图片出现在可视区域。 代码实现 .box{border: 1px solid #000;list-style: …

Math类、System类、Runtime类、Object类、Objects类、BigInteger类、BigDecimal类

课程目标 能够熟练使用Math类中的常见方法 能够熟练使用System类中的常见方法 能够理解Object类的常见方法作用 能够熟练使用Objects类的常见方法 能够熟练使用BigInteger类的常见方法 能够熟练使用BigDecimal类的常见方法 1 Math类 1.1 概述 tips&#xff1a;了解内容…

Java | Leetcode Java题解之第493题翻转对

题目&#xff1a; 题解&#xff1a; class Solution {public int reversePairs(int[] nums) {Set<Long> allNumbers new TreeSet<Long>();for (int x : nums) {allNumbers.add((long) x);allNumbers.add((long) x * 2);}// 利用哈希表进行离散化Map<Long, Int…

【JAVA】第三张_Eclipse下载、安装、汉化

简介 Eclipse是一种流行的集成开发环境&#xff08;IDE&#xff09;&#xff0c;可用于开发各种编程语言&#xff0c;包括Java、C、Python等。它最初由IBM公司开发&#xff0c;后来被Eclipse Foundation接手并成为一个开源项目。 Eclipse提供了一个功能强大的开发平台&#x…

AI 编译器学习笔记之四 -- cann接口使用

1、安装昇腾依赖 # CANN发布件地址 https://cmc.rnd.huawei.com/cmcversion/index/releaseView?deltaId10274626629404288&isSelectSoftware&url_datarun Ascend-cann-toolkit_8.0.T15_linux-aarch64.run Ascend-cann-nnal_8.0.T15_linux-aarch64.run Ascend-cann-ker…

当下大语言模型(LLM)应用的架构介绍

想要构建你的第一个大语言模型应用&#xff1f;这里有你需要了解的一切&#xff0c;以及你今天就能开始探索的问题领域。 LLM 应用架构 我们的目标是让你能够自由地使用大语言模型进行实验、打造自己的应用&#xff0c;并挖掘那些尚未被人注意的问题领域。为此&#xff0c;Git…

数据类型的通用操作

#通用操作有&#xff1a;for语句遍历&#xff0c;len()统计元素个数&#xff0c;是数据类型间的相互转换&#xff0c;元素的排序&#xff08;正反向&#xff09; 1.for语句遍历若遍历字典则 只去字典中的key(即名词) 2.各数据类型间的数据转换&#xff08;若为字典转化为列表…

2024年软件设计师中级(软考中级)详细笔记【7】面向对象技术(上)(分值10+)

目录 前言第7章 面向对象技术 &#xff08;上&#xff09;7.1 面向对象基础(3-4分&#xff09;7.1.1 面向对象的基本概念7.1.2 面向对象分析&#xff08;熟记&#xff09;7.1.3 面向对象设计7.1.4 面向对象程序设计7.1.5 面向对象测试 7.2 UML(3~4分)7.2.1 事务7.2.2 关系7.2.2…