Go 基础语法
程序结构
Hello World 程序
// 这是注释
package main // 包声明，main 包是可执行程序的入口
import "fmt" // 导入标准库 fmt
// main 函数是程序的入口点
func main() {
fmt.Println("Hello, World!") // 打印输出
}程序组成部分
- 包声明：
package main- 声明包名 - 导入语句：
import "fmt"- 导入需要的包 - 函数：
func main()- 定义函数 - 语句：
fmt.Println(...)- 执行语句
注释
// 单行注释
/*
多行注释
可以写多行
*/
// 文档注释（用于生成文档）
// Package main 提供程序入口
// 这是包级别的文档注释
package main
// Add 函数用于计算两个数的和
// 参数 a 和 b 是要相加的两个整数
// 返回 a 和 b 的和
func Add(a, b int) int {
return a + b
}标识符和关键字
标识符规则
// 标识符（变量名、函数名等）规则：
// 1. 必须以字母或下划线开头
// 2. 后面可以跟字母、数字、下划线
// 3. 区分大小写
var name string // 正确
var _name string // 正确
var name123 string // 正确
var 123name string // 错误：不能以数字开头
var my-name string // 错误：不能包含连字符关键字
// Go 的关键字（不能用作标识符）：
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预定义标识符
// 预定义标识符（可以重新定义，但不推荐）：
// 类型：bool, byte, complex64, complex128, error, float32, float64
// int, int8, int16, int32, int64, rune, string, uint, uint8,
// uint16, uint32, uint64, uintptr
// 常量：true, false, iota, nil
// 函数：append, cap, close, complex, copy, delete, imag, len,
// make, new, panic, print, println, real, recover变量声明
使用 var 声明
// 方式一：声明后赋值
var name string
name = "Go"
// 方式二：声明时赋值
var name string = "Go"
// 方式三：类型推断（省略类型）
var name = "Go" // 自动推断为 string
// 方式四：声明多个变量
var (
name string = "Go"
age int = 10
isOk bool = true
)
// 方式五：声明多个同类型变量
var x, y int = 1, 2使用 := 短变量声明
// := 只能在函数内部使用
func main() {
name := "Go" // 等价于 var name string = "Go"
age := 10 // 等价于 var age int = 10
x, y := 1, 2 // 声明多个变量
a, b := 1, "hello" // 不同类型
// 注意：:= 至少有一个新变量
x, y := 3, 4 // 错误：x, y 都已存在
x, z := 3, 4 // 正确：z 是新变量
}变量作用域
package main
var globalVar = "全局变量" // 包级别变量
func main() {
var localVar = "局部变量" // 函数级别变量
{
var blockVar = "块级别变量" // 块级别变量
fmt.Println(blockVar) // 可以访问
}
// fmt.Println(blockVar) // 错误：blockVar 不在作用域内
fmt.Println(localVar) // 可以访问
fmt.Println(globalVar) // 可以访问
}常量
常量声明
// 使用 const 声明常量
const Pi = 3.14159
// 声明多个常量
const (
StatusOK = 200
StatusError = 500
)
// 常量组（如果省略值，则使用上一行的值）
const (
a = 1 // a = 1
b // b = 1
c // c = 1
)
// iota：常量生成器
const (
Sunday = iota // 0
Monday // 1
Tuesday // 2
Wednesday // 3
Thursday // 4
Friday // 5
Saturday // 6
)
// iota 高级用法
const (
_ = iota // 忽略第一个值
KB = 1 << (10 * iota) // 1024
MB // 1048576
GB // 1073741824
TB // 1099511627776
)基本数据类型
布尔类型
var isTrue bool = true
var isFalse bool = false
// 布尔类型的零值是 false
var zero bool // zero = false整数类型
// 有符号整数
var i8 int8 // -128 到 127
var i16 int16 // -32768 到 32767
var i32 int32 // -2147483648 到 2147483647
var i64 int64 // -9223372036854775808 到 9223372036854775807
var i int // 32 或 64 位，取决于平台
// 无符号整数
var u8 uint8 // 0 到 255
var u16 uint16 // 0 到 65535
var u32 uint32 // 0 到 4294967295
var u64 uint64 // 0 到 18446744073709551615
var u uint // 32 或 64 位，取决于平台
// 特殊类型
var b byte = 255 // uint8 的别名
var r rune = '中' // int32 的别名，用于 Unicode 字符浮点数类型
var f32 float32 = 3.14
var f64 float64 = 3.141592653589793
// 科学计数法
var num1 = 1.23e4 // 12300
var num2 = 1.23e-4 // 0.000123复数类型
var c64 complex64 = 1 + 2i
var c128 complex128 = 1 + 2i
// 创建复数
var c1 = complex(1, 2) // 1 + 2i
var c2 = complex(3, 4) // 3 + 4i
// 获取实部和虚部
realPart := real(c1) // 1
imagPart := imag(c1) // 2字符串类型
// 字符串是不可变的字节序列
var str1 string = "Hello"
var str2 = "World"
// 多行字符串
var multiLine = `这是
多行
字符串`
// 字符串连接
var combined = str1 + " " + str2 // "Hello World"
// 字符串长度
length := len("Hello") // 5
// 字符串索引（返回字节）
firstByte := "Hello"[0] // 72 (H 的 ASCII 码)
// 字符串切片
substr := "Hello"[1:3] // "el"零值
// 每种类型都有零值（默认值）
var i int // 0
var f float64 // 0.0
var b bool // false
var s string // ""
var p *int // nil
var sl []int // nil
var m map[string]int // nil
var ch chan int // nil类型转换
// Go 是强类型语言，需要显式类型转换
var i int = 42
var f float64 = float64(i) // int 转 float64
var u uint = uint(f) // float64 转 uint
// 字符串转换
import "strconv"
// 数字转字符串
str := strconv.Itoa(123) // "123"
str2 := strconv.FormatInt(123, 10) // "123"
// 字符串转数字
num, err := strconv.Atoi("123") // 123, nil
num2, err := strconv.ParseInt("123", 10, 64) // 123, nil
// 字符串和字节切片
str := "Hello"
bytes := []byte(str) // []byte{'H', 'e', 'l', 'l', 'o'}
str2 := string(bytes) // "Hello"运算符
算术运算符
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 取余
// 自增自减
a++ // a = 11（只有后置）
a-- // a = 10（只有后置）比较运算符
a, b := 10, 20
fmt.Println(a == b) // false 相等
fmt.Println(a != b) // true 不等
fmt.Println(a < b) // true 小于
fmt.Println(a > b) // false 大于
fmt.Println(a <= b) // true 小于等于
fmt.Println(a >= b) // false 大于等于逻辑运算符
a, b := true, false
fmt.Println(a && b) // false 逻辑与
fmt.Println(a || b) // true 逻辑或
fmt.Println(!a) // false 逻辑非位运算符
a, b := 5, 3 // 二进制：101, 011
fmt.Println(a & b) // 1 按位与 (001)
fmt.Println(a | b) // 7 按位或 (111)
fmt.Println(a ^ b) // 6 按位异或 (110)
fmt.Println(^a) // -6 按位取反
fmt.Println(a << 1) // 10 左移 (1010)
fmt.Println(a >> 1) // 2 右移 (10)赋值运算符
a := 10
a += 5 // a = a + 5 (15)
a -= 3 // a = a - 3 (12)
a *= 2 // a = a * 2 (24)
a /= 4 // a = a / 4 (6)
a %= 4 // a = a % 4 (2)
a <<= 1 // a = a << 1 (4)
a >>= 1 // a = a >> 1 (2)
a &= 3 // a = a & 3 (2)
a |= 1 // a = a | 1 (3)
a ^= 2 // a = a ^ 2 (1)指针
// 指针存储变量的内存地址
var x int = 42
var p *int = &x // p 是指向 x 的指针
fmt.Println(x) // 42 值
fmt.Println(p) // 0xc0000140a0 地址
fmt.Println(*p) // 42 解引用（获取指针指向的值）
// 通过指针修改值
*p = 100
fmt.Println(x) // 100
// 空指针
var nilPtr *int = nil
// fmt.Println(*nilPtr) // 运行时错误：空指针解引用总结
Go 的基础语法特点：
- 简洁明了：语法简单，易于学习
- 类型安全：静态类型，编译时检查
- 零值概念：每个类型都有默认零值
- 指针支持：可以操作内存地址
- 强类型：需要显式类型转换
掌握这些基础语法后，就可以开始编写 Go 程序了！