fix

blog/golang/golang-standard-builtin.md

 # Golang标准库-builtin
+
+这个包不需要导入，可以直接使用
+
+这个包提供了一些类型声明、变量和常量声明，还有一些便利函数
+
+## append
+
+可以在slice后添加元素
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    s := []int{1, 2, 3}
+
+    slice := append(s, 100)
+    fmt.Printf("slice: %v\n", slice)
+    // slice: [1 2 3 100]
+
+    s2 := []int{100, 200}
+    slice2 := append(s, s2...)
+    fmt.Printf("slice2: %v\n", slice2)
+    // slice2: [1 2 3 100 200]
+
+}
+
+```
+
+## len
+
+返回数组、切片、字符串、通道的长度
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    s := []int{1, 2, 3}
+
+    fmt.Printf("len(s): %v\n", len(s))
+    // len(s): 3
+
+    s2 := "hello"
+    fmt.Printf("len(s2): %v\n", len(s2))
+    // len(s2): 5
+
+}
+
+```
+
+## print、println
+
+打印输出到控制台
+
+```go
+package main
+
+func main() {
+    print("name", " ", 23, "\n")
+    // name 23
+
+    println("name", " ", 23)
+    // name   23
+
+}
+
+```
+
+## panic
+
+抛出一个panic异常
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // defer 会被执行
+    defer fmt.Println("defer panic")
+    panic("panic")
+    fmt.Println("after panic")
+    // defer panic
+    // panic: panic
+}
+
+```
+
+## new 和 make
+
+new 和 make区别：
+
+1. make只能用来分配及初始化类型为slice，map，channel 的数据；new可以分配任意类型的数据
+2. new分配返回的是指针，即类型`*T`；make会返回引用，即`T`
+3. new分配的空间被清零，make分配后，会进行初始化
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    b := new(bool)
+    fmt.Printf("b: %T\n", b)
+    // b: *bool
+    fmt.Printf("b: %v\n", b)
+    // b: 0xc000124002
+    fmt.Printf("b: %v\n", *b)
+    // b: false
+}
+
+```
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // 完整写法
+    var p *[]int = new([]int)
+    *p = make([]int, 0, 100)
+    fmt.Printf("p: %v\n", p)
+    // p: &[]
+
+    // 习惯写法
+    v := make([]int, 0)
+    fmt.Printf("v: %v\n", v)
+    // v: []
+
+}
+
+```

blog/golang/golang-standard-bytes.md

+# Golang 标准库-bytes
+
+bytes 包提供了对字节切片进行读写操作的一系列函数
+
+## 类型转换
+
+byte 和 int 类型转换
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    var i int = 10
+    var b byte = 100
+    fmt.Printf("i: %v\n", i)
+    // i: 10
+    fmt.Printf("b: %v\n", b)
+    // b: 100
+
+    i = int(b)
+    fmt.Printf("i: %v\n", i)
+    // i: 100
+
+    b = byte(i)
+    fmt.Printf("b: %v\n", b)
+    // b: 100
+
+}
+
+```
+
+byte 和 string 类型转换
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    var s string = "Hello world"
+    b := []byte(s)
+    fmt.Printf("b: %v\n", b)
+    // b: [72 101 108 108 111 32 119 111 114 108 100]
+
+    s = string(b)
+    fmt.Printf("s: %v\n", s)
+    // s: Hello world
+}
+
+```
+
+## 常用函数
+
+Contains 包含
+
+```go
+package main
+
+import (
+    "bytes"
+    "fmt"
+)
+
+func main() {
+    b := []byte("hello world")
+
+    b1 := []byte("HELLO")
+    b2 := []byte("hello")
+
+    b3 := bytes.Contains(b, b1)
+    fmt.Printf("b3: %v\n", b3)
+    // b3: false
+
+    b4 := bytes.Contains(b, b2)
+    fmt.Printf("b4: %v\n", b4)
+    // b4: true
+}
+
+```
+
+Count 统计出现次数
+
+```go
+package main
+
+import (
+    "bytes"
+    "fmt"
+)
+
+func main() {
+    b := []byte("hello world hello world")
+
+    b1 := []byte("hello")
+
+    i := bytes.Count(b, b1)
+    fmt.Printf("i: %v\n", i)
+    // i: 2
+
+}
+
+```
+
+Repeat 重复
+
+```go
+package main
+
+import (
+    "bytes"
+    "fmt"
+)
+
+func main() {
+    b := []byte("x")
+
+    b1 := bytes.Repeat(b, 3)
+    fmt.Printf("b1: %v\n", string(b1))
+    // b1: xxx
+
+}
+
+```
+
+Replace 替换
+
+```go
+package main
+
+import (
+    "bytes"
+    "fmt"
+)
+
+func main() {
+    b := []byte("hello")
+    old := []byte("l")
+    new := []byte("x")
+
+    // 第三个参数是替换次数
+    b1 := bytes.Replace(b, old, new, 1)
+    fmt.Printf("b1: %v\n", string(b1))
+    // b1: hexlo
+
+}
+
+```
+
+Runes 转换汉字
+
+```go
+package main
+
+import (
+    "bytes"
+    "fmt"
+)
+
+func main() {
+    b := []byte("你好世界")
+    r := bytes.Runes(b)
+
+    fmt.Printf("len(b): %v\n", len(b))
+    // len(b): 12
+
+    fmt.Printf("len(r): %v\n", len(r))
+    // len(r): 4
+
+}
+
+```
+
+join 字节切片连接
+
+```go
+package main
+
+import (
+    "bytes"
+    "fmt"
+)
+
+func main() {
+    b := [][]byte{
+        []byte("你好"),
+        []byte("世界"),
+    }
+
+    s := []byte("#")
+    b2 := bytes.Join(b, s)
+
+    fmt.Printf("b2: %v\n", string(b2))
+    // b2: 你好#世界
+}
+
+```
+
+## Reader 类型
+
+Reader 实现的接口
+
+```go
+io.Reader
+io.ReaderAt
+io.WriterTo
+io.Seeker
+io.ByteScanner
+io.RuneScanner
+```
+
+示例
+
+```go
+package main
+
+import (
+    "bytes"
+    "fmt"
+)
+
+func main() {
+    data := "1234567890"
+
+    // 创建一个Reader
+    br := bytes.NewReader([]byte(data))
+
+    // 返回未读取部分的长度
+    fmt.Printf("br.Len(): %v\n", br.Len())
+    // br.Len(): 10
+
+    // 返回底层数据总长度
+    fmt.Printf("br.Size(): %v\n", br.Size())
+    // br.Size(): 10
+
+    // 每次读取两个字节
+    buf := make([]byte, 2)
+    for {
+        n, err := br.Read(buf)
+        if err != nil {
+            break
+        }
+        fmt.Printf("string(buf[:n]): %v\n", string(buf[:n]))
+    }
+
+    // 设置偏移量，定位到文件头
+    br.Seek(0, 0)
+
+    // 一个字节一个字节的读取
+    for {
+        b, err := br.ReadByte()
+        if err != nil {
+            break
+        }
+        fmt.Printf("b: %v\n", string(b))
+    }
+
+    br.Seek(0, 0)
+    off := int64(0)
+    for {
+        // 指定偏移量读取
+        n, err := br.ReadAt(buf, off)
+        if err != nil {
+            break
+        }
+
+        fmt.Println(off, string(buf[:n]))
+
+        off += int64(n)
+
+    }
+}
+
+```
+
+## Buffer类型
+
+缓冲区是具有读取和写入方法可变大小的字节缓冲区
+
+声明Buffer的4中方法
+
+```go
+// 直接定义一个Buffer变量，不用初始化，可以直接使用
+var buf bytes.Buffer
+
+// 使用New返回Buffer变量
+b := new(bytes.Buffer)
+
+// 从[]byte切片，构造一个Buffer
+b := bytes.NewBuffer(s []byte)
+
+// 从string变量，构造一个Buffer
+b := bytes.NewBufferString(s string)
+```
+
+示例
+
+```go
+package main
+
+import (
+    "bytes"
+    "fmt"
+)
+
+func main() {
+    var buf bytes.Buffer
+    fmt.Printf("buf: %v\n", buf)
+    // buf: {[] 0 0}
+
+    b := bytes.NewBuffer([]byte("hello"))
+    fmt.Printf("b: %v\n", b)
+    // b: hello
+
+    b2 := bytes.NewBufferString("hello")
+    fmt.Printf("b2: %v\n", b2)
+    // b2: hello
+}
+
+```
+
+向Buffer写入数据
+
+```go
+package main
+
+import (
+    "bytes"
+    "fmt"
+)
+
+func main() {
+    var buf bytes.Buffer
+    n, _ := buf.WriteString("hello")
+
+    fmt.Printf("n: %v\n", n)
+    // n: 5
+    fmt.Printf("buf: %v\n", string(buf.Bytes()))
+    // buf: hello
+}
+
+```
+
+从Buffer读取数据
+
+```go
+package main
+
+import (
+    "bytes"
+    "fmt"
+    "io"
+)
+
+func main() {
+    b := bytes.NewBufferString("hello world")
+
+    // 循环读取，每次读取2个字节
+    buf := make([]byte, 2)
+
+    for {
+        n, err := b.Read(buf)
+
+        // 到达文件尾部
+        if err == io.EOF {
+            break
+        }
+
+        fmt.Printf("n: %v\n", n)
+        // n: 2
+        fmt.Printf("buf: %v\n", string(buf[0:n]))
+        // buf: he
+    }
+
+}
+
+```
\ No newline at end of file

blog/golang/golang-standard-errors.md

+# Golang 标准库-errors

blog/golang/index.md

@@ -56,8 +56,10 @@
 - [Golang标准库-bufio](/blog/golang/golang-standard-bufio.md)
 - [Golang标准库-log](/blog/golang/golang-standard-log.md)
 - [Golang标准库-builtin](/blog/golang/golang-standard-builtin.md)
+- [Golang标准库-bytes](/blog/golang/golang-standard-bytes.md)
+- [Golang标准库-errors](/blog/golang/golang-standard-errors.md)
 
 https://www.bilibili.com/video/BV1ME411Y71o?p=27&spm_id_from=pageDriver&vd_source=efbb4dc944fa761b6e016ce2ca5933da
 
 
-https://www.bilibili.com/video/BV1zR4y1t7Wj?p=89&spm_id_from=pageDriver&vd_source=efbb4dc944fa761b6e016ce2ca5933da
+https://www.bilibili.com/video/BV1zR4y1t7Wj?p=93&spm_id_from=pageDriver&vd_source=efbb4dc944fa761b6e016ce2ca5933da
\ No newline at end of file