Golang中如何将结构体字段子集作为嵌套结果结构体

Golang中如何将结构体字段子集作为嵌套结果结构体 大家好，

我遇到一个场景，我有两个结构体，我知道可以像下面这样嵌套它们：

type student struct {
	id      int
	name    string
	branch  string
	contact string
}

type book struct {
	id      int
	name    string
	author  string
	release time.Time
}

type libraryNested struct {
	member student
	rented book
}

但是，如果在嵌套结构体中，我对父结构体的所有字段并不都感兴趣，该怎么办呢？

有没有一种方法可以只从父结构体中获取一个字段子集，然后将其放在 libraryNested 结构体下？

我感兴趣的字段如下所示，但我不想仅仅为了拥有一个能容纳数据的新结构体，而重新声明已经声明过的内容。

type libraryWithoutNest struct {
	studentid   int
	studentName string
	bookid      int
	bookName    string
}

我还想知道这样做是否是一种好的实践。


更多关于Golang中如何将结构体字段子集作为嵌套结果结构体的实战教程也可以访问 https://www.itying.com/category-94-b0.html

5 回复

谢谢 @lutzhorn

更多关于Golang中如何将结构体字段子集作为嵌套结果结构体的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


如果你需要一个仅包含部分字段的类型，你必须自行定义它。正如你所观察到的，类型组合会导致新类型拥有所有嵌入类型的字段。

是的，这存在重复。不，据我所知没有方法可以避免这种情况。

你的 libraryNested 结构体是一个完整的 student 和 book 的组合，它拥有一个学生并且拥有一本书。这真的是你在这里想要建模的吗？

也许 libraryNested 更适合被称为 studentBookRental，一个引用学生和书籍的结构体。

type studentBookRental struct {
    studentId int
    bookId    int
}

可以把它想象成关系数据库中的一个连接表。

你好 @lutzhorn，感谢你的回复……

为了让你了解一些背景信息，我实际上有两个表，它们通过一个ID相关联，我正在构建一个内连接查询来连接这两个表。

结构体 student 和 library 是我的模型，现在我正在执行一个关联这两个表的查询，而我只需要 student 模型和 book 模型提供的字段的一个子集……那么，将结构体绑定到我从内连接查询得到的结果值的最佳方法是什么？

在Golang中，你可以通过结构体嵌入和匿名字段来实现字段子集的嵌套。以下是几种专业解决方案：

方法1：使用结构体嵌入和自定义类型

package main

import (
	"fmt"
	"time"
)

type student struct {
	id      int
	name    string
	branch  string
	contact string
}

type book struct {
	id      int
	name    string
	author  string
	release time.Time
}

// 定义只包含所需字段的子集结构体
type studentSubset struct {
	id   int
	name string
}

type bookSubset struct {
	id   int
	name string
}

// 使用嵌入
type libraryNested struct {
	studentSubset
	bookSubset
}

func main() {
	s := student{id: 1, name: "Alice", branch: "CS", contact: "alice@example.com"}
	b := book{id: 101, name: "Go Programming", author: "Author", release: time.Now()}
	
	lib := libraryNested{
		studentSubset: studentSubset{id: s.id, name: s.name},
		bookSubset:    bookSubset{id: b.id, name: b.name},
	}
	
	fmt.Printf("Student ID: %d, Name: %s\n", lib.id, lib.name)
	fmt.Printf("Book ID: %d, Name: %s\n", lib.bookSubset.id, lib.bookSubset.name)
}

方法2：使用组合而非嵌入

type libraryComposed struct {
	Student studentSubset
	Book    bookSubset
}

func main() {
	s := student{id: 2, name: "Bob", branch: "EE", contact: "bob@example.com"}
	b := book{id: 102, name: "Clean Code", author: "Robert Martin", release: time.Now()}
	
	lib := libraryComposed{
		Student: studentSubset{id: s.id, name: s.name},
		Book:    bookSubset{id: b.id, name: b.name},
	}
	
	fmt.Printf("Student: %+v\n", lib.Student)
	fmt.Printf("Book: %+v\n", lib.Book)
}

方法3：使用工厂函数

func NewLibraryNested(s student, b book) libraryNested {
	return libraryNested{
		studentSubset: studentSubset{id: s.id, name: s.name},
		bookSubset:    bookSubset{id: b.id, name: b.name},
	}
}

func main() {
	s := student{id: 3, name: "Charlie", branch: "ME", contact: "charlie@example.com"}
	b := book{id: 103, name: "Design Patterns", author: "GoF", release: time.Now()}
	
	lib := NewLibraryNested(s, b)
	fmt.Printf("%+v\n", lib)
}

方法4：使用接口实现字段投影

type StudentProjection interface {
	GetID() int
	GetName() string
}

type BookProjection interface {
	GetID() int
	GetName() string
}

type libraryProjected struct {
	StudentID   int
	StudentName string
	BookID      int
	BookName    string
}

func ProjectLibrary(s student, b book) libraryProjected {
	return libraryProjected{
		StudentID:   s.id,
		StudentName: s.name,
		BookID:      b.id,
		BookName:    b.name,
	}
}

关于实践建议

这种方法是良好的实践，特别是在以下场景：

  1. API响应中需要返回字段子集
  2. 数据库查询结果映射
  3. 减少数据传输大小
  4. 避免暴露敏感字段

关键优势包括：

  • 类型安全
  • 明确的字段边界
  • 更好的代码可维护性
  • 减少内存使用

这种方法符合Go语言的组合优于继承的设计哲学，并且在实际项目中广泛使用。

回到顶部