Golang标准库

Go语言标准库的包在SDK/src下面

官方标准库文档:

OS库

包 os 为操作系统功能提供了一个独立于平台的接口。设计类似于 Unix，尽管错误处理类似于 Go；失败的调用返回错误类型的值而不是错误号。通常，错误中会提供更多信息。例如，如果采用文件名的调用失败，例如 Open 或 Stat，则错误将在打印时包含失败的文件名，并且类型为 *PathError，可以将其解包以获取更多信息。

文件及目录操作:

package main

import (
	"fmt"
	"os"
)

//创建文件
func createFile() {
	f, err := os.Create("go2.txt") //调用os模块的Create创建文件
	if err == nil {
		fmt.Println("FileName:", f.Name())
	} else {
		fmt.Println("err:", err)
	}
}

//创建目录 创建一个目录
func createDir() {
	//调用os.Mkdir 创建单个目录
	err := os.Mkdir("Gooo", os.ModePerm) //os.ModePerm 表示该文件默认读写权限为777
	if err != nil {
		fmt.Println("err:", err)
	} else {
		fmt.Println("Dir Create Success!")
	}
}

//多级创建目录
func createMultistageDir() {
	//调用os.MkdirAll 创建多级目录
	err := os.MkdirAll("GO/123/A/Mek", os.ModePerm) //os.ModePerm 表示该文件默认读写权限为777
	if err != nil {
		fmt.Println("err:", err)
	} else {
		fmt.Println("Multistage Dir Create Success!")
	}
}

//删除
func Remove() {
	//调用os.Remove 删除单个文件
	err := os.Remove("go.txt")
	if err != nil {
		fmt.Println("err:", err)
	}

	//调用os.RemoveAll 删除目录
	err2 := os.RemoveAll("GO")
	if err2 != nil {
		fmt.Println("err:", err)
	}
}

//获得工作目录,同Linux下的pwd命令
func pwd() {
	//调用os.Getwd() 获得工作路径
	d, err := os.Getwd()
	if err != nil {
		fmt.Println("err:", err)
	} else {
		fmt.Println(d)
	}
}

//修改工作目录
func chWd() {
	err := os.Chdir("d:/")
	if err != nil {
		fmt.Println("err:", err)

	} else {
		d, _ := os.Getwd()
		fmt.Println(d)
	}
}

//重命名文件
func reName() {
	//调用os.Rename 修改文件名
	err := os.Rename("1.txt", "go.log")
	if err != nil {
		fmt.Println("err:", err)
	}
}

//读取文件
func readFile()  {
	b,_ :=os.ReadFile("go.log")
	fmt.Println(b)	// [79 75 79 75]	读取结果为二进制切片
	fmt.Println(string(b[:]))		//转换为字符串  OKOK
}

//写入文件
func writeFile()  {
	err := os.WriteFile("go.log",[]byte("Hello Go!"),os.ModePerm)
	if err != nil {
		fmt.Println("err:", err)
	}
}

func main() {
	readFile()
	writeFile()
}

高阶文件操作:

使用Flie结构体对文件进行操作

package main

import (
	"fmt"
	"io"
	"os"
)

//打开只读文件
func readFile() {
	//调用系统os.Open打开文件
	file, err := os.Open("go.log")
	if err != nil {
		fmt.Println("err:", err)
	}
	fmt.Println(file.Name())

	for {		//循环读取
		buf := make([]byte, 2)	//创建缓冲区用于读取字节码
		_, err := file.Read(buf)

		//fmt.Println(read)           //读取字节数
		fmt.Println(string(buf[:])) //打印输出
		if err == io.EOF {
			break
		}

	}
	file.Close() //关闭文件
}

//创建读写对象
func Fileclass() {
	//调用os.OpenFile 创建文件对象,os.O_RDWR 可读可写,os.O_CREATE不存在则创建,755 权限
	file, err := os.OpenFile("go.log", os.O_RDWR|os.O_CREATE, 755)
	if err != nil {
		fmt.Println("err:", err)
	}
	fmt.Println(file.Name())

	//写入操作
	//写入字节码
	file.Write([]byte("hello File!")) //hello File!

	file.Close() //关闭文件

	//os.O_APPEND 追加写入
	openFile, _ := os.OpenFile("go.log", os.O_RDWR|os.O_APPEND, 0777)
	//写入字符串
	openFile.WriteString("Hello Java")	//hello File!Hello Java
	openFile.Close()
}

//读取目录
func readDir()  {
	//用os.ReadDir读取目录,得到一个切片
	dir, err := os.ReadDir("d:/")
	if err != nil {
		fmt.Println("err:", err)
	}else {
		for _,v := range dir{	//循环
			fmt.Println(v.IsDir())		//判断是否为目录
			fmt.Println(v.Name())		//打印文件名
		}
	}
}




func main() {
	Fileclass()
}

Go 标准库io包input output

Go语言中，为了方便开发者使用，将I0操作封装在了如下几个包中：

io为IO原语（U/oprimitives）提供基本的接口os File Reader Writer

io/ioutil封装一些实用的IO函数

fmt实现格式化I/O，类似C语言中的printf和scan fformat fmt

bufio实现带缓冲I/O

Go 标准库log包

Golang内置了log包，实现简单的日志服务。通过调用log包的函数，可以实现简单的日志打印功能。

print 单纯打印日志

panic 打印日志,抛出panic异常

fatal 打印日志,强制结束程序,程序内的defer 代码不会被执行

package main

import (
	"fmt"
	"log"
)

// Panic 抛出异常程序退出
// Fatal 打印日志程序结束

func setLog()  {	//设置输出方式
	fmt.Println(log.Flags())
	log.SetFlags(log.Ldate|log.Ltime|log.Lshortfile) //输出到文件
}

func pan()  {
	log.Panic("9999")
	fmt.Println("END")		//这句话不会被输出
}

func fa()  {
	log.Fatalf("my Log")
	fmt.Println("END")	//这句话不会被输出

}

func main() {
	//log.Println("my log")		//2022/06/13 15:03:18 mylog
	//log.Printf("my log %d",1069)		//2022/06/13 15:03:18 my log 1069
	setLog()
}

Go 标准库bytes

bytes包提供了对字节切片进行读写操作的一系列函数，字节切片处理的函数比较多分为基本处理函数、比较函
数、后经检查函数、索引函数、分割函数、大小写处理函数和子切片处理函数等.

package main

import (
	"bytes"
	"fmt"
)

//转换字节码
func Convert() {
	s1 := "Mek"
	b1 := []byte(s1)
	fmt.Println(b1)
}

//比较是否包含
func Contains() {
	s := "mek.plus" //声明一个字符串
	b := []byte(s)  //转换为byte类型

	b1 := []byte("Mek") //声明一个字符串转换为byte类型
	b2 := []byte("mek")

	b3 := bytes.Contains(b, b1) //比较是否存在,返回结果为bool类型
	fmt.Println(b3)             //false
	b4 := bytes.Contains(b, b2)
	fmt.Println(b4) //true
}

//计数,对象出现几次
func Count() {
	s := []byte("hellooooooo")
	ep1 := []byte("e")
	ep2 := []byte("l")
	ep3 := []byte("o")
	ep4 := []byte("hell")
	fmt.Println(bytes.Count(s, ep1)) //1
	fmt.Println(bytes.Count(s, ep2)) //2
	fmt.Println(bytes.Count(s, ep3)) //7
	fmt.Println(bytes.Count(s, ep4)) //1
}

//替换
func Repeat() {
	b := []byte("mek.mek.plus")
	// 对象 查找模板 替换目标 计数
	fmt.Println(string(bytes.Replace(b, []byte("mek"), []byte("Mek"), 1)))  //Mek.mek.plus
	fmt.Println(string(bytes.Replace(b, []byte("mek"), []byte("Mek"), 2)))  //Mek.Mek.plus
	fmt.Println(string(bytes.Replace(b, []byte("plus"), []byte("org"), 1))) //mek.mek.org
}



func main() {
}

Go 标准库error

errors包实现了操作错误的函数。语言使用eror类型来返回函数执行过程中遇到的错误，如果返回的error值为
nil，则表示未遇到错误，否则error会返回一个字符串，用于说明遇到了什么错误.

package main

import (
	"errors"
	"fmt"
)

func check(s string)(string,error)  {
	if s == ""{
			//通过errors.New 创建一个错误
		err := errors.New("字符串不能为空!")
		return s,err
	}else {
		return s,nil
	}
}


func main()  {
	a := ""
	s, err := check(a)
	if err != nil {	//err: 字符串不能为空!

		fmt.Println("err:",err)
		fmt.Println(s)
	}else {
		fmt.Println(s)
	}

	b := "Mek"
	s1, err1 := check(b)
	if err1 != nil {
		fmt.Println("err:",err1)	//Mek
		fmt.Println(s1)
	}else {
		fmt.Println(s1)
	}
}

Go标准库sort包

sort包的内容，以及使用:

sort包提供了排序切片和用户自定义数据集以及相关功能的函数。

sort包主要针对[]int、[]f1oat64、[]string、以及其他自定义切片的排序。

package main

import (
	"fmt"
	"sort"
)

func main() {
	i := []int{2, 3, 1, 4, 5}
	//调用 Ints() 对切片进行排序
	sort.Ints(i)
	fmt.Println(i) // [1 2 3 4 5]

	s := []string{"波", "泽", "阿", "斯", "菲"}
	//sort.Strings(s)
	//fmt.Println(s) //[斯 波 泽 菲 阿]
	sort.StringsAreSorted(s)
	fmt.Println(s) //[波 泽 阿 斯 菲]

}

Go标准库time

time包提供测量和显示时间的功能。

基本用法

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()         //获得当前时间
	fmt.Println(now)          //2022-06-14 19:39:41.0934942 +0800 CST m=+0.001020401
	fmt.Println(now.Year())   //年
	fmt.Println(now.Month())  //月
	fmt.Println(now.Day())    //日
	fmt.Println(now.Hour())   //时
	fmt.Println(now.Minute()) //分
	fmt.Println(now.Second()) //秒

}

时间戳

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()            //获得当前时间
	fmt.Println(now.Unix())      //获得时间戳
	fmt.Printf("%T", now.Unix()) //int64

	unix := time.Now().Unix()

	now2 := time.Unix(unix, 0) //将时间戳转换为时间
	fmt.Println(now2)
}

时间差计算

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now() //获得当前时间
	fmt.Println(now)
	now22 := now.Add(time.Hour * 24) //加上24小时
	fmt.Println(now22)

	now11 := now.Sub(now22) //减去另一个时间的剩余时间
	fmt.Println(now11)
}

其他操作

时间格式化输出

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now() //获得当前时间
	fmt.Println(now)
	now22 := now.Add(time.Hour * 24) //加上24小时
	fmt.Println(now22)

	//时间格式化输出
	println(now.Format("2006-01-02 03:04:05"))
	println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))
	println(now.Format("2006/01/02 03:04:05"))
	println(now.Format("2006/01/02"))
}

字符串转时间

package main

import (
	"fmt"
	"time"
)

func main() {
	//调用time.LoadLocation 获得一个时区
	location, err := time.LoadLocation("Asia/Shanghai")
	fmt.Println(err)

	//调用time.ParseInLocation将字符串还原成时间对象
	//使用方法 时间对象格式化格式,字符串,时间
	inLocation, _ := time.ParseInLocation("2006-01-02 15:04:05", "2012-12-21 14:33:00", location)
	fmt.Println(inLocation)
	println(inLocation.Unix())
}

Go标准库json

这个包可以实现json的编码和解码，就是将json字符串转换为struct(结构体或者MAP)，或者将struct转换为json

package main

import (
	"encoding/json"
	"fmt"
)

type Student struct {
	Name    string
	Age     int
	Address Address
}

type Address struct {
	Road     string
	Street   string
	City     string
	Province string
	Country  string
}

//结构体转json
func test1() {
	Zhang3 := Student{
		Name: "张三",
		Age:  18,
		Address: Address{
			Road:     "renmin south road",
			Street:   "123 street",
			City:     "cs",
			Province: "hn",
			Country:  "CN",
		},
	}
	//调用json.Marshal 传入结构体,返回对象是字节切片
	Info_of_Zhang3, err := json.Marshal(Zhang3)
	if err == nil {
		fmt.Println(string(Info_of_Zhang3))
	} else {
		fmt.Println(err)
		return
	}

}

//字符串转结构体
func test2() {
	s := []byte(`{"Name":"张三","Age":18,"Address":{"Road":"renmin south road","Street":"123 street","City":"cs","Province":"hn","Country":"CN"}}`)
	var s1 Student
	
	//还原为map 声明interface{}		 类型
	var s2 interface{} 

	//将字符串还原为结构体
	err := json.Unmarshal(s, &s1)
	fmt.Println("err:", err)
	fmt.Println(s1) //{张三 18 {renmin south road 123 street cs hn CN}}

	//将字符串还原为map
	err2 := json.Unmarshal(s, &s2)
	fmt.Println("err:", err2)
	fmt.Println(s2) //map[Address:map[City:cs Country:CN Province:hn Road:renmin south road Street:123 street] Age:18 Name:张三]
}

func main() {
	test1()
	test2()
}

Go标准库math

该包包含一些常量和一些有用的数学计算函数，例如：三角函数、随机数、绝对值、平方根等。

常用函数

package main

import (
	"fmt"
	"math"
)

func main() {
	//常量
	fmt.Println(math.MaxFloat64, math.SmallestNonzeroFloat64)
	fmt.Println(math.MaxInt32, math.MinInt32)
	fmt.Println(math.Pi)
	//绝对值  3.14
	fmt.Println(math.Abs(-3.14))
	//2的9次方  512
	fmt.Println(math.Pow(2, 9))
	//十的几次方  1000
	fmt.Println(math.Pow10(3))
	//开平方		8
	fmt.Println(math.Sqrt(64))
	//开立方 	3
	fmt.Println(math.Cbrt(27))
	//取余	100/6 的余数
	fmt.Println(math.Mod(100, 6))
}

随机数

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	//设置随机种子数
	rand.Seed(time.Now().UnixMicro())
	fmt.Println(rand.Int())
	//获得100以内的整数
	fmt.Println(rand.Intn(100))
	//获得一个浮点数
	fmt.Println(rand.Float64())
}

文大师的藏经阁

Go语言学习笔记—标准库

Golang标准库

OS库

文件及目录操作:

高阶文件操作:

Go 标准库io包input output

Go语言中，为了方便开发者使用，将I0操作封装在了如下几个包中：

io为IO原语（U/oprimitives）提供基本的接口os File Reader Writer

io/ioutil封装一些实用的IO函数

fmt实现格式化I/O，类似C语言中的printf和scan fformat fmt

bufio实现带缓冲I/O

Go 标准库log包

print 单纯打印日志

panic 打印日志,抛出panic异常

fatal 打印日志,强制结束程序,程序内的defer 代码不会被执行

Go 标准库bytes

Go 标准库error

Go标准库sort包

sort包的内容，以及使用:

sort包提供了排序切片和用户自定义数据集以及相关功能的函数。

sort包主要针对[]int、[]f1oat64、[]string、以及其他自定义切片的排序。

Go标准库time

基本用法

时间戳

时间差计算

其他操作

Go标准库json

Go标准库math

文大师的藏经阁

Go语言学习笔记—标准库

Golang标准库

OS库

文件及目录操作:

高阶文件操作:

Go 标准库io包input output

Go语言中，为了方便开发者使用，将I0操作封装在了如下几个包中：

io为IO原语（U/oprimitives）提供基本的接口os File Reader Writer

io/ioutil封装一些实用的IO函数

fmt实现格式化I/O，类似C语言中的printf和scan fformat fmt

bufio实现带缓冲I/O

Go 标准库log包

print 单纯打印日志

panic 打印日志,抛出panic异常

fatal 打印日志,强制结束程序,程序内的defer 代码 不会被执行

Go 标准库bytes

Go 标准库error

Go标准库sort包

sort包的内容，以及使用:

sort包提供了排序切片和用户自定义数据集以及相关功能的函数。

sort包主要针对[]int、[]f1oat64、[]string、以及其他自定义切片的排序。

Go标准库time

基本用法

时间戳

时间差计算

其他操作

Go标准库json

Go标准库math

fatal 打印日志,强制结束程序,程序内的defer 代码不会被执行