Go 语言入门指南：基础语法2
1. 函数
函数是可重用的代码块，用于实现特定的功能。Go 语言支持普通函数、匿名函数和闭包。
代码如下：
package main
import "fmt"
func max(n1, n2 int) int {
if n1 > n2 {
return n1
}
return n2
}
func main() {
fmt.Println(max(1, 10)) // 10
fmt.Println(max(-1, -2)) // -1
}
2. 函数作为参数
函数可以作为参数传递。
代码如下
package main
import "fmt"
func test(fn func() int) int {
return fn()
}
func main() {
result := test(func() int { return 100 })
fmt.Println(result) // 100
}
3. 函数返回值
Go 语言支持多个返回值。
代码如下：
package main
import "fmt"
func sum(a, b int) (int, int) {
return a + b, a - b
}
func main() {
a, b := sum(5, 3)
fmt.Println(a, b) // 8 2
}
4. 匿名函数
匿名函数是没有名字的函数，可以作为值使用。
代码如下：
package main
import "fmt"
func main() {
getSqrt := func(a float64) float64 {
return a * a
}
fmt.Println(getSqrt(4)) // 16
}
5. 闭包
闭包是函数和引用其外部变量的环境。
代码如下：
package main
import "fmt"
func counter() func() int {
i := 0
return func() int {
i++
return i
}
}
func main() {
next := counter()
fmt.Println(next()) // 1
fmt.Println(next()) // 2
}
6. 延迟调用
defer 语句用于延迟执行，通常用于资源清理。
代码如下：
package main
import "fmt"
func main() {
defer fmt.Println("World")
fmt.Println("Hello") // 输出: Hello
// 输出: World 在 main 结束时执行
}
7. 异常处理
Go 使用 panic 和 recover 处理异常。
代码如下：
package main
import "fmt"
func main() {
defer func() {
if err := recover(); err != nil {
fmt.Println("Recovered from:", err)
}
}()
panic("This is a panic error!")
fmt.Println("This line will not be executed.")
}
8. 使用 error 类型
Go 语言使用 error 类型来表示可恢复的错误。
代码如下：
package main
import (
"errors"
"fmt"
)
var ErrDivByZero = errors.New("division by zero")
func div(x, y int) (int, error) {
if y == 0 {
return 0, ErrDivByZero
}
return x / y, nil
}
func main() {
if result, err := div(10, 0); err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
}
总结
- 使用
panic：用于不可恢复的错误，如程序逻辑错误。 - 使用
error：用于可恢复的错误，允许调用者处理错误。
在 Go 语言中，结构体是一种非常重要的复合数据类型，它允许你将多个字段组合在一起，从而创建更复杂的数据模型。以下是对结构体及其相关概念的简要介绍和示例。
9. 结构体
结构体是由零个或多个字段组成的复合类型。每个字段都有自己的类型和值。
代码如下
package main
import "fmt"
type Point struct {
X int
Y int
}
func main() {
p := Point{X: 1, Y: 2}
fmt.Printf("Point: %+v\n", p)
}
9.1 实例化
实例化结构体是指根据结构体定义创建一个具体的结构体对象。
基本实例化
package main
import "fmt"
type Point struct {
X int
Y int
}
func main() {
var p Point // 默认值为零值
fmt.Printf("X: %d, Y: %d\n", p.X, p.Y) // 输出: X: 0, Y: 0
}
使用字面量实例化
package main
import "fmt"
type Point struct {
X int
Y int
}
func main() {
p := Point{X: 1, Y: 2}
fmt.Printf("X: %d, Y: %d\n", p.X, p.Y) // 输出: X: 1, Y: 2
}
使用 new 关键字
package main
import "fmt"
type Player struct {
Name string
HealthPoint int
MagicPoint int
}
func main() {
tank := new(Player) // 创建指向 Player 的指针
tank.Name = "Warrior"
tank.HealthPoint = 300
fmt.Printf("Player: %+v\n", *tank) // 输出: Player: {Name:Warrior HealthPoint:300 MagicPoint:0}
}
9.2 匿名结构体
匿名结构体没有类型名称，可以直接定义和使用。
代码如下：
package main
import "fmt"
// 打印消息类型
func printMsgType(msg *struct {
id int
data string
}) {
fmt.Printf("Type: %T, Value: %+v\n", msg, msg)
}
func main() {
// 实例化一个匿名结构体
msg := &struct {
id int
data string
}{
id: 1024,
data: "hello",
}
printMsgType(msg) // 输出: Type: &struct { id int; data string }, Value: &{id:1024 data:hello}
}
