Go语言常用内置包

Go语言常用内置包

一、终端模块—flag

定义：flag包实现了命令行参数的解析

package main

import (
	"flag"
	"fmt"
)

func main() {
	var host string
	var port int
	var help bool //定义需要解析的变量
	/*
		1、flag.IntVar(&变量名, "命名参数 -h", 默认值, "帮助信息")
		2、var ip = flag.Int("命名参数 -h", 默认值, "帮助信息")
	*/
	flag.StringVar(&host, "H", "127.0.0.1", "连接地址")
	flag.IntVar(&port, "p", 22, "端口")
	flag.BoolVar(&help, "h", false, "帮助")
	flag.Usage = func() {
		fmt.Println("帮助提示")
		flag.PrintDefaults() //输出帮助
	}
	flag.Parse() //来解析命令行参数写入注册的flag里。
	if help {
		flag.Usage()
	}
	fmt.Println(flag.NArg()) //NArg返回解析flag之后剩余参数的个数。
	fmt.Println(host, port, help)
}

二、日志模块—log

package main
import (
	"fmt"
	"log"
)
func main() {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println(err)
		}
	}()
	log.SetFlags(log.Flags() | log.Lshortfile) //返回输出选项
	log.SetPrefix("main:")                     //设置日志的前缀
	log.Println("我是第一条日志")                     //调用Output函数,打印日志
	log.Fatalln("我是打印后就退出的日志方法，用于不可解决错误")      //用于不可解决
	log.Panicln("我是用于可以使用Recover捕获错误的日志")
}
	logger := log.New(os.Stdout, "main:", log.Flags()|log.Lshortfile)
	//os.Stdin/Stdout/Stderr 标准输入/输出/错误
	logger.Println("我是使用logger对象创建的日志")
	

三、时间—Time

package main

import (
	"fmt"
	"time"
)

func main() {
	//time包的使用
	fmt.Println(time.Now())        //返回当地本地时间
	fmt.Println(time.Now().Unix()) //时间戳
	var num int = 3
	time.Sleep(time.Duration(num) * time.Second)
	fmt.Println("线程休眠num秒，num需要转换为日期格式")
	//time.After 延迟执行
	//time.Tick  间隔执行
	endtime := time.Now().Add(20 * time.Second) //Add返回时间点t+d。
	for now := range time.Tick(3 * time.Second) {
		fmt.Println(now)
		if now.After(endtime) { //如果now代表的时间点在After之后，返回真；否则返回假。
			break
		}
	}
	//后续更新Newticker
}

四、Base64

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	//base64
	//通常说的base64 0-9/a-z/A-Z/+-/总共64个
	fmt.Println(base64.StdEncoding.EncodeToString([]byte("abcd"))) //转换为YWJjZA==
	txt, _ := base64.StdEncoding.DecodeString("YWJjZA==")          //解码
	fmt.Println(string(txt))
	//在URL中+-的特殊字符，base64url(+-替换)
	fmt.Println(base64.URLEncoding.EncodeToString([]byte("abc撒旦sadd"))) //转换为YWJjZA==
	txt, _ = base64.URLEncoding.DecodeString("YWJj5pKS5pemc2FkZA==")    //解码
	fmt.Println(string(txt))
	//非对齐，一般会把字符编写为3的整数倍，不补=号
	//标准
	fmt.Println(base64.RawStdEncoding.EncodeToString([]byte("abcd"))) //转换为YWJjZA==
	//URL
	fmt.Println(base64.RawURLEncoding.EncodeToString([]byte("abc撒旦sadd"))) //转换为YWJjZA==
	//fmt.Println(string(txt))
}

五、Hex编码

package main
import (
	"crypto/md5"
	"encoding/hex"
	"fmt"
)
func main() {
	//hash算法，一般计算签名，用来比较长度，文件是否改变，md5,sha1,sha256,sha512
	fmt.Printf("%x\n", md5.Sum([]byte("hashMD5加密")))
	//分批录入加密
	hasher := md5.New() //返回一个新的使用MD5校验的hash.Hash接口。
	hasher.Write([]byte("hashMD5"))
	hasher.Write([]byte("加密"))                       //在hash中写字节
	fmt.Println(hex.EncodeToString(hasher.Sum(nil))) //EncodeToString方法将数据src编码为字符串s

}

加盐

package main

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

func init() {
	rand.Seed(time.Now().Unix()) //随机数种子，当有随机数种子的时候，按照随机数种子可以生成特定序列
}
func Rand(n int) (string, string) {
	chars := []byte{'a', 'b', 'c', 'd'}
	rt := make([]byte, 0, n)  //容量为0的时候需要append增加
	rt1 := make([]byte, n, n) //这个直接添加
	for i := 0; i < n; i++ {
		rt = append(rt, chars[rand.Intn(len(chars))])
		rt1[i] = chars[rand.Intn(len(chars))]
	}
	return string(rt), string(rt1)
}
func main() {
	rt, rt1 := Rand(3)
	fmt.Println(rt)  //生成盐
	fmt.Println(rt1) //生成盐1

}

六、Exec执行命令

package main

import (
	"fmt"
	"io"
	"os"
	"os/exec"
)

func main() {
	//第一种方法
	//函数返回一个*Cmd，用于使用给出的参数执行name指定的程序。返回值只设定了Path和Args两个参数。
	//如果name不含路径分隔符，将使用LookPath获取完整路径；否则直接使用name。参数arg不应包含命令名。
	//直接打印结果
	cmd := exec.Command("ping", "127.0.0.1")
	bytes, _ := cmd.Output() //输出执行值
	fmt.Println(string(bytes))
	//第二种方法
	//使用管道实时执行
	//StdoutPipe方法返回一个在命令Start后与命令标准输出关联的管道。
	//Wait方法获知命令结束后会关闭这个管道，一般不需要显式的关闭该管道。
	//但是在从管道读取完全部数据之前调用Wait是错误的；
	//同样使用StdoutPipe方法时调用Run函数也是错误的。参见下例：
	output, _ := cmd.StdoutPipe()
	cmd.Start()
	io.Copy(os.Stdout, output)
	cmd.Wait()
}

七、单元测试

后续增强更新

八、字符串转换包—strconv

package main

import (
	"fmt"
	"strconv"
)

func main() {
	//strconv包的运用
	//1、string与bool之间转换
	flag, _ := strconv.ParseBool("false")
	fmt.Println("flag change bool", flag)
	str := strconv.FormatBool(true)
	fmt.Println("true change string", str)
	//string与int之间的转换
	str = strconv.FormatInt(1, 0)    //缩写为Itio
	fmt.Println("int change string")
	num, _ := strconv.ParseInt("123", 0, 0)   //缩写为Atio
	fmt.Printf("%d", num)
}

八、os包

1、os.Read和os.Open方法

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.Open("test.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	buf := make([]byte, 1024)
	n, err := file.Read(buf)
	fmt.Println("文件的长度为", n)
	fmt.Println("文件的内容为", string(buf[0:n]))
	fmt.Println("文件buf长度为", len(string(buf[0:n])))
}

2、os.Create和os.Write

	file, err := os.Create("name.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	file.Write([]byte("哈哈哈哈哈"))

3、os.OpenFile

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.OpenFile("name.txt", os.O_RDWR, 0666)
	if err != nil {
		fmt.Println(err)
	}
	buf := make([]byte, 2048)
	n, err := file.Read(buf)
	fmt.Println("文件长度为", n)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println("读取到结果为：", string(buf[0:n]))
}

4、os.Seek

/*const (
    SEEK_SET int = 0 // 相对于文件起始位置seek
    SEEK_CUR int = 1 // 相对于文件当前位置seek
    SEEK_END int = 2 // 相对于文件结尾位置seek
)*/
package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.OpenFile("name.txt", os.O_RDWR, 0666)
	if err != nil {
		fmt.Println(err)
	}
	file.Seek(3, os.SEEK_SET)
	buf := make([]byte, 3)
	n, err := file.Read(buf)
	fmt.Println("文件长度为", n)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("读取到结果为：", string(buf[0:n]))
}

5、file.sync()

强制保存

6、输出日志

package main

import (
	"log"
	"os"
)

func main() {
	file, err := os.OpenFile("Err_Log.txt", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
	if err != nil {
		return
	}
	log.SetOutput(file)
	log.Println("错误1")
	log.Println("错误2")
	log.Println("错误3")
}

7、os.Stat和os.IsNotExist

package main

import (
	"fmt"
	"os"
)

//判断文件是否存在
func IsFile(fileName string) bool {
	_, err := os.Stat(fileName)
	if err == nil {
		return true
	} else if os.IsNotExist(err) {
		return false
	} else {
		panic(err)
	}
}
func main() {
	flag := IsFile("name1.txt")
	fmt.Println(flag)
}

8、fileInfo

	fileInfo, _ := os.Stat("name.txt")
	fmt.Println(fileInfo.IsDir())
	fmt.Println(fileInfo.Mode())
	fmt.Println(fileInfo.ModTime())
	fmt.Println(fileInfo.Name())

9、标准输入输出

os.Stdout.WriteString("标准输入") //os.Stdin,指的是标准输入

九、.path.filePath

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	path, _ := filepath.Abs("./main.go")  //获取绝对路径
	fmt.Println(filepath.Base(path))      //Base函数返回路径的最后一个元素
	fmt.Println(filepath.Dir(path))       //去除最后的文件获取目录
	fmt.Println(filepath.Clean(path))     //Clean函数通过单纯的词法操作返回和path代表同一地址的最短路径。
	fmt.Println(filepath.Ext(path))       //Ext函数返回path文件扩展名
	fmt.Println(filepath.FromSlash(path)) //FromSlash函数将path中的斜杠（'/'）替换为路径分隔符并返回替换结果，多个斜杠会替换为多个路径分隔符。
	join函数
    walk函数
}

十、strings

1、builder

	var build strings.Builder              //将内容写到内存对象中，不放在本地
	build.Write([]byte("我是kk"))            //写入字节
	build.WriteString("我是阿宇")              //写入字符串
	build.WriteByte('b')                   //写入字节
	fmt.Println("清空之前的内存", build.String()) //获取写入内容
	build.Reset()                          //清空内存
	fmt.Println("清空之后的内存：", build.String())

2、reader

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	reader := strings.NewReader("1234567891123")
	ctx := make([]byte, 10)
	for {
		_, err := reader.Read(ctx)
		if err != nil {
			break
		}
	}
	//重新设置流指针位置
	reader.Seek(0, os.SEEK_SET)           //从光标0开始读取
	n, err := reader.Read(ctx)            //将读取到的数据放在切片中
	fmt.Println(n, err, string(ctx[0:n])) //打印读取内容
	fmt.Println(reader.Size())            //获取reader内存的大小
	reader.Reset("我已经把内容重置了")             //重置内存的内容
	reader.WriteTo(os.Stdout)             //将内容输出到输出流
}

3、buffer

package main

import (
	"bytes"
	"fmt"
)

func main() {
	buffer1 := bytes.NewBuffer([]byte("das,dasd"))
	buffer2 := bytes.NewBuffer([]byte("asdasdas"))
	buffer1.Write([]byte("dasdasdasd"))
	buffer2.WriteString("dsadasdasdas")
	//读取内容
	ctx := make([]byte, 10)
	n, err := buffer1.Read(ctx)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(ctx[0:n]))
	ctx1 := make([]byte, 10)
	n, err1 := buffer2.Read(ctx1)
	if err1 != nil {
		fmt.Println(err1)
	}
	fmt.Println(string(ctx1[0:n]))
	ctx, _ = buffer1.ReadBytes(',')
	fmt.Println(string(ctx))
}
可以通过读写来写出文件复制函数，也可以使用io.copy方法来直接复制

十一、io

io.Copy
io.CopyN
reader:=io.MultiWriter  //一个信息直接输入到很多个文件中，合并多个文件
reader.Read  //将文件一个一个的读取出来
//输出整个文件，第一：使用遍历；第二，使用io.copy+内存

十二、io/ioutil

	file, _ := os.Open("main.go")
	defer file.Close()
	ctx, _ := ioutil.ReadAll(file)
	fmt.Println(string(ctx)) //读取整个文件
		//直接读取文件
	file, _ := os.Open("main.go")
	ctx, _ := ioutil.ReadAll(file)
	fmt.Println(string(ctx))
	ioutil.ReadDir   //返回fileInfo对象，然后可以调用它的方法
	func TempFile
	func TempDir

十三、文件相关应用
应用1：读取整个文件在内存中

package main

import (
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"os"
)

func main() {
	//第一种将文件全部读取到内存中的方法
	fileLog, err := os.OpenFile("Err_Log.txt", os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
	if err != nil {
		log.Fatal(err)
	}
	log.SetOutput(fileLog) //设置输出错误日志
	//读取文件中的所有内容
	file, err := os.Open("./main.go")
	if err != nil {
		log.Println(err)
		return
	}
	buffer := make([]byte, 1024)      //相当于设置每行可以读取几个字节（当前为1024个字节）
	ctx := make([]byte, 0, 1024*1024) //长度为0，容量为2m的切片
	for {
		n, err := file.Read(buffer)
		if err != nil {
			log.Println(err)
			break
		}
		ctx = append(ctx, buffer[0:n]...) //加三点的作用在于可以将同类型的切片添加上去
	}
	fmt.Println(string(ctx))
	//第二种方法
	file, err := os.Open("main.go")
	if err != nil {
		log.Println(err)
	}
	buffer := bytes.NewBuffer([]byte("")) //创建一个buffer对象
	io.Copy(buffer, file)
	fmt.Println(buffer.String())
	//第三种方法  ioutil.ReadAll方法
	file, _ := os.Open("main.go")
	ctx, _ := ioutil.ReadAll(file)
	fmt.Println(string(ctx))
	//第四种方法  直接读取文件
	ctx, _ := ioutil.ReadFile("main.go")
	fmt.Println(string(ctx))
}

应用2：直接读取文件夹

package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
)

func main() {
	//第一种方法
	files, _ := ioutil.ReadDir(".")
	for _, file := range files {
		if file.IsDir() {
			fmt.Println("D", file.Name())
		} else {
			fmt.Println("F", file.Name(), file.Size())
		}
	}
	//第二种方法
	filepath.Walk(".", func(path string, file os.FileInfo, err error) error {
		fmt.Println(path, file.Name(), file.Size(), err)
		return nil
	})
}

应用三、定义临时文件、文件夹

//生成临时文件夹
package main

import (
	"io/ioutil"
	"os"
	"path/filepath"
	"time"
)

func main() {
	dir, _ := ioutil.TempDir("./test", "log") //创建临时文件夹
	file, _ := os.Create(filepath.Join(dir, "test.log"))
	file.WriteString(time.Now().Format("2020-12"))
	file.Close()
	os.RemoveAll(dir)
}
//生成临时文件
package main

import "io/ioutil"

func main() {
	//创建临时文件
	file, _ := ioutil.TempFile("./test", "test.go")
	file.WriteString("测试临时文件的创建")
}

十四、encode

1、encode和decode

package main

import (
	"encoding/gob"
	"fmt"
	"os"
)

type student struct {
	Id   int
	Name string
	Age  int
}

func init() {
	gob.Register(&student{}) //多个类型的时候需要注册
}
func main() {
	stus := []*student{
		{
			Id:   1,
			Name: "tom",
			Age:  21,
		}, {
			Id:   1,
			Name: "tom",
			Age:  21,
		},
	} //定义结构体数组
	file, err := os.Create("En.gob")
	if err != nil {
		fmt.Println(err)
	}
	encoder := gob.NewEncoder(file)
	err = encoder.Encode(stus)
	if err != nil {
		fmt.Println(err)
	}
	stus := []*student{{}}
	file, err := os.Open("En.gob")
	if err != nil {
		fmt.Println(err)
	}
	decoder := gob.NewDecoder(file)
	err = decoder.Decode(&stus)
	if err != nil {
		fmt.Println(err)
	}
	for _, stu := range stus {
		fmt.Println(stu)
	}
}

2、csv

（1）将内容写入到csv中

package main

import (
	"bufio"
	"encoding/csv"
	"fmt"
	"os"
	"strconv"
)

type Student struct {
	Id   int
	Name string
	Age  int
}

func main() {
	stus := []*Student{
		{
			Id:   1,
			Name: "tom",
			Age:  21,
		}, {
			Id:   1,
			Name: "tom",
			Age:  21,
		},
	}
	var str []string = []string{"Id", "Name", "Age"}
	//创建文件
	file, err := os.Create("task.csv")
	if err != nil {
		fmt.Println(err)
	}
	defer file.Close()
	//带缓冲的buffer
	writer := bufio.NewWriter(file)
	//创建写csv写对象
	csvWriter := csv.NewWriter(writer)
	defer csvWriter.Flush()
	csvWriter.Write(str)
	for _, stu := range stus {
		csvWriter.Write([]string{
			strconv.Itoa(stu.Id),
			stu.Name,
			strconv.Itoa(stu.Age),
		})
	}
}

读取csv文件的内容

package main

import (
	"bufio"
	"encoding/csv"
	"fmt"
	"io"
	"os"
)

type Student struct {
	Id   int
	Name string
	Age  int
}

func main() {
	file, err := os.Open("task.csv")
	if err != nil {
		fmt.Println(err)
	}
	reader := bufio.NewReader(file)
	csvReader := csv.NewReader(reader)
	strs, err := csvReader.Read()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(strs)
	for {
		strs, err = csvReader.Read()
		if err == io.EOF {
			break
		}
		fmt.Println(strs)
	}
}

3、json

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"os"
)

type Student struct {
	Id   int
	Name string
	Age  int
}

func main() {
	//序列化
	stu := []*Student{
		{
			Id:   1,
			Name: "tom",
			Age:  21,
		},
		{
			Id:   2,
			Name: "jack",
			Age:  23,
		},
	}
	data, err := json.Marshal(&stu)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(data))
	//序列化格式
	var dst bytes.Buffer
	err = json.Indent(&dst, data, "", "\t")
	if err != nil {
		fmt.Println(err)
	}
	//将buffer缓冲区的东西写入到json文件之中
	file, err := os.Create("student.json")
	if err != nil {
		fmt.Println(err)
	}
	defer file.Close()
	dst.WriteTo(file) // 将缓存区的文件写入文件中
}

文件中读取json对象

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
)

type Student struct {
	Id   int
	Name string
	Age  int
}

func main() {
	var stus []*Student
	jsonText, err := ioutil.ReadFile("student.json")
	if err != nil {
		fmt.Println(err)
	}
	err = json.Unmarshal(jsonText, &stus)
	if err != nil {
		fmt.Println(err)
	}
	for _, stu := range stus {
		fmt.Println(stu)
	}
}

判断是否为json格式

	fmt.Println(json.Valid([]byte("1")))
	fmt.Println(json. ([]byte("true")))

Encode和Decode

package main

import (
	"encoding/json"
	"log"
	"os"
)

type Student struct {
	Id   int
	Name string
	Age  int
}

func main() {
	//初始化
	stus := []*Student{
		{
			Id:   1,
			Name: "tom",
			Age:  21,
		},
		{
			Id:   2,
			Name: "jack",
			Age:  23,
		},
	}
	//使用json加密
	file, err := os.Create("task.json")
	if err != nil {
		log.Fatal(err)
	}
	encoder := json.NewEncoder(file)
	encoder.Encode(stus)
}

package main

import (
	"encoding/json"
	"fmt"
	"os"
)

type Student struct {
	Id   int
	Name string
	Age  int
}

func main() {
	var stus []*Student
	file, _ := os.Open("task.json")
	decoder := json.NewDecoder(file)
	decoder.Decode(&stus)
	for _, stu := range stus {
		fmt.Println(stu)
	}
}

如果看完对自己有所帮助，请点赞支持。