go常用标准库学习笔记

go常用标准库学习笔记，包含了fmt标准库、os标准库、bytes标准库、io标准库、ioutil标准库、bufio标准库等，收藏可用

fmt标准库

绝知此事要躬行

fmt标准库占位符

1、通用站位符

	fmt.Printf("%v\n", "123")
	fmt.Printf("%+v\n", "123")
	fmt.Printf("%#v\n", "123")
	fmt.Printf("%T\n", "123")
	fmt.Printf("%%\n")

2、布尔占位符

	l := true
	fmt.Printf("%t\n", l)

3、整型占位符

	n := 180
	fmt.Printf("%b\n", n)
	fmt.Printf("%c\n", n)
	fmt.Printf("%d\n", n)
	fmt.Printf("%o\n", n)
	fmt.Printf("%x\n", n)
	fmt.Printf("%X\n", n)

浮点数与复数

	f := 123.34
	fmt.Printf("%b\n", f)
	fmt.Printf("%f\n", f)
	fmt.Printf("%e\n", f)
	fmt.Printf("%E\n", f)
	fmt.Printf("%F\n", f)
	fmt.Printf("%g\n", f)
	fmt.Printf("%G\n", f)

字符串和[]byte

	s := "我是字符串"
	b := []byte{65, 66, 67}
	fmt.Printf("%s\n", s)
	fmt.Printf("%s\n", b)
	fmt.Printf("%q\n", s)
	fmt.Printf("%x\n", s)
	fmt.Printf("%X\n", s)

指针占位符

	var i *int = &n
	fmt.Printf("%p\n", i)

宽度与精度标志符

	fl := 3.12
	fmt.Printf("%f\n", fl)
	fmt.Printf("%10f\n", fl)
	fmt.Printf("%.2f\n", fl)
	fmt.Printf("%10.2f\n", fl)
	fmt.Printf("%10.f\n", fl)

其他占位符

	m := 2
	fmt.Printf("%+v\n", m)
	fmt.Printf(" % d\n", m)
	fmt.Printf("%-d\n", m)
	fmt.Printf("%#d\n", m)
	fmt.Printf("%5d\n", m)

fmt标准库Fprint用法

	fmt.Fprint(os.Stdout, "向标准输出 打印\n")
	fmt.Fprint(os.Stdout, "向标准输出 打印\n")
	fmt.Fprintf(os.Stdout, "%s 向标准输出 打印\n", "张三")

fmt标准库Sprint

Errorf

根据format参数生成格式化字符串并返回一个包含该字符串的错误

err := fmt.Errorf("用户格式不正确:%s", "hha1")
	if err != nil {
		panic(err)
	}

Sprintf

类似于C语言的

fmt.Sprintf("%s:%d",idress,port)

fmt标准库输入

Scan

	var (
		name    string
		age     int
		married bool
	)
	fmt.Scan(&name, &age, &married)
	fmt.Println(name, age, married)

	var (
		name    string
		age     int
		married bool
	)
	reader := strings.NewReader("1:zhangsan 2:18 3:true")
	fmt.Fscanf(reader, "1:%s 2:%d 3:%t", &name, &age, &married)
	fmt.Printf("name:%s age:%d married:%t\n", name, age, married)

os标准库

os标准库有大量的文件操作，需要的权限

• os.Create : 创建文件
• os.Mkdir 创建目录
• os.Remove 移除文件或目录
• os.Getwd 获取当前所在路径
• os.Chdir 更改工作目录
• os.Rename 目录重命名
• os.Chown 更改权限

进程相关

//让当前程序以给出的程序码退出，一般来说，状态码0表示成功，非0表示出错，程序会立刻终止
func Exit(code int)
//获得调用者的用户id
func Getuid() int
//获得调用者的有效用id
func Geteuid() int
//获得调用者组id
func Getgid() int
//获取调用者所在的所有组的组id
func Getgroups()([]int,error)
//获取调用者所在进程的进程
func Getpid() int
//获取调用者所在进程的父进程的

获取命令行参数

func main() {
	args := os.Args
	for _, v := range args {
		fmt.Printf("%v\n", v)
	}
}

bytes标准库

Buffer与Reader

Buffer类型

缓冲区具有读取和写入方法的可变大小字节缓冲区，Buffer的零值是准备使用的空缓冲区。

type Buffer struct {
	buf []byte
	off int
	lastRead readOp
}

声明buffer

• var b bytes.Buffer 直接定义一个buffer变量，不用初始化，可以直接使用
• b := new(bytes.Buffer)使用New返回Buffer变量
• b := bytes.NewBuffer(s []byte) 从一个[]byte切片，构造一个Buffer
• b := bytes.NewBufferString(s string) 从一个string变量，构造一个Buffer

往Buffer中写入数据

• b.Write(d []byte) 将切片d写入Buffer数据
• b.WriteString(s string) 将字符串s写入buffer尾部
• b.WriteByte(c byte) 将字符串c写入Buffer尾部
• b.WriteRune(r rune) 将一个rune类型的数据放到缓冲器尾部
• b.WriteTo(w io.Writer) 将Buffer中的内容输出到实现了io.Writer的可写入对象中

其他方法

• func (b *Buffer) Len() int 未读取部分的数据长度
• func (b* Buffer) Cap() int 获取缓冲的容量
• func (b *Buffer) Next(n int) []byte 读取前n字节的数据并以切片形式返回，如果数据长度小于n，则全部读取，切片只在下一次读写操作前合法.
• func (b *Buffer) Bytes[] byte引用未读取部分的数据切片(不移动读取位置)
• func (b* Buffer) String() string 返回未读取部分的数据字符串(不移动读取位置)
• func (b *Buffer) Grow(n int) 自动增加缓存容量，以保证有n字节的剩余空间，如果n小于0或无法增加容量则会panic
• func (b *Buffer) Truncate(n int) 将数据长度截短到n字节，如果n小于0或大于Cap则panic
• func (b *Buffer) Reset() 重设缓冲区，清空所有数据(包括初始内容)

io标准库

Reader接口

type Reader interface {
	Read(p []byte) (n int,err error)
}

组合接口

• ReadWriter接口
• ReadCloser接口
• WriteCloser接口
• ReadWriteCloser接口
• ReadSeeker 接口
• WriteSeeker 接口
• ReadWriteSeeker接口

ReaderAt 接口

type ReaderAt interface {
	ReadAt(p []byte,off int64)(n int,err error)
}

WriteAt接口

type WriteAt interface {
	WriteAt(p []byte,off int64)(n int,err error)
}

ByteReader接口

type ByteReader interface {
	ReadByte() (byte,error)
}

ByteReader 是基本的ReadByte方法的包装，ReadByte读取输入中的单个字节并返回，如果没有字节可读取，则会返回错误

ByteScanner接口

type ByteScanner interface{
	ByteReader
	UnreadByte() error 
}

ByteScanner接口在基本的ReadByte方法之外还添加了UnreadByte方法，UnreadByte方法让下一次调用ReadByte时返回之前调用ReadByte时返回的同一个字节，连续调用UnreadByte方法而中间没有调用ReadByte时，可能会导致错误

ByteWriter接口

type ByteWriter interface {
	WriteByte(c byte) error
}

包装WriteByte单个字节写入方法的接口

RuneReader接口

type RuneReader interface {
	ReadRune() (r rune,size int,err error)
}

ReadRune方法的包装，读取单个UTF-8 编码的Unicode字符，并返回rune及其字节大小，如果没有可用字符，将设置err

RuneScanner 接口

type RuneScanner interface {
	RuneReader
	UnreadRune() error
}

RuneScanner接口在基本的ReadRune方法之外还添加了UnreadRune方法，UnreadRune方法让下一次调用ReadRune时返回之前调用ReadRune时返回的同一个utf-8字符。连续调用两次UnreadRune方法而中间没有调用ReadRune时，可能会导致错误

StringWriter接口

type StringWriter interface {
	WriteString(s string)(n int,err error)
}

字符串写入方法WrriteString的包装

LimitedReader

type LimitedReader struct {
	R Reader
	N int64
}

LimitedReader从R读取，但将返回的数据量限制为N个字节，每次更新N以标记剩余可以读取的字节数，Read在N <=0事或基础R返回EOF时返回EOF。

PipeReader 接口

type PipeReader struct {
	//内容隐藏或非导出字段
}

PipeReader是一个普通的读取端
具体实现方法有

• func (r *PipeReader) Read(data[] byte) (n int,err error) Read实现了标准的读取接口；它从管道中读取数据阻塞直到写入端到达或写入端被关闭。如果用错误关闭写入端，则返回错误为ERR，否则ERR为EOF
• func (r * PipeReader) Close() error Close关闭读取器，关闭后如果对管道的写入端进行写入操作，就会返回(0,ErrClosedPip)
• func (r *PipeReader) CloseWithError(err error) errorCloseWithError类似Close方法，但将调用Write时返回的错误改为err

PipeWriter

type PipeWriter struct {
}

• func (w *PipeWriter) Write(data[] byte) (n int,err error)write实现了标准的写接口：它将数据写入通道，直到一个或多个读取端消耗完所有数据或读取端关闭为止，如果以错误关闭读取端，则该错误将作为ERR返回，否则ERR作为ErrClosedPipe
• func (w *PipeWriter) Close() error Close关闭写入端，关闭后如果对管道进行读取操作，就会返回(0,EOF)
• func (w *PipeWriter) CloseWithError(err error) error CloseWithErr类似Close方法，但将调用Rea时返回错误改为err

Copy

func Copy(dst Writer,src Reader)(written int64,err error)

将副本从src复制到dst，直到src上达到EOF或发生错误。他返回复制的字节数和复制时遇到的第一个错误，成功的复制将返回err == nil 而不是err ==EOF.因为复制被定义为从src读取直到EOF所以它不会将读取的EOF视为要报告的错误。如果src实现了WriteTo接口，则通过调用src.WriteTo(dst)实现该副本。否则，如果dst实现了ReaderFrom接口，则通过调用dst。ReadFrom(src)实现了该副本

CopyBuffer

func CopyBuffer(dst Writer,src Reader,buf []byte)(written int64,err error)

CopyBuffer 与Copy相同，区别在于CopyBuffer逐步遍历提供的缓冲区(r如果需要)，而不是分配临时混冲去，如果buf为nil，则分配一个，如果长度为0，则CopyBuffer会panic报错，如果src实现了WriterTo或dst实现了ReaderFrom，则buf将不用于执行复制

CopyN

func CopyN(dst Writer,src Reader,n int64)(written int64,err error)

CopyN将n个字节（或直到出错）从src复制到dst，它返回复制的字节数以及复制时遇到的最早错误，返回时，只有err==nil时，writte==n，如果dst实现了ReaderFrom接口，则使用该接口副本

LimitReader

func LimitReader(r Reader,n int64) Reader

LimittedReader从r读取，但将返回的数据量限制为n个字节，每次读取更新n以标记剩余可以读取的字节数，Read在n<=0时或基础r返回EOF时返回EOF

MultiReader

func MultiReader(readers ...Reader) Reader

MultiReader返回一个Reader它是所提供的输入阅读器的逻辑串联。他们被顺序读取，一旦所有输入均返回EOF，读取将返回EOF，如果任何读取器返回非0，非EOF错误，则Read则返回该错误

MultiWriter

func MultiWriter(writers ...Writer) Writer

MultiWriter创建一个Writers，将其写入复制所有提供的写入器中，类似于Unix tee(1)命令，每个写入一次写入每个列出的写入器，如果列出的写程序返回错误，则整个写操作将停止并返回错误，它不会在列表中继续下去

Pipe

func Pipe()(*PipeReader,*PipeWriter)

Pipe创建一个同步的内存管道，可用于链接期望io.Reader的代码和期望io.Writer的代码。
管道上的读和写是一对一匹配的，除非需要多久读取才能使用单词写入。也就是说，每次对PipeWriter的写入都将阻塞，直到它满足从PipeReader读取的一个或多个读取，这些读取完全消耗已写入的数据。数据直接从Write复制到相应的Read，没有内部缓冲，对读的并行调用对写的并行调用也是安全的；单个调用将按顺序执行

ReadAll

func main10() {
	r := strings.NewReader("Go is a general-purpose language designed with system programing in mind.")
	b, err := io.ReadAll(r)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(b))
}

ReadAtLeast

func ReadAtLeast(r Reader,buf []byte,min iint)(n int,err error)

ReadAtLeast从r读取到buf，直到它至少读取了min字节，它返回复制的字节数n，如果读取的字节数少则返回ErrUnexpectedEOF,如果min大于buf的长度，则ReadAtLeast返回ErrShortBuff，返回时，当且仅当err==nil时，n>=min

ReadFull

func ReadFull(r Reader,buf []byte)(n int,err error)

ReadFull将r中的len(buf)个字节准确地读取到buf中，它返回复制的字节数，如果读取到的字节数少则返回错误，仅当未读取任何字节时，错误才是EOF，如果在读取了一些但不是全部字节后发生EOF，则ReadFull返回ErrUnexpectedEOF,返回时，当且仅当err == nil时，0==len(buf)

SectionReader

SectionReader在ReaderAt的基础上实现了Read，Seek和ReadAt

• func NewSectionReader(r ReaderAt,off int64,n int64) * SectionReader 结构体SectionReader的创建方法NewSectionReader返回一个SectionReader它从r开始读取，偏移量为off，并在n个字节后以EOF停止
• func (s *SectionReader) Read(p []byte)(n int,err error) 实现了接口Reader的Read方法
• func(s *SectionReader) ReadAt(p[] byte,off int64) (n int,err error)实现了接口ReaderAt的ReadAt方法
• func(s *SectionReader) Seek(offset int64,where int)(int64 error)实现了接口Seeker的seek方法

TeeReader

func TeeReader(r Reader,w Writer) Reader

TeeReader返回一个Reader，该Reader向w写入从r读取的内容，通过r执行的所有r读取均与对w的相应写入匹配，没有内部缓冲，写入必须在读取完成之前完成。写入时遇到的任何错误均报告为读取错误

ioutil标准库

bufio标准库

bufio包实现了有缓冲的io，它包装一个io.reader或io.Writer接口对象，创建另一个实现了该接口，且同时还提供了缓冲和一些文本I/O的帮助函数对象

bufio基础介绍

type Reader struct {
	buf []byte
	rd  io.Reader
	r,w  int
	err error
	lastByte int
	lastRuneSize int
	
}

• 当缓存区有内容的时，将缓存区内容全部填入p并清空缓存区
• 当缓存区没有内容的时候且len > len(buf)，即要读取的内容比缓存区还要大，直接去文件读取即可。
• 当缓存区没有内容的时候且len < len(buf),即要读取的内容比缓存区小，缓存区从文件读取内容充满缓存区，并将p填满(此时缓存区有剩余内容)
• 以后再次读取时缓存区有内容，将缓存区内容全部填入p并清空缓存区
• reader内部通过维护一个r,w即读入或写入的位置缩影来判断是否缓存区内容被全部读出

Reader

func (b *Reader) Read(p []byte)(n int,err error)

Read读取数据写入p，本方法返回去写入p的字节数，本方法一次调用下层Reader接口一次Read方法，因此返回值n可能小于len,读取到达结尾，返回值n将为n而err将为io.EOF

Peek

func (b *Reader) Peek(n int) ([] byte,error)

Peek返回缓存的一个切片，该切片引用缓存中前n个字节的数据，该操作不会将数据读出，只是引用，引用的数据在下一次读取操作之前是有效的。如果切片长度小于n，则返回一个错误信息说明原因。如果n大于缓存的总大小，则返回ErrBufferFull

ReadByte

func (b *Reader)ReadByte() (c byte,err error)

ReadByte读取并返回一个字节，如果没有可用的数据，会返回错误

UnreadByte

func (b *Reader) UnreadByte() error

UnreadByte吐出最近一次读取的最后一个字节（只能吐出最后一个，多次调用会出问题）

ReadRune

func (b *Reader) ReadRune()(r rune,size int,err error)

ReadRune读取一个utf-8编码的unicode码值，返回该码值，其编码长度和可能的错误，如果utf-8编码非法，读取位置只移动1字节，返回U+FFFD,返回值size为1而err为nil，如果没有可用的数据，会返回错误

UnreadRune

func (b *Reader) UnreadRune() error

UnreadRune吐出最后一次ReadRune调用读取的unicode码值，如果最近一次读取不是调用的ReadRune会返回错误

ReadSlice

func (b *Reader) ReadSlice(delim byte) (line []byte,err error)

ReadSlice读取直到第一次遇到delim字节，返回缓冲里的包含已读取的数据和delim字节的切片。该返回值只在下一次读取操作之前合法。如果ReadSlice放在delim之前遇到错误，他会返回在错误之前读取的数据在缓冲中的切片以及该错误。如果在读取delim之前缓冲就写满了，ReadSlice失败并返回ErrBufferFull.因为ReadSlice的返回值会被下一次I/O操作重写，调用者应尽量使用ReadBytes或ReadString替代本法功法。当且仅当ReadBytes方法返回的切片不以delim结尾时，会返回一次非nil的错误

WriteTo

func (b *Reader) WriteTo(w io.Writer)(n int64,err error)

WriteTo方法实现了io.WriteTo接口

Writer

type Writer struct {
	err error 
	buf []byte
	n int
	wr io.Writer
}

Buffered

func (b *Writer) Buffered() int

Buffered 返回缓冲中已使用的字节数

Available

func (b *Writer) Available() int

Available 返回缓冲中还有多少字节未使用

Write

func (b *Writer) Write(p []byte)(nn int,err error)

Write将p的内容写入缓冲，返回写入的字节数，如果返回值nn < len，还会返回一个错误说明原因

WriteString

func (b *Writer)WriteString(s string)(int,err)

WriteString写入一个字符串，返回写入的字节数，如果返回值m < len(s),还会返回一个错误说明原因

WriteByte

func (b *Writer) WriteByte(c byte) error

WriteByte写入单个字节

WriteRune

func (b * Writer) WriteRune(r rune)(size int,err error)

WriteRune写入一个unicode码值的utf-8编码，返回写入的字节数和可能的错误

Flush

func (b *Writer) Flush() error

Flush方法将缓冲中的数据写入下层的io.Writer接口

ReadFrom

func (b *Writer) ReadFrom(r io.Reader)(n int64,err error)

ReadFrom实现了io.ReaderFrom接口

Text

func (s * Scanner)Text() string

Bytes方法返回最近一次Scan调用生成的token，会申请一个字符串保存token并返回该字符串

Err

func (s *Scanner)Err() error

Err返回的Scanner遇到的第一个非EOF的错误

Bulitin标准库

builtin包提供了一些类型说明，变量和常量声明，还有一些便利函数，这个包不需要导入，这些变量和函数就可以直接使用

• append
• len
• new
• make
• panic

Json标准库

• Marshal
• Unmarshal
• Encode
• Decode

Sort标准库

type Interface interface {
	Less() int
	Less(i,j int) bool
	Swap(i,j int)
}

Math标准库

常量

• math.MaxFloat64
• math.SmallestNonzeroFloat64
• math.MaxFloat32
• math.SmallestNonzeroFloat32
• math.MaxInt8
• math.MinInt8
• math.MaxUint8
• math.MaxInt16
• math.MinInt16
• math…MaxUint16
• math.MaxInt32
• math.MinInt32
• math.MaxUint32
• math.MaxInt64
• math.MinInt64
• math.Pi

IsNaN函数

func IsNaN(f float64) (is bool)

报告f是否表示一个NaN(Not a Number )值，是数值返回一个false，不是数值则返回一个true

Ceil函数

func Ceil(x float64) float64

返回一个不小于x的最小整数，向上取整

Floor函数

与上面类似，向下取整

Trunc函数

func Trunc(x float64) float64

返回x整数部分，与Floor一样

Abs函数

func Abs(x float64) float64

返回x的绝对值

Max函数

返回最大值

Min函数

返回最小值

Dim函数

函数返回x-y和0z中的最大值

Mod函数

返回取模

Sqrt函数

返回平方根

Cbrt函数

返回立方根

Hyport函数

Sqrt(pp+qq)

Pow函数

x的y次方

Sin函数

求正弦

Cos函数

求余弦

Tan函数

求正切

随机数

rand.Seed(time.Now().Unix())
fmt.Println(rand.Int())

runtime标准库

• runtime.Gosched 让出时间片
• runtime.Goexit 退出当前goruntine
• runtime.GOMAXPROCS 最大携程数
• runtime.NumCPU cpu的数量
• runtime.GOOS 运行的操作系统