当前位置： 首页 > article >正文

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

article 2025/1/17 0:20:39

文章目录

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

一、文件操作 📂

（一）文件读取与写入 🌟

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

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

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

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

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

    content, err := ioutil.ReadAll(file)
if err!= nil {
    log.Fatal(err)
}

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

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

    scanner := bufio.NewScanner(file)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

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

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

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

（二）文件路径操作 🌐

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

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

    path := filepath.Join("dir", "subdir", "file.txt")

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

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

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

（三）文件信息获取 📋

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

  • os.Stat 可以获取文件的信息，如文件大小、权限、是否为目录等：
    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 可递归创建目录：

    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 可以递归删除目录：

    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 进行并发操作：

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

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

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

    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 间的数据通信，可用于数据传递和同步：

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

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

    bufferedCh := make(chan int, 10)
bufferedCh <- 1
bufferedCh <- 2
value := <-bufferedCh
fmt.Println(value)

（三）Select 语句 ⏱️

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

  • select 语句可以同时等待多个 Channel 的操作，实现非阻塞通信和超时机制：
    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：

    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 处理任务队列：

    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 服务器：

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

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

    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 服务器，监听和处理连接：

    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 客户端，建立连接并发送数据：

    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 服务：
    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 等：

    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 操作，自动映射结果到结构体：

    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 包：

    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 包：

    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 包进行基本日志记录：
    log.Println("This is a log message")
log.Printf("Value: %d", 42)

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

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

  • 使用 logrus 等第三方包实现日志分级：
    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 进行性能分析和调试：
    import (
    _ "net/http/pprof"
)
go func() {
    http.ListenAndServe(":6060", nil)
}()

六、配置管理 ⚙️

（一）环境变量读取 🌳

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

  • 读取环境变量，使用 os.Getenv：
    port := os.Getenv("PORT")
if port == "" {
    port = "8080"
}

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

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

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

    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 包：

    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)

七、错误处理与恢复 🛡️

（一）错误处理 ❌

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

  • 函数返回错误，调用者检查错误：
    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 处理异常：
    func main() {
    defer func() {
        if r := recover(); r!= nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    panic("Something went wrong")
}

八、测试与性能优化 🧪

（一）单元测试 🧐

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

  • 编写单元测试，使用 testing 包：
    func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result!= 5 {
        t.Errorf("Expected 5, got %d", result)
    }
}

（二）性能测试 🚀

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

  • 进行性能测试，使用 testing 包：
    func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

（三）代码优化 🔍

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

  • 避免不必要的内存分配，使用 strings.Builder 替代 + 拼接字符串：
    var builder strings.Builder
builder.WriteString("Hello")
builder.WriteString(", World!")
result := builder.String()

九、数据结构与算法 🔢

（一）切片操作 🍕

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

  • 使用切片存储和操作数据：
    slice := []int{1, 2, 3}
slice = append(slice, 4)
fmt.Println(slice[0])

（二）映射操作 🔑

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

  • 使用映射存储键值对：
    m := make(map[string]int)
m["key"] = 42
value, exists := m["key"]
if exists {
    fmt.Println(value)
}

（三）排序算法 🔀

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

  • 使用 sort 包对切片排序：
    ints := []int{3, 1, 4, 1, 5, 9}
sort.Ints(ints)
fmt.Println(ints)

十、模板引擎 🎨

（一）HTML 模板 🌐

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

  • 使用 html/template 包生成 HTML 内容：
    tmpl := template.Must(template.New("index").Parse(`<html><body>{{.}}</body></html>`))
tmpl.Execute(w, "Hello, World!")

（二）文本模板 📃

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

  • 使用 text/template 包生成文本内容：
    tmpl := template.Must(template.New("greet").Parse("Hello, {{.}}!"))
tmpl.Execute(w, "World")

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

（一）flag 包 🏁

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

  • 使用 flag 包解析命令行参数：
    var name string
flag.StringVar(&name, "name", "World", "a name to greet")
flag.Parse()
fmt.Printf("Hello, %s!\n", name)

（二）cobra 包 🔨

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

  • 使用 cobra 包创建强大的命令行工具：
    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 加密：
    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 计算哈希值：
    h := sha25

http://www.kler.cn/a/505693.html

相关文章：

  • SpringBoot+Lombok项目实体属性名xXxx格式，前端接收不到
  • Linux 查看内存命令
  • ImageSharp图形库学习
  • 开发指南091-延迟退休算法
  • MySQL主从：如何处理“Got Fatal Error 1236”或 MY-013114 错误（percona译文）
  • 第G1周：生成对抗网络（GAN）入门
  • 【论文阅读】具身人工智能（Embodied AI）综述：连接数字与物理世界的桥梁
  • springboot房屋租赁管理系统
  • Kotlin 极简小抄 P4（for 循环、while 循环、do while 循环、continue 与 break、for 循环标签）
  • O2O同城系统架构与功能分析
  • DNS解析域名简记
  • Oracle查询-in条件超过1000
  • (NIPS-2024)GAN 已死；GAN 万岁！现代基线 GAN
  • Python 上下文管理器：优雅地管理资源
  • 鸿蒙-UIAbility组件生命周期
  • Vue3初学之Element-plus-table组件及分页
  • 【linux】文件与目录命令 - vim
  • linux之进程信号(初识信号，信号的产生)
  • 基于单片机的无线智能窗帘控制器的设计
  • 基于Java+SpringMvc+Vue技术的在线宠物分享平台分享
  • Windows 环境下安装和启动 Redis 服务
  • 国产fpga nvme ip高速存储方案设计
  • MATLAB语言的编程范式
  • 当父级元素设置了flex 布局 ，两个子元素都设置了flex :1, 但是当子元素放不下的时候会溢出父元素怎么解决 （css 样式问题）
  • 雷达流量监测系统：精准监控水流，确保水资源安全
  • 基于vite+vue3+mapbox-gl从零搭建一个项目