Go 从 0 到精通 · 第 01 课：Go 语言入门与环境搭建

学习定位：这是整套 Go 教程的第 1 课。
目标人群：有其他语言编程经验，但准备从 0 系统学习 Go 的学习者。
本课目标：理解 Go 是什么、为什么学它、如何搭建环境、如何写并运行第一个 Go 程序。

1. 先建立整体认知：Go 到底是什么

Go 是 Google 开发的一门编程语言，官方名称叫 Go，社区里也常叫 Golang。

它不是一门追求“语法花样很多”的语言，而是一门非常强调：

  • 简洁
  • 清晰
  • 高效
  • 工程化
  • 并发友好

如果用一句话概括 Go：

Go 是一门面向工程实践的编译型语言，特别适合构建稳定、清晰、易维护的后端和基础设施程序。

2. 为什么 Go 值得学

如果你已经有其他语言经验，那么学习 Go 的价值并不只是“多会一门语言”，而是你会接触一种非常典型的工程化表达方式。

2.1 Go 的主要优势

语法简洁

Go 刻意减少了一些复杂特性，目的是让代码更统一、更容易读。

这会带来两个直接好处：

  • 代码可读性高
  • 团队协作成本低

编译速度快

Go 是编译型语言，但编译速度通常比较快，开发体验比较舒服。

并发支持好

Go 内置并发能力，核心概念是：

  • goroutine
  • channel

你现在先记住这两个词，后面我们会详细讲。

部署方便

Go 可以编译成独立可执行文件，这意味着部署通常比较简单。

标准库实用

Go 的标准库质量很高，很多任务不依赖框架就能完成。

3. Go 适合做什么

Go 非常适合下面这些场景：

  • 后端服务
  • API 服务
  • 微服务
  • 网络编程
  • CLI 工具
  • 中间件
  • 云原生相关工具
  • 高并发程序

一些知名项目和 Go 关系很深：

  • Docker
  • Kubernetes
  • etcd
  • Terraform
  • Prometheus

你现在不需要去学这些项目，但知道这些例子有助于你理解：

Go 是一门非常偏“实战工程”的语言。

4. 学 Go 前必须先理解的设计气质

很多人学习新语言失败，不是因为语法不会，而是因为总想用旧语言的方式去理解新语言。

学习 Go，你要先接受它的几种核心风格。

4.1 Go 崇尚简单

Go 不鼓励过度设计。它更喜欢：

  • 直白表达
  • 少而清晰的抽象
  • 可维护性优先

4.2 Go 强调显式

Go 不喜欢把很多逻辑藏起来，尤其是在错误处理上。

例如你后面会经常看到这样的代码：

1
2
3
4
result, err := someFunc()
if err != nil {
    // 处理错误
}

这看起来比异常机制啰嗦一点，但它的优点是：

  • 错误路径清楚
  • 调试更直接
  • 工程上更容易审查

4.3 Go 倾向组合，而不是复杂继承

如果你来自 Java、C++、C# 之类的语言，你可能会习惯类、继承、层层抽象。

但 Go 更推崇：

  • 组合
  • 接口
  • 小而清晰的行为定义

这个思想会在后续的 struct、方法、接口部分逐步体现出来。

5. 环境搭建：你需要知道什么

这一部分不只讲“怎么装”，还会讲“装的是什么”。

5.1 安装 Go

安装 Go 官方版本后，系统中会提供 go 命令。

安装完成后，在终端执行：

1
go version

如果看到类似输出：

1
go version go1.22.0 windows/amd64

说明 Go 已安装成功。

注意：版本号可能和示例不同，只要命令能正常返回即可。

5.2 理解 GOROOT

GOROOT 表示 Go 语言本身的安装位置。

你可以把它理解为：

Go 编译器、工具链和标准库所在的位置。

对于初学者来说，通常不需要频繁手动设置它，安装程序一般会处理好。

5.3 理解 GOPATH

GOPATH 是 Go 早期非常重要的工作目录概念。

过去很多项目和依赖包会放在这个目录结构中。

但你作为现代 Go 初学者，要记住一个重点：

现在开发 Go 项目，核心不再是 GOPATH，而是 Go Modules。

所以目前你只要知道：

  • GOPATH 是历史上重要概念
  • 现代 Go 项目主要使用模块机制管理依赖

5.4 现代 Go 项目的核心：Go Modules

现代 Go 项目通常都会先初始化模块。

命令如下：

1
go mod init myproject

这条命令会做几件事：

  • 把当前目录初始化为一个 Go 模块
  • 生成一个 go.mod 文件
  • 记录模块名和依赖信息

你现在不用深入理解依赖管理细节，但一定要先建立一个意识：

以后写 Go 项目，看到 go.mod 是非常正常的。

5.5 编辑器建议

建议使用：

  • VS Code
  • 安装 Go 官方插件

原因是：

  • 补全体验好
  • 调试方便
  • 上手快
  • 生态成熟

如果你已经有熟悉的 IDE，也可以继续使用，只要 Go 支持足够完善即可。

6. 第一个 Go 程序

现在开始正式写第一段 Go 代码。

创建文件：main.go

1
2
3
4
5
6
7
package main

import "fmt"

func main() {
    fmt.Println("你好，Go！")
}

运行命令：

1
go run main.go

如果输出：

1
你好，Go！

说明你的第一个 Go 程序运行成功。

7. 逐行理解这段程序

不要满足于“能跑”，你要知道每一行为什么这么写。

7.1 package main

1
package main

这表示当前文件属于 main 包。

在 Go 中，源代码文件都属于某个包。
当一个程序要编译成可执行文件时，入口包通常需要是 main。

你可以先把它理解为：

这是一个可执行程序的主包。

7.2 import "fmt"

1
import "fmt"

这一行表示导入标准库中的 fmt 包。

fmt 是 Go 中最常用的标准库之一，主要负责：

  • 输出文本
  • 格式化字符串
  • 打印变量信息

你后面会频繁使用它。

7.3 func main()

1
2
func main() {
}

这定义了一个名为 main 的函数。

它是程序的入口函数，也就是程序运行时首先执行的地方。

你可以把它理解成：

  • C 里的 main
  • Java 的主入口函数概念
  • Python 脚本的顶层执行入口的固定形式版本

7.4 fmt.Println("你好，Go！")

1
fmt.Println("你好，Go！")

这表示调用 fmt 包中的 Println 函数，把字符串输出到控制台，并自动换行。

这里顺便理解两个小点：

点号调用

1
fmt.Println

表示调用 fmt 这个包里的 Println。

字符串字面量

1
"你好，Go！"

双引号包起来的是字符串。

8. go run 和 go build 的区别

这两个命令你必须从第一课就分清楚。

8.1 go run

1
go run main.go

它的本质是：

  • 先编译
  • 再运行

只不过这个编译结果通常是临时的，不会像正式构建那样明显留在目录里。

它更适合：

  • 快速测试
  • 开发调试

8.2 go build

1
go build

或者：

1
go build main.go

它会：

  • 编译源码
  • 生成可执行文件
  • 不自动运行

它更适合：

  • 正式构建
  • 打包交付
  • 部署程序

8.3 一句话区分

  • go run：边编译边运行
  • go build：只编译不运行

这个区别非常基础，但很重要。

9. Go 的几个语法习惯，第一课先有印象

9.1 大括号的位置很重要

Go 通常写成这样：

1
2
3
func main() {
    fmt.Println("hello")
}

而不是这样：

1
2
3
4
func main()
{
    fmt.Println("hello")
}

Go 对格式和风格要求比较统一，这其实是它工程可维护性的一部分。

9.2 分号通常不用手写

很多语言习惯这样写：

1
fmt.Println("hello");

但在 Go 中，通常不需要你手动写分号。
编译器会在合适的位置自动处理。

这样做的好处是：

  • 减少语法噪音
  • 统一代码风格

9.3 未使用的变量和包会报错

这一点非常有 Go 风格。

比如你导入了包：

1
import "fmt"

但后面没有使用 fmt，编译器通常会报错。
同理，如果你定义了变量却不用，也可能报错。

这说明 Go 倾向于：

  • 早发现问题
  • 保持代码整洁
  • 减少无意义残留

这不是“故意严格”，而是在帮你养成更好的工程习惯。

10. 本课你应该真正掌握什么

学完这一课，不是只会抄代码，而是要能自己复述下面这些内容。

10.1 概念掌握清单

你应该能解释：

  • Go 是什么类型的语言
  • Go 的主要特点有哪些
  • package main 的作用是什么
  • func main() 的作用是什么
  • import "fmt" 的作用是什么
  • go run 和 go build 的区别是什么
  • go mod init 是做什么的

如果这些你可以不看文档自己讲出来，就说明这一课你是真的学会了。

11. 本课练习

练习一定要亲手做。你已经有其他语言经验，所以你更应该利用“改代码”的方式建立 Go 直觉。

练习 1：修改输出内容

把这句：

1
fmt.Println("你好，Go！")

改成输出你自己的名字，例如：

1
fmt.Println("你好，我叫小明")

练习 2：连续打印两行

让程序输出两行内容，例如：

1
2
fmt.Println("我开始学习 Go")
fmt.Println("今天是第 1 天")

练习 3：试试 go build

在当前目录执行：

1
go build

观察当前目录是否生成了可执行文件。

这个练习的真正目的，是让你建立一个非常重要的意识：

Go 代码不是只能解释执行，它会被编译成真正的程序。

练习 4：故意制造一个错误

你可以这样做：

  • 保留 import "fmt"
  • 删除 fmt.Println(...)

然后重新运行或构建，看看编译器报什么错。

这个练习的意义是：

  • 感受 Go 编译器的严格性
  • 理解“未使用导入”为什么会报错

12. 常见疑问答疑

12.1 Go 难不难

如果你已经有其他语言经验，Go 的基础语法并不难。
真正值得深入打磨的是：

  • 接口设计
  • 错误处理
  • 并发模型
  • 工程实践
  • 性能理解

所以 Go 的特点是：

入门快，但想真正写得好，需要持续练习和理解。

12.2 为什么现在不讲框架

因为顺序非常重要。

如果语言本体没学清楚，就直接学框架，往往会出现下面的问题：

  • 只会照着写
  • 不知道为什么这么写
  • 一旦报错就不会排查
  • 一换项目场景就容易失去方向

正确顺序是：

先掌握语言，再进入标准库、并发、工程能力，最后再看框架生态。

13. 本课总结

这节课你已经完成了 Go 学习的第一步。虽然内容还不多，但它非常关键，因为它帮你建立了最初的认知框架。

你现在应该已经知道：

  • Go 是什么
  • Go 为什么值得学
  • 怎么检查环境是否安装成功
  • go mod init 的意义
  • 怎么写并运行第一个 Go 程序
  • 为什么 package main 和 main() 很重要
  • go run 与 go build 的区别

如果你能把这些内容讲清楚，第一课就算真正过关。

14. 课后作业

今天只做下面这些事情，不要贪多：

  1. 安装 Go，并执行 go version
  2. 新建一个项目目录
  3. 执行 go mod init
  4. 创建 main.go
  5. 用 go run main.go 运行程序
  6. 把输出内容改 3 次
  7. 试一次 go build
  8. 故意删掉 fmt.Println 看编译错误

15. 下一课预告

下一课我们讲：变量、常量、基础数据类型。

会重点讲清楚：

  • 为什么 Go 里既有 var，又有 :=
  • 类型推断到底是什么
  • 零值是什么意思
  • int、float64、bool、string 怎么选
  • 常量和变量的本质区别
  • 新手常见坑有哪些

如果你学完本课并完成练习，我们就可以进入第 2 课。