如何动态创建少一个属性的结构体？如何复制泛型结构体并跳过指定属性？

Great question! Since you're working with an interface{} struct that has a known path field plus unknown additional fields, Go's reflect package is exactly the tool you need here. Let's break down solutions for both your closely linked questions.

1. Dynamically Creating a Struct with One Less Field #

If you need to generate a new struct type that excludes the path field entirely, you can use reflection to build the new struct definition on the fly and populate its values:

import (
    "fmt"
    "reflect"
)

func RemoveField(data interface{}, fieldToRemove string) (interface{}, error) {
    inputVal := reflect.ValueOf(data)
    // Validate we're working with a struct
    if inputVal.Kind() != reflect.Struct {
        return nil, fmt.Errorf("input must be a struct, got %s", inputVal.Kind())
    }
    inputType := inputVal.Type()

    // Gather all fields except the one we want to remove
    var retainedFields []reflect.StructField
    var retainedValues []reflect.Value

    for i := 0; i < inputType.NumField(); i++ {
        field := inputType.Field(i)
        if field.Name == fieldToRemove {
            continue // Skip the unwanted field
        }
        retainedFields = append(retainedFields, field)
        retainedValues = append(retainedValues, inputVal.Field(i))
    }

    // Create the new struct type
    newStructType := reflect.StructOf(retainedFields)
    // Initialize a new instance of this struct
    newStruct := reflect.New(newStructType).Elem()
    // Populate the new struct with values from the original
    for i := 0; i < newStruct.NumField(); i++ {
        newStruct.Field(i).Set(retainedValues[i])
    }

    return newStruct.Interface(), nil
}

Quick Usage Example: #

// Sample original struct
type OriginalData struct {
    Path  string
    ID    int
    Name  string
    Score float64
}

func main() {
    original := OriginalData{Path: "/api/v1", ID: 123, Name: "Alice", Score: 98.5}
    stripped, err := RemoveField(original, "Path")
    if err != nil {
        panic(err)
    }
    fmt.Printf("%+v\n", stripped)
    // Output: {ID:123 Name:Alice Score:98.5}
}

2. Copying a Generic Struct & Skipping a Known Field #

Since you mentioned the remaining fields map to one of 30 predefined struct types, you can simplify things by directly mapping valid fields to your target struct. This avoids creating a dynamic anonymous struct and gives you type safety:

// Example one of your 30 target structs
type UserData struct {
    ID    int
    Name  string
    Score float64
}

func MapToTargetStruct(data interface{}, target interface{}) error {
    inputVal := reflect.ValueOf(data)
    targetVal := reflect.ValueOf(target).Elem()

    // Validate inputs
    if inputVal.Kind() != reflect.Struct {
        return fmt.Errorf("input must be a struct")
    }
    if targetVal.Kind() != reflect.Struct {
        return fmt.Errorf("target must be a pointer to a struct")
    }

    inputType := inputVal.Type()

    for i := 0; i < inputType.NumField(); i++ {
        inputField := inputType.Field(i)
        if inputField.Name == "Path" {
            continue // Skip the path field
        }
        // Find matching field in target struct and set its value
        targetField := targetVal.FieldByName(inputField.Name)
        if targetField.IsValid() && targetField.CanSet() && targetField.Type() == inputVal.Field(i).Type() {
            targetField.Set(inputVal.Field(i))
        }
    }
    return nil
}

Quick Usage Example: #

func main() {
    original := OriginalData{Path: "/api/v1", ID: 123, Name: "Alice", Score: 98.5}
    var userData UserData
    err := MapToTargetStruct(original, &userData)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%+v\n", userData)
    // Output: {ID:123 Name:Alice Score:98.5}
}

Key Notes: #

• Both solutions require exported fields (fields starting with a capital letter) — Go reflection can't access unexported fields, so ensure Path and your other fields follow this rule.
• Use the first approach for truly unknown structs, and the second if you want type safety with your predefined 30 target struct types.

内容的提问来源于stack exchange，提问作者Michael Sorens