常用标准库

数学计算

数学常量

math.E	//自然对数的底，2.718281828459045
math.Pi	//圆周率，3.141592653589793
math.Phi	//黄金分割，长/短，1.618033988749895
math.MaxInt	//9223372036854775807
uint64(math.MaxUint)	//得先把MaxUint转成uint64才能输出，18446744073709551615
math.MaxFloat64	//1.7976931348623157e+308
math.SmallestNonzeroFloat64	//最小的非0且正的浮点数，5e-324

NaN(Not a Number)

f := math.NaN()
math.IsNaN(f)

常用函数

math.Ceil(1.1)	//向上取整，2
math.Floor(1.9)	//向下取整，1。 math.Floor(-1.9)=-2
math.Trunc(1.9)	//取整数部分，1
math.Modf(2.5)	//返回整数部分和小数部分，2  0.5
math.Abs(-2.6)	//绝对值，2.6
math.Max(4, 8)	//取二者的较大者，8
math.Min(4, 8)	//取二者的较小者，4
math.Mod(6.5, 3.5)	//x-Trunc(x/y)*y结果的正负号和x相同，3
math.Sqrt(9)		//开平方，3
math.Cbrt(9)		//开三次方，2.08008

三角函数

math.Sin(1)
math.Cos(1)
math.Tan(1)
math.Tanh(1)

对数和指数

math.Log(5)	//自然对数，1.60943
math.Log1p(4)	//等价于Log(1+p)，确保结果为正数，1.60943
math.Log10(100)	//以10为底数，取对数，2
math.Log2(8)	//以2为底数，取对数，3
math.Pow(3, 2)	//x^y，9
math.Pow10(2)	//10^x，100
math.Exp(2)	//e^x，7.389

随机数生成器

//创建一个Rand
source := rand.NewSource(1) //seed相同的情况下，随机数生成器产生的数列是相同的
rander := rand.New(source)
for i := 0; i < 10; i++ {
    fmt.Printf("%d ", rander.Intn(100))
}
fmt.Println()
source.Seed(1) //必须重置一下Seed
rander2 := rand.New(source)
for i := 0; i < 10; i++ {
    fmt.Printf("%d ", rander2.Intn(100))
}
fmt.Println()

//使用全局Rand
rand.Seed(1)                //如果对两次运行没有一致性要求，可以不设seed
fmt.Println(rand.Int())     //随机生成一个整数
fmt.Println(rand.Float32()) //随机生成一个浮点数
fmt.Println(rand.Intn(100)) //100以内的随机整数，[0,100)
fmt.Println(rand.Perm(100)) //把[0,100)上的整数随机打乱
arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
rand.Shuffle(len(arr), func(i, j int) { //随机打乱一个给定的slice
    arr[i], arr[j] = arr[j], arr[i]
})
fmt.Println(arr)

时间函数

时间的解析和格式化

TIME_FMT := "2006-01-02 15:04:05"
now := time.Now()
ts := now.Format(TIME_FMT)
loc, _ = time.LoadLocation("Asia/Shanghai")
t, _ = time.ParseInLocation(TIME_FMT, ts, loc)

时间运算

diff1 := t1.Sub(t0) //计算t1跟t0的时间差，返回类型是time.Duration
diff2 := time.Since(t0) //计算当前时间跟t0的时间差，返回类型是time.Duration
diff3 := time.Duration(3 * time.Hour) //Duration表示两个时刻之间的距离
t4 := t0.Add(diff3) 
t4.After(t0)    //true

时间的属性

t0.Unix(), t0.UnixMilli(), t0.UnixMicro(), t0.UnixNano()
t2.Year(), t2.Month(), t2.Day(), t2.YearDay()
t2.Weekday().String(), t2.Weekday()
t1.Hour(), t1.Minute(), t1.Second()

定时执行

tm := time.NewTimer(3 * time.Second)
<-tm.C //阻塞3秒钟
//do something
tm.Stop()

//或者用：
<-time.After(3 * time.Second) //阻塞3秒钟

周期执行

tk := time.NewTicker(1 * time.Second)
for i := 0; i < 10; i++ {
    <-tk.C //阻塞1秒钟
    //do something
}
tk.Stop()

I/O操作

格式化输出

输出格式	输出内容
%t	单词 true 或 false
%b	表示为二进制
%d	表示为十进制
%e	（=%.6e）有 6 位小数部分的科学计数法，如 -1234.456e+78
%f	（=%.6f）有 6 位小数部分，如 123.456123
%g	根据实际情况采用 %e 或 %f 格式（获得更简洁、准确的输出）
%s	直接输出字符串或者字节数组
%v	值的默认格式表示
%+v	类似 %v，但输出结构体时会添加字段名
%#v	值的 Go 语法表示
%Т	值的类型的 Go 语法表示

标准输入

fmt.Println("please input two word")
var word1 string 
var word2 string
fmt.Scan(&word1, &word2) //读入多个单词，空格分隔。如果输入了更多单词会被缓存起来，丢给下一次scan

fmt.Println("please input an int")
var i int
fmt.Scanf("%d", &i) //类似于Scan，转为特定格式的数据

打开文件

func os.Open(name string) (*os.File, error)
fout, err := os.OpenFile("data/verse.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)

os.O_WRONLY以只写的方式打开文件，os.O_TRUNC把文件之前的内容先清空掉，os.O_CREATE如果文件不存在则先创建，0666新建文件的权限设置。读文件

cont := make([]byte, 10)
fin.Read(cont) //读出len(cont)个字节，返回成功读取的字节数
fin.ReadAt(cont, int64(n)) //从指定的位置开始读len(cont)个字节
fin.Seek(int64(n), 0) //重新定位。whence: 0从文件开头计算偏移量，1从当前位置计算偏移量，2到文件末尾的偏移量

reader := bufio.NewReader(fin) //读文件文件建议用bufio.Reader
for { //无限循环
    if line, err := reader.ReadString('\n'); err != nil { //指定分隔符
        if err == io.EOF {
            if len(line) > 0 { //如果最后一行没有换行符，则此时最后一行就存在line里
                fmt.Println(line)
            }
            break //已读到文件末尾
        } else {
            fmt.Printf("read file failed: %v\n", err)
        }
    } else {
        line = strings.TrimRight(line, "\n") //line里面是包含换行符的，需要去掉
        fmt.Println(line)
    }
}

写文件

defer fout.Close() //别忘了关闭文件句柄
writer := bufio.NewWriter(fout)
writer.WriteString("明月多情应笑我")
writer.WriteString("\n") //需要手动写入换行符

创建文件/目录

os.Create(name string)//创建文件
os.Mkdir(name string, perm fs.FileMode)//创建目录
os.MkdirAll(path string, perm fs.FileMode)//增强版Mkdir，沿途的目录不存在时会一并创建
os.Rename(oldpath string, newpath string)//给文件或目录重命名，还可以实现move的功能
os.Remove(name string)//删除文件或目录，目录不为空时才能删除成功
os.RemoveAll(path string)//增强版Remove，所有子目录会递归删除

遍历目录

if fileInfos, err := ioutil.ReadDir(path); err != nil {
	return err
} else {
    for _, fileInfo := range fileInfos {
    fmt.Println(fileInfo.Name())
    if fileInfo.IsDir() { //如果是目录，就递归子遍历
        walk(filepath.Join(path, fileInfo.Name}
    }
}

默认的log输出到控制台。

log.Printf("%d+%d=%d\n", 3, 4, 3+4)
log.Println("Hello Golang")
log.Fatalln("Bye, the world") //日志输出后会执行os.Exit(1)

指定日志输出到文件。

logWriter := log.New(fout, "[BIZ_PREFIX]", log.Ldate|log.Lmicroseconds) //通过flag参数定义日志的格式
logWriter.Println("Hello Golang")

调用系统命令

cmd_path, err := exec.LookPath("df") //查看系统命令所在的目录，确保命令已安装
cmd := exec.Command("df", "-h") //相当于命令df -h，注意Command的每一个参数都不能包含空格
output, err := cmd.Output() //cmd.Output()运行命令并获得其输出结果
cmd = exec.Command("rm", "./data/test.log")
cmd.Run() //如果不需要获得命令的输出，直接调用cmd.Run()即可

编码

json是go标准库里自带的序列化工具，使用了反射，效率比较低。
easyjson只针对预先定义好的json结构体对输入的json字符串进行纯字符串的截取，并将对应的json字段赋值给结构体。easyjson -all xxx.go 生成go文件中定义的结构体对应的解析，xxx.go所在的package不能是main。

func easyjson.Marshal(v easyjson.Marshaler) ([]byte, error)
func easyjson.Unmarshal(data []byte, v easyjson.Unmarshaler) error

sonic是字节跳动开源的json序列化工具包，号称性能强过easyjson、jsoniter，使用起来非常方便。

import "github.com/bytedance/sonic"

// Marshal
output, err := sonic.Marshal(&data) 
// Unmarshal
err := sonic.Unmarshal(input, &data)

base64经常在http环境下用来传输较长的信息。任意byte数组都可以采用base64编码转为字符串，并且可以反解回byte数组。编码和解码的方法是公开、确定的， base64不属于加密算法。

func (*base64.Encoding).EncodeToString(src []byte) string
func (*base64.Encoding).DecodeString(s string) ([]byte, error)

compress包下实现了zlib、bzip、gip、lzw等压缩算法。

writer := zlib.NewWriter(fout)//压缩
writer.Write(bytes)
reader, err := zlib.NewReader(fin) //解压
io.Copy(os.Stdout, reader)   //把reader流里的内容拷贝给标准输出流，即文件解压后的内容打印到控制台

常用标准库 ​

数学计算 ​

时间函数 ​

I/O操作 ​

编码 ​

常用标准库

数学计算

时间函数

I/O操作

编码