Go 语言核心：函数、结构体与接口详解 | 极客日志

Go / Golang

Go 语言核心：函数、结构体与接口详解

深入解析 Go 语言的三大核心特性：函数、结构体与接口。涵盖函数定义、多返回值、高阶函数、闭包及 defer 机制；结构体初始化、方法接收者、嵌套与深浅拷贝；接口定义、隐式实现、空接口及类型断言。通过实例展示三者如何联动构建高内聚系统，帮助开发者掌握 Go 编程精髓，编写优雅代码。

内存管理发布于 2026/3/27更新于 2026/4/162 浏览

Go 语言核心：函数、结构体与接口详解

Go 语言以简洁、高效著称，其设计哲学强调'少即是多'。在 Go 的编程实践中，函数是程序的执行单元，结构体是数据的组织载体，接口则是行为的抽象契约。三者相互配合，构建出高内聚、低耦合的软件系统。本文将从实战角度，深入解析这三大核心特性，并展示它们的联动关系，帮助你写出更优雅的 Go 代码。

一、函数 —— Go 程序的执行单元

函数是 Go 中最基本的代码块，支持多返回值、一等公民特性，是构建复杂逻辑的基石。

1.1 函数定义与参数传递

核心规则

使用 func 关键字声明，支持多返回值。
参数采用值传递：基础类型拷贝值，引用类型（切片、map、指针）拷贝指针，因此函数内修改引用类型会影响外部。
可变参数用 ...类型 声明，函数内表现为切片。

示例：多返回值与可变参数

package main
import (
	"errors"
	"fmt"
)

// 多返回值：返回和与错误（除零检查）
func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("除数不能为 0")
	}
	return a / b, nil
}

// 可变参数：计算任意数量整数的和
func sum(nums ...int) int {
	total := 0
	for _, v := range nums {
		total += v
	}
	return total
}

func main() {
	// 多返回值调用
	result, err := divide(10, 2)
	if err != nil {
		fmt.Println(, err)
	}  {
		fmt.Println(, result) 
	}
	
	fmt.Println(sum(, , )) 
	
	nums := []{, , }
	fmt.Println(sum(nums...)) 
}

极客日志微信公众号二维码

更多推荐文章

相关免费在线工具

Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online
Markdown转HTML
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。在线工具，Markdown转HTML在线工具，online
HTML转Markdown
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。在线工具，HTML转Markdown在线工具，online
JSON 压缩
通过删除不必要的空白来缩小和压缩JSON。在线工具，JSON 压缩在线工具，online
JSON美化和格式化
将JSON字符串修饰为友好的可读格式。在线工具，JSON美化和格式化在线工具，online

package main
import "fmt"

// 定义函数类型
type operation func(int, int)

// 高阶函数：接收函数作为参数
func calc(a, b int, op operation) int {
	return op(a, b)
}

func main() {
	// 将匿名函数赋值给变量
	add := func(x, y int) int { return x + y }
	sub := func(x, y int) int { return x - y }
	// 传入不同操作，复用 calc 逻辑
	fmt.Println(calc(10, 5, add)) // 输出：15
	fmt.Println(calc(10, 5, sub)) // 输出：5
	// 直接传入匿名函数
	fmt.Println(calc(10, 5, func(x, y int) int { return x * y })) // 输出：50
}

package main
import "fmt"

// 闭包：生成计数器
func counter() func() int {
	i := 0
	return func() int {
		i++
		return i
	}
}

func main() {
	// 创建两个独立计数器
	c1 := counter()
	c2 := counter()
	fmt.Println(c1()) // 输出：1
	fmt.Println(c1()) // 输出：2
	fmt.Println(c2()) // 输出：1 (独立状态)
}

package main
import "fmt"

func main() {
	// defer 示例
	x := 10
	defer fmt.Println("defer x =", x) // 此时 x=10，值已确定
	x = 20
	fmt.Println("main x =", x) // 先输出 main x = 20，然后输出 defer x = 10
}

package main
import "fmt"

var num = 10 // 包块

func main() {
	num := 20 // 函数块（屏蔽包块）
	fmt.Println(num) // 输出：20
	if true {
		num := 30 // 语句块（屏蔽函数块）
		fmt.Println(num) // 输出：30
	}
}

package main
import "fmt"

var cache = make(map[int]int)

func fib(n int) int {
	if n < 2 {
		return n
	}
	if val, ok := cache[n]; ok {
		return val
	}
	res := fib(n-1) + fib(n-2)
	cache[n] = res
	return res
}

func main() {
	for i := 0; i < 10; i++ {
		fmt.Printf("fib(%d) = %d\n", i, fib(i))
	}
}

package main
import "fmt"

// 定义 Person 结构体
type Person struct {
	Name string // 公有字段
	age  int    // 私有字段（仅包内可见）
}

func main() {
	// 1. 字面量初始化（键值对，推荐）
	p1 := Person{Name: "Alice", age: 30}
	fmt.Println(p1) // 输出：{Alice 30}
	// 2. 按顺序初始化（不推荐，易出错）
	p2 := Person{"Bob", 25}
	fmt.Println(p2)
	// 3. new 关键字，返回指针，字段为零值
	p3 := new(Person)
	p3.Name = "Charlie"
	fmt.Println(p3) // 输出：&{Charlie 0}
	// 4. 取地址初始化，常用
	p4 := &Person{Name: "David", age: 40}
	fmt.Println(p4) // 输出：&{David 40}
}

package main
import "fmt"

type Person struct {
	Name string
	age  int
}

// 值接收者：只读，不影响原对象
func (p Person) GetName() string {
	return p.Name
}

// 指针接收者：可修改字段
func (p *Person) SetName(newName string) {
	p.Name = newName
}

func main() {
	p := Person{Name: "Eve", age: 28}
	fmt.Println(p.GetName()) // 输出：Eve
	p.SetName("Evelyn")
	fmt.Println(p.GetName()) // 输出：Evelyn
}

package main
import "fmt"

// 父结构体
type Animal struct {
	Name string
	Age  int
}

// 子结构体，嵌入 Animal
type Cat struct {
	Animal // 匿名成员
	Color  string
}

// 构造函数（返回指针，避免拷贝）
func NewCat(name string, age int, color string) *Cat {
	return &Cat{
		Animal: Animal{Name: name, Age: age},
		Color:  color,
	}
}

func main() {
	// 使用构造函数创建实例
	cat := NewCat("Tom", 3, "black")
	// 可以直接访问 Animal 的字段（提升）
	fmt.Println(cat.Name) // 输出：Tom
	fmt.Println(cat.Age)  // 输出：3
	fmt.Println(cat.Color) // 输出：black
}

package main
import "fmt"

type Data struct {
	Nums []int
}

func main() {
	// 浅拷贝
	d1 := Data{Nums: []int{1, 2, 3}}
	d2 := d1
	d2.Nums[0] = 100
	fmt.Println(d1.Nums) // 输出：[100 2 3] (d1 也被修改)
	// 深拷贝（手动复制切片）
	d3 := Data{Nums: make([]int, len(d1.Nums))}
	copy(d3.Nums, d1.Nums)
	d3.Nums[1] = 200
	fmt.Println(d1.Nums) // 输出：[100 2 3] (未变)
	fmt.Println(d3.Nums) // 输出：[100 200 3]
}

package main
import "fmt"

// 定义 Speaker 接口
type Speaker interface {
	Speak() string
}

// Dog 类型
type Dog struct{}

func (d Dog) Speak() string {
	return "汪汪！"
}

// Cat 类型
type Cat struct{}

func (c Cat) Speak() string {
	return "喵喵～"
}

func main() {
	var s Speaker
	s = Dog{}
	fmt.Println(s.Speak()) // 输出：汪汪！
	s = Cat{}
	fmt.Println(s.Speak()) // 输出：喵喵～
	// 多态：传入不同实现
	animalSpeak(Dog{})
	animalSpeak(Cat{})
}

func animalSpeak(s Speaker) {
	fmt.Println("动物说:", s.Speak())
}

package main
import "fmt"

func printAny(v interface{}) {
	// type-switch 判断类型
	switch val := v.(type) {
	case int:
		fmt.Println("整数:", val)
	case string:
		fmt.Println("字符串:", val)
	default:
		fmt.Printf("未知类型：%T\n", val)
	}
}

func main() {
	printAny(42) // 输出：整数：42
	printAny("hello") // 输出：字符串：hello
	printAny(3.14) // 输出：未知类型：float64
	// 类型断言
	var x interface{} = "Golang"
	if s, ok := x.(string); ok {
		fmt.Println("断言成功:", s) // 输出：断言成功：Golang
	} else {
		fmt.Println("断言失败")
	}
}

package main
import "fmt"

// Person 结构体
type Person struct {
	Name string
	Age  int
}

// 实现 fmt.Stringer 接口（值接收者）
func (p Person) String() string {
	return fmt.Sprintf("Person(Name=%s, Age=%d)", p.Name, p.Age)
}

// 实现 fmt.GoStringer 接口（指针接收者，%#v 时调用）
func (p *Person) GoString() string {
	return fmt.Sprintf("&Person{Name:%q, Age:%d}", p.Name, p.Age)
}

func main() {
	p := Person{"Alice", 30}
	// 使用 String() 自定义输出
	fmt.Println(p) // 输出：Person(Name=Alice, Age=30)
	fmt.Printf("%v\n", p) // 输出：Person(Name=Alice, Age=30)
	// 使用 GoString()
	fmt.Printf("%#v\n", &p) // 输出：&Person{Name:"Alice", Age:30}
}

package main
import "fmt"

// 接口定义
type Speaker interface {
	Speak() string
}

// 结构体实现接口
type Dog struct {
	Name string
}

// 值接收者
func (d Dog) Speak() string {
	return fmt.Sprintf("%s 说：汪汪！", d.Name)
}

type Cat struct {
	Name string
}

// 指针接收者
func (c *Cat) Speak() string {
	return fmt.Sprintf("%s 说：喵喵～", c.Name)
}

// 高阶函数，接收接口类型
func PerformSpeak(s Speaker) {
	fmt.Println(s.Speak())
}

// 函数返回接口
func NewSpeaker(animal string, name string) Speaker {
	switch animal {
	case "dog":
		return Dog{Name: name} // Dog 值类型，也实现了接口
	case "cat":
		return &Cat{Name: name} // Cat 指针类型
	default:
		return nil
	}
}

func main() {
	// 1. 直接使用接口变量
	var s Speaker
	s = Dog{Name: "旺财"}
	PerformSpeak(s) // 输出：旺财 说：汪汪！
	s = &Cat{Name: "咪咪"}
	PerformSpeak(s) // 输出：咪咪 说：喵喵～
	// 2. 通过函数返回接口
	animal := NewSpeaker("dog", "小黑")
	PerformSpeak(animal) // 输出：小黑 说：汪汪！
	// 3. 方法作为函数值（方法表达式）
	dogMethod := Dog.Speak // 类型方法，接收 Dog 值
	fmt.Println(dogMethod(Dog{Name: "小白"})) // 输出：小白 说：汪汪！
	catMethod := (*Cat).Speak // 注意指针类型的方法表达式
	fmt.Println(catMethod(&Cat{Name: "小花"})) // 输出：小花 说：喵喵～
}