TeamClass_MD/Class2 Go的基本语法.md at c318c00772146ad5a0890c1daa0779fb7e2187e8

2025-03-19 15:57:44 +08:00

5.0 KiB

Raw Blame History

1. 基础结构

package main  // 包声明（必须）
import "fmt" // 导入包

func main() { // 主函数（程序入口）
    fmt.Println("Hello, World!")
}

2. 变量与常量

变量声明

var a int = 10        // 显式类型
var b = 20            // 类型推断
c := 30               // 短声明（函数内使用）
var d, e int = 1, 2   // 多变量声明

常量

const Pi = 3.14
const (
    A = 1
    B = 2
)

着重强调：开头是大写的是Public！

3. 基本数据类型

基本类型

int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
float32, float64
bool
string
byte (等同于 uint8)
rune (等同于 int32, 表示 Unicode 字符)

复合类型

var arr [3]int                   // 数组（固定长度）
slice := []int{1, 2, 3}          // 切片（动态数组）
m := map[string]int{"key": 1}    // 映射（字典）
type Person struct { Name string } // 结构体

4. 控制结构

条件语句

if x > 0 {
    // ...
} else if x == 0 {
    // ...
} else {
    // ...
}

循环

for i := 0; i < 10; i++ { ... }   // 传统 for 循环
for i < 10 { ... }                // 类似 while
for index, value := range slice { ... } // 遍历切片/数组/map

Switch

switch x {
case 1:
    // ...
case 2, 3:  // 多值匹配
    // ...
default:
    // ...
}

特点:不需要break！

5. 函数

基本函数

func add(a int, b int) int {
    return a + b
}

多返回值

func swap(a, b int) (int, int) {
    return b, a
}

命名返回值

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return // 隐式返回 x, y
}

匿名函数与闭包（即函数内套函数）

func() {
    fmt.Println("Anonymous function")
}()

6. 指针与结构体

指针

var p *int
x := 10
p = &x
*p = 20 // 修改 x 的值

特点:
- Go 的指针不支持算术运算，避免了内存越界和非法访问的风险，同时通过垃圾回收机制自动管理内存，减少了内存泄漏的可能性。
- Go 的指针类型严格区分，空指针用 nil 表示，解引用空指针会触发 panic，不支持指针算术运算和强制类型转换。

结构体与方法

type Circle struct {
    Radius float64
}

// 方法（值接收者）
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

// 方法（指针接收者）
func (c *Circle) Scale(factor float64) {
    c.Radius *= factor
}

7. 接口与错误处理

接口

type Shape interface {
    Area() float64
}

// 隐式实现接口
func (c Circle) Area() float64 { ... }

错误处理

func readFile() ([]byte, error) {
    data, err := os.ReadFile("file.txt")
    if err != nil {
        return nil, err
    }
    return data, nil
}

// 调用
data, err := readFile()
if err != nil {
    log.Fatal(err)
}

Panic & Recover

func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()
    panic("Something went wrong!")
}

8. 并发编程

Goroutine

go func() {
    fmt.Println("Running in goroutine")
}()

Channel（数据通道）

ch := make(chan int)
go func() { ch <- 1 }() // 发送数据
value := <-ch           // 接收数据

Select（主要用于事件驱动）

select {
case msg1 := <-ch1:
    fmt.Println(msg1)
case msg2 := <-ch2:
    fmt.Println(msg2)
case <-time.After(1 * time.Second):
    fmt.Println("Timeout")
}

9. 包与模块

创建模块
```
go mod init xx
```

导入包

import (
    "fmt"
    "math/rand"
    "github.com/user/package"
)

10. 其他特性

Defer
defer 是 Go 语言中的一个关键字，用于延迟执行一个函数调用。被 defer 修饰的函数调用会推迟到当前函数返回之前执行，无论当前函数是正常返回还是由于错误（如 panic）提前返回。defer 的主要用途是确保某些操作（如资源释放、清理工作等）一定会被执行，避免遗漏。
```
func readFile() {
    file, _ := os.Open("file.txt")
    defer file.Close() // 函数返回前执行
    // ...
}
```

JSON 处理

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}
data, _ := json.Marshal(user) //序列化

常用内置函数

len()：获取长度
cap()：切片容量
make()：创建切片/map/channel
append()：切片追加元素

5.0 KiB Raw Blame History Unescape Escape