下面是一份系统深入的 Go 语言核心解析：函数（Function）、结构体（Struct）、接口（Interface）。这些是 Go 最重要的三大语言机制，理解透基本就掌握了 Go 的设计思想。
Go 语言核心：函数、结构体与接口深度解析
一、函数（Function）
Go 是一种**函数一等公民（First-class Function）**的语言。
函数可以：
- 作为变量
- 作为参数
- 作为返回值
- 形成闭包
1 基本函数定义
func add(a int, b int) int {
return a + b
}
简写：
func add(a, b int) int {
return a + b
}
调用：
result := add(3, 5)
2 多返回值（Go 特色）
Go 支持返回多个值，这是 Go 非常重要的设计。
func divide(a, b int) (int, int) {
return a / b, a % b
}
调用：
q, r := divide(10, 3)
输出：
q = 3
r = 1
3 命名返回值
func calc(a, b int) (sum int, diff int) {
sum = a + b
diff = a - b
return
}
特点：
- 自动初始化
- return 可以省略变量
4 错误处理模式
Go 的标准错误模式：
func sqrt(x float64) (float64, error) {
if x < 0 {
return 0, errors.New("negative number")
}
return math.Sqrt(x), nil
}
调用：
result, err := sqrt(-1)
if err != nil {
fmt.Println(err)
}
Go 不使用异常，而是显式 error。
5 可变参数
func sum(nums ...int) int {
total := 0
for _, v := range nums {
total += v
}
return total
}
调用：
sum(1,2,3,4)
6 匿名函数
func() {
fmt.Println("hello")
}()
赋值给变量：
f := func(a int) int {
return a * 2
}
7 闭包（Closure）
闭包 = 函数 + 外部变量
func counter() func() int {
i := 0
return func() int {
i++
return i
}
}
调用：
c := counter()
fmt.Println(c()) //1
fmt.Println(c()) //2
fmt.Println(c()) //3
二、结构体（Struct）
结构体是 Go 中最核心的数据结构。
类似：
- Java class
- C struct
但 Go 结构体没有继承。
1 定义结构体
type Person struct {
Name string
Age int
}
2 创建结构体
方式1：
p := Person{
Name: "Tom",
Age: 20,
}
方式2：
p := Person{"Tom", 20}
方式3：
p := new(Person)
p.Name = "Tom"
3 结构体指针
Go 推荐使用 指针传递。
p := &Person{
Name: "Tom",
Age: 20,
}
访问：
p.Name
Go 自动解引用。
4 结构体方法
给结构体绑定方法：
func (p Person) SayHello() {
fmt.Println("Hello", p.Name)
}
调用：
p.SayHello()
5 指针接收者
func (p *Person) Grow() {
p.Age++
}
调用：
p.Grow()
为什么用指针？
优点：
1 避免拷贝
2 可以修改对象
3 性能更好
6 结构体嵌套（组合）
Go 用组合代替继承。
type Address struct {
City string
}
type User struct {
Name string
Address
}
使用：
u := User{
Name: "Tom",
Address: Address{
City: "Beijing",
},
}
fmt.Println(u.City)
三、接口（Interface）
接口是 Go 最核心的设计哲学。
Go 接口特点：
隐式实现
不像 Java：
class Dog implements Animal
Go 不需要写 implements。
1 定义接口
type Animal interface {
Speak() string
}
2 实现接口
type Dog struct{}
func (d Dog) Speak() string {
return "wang"
}
Dog 自动实现 Animal。
3 使用接口
func makeSound(a Animal) {
fmt.Println(a.Speak())
}
dog := Dog{}
makeSound(dog)
输出：
wang
4 多态
type Cat struct{}
func (c Cat) Speak() string {
return "miao"
}
使用：
animals := []Animal{
Dog{},
Cat{},
}
for _, a := range animals {
fmt.Println(a.Speak())
}
输出：
wang
miao
5 空接口（any）
空接口可以表示任何类型。
var x interface{}
Go1.18 之后：
var x any
例子：
func print(v any) {
fmt.Println(v)
}
6 类型断言
var i interface{} = "hello"
s := i.(string)
安全写法：
s, ok := i.(string)
if ok {
fmt.Println(s)
}
四、接口设计原则（Go 精髓）
Go 提倡：
小接口原则
例子：
type Reader interface {
Read(p []byte) (n int, err error)
}
来源：Go Project 标准库。
典型接口：
type Writer interface {
Write(p []byte) (n int, err error)
}
组合接口：
type ReadWriter interface {
Reader
Writer
}
五、接口 + 结构体 = Go 面向对象
Go 没有：
- class
- 继承
- 泛型（早期）
但通过：
struct + method + interface
实现面向对象。
例子：
type Shape interface {
Area() float64
}
type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
六、真实 Go 项目架构模式
典型 Go 项目结构：
service
├── interface
├── implementation
示例：
接口定义：
type UserService interface {
GetUser(id int) User
}
实现：
type UserServiceImpl struct{}
func (s UserServiceImpl) GetUser(id int) User {
return User{ID: id}
}
七、Go 设计哲学总结
Go 核心思想：
1 简单
没有复杂 OOP
2 组合优于继承
struct embedding
3 接口解耦
面向接口编程
4 显式错误处理
if err != nil
八、三者关系总结
函数
↓
实现逻辑
结构体
↓
组织数据
接口
↓
抽象行为
整体结构：
interface
↑
struct + method
↑
function
如果你需要，我还可以给你一份 Go 高级进阶系列（非常硬核）：
- Go 并发模型：Goroutine + Channel
- Go 内存模型
- Go GC 原理
- Go runtime 调度器（GMP）
- Go interface 底层实现
- Go escape analysis
- Go 面试 500 题
我也可以帮你整理一份 《Go 核心原理 10 万字深度版》（非常适合面试 + 进阶）。
