Day 1｜Go 的设计哲学 & 开发环境[Go 语言 30 天系统学习计划]

作者

学习目标
1. 建立正确的 Go 语言心智模型
2. 完成标准 Go 开发环境与 Module 初始化
3. 理解 Go 为什么“简单但不随意”

一、为什么 Go 看起来简单，却不容易写好

如果你有 Java / PHP / Python / C++ 等开发经验，初看 Go 往往会觉得：

  • 语法很少
  • 没有继承、异常、宏
  • 写法“啰嗦”

但 Go 的核心价值 不在语法表达能力，而在工程约束能力。

Go 的目标不是：

  • 写最短的代码
  • 写最聪明的代码

而是：

  • 写 10 年后还能维护的代码
  • 写 多人协作下不出事故的代码

二、Go 的三大设计哲学（必须理解）

1. 显式优于隐式（Explicit is better than implicit）

Go 反对“偷偷帮你做事”。

体现点
  • 错误是返回值，不是异常
  • 没有隐式类型转换
  • 没有默认参数
  • 未使用变量 / import 直接编译失败
示例：错误必须显式处理
v, err := strconv.Atoi("123")
if err != nil {
    fmt.Println(err)
}

过程说明：

  • err 是普通返回值
  • 编译器强迫你“看到”错误

结论：

Go 不替你兜底，但确保你不会忽略风险

2. 组合优于继承（Composition over inheritance）

Go 没有继承机制，但支持更安全的组合。

示例：struct 嵌入
type Logger struct{}

func (l *Logger) Log(msg string) {
    fmt.Println("log:", msg)
}

type Service struct {
    Logger
}

func main() {
    s := Service{}
    s.Log("hello")
}

过程说明：

  • Service 并不是 Logger 的“子类”
  • 只是“拥有 Logger 的能力”

结论：

Go 组合的是能力，不是类型层级

3. 简单优于聪明（Simplicity over cleverness）

Go 在语法层面刻意限制复杂度：

  • 只有一种循环：for
  • 没有 while / do-while
  • 没有运算符重载
  • 没有宏
for i := 0; i < 3; i++ {
    fmt.Println(i)
}

结论：

Go 把复杂度留给架构，不留给语法

三、Go 程序的执行模型

Go 程序从 main 包的 main 函数开始执行。

package main

func main() {
    // 程序入口
}

强制规则：

  • 可执行程序只能有一个 main 包
  • main 包中必须有 main() 函数

四、Go 开发环境与 Module 初始化

1. 验证 Go 安装

go version

2. 初始化 Go Module（必须）

mkdir hello-go
cd hello-go
go mod init hello-go

生成文件：

go.mod

说明：

  • Go Module 是依赖与版本的唯一管理方式
  • GOPATH 已经是历史方案

五、第一个 Go 程序

// main.go
package main

import "fmt"

func main() {
    fmt.Println("Hello, Go")
}

运行：

go run main.go

输出结果：

Hello, Go

六、Go 的基础工具链（每天都会用）

1. go run

go run main.go
  • 编译 + 运行
  • 适合开发期

2. go build

go build
  • 生成可执行文件
  • 不运行

3. go fmt（强制风格）

go fmt ./...

说明：

  • Go 没有风格争论
  • gofmt 是语言规范的一部分

4. go vet（静态检查）

go vet ./...

七、package 与 import 基本规则

1. package 是编译单元

package main
  • 同一目录下文件必须同 package
  • package 名通常与目录名一致

2. import 规则

import (
    "fmt"
    "time"
)
  • 未使用的 import 会直接编译失败
  • 这是刻意设计，用于减少隐患

八、Day 1 必须掌握的关键点

  1. Go 是工程语言，不是炫技语言
  2. 显式错误是优势
  3. 组合替代继承
  4. 工具链是语言的一部分
  5. 代码是写给“后来的人”看的

预告：Day 2

Day 2｜变量、控制流与值语义

你将彻底理解：

  • Go 的值拷贝模型
  • defer 的执行顺序
  • for + goroutine 的经典陷阱

发表评论