【10】Golang实用且神奇的开发操作总结

不知名美食探索家2025-01-19 16:29

文章目录

    • [一、文件操作 📂](#一、文件操作 📂)
      • [（一）文件读取与写入 🌟](#（一）文件读取与写入 🌟)
      • [（二）文件路径操作 🌐](#（二）文件路径操作 🌐)
      • [（三）文件信息获取 📋](#（三）文件信息获取 📋)
      • [（四）目录操作 🗂️](#（四）目录操作 🗂️)
    • [二、并发与并行处理 ⚙️](#二、并发与并行处理 ⚙️)
      • [（一）Goroutines 并发 🌠](#（一）Goroutines 并发 🌠)
      • [（二）Channels 通信 📡](#（二）Channels 通信 📡)
      • [（三）Select 语句 ⏱️](#（三）Select 语句 ⏱️)
      • [（四）Concurrency Patterns 并发模式 🔀](#（四）Concurrency Patterns 并发模式 🔀)
    • [三、网络编程 🌐](#三、网络编程 🌐)
      • [（一）HTTP 服务 🌍](#（一）HTTP 服务 🌍)
      • [（二）TCP 服务与客户端 📡](#（二）TCP 服务与客户端 📡)
      • [（三）WebSocket 服务 🌐](#（三）WebSocket 服务 🌐)
    • [四、数据库操作 🗃️](#四、数据库操作 🗃️)
      • [（一）SQL 数据库 💾](#（一）SQL 数据库 💾)
      • [（二）NoSQL 数据库 🔍](#（二）NoSQL 数据库 🔍)
    • [五、日志记录与调试 📝](#五、日志记录与调试 📝)
      • [（一）标准日志记录 📜](#（一）标准日志记录 📜)
      • [（二）日志级别和自定义日志 🌟](#（二）日志级别和自定义日志 🌟)
      • [（三）调试工具 🐞](#（三）调试工具 🐞)
    • [六、配置管理 ⚙️](#六、配置管理 ⚙️)
      • [（一）环境变量读取 🌳](#（一）环境变量读取 🌳)
      • [（二）YAML/JSON 配置文件读取 📄](#（二）YAML/JSON 配置文件读取 📄)
    • [七、错误处理与恢复 🛡️](#七、错误处理与恢复 🛡️)
      • [（一）错误处理 ❌](#（一）错误处理 ❌)
      • [（二）Panic 与 Recover 🔧](#（二）Panic 与 Recover 🔧)
    • [八、测试与性能优化 🧪](#八、测试与性能优化 🧪)
      • [（一）单元测试 🧐](#（一）单元测试 🧐)
      • [（二）性能测试 🚀](#（二）性能测试 🚀)
      • [（三）代码优化 🔍](#（三）代码优化 🔍)
    • [九、数据结构与算法 🔢](#九、数据结构与算法 🔢)
      • [（一）切片操作 🍕](#（一）切片操作 🍕)
      • [（二）映射操作 🔑](#（二）映射操作 🔑)
      • [（三）排序算法 🔀](#（三）排序算法 🔀)
    • [十、模板引擎 🎨](#十、模板引擎 🎨)
      • [（一）HTML 模板 🌐](#（一）HTML 模板 🌐)
      • [（二）文本模板 📃](#（二）文本模板 📃)
    • [十一、命令行工具开发 🛠️](#十一、命令行工具开发 🛠️)
      • [（一）`flag` 包 🏁](#（一）flag 包 🏁)
      • [（二）`cobra` 包 🔨](#（二）cobra 包 🔨)
    • [十二、加密与安全 🔒](#十二、加密与安全 🔒)
      • [（一）加密算法 🔐](#（一）加密算法 🔐)
      • [（二）哈希算法 🔑](#（二）哈希算法 🔑)

一、文件操作 📂

（一）文件读取与写入 🌟

在 Go 语言中，文件操作是常见的开发任务，以下是一些实用的操作技巧：

  • 使用 os.Open 和 os.Create 打开和创建文件：

    go 复制代码 
    file, err := os.Open("example.txt")
if err!= nil {
    log.Fatal(err)
}
defer file.Close()

    这里使用 os.Open 打开文件，同时使用 defer 关键字确保文件在操作完成后关闭，避免资源泄漏。

  • 利用 ioutil.ReadAll 快速读取文件的全部内容：

    go 复制代码 
    content, err := ioutil.ReadAll(file)
if err!= nil {
    log.Fatal(err)
}

    此方法能方便地将文件内容读取到一个字节切片中。

  • 对于大文件，可以使用 bufio.Scanner 逐行读取：

    go 复制代码 
    scanner := bufio.NewScanner(file)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

    这种方式避免了一次性加载整个文件到内存，适用于大文件处理。

  • 用 os.WriteFile 简单地将数据写入文件：

    go 复制代码 
    data := []byte("Hello, World!")
err := os.WriteFile("output.txt", data, 0644)
if err!= nil {
    log.Fatal(err)
}

（二）文件路径操作 🌐

文件路径的处理在文件操作中至关重要，path/filepath 包提供了强大的功能：

  • filepath.Join 可以正确拼接路径：

    go 复制代码 
    path := filepath.Join("dir", "subdir", "file.txt")

    它会根据操作系统自动选择正确的路径分隔符，确保跨平台的兼容性。

  • 使用 filepath.Abs 获取文件的绝对路径：

    go 复制代码 
    absPath, err := filepath.Abs("relative/path")
if err!= nil {
    log.Fatal(err)
}

（三）文件信息获取 📋

我们经常需要获取文件的各种信息，os.Stat 是一个得力工具：

  • os.Stat 可以获取文件的信息，如文件大小、权限、是否为目录等 ：

    go 复制代码 
    fileInfo, err := os.Stat("example.txt")
if err!= nil {
    log.Fatal(err)
}
fmt.Println(fileInfo.Size())
fmt.Println(fileInfo.IsDir())

（四）目录操作 🗂️

目录的创建、删除和管理是文件系统操作的重要部分：

  • 使用 os.Mkdir 和 os.MkdirAll 创建目录，os.MkdirAll 可递归创建目录：

    go 复制代码 
    err := os.Mkdir("newdir", 0755)
if err!= nil {
    log.Fatal(err)
}
err = os.MkdirAll("parent/child/grandchild", 0755)
if err!= nil {
    log.Fatal(err)
}

  • os.Remove 和 os.RemoveAll 用于删除文件和目录，os.RemoveAll 可以递归删除目录：

    go 复制代码 
    err := os.Remove("file.txt")
if err!= nil {
    log.Fatal(err)
}
err = os.RemoveAll("parent")
if err!= nil {
    log.Fatal(err)
}

二、并发与并行处理 ⚙️

（一）Goroutines 并发 🌠

Goroutines 是 Go 语言并发的核心，以下是其使用示例：

  • 启动 Goroutines 进行并发操作：

    go 复制代码 
    func printMessage(msg string) {
    fmt.Println(msg)
}
go printMessage("Hello from goroutine 1")
go printMessage("Hello from goroutine 2")

    简单的 go 关键字就能启动一个 Goroutine。

  • 使用 sync.WaitGroup 来等待多个 Goroutines 完成任务：

    go 复制代码 
    var wg sync.WaitGroup
wg.Add(2)
go func() {
    defer wg.Done()
    printMessage("Task 1")
}()
go func() {
    defer wg.Done()
    printMessage("Task 2")
}()
wg.Wait()

    它能帮助我们更好地控制 Goroutines 的同步。

（二）Channels 通信 📡

Channels 是 Goroutines 之间通信的重要方式：

  • 通过 Channels 进行 Goroutines 间的数据通信，可用于数据传递和同步：

    go 复制代码 
    ch := make(chan int)
go func() {
    ch <- 42
}()
value := <-ch
fmt.Println(value)

  • 使用 buffered channels 减少阻塞，提高性能：

    go 复制代码 
    bufferedCh := make(chan int, 10)
bufferedCh <- 1
bufferedCh <- 2
value := <-bufferedCh
fmt.Println(value)

（三）Select 语句 ⏱️

select 语句为并发编程带来了更多的灵活性：

  • select 语句可以同时等待多个 Channel 的操作，实现非阻塞通信和超时机制 ：

    go 复制代码 
    ch1 := make(chan int)
ch2 := make(chan int)
go func() {
    ch1 <- 1
}()
select {
case val := <-ch1:
    fmt.Println(val)
case val := <-ch2:
    fmt.Println(val)
case <-time.After(1 * time.Second):
    fmt.Println("Timeout")
}

（四）Concurrency Patterns 并发模式 🔀

一些常见的并发模式能帮助我们解决复杂的并发问题：

  • Fan-In 模式，将多个 Channels 数据汇聚到一个 Channel：

    go 复制代码 
    func fanIn(input1, input2 <-chan int) <-chan int {
    output := make(chan int)
    go func() {
        for {
            select {
            case val := <-input1:
                output <- val
            case val := <-input2:
                output <- val
            }
        }
    }()
    return output
}

  • Worker Pool 模式，多个工作 Goroutines 处理任务队列：

    go 复制代码 
    func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d started job %d\n", id, j)
        time.Sleep(time.Second)
        results <- j * 2
        fmt.Printf("worker %d finished job %d\n", id, j)
    }
}
jobs := make(chan int, 100)
results := make(chan int, 100)
for w := 1; w <= 3; w++ {
    go worker(w, jobs, results)
}
for j := 1; j <= 5; j++ {
    jobs <- j
}
close(jobs)
for a := 1; a <= 5; a++ {
    fmt.Println(<-results)
}

三、网络编程 🌐

（一）HTTP 服务 🌍

Go 语言在网络编程方面提供了简洁而强大的支持，以下是 HTTP 服务的创建方法：

  • 使用 net/http 包创建简单的 HTTP 服务器：

    go 复制代码 
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, World!")
})
http.ListenAndServe(":8080", nil)

  • 自定义 HTTP 客户端，设置请求头、超时等：

    go 复制代码 
    client := &http.Client{
    Timeout: 10 * time.Second,
}
req, err := http.NewRequest("GET", "http://example.com", nil)
req.Header.Set("User-Agent", "my-client")
resp, err := client.Do(req)
if err!= nil {
    log.Fatal(err)
}
defer resp.Body.Close()

（二）TCP 服务与客户端 📡

TCP 是基础的网络协议，以下是 TCP 服务和客户端的实现：

  • 实现 TCP 服务器，监听和处理连接：

    go 复制代码 
    listener, err := net.Listen("tcp", ":12345")
if err!= nil {
    log.Fatal(err)
}
defer listener.Close()
for {
    conn, err := listener.Accept()
    if err!= nil {
        log.Fatal(err)
    }
    go func(c net.Conn) {
        defer c.Close()
        // 处理连接
    }(conn)
}

  • TCP 客户端，建立连接并发送数据：

    go 复制代码 
    conn, err := net.Dial("tcp", "localhost:12345")
if err!= nil {
    log.Fatal(err)
}
defer conn.Close()
conn.Write([]byte("Hello, Server!"))

（三）WebSocket 服务 🌐

对于实时通信，WebSocket 是一个不错的选择：

  • 使用 gorilla/websocket 包实现 WebSocket 服务 ：

    go 复制代码 
    var upgrader = websocket.Upgrader{}
http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
    c, err := upgrader.Upgrade(w, r, nil)
    if err!= nil {
        log.Fatal(err)
    }
    defer c.Close()
    for {
        _, message, err := c.ReadMessage()
        if err!= nil {
            log.Println(err)
            break
        }
        fmt.Printf("Received: %s\n", message)
        err = c.WriteMessage(websocket.TextMessage, []byte("Echo: "+string(message)))
        if err!= nil {
            log.Println(err)
            break
        }
    }
})
http.ListenAndServe(":8080", nil)

四、数据库操作 🗃️

（一）SQL 数据库 💾

操作 SQL 数据库是后端开发的常见需求：

  • 使用 database/sql 包操作 SQL 数据库，如 MySQL、PostgreSQL 等：

    go 复制代码 
    db, err := sql.Open("mysql", "user:password@/dbname")
if err!= nil {
    log.Fatal(err)
}
defer db.Close()
rows, err := db.Query("SELECT * FROM users")
if err!= nil {
    log.Fatal(err)
}
defer rows.Close()
for rows.Next() {
    var id int
    var name string
    if err := rows.Scan(&id, &name); err!= nil {
        log.Fatal(err)
    }
    fmt.Printf("ID: %d, Name: %s\n", id, name)
}

  • 使用 sqlx 包简化 SQL 操作，自动映射结果到结构体：

    go 复制代码 
    type User struct {
    ID   int
    Name string
}
var users []User
err := db.Select(&users, "SELECT * FROM users")
if err!= nil {
    log.Fatal(err)
}

（二）NoSQL 数据库 🔍

NoSQL 数据库也有丰富的 Go 语言支持：

  • 操作 Redis 数据库，使用 redis/go-redis 包：

    go 复制代码 
    client := redis.NewClient(&redis.Options{
    Addr:     "localhost:6379",
    Password: "",
    DB:       0,
})
err := client.Set("key", "value", 0).Err()
if err!= nil {
    log.Fatal(err)
}
val, err := client.Get("key").Result()
if err!= nil {
    log.Fatal(err)
}
fmt.Println(val)

  • 与 MongoDB 交互，使用 mongo-go-driver 包：

    go 复制代码 
    client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:25017"))
if err!= nil {
    log.Fatal(err)
}
defer client.Disconnect(context.TODO())
collection := client.Database("test").Collection("users")
result, err := collection.InsertOne(context.TODO(), bson.D{
    {"name", "John Doe"},
})
if err!= nil {
    log.Fatal(err)
}
fmt.Println(result.InsertedID)

五、日志记录与调试 📝

（一）标准日志记录 📜

Go 语言内置了基本的日志记录功能：

  • 使用 log 包进行基本日志记录 ：

    go 复制代码 
    log.Println("This is a log message")
log.Printf("Value: %d", 42)

（二）日志级别和自定义日志 🌟

为了更好地管理日志，可以使用第三方日志库：

  • 使用 logrus 等第三方包实现日志分级 ：

    go 复制代码 
    import (
    log "github.com/sirupsen/logrus"
)
log.SetLevel(log.InfoLevel)
log.Info("This is an info message")
log.Warn("This is a warning message")

（三）调试工具 🐞

在性能分析和调试时，以下工具会很有用：

  • 使用 pprof 进行性能分析和调试 ：

    go 复制代码 
    import (
    _ "net/http/pprof"
)
go func() {
    http.ListenAndServe(":6060", nil)
}()

六、配置管理 ⚙️

（一）环境变量读取 🌳

环境变量在不同部署环境中起着重要作用：

  • 读取环境变量，使用 os.Getenv ：

    go 复制代码 
    port := os.Getenv("PORT")
if port == "" {
    port = "8080"
}

（二）YAML/JSON 配置文件读取 📄

配置文件常用于存储程序的配置信息：

  • 读取 YAML 配置文件，使用 gopkg.in/yaml.v3 包：

    go 复制代码 
    type Config struct {
    Server struct {
        Port int `yaml:"port"`
    } `yaml:"server"`
}
var config Config
data, err := ioutil.ReadAll(file)
if err!= nil {
    log.Fatal(err)
}
err = yaml.Unmarshal(data, &config)
if err!= nil {
    log.Fatal(err)
}
fmt.Println(config.Server.Port)

  • 读取 JSON 配置文件，使用 encoding/json 包：

    go 复制代码 
    var config Config
data, err := ioutil.ReadAll(file)
if err!= nil {
    log.Fatal(err)
}
err = json.Unmarshal(data, &config)
if err!= nil {
    log.Fatal(err)
}
fmt.Println(config.Server.Port)

七、错误处理与恢复 🛡️

（一）错误处理 ❌

良好的错误处理是编写健壮程序的关键：

  • 函数返回错误，调用者检查错误 ：

    go 复制代码 
    func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}
result, err := divide(10, 2)
if err!= nil {
    log.Fatal(err)
}
fmt.Println(result)

（二）Panic 与 Recover 🔧

处理异常情况时，panic 和 recover 是重要的工具：

  • 使用 panic 和 recover 处理异常 ：

    go 复制代码 
    func main() {
    defer func() {
        if r := recover(); r!= nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    panic("Something went wrong")
}

八、测试与性能优化 🧪

（一）单元测试 🧐

测试是保证代码质量的重要手段：

  • 编写单元测试，使用 testing 包 ：

    go 复制代码 
    func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result!= 5 {
        t.Errorf("Expected 5, got %d", result)
    }
}

（二）性能测试 🚀

性能测试可以帮助我们优化代码性能：

  • 进行性能测试，使用 testing 包 ：

    go 复制代码 
    func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

（三）代码优化 🔍

为了提高代码性能，我们可以进行各种优化：

  • 避免不必要的内存分配，使用 strings.Builder 替代 + 拼接字符串 ：

    go 复制代码 
    var builder strings.Builder
builder.WriteString("Hello")
builder.WriteString(", World!")
result := builder.String()

九、数据结构与算法 🔢

（一）切片操作 🍕

切片是 Go 语言中常用的数据结构：

  • 使用切片存储和操作数据 ：

    go 复制代码 
    slice := []int{1, 2, 3}
slice = append(slice, 4)
fmt.Println(slice[0])

（二）映射操作 🔑

映射可以存储键值对，方便数据查找：

  • 使用映射存储键值对 ：

    go 复制代码 
    m := make(map[string]int)
m["key"] = 42
value, exists := m["key"]
if exists {
    fmt.Println(value)
}

（三）排序算法 🔀

排序是常见的数据操作，sort 包提供了方便的排序功能：

  • 使用 sort 包对切片排序 ：

    go 复制代码 
    ints := []int{3, 1, 4, 1, 5, 9}
sort.Ints(ints)
fmt.Println(ints)

十、模板引擎 🎨

（一）HTML 模板 🌐

模板引擎可以帮助我们生成动态内容：

  • 使用 html/template 包生成 HTML 内容 ：

    go 复制代码 
    tmpl := template.Must(template.New("index").Parse(`<html><body>{{.}}</body></html>`))
tmpl.Execute(w, "Hello, World!")

（二）文本模板 📃

文本模板适用于生成文本内容：

  • 使用 text/template 包生成文本内容 ：

    go 复制代码 
    tmpl := template.Must(template.New("greet").Parse("Hello, {{.}}!"))
tmpl.Execute(w, "World")

十一、命令行工具开发 🛠️

（一）flag 包 🏁

flag 包方便我们解析命令行参数：

  • 使用 flag 包解析命令行参数 ：

    go 复制代码 
    var name string
flag.StringVar(&name, "name", "World", "a name to greet")
flag.Parse()
fmt.Printf("Hello, %s!\n", name)

（二）cobra 包 🔨

cobra 是一个强大的命令行工具开发包：

  • 使用 cobra 包创建强大的命令行工具 ：

    go 复制代码 
    var rootCmd = &cobra.Command{
    Use:   "myapp",
    Short: "My amazing application",
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Println("Hello, World!")
    },
}
rootCmd.Execute()

十二、加密与安全 🔒

（一）加密算法 🔐

加密对于数据安全至关重要：

  • 使用 crypto 包进行加密操作，如 AES 加密 ：

    go 复制代码 
    block, err := aes.NewCipher(key)
if err!= nil {
    log.Fatal(err)
}
ciphertext := make([]byte, aes.BlockSize+len(plaintext))
iv := ciphertext[:aes.BlockSize]
stream := cipher.NewCFBEncrypter(block, iv)
stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)

（二）哈希算法 🔑

哈希算法常用于数据完整性和密码存储：

  • 使用 crypto/sha256 计算哈希值 ：

    go 复制代码 
    h := sha25
相关推荐
我是菜鸟0713号13 分钟前
上位机工作感想-2024年工作总结和来年计划
开发语言·qt
SomeB1oody14 分钟前
【Rust自学】13.5. 迭代器 Pt.1：迭代器的定义、iterator trait和next方法
开发语言·后端·rust
laimaxgg18 分钟前
Linux网络连接内核
linux·运维·服务器·网络·网络协议·tcp/ip
Hello.Reader19 分钟前
用 Rust 写下第一个 “Hello, World!”
开发语言·后端·rust
小哇66630 分钟前
nginx常用配置 （含负载均衡、反向代理、限流、Gzip压缩、图片防盗链 等示例）
java·服务器·nginx
叫我：松哥31 分钟前
基于python对抖音热门视频的数据分析与实现
开发语言·python·数据挖掘·数据分析·数据可视化·情感分析·lda主题分析
sp_fyf_20241 小时前
Python与PyTorch的浅拷贝与深拷贝
开发语言·pytorch·python
m0_748251351 小时前
在21世纪的我用C语言探寻世界本质——字符函数和字符串函数(2)
c语言·开发语言
步、步、为营1 小时前
C# 条件编译的应用
开发语言·c#
前端熊猫1 小时前
文件读取和输入输出
服务器·文件操作
热门推荐
01Oracle Scheduler: Calendaring02Dell服务器升级ubuntu 22.04失败解决03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04leetcode - 916. Word Subsets05(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07微服务概论(https://microservices.io/)08密码学原理技术-第六章-introduction to pulibc-key cryptography09渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了10centos7 init.d 和system.d