# Golang 语法详解：掌握 Go 语言的核心语法
## 标识符和关键字
### 标识符
标识符是用来命名变量、函数、类型等的名称，必须以字母或下划线开头，后跟任意数量的字母、数字或下划线。
### 关键字
Go 语言有 25 个关键字：
“`
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
“`
## 变量声明与初始化
### 变量声明
“`go
// 标准声明
var name string
var age int
// 批量声明
var (
name string
age int
)
// 声明并初始化
var name string = “Go”
var age int = 10
// 类型推断
var name = “Go”
var age = 10
// 简短声明（只能在函数内部使用）
name := “Go”
age := 10
“`
### 零值
当变量声明后未初始化时，会被赋予零值：
– 数值类型：0
– 布尔类型：false
– 字符串：””
– 指针：nil
– 切片：nil
– 映射：nil
– 通道：nil
– 函数：nil
## 常量
### 常量声明
“`go
// 单个常量
const Pi = 3.14159
// 批量声明
const (
StatusOK = 200
StatusError = 500
)
// iota 常量生成器
const (
A = iota // 0
B // 1
C // 2
)
“`
## 数据类型
### 基本类型
#### 布尔型
“`go
var b bool = true
“`
#### 数值型
– 整数类型：`int`, `int8`, `int16`, `int32`, `int64`, `uint`, `uint8`, `uint16`, `uint32`, `uint64`, `uintptr`
– 浮点类型：`float32`, `float64`
– 复数类型：`complex64`, `complex128`
“`go
var i int = 10
var f float64 = 3.14
var c complex128 = 1 + 2i
“`
#### 字符串
“`go
var s string = “Hello, Go!”
// 字符串拼接
s = s + ” World”
// 多行字符串
s = `
Hello
Go
`
“`
### 复合类型
#### 数组
“`go
// 声明数组
var arr [5]int
// 初始化数组
arr = [5]int{1, 2, 3, 4, 5}
// 自动推断长度
arr = […]int{1, 2, 3, 4, 5}
“`
#### 切片
“`go
// 声明切片
var slice []int
// 从数组创建切片
slice = arr[1:4] // 包含索引 1，不包含索引 4
// 使用 make 创建切片
slice = make([]int, 5) // 长度为 5，容量为 5
slice = make([]int, 5, 10) // 长度为 5，容量为 10
// 直接初始化切片
slice = []int{1, 2, 3, 4, 5}
“`
#### 切片操作
“`go
// 添加元素
slice = append(slice, 6)
// 添加另一个切片
slice = append(slice, []int{7, 8, 9}…)
// 复制切片
copy(dest, src)
“`
## 控制流
### 条件语句
“`go
if x > 0 {
fmt.Println(“x is positive”)
} else if x < 0 {
fmt.Println("x is negative")
} else {
fmt.Println("x is zero")
}
// if 语句可以包含初始化语句
if y := 10; y > 0 {
fmt.Println(“y is positive”)
}
“`
### 循环语句
“`go
// for 循环
for i := 0; i < 10; i++ {
fmt.Println(i)
}
// while 循环
for i < 10 {
fmt.Println(i)
i++
}
// 无限循环
for {
fmt.Println("infinite loop")
break
}
// 遍历数组、切片、映射
for index, value := range slice {
fmt.Println(index, value)
}
```
### switch 语句
```go
switch x {
case 1:
fmt.Println("x is 1")
case 2:
fmt.Println("x is 2")
default:
fmt.Println("x is other")
}
// switch 语句可以包含初始化语句
switch y := 10; y {
case 1:
fmt.Println("y is 1")
case 10:
fmt.Println("y is 10")
default:
fmt.Println("y is other")
}
// 无表达式 switch
switch {
case x > 0:
fmt.Println(“x is positive”)
case x < 0:
fmt.Println("x is negative")
default:
fmt.Println("x is zero")
}
```
## 函数
### 函数定义
```go
// 基本函数定义
func add(a, b int) int {
return a + b
}
// 多个返回值
func swap(a, b string) (string, string) {
return b, a
}
// 命名返回值
func divide(a, b float64) (result float64, err error) {
if b == 0 {
err = errors.New("division by zero")
return
}
result = a / b
return
}
// 可变参数
func sum(nums ...int) int {
total := 0
for _, num := range nums {
total += num
}
return total
}
```
### 函数作为参数和返回值
```go
// 函数类型
type Operation func(int, int) int
// 函数作为参数
func calculate(a, b int, op Operation) int {
return op(a, b)
}
// 函数作为返回值
func getOperation(operation string) Operation {
switch operation {
case "add":
return func(a, b int) int {
return a + b
}
case "subtract":
return func(a, b int) int {
return a - b
}
default:
return func(a, b int) int {
return 0
}
}
}
```
## 结构体和方法
### 结构体定义
```go
type Person struct {
Name string
Age int
Address string
}
```
### 结构体方法
```go
// 值接收者方法
func (p Person) GetName() string {
return p.Name
}
// 指针接收者方法
func (p *Person) SetAge(age int) {
p.Age = age
}
```
## 接口
### 接口定义
```go
type Animal interface {
Speak() string
Move() string
}
```
### 接口实现
```go
type Dog struct {
Name string
}
func (d Dog) Speak() string {
return "Woof!"
}
func (d Dog) Move() string {
return "Run"
}
type Cat struct {
Name string
}
func (c Cat) Speak() string {
return "Meow!"
}
func (c Cat) Move() string {
return "Walk"
}
```
## 错误处理
### 错误返回
```go
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("division by zero")
}
return a / b, nil
}
// 使用错误
result, err := divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println("Result:", result)
```
## 包管理
### 包声明
```go
package main
```
### 导入包
```go
import (
"fmt"
"math"
"errors"
)
// 导入别名
import (
f "fmt"
m "math"
)
// 导入空白标识符
import (
_ "github.com/go-sql-driver/mysql"
)
```
## 总结
本文详细介绍了 Go 语言的核心语法，包括标识符和关键字、变量声明与初始化、常量、数据类型、控制流、函数、结构体和方法、接口以及错误处理等内容。掌握这些语法知识是学习 Go 语言的基础，也是编写高质量 Go 代码的前提。在实际开发中，我们需要灵活运用这些语法特性，结合具体场景编写清晰、高效的代码。