使用go-dry库实现DRY原则

DRY(Don’t Repeat Yourself)原则是软件开发中的重要原则，旨在减少代码重复。在Go语言中，我们可以使用go-dry库来帮助我们实现这一原则。

go-dry库简介

go-dry是一个实用的Go工具库，提供了一系列常用功能的实现，帮助我们避免重复编写相同的工具函数。它包含了字符串处理、文件操作、切片操作、网络工具等多种实用功能。

安装go-dry

go get github.com/ungerik/go-dry

主要功能和使用示例

1. 字符串处理

package main

import (
	"fmt"
	"github.com/ungerik/go-dry"
)

func main() {
	// 字符串截取
	str := "Hello, World!"
	sub := dry.StringCut(str, 7, 12)
	fmt.Println(sub) // 输出: World

	// 字符串填充
	padded := dry.StringPadLeft("42", "0", 5)
	fmt.Println(padded) // 输出: 00042

	// 字符串分割
	parts := dry.StringSplit("a,b,c", ",", 2)
	fmt.Println(parts) // 输出: [a b,c]
}

2. 文件操作

package main

import (
	"fmt"
	"github.com/ungerik/go-dry"
)

func main() {
	// 检查文件是否存在
	exists := dry.FileExists("test.txt")
	fmt.Println("File exists:", exists)

	// 读取文件内容
	content, err := dry.FileGetString("test.txt")
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Content:", content)
	}

	// 递归创建目录
	err = dry.MkdirAll("path/to/directory")
	if err != nil {
		fmt.Println("Error:", err)
	}
}

3. 切片操作

package main

import (
	"fmt"
	"github.com/ungerik/go-dry"
)

func main() {
	// 切片去重
	slice := []int{1, 2, 2, 3, 4, 4, 5}
	unique := dry.SliceUniqueInt(slice)
	fmt.Println(unique) // 输出: [1 2 3 4 5]

	// 切片过滤
	filtered := dry.SliceFilterInt(slice, func(x int) bool {
		return x%2 == 0
	})
	fmt.Println(filtered) // 输出: [2 2 4 4]

	// 切片映射
	mapped := dry.SliceMapIntToString(slice, func(x int) string {
		return fmt.Sprintf("num-%d", x)
	})
	fmt.Println(mapped) // 输出: [num-1 num-2 num-2 num-3 num-4 num-4 num-5]
}

4. 网络工具

package main

import (
	"fmt"
	"github.com/ungerik/go-dry"
)

func main() {
	// 获取本地IP地址
	ip, err := dry.LocalIPv4()
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Local IP:", ip)
	}

	// 检查端口是否可用
	available := dry.IsPortAvailable(8080)
	fmt.Println("Port 8080 available:", available)

	// 获取外网IP
	externalIP, err := dry.ExternalIPv4()
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("External IP:", externalIP)
	}
}

5. 其他实用功能

package main

import (
	"fmt"
	"github.com/ungerik/go-dry"
	"time"
)

func main() {
	// 生成随机字符串
	randomStr := dry.RandomHexString(16)
	fmt.Println("Random string:", randomStr)

	// 重试函数
	var result string
	err := dry.Retry(3, 1*time.Second, func() error {
		var err error
		result, err = someUnreliableFunction()
		return err
	})
	if err != nil {
		fmt.Println("Failed after retries:", err)
	} else {
		fmt.Println("Success:", result)
	}

	// 并行执行
	results := dry.Parallelize(
		func() interface{} { return task1() },
		func() interface{} { return task2() },
		func() interface{} { return task3() },
	)
	fmt.Println("Parallel results:", results)
}

func someUnreliableFunction() (string, error) {
	// 模拟可能失败的操作
	return "success", nil
}

func task1() interface{} { return "task1" }
func task2() interface{} { return "task2" }
func task3() interface{} { return "task3" }

自定义DRY工具

除了使用go-dry库，我们也可以创建自己的DRY工具集。例如：

package dry

import (
	"reflect"
)

// Contains 检查slice是否包含元素
func Contains(slice interface{}, elem interface{}) bool {
	v := reflect.ValueOf(slice)
	if v.Kind() != reflect.Slice {
		return false
	}
	
	for i := 0; i < v.Len(); i++ {
		if reflect.DeepEqual(v.Index(i).Interface(), elem) {
			return true
		}
	}
	return false
}

// MapKeys 获取map的所有key
func MapKeys(m interface{}) []interface{} {
	v := reflect.ValueOf(m)
	if v.Kind() != reflect.Map {
		return nil
	}
	
	keys := make([]interface{}, 0, v.Len())
	for _, key := range v.MapKeys() {
		keys = append(keys, key.Interface())
	}
	return keys
}

总结

go-dry库提供了许多实用的功能，可以帮助我们避免重复编写常见的工具代码。通过使用这些现成的工具函数，我们可以：

1. 减少代码重复
2. 提高开发效率
3. 保持代码一致性
4. 专注于业务逻辑而非基础设施代码

在实际项目中，我们可以结合go-dry和自定义的工具函数，构建适合自己项目的DRY工具集，从而编写更简洁、更易维护的代码。