要点

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 系列函数按动词格式化值，本文及后续文档会频繁用到：

遇到不认识的动词回查此表即可，细节在后续文档逐步展开。

练习1: 添加变量

package main

import "fmt"

func main() {
    // 声明变量
    name := "张三"
    age := 25
    city := "北京"

    // 打印个人信息
    fmt.Println("个人信息:")
    fmt.Printf("姓名: %sn", name)
    fmt.Printf("年龄: %dn", age)
    fmt.Printf("城市: %sn", city)

    // 计算并显示明年年龄
    nextAge := age + 1
    fmt.Printf("明年年龄: %dn", nextAge)
}

练习2: 使用函数

💡 这里用到了自定义函数的定义与调用，函数语法详见 05-functions-methods.md。

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 = %dn", result)
}

练习3: 条件判断

💡 这里用到了 if/else 条件判断，语法详见 06-control-structures.md。

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 调试

💡 这里用到了切片（[]int）与 for/range 循环：切片详见 04-composite-types.md，循环语法详见 06-control-structures.md。

package main

import "fmt"

func calculateSum(numbers []int) int {
    sum := 0
    for i, num := range numbers {
        fmt.Printf("处理第%d个数: %dn", i, num) // 调试输出
        sum += num
    }
    fmt.Printf("总和: %dn", sum) // 调试输出
    return sum
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    result := calculateSum(numbers)
    fmt.Printf("最终结果: %dn", result)
}

2. 使用 panic 调试

package main

import "fmt"

func process(data string) {
    if data == "" {
        panic("数据不能为空") // 程序会在这里停止并显示错误信息
    }
    fmt.Printf("处理数据: %sn", data)
}

func main() {
    process("Hello")
    // process("") // 这行会触发panic
}

实战小项目

项目1: 个人信息卡片

💡 这里用到了结构体（struct），结构体语法详见 04-composite-types.md。

package main

import "fmt"

// 定义个人信息结构体
type Person struct {
    Name    string
    Age     int
    City    string
    Hobby   string
}

// 打印个人信息
func printPersonInfo(p Person) {
    fmt.Println("=== 个人信息 ===")
    fmt.Printf("姓名: %sn", p.Name)
    fmt.Printf("年龄: %dn", p.Age)
    fmt.Printf("城市: %sn", p.City)
    fmt.Printf("爱好: %sn", 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 多路分支，语法详见 06-control-structures.md。

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 = %.2fn", 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 程序后，建议按以下顺序继续学习：

1. 变量和常量 – 学习 Go 的数据类型和变量声明
2. 函数和方法 – 深入学习函数定义和调用
3. 控制结构 – 掌握条件语句和循环
4. 错误处理 – 学习 Go 的错误处理机制
5. 结构体和接口 – 了解 Go 的面向对象编程

文档交叉引用

相关文档

• Go 变量与常量
• Go 环境搭建与工具链
• Go 复合类型
• Go 函数与方法
• Go 控制结构

参考资源

• 📖 [Go 官方教程]: https://tour.golang.org/
• 📖 [Go Playground]: https://play.golang.org/
• 📖 [Go 官方文档]: https://golang.org/doc/

总结

核心要点回顾

1. 程序结构: 理解 package main 和 import 的作用
2. 运行方式: 掌握 go run 和 go build 的区别
3. 基本语法: 学习函数定义和调用
4. 调试技巧: 使用 fmt 包进行简单调试

实践练习

• [ ] 成功运行第一个 Go 程序
• [ ] 修改程序输出自己的信息
• [ ] 创建一个简单的计算器程序
• [ ] 尝试使用不同的数据类型和操作

文档状态: ✅ 已完成最后更新: 2026年9月版本: v1.0.0

💡 学习建议: – 多动手实践，不要只看不练 – 遇到错误时仔细阅读错误信息 – 使用 Go 官方的 Tour 进行交互式学习 – 尝试修改示例代码，观察运行结果的变化