阶段 1：语言基础与核心语法

（一）文件和调用

1. 包声明 & 入口函数

package main   // 必须为 main 包，才能执行

import "fmt"   // 导入标准库

func main() {
    fmt.Println("Hello, Go!")
}

• package 是 Go 的模块机制，每个 Go 文件必须声明属于哪个“包（package）”。

• main 是一个特殊的包名，表示这个文件是一个可独立执行的程序，而不是一个可复用的库。

  • package utils：表示这是一个工具库，不会直接运行

  • package controller：表示是用于组织控制逻辑的模块

• import 用来导入其他包（标准库或第三方包）

• "fmt" 是 Go 自带的标准库，全名是：format，提供格式化 I/O 功能

功能	示例
打印到控制台	fmt.Println("Hi")
格式化字符串	fmt.Sprintf("Hello %s", name)
打印变量值	fmt.Printf("x = %d\n", x)

• func 表示函数定义

• main() 是 Go 程序的程序入口点，必须是这个名字，不能改成 start()、run() 等其他名称

  程序执行时，Go 运行时会从 main() 开始执行

2. 调用文件

假设你有如下目录结构：

myproject/
├── main.go
└── utils/
    └── mathutils.go

文件路径：myproject/main.go

package main

import (
    "fmt"
    "myproject/utils"  // 引入 utils 包
)

func main() {
    sum := utils.Add(10, 20)
    fmt.Println("Sum:", sum)

    p := utils.Person{Name: "Alanna", Age: 22}
    fmt.Println(p.Greet())
}

文件路径：myproject/utils/mathutils.go

package utils

import "fmt"

// 公有函数（首字母大写）
func Add(a int, b int) int {
    return a + b
}

// 私有函数（首字母小写，只能在 utils 包内使用）
func internalLog() {
    fmt.Println("This is a private function inside utils package.")
}

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

// 方法绑定
func (p Person) Greet() string {
    return fmt.Sprintf("Hello, my name is %s, I am %d years old.", p.Name, p.Age)
}

cd myproject
go mod init myproject      # 初始化模块
go run main.go             # 运行程序

输出结果：

Sum: 30
Hello, my name is Alanna, I am 22 years old.

（二）变量声明

标准写法

var x int = 10
var y = 20          // 自动推导为 int

简洁写法（推荐）

z := 30             // 类型自动推导

注意事项

• := 只能在函数内部使用
• Go 是强类型语言，一旦声明类型就不能赋其他类型值

常用数据类型

类型	示例
int / int64	var a int = 10
float64	var b float64 = 3.14
string	var name = "Go"
bool	var alive = true

输出中插入变量

package main

import "fmt"

func main() {
    name := "Alanna"
    age := 20
    fmt.Printf("Hello, %s! You are %d years old.\n", name, age)
}

（三）复合数据类型

Array（长度固定）

var arr [3]int = [3]int{1, 2, 3}

Slice（动态数组，实际开发最常用）

s := []int{1, 2, 3}
s = append(s, 4)

Map（字典）

m := map[string]int{"apple": 2, "banana": 5}
fmt.Println(m["apple"])

Struct（结构体）

type Person struct {
    Name string
    Age  int
}

p := Person{"Alice", 30}

（四）控制结构

if / else

if x > 10 {
    fmt.Println("x is big")
} else {
    fmt.Println("x is small")
}

switch（Go 的 switch 支持表达式）

switch x {
case 1:
    fmt.Println("one")
case 2:
    fmt.Println("two")
default:
    fmt.Println("other")
}

for 循环

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

for range（迭代数组、切片、map、字符串）

for i, v := range []string{"a", "b", "c"} {
    fmt.Println(i, v)
}

（五）函数定义

1. 单返回值

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

2. 多返回值（Go 语言特有！）

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

3. 可变参数

func sum(nums ...int) int {
    total := 0
    for _, v := range nums {
        total += v
    }
    return total
}

（六）指针

1. 基本用法

x := 10
p := &x       // p 是 *int 类型
fmt.Println(*p) // 解引用，输出 10

2. 函数传地址

func modify(p *int) {
    *p = 100
}
modify(&x)  // 修改 x 的值为 100

Go 语言默认是值传递，如果要修改外部变量，必须传指针。

（七）结构体 Struct 和方法绑定

1. 自定义结构体 + 方法绑定

type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

• func (r Rectangle) 表示方法绑定在 Rectangle 类型上。
• 类似面向对象的“类 + 方法”。

（八）接口 Interface

1. 接口定义与实现（无需显式继承）

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

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

任何实现了 Area() 方法的类型 自动 实现 Shape 接口。

2. 类型断言

var s Shape = Circle{10}
c, ok := s.(Circle)  // 类型断言
if ok {
    fmt.Println("This is a circle", c)
}

（九）错误处理机制（非 try/catch）

Go 使用显式错误返回值：

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

调用时判断：

err := doSomething()
if err != nil {
    fmt.Println("Error:", err)
}

1. 自定义错误：

return fmt.Errorf("failed to process item: %v", reason)

2. panic / recover（少用）

defer func() {
    if r := recover(); r != nil {
        fmt.Println("Recovered:", r)
    }
}()
panic("crash now")

推荐练习

1. Fibonacci 函数

func fib(n int) int {
    if n <= 1 {
        return n
    }
    return fib(n-1) + fib(n-2)
}

2. 冒泡排序

func bubbleSort(arr []int) {
    n := len(arr)
    for i := 0; i < n; i++ {
        for j := 0; j < n-i-1; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
}

3. 自定义结构体 + 接口实现

type Animal interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof!" }

type Cat struct{}
func (c Cat) Speak() string { return "Meow!" }