Go 语言核心特性与实战速成指南

package main

import (
	"fmt"
	"os"
)

func main() {
	if len(os.Args) > 1 {
		fmt.Println("Hello World", os.Args[1])
	}
}

这段代码展示了包导入、入口函数 main、条件判断以及字符串拼接。运行 go run hello.go ZYF 将输出 Hello World ZYF。

（二）基本语法结构

1. 变量

Go 支持多种变量声明方式：

• 声明：var x int
• 类型推断：y := 5（短变量声明，仅限函数内）
• 多变量：var a, b, c int
• 零值：未初始化的变量会有默认值（数字为 0，布尔为 false，字符串为空）

斐波那契数列练习：

package variables

import "testing"

func TestFibList(t *testing.T) {
	a, b := 1, 1
	t.Log(a)
	for i := 0; i < 5; i++ {
		t.Log(" ", b)
		tmp := a
		a = b
		b = tmp + a
	}
}

func TestExchange(t *testing.T) {
	a, b := 1, 2
	// Go 支持直接交换，无需临时变量
	a, b = b, a
	t.Log(a, b)
}

2. 常量

使用 const 声明，不可修改。支持 iota 枚举生成器：

package constant

import "testing"

const (
	Monday = 1 + iota
	Tuesday
	Wednesday
)

const (
	Readable = 1 << iota
	Writable
	Executable
)

func TestConstant1(t *testing.T) {
	t.Log(Monday, Tuesday)
}

func TestConstant2(t *testing.T) {
	a := 1
	t.Log(a&Readable == Readable, a&Writable == Writable, a&Executable == Executable)
}

3. 数据类型

Go 拥有丰富的内置类型：

• 数值：int, float32/64, complex64/128
• 布尔：bool
• 字符串：不可变，支持 UTF-8
• 集合：数组（固定）、切片（动态）、映射（Map）
• 复合：结构体（Struct）、接口（Interface）
• 其他：函数类型、通道（Channel）、指针

类型转换示例：

package main

import "fmt"

func main() {
	// 显式转换
	var x int = 10
	var y float64 = float64(x)
	fmt.Println(y)

	// 类型别名
	type Celsius float64
	type Fahrenheit float64
	c := Celsius(25)
	f := Fahrenheit(c*9/5 + 32)
	fmt.Println(f)
}

4. 运算符

Go 支持算术、逻辑、比较、位运算等。特别注意按位清除运算符 &^：

func TestBitClear(t *testing.T) {
	a := 7 // 0111
	a = a &^ 1 // 清除第 0 位
	t.Log(a)
}

5. 条件语句

• if：标准分支判断。
• switch：自动匹配，无需 break。支持多 case 和条件表达式。

func TestConditionSwitch(t *testing.T) {
	dayOfWeek := 3
	switch dayOfWeek {
	case 1:
		t.Log("Monday")
	case 2, 3:
		t.Log("Tuesday or Wednesday")
	default:
		t.Log("Weekend")
	}
}

6. 循环语句

Go 只有 for 循环，可模拟 while 和 do-while：

func TestLoopForRange(t *testing.T) {
	numbers := []int{1, 2, 3, 4, 5}
	for index, value := range numbers {
		t.Logf("Index: %d, Value: %d", index, value)
	}
}

7. 跳转语句

支持 break, continue。goto 存在但不推荐使用。

（三）常用集合和字符串

1. 数组与切片

数组长度固定，切片更灵活（引用底层数组）。

numbers := []int{1, 2, 3, 4, 5}
subSlice := numbers[1:4]

2. 映射 (Map)

无序键值对集合，用于存储关联数据。

ages := map[string]int{
	"Alice": 25,
	"Bob": 30,
}
ages["Charlie"] = 22

3. Set 实现

Go 标准库无 Set，可用 Map 模拟：

type Set map[int]bool
func (s Set) Add(element int) { s[element] = true }

4. 字符串

注意字符串不可变，UTF-8 编码。使用 rune 处理字符。

str := "中华人民共和国"
for _, c := range str {
	t.Logf("%[1]c %[1]x", c)
}

（四）函数

Go 函数支持多返回值、命名返回值、可变参数、闭包及 defer 延迟调用。

func divide(a, b int) (result int, err error) {
	if b == 0 {
		err = errors.New("division by zero")
		return
	}
	result = a / b
	return
}

func main() {
	defer fmt.Println("End")
	fmt.Println("Start")
}

（五）面向对象编程

Go 没有类，通过结构体和组合实现 OOP。

1. 结构体与方法

type Circle struct {
	Radius float64
}

func (c Circle) Area() float64 {
	return 3.14 * c.Radius * c.Radius
}

2. 接口

接口定义方法集合，实现是隐式的。

type Shape interface {
	Area() float64
}

3. 空接口与断言

interface{} 可接收任意类型，配合类型断言使用。

func DoSomething(p interface{}) {
	switch v := p.(type) {
	case int:
		fmt.Println("Integer", v)
	}
}

（六）错误处理

Go 使用返回值处理错误，而非异常。

func GetFibonacci(n int) ([]int, error) {
	if n < 2 {
		return nil, errors.New("n should be not less than 2")
	}
	// ... logic
	return fibList, nil
}

对于复杂场景，可使用自定义错误类型或 panic/recover（谨慎使用）。

（七）包和依赖管理

Go Modules 是标准的依赖管理工具。

• 包可见性：首字母大写导出，小写私有。
• 模块隔离：每个项目独立管理依赖版本，避免冲突。
• 远程依赖：使用 go get 获取第三方包。

（八）并发编程

1. Goroutine vs Thread

Goroutine 栈初始仅 2KB，由 Go 运行时调度（M:N 模型），开销极小。

2. 共享内存同步

使用 sync.Mutex 保护临界区，或使用 sync.WaitGroup 等待完成。

var mut sync.Mutex
counter := 0
for i := 0; i < 5000; i++ {
	go func() {
		mut.Lock()
		defer mut.Unlock()
		counter++
	}()
}
wg.Wait()

3. CSP 模型与 Channel

'不要通过共享内存来通信，而要通过通信来共享内存'。

• 无缓冲 Channel：发送接收同步阻塞。
• 有缓冲 Channel：允许非阻塞发送直到满。

4. Select 与超时

select {
case result := <-ch:
	log(result)
case <-time.After(2 * time.Second):
	log("Timeout")
}

5. Context 取消

使用 context 包管理任务取消和超时控制，是并发协作的最佳实践。

注：本文档涵盖了 Go 语言的基础语法、并发模型及工程化实践。实际开发中请结合官方文档深入理解各组件细节。