Go 语言基础语法

Go 语言的语法简洁清晰，本章将详细介绍 Go 语言的基础语法规则，包括标识符、关键字、字面量、运算符等核心概念。

🔤 标识符（Identifiers）

标识符规则

Go 语言中的标识符用来命名变量、类型、函数等。

命名规则

字符组成：字母、数字、下划线
首字符：必须是字母或下划线
大小写敏感：name 和 Name 是不同的标识符
长度限制：无限制，但建议合理长度

// 有效的标识符
var name string
var age int
var _private string
var userName string
var user_name string    // 不推荐，Go 风格倾向于 camelCase
var π float64          // 支持 Unicode 字符
var 中文变量 string      // 支持中文，但不推荐

// 无效的标识符
// var 123name string   // 不能以数字开头
// var my-name string   // 不能包含短横线
// var my name string   // 不能包含空格

命名规范

Go 命名约定

// 1. 驼峰命名法（推荐）
var userName string      // 小驼峰，包内使用
var UserName string      // 大驼峰，导出标识符

// 2. 常量命名
const MaxSize = 100      // 导出常量
const maxRetries = 3     // 包内常量

// 3. 函数命名
func getName() string    // 包内函数
func GetName() string    // 导出函数

// 4. 类型命名
type user struct         // 包内类型
type User struct         // 导出类型

// 5. 接口命名
type reader interface    // 包内接口
type Reader interface    // 导出接口

可见性规则

package example

// 导出的（可被其他包访问）
var PublicVar = "公开变量"
func PublicFunc() {}
type PublicType struct {}

// 包内的（只能在当前包内访问）
var privateVar = "私有变量"
func privateFunc() {}
type privateType struct {}

🔑 关键字（Keywords）

Go 语言保留字

Go 语言有 25 个关键字，不能用作标识符：

// 包和导入
package  import

// 声明
var      const    type     func

// 控制流
if       else     switch   case     default
for      range    break    continue goto
return   go       select   defer

// 类型
chan     interface  map     struct

// 其他
fallthrough

关键字分类

1. 声明关键字

package main      // 包声明
import "fmt"      // 导入声明
var x int        // 变量声明
const PI = 3.14  // 常量声明
type Point struct { X, Y int }  // 类型声明
func hello() {}  // 函数声明

2. 控制流关键字

// 条件控制
if x > 0 {
    fmt.Println("正数")
} else {
    fmt.Println("非正数")
}

// 多分支控制
switch x {
case 1:
    fmt.Println("一")
case 2:
    fmt.Println("二")
default:
    fmt.Println("其他")
}

// 循环控制
for i := 0; i < 10; i++ {
    if i == 5 {
        continue  // 跳过当次循环
    }
    if i == 8 {
        break     // 跳出循环
    }
    fmt.Println(i)
}

// 函数返回
func add(a, b int) int {
    return a + b
}

// 无条件跳转（不推荐使用）
goto label
label:
    fmt.Println("跳转到这里")

3. 并发关键字

// 启动 goroutine
go func() {
    fmt.Println("并发执行")
}()

// 通道操作
ch := make(chan int)
select {
case x := <-ch:
    fmt.Println("接收到:", x)
case ch <- 42:
    fmt.Println("发送成功")
default:
    fmt.Println("没有可用操作")
}

// 延迟执行
func example() {
    defer fmt.Println("函数结束时执行")
    fmt.Println("正常执行")
}

💡 字面量（Literals）

数值字面量

整数字面量

// 十进制
var dec = 42
var dec2 = 1_000_000  // 可以用下划线分隔提高可读性

// 二进制（Go 1.13+）
var bin = 0b1010      // 二进制：10

// 八进制
var oct = 0o755       // 八进制：493
var oct2 = 0755       // 传统八进制写法

// 十六进制
var hex = 0xFF        // 十六进制：255
var hex2 = 0x2A       // 十六进制：42

浮点数字面量

// 小数形式
var f1 = 3.14
var f2 = .25          // 0.25
var f3 = 1.           // 1.0

// 科学计数法
var f4 = 1e6          // 1000000.0
var f5 = 2.5e-3       // 0.0025
var f6 = 1.5E+2       // 150.0

// 十六进制浮点数
var f7 = 0x1p-2       // 0.25 (1 * 2^-2)

字符串字面量

解释字符串

// 使用双引号，支持转义字符
var str1 = "Hello, World!"
var str2 = "第一行\n第二行"
var str3 = "制表符\t分隔"
var str4 = "引号：\"内容\""
var str5 = "反斜杠：\\"

原始字符串

// 使用反引号，不处理转义字符
var raw1 = `Hello, World!`
var raw2 = `第一行
第二行`  // 保留换行符
var raw3 = `文件路径：C:\Program Files\Go\bin`
var raw4 = `正则表达式：\d+\.\d+`

字符字面量

// 使用单引号表示字符（rune 类型）
var char1 = 'A'          // 字符 A
var char2 = '中'         // 中文字符
var char3 = '\n'         // 换行符
var char4 = '\u4e2d'     // Unicode：中
var char5 = '\U00004e2d' // Unicode：中
var char6 = '\x41'       // 十六进制：A

布尔字面量

var true_val = true
var false_val = false

📝 语法结构

语句分隔

// Go 语言自动插入分号，通常不需要手动添加
fmt.Println("第一句")
fmt.Println("第二句")

// 同一行多个语句需要分号分隔（不推荐）
x := 1; y := 2; z := x + y

// 大括号不能单独放在新行（语法要求）
if x > 0 {  // 正确
    fmt.Println("正数")
}

// if x > 0    // 错误！会自动插入分号
// {
//     fmt.Println("正数")  
// }

代码块

// 使用大括号定义代码块
{
    var x = 1
    fmt.Println(x)
    // x 的作用域仅在此代码块内
}
// fmt.Println(x)  // 错误！x 超出作用域

// 函数代码块
func example() {
    // 函数体
}

// 条件代码块
if condition {
    // if 代码块
} else {
    // else 代码块
}

🔧 表达式和运算符

算术运算符

var a, b = 10, 3

fmt.Println(a + b)    // 13  加法
fmt.Println(a - b)    // 7   减法
fmt.Println(a * b)    // 30  乘法
fmt.Println(a / b)    // 3   除法（整数除法）
fmt.Println(a % b)    // 1   取余

// 浮点数除法
var x, y = 10.0, 3.0
fmt.Println(x / y)    // 3.3333333333333335

比较运算符

var a, b = 5, 10

fmt.Println(a == b)   // false  等于
fmt.Println(a != b)   // true   不等于
fmt.Println(a < b)    // true   小于
fmt.Println(a <= b)   // true   小于等于
fmt.Println(a > b)    // false  大于
fmt.Println(a >= b)   // false  大于等于

逻辑运算符

var x, y = true, false

fmt.Println(x && y)   // false  逻辑与
fmt.Println(x || y)   // true   逻辑或
fmt.Println(!x)       // false  逻辑非
fmt.Println(!y)       // true   逻辑非

位运算符

var a, b uint = 12, 10  // 二进制：1100, 1010

fmt.Println(a & b)     // 8   按位与：1000
fmt.Println(a | b)     // 14  按位或：1110
fmt.Println(a ^ b)     // 6   按位异或：0110
fmt.Println(^a)        // 按位取反
fmt.Println(a << 2)    // 48  左移：110000
fmt.Println(a >> 2)    // 3   右移：11

赋值运算符

var x = 10

x += 5    // x = x + 5  结果：15
x -= 3    // x = x - 3  结果：12
x *= 2    // x = x * 2  结果：24
x /= 4    // x = x / 4  结果：6
x %= 5    // x = x % 5  结果：1

// 位运算赋值
x = 12    // 重置
x &= 10   // x = x & 10
x |= 5    // x = x | 5
x ^= 3    // x = x ^ 3
x <<= 1   // x = x << 1
x >>= 2   // x = x >> 2

递增递减运算符

var i = 5

i++       // i = i + 1  结果：6
i--       // i = i - 1  结果：5

// 注意：Go 中 ++ 和 -- 是语句，不是表达式
// var j = i++  // 错误！不能这样使用
// var k = ++i  // 错误！Go 没有前置递增

🎯 运算符优先级

从高到低的优先级：

优先级	运算符	说明
5	`*` `/` `%` `<<` `>>` `&` `&^`	乘除、移位、按位与
4	`+` `-` `	^`
3	`==` `!=` `<` `<=` `>` `>=`	比较运算符
2	`&&`	逻辑与
1	`

优先级示例

// 不同优先级的计算
result := 2 + 3 * 4        // 14  (3*4 先计算)
result = (2 + 3) * 4       // 20  (使用括号改变优先级)

// 逻辑运算符优先级
condition := true || false && false  // true (先算 false && false)
condition = (true || false) && false // false (括号改变优先级)

🔄 类型推断

var 声明的类型推断

// 明确指定类型
var name string = "Go"
var age int = 10

// 类型推断
var name2 = "Go"        // 推断为 string
var age2 = 10           // 推断为 int
var pi = 3.14           // 推断为 float64
var isTrue = true       // 推断为 bool

短变量声明

// := 运算符进行声明和初始化
name := "Go"            // string
age := 25               // int
height := 1.75          // float64
isStudent := false      // bool

// 多变量声明
x, y := 10, 20
a, b, c := 1, 2.5, "hello"

📋 空白标识符

丢弃不需要的值

// 函数返回多个值时，使用 _ 丢弃不需要的值
value, _ := strconv.Atoi("123")  // 忽略错误
_, err := fmt.Println("Hello")   // 忽略返回的字节数

// 导入包但不使用（仅执行 init 函数）
import _ "net/http/pprof"

// 检查类型是否实现接口
var _ io.Writer = (*os.File)(nil)

🎯 实践示例

综合语法示例

package main

import (
    "fmt"
    "math"
    "strconv"
    "strings"
)

func main() {
    // 变量声明和类型推断
    var message string = "Hello, Go!"
    count := 42
    pi := 3.14159
    isActive := true
    
    // 字符串操作
    fmt.Println("原始消息:", message)
    fmt.Println("大写:", strings.ToUpper(message))
    fmt.Println("长度:", len(message))
    
    // 数值运算
    fmt.Printf("数字: %d, 平方: %d\n", count, count*count)
    fmt.Printf("π ≈ %.2f, 面积: %.2f\n", pi, pi*math.Pow(5, 2))
    
    // 条件判断
    if count > 40 {
        fmt.Println("count 大于 40")
    }
    
    // 类型转换
    countStr := strconv.Itoa(count)
    fmt.Println("数字转字符串:", countStr)
    
    // 运算符演示
    a, b := 15, 4
    fmt.Printf("%d + %d = %d\n", a, b, a+b)
    fmt.Printf("%d - %d = %d\n", a, b, a-b)
    fmt.Printf("%d * %d = %d\n", a, b, a*b)
    fmt.Printf("%d / %d = %d\n", a, b, a/b)
    fmt.Printf("%d %% %d = %d\n", a, b, a%b)
    
    // 位运算演示
    x, y := uint(12), uint(10)
    fmt.Printf("位与: %d & %d = %d\n", x, y, x&y)
    fmt.Printf("位或: %d | %d = %d\n", x, y, x|y)
    fmt.Printf("位异或: %d ^ %d = %d\n", x, y, x^y)
    
    // 逻辑运算
    fmt.Printf("true && false = %t\n", true && false)
    fmt.Printf("true || false = %t\n", true || false)
    fmt.Printf("!true = %t\n", !true)
}

🎓 小结

本章我们学习了 Go 语言的基础语法：

✅ 标识符：命名规则和可见性规范
✅ 关键字：25 个保留字及其用途
✅ 字面量：数值、字符串、字符、布尔字面量
✅ 运算符：算术、比较、逻辑、位运算、赋值运算符
✅ 语法结构：语句分隔、代码块、表达式
✅ 类型推断：自动类型推导机制

掌握这些基础语法是进一步学习 Go 语言的重要基础。

接下来，我们将学习 Go 语言数据类型，深入了解 Go 语言的类型系统。

语法提示

Go 语言的语法设计简洁明了，减少了不必要的复杂性
大括号的位置有严格要求，左大括号不能单独在新行
使用 gofmt 工具可以自动格式化代码，保持一致的代码风格

Go 语言基础语法 ​

🔤 标识符（Identifiers） ​

标识符规则 ​

命名规则 ​

命名规范 ​

Go 命名约定 ​

可见性规则 ​

🔑 关键字（Keywords） ​

Go 语言保留字 ​

关键字分类 ​

1. 声明关键字 ​

2. 控制流关键字 ​

3. 并发关键字 ​

💡 字面量（Literals） ​

数值字面量 ​

整数字面量 ​

浮点数字面量 ​

字符串字面量 ​

解释字符串 ​

原始字符串 ​

字符字面量 ​

布尔字面量 ​

📝 语法结构 ​

语句分隔 ​

代码块 ​

🔧 表达式和运算符 ​

算术运算符 ​

比较运算符 ​

逻辑运算符 ​

位运算符 ​

赋值运算符 ​

递增递减运算符 ​

🎯 运算符优先级 ​

优先级示例 ​

🔄 类型推断 ​

var 声明的类型推断 ​

短变量声明 ​

📋 空白标识符 ​

丢弃不需要的值 ​

🎯 实践示例 ​

综合语法示例 ​

🎓 小结 ​

Go 语言基础语法

🔤 标识符（Identifiers）

标识符规则

命名规则

命名规范

Go 命名约定

可见性规则

🔑 关键字（Keywords）

Go 语言保留字

关键字分类

1. 声明关键字

2. 控制流关键字

3. 并发关键字

💡 字面量（Literals）

数值字面量

整数字面量

浮点数字面量

字符串字面量

解释字符串

原始字符串

字符字面量

布尔字面量

📝 语法结构

语句分隔

代码块

🔧 表达式和运算符

算术运算符

比较运算符

逻辑运算符

位运算符

赋值运算符

递增递减运算符

🎯 运算符优先级

优先级示例

🔄 类型推断

var 声明的类型推断

短变量声明

📋 空白标识符

丢弃不需要的值

🎯 实践示例

综合语法示例

🎓 小结