go 标准库包学习笔记

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

文章目录

• 1、math
• 2、net/http
• 3、fmt
• 4、io
• • 打开文件
  • 写文件
  • 读文件
  • 文件拷贝
• csv
• • 读取
• json
• • 结构体转字符串
  • 结构体带tag版本
  • json转struct
  • 组合json读取
• 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]byte
	var content []byte
	for {
		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()
}

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 []*Person
	if 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()
}

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 UserInfo
	err := 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 main

import (
	"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 UserInfo
	err := 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 CheckResultInfo
	err := 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()
}

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.C
	fmt.Println("Timer 触发")
	//换时区
	loc, _ := time.LoadLocation("Asia/Tokyo")
	nyTime := time.Now().In(loc)
	fmt.Println("泰国时间:", nyTime)
	//随机时间生成
	randomDuration := time.Duration(rand.Intn(1000)) * time.Millisecond
	randomTime := time.Now().Add(randomDuration)
	fmt.Println("随机时间", randomTime)

strconv

一些操作

	//strconv
	var i int = 10
	fmt.Println("返回字符串", strconv.Itoa(i))
	j := 12.233
	fmt.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)

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, " "))

}

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))
}

参考文章

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