Go 语言基础语法
- [Go 语言基础语法](#Go 语言基础语法)
-
- [1. 包声明与导入](#1. 包声明与导入)
- [2. 变量声明](#2. 变量声明)
- [3. 基本数据类型](#3. 基本数据类型)
- [4. 常量](#4. 常量)
- [5. 控制流](#5. 控制流)
-
- [if / else](#if / else)
- [for（Go 唯一的循环关键字）](#for（Go 唯一的循环关键字）)
- switch
- [6. 函数](#6. 函数)
- [7. 指针](#7. 指针)
- [8. 数组、切片、映射](#8. 数组、切片、映射)
- [9. 结构体与方法](#9. 结构体与方法)
- [10. 接口（隐式实现）](#10. 接口（隐式实现）)
- [11. 错误处理](#11. 错误处理)
- [12. goroutine 与 channel（并发基础）](#12. goroutine 与 channel（并发基础）)
- 关键特性总结
Go 语言基础语法
1. 包声明与导入
go
package main
import (
"fmt"
"strings"
)- 每个
.go文件必须属于一个package - 可执行程序入口是
package main+func main() - 多个包用
()分组导入
2. 变量声明
go
// 显式声明
var name string = "Go"
var age int = 10
// 类型推断
var name = "Go" // 自动推断 string
age := 10 // 短声明，只能在函数内使用
// 批量声明
var (
x int = 1
y string = "hello"
)零值机制 ：未赋值的变量自动初始化为类型的零值（0、""、false、nil）。
3. 基本数据类型
| 类型 | 示例 |
|---|---|
bool |
true, false |
int / int8 / int16 / int32 / int64 |
整数 |
uint / uintptr |
无符号整数 |
float32 / float64 |
浮点数 |
byte (= uint8) |
字节 |
rune (= int32) |
Unicode 码点 |
string |
字符串（不可变） |
4. 常量
go
const Pi = 3.14
// 枚举
const (
StatusOK = 200
StatusErr = 500
StatusNP = iota // 0, 1, 2... 自动递增
)5. 控制流
if / else
go
if x > 0 {
fmt.Println("positive")
} else if x == 0 {
fmt.Println("zero")
} else {
fmt.Println("negative")
}
// 带初始化语句（作用域仅限 if 块内）
if err := doSomething(); err != nil {
log.Fatal(err)
}for（Go 唯一的循环关键字）
go
// 经典
for i := 0; i < 10; i++ { ... }
// 类 while
for i < 10 { ... }
// 死循环
for { ... }
// range 遍历
for idx, val := range slice { ... } // idx 可用 _ 忽略
for key, val := range myMap { ... }switch
go
switch day {
case "Mon":
fmt.Println("周一")
case "Tue", "Wed":
fmt.Println("周中")
default:
fmt.Println("其他")
}
// 无表达式：类似 if-else chain
switch {
case score >= 90:
fmt.Println("A")
case score >= 60:
fmt.Println("B")
}6. 函数
go
// 基本函数
func add(a int, b int) int {
return a + b
}
// 多返回值（Go 惯用错误处理模式）
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("division by zero")
}
return a / b, nil
}
// 命名返回值
func rect(width, height float64) (area float64) {
area = width * height
return // 自动返回 area
}
// 可变参数
func sum(nums ...int) int { ... }7. 指针
go
x := 10
p := &x // 取地址
fmt.Println(*p) // 解引用 → 10
*p = 20 // 通过指针修改Go 的指针不支持运算 （没有 p++），比 C 简单安全。
8. 数组、切片、映射
数组（固定长度）
go
var arr [5]int = [5]int{1, 2, 3, 4, 5}切片（动态长度，核心数据结构）
go
s := []int{1, 2, 3} // 字面量
s = append(s, 4) // 追加
s2 := s[1:3] // 切片操作 [low:high]
// make 创建
s3 := make([]int, 0, 10) // 长度0，容量10映射（Map）
go
m := map[string]int{"Go": 10, "Python": 30}
m["Rust"] = 8
v, ok := m["Go"] // ok 表示 key 是否存在
delete(m, "Python")9. 结构体与方法
go
type User struct {
Name string
Age int
}
// 值接收者（不修改原对象）
func (u User) Greet() string {
return "Hi, " + u.Name
}
// 指针接收者（可修改原对象）
func (u *User) SetAge(age int) {
u.Age = age
}10. 接口（隐式实现）
go
type Speaker interface {
Speak() string
}
type Dog struct{}
func (d Dog) Speak() string { return "Woof!" }
// Dog 自动实现 Speaker，无需显式声明
var s Speaker = Dog{}11. 错误处理
go
if err := doWork(); err != nil {
return fmt.Errorf("doWork failed: %w", err) // %w 包装错误链
}Go 没有异常，用返回 error 值处理，这是语言设计哲学的核心。
12. goroutine 与 channel（并发基础）
go
// 启动 goroutine
go func() {
fmt.Println("concurrent")
}()
// channel
ch := make(chan int, 1) // 缓冲通道
ch <- 42 // 发送
val := <-ch // 接收
// select 多路复用
select {
case msg := <-ch1:
fmt.Println(msg)
case msg := <-ch2:
fmt.Println(msg)
case <-time.After(2 * time.Second):
fmt.Println("timeout")
}关键特性总结
| 特性 | 说明 |
|---|---|
| 编译型 | 直接编译为机器码，无运行时依赖 |
| GC | 内置垃圾回收 |
| 隐式接口 | 结构体只要实现了方法就自动满足接口 |
| 多返回值 | 天然支持 error 返回模式 |
| 无继承 | 组合优于继承，用嵌入（embedding）替代 |
| goroutine | 轻量级协程，CSP 并发模型 |