技术学习笔记

Appearance

常用标准库 ​

Go语言提供了丰富的标准库，本节介绍最常用的几个。

fmt包 - 格式化I/O ​

基本输出 ​

go
package main

import "fmt"

func main() {
    // 基本输出
    fmt.Print("Hello ")
    fmt.Println("World!")
    fmt.Printf("数字: %d, 字符串: %s\n", 42, "Go")
    
    // 格式化占位符
    name := "张三"
    age := 25
    score := 95.5
    
    fmt.Printf("姓名: %s, 年龄: %d, 分数: %.1f\n", name, age, score)
    fmt.Printf("变量类型: %T, 变量地址: %p\n", name, &name)
}

常用占位符 ​

占位符说明示例
%v默认格式fmt.Printf("%v", person)
%+v添加字段名fmt.Printf("%+v", person)
%#vGo语法格式fmt.Printf("%#v", person)
%T类型fmt.Printf("%T", x)
%d整数fmt.Printf("%d", 42)
%b二进制fmt.Printf("%b", 42)
%o八进制fmt.Printf("%o", 42)
%x十六进制fmt.Printf("%x", 42)
%f浮点数fmt.Printf("%f", 3.14)
%.2f保留2位小数fmt.Printf("%.2f", 3.14159)
%s字符串fmt.Printf("%s", "hello")
%q带引号字符串fmt.Printf("%q", "hello")
%c字符fmt.Printf("%c", 'A')
%t布尔值fmt.Printf("%t", true)
%p指针fmt.Printf("%p", &x)

输入 ​

go
func main() {
    var name string
    var age int
    
    fmt.Print("请输入姓名: ")
    fmt.Scanln(&name)
    
    fmt.Print("请输入年龄: ")
    fmt.Scanln(&age)
    
    fmt.Printf("姓名: %s, 年龄: %d\n", name, age)
}

Sprintf ​

go
func main() {
    // 格式化字符串（不输出）
    s := fmt.Sprintf("姓名: %s, 年龄: %d", "张三", 25)
    fmt.Println(s)
    
    // 格式化到writer
    fmt.Fprintf(os.Stdout, "写入标准输出: %s\n", "hello")
}

strings包 - 字符串操作 ​

go
package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Hello, Go Language!"
    
    // 字符串转换
    fmt.Println(strings.ToUpper(str))  // HELLO, GO LANGUAGE!
    fmt.Println(strings.ToLower(str))  // hello, go language!
    fmt.Println(strings.Title("hello world"))  // Hello World
    
    // 字符串查找
    fmt.Println(strings.Contains(str, "Go"))     // true
    fmt.Println(strings.ContainsAny(str, "abc")) // true
    fmt.Println(strings.HasPrefix(str, "Hello")) // true
    fmt.Println(strings.HasSuffix(str, "!"))     // true
    fmt.Println(strings.Index(str, "Go"))        // 7
    fmt.Println(strings.LastIndex(str, "a"))     // 13
    fmt.Println(strings.Count(str, "a"))         // 2
    
    // 字符串分割和连接
    words := strings.Split(str, " ")
    fmt.Println(words)  // [Hello, Go Language!]
    
    joined := strings.Join(words, "-")
    fmt.Println(joined)  // Hello,-Go-Language!
    
    // 字符串替换
    newStr := strings.ReplaceAll(str, "Go", "Golang")
    fmt.Println(newStr)  // Hello, Golang Language!
    
    // 字符串修剪
    fmt.Println(strings.TrimSpace("  hello  "))      // "hello"
    fmt.Println(strings.Trim("xxhelloxx", "x"))      // "hello"
    fmt.Println(strings.TrimLeft("xxhelloxx", "x"))  // "helloxx"
    fmt.Println(strings.TrimRight("xxhelloxx", "x")) // "xxhello"
    
    // 字符串重复
    fmt.Println(strings.Repeat("Go", 3))  // GoGoGo
    
    // 字符串分割成字段
    fmt.Println(strings.Fields("  hello   world  "))  // [hello world]
    
    // Builder 高效构建字符串
    var builder strings.Builder
    for i := 0; i < 10; i++ {
        builder.WriteString(fmt.Sprintf("%d ", i))
    }
    fmt.Println(builder.String())
}

strconv包 - 类型转换 ​

go
package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 整数转字符串
    s := strconv.Itoa(123)
    fmt.Println(s)  // "123"
    
    // 字符串转整数
    n, err := strconv.Atoi("123")
    if err == nil {
        fmt.Println(n)  // 123
    }
    
    // 字符串转其他类型
    f, _ := strconv.ParseFloat("3.14", 64)
    fmt.Println(f)  // 3.14
    
    b, _ := strconv.ParseBool("true")
    fmt.Println(b)  // true
    
    i, _ := strconv.ParseInt("FF", 16, 64)
    fmt.Println(i)  // 255
    
    // 其他类型转字符串
    fmt.Println(strconv.FormatBool(true))      // "true"
    fmt.Println(strconv.FormatInt(255, 16))    // "ff"
    fmt.Println(strconv.FormatFloat(3.14, 'f', 2, 64))  // "3.14"
    
    // 引号字符串
    fmt.Println(strconv.Quote("hello"))  // "\"hello\""
}

time包 - 时间处理 ​

go
package main

import (
    "fmt"
    "time"
)

func main() {
    // 获取当前时间
    now := time.Now()
    fmt.Println("当前时间:", now)
    
    // 格式化时间（注意：Go使用特定日期作为格式化模板）
    fmt.Println("格式化时间:", now.Format("2006-01-02 15:04:05"))
    fmt.Println("日期:", now.Format("2006-01-02"))
    fmt.Println("时间:", now.Format("15:04:05"))
    
    // 时间戳
    fmt.Println("Unix时间戳:", now.Unix())
    fmt.Println("毫秒时间戳:", now.UnixMilli())
    fmt.Println("纳秒时间戳:", now.UnixNano())
    
    // 时间组件
    fmt.Println("年:", now.Year())
    fmt.Println("月:", now.Month())
    fmt.Println("日:", now.Day())
    fmt.Println("时:", now.Hour())
    fmt.Println("分:", now.Minute())
    fmt.Println("秒:", now.Second())
    fmt.Println("星期:", now.Weekday())
    
    // 时间计算
    tomorrow := now.AddDate(0, 0, 1)
    fmt.Println("明天:", tomorrow.Format("2006-01-02"))
    
    later := now.Add(2 * time.Hour)
    fmt.Println("2小时后:", later.Format("15:04:05"))
    
    // 时间差
    diff := tomorrow.Sub(now)
    fmt.Println("时间差:", diff.Hours(), "小时")
    
    // 解析时间字符串
    parsedTime, err := time.Parse("2006-01-02", "2023-12-25")
    if err == nil {
        fmt.Println("解析的时间:", parsedTime)
    }
    
    // 解析带时区的时间
    loc, _ := time.LoadLocation("Asia/Shanghai")
    parsedWithLoc, _ := time.ParseInLocation("2006-01-02 15:04:05", "2023-12-25 10:00:00", loc)
    fmt.Println("上海时间:", parsedWithLoc)
    
    // 睡眠
    fmt.Println("开始睡眠...")
    time.Sleep(1 * time.Second)
    fmt.Println("睡眠结束")
    
    // 定时器
    timer := time.NewTimer(2 * time.Second)
    <-timer.C
    fmt.Println("定时器触发")
    
    // 打断器
    ticker := time.NewTicker(500 * time.Millisecond)
    go func() {
        for t := range ticker.C {
            fmt.Println("Tick at", t.Format("15:04:05.000"))
        }
    }()
    time.Sleep(2 * time.Second)
    ticker.Stop()
}

io包 - 输入输出 ​

go
package main

import (
    "fmt"
    "io"
    "os"
    "strings"
)

func main() {
    // 从Reader读取
    reader := strings.NewReader("Hello, Go!")
    data, _ := io.ReadAll(reader)
    fmt.Println(string(data))
    
    // 复制数据
    src := strings.NewReader("源数据")
    dst := &strings.Builder{}
    io.Copy(dst, src)
    fmt.Println(dst.String())
    
    // 写入Writer
    io.WriteString(os.Stdout, "写入标准输出\n")
    
    // 限制读取
    limited := io.LimitReader(strings.NewReader("Hello World"), 5)
    limitedData, _ := io.ReadAll(limited)
    fmt.Println(string(limitedData))  // Hello
    
    // TeeReader（同时读取和写入）
    var buf strings.Builder
    tee := io.TeeReader(strings.NewReader("Hello"), &buf)
    teeData, _ := io.ReadAll(tee)
    fmt.Println(string(teeData))  // Hello
    fmt.Println(buf.String())     // Hello
}

os包 - 操作系统功能 ​

go
package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    // 环境变量
    fmt.Println("HOME:", os.Getenv("HOME"))
    fmt.Println("PATH:", os.Getenv("PATH"))
    os.Setenv("MY_VAR", "my_value")
    fmt.Println("MY_VAR:", os.Getenv("MY_VAR"))
    
    // 命令行参数
    fmt.Println("程序名:", os.Args[0])
    for i, arg := range os.Args {
        fmt.Printf("参数%d: %s\n", i, arg)
    }
    
    // 文件操作
    file, err := os.Create("test.txt")
    if err != nil {
        fmt.Println("创建文件失败:", err)
        return
    }
    defer file.Close()
    
    file.WriteString("Hello, Go!")
    
    // 读取文件
    data, _ := os.ReadFile("test.txt")
    fmt.Println(string(data))
    
    // 文件信息
    info, _ := os.Stat("test.txt")
    fmt.Println("文件名:", info.Name())
    fmt.Println("大小:", info.Size())
    fmt.Println("修改时间:", info.ModTime())
    fmt.Println("是否目录:", info.IsDir())
    
    // 目录操作
    os.Mkdir("testdir", 0755)
    os.MkdirAll("testdir/subdir", 0755)
    
    // 删除
    os.Remove("test.txt")
    os.RemoveAll("testdir")
    
    // 执行命令
    cmd := exec.Command("ls", "-la")
    output, _ := cmd.Output()
    fmt.Println(string(output))
    
    // 退出程序
    // os.Exit(0)
}

encoding/json包 - JSON处理 ​

go
package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
    City string `json:"city,omitempty"`
}

func main() {
    // 结构体转JSON
    p := Person{Name: "张三", Age: 25, City: "北京"}
    jsonData, _ := json.Marshal(p)
    fmt.Println(string(jsonData))  // {"name":"张三","age":25,"city":"北京"}
    
    // 格式化输出
    prettyJSON, _ := json.MarshalIndent(p, "", "  ")
    fmt.Println(string(prettyJSON))
    
    // JSON转结构体
    jsonStr := `{"name":"李四","age":30}`
    var p2 Person
    json.Unmarshal([]byte(jsonStr), &p2)
    fmt.Printf("%+v\n", p2)
    
    // 处理未知结构
    var result map[string]interface{}
    json.Unmarshal([]byte(jsonStr), &result)
    fmt.Println(result["name"])
    
    // 编码器/解码器
    // 用于处理流式JSON数据
}

net/http包 - HTTP客户端和服务端 ​

go
package main

import (
    "fmt"
    "io"
    "net/http"
)

func main() {
    // HTTP客户端
    resp, err := http.Get("https://httpbin.org/get")
    if err != nil {
        fmt.Println("请求失败:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
    
    // POST请求
    // resp, err := http.Post("https://httpbin.org/post", "application/json", bytes.NewBuffer(data))
}

HTTP服务端 ​

go
package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}