Go语言知识点汇总

前言

这里只是简单列出GO语言的知识点

---

一、基础语法

1.1 程序结构

package main  // 包声明

import "fmt"  // 导入语句

func main() { // 主函数
    fmt.Println("Hello, 世界！") // 输出语句
}

1.2 变量与常量

var name string = "Go"  // 显式类型声明
var age = 10            // 类型推断
height := 1.75          // 短变量声明（函数内）

const PI = 3.14         // 常量
const (
    StatusOK = 200
    NotFound = 404
)

1.3 基本数据类型

类型	说明	示例
bool	布尔值	true, false
string	字符串	"Go"
int int8-int64	整型	42
uint uint8-uint64	无符号整型	255
float32 float64	浮点型	3.14
complex64 complex128	复数	1+2i
byte	uint8别名	0xFF
rune	int32别名(Unicode)	'中'

---

二、运算符

2.1 算术运算符

+ - * / % ++ --

2.2 关系运算符

== != > < >= <=

2.3 逻辑运算符

&& || !

2.4 位运算符

& | ^ &^ << >>

2.5 赋值运算符

= += -= *= /= %= <<= >>= &= ^= |=

2.6 其他运算符

&  // 取地址
*  // 指针解引用
<- // 通道操作

---

三、流程控制

3.1 条件语句

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

switch os := runtime.GOOS; os {
case "darwin":
    fmt.Println("macOS")
case "linux":
    fmt.Println("Linux")
default:
    fmt.Printf("%s.\n", os)
}

3.2 循环结构

// 只有for循环
for i := 0; i < 10; i++ {
    // ...
}

// while形式
for x < 100 {
    // ...
}

// 无限循环
for {
    // ...
    break // 退出循环
}

// range迭代
for idx, val := range slice {
    // ...
}

---

四、函数

4.1 函数定义

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

// 多返回值
func swap(x, y string) (string, string) {
    return y, x
}

// 命名返回值
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return // 裸返回
}

4.2 高阶函数

// 函数作为参数
func compute(fn func(float64, float64) float64) float64 {
    return fn(3, 4)
}

// 闭包
func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

---

五、复合数据类型

5.1 数组与切片

var a [3]int           // 数组
b := [...]int{1, 2, 3} // 数组自动长度推断

s := []int{1, 2, 3}    // 切片
s = append(s, 4)       // 追加元素
sub := s[1:3]          // 子切片

5.2 映射(Map)

m := make(map[string]int)
m["key"] = 42
delete(m, "key")
val, ok := m["key"] // 检查存在性

5.3 结构体

type Vertex struct {
    X, Y float64
}

v := Vertex{1, 2}
v.X = 4
p := &v
p.Y = 8 // 隐式解引用

---

六、方法与接口

6.1 方法

// 值接收者
func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

// 指针接收者
func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}

6.2 接口

type Abser interface {
    Abs() float64
}

var a Abser
a = Vertex{3, 4} // 实现接口
fmt.Println(a.Abs())

6.3 类型断言与类型开关

var i interface{} = "hello"

s := i.(string)   // 类型断言
s, ok := i.(string)

switch v := i.(type) { // 类型开关
case int:
    // ...
case string:
    // ...
default:
    // ...
}

---

七、并发编程

7.1 Goroutine

go say("world") // 启动goroutine
say("hello")

7.2 Channel

ch := make(chan int) // 无缓冲通道
buffered := make(chan int, 100) // 缓冲通道

ch <- 42    // 发送
v := <-ch   // 接收

close(ch)   // 关闭通道

7.3 Select

select {
case msg1 := <-ch1:
    fmt.Println(msg1)
case msg2 := <-ch2:
    fmt.Println(msg2)
case <-time.After(time.Second):
    fmt.Println("timeout")
default:
    fmt.Println("no activity")
}

---

八、错误处理

8.1 错误类型

func doSomething() error {
    return errors.New("something went wrong")
}

if err := doSomething(); err != nil {
    log.Fatal(err)
}

8.2 自定义错误

type MyError struct {
    When time.Time
    What string
}

func (e *MyError) Error() string {
    return fmt.Sprintf("at %v, %s", e.When, e.What)
}

---

九、标准库常用包

包名	用途
fmt	格式化I/O
os	操作系统接口
io	基本I/O接口
bufio	缓冲I/O
strconv	字符串转换
strings	字符串操作
bytes	字节操作
sort	排序
encoding/json	JSON处理
net/http	HTTP协议
sync	同步原语
time	时间处理
testing	测试支持

---

十、最佳实践

1. 遵循Go代码风格（gofmt）
2. 使用短变量声明（函数内）
3. 错误处理而非异常
4. 优先组合而非继承
5. 使用接口解耦
6. 避免全局变量
7. 并发安全设计
8. 编写单元测试（go test）
9. 文档注释（godoc）
10. 保持简单和可读性
    注：本文档基于Go 1.18+版本，部分特性如泛型需要较新版本支持。

---