罗罗编程学习记录
本页内容 展开查看

05.1 阶段 0 环境与基础准备

所属:全栈开发面试题库 / 学习路径 / 05 Go 全栈

本页目录

一、阶段定位

这是整条路径的第 0 步,目标不是"学会 Go",而是"在本机把工具链、编辑器、命令行三件套调到可用状态,并对 HTTP、进程、文件这三个后端开发最常打交道的对象建立基本直觉"。阶段 1(05.2 阶段 1 语言基础与数据类型)会立刻要求你在多包工程里跑 go build、go vet、go test,如果本阶段连 go env 的输出都读不懂、连 go mod init 之后依赖拉不下来都不知道改哪里,阶段 1 的每个练习都会卡在环境问题上,而不是语言问题上。

本阶段解决的具体问题:

  1. 工具链可用:go version 能输出版本号,go env GOPATH 指向一个你知道在哪里的目录,go run hello.go 能编译运行一个最小程序。
  2. 依赖能拉取:国内网络下默认 proxy.golang.org 不可达,必须知道 GOPROXY 怎么配,否则第一次 go get 就卡死。
  3. 命令行直觉:知道 cd、绝对路径与相对路径、环境变量、后台进程是什么,能看懂一个进程在哪个目录、监听哪个端口。
  4. HTTP 模型:知道请求由方法、路径、头部、正文组成,响应有状态码,能用 curl 手动发一次请求。

原提纲里的"卡点"要展开成可判断的现象依据,满足任意一条就算卡在本阶段:

  • 在旧文档里看到 GOPATH=/home/user/go 这套写法,自己也照做,结果引入第三方包时报 cannot find module providing package,却不知道问题出在 GOPATH 与 Go Modules 两套模型的混淆。
  • 不会查官方文档:遇到报错先去搜索引擎问"这个错怎么解决",而不是先读 go help、go env 输出与错误信息本身。
  • 把"装了 IDE"当成"环境就绪":IDE 里点运行能跑,但在终端里 go build 找不到 go 命令,说明 PATH 没配对。
  • 分不清 go run 与 go build:以为 go run 产出了一个二进制文件,在另一台机器上找不到产物。

二、阶段目标与投入

学完本页,应当能用可观察的行为证明以下六条能力,而不是"装好了软件":

能力目标(可验证的行为) 验证方式
能在终端任意目录执行 go version、go env GOPATH、go run hello.go 三条命令都有正常输出,且不依赖 IDE 内嵌终端
能解释 GOROOT、GOPATH、GOBIN、GOPROXY 四个变量各自指向什么 对照 go env 输出,逐项说出"这是安装目录、这是工作区、这是可执行产物目录、这是依赖代理"
能用 go mod init 建模块,并用 go get 引入一个第三方库 引入后 go build ./... 通过,go.mod 里多出 require 行
能用 curl 向一个本地 HTTP 服务发 GET 与 POST,看懂状态码与响应头 curl -i 输出里能指出 200 OK、Content-Type、响应体
能在终端完成建目录、写文件、查看进程、按端口找进程 ls、cat、ps、netstat/lsof 四类命令各用过一次
能把编译出的二进制复制到另一目录(或另一台同架构机器)直接运行 不依赖源码目录,./hello 仍能执行

建议学时:

  • 全职(每天有效学习 4–6 小时):3–4 天,约 15–20 小时。其中装环境与验证 3 小时、命令行与 HTTP 直觉 8 小时、跑通第三方依赖工程 5 小时。
  • 在职(每天 2 小时、周末补):1.5–2 周,约 20 小时。不要在一天内把全部命令背完,按"一个模块两天"的节奏边敲边记。

学时分配建议:工具链安装与目录约定 20%、编译运行命令与依赖管理 25%、编辑器与 gopls 10%、HTTP 模型 20%、命令行与文件操作 15%、Linux 进程与端口 10%。

三、先修自检

进入本阶段前逐条自检。本阶段是整条路径的起点,没有更前的页面可回;任何一条做不到,就在本阶段对应模块里多花时间,不要跳。

先修项 合格标准 不合格时怎么做
会用终端 能打开终端(Windows 用 PowerShell 或 Windows Terminal),能执行 cd、dir/ls 见 5.6 命令行与文件操作,照着敲一遍
会用编辑器 有一个能保存纯文本文件的编辑器(VS Code / GoLand / Cursor 均可),知道怎么切换到终端 见 5.4 编辑器与 gopls
知道什么是函数与返回值 能看懂 fmt.Println("hello") 是在调用一个函数 本阶段不要求会写,能看懂即可;看不懂直接照 05.2 敲一遍示例
知道什么是 IP 与端口 能说出 127.0.0.1 是本机、8080 是一个端口号 见 5.5 HTTP 请求响应模型
会用 Git 提交 能 git init、git add、git commit,看懂 git status 本阶段只要求会初始化与提交;分支操作留到后面

经验判断:本阶段最常见的不是"不会",而是"环境差一点能用,就凑合着往下走"。只要出现一次"换个目录就跑不起来",就停下来修环境,不要带着问题进阶段 1。

四、知识地图

"掌握程度"分三档:了解(知道有这个东西、能查到)、会用(能写对、能调通)、能讲清原理(能解释底层行为、能回答追问)。本阶段的目标分布如下。

模块 知识点 掌握程度 对应题库章节
工具链安装 官方安装包、GOROOT、PATH、卸载与升级 会用 01 操作系统
目录约定 GOPATH、GOBIN、pkg/mod 缓存目录 会用 01 操作系统
依赖代理 GOPROXY、GOPRIVATE、GOSUMDB 会用 06 通用后端工程
编译运行 go build、go run、go install、静态二进制 能讲清原理 04.3 Go
HTTP 模型 方法、状态码、头部、curl、端口 会用 01 操作系统
命令行 flag 包、参数、文件读写、相对路径 会用 02 数据结构与算法
进程与端口 ps、netstat/lsof、环境变量、后台运行 了解 01 操作系统

进度管理建议:把这张表复制到自己的笔记里,每学完一个模块把"掌握程度"往下调一档;三档都到位再进 05.2。本阶段不要求背命令,要求"遇到问题能自己定位"。

五、分模块精讲

5.1 Go 工具链安装与目录约定

为什么需要它:Go 是编译型语言,安装目录、用户工作区、可执行产物目录三者是分开的。第一次装完如果分不清哪个目录装 Go、哪个目录放你的代码、哪个目录放编译产物,后面 go install 装的工具找不到、go get 拉的依赖找不到,都是常态。

核心机制:

  • GOROOT 是 Go 语言自身的安装目录,里面有 bin/go、bin/gofmt 和标准库源码;不要手动改它,升级 Go 版本就换一个 GOROOT。
  • GOPATH 是用户工作区,默认在用户目录下的 go/。它下面有 bin/(go install 产出的可执行文件)、pkg/mod/(全局依赖缓存,所有模块共享)、src/(Go Modules 之前的老代码组织方式,现在基本不用)。
  • GOBIN 是 go install 产物落地目录;未设置时默认用 $GOPATH/bin。这个目录必须加进 PATH,否则 go install 出来的 staticcheck、dlv 在终端敲不到。
  • 安装时官方安装包会把 GOROOT/bin(Linux/macOS 默认 /usr/local/go/bin,Windows 默认安装目录下的 bin)加进 PATH;用版本管理器(如 g、gvm)时由管理器负责切换。
  • Go Modules 从 1.11 起是默认模式,与 GOPATH 目录无关:你的代码放在任意目录都能用 go mod init 起一个模块,不再要求放进 $GOPATH/src。

最小可运行示例:

# 查看当前工具链的关键路径,逐条对照
go version
go env GOROOT GOPATH GOBIN GOPROPATH GOPROXY GOPRIVATE

# 期望输出示例(macOS / Linux):
# go version go1.23.4 darwin/arm64
# /usr/local/go
# ~/go            (即当前用户目录下的 go/,对应 go env GOPATH)
# (空)
# https://proxy.golang.org,direct
# (空)

# Windows 下 PowerShell 同样执行 go env GOROOT GOPATH,
# 输出为系统安装目录与用户目录下的 go/,无需手敲路径。
# 国内网络必须配置代理,否则 go get 会卡到超时
# 一次性写入用户级配置(写入 ~/.config/go/env 或 %APPDATA%\go\env)
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct
go env -w GOSUMDB=sum.golang.google.cn   # 校验和镜像,避免 sum.golang.org 不可达

# 验证配置是否写入
go env GOPROXY

常见坑:

现象 原因 修法
go: command not found GOROOT/bin 没加进 PATH 安装包勾选"加入 PATH";手动加 export PATH=$PATH:/usr/local/go/bin(或 Windows 环境变量)
go install 完的工具在终端敲不到 $GOPATH/bin 没加进 PATH 把 $(go env GOPATH)/bin 加进 PATH
go get 长时间无输出后报 dial tcp: lookup proxy.golang.org 默认代理在国内不可达 go env -w GOPROXY=https://goproxy.cn,direct
升级 Go 后 go version 还是旧版 系统里有多个 Go,PATH 排在前面的是旧版 which go(Windows 用 Get-Command go)看实际命中哪个

面试考法:常见问法是"Go 的 GOPATH 和 Go Modules 有什么区别""为什么现在不需要把代码放进 GOPATH/src"。要答到:GOPATH 是 1.11 之前的单工作区模型,所有项目共享 src,没有版本概念;Go Modules 以 go.mod 为单位,任意目录可建模块,依赖版本写在 require 里,全局缓存放在 pkg/mod 供多模块复用。追问常落在 pkg/mod 缓存为什么不直接改——因为它是只读共享缓存,改了会影响所有项目。

5.2 编译、运行与安装命令

为什么需要它:很多人以为 go run main.go 就是"编译运行",其实它每次都重新编译到临时目录再执行;而 go build 产出二进制、go install 把二进制装进 GOBIN,三者用途完全不同。分不清这三者,就会在"我要把程序放到服务器上跑"时不知道该复制哪个文件。

核心机制:

  • go build 在当前目录编译包,产出与目录同名的二进制(不安装到任何地方);加 -o app 指定产物名。
  • go run main.go 编译到临时目录并立即运行,不产出可分发文件;适合开发期快速验证。
  • go install 编译并把可执行文件放进 $GOBIN;用于安装第三方 CLI 工具。
  • go build ./... 编译模块内所有包但不产出二进制(仅检查能否编译);go vet ./... 做静态检查。
  • Go 默认编译为静态二进制(纯 Go 代码、无 CGO 时),不依赖系统 libc,可以直接丢到 alpine 或 scratch 镜像里跑;这是 Go 在云原生场景的核心优势。
  • GOOS 与 GOARCH 控制交叉编译:GOOS=linux GOARCH=amd64 go build 在 macOS 上直接产出 Linux 二进制。

最小可运行示例:

# 1. 写一个最小程序
cat > hello.go <<'EOF'
package main

import "fmt"

func main() {
	fmt.Println("hello, go")
}
EOF

# 2. 三种运行方式的区别
go run hello.go          # 编译到临时目录并执行,终端打印 hello, go
go build hello.go        # 在当前目录产出 hello(或 hello.exe)
./hello                  # 直接执行产物

# 3. 交叉编译:在 Windows 上产出 Linux amd64 二进制
set GOOS=linux          # PowerShell: $env:GOOS="linux"
set GOARCH=amd64        # PowerShell: $env:GOARCH="amd64"
go build -o hello-linux hello.go
# 把 hello-linux 拷到 Linux 服务器,chmod +x 后直接 ./hello-linux

常见坑:

现象 原因 修法
以为 go run 产出了可执行文件 go run 只编译到临时目录 用 go build -o app . 产出正式二进制
二进制在 Linux 上报 not executable format 交叉编译时 GOOS/GOARCH 与目标机不符 uname -m 看目标架构;Windows 用 echo %PROCESSOR_ARCHITECTURE%
产出的二进制特别大 没去掉调试符号,或引入了 CGO go build -ldflags "-s -w" 去掉符号表与 DWARF;CGO 用 CGO_ENABLED=0
go build ./... 报某个包错但不知道哪个 错误信息被截断 加 -x 看完整编译命令,或 go list ./... 看包列表

面试考法:常问"Go 编译出来的二进制为什么能直接在容器里跑、不需要装运行时"。答到:Go 编译器把标准库与运行时(goroutine 调度、GC、网络轮询)全部静态链接进单一可执行文件,目标机只要架构匹配即可,不需要 JRE 那样的运行时。追问:"那为什么还会有 not executable format"——答静态链接不等于跨架构,GOOS/GOARCH 必须匹配目标机。

5.3 Go Modules 与依赖管理命令

为什么需要它:阶段 1 的多包工程骨架(见 05.2)默认你已经知道 go mod init、go mod tidy、go get 三件套怎么用。本模块只讲依赖管理命令本身,不重复包结构与 internal/ 可见性(那部分在阶段 1)。

核心机制:

  • go.mod 记录模块路径、Go 版本、require 依赖及版本;go.sum 记录每个依赖版本的校验和,用于防篡改。
  • go mod init example.com/notes 创建新模块;go mod tidy 根据 import 自动增删 require 与 go.sum。
  • go get github.com/xxx/pkg@v1.2.0 拉取指定版本;go get -u ./... 升级到最新次版本。
  • 依赖缓存全局在 $(go env GOPATH)/pkg/mod,多个项目共享;删除该目录不会损坏任何项目,但下次构建会重新拉取。
  • replace 指令可以把某依赖替换成本地路径,调试内部库时常用;vendor 目录会把依赖复制进项目,离线构建用,日常一般不开。

最小可运行示例:

mkdir demo && cd demo
go mod init example.com/demo
# 引入一个真实存在的第三方库作为练习
go get github.com/redis/go-redis/v9@latest
go mod tidy
go list -m all          # 列出当前模块的所有直接与间接依赖
go mod graph            # 看依赖关系图
package main

import (
	"fmt"

	"github.com/redis/go-redis/v9"
)

func main() {
	// 不连接真实 Redis,仅验证依赖可用
	client := redis.NewClient(&redis.Options{Addr: "127.0.0.1:6379"})
	fmt.Println(client.Options().Addr)
}

常见坑:

现象 原因 修法
no required module provides package ... 代码里 import 了但没 go get 在模块根目录执行 go mod tidy
invalid version: unknown revision 仓库不存在或标签名拼错 去 GitHub 看真实 tag;用 @latest 先试
go.sum 被改动后 CI 失败 本地与服务器校验和不一致 go mod tidy 后把 go.sum 一起提交
replace 指向本地路径后同事拉不下来 本地路径是个人目录 用相对路径 replace ../localpkg,并确认仓库结构一致

面试考法:"Go Modules 和 Maven / npm 有什么本质区别"是必问题。答到:模块路径即导入前缀,版本由 go.mod require 与 go.sum 校验和共同固定;没有中央仓库强绑定,直接从 VCS 拉取,靠 GOPROXY 做代理与缓存;语义化版本选择遵循 MVS(最小版本选择),不是 npm 的"最新兼容版本"。追问会到 go mod tidy 与 go mod vendor 的区别——tidy 是整理依赖清单,vendor 是把依赖物理拷贝进项目。

5.4 编辑器与 gopls

为什么需要它:写 Go 不需要 IDE,但没有 gopls 提供的跳转、补全、格式化,调试体验会退回"改完手动 go build 才知道错没错"的状态。本模块的目标是让编辑器成为工具链的延伸,而不是另一个需要单独维护的环境。

核心机制:

  • gopls 是 Go 官方语言服务器,提供跳转定义、查找引用、悬停文档、自动补全;VS Code 的 Go 插件、GoLand、Cursor 都通过它拿信息。
  • 编辑器保存时自动跑 goimports:自动格式化 + 自动加/删 import;这是 Go 团队推荐的默认行为。
  • gofmt 只做格式化,不管 import;goimports 等于 gofmt + import 管理。
  • 测试、调试、静态检查在编辑器里都是调用本机工具链:go test、dlv(Delve)、staticcheck,不需要单独的"IDE 版"。
  • 升级 Go 版本后要重启 gopls:gopls 是按 Go 版本装的,版本不匹配会出现跳转失效。

最小可运行示例:

# 安装 gopls(一般装一次即可)
go install golang.org/x/tools/gopls@latest
# 确认装到了 GOBIN
$(go env GOPATH)/bin/gopls version

# 安装常用辅助工具
go install honnef.co/go/tools/cmd/staticcheck@latest
go install github.com/go-delve/delve/cmd/dlv@latest

常见坑:

现象 原因 修法
编辑器报 "gopls is not installed" Go 插件没装或路径不对 手动 go install golang.org/x/tools/gopls@latest,重启编辑器
保存后 import 没自动整理 插件配置指向了 gofmt 而非 goimports VS Code 设置 "go.formatTool": "goimports"
跳转定义跳到了 pkg/mod 缓存里的旧版本 模块版本与编辑器加载的不一致 重启 gopls:命令面板执行 Go: Restart Language Server
调试时断点不生效 Delve 版本与 Go 版本不匹配 重新 go install github.com/go-delve/delve/cmd/dlv@latest

面试考法:这类问题在面试里出现频率不高,但工程评审常问"你怎么保证团队代码风格一致"。答到:gofmt/goimports 是强制的,CI 里跑 gofmt -l . 检查输出是否为空;go vet ./... 与 staticcheck ./... 作为提交前钩子。

5.5 HTTP 请求响应模型

为什么需要它:从阶段 5 开始你要写 HTTP 服务,本阶段先建立"请求由哪几部分组成、响应怎么判断对错"的直觉。不会用 curl 手动发请求,就只能在浏览器里点点点,看不到请求头与响应头。

核心机制:

  • 请求行:方法(GET/POST/PUT/DELETE)+ 路径 + HTTP 版本;请求头:Content-Type、Authorization、自定义 header;请求体:POST/PUT 的 JSON 或表单。
  • 响应状态码:200 成功、301/302 重定向、400 参数错、401 未认证、403 无权限、404 路径不存在、500 服务端内部错、502/504 网关错。
  • curl 常用参数:-i 显示响应头、-X POST 指定方法、-H "Key: Val" 加请求头、-d '...' 发请求体、-v 看完整交互过程。
  • 端口:一台机器可以同时监听多个端口,127.0.0.1:8080 表示只允许本机访问;0.0.0.0:8080 表示接受外部连接。

最小可运行示例:

# 用 Go 标准库起一个 5 行 HTTP 服务
cat > srv.go <<'EOF'
package main

import (
	"fmt"
	"net/http"
)

func main() {
	http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
		fmt.Fprintf(w, "path=%s method=%s", r.URL.Path, r.Method)
	})
	_ = http.ListenAndServe("127.0.0.1:8080", nil)
}
EOF
go run srv.go &

# 另开一个终端,用 curl 发请求
curl -i http://127.0.0.1:8080/hello
curl -i -X POST http://127.0.0.1:8080/hello
curl -i -H "X-Request-Id: 123" -d '{"a":1}' http://127.0.0.1:8080/hello

常见坑:

现象 原因 修法
curl: (7) Failed to connect 服务没起来,或端口写错 curl 前先 go run srv.go & 确认在跑;lsof -i :8080 看监听
返回 404 page not found 路径与注册的 handler 不匹配 Go 标准库 ServeMux 区分大小写与尾斜杠;看注册的精确路径
中文响应体在终端乱码 Content-Type 没带 charset=utf-8 响应头显式设置 text/plain; charset=utf-8
浏览器能访问但 curl 不能 服务绑在 127.0.0.1,curl 走了代理 用 --noproxy '*' 绕过代理,或绑 0.0.0.0

面试考法:"GET 和 POST 的本质区别""状态码 301 与 302 区别""502 与 504 区别"。答到:GET 是安全且幂等的、参数在 URL、POST 把数据放 body;301 是永久重定向(浏览器会缓存),302 是临时;502 是网关拿到无效响应(后端崩了),504 是网关等后端超时。

5.6 命令行与文件操作基础

为什么需要它:Go 写的命令行工具是工程里最常见的形态(CLI、迁移脚本、批处理)。本模块要求你会用 flag 包接参数、会读写文件、能区分相对路径与绝对路径——这是后面所有阶段练习的基础能力。

核心机制:

  • flag 包定义命令行参数:flag.String("name", "default", "help") 定义字符串参数,flag.Parse() 解析。
  • 文件读写用 os.ReadFile / os.WriteFile(一次性读写);按行读用 bufio.Scanner。
  • 相对路径是相对于进程当前工作目录,不是相对于源码文件位置;在 IDE 里点运行与在终端 cd 到不同目录跑,工作目录可能不同。
  • os.Args 是未解析的原始参数切片;flag 包适合带名字的参数,os.Args 适合位置参数。

最小可运行示例:

// echo.go:读文件、按行筛选、写新文件,带命令行参数
package main

import (
	"bufio"
	"flag"
	"fmt"
	"os"
	"strings"
)

func main() {
	in := flag.String("in", "", "输入文件路径(必填)")
	out := flag.String("out", "", "输出文件路径(必填)")
	kw := flag.String("kw", "", "按关键字筛选行")
	flag.Parse()

	if *in == "" || *out == "" {
		flag.Usage() // 自动打印 -h 帮助
		os.Exit(2)
	}

	f, err := os.Open(*in)
	if err != nil {
		fmt.Fprintln(os.Stderr, "open:", err)
		os.Exit(1)
	}
	defer f.Close()

	var kept []string
	sc := bufio.NewScanner(f)
	for sc.Scan() {
		line := sc.Text()
		if strings.Contains(line, *kw) {
			kept = append(kept, line)
		}
	}
	if err := sc.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "scan:", err)
		os.Exit(1)
	}

	// 写出结果,权限 0644
	if err := os.WriteFile(*out, []byte(strings.Join(kept, "\n")), 0644); err != nil {
		fmt.Fprintln(os.Stderr, "write:", err)
		os.Exit(1)
	}
	fmt.Printf("kept %d lines -> %s\n", len(kept), *out)
}
# 准备一个测试文件,然后运行
printf 'apple\nbanana\ncherry\n' > input.txt
go run echo.go -in input.txt -out output.txt -kw a
cat output.txt   # 期望:apple\nbanana

常见坑:

现象 原因 修法
报 open: no such file or directory 相对路径相对的是进程工作目录,不是源码目录 用绝对路径,或在运行前 cd 到正确目录;生产环境建议 -in 接绝对路径
flag: help 输出但参数没生效 flag.Parse() 没调用,或调用位置在读取 flag 之后 flag.Parse() 必须在所有 flag.Xxx() 之后、读参数之前
大文件 os.ReadFile 内存爆 一次性读进内存 用 bufio.Scanner 流式读
写文件报 permission denied 目录不可写或权限位错 检查目标目录;os.WriteFile 用 0644 不是 644(八进制)

面试考法:"命令行工具的参数应该怎么设计"。答到:必填参数校验在启动早期、错误信息打到 stderr 并以非零码退出、-h 输出用法、路径参数默认相对当前工作目录但应在文档里说明。

5.7 Linux 常用命令与进程概念

为什么需要它:Go 服务最终跑在 Linux 容器里。本阶段只要求能看懂"进程在不在、监听哪个端口、日志在哪",不要求会写 shell 脚本——这部分在阶段 7(05.8)会展开。

核心机制:

  • ps aux | grep app 看进程;top / htop 看 CPU 与内存实时占用。
  • lsof -i :8080(Linux/macOS)或 netstat -ano | findstr 8080(Windows)按端口找进程。
  • 环境变量:export PORT=8080 临时设置,进程启动时继承;os.Getenv("PORT") 在 Go 里读取。
  • 后台运行:nohup ./app & 让进程脱离终端;容器里不需要 nohup,由 init 进程托管。
  • 日志:约定打到 stdout/stderr,由容器运行时统一收集,不要写本地文件。

最小可运行示例:

# 起一个 HTTP 服务在后台,看它在不在
go run srv.go &
echo $!                 # 打印后台进程 PID(Linux/macOS)
lsof -i :8080           # 看谁在监听 8080
kill $!                 # 结束它

# 用环境变量控制端口
PORT=9090 go run srv.go &
# srv.go 里把 ListenAndServe 改成 ":" + os.Getenv("PORT")

常见坑:

现象 原因 修法
lsof: command not found 最小化镜像里没有 lsof 用 ss -ltnp 或 netstat -ltnp;容器里直接 ps 看
端口被占报 bind: address already in use 上一个进程没退干净 lsof -i :8080 找到 PID 后 kill
环境变量在 Go 里读不到 变量设在了另一个 shell 会话 export 后再启动进程;或在启动命令前直接 PORT=9090 ./app
日志写到本地文件后磁盘打满 没遵守 stdout 约定 改成 fmt.Println 打到 stdout,由 Docker 收集

面试考法:"一个进程监听 8080 但外部访问不到,怎么排查"。答到:先看进程是否真的起来(ps),再看绑的是 127.0.0.1 还是 0.0.0.0(前者外部不通),再看防火墙与安全组,最后看容器端口映射。

六、分层练习

三档练习逐档升级,上一档没做完不要跳。

6.1 复现型(照着做,目标是"跑通 + 能解释")

练习 要求 验收标准 预计耗时
安装并配置 Go 装完后 go version、go env GOPATH、go env GOPROXY 都正常 三条命令输出与 5.1 示例一致 1 小时
交叉编译 在 Windows 上产出一个 Linux amd64 二进制 二进制拷到 Linux 机器(或 WSL)能 ./hello 直接跑 1 小时
引入第三方库 go mod init 后 go get github.com/redis/go-redis/v9 go.mod 出现 require 行,go build ./... 通过 0.5 小时
curl 手动发请求 用 5.5 的 srv.go 起服务,用 curl -i 发 GET/POST 能指出响应头里的 Content-Type、状态码、响应体 0.5 小时
flag 工具 用 5.6 的 echo.go 处理一个 100 行文本文件 输出文件只含匹配行;错误参数时退出码非 0 1 小时

6.2 改造型(给出现成代码,改出正确行为)

练习 要求 验收标准 预计耗时
改绑定地址 把 ListenAndServe("127.0.0.1:8080", nil) 改成读 PORT 环境变量 不重启代码,PORT=9090 go run srv.go 就监听 9090 0.5 小时
静态编译瘦身 用 go build -ldflags "-s -w" 构建,对比二进制体积 体积比默认构建小 30% 以上,运行行为不变 0.5 小时
错误处理改造 给 echo.go 的文件打开错误加上文件名与行号位置 错误信息形如 open input.txt: no such file or directory,并打到 stderr 1 小时
加一个子命令 给 echo.go 加 --version 旗标,打印版本号 go run echo.go --version 直接退出,不做其他事 1 小时

6.3 设计型(自己定方案,目标是"能交付、能讲清取舍")

练习 要求 验收标准 预计耗时
个人笔记 CLI 支持 add "内容"、list、search 关键字 三个子命令,数据存 JSON 文件 子命令分发清晰;JSON 文件可读;错误参数有帮助输出 4 小时
静态站点体检脚本 输入一个 URL,输出状态码、响应时间、Content-Type、大小 用 net/http 与 time.Since;表格化输出;支持批量 URL 列表 4 小时
环境巡检工具 启动时打印 go version、GOPATH、GOPROXY、当前目录、监听端口 输出形式可直接贴进 issue 报告;不依赖额外库 2 小时

七、排障表

现象 可能原因 排查步骤 解决办法
go: command not found GOROOT/bin 未加入 PATH echo $PATH(PowerShell $env:PATH)看路径 安装包勾选 PATH,或手动加 /usr/local/go/bin
go get 报 dial tcp: lookup proxy.golang.org 默认代理在国内不可达 go env GOPROXY 看当前值 go env -w GOPROXY=https://goproxy.cn,direct
bind: address already in use 上一个进程没退干净 lsof -i :8080(Windows netstat -ano \| findstr 8080) kill <PID>,或换端口
curl: (7) Failed to connect 服务没起、绑在 127.0.0.1 或防火墙拦截 ps 看进程;lsof -i :8080 看绑定地址 起服务;绑 0.0.0.0;检查防火墙
编辑器报 "gopls is not installed" 插件找不到 gopls which gopls(PowerShell Get-Command gopls) go install golang.org/x/tools/gopls@latest,重启编辑器
编译出的二进制在 Linux 报 cannot execute binary file GOOS/GOARCH 与目标架构不符 uname -m 看目标架构 重新交叉编译,GOOS=linux GOARCH=amd64
open: no such file or directory 相对路径相对进程工作目录 在错误信息里打印当前工作目录 os.Getwd() 用绝对路径,或在正确目录启动
permission denied 执行二进制 没有可执行权限 ls -l app 看权限位 chmod +x app(Windows 下直接 ./app.exe)

八、出口条件

全部勾选后再进入 05.2 阶段 1 语言基础与数据类型。

  • [ ] 在终端任意目录执行 go version、go env GOPATH、go run hello.go 都正常,不依赖 IDE
  • [ ] 能解释 GOROOT、GOPATH、GOBIN、GOPROXY 四个变量各自指向什么
  • [ ] 能在本模块目录下用 go mod init 建模块并 go get 引入一个第三方库,go build ./... 通过
  • [ ] 能在 Windows 上交叉编译出 Linux amd64 二进制并直接运行
  • [ ] 能用 curl -i 向本地服务发 GET 与 POST,并指出响应头里的状态码与 Content-Type
  • [ ] 能用 flag 包写一个接收参数的 CLI 工具,错误参数时退出码非 0
  • [ ] 能用 lsof -i :8080(或 netstat)定位一个占用端口的进程

自测题(先自己想,再看要点):

  1. go run hello.go 和 go build hello.go 的产物有什么区别?
    • 要点:前者编译到临时目录并立即执行,不产出可分发文件;后者在当前目录产出二进制,可拷到同架构机器直接运行。
  2. GOROOT 与 GOPATH 分别是什么?为什么不要把代码放进 GOPATH/src?
    • 要点:GOROOT 是 Go 安装目录,GOPATH 是用户工作区(含 bin 与 mod 缓存);Go Modules 之后任意目录可建模块,GOPATH/src 是 1.11 之前的旧约定。
  3. 国内 go get 拉不动依赖,应该改哪个环境变量?临时改与永久改有什么区别?
    • 要点:GOPROXY;临时改在 shell 里 export,永久改用 go env -w GOPROXY=...(写入 ~/.config/go/env)。
  4. 一个 HTTP 服务绑在 127.0.0.1:8080,局域网其他机器访问不到,为什么?
    • 要点:127.0.0.1 只接受本机回环连接;要外部访问需绑 0.0.0.0:8080,再确认防火墙与安全组。
  5. 你写的 CLI 工具在 IDE 里点运行能读到 input.txt,在终端 cd 到别的目录运行就读不到,为什么?
    • 要点:相对路径相对的是进程当前工作目录,不是源码文件位置;IDE 与终端的工作目录不同。
  6. go build -ldflags "-s -w" 的作用是什么?为什么生产构建要用它?
    • 要点:-s 去符号表、-w 去 DWARF 调试信息,能让二进制体积缩小 30%–50%,不影响运行;生产镜像越小越好。