Go 语言常用工具方法总结

在 Go 语言开发中，常常需要进行一些常见的类型转换、字符串处理、时间处理等操作。本文将总结一些常用的工具方法，帮助大家提高编码效率，并提供必要的代码解释和注意事项（go新人浅浅记录一下，以后来翻看🤣）。

1. 类型转换

1.1 整数与字符串之间的转换

1.1.1 int 转 string

import "strconv"

// IntToString 将 int 转换为 string
func IntToString(i int) string {
    return strconv.Itoa(i)
}

说明：strconv.Itoa 是 Go 标准库中的函数，用于将整数转换为字符串。

1.1.2 int64 转 string

// Int64ToString 将 int64 转换为 string
func Int64ToString(i int64) string {
    return strconv.FormatInt(i, 10) // 10 表示以十进制格式转换
}

注意：FormatInt 的第二个参数是基数，常用的有 10（十进制）、16（十六进制）等。

1.1.3 string 转 int

// StringToInt 将 string 转换为 int
func StringToInt(s string) (int, error) {
    return strconv.Atoi(s) // Atoi 是 "ASCII to integer" 的缩写
}

注意：如果字符串无法转换为整数，将返回错误。

1.1.4 string 转 int64

// StringToInt64 将 string 转换为 int64
func StringToInt64(s string) (int64, error) {
    return strconv.ParseInt(s, 10, 64) // 10 表示十进制，64 表示返回值的位数
}

注意：ParseInt 的第三个参数指定了返回值的位数，通常使用 64。

1.2 浮点数与字符串之间的转换

1.2.1 float64 转 string

// Float64ToString 将 float64 转换为 string
func Float64ToString(f float64) string {
    return strconv.FormatFloat(f, 'f', -1, 64) // 'f' 表示以十进制格式输出
}

说明：FormatFloat 的第二个参数控制输出格式，第三个参数控制小数点后位数，-1 表示使用默认。

1.2.2 string 转 float64

// StringToFloat64 将 string 转换为 float64
func StringToFloat64(s string) (float64, error) {
    return strconv.ParseFloat(s, 64) // 64 表示返回值的位数
}

注意：如果字符串无法转换为浮点数，将返回错误。

2. 字符串处理

2.1 字符串拼接

import "strings"

// JoinStrings 将字符串切片拼接为一个字符串
func JoinStrings(strs []string, sep string) string {
    return strings.Join(strs, sep) // sep 是分隔符
}

说明：Join 方法可以高效地拼接字符串，避免使用 + 运算符造成的性能损失。

2.2 字符串分割

import "strings"
// SplitString 将字符串按分隔符分割为切片
func SplitString(s, sep string) []string {
    return strings.Split(s, sep) // 返回分割后的字符串切片
}

注意：如果分隔符不存在，返回的切片将包含原字符串。

2.3 字符串去空格

import "strings"
// TrimString 去除字符串两端的空格
func TrimString(s string) string {
    return strings.TrimSpace(s) // 去除前后空格
}

说明：TrimSpace 会去除字符串两端的所有空白字符。

2.4 字符串替换

import "strings"
// ReplaceString 替换字符串中的子串
func ReplaceString(s, old, new string, n int) string {
    return strings.Replace(s, old, new, n) // n 为替换次数，-1 表示替换所有
}

注意：如果 old 不在 s 中，返回的字符串与原字符串相同。

3. 时间处理

3.1 获取当前时间

import "time"

// GetCurrentTime 获取当前时间
func GetCurrentTime() time.Time {
    return time.Now() // 返回当前时间
}

说明：time.Now() 返回当前的本地时间。

3.2 时间格式化

// FormatTime 格式化时间为字符串
func FormatTime(t time.Time, layout string) string {
    return t.Format(layout) // layout 是时间格式，例如 "2006-01-02 15:04:05"
}

注意：Go 的时间格式化使用特定的布局，必须使用 2006-01-02 15:04:05 这种格式。

Tips：
Go 标准库中没有直接提供时间格式常量，但可以通过定义常量来提高代码的可读性

const (
    DateFormat       = "2006-01-02"
    TimeFormat       = "15:04:05"
    DateTimeFormat   = "2006-01-02 15:04:05"
    FullDateFormat   = "Mon Jan 2 15:04:05 MST 2006"
    ChineseDateFormat = "2006年01月02日 15时04分05秒"
)

引出一个小问题：

Go 语言在时间处理方面的设计与 Java 等其他语言里的有所不同？没有一组常量或格式符号（如yyyy, MM，dd）等符号。

Go 语言的设计哲学强调简洁和明确。Go 的时间格式化使用的是一个固定的时间布局（Mon Jan 2 15:04:05 MST 2006），而不是使用一组常量或格式符号（如 yyyy, MM, dd 等）。这种设计使得时间格式化的方式非常直观，因为开发者可以直接看到格式化的样子，而不需要记住一堆格式符号。

3.3 字符串转时间

// StringToTime 将字符串转换为时间
func StringToTime(s, layout string) (time.Time, error) {
    return time.Parse(layout, s) // layout 必须与字符串格式一致
}

注意：如果字符串格式不符合布局，将返回错误。

4. 数组和切片处理

4.1 切片去重

// UniqueInts 从切片中去重
func UniqueInts(ints []int) []int {
    m := make(map[int]struct{}) // 使用 map 来记录出现过的元素
    var result []int
    for _, v := range ints {
        if _, exists := m[v]; !exists {
            m[v] = struct{}{}
            result = append(result, v) // 只添加未出现过的元素
        }
    }
    return result
}

说明：使用 map 去重，时间复杂度为 O(n)。

4.2 切片排序

import "sort"

// SortInts 对切片进行排序
func SortInts(ints []int) {
    sort.Ints(ints) // 使用 sort 包的 Ints 方法进行排序
}

注意：sort.Ints 会对原切片进行排序，若需要保留原切片，请先复制。

4.2.1. 自定义排序

package main

import (
    "fmt"
    "sort"
)

// 定义一个 Student 结构体
type Student struct {
    Name  string
    Score int
}

func main() {
    // 创建一个 Student 切片
    students := []Student{
        {"Alice", 85},
        {"Bob", 92},
        {"Charlie", 78},
        {"David", 88},
    }

    // 使用 sort.Slice 对切片进行排序
    sort.Slice(students, func(i, j int) bool {
        return students[i].Score < students[j].Score // 按分数升序排序
    })

    // 打印排序后的切片
    fmt.Println("按分数排序后的学生切片:")
    for _, student := range students {
        fmt.Printf("%s: %d\n", student.Name, student.Score)
    }
}

输出：

按分数排序后的学生切片:
Charlie: 78
Alice: 85

小结

对于基本数据类型的切片，可以使用 sort.Ints、sort.Strings 等函数进行排序。

对于自定义数据类型的切片，可以通过实现 sort.Interface 接口来进行排序，或者使用 sort.Slice 函数来简化排序过程。

sort.Slice 提供了一种更简洁的方式来对切片进行排序，特别是在处理简单的排序逻辑时。

5. 错误处理

5.1 检查错误并处理

import "log"

// CheckError 检查错误并处理
func CheckError(err error) {
    if err != nil {
        log.Println(err) // 打印错误日志
    }
}

说明：在 Go 中，错误处理是非常重要的，建议在每个可能出错的地方都进行错误检查。

6. JSON 处理

6.1 对象转 JSON

import "encoding/json"

// StructToJSON 将结构体转换为 JSON 字符串
func StructToJSON(v interface{}) (string, error) {
    jsonData, err := json.Marshal(v) // Marshal 将对象编码为 JSON
    return string(jsonData), err
}

注意：如果对象中包含不可导出的字段，Marshal 将忽略这些字段。

6.2 JSON 转对象

// JSONToStruct 将 JSON 字符串转换为对象
func JSONToStruct(data string, v interface{}) error {
    return json.Unmarshal([]byte(data), v) // Unmarshal 将 JSON 解码为对象
}

注意：确保传入的对象是指针类型，以便 Unmarshal 能够正确填充数据。

7. 文件操作

7.1 读取文件

import (
    "io/ioutil"
    "os"
)

// ReadFile 读取文件内容
func ReadFile(filename string) (string, error) {
    data, err := ioutil.ReadFile(filename) // 读取文件
    return string(data), err
}

注意：ioutil.ReadFile 会一次性读取整个文件，适合小文件。

7.2 写入文件

// WriteFile 将字符串写入文件
func WriteFile(filename, data string) error {
    return ioutil.WriteFile(filename, []byte(data), os.ModePerm) // 写入文件
}

注意：os.ModePerm 表示文件的权限，通常使用默认权限即可。

8. 并发处理

8.1 使用 WaitGroup 等待多个 goroutine 完成

import (
    "sync"
)

// WaitForGoroutines 等待多个 goroutine 完成
func WaitForGoroutines(goroutines int) {
    var wg sync.WaitGroup
    for i := 0; i < goroutines; i++ {
        wg.Add(1) // 增加 WaitGroup 计数
        go func(i int) {
            defer wg.Done() // 完成时减少计数
            // 执行任务
        }(i)
    }
    wg.Wait() // 等待所有 goroutine 完成
}