go常用标准库学习笔记，包含了fmt标准库、os标准库、bytes标准库、io标准库、ioutil标准库、bufio标准库等，收藏可用
文章目录
- fmt标准库
- os标准库
- bytes标准库
- io标准库
-
- Reader接口
- 组合接口
-
- [ReaderAt 接口](#ReaderAt 接口)
- WriteAt接口
- ByteReader接口
- ByteScanner接口
- ByteWriter接口
- RuneReader接口
- [RuneScanner 接口](#RuneScanner 接口)
- StringWriter接口
- LimitedReader
- [PipeReader 接口](#PipeReader 接口)
- PipeWriter
- Copy
- CopyBuffer
- CopyN
- LimitReader
- MultiReader
- MultiWriter
- Pipe
- ReadAll
- ReadAtLeast
- ReadFull
- SectionReader
- TeeReader
- ioutil标准库
- bufio标准库
- Bulitin标准库
- Json标准库
- Sort标准库
- Math标准库
- runtime标准库
fmt标准库
绝知此事要躬行
fmt标准库占位符
1、通用站位符
| 占位符 | 说明 |
|---|---|
| %v | 值的默认格式表示 |
| %+v | 类似%v，但输出结构体时会添加字段名 |
| %#v | 值的go语法表示 |
| %T | 打印值的类型 |
| %% | 百分号 |
go
fmt.Printf("%v\n", "123")
fmt.Printf("%+v\n", "123")
fmt.Printf("%#v\n", "123")
fmt.Printf("%T\n", "123")
fmt.Printf("%%\n")
2、布尔占位符
| 占位符 | 说明 |
|---|---|
| %t | true |
go
l := true
fmt.Printf("%t\n", l)
3、整型占位符
| 占位符 | 说明 |
|---|---|
| %b | 表示为二进制 |
| %c | 该值对应的unicode码值 |
| %d | 表示为十进值 |
| %o | 表示为八进制 |
| %x | 表示为十六进制 使用a-f |
| %X | 表示为十六进制，使用 A-F |
| %U | 表示为Unicode格式，U+1234,等价于 "U+%04X" |
| %q | 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示 |
go
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)
浮点数与复数
| 占位符 | 说明 |
|---|---|
| %b | 无小数部分，二进制指数的科学计数法，如-123456p-89 |
| %e | 科学计数法 ，如-1234,456e+78 |
| %E | 科学计数法 ，如-1234.456e+78 |
| %f | 有小数部分但无指数部分，如123.456 |
| %F | 等价于%f |
| %g | 根据实际情况采用%e 或%f 格式 (以获得更简介、准确的输出) |
| %G | 根据实际情况采用%E 或%F 格式(以获得更简介，准确的输出) |
go
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 | 直接输出字符串或者[]byte |
| %q | 该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示 |
| %x | 每个字节用两字符十六进制数表示(使用a-f) |
| %X | 每个字节用两字符十六进制表示(使用A-F) |
go
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)
指针占位符
| 占位符 | 说明 |
|---|---|
| %p | 表示为十六进制 ，并加上前导的0x |
go
var i *int = &n
fmt.Printf("%p\n", i)
宽度与精度标志符
| 占位符 | 说明 |
|---|---|
| %f | 默认宽度，默认精度 |
| %10f | 宽度9，默认精度 |
| %.2f | 默认宽度，精度2 |
| %10.2f | 宽度9，精度2 |
| %10.f | 宽度9，精度0 |
go
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)
其他占位符
| 占位符 | 说明 |
|---|---|
| + | 总是输出数值的正负号，对%q(%+q)会生成全部是ASCII字符的输出 |
| 空格 | 对数值，正数前加空格而负数前面加负号，对字符串采用%x或%X会给出打印的字节之间加空格 |
| - | 在输出右边填充空白而不是默认的左边(即从默认的右对齐切换为左对齐) |
| # | 八进制前加0（%#o）,十六进制数前加0x(%#x)或0x(%#X),指针去掉前面的0x(%#p)对%q(%#q),对%U(%#U) 会输出空格和单引号括起来的go字面值 |
| 0 | 使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面 |
go
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用法
go
fmt.Fprint(os.Stdout, "向标准输出 打印\n")
fmt.Fprint(os.Stdout, "向标准输出 打印\n")
fmt.Fprintf(os.Stdout, "%s 向标准输出 打印\n", "张三")fmt标准库Sprint
Errorf
根据format参数生成格式化字符串并返回一个包含该字符串的错误
go
err := fmt.Errorf("用户格式不正确:%s", "hha1")
if err != nil {
panic(err)
}
Sprintf
类似于C语言的
go
fmt.Sprintf("%s:%d",idress,port)fmt标准库输入
Scan
go
var (
name string
age int
married bool
)
fmt.Scan(&name, &age, &married)
fmt.Println(name, age, married)
go
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 更改权限
进程相关
go
//让当前程序以给出的程序码退出，一般来说，状态码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
//获取调用者所在进程的父进程的获取命令行参数
go
func main() {
args := os.Args
for _, v := range args {
fmt.Printf("%v\n", v)
}
}bytes标准库
Buffer与Reader
Buffer类型
缓冲区具有读取和写入方法的可变大小字节缓冲区，Buffer的零值是准备使用的空缓冲区。
go
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切片，构造一个Bufferb := 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或无法增加容量则会panicfunc (b *Buffer) Truncate(n int)将数据长度截短到n字节，如果n小于0或大于Cap则panicfunc (b *Buffer) Reset()重设缓冲区，清空所有数据(包括初始内容)
io标准库
Reader接口
go
type Reader interface {
Read(p []byte) (n int,err error)
}
组合接口
- ReadWriter接口
- ReadCloser接口
- WriteCloser接口
- ReadWriteCloser接口
- ReadSeeker 接口
- WriteSeeker 接口
- ReadWriteSeeker接口
ReaderAt 接口
go
type ReaderAt interface {
ReadAt(p []byte,off int64)(n int,err error)
}
WriteAt接口
go
type WriteAt interface {
WriteAt(p []byte,off int64)(n int,err error)
}
ByteReader接口
go
type ByteReader interface {
ReadByte() (byte,error)
}ByteReader 是基本的ReadByte方法的包装，ReadByte读取输入中的单个字节并返回，如果没有字节可读取，则会返回错误
ByteScanner接口
go
type ByteScanner interface{
ByteReader
UnreadByte() error
}ByteScanner接口在基本的ReadByte方法之外还添加了UnreadByte方法，UnreadByte方法让下一次调用ReadByte时返回之前调用ReadByte时返回的同一个字节，连续调用UnreadByte方法而中间没有调用ReadByte时，可能会导致错误
ByteWriter接口
go
type ByteWriter interface {
WriteByte(c byte) error
}包装WriteByte单个字节写入方法的接口
RuneReader接口
go
type RuneReader interface {
ReadRune() (r rune,size int,err error)
}ReadRune方法的包装，读取单个UTF-8 编码的Unicode字符，并返回rune及其字节大小，如果没有可用字符，将设置err
RuneScanner 接口
go
type RuneScanner interface {
RuneReader
UnreadRune() error
}RuneScanner接口在基本的ReadRune方法之外还添加了UnreadRune方法，UnreadRune方法让下一次调用ReadRune时返回之前调用ReadRune时返回的同一个utf-8字符。连续调用两次UnreadRune方法而中间没有调用ReadRune时，可能会导致错误
StringWriter接口
go
type StringWriter interface {
WriteString(s string)(n int,err error)
}字符串写入方法WrriteString的包装
LimitedReader
go
type LimitedReader struct {
R Reader
N int64
}LimitedReader从R读取，但将返回的数据量限制为N个字节，每次更新N以标记剩余可以读取的字节数，Read在N <=0事或基础R返回EOF时返回EOF。
PipeReader 接口
go
type PipeReader struct {
//内容隐藏或非导出字段
}PipeReader是一个普通的读取端
具体实现方法有
func (r *PipeReader) Read(data[] byte) (n int,err error)Read实现了标准的读取接口；它从管道中读取数据阻塞直到写入端到达或写入端被关闭。如果用错误关闭写入端，则返回错误为ERR，否则ERR为EOFfunc (r * PipeReader) Close() errorClose关闭读取器，关闭后如果对管道的写入端进行写入操作，就会返回(0,ErrClosedPip)func (r *PipeReader) CloseWithError(err error) errorCloseWithError类似Close方法，但将调用Write时返回的错误改为err
PipeWriter
go
type PipeWriter struct {
}func (w *PipeWriter) Write(data[] byte) (n int,err error)write实现了标准的写接口：它将数据写入通道，直到一个或多个读取端消耗完所有数据或读取端关闭为止，如果以错误关闭读取端，则该错误将作为ERR返回，否则ERR作为ErrClosedPipefunc (w *PipeWriter) Close() errorClose关闭写入端，关闭后如果对管道进行读取操作，就会返回(0,EOF)func (w *PipeWriter) CloseWithError(err error) errorCloseWithErr类似Close方法，但将调用Rea时返回错误改为err
Copy
go
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
go
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
go
func CopyN(dst Writer,src Reader,n int64)(written int64,err error)CopyN将n个字节（或直到出错）从src复制到dst，它返回复制的字节数以及复制时遇到的最早错误，返回时，只有err==nil时，writte==n，如果dst实现了ReaderFrom接口，则使用该接口副本
LimitReader
go
func LimitReader(r Reader,n int64) ReaderLimittedReader从r读取，但将返回的数据量限制为n个字节，每次读取更新n以标记剩余可以读取的字节数，Read在n<=0时或基础r返回EOF时返回EOF
MultiReader
go
func MultiReader(readers ...Reader) ReaderMultiReader返回一个Reader它是所提供的输入阅读器的逻辑串联。他们被顺序读取，一旦所有输入均返回EOF，读取将返回EOF，如果任何读取器返回非0，非EOF错误，则Read则返回该错误
MultiWriter
go
func MultiWriter(writers ...Writer) WriterMultiWriter创建一个Writers，将其写入复制所有提供的写入器中，类似于Unix tee(1)命令，每个写入一次写入每个列出的写入器，如果列出的写程序返回错误，则整个写操作将停止并返回错误，它不会在列表中继续下去
Pipe
go
func Pipe()(*PipeReader,*PipeWriter)Pipe创建一个同步的内存管道，可用于链接期望io.Reader的代码和期望io.Writer的代码。
管道上的读和写是一对一匹配的，除非需要多久读取才能使用单词写入。也就是说，每次对PipeWriter的写入都将阻塞，直到它满足从PipeReader读取的一个或多个读取，这些读取完全消耗已写入的数据。数据直接从Write复制到相应的Read，没有内部缓冲，对读的并行调用对写的并行调用也是安全的；单个调用将按顺序执行
ReadAll
go
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
go
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
go
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
go
func TeeReader(r Reader,w Writer) ReaderTeeReader返回一个Reader，该Reader向w写入从r读取的内容，通过r执行的所有r读取均与对w的相应写入匹配，没有内部缓冲，写入必须在读取完成之前完成。写入时遇到的任何错误均报告为读取错误
ioutil标准库
| 函数 | 说明 |
|---|---|
| ReadAll | 读取数据，返回读到的字节slice |
| ReadDir | 读取一个目录，返回目录入口数组[]os.FileInfo |
| ReadFile | 都一个文件，返回读到的文件内存字节slice |
| WriteFile | 根据文件路径,写入字节silice |
| TempDir | 在一个目录中创建指定前缀名的临时目录，返回新临时目录的路径 |
| TempFile | 在一个目录中创建指定前缀名的临时文件，返回os.File |
| NopCloser | 用一个无操作的Close方法包装文件并返回一个ReadCloser接口 |
bufio标准库
bufio包实现了有缓冲的io，它包装一个io.reader或io.Writer接口对象，创建另一个实现了该接口，且同时还提供了缓冲和一些文本I/O的帮助函数对象
bufio基础介绍
go
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
go
func (b *Reader) Read(p []byte)(n int,err error)Read读取数据写入p，本方法返回去写入p的字节数，本方法一次调用下层Reader接口一次Read方法，因此返回值n可能小于len,读取到达结尾，返回值n将为n而err将为io.EOF
Peek
go
func (b *Reader) Peek(n int) ([] byte,error)Peek返回缓存的一个切片，该切片引用缓存中前n个字节的数据，该操作不会将数据读出，只是引用，引用的数据在下一次读取操作之前是有效的。如果切片长度小于n，则返回一个错误信息说明原因。如果n大于缓存的总大小，则返回ErrBufferFull
ReadByte
go
func (b *Reader)ReadByte() (c byte,err error)ReadByte读取并返回一个字节，如果没有可用的数据，会返回错误
UnreadByte
go
func (b *Reader) UnreadByte() errorUnreadByte吐出最近一次读取的最后一个字节（只能吐出最后一个，多次调用会出问题）
ReadRune
go
func (b *Reader) ReadRune()(r rune,size int,err error)ReadRune读取一个utf-8编码的unicode码值，返回该码值，其编码长度和可能的错误，如果utf-8编码非法，读取位置只移动1字节，返回U+FFFD,返回值size为1而err为nil，如果没有可用的数据，会返回错误
UnreadRune
go
func (b *Reader) UnreadRune() errorUnreadRune吐出最后一次ReadRune调用读取的unicode码值，如果最近一次读取不是调用的ReadRune会返回错误
ReadSlice
go
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
go
func (b *Reader) WriteTo(w io.Writer)(n int64,err error)WriteTo方法实现了io.WriteTo接口
Writer
go
type Writer struct {
err error
buf []byte
n int
wr io.Writer
}Buffered
go
func (b *Writer) Buffered() intBuffered 返回缓冲中已使用的字节数
Available
go
func (b *Writer) Available() intAvailable 返回缓冲中还有多少字节未使用
Write
go
func (b *Writer) Write(p []byte)(nn int,err error)Write将p的内容写入缓冲，返回写入的字节数，如果返回值nn < len，还会返回一个错误说明原因
WriteString
go
func (b *Writer)WriteString(s string)(int,err)WriteString写入一个字符串，返回写入的字节数，如果返回值m < len(s),还会返回一个错误说明原因
WriteByte
go
func (b *Writer) WriteByte(c byte) errorWriteByte写入单个字节
WriteRune
go
func (b * Writer) WriteRune(r rune)(size int,err error)WriteRune写入一个unicode码值的utf-8编码，返回写入的字节数和可能的错误
Flush
go
func (b *Writer) Flush() errorFlush方法将缓冲中的数据写入下层的io.Writer接口
ReadFrom
go
func (b *Writer) ReadFrom(r io.Reader)(n int64,err error)ReadFrom实现了io.ReaderFrom接口
Text
go
func (s * Scanner)Text() stringBytes方法返回最近一次Scan调用生成的token，会申请一个字符串保存token并返回该字符串
Err
go
func (s *Scanner)Err() errorErr返回的Scanner遇到的第一个非EOF的错误
Bulitin标准库
builtin包提供了一些类型说明，变量和常量声明，还有一些便利函数，这个包不需要导入，这些变量和函数就可以直接使用
- append
- len
- new
- make
- panic
Json标准库
- Marshal
- Unmarshal
- Encode
- Decode
Sort标准库
go
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函数
go
func IsNaN(f float64) (is bool)报告f是否表示一个NaN(Not a Number )值，是数值返回一个false，不是数值则返回一个true
Ceil函数
go
func Ceil(x float64) float64返回一个不小于x的最小整数，向上取整
Floor函数
与上面类似，向下取整
Trunc函数
go
func Trunc(x float64) float64返回x整数部分，与Floor一样
Abs函数
go
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函数
求正切
随机数
go
rand.Seed(time.Now().Unix())
fmt.Println(rand.Int())runtime标准库
- runtime.Gosched 让出时间片
- runtime.Goexit 退出当前goruntine
- runtime.GOMAXPROCS 最大携程数
- runtime.NumCPU cpu的数量
- runtime.GOOS 运行的操作系统
