go语言os.exit(1)_Go语言开发（十一）、Go语言常用标准库一
Go语言开发(十一)、Go语言常用标准库一
一、log
1、log模块简介
Go语言中log模块用于在程序中输出日志。
log模块提供了三类日志输出接口，Print、Fatal和Panic。Print是普通输出；Fatal是在执行完Print后，执行 os.Exit(1)；Panic是在执行完Print后调用panic()方法。log模块对每一类接口其提供了3中调用方式，分别是"Xxxx、 Xxxxln、Xxxxf"。
2、log.Print接口
log.Print类接口包括log.Print、log.Println、log.Printf，接口如下：
// Printf calls l.Output to print to the logger.
// Arguments are handled in the manner of fmt.Printf.
func (l *Logger) Printf(format string, v ...interface{}) {
l.Output(2, fmt.Sprintf(format, v...))
}
// Print calls l.Output to print to the logger.
// Arguments are handled in the manner of fmt.Print.
func (l *Logger) Print(v ...interface{}) { l.Output(2, fmt.Sprint(v...)) }
// Println calls l.Output to print to the logger.
// Arguments are handled in the manner of fmt.Println.
func (l *Logger) Println(v ...interface{}) { l.Output(2, fmt.Sprintln(v...)) }
log.Print类接口使用示例：
package main
import (
"log"
)
func logPrintTest(){
arr := []int {2,3}
log.Print("Print array ",arr,"\n")
log.Println("Println array",arr)
log.Printf("Printf array with item [%d,%d]\n",arr[0],arr[1])
}
func main() {
logPrintTest()
}
// output
// 2018/10/06 13:38:29 Print array [2 3]
// 2018/10/06 13:38:29 Println array [2 3]
// 2018/10/06 13:38:29 Printf array with item [2,3]
3、log.Fatal接口
log.Fatal类接口包括log.Fatal、log.Fatalln、log.Fatalf，接口如下：
// Fatal is equivalent to l.Print() followed by a call to os.Exit(1).
func (l *Logger) Fatal(v ...interface{}) {
l.Output(2, fmt.Sprint(v...))
os.Exit(1)
}
// Fatalf is equivalent to l.Printf() followed by a call to os.Exit(1).
func (l *Logger) Fatalf(format string, v ...interface{}) {
l.Output(2, fmt.Sprintf(format, v...))
os.Exit(1)
}
// Fatalln is equivalent to l.Println() followed by a call to os.Exit(1).
func (l *Logger) Fatalln(v ...interface{}) {
l.Output(2, fmt.Sprintln(v...))
os.Exit(1)
}
log.Fata接口会先将日志内容打印到标准输出，接着调用系统的 os.exit(1)接口，退出程序并返回状态1 。但由于直接调用系统接口退出，defer函数不会被调用。
log.Fatal接口使用示例：
package main
import (
"log"
"fmt"
)
func logFatalTest(){
level := "Fatal"
defer func() {
fmt.Println("defer Fatal")
}()
log.Fatal("print ",level, " level\n")
// 后续不会被执行
log.Fatalln("print ",level)
log.Fatalf("print %s level", level)
}
func main() {
logFatalTest()
}
// output
// 2018/10/06 13:47:57 print Fatal level
log.Fatal接口调用会导致程序退出。
4、log.Panic接口
log.Panic类接口包括log.Panic、log.Panicln、log.Panicf，接口如下：
// Panic is equivalent to l.Print() followed by a call to panic().
func (l *Logger) Panic(v ...interface{}) {
s := fmt.Sprint(v...)
l.Output(2, s)
panic(s)
}
// Panicf is equivalent to l.Printf() followed by a call to panic().
func (l *Logger) Panicf(format string, v ...interface{}) {
s := fmt.Sprintf(format, v...)
l.Output(2, s)
panic(s)
}
// Panicln is equivalent to l.Println() followed by a call to panic().
func (l *Logger) Panicln(v ...interface{}) {
s := fmt.Sprintln(v...)
l.Output(2, s)
panic(s)
}
log.Panic接口函数把日志内容刷到标准错误后调用panic函数。
log.Panic接口使用示例：
package main
import (
"log"
"fmt"
)
func logPanicTest(){
level := "Panic"
defer func() {
fmt.Println("defer Panic 1")
if err := recover(); err != nil {
fmt.Println(err)
}
}()
log.Panic(level, " level")
defer func() {
fmt.Println("defer Panic 2")
}()
}
func main() {
logPanicTest()
}
// output
// defer Panic 1
// 2018/10/06 13:55:17 Panic level
// Panic level
第一个defer函数被调用并输出“defer Panic 1”，Panic后声明的defer不会执行。
5、logger定制
Logger是写入日志的基本组件，log模块中存在一个标准Logger，可以直接通过log进行访问，可以直接使用log.xxxx进行日志进行输出。但在实际使用中，不同类型的日志可能拥有需求，仅标准Logger不能满足日志记录的需求，通过创建不同的Logger可以将不同类型的日志分类输出。使用logger前需要首先通过New函数创建一个Logger对象，函数声明如下：
func New(out io.Writer, prefix string, flag int) *Logger {
return &Logger{out: out, prefix: prefix, flag: flag}
}
函数接收三个参数分别是日志输出的IO对象，日志前缀和日志包含的通用信息标识位，通过对参数进行设置可以对Logger进行定制。其中IO对象通常是标准输出os.Stdout，os.Stderr，或者绑定到文件的IO。日志前缀和信息标识位可以对日志的格式进行设置。
一条日志由三个部分组成，其结构如下：
{日志前缀} {标识1} {标识2} ... {标识n} {日志内容}
日志前缀，通过prefix参数设置，可以是任意字符串。
标识，通过flags参数设置，当某个标识被设置，会在日志中进行显示，log模块中定义了如下标识，多个标识通过按位或进行组合：
Ldate 显示当前日期(当前时区)
Ltime 显示当前时间(当前时区)
Lmicroseconds 显示当前时间(微秒)
Llongfile 包含路径的完整文件名
Lshortfile 不包含路径的文件名
LUTC Ldata和Ltime使用UTC时间
LstdFlags 标准Logger的标识，等价于 Ldate | Ltime
Logger相关接口如下：
// Flags returns the output flags for the logger.
func (l *Logger) Flags() int {
l.mu.Lock()
defer l.mu.Unlock()
return l.flag
}
// SetFlags sets the output flags for the logger.
func (l *Logger) SetFlags(flag int) {
l.mu.Lock()
defer l.mu.Unlock()
l.flag = flag
}
// Prefix returns the output prefix for the logger.
func (l *Logger) Prefix() string {
l.mu.Lock()
defer l.mu.Unlock()
return l.pref