语法 on Liangweidong's blog

Go 核心语法精要：指针、make/new、接口、闭包与函数式编程

Mon, 15 Apr 2019 00:00:00 +0800

前置知识

Go 基础语法（package、func、struct、if/for）
了解 C/C++ 的指针（Go 指针是无 C 那么灵活）
至少用一种 OOP 语言写过代码

为什么这篇文章很重要

Go 的语法设计经常让 Java/Python 转 Go 的人踩坑连连：

make vs new 到底用哪个
指针不能算术运算，但又不像 Java 那样完全无指针
map 是引用类型，传参居然"几乎"按引用传
闭包在 for 循环里捕获变量——经典坑
“接口” 不是抽象类，不能有成员变量

这一篇把 Go 最容易"看文档一眼就懂、写代码就懵"的核心概念一次性厘清。

一、make 与 new 的区别

1.1 一句话总结

make：初始化 内置数据结构（slice、map、channel），返回引用类型本身
new：分配内存 给任意类型，返回指向零值的指针

1.2 make 用法

1
2
3
4
5
6
7
8


// 切片：长度 0，容量 100
slice := make([]int, 0, 100)

// map：初始容量 10
hash := make(map[int]bool, 10)

// channel：缓冲区 5
ch := make(chan int, 5)

底层真相：

slice 是 reflect.SliceHeader 结构体（含 data 指针、len、cap）
map 实际是 *runtime.hmap 指针
chan 实际是 *runtime.hchan 指针

1.3 new 用法

1
2
3
4
5


i := new(int) // *int，指向 0
*p := 42 // 解引用赋值

v := new(int)
fmt.Println(*v) // 0

等价写法：

1
2
3


i := new(int) // *int → 0
var v int // int → 0
i = &v // i 指向 v

1.4 对比表

维度	make	new
用途	初始化内置数据结构	分配内存给任意类型
适用类型	slice、map、channel	任意类型
返回	引用类型本身	指向类型零值的指针
是否清零	是（并初始化内部结构）	是（清零）

二、指针：Go 的"受限"指针

2.1 指针基础

1
2
3
4
5
6


// 声明
var p *int // nil 指针
var m int = 100
p = &m // p 指向 m
*p = 1 // 通过指针改 m
fmt.Println(*p) // 1

2.2 用 new 初始化

1
2
3


var p *int
p = new(int)
*p = 1

2.3 取消引用

1
2
3
4
5
6
7
8
9


func demo3() {
 a := 100
 b := &a
 fmt.Printf("a：%d\n", a) // a：100
 fmt.Printf("b：%v\n", b) // b：0xc00000a098
 fmt.Printf("*b：%v\n", *b) // *b：100
 *b = 200
 fmt.Printf("a：%d\n", a) // a：200
}

2.4 指向指针的指针

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


func demo4() {
 a := 7.98
 p := &a
 pp := &p

 fmt.Println("a =", a) // 7.98
 fmt.Println("address of a =", &a) // 0xc00000a098
 fmt.Println("p =", p) // 0xc00000a098
 fmt.Println("address of p =", &p) // 0xc000006028
 fmt.Println("pp =", pp) // 0xc000006028

 // 双重解引用
 fmt.Println("*pp =", *pp) // 0xc00000a098
 fmt.Println("**pp =", **pp) // 7.98
}

2.5 Go 没有指针算术

1
2
3


var x = 67
var p = &x
var p1 = p + 1 // 编译错误：invalid operation

好处：杜绝 C 那种野指针越界访问——安全！
代价：底层数据操作不够灵活，得用 unsafe.Pointer 绕。

2.6 指针比较

1
2
3


p1 := &a
p2 := &a
fmt.Println(p1 == p2) // true：同一地址

2.7 简单类型的指针

1
2
3
4
5
6
7
8
9


func main() {
 p := 5
 change(&p)
 fmt.Println("p =", p) // p = 0
}

func change(p *int) {
 *p = 0
}

2.8 值类型 vs 引用类型的"传参魔法"

Go 所有参数都是值传递——但 map、slice、channel 是引用类型的零值结构，传参相当于传了"指针副本"。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


func main() {
 m := map[string]int{"one": 1, "two": 2}
 n := m
 fmt.Printf("%p\n", &m) // 0xc000074018
 fmt.Printf("%p\n", &n) // 0xc000074020
 fmt.Println(m) // map[one:1 two:2]
 fmt.Println(n) // map[one:1 two:2]

 changeMap(m)
 fmt.Println(m) // map[one:1 two:2 three:3]
 fmt.Println(n) // map[one:1 two:2 three:3] ← 跟着变
}

func changeMap(m map[string]int) {
 m["three"] = 3
 fmt.Printf("changeMap func %p\n", m)
}

m 和 n 是不同 map header（地址不同），但都指向同一份底层 hash 表——改一个，两个都变。

2.9 显式传指针

1
2
3


func changeMap(m *map[string]int) {
 (*m)["three"] = 3 // 必须先解引用
}

不推荐——多此一举，map 本身已经"几乎按引用传"了。

2.10 总结

Go 不支持指针算术（安全）
指针传递只占 4 / 8 字节（高效）
函数方法的接受者可以是值或指针
复杂类型（map/slice/chan）传递的是"指针副本"

三、接口：Go 的"鸭子类型"

3.1 定义

1
2
3


type MyInterface interface {
 Error() string
}

特性：

只能有方法签名，不能有成员变量
隐式实现——只要类型实现了接口的所有方法，就自动满足接口
空接口 interface{} 等价于 Java 的 Object、C++ 的 void*

3.2 经典示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


type Speaker interface {
 Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "汪汪汪" }

type Cat struct{}
func (c Cat) Speak() string { return "喵喵喵" }

func main() {
 var s Speaker
 s = Dog{}
 fmt.Println(s.Speak()) // 汪汪汪
 s = Cat{}
 fmt.Println(s.Speak()) // 喵喵喵
}

Dog 和 Cat 都没显式说"我实现了 Speaker"——只要方法对得上，编译就过。

3.3 常见接口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// fmt.Stringer
type Stringer interface {
 String() string
}

// error
type error interface {
 Error() string
}

// io.Reader
type Reader interface {
 Read(p []byte) (n int, err error)
}

// io.Writer
type Writer interface {
 Write(p []byte) (n int, err error)
}

3.4 类型断言

1
2
3
4


var s Speaker = Dog{}
if d, ok := s.(Dog); ok {
 fmt.Println("这是 Dog：", d.Speak())
}

3.5 接口 vs 抽象类（Java/C++）

维度	Go 接口	Java interface / C++ 抽象类
成员变量	无	常量 / 静态变量（Java 8+）
默认方法	无	Java 8+ default method
实现方式	隐式	显式 `implements`
多继承	任意多	受限
嵌入接口	支持	不直接支持

四、函数式编程：命令式 vs 函数式

4.1 编程范式

1979 年图灵奖得主 Robert Floyd 在颁奖演说中使用"编程范式"一词。常见范式：

命令式 / 过程式（C、Pascal）
面向对象（Java、C++、Python）
声明式（SQL、HTML、CSS）
函数式（Haskell、Lisp、ML、Go 部分支持）
泛型编程（C++ STL、Go 1.18+）

4.2 命令式编程

1
2
3
4
5


// 一行一行告诉计算机先做什么再做什么
sum := 0
for i := 1; i <= 100; i++ {
 sum += i
}

思想：模拟冯·诺依曼机运行机制，按指令顺序排列。
适用：线性、按部就班的算法问题。
不足：非结构化、复杂算法时极其困难。

4.3 面向对象

1
2
3
4
5
6
7


type Animal struct {
 Name string
}

func (a *Animal) Speak() string {
 return a.Name + " makes a sound"
}

三大特性：

封装：隐藏实现细节
继承：子类复用父类
多态：同一消息不同响应

4.4 声明式编程

1

SELECT * FROM users WHERE age > 18

只描述"做什么"不描述"怎么做"。

4.5 函数式编程

1
2
3
4
5
6
7
8


// 一等公民：函数可以当参数、返回值、变量
func Map[T, U any](ts []T, f func(T) U) []U {
 us := make([]U, len(ts))
 for i, t := range ts {
 us[i] = f(t)
 }
 return us
}

核心思想：

函数是"一等公民"
没有"语句"只有"表达式"
无副作用——同一输入永远同一输出
不可变——不修改变量，返回新值

4.6 函数式 vs 命令式

维度	命令式	函数式
关注点	步骤（先做什么）	关系（输入 → 输出）
变量	可变（存储状态）	不可变（代数变量）
循环	for/while	递归
状态	依赖外部	不依赖
并发	需锁	无共享，无需锁

函数式优势：

单元测试容易——纯函数 = 输入输出对
并发安全——不共享状态，无 race condition
惰性求值——表达式不计算直到使用
模式匹配——代数数据类型 + case 表达
错误容易复现——不依赖运行历史

Go 的函数式特性：

函数是一等公民
高阶函数（函数当参数/返回值）
闭包
偏应用函数
柯里化（手动）
❌ 没有惰性求值、模式匹配、不可变集合

五、闭包：Go 里的"陷阱"与"利器"

5.1 闭包定义

闭包 = 函数 + 引用环境

1
2
3
4
5
6
7


func closure() func(int) int {
 var x int
 return func(b int) int {
 x++
 return b + x
 }
}

返回的匿名函数捕获了 x——x 逃逸到堆，闭包整个生命周期内都有效。

5.2 经典案例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


func AnotherExFunc(n int) func() {
 n++
 return func() {
 fmt.Println(n)
 }
}

func ExFunc(n int) func() {
 return func() {
 n++
 fmt.Println(n)
 }
}

func main() {
 myAnotherFunc := AnotherExFunc(20)
 fmt.Println(myAnotherFunc) // 0x48e3d0
 myAnotherFunc() // 21
 myAnotherFunc() // 21

 myFunc := ExFunc(10)
 fmt.Println(myFunc) // 0x48e340
 myFunc() // 11
 myFunc() // 12
}

分析：

AnotherExFunc 在 n++ 后定义闭包，所以闭包捕获的是 21——后续调用不修改 n
ExFunc 把 n++ 放在闭包里——每次调用都 n++

5.3 for 循环闭包陷阱

1
2
3
4
5
6
7
8
9


func main() {
 s := []string{"a", "b", "c"}
 for _, v := range s {
 go func() {
 fmt.Println(v)
 }()
 }
 time.Sleep(time.Second)
}

输出：c c c（不是 a b c）——闭包捕获的是循环变量 v 本身（同一个地址），不是每次迭代的值。

解法 1：传参

1
2
3
4
5


for _, v := range s {
 go func(v string) {
 fmt.Println(v)
 }(v)
}

解法 2：Go 1.22+

Go 1.22 改进了 for 循环变量——每次迭代是独立变量：

1
2
3
4
5
6


// Go 1.22+
for _, v := range s {
 go func() {
 fmt.Println(v) // a, b, c
 }()
}

5.4 多次调用独立性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


func intSeq() func() int {
 i := 0
 return func() int {
 i++
 return i
 }
}

func main() {
 nextInt := intSeq()
 println(nextInt()) // 1
 println(nextInt()) // 2
 println(nextInt()) // 3

 newInts := intSeq()
 println(newInts()) // 1（独立闭包）
}

5.5 defer 与闭包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


func main() {
 x, y := 1, 2
 defer func(a int) {
 fmt.Printf("x:%d,y:%d\n", a, y)
 }(x) // 复制 x
 x += 100
 y += 100
 fmt.Println(x, y) // 101 102
}

// 输出：
// 101 102
// x:1,y:102

关键：defer 注册时复制了 x 的值，但 y 是闭包引用——闭包持有 y 的地址，y 改了就跟着改。

5.6 闭包对 GC 的影响

闭包引用的变量逃逸到堆——比局部变量多一次 GC 开销。

1
2


go build -gcflags "-N -l -m" closure.go
# moved to heap: x

六、判断结构体是否为空

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 方法 1：直接比较（不适用于含 slice/map/func 字段的 struct）
var st Person
if (Person{} == st) {
 fmt.Println("空")
}

// 方法 2：reflect.DeepEqual
import "reflect"
reflect.DeepEqual(st, Person{})

// 方法 3：自定义 IsEmpty 方法
func (p Person) IsEmpty() bool {
 return p.Name == "" && p.Age == 0
}

七、string 与 int 互转

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


import "strconv"

// string → int
i, err := strconv.Atoi("123")

// string → int64
i64, err := strconv.ParseInt("123", 10, 64)

// int → string
s := strconv.Itoa(123)

// int64 → string
s := strconv.FormatInt(123, 10)

八、下一步

泛型（Go 1.18+）—— func Map[T, U any](ts []T, f func(T) U) []U
错误处理：errors.Is / errors.As / fmt.Errorf("%w", err)
Context：context.Context 控制 goroutine 生命周期
反射：reflect 包做通用编程
unsafe：unsafe.Pointer 底层操作

参考资料

Go 官方教程：https://go.dev/tour/
Go 语言规范：https://go.dev/ref/spec
《Go 程序设计语言》（The Go Programming Language）
《Go 语言高级编程》—— 柴树衫、曹春晖
Go FAQ：https://go.dev/doc/faq

英语词性速查：开放类与封闭类 11 大词性精要

Mon, 15 May 2017 00:00:00 +0800

背景：英语词性（part of speech）是读英文文档、写技术博客、面试英语 question 的最底层语法。很多程序员读 GitHub README 卡壳、写英文 commit message 词不达意、做英语面试自我介绍时主谓不一致——根因往往不是单词量不够，而是词性边界不清（把形容词当副词用、把限定词当形容词用）。本文用 11 大词性 + 例句对照表，把"什么词能修饰什么、能做什么成分"一次说清。

Why 2026 还重要：从 2017 年写这篇到 2026 年，词性边界不清的问题一个都没消失——GitHub Copilot 写出来的英文 commit 90% 词性错配，AI 翻译工具仍然搞不定"形容词/副词"边界。词性是底层基础设施——AI 再强，词性没搞懂，写出来的东西机器能读、人读起来别扭。

一、为什么程序员要学词性

1.1 三个真实场景

场景	卡壳点	根因
读 RFC 文档	“The packet is fragmented by the router.”	不知道 `fragmented` 是过去分词（形容词性），作表语
写 commit message	“Fix bug where user can’t login”	漏写助动词 `does`，因为不知道情态动词要 + 动词原形
英语面试	“I’m a developer responsible for backend.”	把 `responsible`（形容词）当动词用
读代码注释	`// Function to quickly sort the array`	把 `quickly`（副词）当形容词用修饰 `sort`（动词）是对的；但 `// A quick sort` 修饰 `sort` 又是错的——`sort` 是名词，形容词 OK
Stack Overflow 答题	“I am interesting in this problem”	漏写 `interested`——`interesting` 是形容词（修饰物），`interested` 是形容词（修饰人）

1.2 词性的"开放"和"封闭"区别

开放类（Open Class）：可以创造新词，词典不断更新。包含：名词、动词、形容词、副词、代词
封闭类（Closed Class）：数量固定，不能创造新词。包含：介词、连词、冠词、数词、感叹词、限定词

类比记忆：开放类像"开源代码库"（PR 不断合并新词），封闭类像"标点符号"（已经定型）。

二、开放类 5 大词性

2.1 名词（Noun, n.）

定义：表示人、事物、地点、概念或情感的词。

分类：

分类	例子	说明
普通名词	`book` `dog` `computer`	泛指
专有名词	`China` `Tom` `Linux`	首字母大写，特指
可数名词	`apple` `bug` `function`	有单复数
不可数名词	`water` `information` `code`	无单复数

例句：

The book is on the desk.（这本书在桌子上。）

标志：可作主语、宾语、表语；可被形容词修饰；可加 -s 变复数（可数时）。

2.2 动词（Verb, v.）

定义：表示动作、状态或发生的词。

分类：

分类	例子	说明
实义动词	`run` `eat` `compile`	有具体含义
系动词	`be` `become` `seem`	连接主语和表语
助动词	`do` `have` `will`	帮助构成时态、语态、疑问句
情态动词	`can` `must` `should` `may`	表能力/义务/可能

例句：

She sings very well.（她唱歌很好听。）

5 种基本形式（以 take 为例）：

形式	例子	用法
原形	`take`	一般现在时
第三人称单数	`takes`	he/she/it + 动词
过去式	`took`	一般过去时
过去分词	`taken`	完成时、被动态
现在分词	`taking`	进行时

程序员陷阱：build → built → built（不规则）；commit → committed → committed（双写 t + ed）

2.3 形容词（Adjective, adj.）

定义：修饰名词或代词，表示性质、特征、数量或状态。

例句：

This is a beautiful flower.（这是一朵漂亮的花。）

比较级与最高级：

规则	原级	比较级	最高级
一般加 -er/-est	`tall`	`taller`	`tallest`
辅音字母 + y 变 i	`easy`	`easier`	`easiest`
重读闭音节双写	`big`	`bigger`	`biggest`
多音节用 more/most	`beautiful`	`more beautiful`	`most beautiful`
不规则	`good` `bad`	`better` `worse`	`best` `worst`

标志：可作定语（前置：a fast car）或表语（后置：The car is fast）。

2.4 副词（Adverb, adv.）

定义：修饰动词、形容词、其他副词或整个句子，表示时间、地点、方式、程度等。

例句：

He runs fast.（他跑得很快。）

6 大类副词：

类型	例子	问什么
时间	`now` `yesterday` `often`	When?
地点	`here` `there` `everywhere`	Where?
方式	`quickly` `slowly` `carefully`	How?
程度	`very` `quite` `almost`	How much?
频率	`always` `usually` `sometimes`	How often?
疑问/连接	`why` `how` `therefore`	Why?/How?

常见误区：hard（努力地，形容词也是 hard）是少数既可作形容词也可作副词且同形的词。He works hard.（副词，修饰动词）/ It's a hard problem.（形容词，修饰名词）

2.5 代词（Pronoun, pron.）

定义：用来代替名词、名词短语或句子，避免重复。

8 大分类：

分类	例子	用法
人称代词	`I` `you` `he` `she` `it` `we` `they`	主语/宾语
物主代词	`my` `your` `his`（形容词性）/`mine` `yours`（名词性）	表示所属
反身代词	`myself` `yourself` `themselves`	强调/反身
指示代词	`this` `that` `these` `those`	指代方向
疑问代词	`who` `what` `which`	引导疑问句
关系代词	`who` `which` `that`	引导定语从句
不定代词	`some` `any` `all` `none` `each`	不定指代
相互代词	`each other` `one another`	相互关系

例句：

She is a teacher.（她是一名教师。）

The package that you sent has arrived.（你寄的包裹到了。）

三、封闭类 6 大词性

3.1 介词（Preposition, prep.）

定义：表示名词或代词与其他词之间的关系（时间、地点、方向、方式等）。

5 大类：

类型	例子
时间	`at` `on` `in` `during` `since` `for`
地点	`in` `on` `at` `under` `behind` `between`
方向	`to` `from` `into` `out of` `towards`
方式	`by` `with` `without` `through`
其他	`about` `of` `against` `as`

例句：

The cat is under the table.（猫在桌子下面。）

at 5 o’clock / on Monday / in 2026

3.2 连词（Conjunction, conj.）

定义：连接单词、短语、从句或句子。

3 大类：

分类	例子	用法
并列连词	`and` `but` `or` `so` `yet`	连接并列成分（7 个：FANBOYS）
从属连词	`because` `when` `if` `although` `while`	引导从句
关联连词	`both...and` `either...or` `neither...nor` `not only...but also`	成对使用

例句：

I like coffee but I don’t like tea.（我喜欢咖啡，但不喜欢茶。）

Although it’s raining, we still go out.（虽然下雨，我们还是出门。）

3.3 冠词（Article, art.）

定义：放在名词前，帮助说明名词所指的人或事物。

3 大类：

分类	例子	用法
不定冠词	`a` / `an`	泛指、可数单数；`a` 后辅音音素开头，`an` 后元音音素开头
定冠词	`the`	特指（双方都知道的事物、最高级、序数词、独一无二的事物）
零冠词	无	复数名词/不可数名词泛指时

例句：

She is a student.（她是一名学生。）

The book I bought is interesting.（我买的那本书很有趣。）

/ Books are my friends.（书是我的朋友。）

坑：a university（不是 an university，因为 university 发音是 /juː/，是辅音音素）

3.4 数词（Numeral, num.）

定义：表示数量或顺序的词。

2 大类：

分类	例子	用法
基数词	`one` `two` `three` `ten` `hundred`	数量
序数词	`first` `second` `third` `tenth`	顺序

例句：

There are three apples on the plate.（盘子里有三个苹果。）

He is in the first grade.（他在一年级。）

不规则序数词必背：one → first two → second three → third five → fifth eight → eighth nine → ninth twelve → twelfth（其余 + th）

3.5 感叹词（Interjection, interj.）

定义：表示强烈的情感，独立于句子结构之外。

常见：oh wow ah oops hey alas ouch hmm yeah nope

例句：

Wow! That’s amazing!（哇！太神奇了！）

Oops, I made a mistake.（哎呀，我犯了个错。）

Hmm, let me think.（嗯，让我想想。）

3.6 限定词（Determiner, det.）

定义：限定名词的范围、数量、所有关系等。很多人把它误归为形容词——但严格语法学派把它独立出来。

5 大类：

分类	例子	例句
物主限定词	`my` `your` `his` `her` `its` `our` `their`	my pen（我的笔）
指示限定词	`this` `that` `these` `those`	this apple（这个苹果）
数量限定词	`some` `any` `many` `much` `few` `little`	some water（一些水）
疑问限定词	`which` `what` `whose`	Which car is yours?（哪辆车是你的？）
不定限定词	`a` `an` `the`（冠词也是限定词的一种）	a book（一本书）

关键区别：my（限定词）vs mine（代词）

This is **my** book.（限定词，限定 book）

Mine is on the table.（代词，代替 my book）

四、11 类词性速查表

词性	英文	缩写	核心功能	例子
名词	Noun	n.	人事物概念	`book` `code`
动词	Verb	v.	动作状态	`run` `compile`
形容词	Adjective	adj.	修饰名词	`big` `fast`
副词	Adverb	adv.	修饰动/形/副/句	`quickly` `very`
代词	Pronoun	pron.	代替名词	`he` `it` `this`
介词	Preposition	prep.	关系	`in` `on` `at`
连词	Conjunction	conj.	连接	`and` `but` `if`
冠词	Article	art.	限定名词	`a` `an` `the`
数词	Numeral	num.	数量/顺序	`one` `first`
感叹词	Interjection	interj.	情感	`oh` `wow`
限定词	Determiner	det.	限定名词	`my` `this` `some`

五、程序员英语常见词性错误

错误	正确	分析
“The code run fast.”	“The code runs fast.”	主语是单数第三人称，动词要加 `-s`
“I’m interest in AI.”	“I’m interested in AI.”	`interested` 是过去分词（形容词性），表示"我被引起兴趣"
“I can runs faster.”	“I can run faster.”	情态动词后接动词原形
“Hardly work”	“I work hard.”	`hardly` 是"几乎不"（否定），`hard` 才是"努力地"
“I’m a success developer.”	“I’m a successful developer.”	`successful` 形容词修饰名词；`success` 是名词
“Discuss about the issue”	“Discuss the issue”	`discuss` 是及物动词，后面直接接宾语，不要加 about

六、3 个实战训练法

6.1 句子成分分析法

任意找一句英文，用 5 个 W 标注每个词：

1
2
3


[She] [sings] [very] [well] [in] [the] [room].
 代词 动词 副词 副词 介词 冠词 名词
 主语 谓语 状语 状语 状语 定语 状语

6.2 GitHub README 词性扫盲

读任意开源项目 README，圈出 11 类词性的出现频次——你会发现名词（30%）+ 动词（25%）+ 限定词/冠词（20%）+ 形容词（10%）+ 介词（10%） 这 5 类就占了 95%。

6.3 commit message 词性自查

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# ❌ 错（缺助动词）
Fix bug where user can't login.

# ✅ 对（一般现在时第三人称 + can + 动词原形）
Fix bug where user can't log in.

# ❌ 错（形容词当副词用）
The function return quick.

# ✅ 对（quickly 副词修饰动词 return）
The function returns quickly.

七、词性在 GitHub/CI/CD/Stack Overflow 中的实战对照表

下面是程序员日常高频场景的"词性错配"对照表，背下来能避开 90% 英文写作的尴尬：

场景	错（词性错配）	对（词性正确）	错配类型
commit message	`Fix bug where user can't login`	`Fix bug where user can't log in`	漏加空格（login 是名词，log in 是动词短语）
commit message	`Add new feature`	`Add a new feature`	漏冠词（feature 是可数名词单数）
PR description	`This PR fix the bug`	`This PR fixes the bug`	主谓不一致（PR 是单数第三人称）
PR description	`I has tested it`	`I have tested it`	助动词错误（I + have，不是 has）
Stack Overflow 提问	`How to learn English?`	`How do I learn English?`	缺少助动词 do
代码注释	`// Return the result quick`	`// Return the result quickly`	副词形式错误（修饰动词要用副词）
代码注释	`// The function is use to sort`	`// The function is used to sort`	语态错误（被动语态用过去分词）
README	`This library help you to X`	`This library helps you to X`	主谓不一致（library 是单数第三人称）
CHANGELOG	`Breaking change`	`Breaking change`（这条对的，但加 “in API” 才对完整）	缺修饰成分
issue 描述	`It's not working on my machine`	`It doesn't work on my machine`	缩写歧义（working 是名词/动名词，work 是动词）

记住 3 条铁律：

第三人称单数（he/she/it/library/PR/function）→ 动词加 s：works、fixes、returns
助动词 do/does/did 后 → 动词用原形：does fix、do work、did return
形容词修饰名词、副词修饰动词：quick function（形容词）、work quickly（副词）

八、参考与延伸

English Parts of Speech (Britannica)：https://www.britannica.com/topic/part-of-speech
Cambridge Dictionary Grammar：https://dictionary.cambridge.org/grammar/british-grammar
EnglishClub 词性专题：https://www.englishclub.com/grammar/parts-of-speech/
EnglishPage 语法在线课：https://www.englishpage.com/grammar/
GitHub Open Source Guide 英文写作规范：https://opensource.guide/how-to-contribute/#communicating-effectively
Google Developer Documentation Style Guide：https://developers.google.com/style（程序员英文技术写作圣经）
Conventional Commits 规范：https://www.conventionalcommits.org/（commit message 词性规范的"事实标准"）
Stack Overflow 英语提问指南：https://stackoverflow.com/help/how-to-ask

下一步：挑一本英语语法书（如《赖世雄语法》薄荷阅读/《English Grammar in Use》剑桥中级）系统过一遍；接下来读英文 RFC / Stack Overflow 时主动标注词性，3 个月后就能形成"语感"。