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)
}
}
如果看完对自己有所帮助，请点赞支持。