在 Go 语言开发中，常常需要进行一些常见的类型转换、字符串处理、时间处理等操作。本文将总结一些常用的工具方法，帮助大家提高编码效率，并提供必要的代码解释和注意事项（go新人浅浅记录一下，以后来翻看🤣）。
1. 类型转换
1.1 整数与字符串之间的转换
1.1.1 int 转 string
go
import "strconv"
// IntToString 将 int 转换为 string
func IntToString(i int) string {
return strconv.Itoa(i)
}说明 ：strconv.Itoa 是 Go 标准库中的函数，用于将整数转换为字符串。
1.1.2 int64 转 string
go
// Int64ToString 将 int64 转换为 string
func Int64ToString(i int64) string {
return strconv.FormatInt(i, 10) // 10 表示以十进制格式转换
}注意 ：FormatInt 的第二个参数是基数，常用的有 10（十进制）、16（十六进制）等。
1.1.3 string 转 int
go
// StringToInt 将 string 转换为 int
func StringToInt(s string) (int, error) {
return strconv.Atoi(s) // Atoi 是 "ASCII to integer" 的缩写
}注意：如果字符串无法转换为整数，将返回错误。
1.1.4 string 转 int64
go
// 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
go
// Float64ToString 将 float64 转换为 string
func Float64ToString(f float64) string {
return strconv.FormatFloat(f, 'f', -1, 64) // 'f' 表示以十进制格式输出
}说明 ：FormatFloat 的第二个参数控制输出格式，第三个参数控制小数点后位数，-1 表示使用默认。
1.2.2 string 转 float64
go
// StringToFloat64 将 string 转换为 float64
func StringToFloat64(s string) (float64, error) {
return strconv.ParseFloat(s, 64) // 64 表示返回值的位数
}注意：如果字符串无法转换为浮点数，将返回错误。
2. 字符串处理
2.1 字符串拼接
go
import "strings"
// JoinStrings 将字符串切片拼接为一个字符串
func JoinStrings(strs []string, sep string) string {
return strings.Join(strs, sep) // sep 是分隔符
}说明 ：Join 方法可以高效地拼接字符串，避免使用 + 运算符造成的性能损失。
2.2 字符串分割
go
import "strings"
// SplitString 将字符串按分隔符分割为切片
func SplitString(s, sep string) []string {
return strings.Split(s, sep) // 返回分割后的字符串切片
}注意：如果分隔符不存在，返回的切片将包含原字符串。
2.3 字符串去空格
go
import "strings"
// TrimString 去除字符串两端的空格
func TrimString(s string) string {
return strings.TrimSpace(s) // 去除前后空格
}说明 ：TrimSpace 会去除字符串两端的所有空白字符。
2.4 字符串替换
go
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 获取当前时间
go
import "time"
// GetCurrentTime 获取当前时间
func GetCurrentTime() time.Time {
return time.Now() // 返回当前时间
}说明 ：time.Now() 返回当前的本地时间。
3.2 时间格式化
go
// 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 标准库中没有直接提供时间格式常量，但可以通过定义常量来提高代码的可读性
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 字符串转时间
go
// StringToTime 将字符串转换为时间
func StringToTime(s, layout string) (time.Time, error) {
return time.Parse(layout, s) // layout 必须与字符串格式一致
}注意：如果字符串格式不符合布局，将返回错误。
4. 数组和切片处理
4.1 切片去重
go
// 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 切片排序
go
import "sort"
// SortInts 对切片进行排序
func SortInts(ints []int) {
sort.Ints(ints) // 使用 sort 包的 Ints 方法进行排序
}注意 ：sort.Ints 会对原切片进行排序，若需要保留原切片，请先复制。
4.2.1. 自定义排序
go
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 检查错误并处理
go
import "log"
// CheckError 检查错误并处理
func CheckError(err error) {
if err != nil {
log.Println(err) // 打印错误日志
}
}说明：在 Go 中，错误处理是非常重要的，建议在每个可能出错的地方都进行错误检查。
6. JSON 处理
6.1 对象转 JSON
go
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 转对象
go
// JSONToStruct 将 JSON 字符串转换为对象
func JSONToStruct(data string, v interface{}) error {
return json.Unmarshal([]byte(data), v) // Unmarshal 将 JSON 解码为对象
}注意 ：确保传入的对象是指针类型，以便 Unmarshal 能够正确填充数据。
7. 文件操作
7.1 读取文件
go
import (
"io/ioutil"
"os"
)
// ReadFile 读取文件内容
func ReadFile(filename string) (string, error) {
data, err := ioutil.ReadFile(filename) // 读取文件
return string(data), err
}注意 ：ioutil.ReadFile 会一次性读取整个文件，适合小文件。
7.2 写入文件
go
// WriteFile 将字符串写入文件
func WriteFile(filename, data string) error {
return ioutil.WriteFile(filename, []byte(data), os.ModePerm) // 写入文件
}注意 ：os.ModePerm 表示文件的权限，通常使用默认权限即可。
8. 并发处理
8.1 使用 WaitGroup 等待多个 goroutine 完成
go
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 完成
}说明 ：sync.WaitGroup 是用于等待一组 goroutine 完成的同步原语。
总结
以上是 Go 语言中一些常用的工具方法的汇总。这些方法涵盖了类型转换、字符串处理、时间处理、数组和切片处理、错误处理、JSON 处理、文件操作以及并发处理等常见场景。通过这些工具方法，开发者可以提高编码效率，减少重复代码的编写。
一些小 tips
- 在进行类型转换时，务必检查返回的错误，确保数据的有效性。
- 字符串处理时，注意使用合适的分隔符和格式，避免因格式不匹配导致的错误。
- 在并发编程中，确保对共享资源的访问是安全的，避免数据竞争。
- 处理 JSON 时，确保结构体的字段是可导出的，以便正确编码和解码。
老 Java 初入 Go，不喜轻喷～～