这是我能想到的一个好办法，不知道是否合适，欢迎交流。

package main

import (
    "fmt"
    "log"
)

type Base struct{ ID string }

func (b Base) GetBase() Base {
    return b
}

type RecordA struct {
    Base
    A string
}
type RecordB struct {
    Base
    B string
}

type RecordC struct {
    Base
    C string
}

type RecordD struct {
    D string
}

func (r RecordD) GetBase() Base {
    return Base{ID: r.D}
}

type baseGetter interface {
    GetBase() Base
}

func ToBaseSlice(arg any) ([]Base, error) {
    switch v := arg.(type) {
    case []any:
        var out []Base
        for _, i := range v {
            if g, ok := i.(baseGetter); ok {
                out = append(out, g.GetBase())
            }
        }
        if len(out) == 0 {
            return nil, fmt.Errorf("no element can be convert to Base")
        }
        return out, nil
    case baseGetter:
        return []Base{v.GetBase()}, nil
    }
    return nil, fmt.Errorf("can not convert to []Base")
}

func main() {
    out, err := ToBaseSlice([]any{
        RecordA{Base: Base{ID: "A"}},
        RecordB{Base: Base{ID: "B"}},
        RecordC{Base: Base{ID: "C"}},
        RecordD{D: "D"},
    })
    if err != nil {
        log.Println(err)
        return
    }
    log.Println(out)
}

字符串