假设您有两个结构数据类型A和B。
如果您希望A和B都有一个名为F且类型为T的字段，则可以如下所示

type (
    A struct {
        F T
    }

    B struct {
        F T
    }
)

如果您希望只在源代码中的一个位置更改T类型，则可以如下抽象它

type (
    T = someType

    A struct {
        F T
    }

    B struct {
        F T
    }
)

如果您希望只在源代码中的一个位置更改F的名称，则可以这样抽象它

type (
    myField struct {
        F T
    }

    A struct {
        myField
    }

    B struct {
        myField
    }
)

如果您有多个要抽象的可解压缩字段，则必须像这样分别对它们进行抽象

type (
    myField1 struct {
        F1 T1
    }
    myField2 struct {
        F2 T2
    }
    
    A struct {
        myField1
        myField2
    }
    
    B struct {
        myField1
    }
)

不能嵌入单个字段。只能嵌入整个类型。
如果要嵌入单个字段，则需要创建仅包含该字段的新类型，然后嵌入该类型：

type R struct {
  R int64
}

type B struct {
  R
}

这是我现在最好的解决方案...

type A struct {
  R int64
  S int64
}

type B struct {
  R A
}

然后在实施过程中...

&B{
 R: &A{
   R,
   // S, - ideally we would not be able to pass in `S`
 }
}

我不喜欢这个解决方案，因为我们仍然可以传入S...

**更新：**根据@HymnsForDisco的答案，这可以编码为...

// A type definition could be used `type AR int64`,
//   instead of a type alias (below), but that would
//   require us to create and pass the `&AR{}` object,
//   to `&A{}` or `&B{}` for the `R` field.
type AR = int64

type A struct {
  R AR
  S int64
}

type B struct {
  R AR
}

并实现为...

&B{
  R,
}