Go语言基础入门指南
Go语言简介
Go语言（也叫Golang）是由Google开发的一种编译型静态语言。开发者需要先编写Go代码，然后将其编译为可执行文件，才能在对应的操作系统上运行。开发环境通常需要安装Go SDK，它提供了一套管理代码资源的工具。常用命令包括：go build（编译代码生成可执行文件）和 go run（编译并立即运行代码，中间的编译产物会被自动清理）。
第一个程序：Hello World
下面是一个最基础的Go程序：
package main // 每个Go文件需要声明所属包，main包是程序的起点
import "fmt" // 导入标准库中的fmt包，用于格式化输出
func main() { // main函数是程序入口，无参数无返回值
fmt.Println("hello world")
}
在GoLand等IDE中，可以直接右键文件选择"运行"来编译执行。通常，一个Go项目只有一个main包，且入口为main包下的main函数。学习阶段，我们可以将每个Go文件单独编译运行。
注意：Go语言要求导入的包必须在代码中实际使用，否则编译器会报错。这样做可以有效避免不必要的内存和性能浪费。GoLand等编辑器会智能地自动管理包导入——当你使用某个包时自动添加导入语句，删除相关引用后也会移除对应的导入行。
变量命名规范
基本规则
变量名可以由字母（包括Unicode字符）、下划线和数字组成，但数字不能开头。Go语言区分大小写。应避免使用以下25个关键字和37个保留字作为变量名：
关键字：
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
保留字（内置常量、类型和函数）：
true false iota nil
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
make len cap new append copy close delete
complex real imag panic recover
常见命名风格
- Go语言：变量和函数名采用小驼峰（如
myVariable），文件名采用下划线（如my_file.go） - 对比Python：全下划线风格（如
my_variable） - 对比Java：全驼峰风格（如
MyVariable）
变量声明
Go中声明的变量必须被使用，否则编译器会报错。三种基本声明方式如下：
// 完整声明：var 变量名 类型 = 值
var name string = "leethon"
// 类型推导：var 变量名 = 值
var name = "leethon"
// 简短声明：变量名 := 值（省略var）
name := "leethon"
一次性声明多个变量：
// 完整声明多个，类型必须一致
var name, age, hobby string = "leethon", "19", "篮球"
// 使用var分组，每个变量可单独指定类型
var (
name string = "leethon"
age int = 19
hobby = "篮球"
)
// 类型推导，类型可以不同
var name, age, hobby = "leethon", 19, "basketball"
// 简短声明，类型可以不同
name, age, hobby := "leethon", 19, "basketball"
先声明后赋值：必须使用完整声明语法，变量会获得对应类型的零值。
var name string // 默认为 ""
var age int // 默认为 0
数据类型
可以使用%T占位符打印变量类型：
fmt.Printf("a的值是：%v, 类型是：%T", a, a)
数字类型
- 有符号整型：
int8（-128~127）、int16、int32、int64、int（32位系统上为int32，64位系统上为int64） - 无符号整型：
uint8（0~255）、uint16、uint32、uint64、uint - 浮点型：
float32、float64 - 复数：
complex64、complex128 - 别名：
byte是uint8的别名，rune是int32的别名
字符类型
// 字符串：使用双引号或反引号
"hello"
`多行
字符串`
// 单引号：表示字符编码对应的整型值
var a, b, c = 'a', '2', '三'
fmt.Printf("%T %v, %T %v, %T %v", a, a, b, b, c, c)
// 输出：int32 97, int32 50, int32 19977
布尔类型
var flag bool = true
var f bool = false
自由数据类型
any（Go 1.18+）可用于声明变量或形参，由实际传入的值决定具体类型。
常量
使用const关键字声明，声明后不可修改：
const pi float64 = 3.14159
const name = "leethon"
// 多常量声明
const (
male = 1
female = 2
unknown = 0
)
// 依赖规则：未赋值的常量自动与前一个相同
const (
a = 10
b // b = 10
)
iota：递增枚举器
iota在const块中从0开始，每新增一行常量声明就自增1，常用于枚举：
const (
unknown = iota // 0
male // 1
female // 2
)
复杂用法：
const (
a = iota // 0
b // 1
c // 2
d = "ha" // 独立值，iota仍递增到3
e // "ha", iota=4
f = 100 // iota=5
g // 100, iota=6
h = iota // 7，恢复使用iota
i // 8
)
结合位运算：
const (
KB = 1 << (iota * 10) // 1 << 10 = 1024
MB // 1 << 20
GB // 1 << 30
)
函数
main函数
每个可执行程序必须有main函数，它是程序入口，无参数无返回值。
函数定义与调用
// 无参函数
func test() {
fmt.Println("无参函数")
}
// 有参函数，必须指定参数类型
func test1(a int, b string) {
fmt.Println(a, b)
}
// 相同类型的参数可以简写
func test2(a, b int, c string) {
fmt.Println(a, b, c)
}
// 有返回值
func add(a, b int) int {
return a + b
}
// 多返回值
func swap(a, b int) (int, int) {
return b, a
}
// 调用示例
func main() {
test()
test1(11, "leethon")
sum := add(1, 2)
x, y := swap(3, 4)
// 使用 _ 忽略不需要的返回值
_, z := swap(5, 6)
}
匿名函数与一等公民
Go中函数是一等公民，可以赋值给变量、作为参数传递或从函数返回：
// 赋值给变量
f := func() {
fmt.Println("匿名函数赋值")
}
// 作为参数
func execute(f func()) {
f()
}
// 闭包（装饰器模式）
func wrapper(f func()) func() {
return func() {
f()
fmt.Println("额外操作")
}
}
作用域
- 局部变量：函数内部声明
- 全局变量：函数外部声明，同一包内可见
- 形式参数：函数定义中的参数，作用域仅限于函数体内
var global = 10 // 全局变量
func main() {
local := 20 // 局部变量
fmt.Println(global, local)
}
// 注意：同一包内多个文件的顶级作用域不允许重复声明同名变量或函数
类型重命名与别名
type MyFunc func(int, int) int // 定义新类型
type MyType = int // 仅别名，与int视为同一类型
// 区别：新类型与原始类型不同，别名则完全相同
func test(a int) {}
var a MyType = 10
test(a) // MyType（别名）可以传入；如果使用type MyType int则不行
