go 标准库包学习笔记

本博文包含了go的math，net/http，fmt,io,csv，time.Time,strconv,strings,sync.Pool的学习,笔记多是其实战如何用，而非简单的函数式的讲解，可谓是收藏佳作，不时翻翻。

1、math

math包其他比较复杂，常用的还是max,min，abs几个，因此写了这几个demo

func TestMath(t *testing.T) {//绝对值fmt.Println(math.Abs(-2.3))fmt.Println(math.Sqrt(8))fmt.Println(math.Round(5.2))fmt.Println(math.Floor(5.6))minInt := math.Min(2.3, 3.2)maxInt := math.Max(2.3, 3.2)fmt.Println(minInt, maxInt)}

2 net/http

func TestHttp(t *testing.T) {http.HandleFunc("/", helloHandler)fmt.Println("Starting server...")fmt.Println("http://127.0.0.1:8080")if err := http.ListenAndServe(":8080", nil); err != nil {fmt.Println("Error starting server:", err)}
}// 简单的get请求
func handleRequest(w http.ResponseWriter, r *http.Request) {switch r.Method {case "GET":fmt.Fprintf(w, "This is a GET request")case "POST":fmt.Fprintf(w, "This is a POST request")default:http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)}
}// 复杂路由
func TestHttp2(t *testing.T) {http.HandleFunc("/", handleRequest)fmt.Println("Starting server...")fmt.Println("http://127.0.0.1:8081")if err := http.ListenAndServe(":8081", nil); err != nil {fmt.Println("Error starting server:", err)}
}func userHandler(w http.ResponseWriter, r *http.Request) {vars := mux.Vars(r)userID := vars["id"]fmt.Fprintf(w, "Hello %s", userID)
}func TestHttp3(t *testing.T) {r := mux.NewRouter()r.HandleFunc("/users/{id}", userHandler).Methods("GET")fmt.Println("Starting server...:8080")fmt.Println("http://127.0.0.1:8082")if err := http.ListenAndServe(":8082", r); err != nil {fmt.Println("Error starting server:", err)}
}func logginMiddleware(next http.Handler) http.Handler {return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {start := time.Now()next.ServeHTTP(w, r)duration := time.Since(start)log.Printf("%s %s %s %v", r.Method, r.URL.Path, r.RemoteAddr, duration)})
}
func helloHandler(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, "Hello World")
}func TestHttp4(t *testing.T) {router := http.NewServeMux()router.Handle("/",logginMiddleware(http.HandlerFunc(helloHandler)),)fmt.Println("Starting server on :8083")fmt.Println("http://127.0.0.1:8083")if err := http.ListenAndServe(":8083", router); err != nil {fmt.Println("Error starting server:", err)}
}func TestHttp5(t *testing.T) {fs := http.FileServer(http.Dir("static"))http.Handle("/static/", http.StripPrefix("/static/", fs))fmt.Println("Starting server on :8080")if err := http.ListenAndServe(":8080", nil); err != nil {fmt.Println("Error starting server:", err)}
}func errorHandler(w http.ResponseWriter, r *http.Request, status int, message string) {w.WriteHeader(status)fmt.Fprintf(w, "Error %d: %s", status, message)
}func handleRequest1(w http.ResponseWriter, r *http.Request) {if r.URL.Path == "/error" {errorHandler(w, r, http.StatusInternalServerError, "Internal Server Error")return}fmt.Fprintf(w, "Hello World")
}func TestHttp6(t *testing.T) {http.HandleFunc("/", handleRequest1)fmt.Println("Starting server...")fmt.Println("http://127.0.0.1:8084")if err := http.ListenAndServe(":8084", nil); err != nil {fmt.Println("Error starting server:", err)}
}func fetchURL(url string) (string, error) {resp, err := http.Get(url)if err != nil {return "", err}defer resp.Body.Close()body, err := ioutil.ReadAll(resp.Body)if err != nil {return "", err}return string(body), nil
}func TestHttp7(t *testing.T) {url := "http://www.baidu.com"content, err := fetchURL(url)if err != nil {fmt.Println(err)return}fmt.Println(content)
}func postJSON(url string, data []byte) (string, error) {req, err := http.NewRequest("POST", url, bytes.NewBuffer(data))if err != nil {return "", err}req.Header.Set("Content-Type", "application/json")client := &http.Client{}resp, err := client.Do(req)if err != nil {return "", err}defer resp.Body.Close()body, err := ioutil.ReadAll(resp.Body)if err != nil {return "", err}return string(body), nil}func TestHttp8(t *testing.T) {url := "http://jsonplaceholder.typicode.com/posts"jsonData := []byte(`{"title": "foo", "body":"bar","userId":"1"}`)content, err := postJSON(url, jsonData)if err != nil {fmt.Println("Error:", err)return}fmt.Println(content)
}

3、fmt

func TestFmt(t *testing.T) {fmt.Println("hello world")fmt.Print("hello world\n")fmt.Printf("hello\n")str := fmt.Sprintf("%s", "hello world")fmt.Printf(str)
}

4、io

打开文件

func main() {file, err := os.Open("./a.txt")if err != nil {fmt.Println("open file failed!,err:", err)return}file.Close()
}

写文件

	file, err := os.Create("b.txt")if err != nil {fmt.Println(err)return}defer file.Close()for i := 0; i < 10; i++ {fmt.Fprintf(file, "%d", i)file.WriteString("hello\n")file.Write([]byte("cd\n"))}

读文件

	file, err := os.Open("./a.txt")if err != nil {fmt.Println("open file err :", err)return}defer file.Close()var buf [128]bytevar content []bytefor {n, err := file.Read(buf[:])if err == io.EOF {break}if err != nil {fmt.Println("read file err :", err)return}content = append(content, buf[:n]...)}fmt.Println(string(content))

文件拷贝

srcFile, err := os.Open("./a.txt")if err != nil {fmt.Println(err)return}dstFile, err := os.Create("./a2.txt")if err != nil {fmt.Println(err)return}buf := make([]byte, 1024)for {n, err := srcFile.Read(buf)if err == io.EOF {fmt.Println("读取完毕")break}if err != nil {fmt.Println(err)break}dstFile.Write(buf[:n])}dstFile2, err := os.Create("./a4.txt")if err != nil {fmt.Println(err)return}_, err = io.Copy(dstFile2, srcFile)if err != nil {fmt.Println(err)return}fmt.Println("File copied successfully")defer dstFile2.Close()

func re() {file, err := os.Open("./test.txt")if err != nil {return}defer file.Close()reader := bufio.NewReader(file)for {line, _, err := reader.ReadLine()if err == io.EOF {break}if err != nil {return}fmt.Println(string(line))}
}
func wr() {file, err := os.OpenFile("test.txt", os.O_CREATE|os.O_WRONLY, 0666)if err != nil {return}defer file.Close()writer := bufio.NewWriter(file)for i := 0; i < 10; i++ {writer.WriteString("hello \n")}writer.Flush()
}func main() {wr()
}

5.csv

读取

type Person struct {Name string `csv:"name"`Age  int    `csv:"age"`
}func read() {file, err := os.OpenFile("./csv.csv", os.O_RDWR|os.O_CREATE, 0666)if err != nil {fmt.Println("打开文件失败", err)return}var person []*Personif err := gocsv.UnmarshalFile(file, &person); err != nil {fmt.Println(err)return}for _, v := range person {fmt.Printf("name: %s, age: %d\n", v.Name, v.Age)}defer file.Close()
}
func main() {read()
}

写入

type Person struct {Name string `csv:"name"`Age  int    `csv:"age"`
}func write() {file, err := os.OpenFile("./csv.csv", os.O_RDWR|os.O_CREATE, 0666)if err != nil {fmt.Println("打开文件失败", err)return}defer file.Close()people := []*Person{{Name: "Alice", Age: 21},{Name: "Bob", Age: 22},}if err := gocsv.Marshal(&people, file); err != nil {fmt.Println("写入文件失败", err)return}fmt.Println("写入成功")
}
func main() {write()
}

6.json

结构体转字符串

func struct_to_jsonstring() {user := UserInfo{Id: 1, Age: 18}b, err := json.Marshal(user)if err != nil {fmt.Println(err)return}fmt.Println(string(b))
}func main() {struct_to_jsonstring()
}

结构体带tag版本

type UserInfo struct {Id  int `json:"id"`Age int `json:"age"`
}func struct_to_jsonstring() {user := UserInfo{Id: 1, Age: 18}b, err := json.Marshal(user)if err != nil {fmt.Println(err)return}fmt.Println(string(b))
}func main() {struct_to_jsonstring()
}

json转struct

结构体还是上面的结构体，代码取相反

func jsonstring_to_struct() {s := `{"Id":110,"Age":18}`var user UserInfoerr := json.Unmarshal([]byte(s), &user)if err != nil {fmt.Println(err)return}fmt.Println(user)fmt.Println(user.Id, user.Age)
}
func main() {jsonstring_to_struct()
}

组合json读取

相关的json文件

{"title": "信号准入检查结果","time": "202230712123456789","author":{"name":"張三","age":18},"body":[{"group_item": "定位类","detail_list": [{"check_item": "信号中的所有项","check_list": [{"priority": "P0", "type": "完整性检查", "check_desc": "具体描述1。", "result": "通过", "conclusion_detail":"ok", "detail_reason": "/tmp/sianal/summary1.txt"},{"priority": "P0", "type": "连续性检查", "check_desc": "具体描述2。", "result": "通过", "conclusion_detail":"ok", "detail_reason": "/tmp/sianal/summary2.txt"}]},{"check_item": "经纬度","check_list": [{"priority": "P0", "type": "异常检测（跳变）", "check_desc": "具体描述3。", "result": "通过", "conclusion_detail":"ok", "detail_reason": "/tmp/sianal/summary3.txt"},{"priority": "P0", "type": "异常检测（静止）", "check_desc": "具体描述4。", "result": "通过", "conclusion_detail":"ok", "detail_reason": "/tmp/sianal/summary4.txt"}]}]},{"group_item": "感知类","detail_list":[{"check_item": "此类中所有必须项","check_list": [{"priority": "P0", "type": "完整性检查", "check_desc": "具体描述5。", "result": "通过", "conclusion_detail":"ok", "detail_reason": "/tmp/sianal/summary5.txt"},{"priority": "P0", "type": "连续性检查", "check_desc": "具体描述6。", "result": "通过", "conclusion_detail":"ok", "detail_reason": "/tmp/sianal/summary8.txt"}]},{"check_item": "障碍物坐标信号『position』","check_list": [{"priority": "P0", "type": "跳变异常", "check_desc": "具体描述7。", "result": "通过", "conclusion_detail":"ok", "detail_reason": "/tmp/sianal/summary7.txt"},{"priority": "P0", "type": "超出路面异常", "check_desc": "具体描述8。", "result": "通过", "conclusion_detail":"ok", "detail_reason": "/tmp/sianal/summary8.txt"}]}]}]
}

package mainimport ("encoding/json""fmt""io/ioutil"
)type UserInfo struct {Id  int `json:"id"`Age int `json:"age"`
}func struct_to_jsonstring() {user := UserInfo{Id: 1, Age: 18}b, err := json.Marshal(user)if err != nil {fmt.Println(err)return}fmt.Println(string(b))
}func jsonstring_to_struct() {s := `{"Id":110,"Age":18}`var user UserInfoerr := json.Unmarshal([]byte(s), &user)if err != nil {fmt.Println(err)return}fmt.Println(user)fmt.Println(user.Id, user.Age)
}type CheckResultInfo struct {Title  string     `json:"title"`Time   string     `json:"time"`Author AuthorInfo `json:"author"`Body   []BodyInfo `json:"body"`
}type AuthorInfo struct {Name string `json:"name"`Age  int    `json:"age"`
}type BodyInfo struct {GroupItem  string       `json:"group_item"`DetailList []DetailInfo `json:"detail_list"`
}type DetailInfo struct {CheckItem string      `json:"check_item"`CheckList []CheckInfo `json:"check_list"`
}type CheckInfo struct {Priority         string `json:"priority"`Type             string `json:"type"`CheckDesc        string `json:"check_desc"`Result           string `json:"result"`ConclusionDetail string `json:"conclusion_detail"`DetailReason     string `json:"detail_reason"`
}func common_deal_nestjson() {path := "./test.json"f, _ := ioutil.ReadFile(path)var result CheckResultInfoerr := json.Unmarshal(f, &result)if err != nil {fmt.Println(err)return}for _, iv := range result.Body {fmt.Println(iv.GroupItem)for _, nv := range iv.DetailList {fmt.Println(nv.CheckItem)for _, cv := range nv.CheckList {fmt.Println(cv.Priority, cv.Type, cv.Result, cv.ConclusionDetail, cv.DetailReason)}}}}func main() {common_deal_nestjson()
}

7.time.Time

按照格式输出当前文件

func main() {currentTime := time.Now()fmt.Println(currentTime.Format("2006-01-02 15:04:05"))
}

输出时分秒年月日

func main() {fmt.Println("年：", time.Now().Year())fmt.Println("月：", time.Now().Month())fmt.Println("日：", time.Now().Day())fmt.Println("小时：", time.Now().Hour())fmt.Println("分钟：", time.Now().Minute())fmt.Println("秒：", time.Now().Second())fmt.Println("纳秒：", time.Now().Nanosecond())fmt.Println("星期几：", time.Now().Weekday())
}

时间的格式化以及其他的时间使用

fmt.Println("Unix 时间戳(秒):", time.Now().Unix())fmt.Println("Unix时间戳(纳秒)", time.Now().UnixNano())fmt.Println("年-月-日", time.Now().Format("2006-01-02"))fmt.Println("时:分:秒", time.Now().Format("15:04:05"))fmt.Println("时:分:秒 PM", time.Now().Format("15:04:05 PM"))//时间解析timeStr := "2025-03-08 15:04:05"parsedTime, err := time.Parse("2006-01-02 15:04:05", timeStr)if err != nil {fmt.Println("解析时间出错", err)} else {fmt.Println("解析后的时间", parsedTime)}//模拟耗时time.Sleep(1 * time.Second)//模拟用时startTime := time.Now()time.Sleep(1 * time.Second)elapsedTime := time.Since(startTime)fmt.Println("操作耗时:", elapsedTime)//时间加减nextWeek := time.Now().Add(7 * 24 * time.Hour)fmt.Println("一周后的时间：", nextWeek)yesterday := time.Now().Add(-24 * time.Hour)fmt.Println("一周前的时间", yesterday)//时间差计算startTime = time.Date(2025, 3, 12, 12, 12, 0, 0, time.Local)duration := time.Now().Sub(startTime)fmt.Println("时间差:", duration)//延时执行fmt.Println("延时3秒执行")time.Sleep(3 * time.Second)fmt.Println("延时结束")//延时触发select {case <-time.After(1 * time.Second):fmt.Println("1秒后执行")}//周期性触发ticker := time.NewTicker(1 * time.Second)go func() {for t := range ticker.C {fmt.Println("每秒触发1次，当前时间:", t)}}()time.Sleep(1 * time.Second)ticker.Stop()fmt.Println("Ticker已停止")//一次性定时器timer := time.NewTimer(3 * time.Second)fmt.Println("等待3秒")<-timer.Cfmt.Println("Timer 触发")//换时区loc, _ := time.LoadLocation("Asia/Tokyo")nyTime := time.Now().In(loc)fmt.Println("泰国时间:", nyTime)//随机时间生成randomDuration := time.Duration(rand.Intn(1000)) * time.MillisecondrandomTime := time.Now().Add(randomDuration)fmt.Println("随机时间", randomTime)

8.strconv

一些操作

	//strconvvar i int = 10fmt.Println("返回字符串", strconv.Itoa(i))j := 12.233fmt.Println("将浮点数转换", strconv.FormatFloat(j, 'f', 2, 64))strValue := "245"atoi, err := strconv.Atoi(strValue)fmt.Println("字符串转int", atoi, err)strFloat := "12.333"float, err := strconv.ParseFloat(strFloat, 64)fmt.Println("字符串转float", float, err)

9.strings

func main() {var str string = "this is an example"fmt.Println(strings.HasPrefix(str, "th"))fmt.Println("字符串包含:", strings.Contains(str, "is"))fmt.Println("子串索引", strings.Index(str, "th"))var strChines = []rune("中国")fmt.Println("子串包含", strings.ContainsRune(string(strChines), '中'))fmt.Println("子串包含", strings.IndexRune(string(strChines), '中'))fmt.Println("子串从后往前找", strings.LastIndex(str, "example"))fmt.Println("子串替换", strings.Replace(str, "is", "as", 1))fmt.Println("统计:", strings.Count(str, "s"))fmt.Println("字符串重复", strings.Repeat(str, 2))fmt.Println("字符串转大写", strings.ToLower(str))fmt.Println("字符串转小写", strings.ToUpper(str))fmt.Println("修剪字符串", strings.TrimSpace(str))fmt.Println("分割字符串", strings.Split(str, " "))strSlice := []string{"This", "is", "a", "apple"}fmt.Println("拼接字符串", strings.Join(strSlice, " "))}

10.sync.Pool

func main() {var bufferPool = sync.Pool{New: func() interface{} {return make([]byte, 1024)},}buffer := bufferPool.Get().([]byte)fmt.Println("缓冲区内容：", len(buffer))copy(buffer, "hello,sync.Pool")fmt.Println("缓冲区内容", string(buffer[:18]))//放入bufferPool.Put(buffer)//获取anotherBuffer := bufferPool.Get().([]byte)fmt.Println(len(anotherBuffer))
}

11.ioutil 包

Go 1.16 开始，ioutil 中的函数被移到了其他包中。例如：

• ioutil.ReadFile → os.ReadFile
• ioutil.WriteFile → os.WriteFile
• ioutil.ReadAll → io.ReadAll
• ioutil.NopCloser → io.NopCloser

因此ioutil包不进行学习其操作了，将放在

12.os 包

创建文件并写入

file, err := os.Create("example.txt")if err != nil {fmt.Println("Error Creating file:", err)return}defer file.Close()_, err = file.WriteString("Hello,Test!")if err != nil {fmt.Println("Error Writing to file.", err)return}fmt.Println("文件写入完毕")

读取文件内容

package mainimport ("fmt""os"
)func main() {file, err := os.Open("example.txt")if err != nil {fmt.Println("Error opening file:", err)return}defer file.Close()stat, err := file.Stat()if err != nil {fmt.Println("Error getting file stats:", err)return}data := make([]byte, stat.Size())_, err = file.Read(data)if err != nil {fmt.Println("Error reading file:", err)return}fmt.Println("file content:", string(data))}

创建目录

func main() {err := os.Mkdir("tmpDir", 0755)if err != nil {fmt.Println("Error creating directory:", err)return}fmt.Println("Directory created successfully")
}

检查文件或目录是否存在

func main() {_, err := os.Stat("example.txt")if os.IsNotExist(err) {fmt.Println("file does not exist")} else if err != nil {fmt.Println("Error checking file:", err)} else {fmt.Println("File exists.")}_, err = os.Stat("tmpDir")if os.IsNotExist(err) {fmt.Println("dir does not exist")} else if err != nil {fmt.Println("Error checking file:", err)} else {fmt.Println("Directory exists.")}}

重命名文件

func main() {err := os.Rename("example.txt", "test.txt")if err != nil { fmt.Println("Error renaming file", err)return}fmt.Println("File named successfully")
}

删除文件或目录

func main() {err := os.Remove("test.txt")//目录名就可以删除目录了if err != nil {fmt.Println("Error remove file", err)return}fmt.Println("File remove successfully")
}

获取当前路径

func main() {dir, err := os.Getwd()if err != nil {fmt.Println("Error getting current directory", err)return}fmt.Println("Current directory", dir)
}

获取系统环境变量

func main() {value := os.Getenv("JAVA_HOME")if value == "" {fmt.Println("$JAVA_HOME not set")} else {fmt.Println("JAVA_HOME environment variable:", value)}
}

os.ReadFile

package mainimport ("fmt""os"
)func main() {data, err := os.ReadFile("hello.txt")if err != nil {fmt.Println("error:", err)return}fmt.Println(string(data))}

os.WriteFile

将内容写到hello.txt

package mainimport ("fmt""os"
)func main() {content := []byte("hello,this is the content,written using os.WriteFile")err := os.WriteFile("hello.txt", content, 0644)if err != nil {fmt.Println("Error writting to file:", err)return}fmt.Println("Content written to file successfully")
}

13.flag 包

多用于解析命令行所使用

命令行解析多个参数

package mainimport ("flag""fmt"
)func main() {name := flag.String("name", "gopher", "your name")age := flag.Int("age", 18, "your age")isStudent := flag.Bool("student", false, "Are you a student?")flag.Parse()fmt.Printf("Name: %s, Age: %d,Student:%t\n", *name, *age, *isStudent)
}

命令行解析位置参数

package mainimport ("flag""fmt"
)func main() {name := flag.String("name", "gopher", "your name")flag.Parse()fmt.Printf("Hello %s!\n", *name)args := flag.Args()if len(args) > 0 {fmt.Println("Additional arguments:")for _, arg := range args {fmt.Println(arg)}} else {fmt.Println("No additional arguments.")}
}

14.sort包

sort包主要用来排序使用

对整数进行排序

package mainimport ("fmt""sort"
)func main() {numbers := []int{5, 3, 8, 1, 7}//使用sort.Ints排序sort.Ints(numbers)fmt.Println(numbers)
}

字符串切片排序

package mainimport ("fmt""sort"
)func main() {strings := []string{"banana", "apple", "cherry", "mango"}sort.Strings(strings)fmt.Println("Sorted strings", strings)
}

自定义排序

package mainimport ("fmt""sort"
)type Person struct {Name stringAge  int
}type ByAge []Personfunc (a ByAge) Len() int           { return len(a) }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }func main() {people := []Person{{"John", 30},{"Alice", 25},{"Bob", 25},}sort.Sort(ByAge(people))fmt.Println(people)
}

15.reflect 包

获取类型和反射值

package mainimport ("fmt""reflect"
)func main() {var x int = 42t := reflect.TypeOf(x)v := reflect.ValueOf(x)//打印类型和反射值fmt.Println("Type:", t)fmt.Println("Value:", v)
}

修改值

type Person struct {Name stringAge  int
}func main() {p := Person{Name: "Bob", Age: 18}v := reflect.ValueOf(&p).Elem()v.FieldByName("Name").SetString("Alice")v.FieldByName("Age").SetInt(14)fmt.Println("Undated Person:", p)
}

判断类型和动态调用方法

type Greeter struct {Message string
}func (g Greeter) Greet(name string) {fmt.Println(g.Message)
}func main() {g := Greeter{"Hello World"}v := reflect.ValueOf(g)method := v.MethodByName("Greet")if method.IsValid() {args := []reflect.Value{reflect.ValueOf("Hello World")}method.Call(args)} else {fmt.Println("Method not found")}
}

遍历结构体字段

type Person struct {Name stringAge  int
}func main() {p := Person{Name: "John", Age: 30}v := reflect.ValueOf(p)for i := 0; i < v.NumField(); i++ {field := v.Field(i)fieldName := v.Type().Field(i).Namefmt.Println(fieldName, field, field.Interface())}
}

使用反射创建实例

package mainimport ("fmt""reflect"
)func main() {t := reflect.TypeOf(0)v := reflect.New(t).Elem()fmt.Println("New Value:", v)fmt.Println("Type of new Value", v.Type())
}

获取tag标签

package mainimport ("fmt""reflect"
)type Person struct {Name string `json:"name"`Age  int    `json:"age"`
}func main() {t := reflect.TypeOf(Person{})for i := 0; i < t.NumField(); i++ {field := t.Field(i)tag := field.Tag.Get("json")fmt.Printf("%s: %s\n", tag, field.Name)}
}

16.context包

创建和使用context.Backgroud()

package mainimport ("context""fmt""time"
)func main() {ctx := context.Background()doSomething(ctx)
}func doSomething(ctx context.Context) {select {case <-time.After(1 * time.Second):fmt.Println("Operation Completed")case <-ctx.Done():fmt.Println("Context canceled", ctx.Err())}
}

取消任务context.WithCancel()

package mainimport ("context""fmt""time"
)func main() {ctx, cancel := context.WithCancel(context.Background())go doWork(ctx)time.Sleep(5 * time.Second)cancel()time.Sleep(1 * time.Second)
}func doWork(ctx context.Context) {for {select {case <-time.After(1 * time.Second):fmt.Println("working...")case <-ctx.Done():fmt.Println("work canceled:", ctx.Err())return}}
}

使用context.WithTimeout设置超时

package mainimport ("context""fmt""time"
)func main() {ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)defer cancel()err := doTask(ctx)if err != nil {fmt.Println("Error:", err)}
}func doTask(ctx context.Context) (err error) {select {case <-time.After(3 * time.Second):fmt.Println("Task completed")return nilcase <-ctx.Done():return fmt.Errorf("timed out:%v", ctx.Err())}
}

使用context.WithValue传递数据

package mainimport ("context""fmt"
)type key stringconst requestIDKey key = "requestID"func main() {ctx := context.WithValue(context.Background(), requestIDKey, "12345")processRequest(ctx)
}func processRequest(ctx context.Context) {requestID := ctx.Value(requestIDKey).(string)fmt.Println("Processing request with ID:", requestID)
}

使用多个context配合工作

package mainimport ("context""fmt""time"
)func main() {ctx, cancel := context.WithCancel(context.Background())ctx, timeoutCancel := context.WithTimeout(ctx, 3*time.Second)defer timeoutCancel()go doWork(ctx)time.Sleep(time.Second * 2)cancel()time.Sleep(time.Second * 1)
}func doWork(ctx context.Context) {select {case <-time.After(time.Second * 5):fmt.Println("time out")case <-ctx.Done():fmt.Println("Task cancelled or time out:", ctx.Err())}
}

17.log包

设置日期与时间戳

func main() {log.SetPrefix("INFO: ")log.SetFlags(log.Ldate | log.Ltime)log.Println("Hello World")
}

日志记录到文件

package mainimport ("log""os"
)func main() {file, err := os.OpenFile("example.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)if err != nil {log.Fatal(err)}defer file.Close()log.SetOutput(file)log.Println("This log is written to a file.")
}

自定义输出错误日志

package mainimport ("log""os"
)func main() {customLogger := log.New(os.Stderr, "CUSTOM LOG", log.Ldate|log.Ltime|log.Lshortfile)file, err := os.Open("abc.txt")if err != nil {customLogger.Fatal(err)}defer file.Close()customLogger.Println("File opened successfully")
}

日志记录到标准错误流

log.SetOutput(os.Stderr)

18.bufio包

使用bufio.Reader进行读取

使用ReadLine也可以

package mainimport ("bufio""fmt""os"
)func main() {file, err := os.Open("hello.txt")if err != nil {fmt.Println("Error opening file:", err)return}defer file.Close()reader := bufio.NewReader(file)for {line, err := reader.ReadString('\n')//也可使用ReadLineif err != nil {break}fmt.Print(line)}
}

使用bufio.Writer进行写入

package mainimport ("bufio""fmt""os"
)func main() {file, err := os.Create("hello.txt")if err != nil {fmt.Println("Error creating file:", err)return}defer file.Close()//使用bufio.NewWriter创建一个带缓冲的写入器writer := bufio.NewWriter(file)writer.WriteString("Hello,this is a buffered write.\n")writer.WriteString("This is the second line.\n")writer.Flush()}

bufio.scanner逐行扫描输入

package mainimport ("bufio""fmt""os"
)func main() {scanner := bufio.NewScanner(os.Stdin)//提示用户输入fmt.Println("Please enter text (Ctrl+D):")for scanner.Scan() {line := scanner.Text()fmt.Println("You entered:", line)}if err := scanner.Err(); err != nil {fmt.Println("Error reading input:", err)}
}

19.regexp包

匹配包含字符串

func main() {re := regexp.MustCompile(`\d+`)str := "hello 123 world"if re.MatchString(str) {fmt.Println("compatible success")} else {fmt.Println("compatible success")}}

提取数字串

package mainimport ("fmt""regexp"
)func main() {re := regexp.MustCompile(`\d{3}-\d{3}-\d{3}`)str := "我的电话号码是 110-120-119"watch := re.FindString(str)fmt.Println("匹配到的电话号码:", watch)}

替换数字

func main() {re := regexp.MustCompile(`\d+`)str := "今年是2025年,明年是2026年"result := re.ReplaceAllString(str, "数字")fmt.Println(result)
}

查找匹配所有

func main() {re := regexp.MustCompile(`\w+`)str := "go is the best language"words := re.FindAllString(str, -1)fmt.Println("查找到所有单词", words)
}

正则分组

package mainimport ("fmt""regexp"
)func main() {re := regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)str := "今天是 2025-03-10"match := re.FindStringSubmatch(str)if match != nil {fmt.Println("完整匹配:", match[0])fmt.Println("年份:", match[1])fmt.Println("月份:", match[2])fmt.Println("日期:", match[3])}
}

20.net

string类型的ip转化为ip对象

func main() {name := "192.168.1.97"ip := net.ParseIP(name)fmt.Fprintf(os.Stdout, "IP:%s %s\n", ip, ip.String())defaultMask := ip.DefaultMask()fmt.Fprintf(os.Stdout, "DefaultMask: %s %s\n", defaultMask)_, bits := defaultMask.Size()fmt.Fprintf(os.Stdout, "%d\n", bits)
}

根据ip和掩码获得网络

func main() {name := "192.168.1.97"ip := net.ParseIP(name)mask := ip.DefaultMask()network := ip.Mask(mask)fmt.Println(network)fmt.Println(network.String())
}

dns解析

func main() {domain := "www.baidu.com"ipAddr, _ := net.ResolveIPAddr("ip", domain)fmt.Println(ipAddr)ns, _ := net.LookupNS(domain)fmt.Println(ns)
}

查看tcp所使用的端口

func main() {port, err := net.LookupPort("tcp", "telnet")if err != nil {fmt.Println(err)return}fmt.Printf("Server listening on port %d\n", port)
}

udp客户端与服务端

func main() {pUDPAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:7070")if err != nil {fmt.Fprintf(os.Stderr, "Error ResolveUDPAddr: %s", err.Error())return}pUDPConn, err := net.DialUDP("udp", nil, pUDPAddr)if err != nil {fmt.Fprintf(os.Stderr, "Error DialUDP: %s", err.Error())return}n, err := pUDPConn.Write([]byte("你好啊！！！"))if err != nil {fmt.Fprintf(os.Stderr, "Error WriteToUDP: %s", err.Error())return}fmt.Fprintf(os.Stdout, "writed: %d ", n)buf := make([]byte, 1024)n, _, err = pUDPConn.ReadFromUDP(buf)if err != nil {fmt.Fprintf(os.Stderr, "Error ReadFromUDP: %s", err.Error())return}fmt.Fprintf(os.Stdout, " readed: %d  %s", n, string(buf[:n]))
}

服务端

func main() {pUDPAddr, err := net.ResolveUDPAddr("udp", ":7070")if err != nil {fmt.Fprintf(os.Stderr, "Error: %s", err.Error())return}pUDPConn, err := net.ListenUDP("udp", pUDPAddr)if err != nil {fmt.Fprintf(os.Stderr, "Error: %s", err.Error())return}defer pUDPConn.Close()for {buf := make([]byte, 256)n, pUDPAddr, err := pUDPConn.ReadFromUDP(buf)if err != nil {fmt.Fprintf(os.Stderr, "Error: %s", err.Error())return}fmt.Fprintf(os.Stdout, " readed: %d", n)n, err = pUDPConn.WriteToUDP(buf, pUDPAddr)if err != nil {fmt.Fprintf(os.Stderr, "Error: %s", err.Error())return}fmt.Fprintf(os.Stdout, " writed: %d", n)}
}

tcp客户端与服务端

客户端

func main() {// 连接到指定的地址和端口conn, err := net.Dial("tcp", "localhost:8080")if err != nil {fmt.Println("Error connecting:", err)os.Exit(1)}defer conn.Close()// 发送数据_, err = conn.Write([]byte("Hello, server"))if err != nil {fmt.Println("Error sending data:", err)os.Exit(1)}// 接收响应buffer := make([]byte, 1024)n, err := conn.Read(buffer)if err != nil {fmt.Println("Error reading data:", err)os.Exit(1)}fmt.Println("Received:", string(buffer[:n]))
}

服务端

package mainimport ("fmt""net""os"
)func handleConnection(conn net.Conn) {defer conn.Close()buffer := make([]byte, 1024)// 读取客户端发送的数据n, err := conn.Read(buffer)if err != nil {fmt.Println("Error reading:", err)return}fmt.Println("Received:", string(buffer[:n]))// 向客户端发送响应_, err = conn.Write([]byte("Hello from server"))if err != nil {fmt.Println("Error sending response:", err)return}
}func main() {// 监听端口 8080listener, err := net.Listen("tcp", ":8080")if err != nil {fmt.Println("Error listening:", err)os.Exit(1)}defer listener.Close()fmt.Println("Server listening on port 8080...")// 接受客户端连接for {conn, err := listener.Accept()if err != nil {fmt.Println("Error accepting connection:", err)continue}go handleConnection(conn)}
}

21.error

创建个错误

package mainimport ("errors""fmt"
)func doSomething() error {return errors.New("this is an error")
}
func main() {err := doSomething()if err != nil {fmt.Println(err)}
}

包装错误

func process(value int) error {if value < 0 {return fmt.Errorf("Error:%w", errors.New("value is negative"))}return nil
}func main() {err := process(-1)if err != nil {fmt.Println(err)}
}

解包装error

package mainimport ("errors""fmt"
)func main() {err := fmt.Errorf("Error:%w", errors.New("File not found"))if err != nil {fmt.Println(err)}unwrappedErr := errors.Unwrap(err)fmt.Println(unwrappedErr)
}

Is验证错误

package mainimport ("errors""fmt"
)var ErrNotFound = errors.New("not found")func findItem(item int) error {if item != 1 {return ErrNotFound}return nil
}func main() {err := findItem(12)if errors.Is(err, ErrNotFound) {fmt.Println("Item not found")} else {fmt.Println("Item found")}
}

提取特定错误

package mainimport ("errors""fmt"
)type MyError struct {Message string
}func (e *MyError) Error() string {return e.Message
}func causeError() error {return &MyError{"This is an error"}
}func main() {err := causeError()var myErr *MyErrorif errors.As(err, &myErr) {fmt.Println(myErr.Message)} else {fmt.Println(err)}
}

22.runtime

获取goroutine的数量

package mainimport ("fmt""runtime"
)func main() {//控制goroutine数量fmt.Println("Goroutines running:", runtime.NumGoroutine())
}

控制GC垃圾回收

package mainimport ("fmt""os""runtime"
)func main() {var m runtime.MemStatsruntime.ReadMemStats(&m)fmt.Println("Before GC-Alloc:", m.Alloc)runtime.GC()runtime.ReadMemStats(&m)fmt.Fprintf(os.Stdout, "After GC-Alloc:", m.Alloc)
}

获取当前cpu数量

package mainimport ("fmt""runtime"
)func main() {fmt.Printf("%d", runtime.NumCPU())
}

设置CPU使用的核心数

func main() {//设置程序最多使用的CPU核心数runtime.GOMAXPROCS(2)fmt.Println("max CPUs:", runtime.GOMAXPROCS(0))
}

获取内存使用情况

func main() {//设置程序最多使用的CPU核心数var m runtime.MemStatsruntime.ReadMemStats(&m)fmt.Printf("%v,Alloc = %v KiB \n", m.Alloc, m.Alloc/1024)
}

调用堆栈信息打印输出

func main() {// 获取当前 Goroutine 的堆栈信息buf := make([]byte, 1024)n := runtime.Stack(buf, false)fmt.Printf("Run:%s\n", buf[:n])
}

参考文章

文章1
文章2:io
文章三：json
文章4：time
文章四