Go语言中函数返回类型与interface{}的兼容性及泛型应用

package main

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

// MyType 示例结构体
type MyType struct {
    SomeField    string
    AnotherField string
}

// readFile 函数，期望一个返回 interface{} 的 transform 函数
func readFile(filename string, transform func(string) interface{}) (list []interface{}) {
    rawBytes, err := ioutil.ReadFile(filename)
    if err != nil {
        // 在实际应用中，通常应该返回错误而不是 log.Fatal
        log.Fatalf("Error reading file: %v", 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
}

// transform 函数，返回 *MyType
func transform(line string) *MyType {
    fields := strings.Split(line, "\t")
    if len(fields) < 2 {
        // 处理格式错误或返回 nil，这里简化处理
        return nil
    }
    // 注意：这里需要初始化 MyType 实例
    myObject := &MyType{
        SomeField:    fields[0],
        AnotherField: fields[1],
    }
    return myObject
}

func main() {
    // 假设有一个名为 "data.txt" 的文件，内容如下：
    // field1_value1\tfield2_value1
    // field1_value2\tfield2_value2

    // 尝试调用 readFile
    // list := readFile("data.txt", transform) // 这会导致编译错误
    // fmt.Println(list)
}

// transform 函数，现在返回 interface{}
func transformWithInterfaceReturn(line string) interface{} {
    fields := strings.Split(line, "\t")
    if len(fields) < 2 {
        return nil // 或返回特定的错误对象
    }
    myObject := &MyType{
        SomeField:    fields[0],
        AnotherField: fields[1],
    }
    return myObject // *MyType 会自动转换为 interface{}
}

func main() {
    // ... (readFile 和 MyType 定义同上) ...

    // 使用修改签名的 transform 函数
    list := readFile("data.txt", transformWithInterfaceReturn)
    fmt.Println("Solution 1 (Direct Signature Change):")
    for _, item := range list {
        // 在这里，我们需要进行类型断言才能访问 MyType 的字段
        if obj, ok := item.(*MyType); ok {
            fmt.Printf("  MyType: SomeField=%s, AnotherField=%s\n", obj.SomeField, obj.AnotherField)
        } else {
            fmt.Printf("  Unexpected type: %T\n", item)
        }
    }
}

// transform 函数保持原始签名，返回 *MyType
// func transform(line string) *MyType { ... } // 同上

func main() {
    // ... (readFile 和 MyType 定义同上) ...

    // 使用匿名函数包装原始的 transform
    wrappedTransform := func(line string) interface{} {
        return transform(line) // transform 返回 *MyType，这里会自动转换为 interface{}
    }

    list := readFile("data.txt", wrappedTransform)
    fmt.Println("\nSolution 2 (Wrapper Function):")
    for _, item := range list {
        if obj, ok := item.(*MyType); ok {
            fmt.Printf("  MyType: SomeField=%s, AnotherField=%s\n", obj.SomeField, obj.AnotherField)
        }
    }
}

package main

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

// MyType 示例结构体
type MyType struct {
    SomeField    string
    AnotherField string
}

// transform 函数保持原始签名，返回 *MyType
func transform(line string) *MyType {
    fields := strings.Split(line, "\t")
    if len(fields) < 2 {
        return nil // 简化处理，实际中可能返回错误或默认值
    }
    myObject := &MyType{
        SomeField:    fields[0],
        AnotherField: fields[1],
    }
    return myObject
}

// GenericReadFile 泛型版本的 readFile 函数
// T 是一个类型参数，any 表示 T 可以是任何类型
func GenericReadFile[T any](filename string, transformFunc func(string) T) ([]T, error) {
    rawBytes, err := ioutil.ReadFile(filename)
    if err != nil {
        return nil, fmt.Errorf("error reading file %s: %w", filename, err)
    }

    var list []T
    lines := strings.Split(string(rawBytes), "\n")
    for _, line := range lines {
        if strings.TrimSpace(line) == "" {
            continue
        }
        t := transformFunc(line)
        list = append(list, t)
    }
    return list, nil
}

func main() {
    // 假设有一个名为 "data.txt" 的文件，内容如下：
    // field1_value1\tfield2_value1
    // field1_value2\tfield2_value2

    // 使用泛型版本的 GenericReadFile
    // 编译器会根据传入的 transform 函数自动推断 T 为 *MyType
    myObjects, err := GenericReadFile("data.txt", transform)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Println("\nSolution 3 (Go Generics):")
    for _, obj := range myObjects {
        // 现在 obj 的类型就是 *MyType，无需类型断言
        if obj != nil { // 检查是否为 nil，因为 transform 可能返回 nil
            fmt.Printf("  MyType: SomeField=%s, AnotherField=%s\n", obj.SomeField, obj.AnotherField)
        } else {
            fmt.Println("  Skipped nil object")
        }
    }
}