Go语言中将具体类型函数转换为接口函数参数的策略与泛型实践

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "strings"
)

// readFile 函数：读取文件，并使用 transform 函数处理每一行
func readFile(filename string, transform func(string) interface{}) (list []interface{}, err error) {
    rawBytes, err := ioutil.ReadFile(filename)
    if err != nil {
        return nil, fmt.Errorf("读取文件失败: %w", err)
    }

    lines := strings.Split(string(rawBytes), "\n")
    for _, line := range lines {
        if strings.TrimSpace(line) == "" { // 忽略空行
            continue
        }
        t := transform(line)
        list = append(list, t)
    }
    return list, nil
}

// 假设我们有一个 MyType 类型
type MyType struct {
    SomeField    string
    AnotherField string
}

// transformMyType 函数：将字符串行转换为 *MyType
func transformMyType(line string) *MyType {
    fields := strings.Split(line, "\t")
    if len(fields) < 2 {
        log.Printf("警告: 行格式不正确，跳过: %s", line)
        return nil
    }
    return &MyType{
        SomeField:    fields[0],
        AnotherField: fields[1],
    }
}

func main() {
    // 尝试调用 readFile
    // list, err := readFile("path/to/file.txt", transformMyType) // 这会产生编译错误
    // cannot use transformMyType (type func(string) *MyType) as type func(string) interface {} in argument to readFile
    fmt.Println("编译错误示例已注释")
}

// transformMyTypeV1 函数：将字符串行转换为 interface{}
func transformMyTypeV1(line string) interface{} {
    fields := strings.Split(line, "\t")
    if len(fields) < 2 {
        log.Printf("警告: 行格式不正确，跳过: %s", line)
        return nil // 返回 nil 接口值
    }
    return &MyType{ // *MyType 会被隐式转换为 interface{}
        SomeField:    fields[0],
        AnotherField: fields[1],
    }
}

func main() {
    // 创建一个模拟文件
    err := ioutil.WriteFile("test.txt", []byte("value1\tvalueA\nvalue2\tvalueB\n"), 0644)
    if err != nil {
        log.Fatal(err)
    }

    list, err := readFile("test.txt", transformMyTypeV1)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("使用 interface{} 方案处理结果:")
    for i, item := range list {
        // 此时 item 是 interface{} 类型，需要进行类型断言才能访问其具体字段
        if myObj, ok := item.(*MyType); ok {
            fmt.Printf("Item %d: SomeField=%s, AnotherField=%s\n", i, myObj.SomeField, myObj.AnotherField)
        } else {
            fmt.Printf("Item %d: 类型错误或为 nil\n", i)
        }
    }
}

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "strings"
)

// MyType 类型定义
type MyType struct {
    SomeField    string
    AnotherField string
}

// readFileGeneric 函数：使用泛型处理文件和转换
// T 是一个类型参数，可以是任何类型（any 是 interface{} 的别名）
func readFileGeneric[T any](filename string, transform func(string) T) ([]T, error) {
    rawBytes, err := ioutil.ReadFile(filename)
    if err != nil {
        return nil, fmt.Errorf("读取文件失败: %w", err)
    }

    var list []T // 列表的类型现在是 []T，而不是 []interface{}
    lines := strings.Split(string(rawBytes), "\n")
    for _, line := range lines {
        if strings.TrimSpace(line) == "" { // 忽略空行
            continue
        }
        t := transform(line)
        list = append(list, t)
    }
    return list, nil
}

// transformMyTypeGeneric 函数：保持其具体返回类型 *MyType
func transformMyTypeGeneric(line string) *MyType {
    fields := strings.Split(line, "\t")
    if len(fields) < 2 {
        log.Printf("警告: 行格式不正确，跳过: %s", line)
        return nil
    }
    return &MyType{
        SomeField:    fields[0],
        AnotherField: fields[1],
    }
}

func main() {
    // 创建一个模拟文件
    err := ioutil.WriteFile("test_generic.txt", []byte("value1\tvalueA\nvalue2\tvalueB\n"), 0644)
    if err != nil {
        log.Fatal(err)
    }

    // 调用泛型版本的 readFileGeneric
    // 此时，Go编译器会推断 T 为 *MyType
    myObjects, err := readFileGeneric("test_generic.txt", transformMyTypeGeneric)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("\n使用泛型方案处理结果:")
    for i, obj := range myObjects {
        // obj 现在直接就是 *MyType 类型，无需类型断言
        fmt.Printf("Item %d: SomeField=%s, AnotherField=%s\n", i, obj.SomeField, obj.AnotherField)
    }

    // 尝试传入一个返回 int 的 transform 函数
    transformToInt := func(line string) int {
        i, _ := fmt.Sscanf(line, "%d", &i)
        return i
    }
    err = ioutil.WriteFile("test_int_generic.txt", []byte("10\n20\n30\n"), 0644)
    if err != nil {
        log.Fatal(err)
    }
    intList, err := readFileGeneric("test_int_generic.txt", transformToInt)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("\n使用泛型方案处理整数结果:")
    for i, val := range intList {
        fmt.Printf("Item %d: %d\n", i, val) // val 直接就是 int 类型
    }
}