要点
package main 表示可执行程序的包，main 函数是入口。import 引入其他包，不是把源码文本粘贴进来。
编写第一个Go程序
1. 创建程序文件
创建你的第一个Go程序文件 hello.go：
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
fmt.Println("欢迎来到Go语言的世界!")
}
2. 程序结构解析
让我们逐行分析这个程序：
// 包声明 - 定义这个文件属于哪个包
package main
// 导入包 - 导入需要使用的包
import "fmt"
// 主函数 - 程序的入口点
func main() {
// 调用fmt包的Println函数
fmt.Println("Hello, World!")
fmt.Println("欢迎来到Go语言的世界!")
}
关键概念解释：
package main：- 每个Go程序都必须属于一个包
main包是特殊的，表示这是一个可执行程序- 只有main包中的main函数才能作为程序入口
import "fmt"：- 导入标准库中的
fmt包 fmt包提供格式化输入输出功能- 用于打印文本到控制台
- 导入标准库中的
func main()：- 程序的主入口函数
- 程序从这里开始执行
- 当main函数返回时，程序结束
fmt.Println()：- 打印一行文本到控制台
- 自动在末尾添加换行符
运行Go程序
方法1: 直接运行
# 直接运行Go文件
go run hello.go
输出：
Hello, World!
欢迎来到Go语言的世界!
方法2: 先编译后运行
# 编译Go程序
go build hello.go
1. 运行生成的可执行文件
./hello
在Windows上：
# 编译
go build hello.go
1. 运行
hello.exe
方法3: 使用模块
# 初始化Go模块
go mod init hello-world
1. 运行程序
go run hello.go
程序进阶练习
常用格式化动词速览：
fmt.Printf系列函数按动词格式化值，本文及后续文档会频繁用到：
| 动词 | 用途 | 示例 | 输出 |
|---|---|---|---|
%d | 十进制整数 | fmt.Printf("%d", 42) | 42 |
%s | 字符串 | fmt.Printf("%s", "Go") | Go |
%q | 带双引号的字符串 | fmt.Printf("%q", "Go") | "Go" |
%t | 布尔值 | fmt.Printf("%t", true) | true |
%f | 浮点数（%.2f 保留两位小数） | fmt.Printf("%.2f", 3.14159) | 3.14 |
%v | 默认格式（任意类型） | fmt.Printf("%v", []int{1, 2}) | [1 2] |
%c | 字符（rune 的码点） | fmt.Printf("%c", 20013) | 中 |
遇到不认识的动词回查此表即可，细节在后续文档逐步展开。
练习1: 添加变量
package main
import "fmt"
func main() {
// 声明变量
name := "张三"
age := 25
city := "北京"
// 打印个人信息
fmt.Println("个人信息:")
fmt.Printf("姓名: %s\n", name)
fmt.Printf("年龄: %d\n", age)
fmt.Printf("城市: %s\n", city)
// 计算并显示明年年龄
nextAge := age + 1
fmt.Printf("明年年龄: %d\n", nextAge)
}
练习2: 使用函数
这里用到了自定义函数的定义与调用，函数语法详见 Go 函数与方法。
package main
import "fmt"
// 定义一个简单的函数
func greet(name string) {
fmt.Printf("你好, %s!\n", name)
}
// 带返回值的函数
func add(a, b int) int {
return a + b
}
func main() {
// 调用greet函数
greet("小明")
greet("小红")
// 调用add函数
result := add(10, 20)
fmt.Printf("10 + 20 = %d\n", result)
}
练习3: 条件判断
这里用到了
if/else条件判断，语法详见 Go 控制结构。
package main
import "fmt"
func checkAge(age int) {
if age >= 18 {
fmt.Printf("%d岁是成年人\n", age)
} else {
fmt.Printf("%d岁是未成年人\n", age)
}
}
func main() {
// 测试不同年龄
checkAge(16)
checkAge(18)
checkAge(25)
// 用户输入年龄
var userAge int
fmt.Print("请输入你的年龄: ")
fmt.Scanln(&userAge)
checkAge(userAge)
}
常用Go命令
基本命令
# 运行Go程序
go run filename.go
1. 编译Go程序
go build filename.go
1. 运行测试
go test
1. 格式化代码
go fmt filename.go
1. 检查代码错误
go vet filename.go
模块命令
# 初始化模块
go mod init module-name
1. 添加依赖
go get package-name
1. 整理依赖
go mod tidy
1. 查看依赖
go mod list
程序调试技巧
1. 使用fmt调试
package main
import "fmt"
func calculateSum(numbers []int) int {
sum := 0
for i, num := range numbers {
fmt.Printf("处理第%d个数: %d\n", i, num) // 调试输出
sum += num
}
fmt.Printf("总和: %d\n", sum) // 调试输出
return sum
}
func main() {
numbers := []int{1, 2, 3, 4, 5}
result := calculateSum(numbers)
fmt.Printf("最终结果: %d\n", result)
}
2. 使用panic调试
package main
import "fmt"
func process(data string) {
if data == "" {
panic("数据不能为空") // 程序会在这里停止并显示错误信息
}
fmt.Printf("处理数据: %s\n", data)
}
func main() {
process("Hello")
// process("") // 这行会触发panic
}
实战小项目
项目1: 个人信息卡片
这里用到了结构体（
struct），结构体语法详见 Go 复合类型。
package main
import "fmt"
// 定义个人信息结构体
type Person struct {
Name string
Age int
City string
Hobby string
}
// 打印个人信息
func printPersonInfo(p Person) {
fmt.Println("=== 个人信息 ===")
fmt.Printf("姓名: %s\n", p.Name)
fmt.Printf("年龄: %d\n", p.Age)
fmt.Printf("城市: %s\n", p.City)
fmt.Printf("爱好: %s\n", p.Hobby)
fmt.Println("================")
}
func main() {
// 创建个人信息
me := Person{
Name: "张三",
Age: 28,
City: "上海",
Hobby: "编程",
}
// 打印信息
printPersonInfo(me)
// 创建朋友信息
friend := Person{
Name: "李四",
Age: 26,
City: "北京",
Hobby: "阅读",
}
printPersonInfo(friend)
}
项目2: 简单计算器
这里用到了
switch多路分支，语法详见 Go 控制结构。
package main
import "fmt"
// 加法
func add(a, b float64) float64 {
return a + b
}
// 减法
func subtract(a, b float64) float64 {
return a - b
}
// 乘法
func multiply(a, b float64) float64 {
return a * b
}
// 除法
func divide(a, b float64) float64 {
if b == 0 {
fmt.Println("错误: 除数不能为0")
return 0
}
return a / b
}
func main() {
var num1, num2 float64
var operator string
fmt.Println("=== 简单计算器 ===")
fmt.Print("请输入第一个数字: ")
fmt.Scanln(&num1)
fmt.Print("请输入运算符 (+, -, *, /): ")
fmt.Scanln(&operator)
fmt.Print("请输入第二个数字: ")
fmt.Scanln(&num2)
var result float64
switch operator {
case "+":
result = add(num1, num2)
case "-":
result = subtract(num1, num2)
case "*":
result = multiply(num1, num2)
case "/":
result = divide(num1, num2)
default:
fmt.Println("错误: 不支持的运算符")
return
}
fmt.Printf("结果: %.2f %s %.2f = %.2f\n", num1, operator, num2, result)
}
常见错误和解决方法
错误1: 包声明错误
// ❌ 错误
package mainx // 拼写错误
// ✅ 正确
package main
错误2: 未使用的导入
// ❌ 错误
package main
import "fmt" // 导入了但未使用
import "os" // 导入了但未使用
func main() {
fmt.Println("Hello")
}
// ✅ 正确
package main
import "fmt"
func main() {
fmt.Println("Hello")
}
错误3: return 换行被自动分号截断
Go 通常不需要手写分号——词法器会在行尾自动插入：当一行的最后一个词法单元是标识符、字面量、return/break/continue/fallthrough 或 )、]、}、++、-- 时，就在行尾插入一个分号。显式写出分号是合法的（可以编译），但 gofmt 会将其移除，所以不要手写分号。
真正的陷阱是自动分号截断语句：return 单独写在行尾时会被自动插入分号，函数直接返回，后面的表达式永远不会执行：
// ❌ 错误 - return 在行尾被自动插入分号，a + b 不会被求值
func add(a, b int) int {
return
a + b // 编译错误: missing return
}
// ✅ 正确 - 返回值与 return 写在同一行
func add(a, b int) int {
return a + b
}
错误4: 大小写敏感
// ❌ 错误
package main
import "fmt"
func main() {
fmt.println("Hello") // 应该是Println（大写P）
}
// ✅ 正确
package main
import "fmt"
func main() {
fmt.Println("Hello") // 注意大小写
}
下一步学习建议
完成第一个Go程序后，建议按以下顺序继续学习：
练习建议
- 先照着示例跑通，再逐行改一个变量观察输出变化，比重读十遍有效
- 报错时完整读一遍错误信息，Go 的错误通常包含出错位置和期望类型
- 用 Go Tour 做交互式练习，它在浏览器里直接运行代码
- 把
go run、go build和go vet都跑一遍，vet 能发现编译器放过的可疑写法
延伸阅读
- Go 变量与常量——变量与常量是所有后续代码的地基