标签 Naming 下的文章

Dave Cheney 复出首谈:那些我反复强调的Go编程模式

本文永久链接 – https://tonybai.com/2025/09/17/some-things-i-keep-repeating-about-go

大家好,我是Tony Bai。

在阔别公众视野数年后,Go 社区的传奇人物 Dave Cheney 终于重返 GopherCon Europe 的舞台,发表了一场备受瞩目的复出首谈(注:我印象中的回归首谈^_^)。这场题为《那些我反复强调的 Go 编程之事》的演讲,没有追逐时髦的技术热点,而是选择回归编程的本源,分享了他十五年 Go 编程生涯中,那些被反复实践、验证并沉淀下来的核心理念。

本文将和大家一起深入解读这场演讲的三大核心支柱:命名、初始化与流程控制、以及辅助函数,并探讨为何这些看似简单的模式,却是编写可读、可维护、可测试 Go 代码的基石。

引言:一位 Go “哲人”的回归与沉淀

对于许多 Go 开发者而言,Dave Cheney 的名字不仅代表着一位高产的贡献者,更像是一位编程哲学的布道者。在他“消失”的几年里,社区依旧在流传和实践着他提出的诸多模式。因此,当他重返 GopherCon Europe 2025的舞台时,整个社区都在好奇:他反复强调的那些 Go 编程理念,变了吗?

答案既是“没有”,也是“更加深刻了”。

正如他在开场时所言,这次演讲是他对自己为多家公司编写了超过十年 Go 代码的经验总结,是他对 Peter Bourgon 经典演讲《Ways to do things》的致敬,更是一次对他自己编程风格的提纯与升华。他所分享的,正是那些在无数次代码审查、项目重构和生产救火中,被他反复提及、反复实践的编程模式。这些“重复之事”,构成了他编程哲学的坚实内核。

支柱一:命名 —— 程序的灵魂与第一印象

“我们应该执着地、狂热地关注程序中使用的每一个名字。” 演讲开篇,Dave 便直指编程的核心——命名。它涵盖了变量、常量、包、类型、方法和函数,是代码清晰度的源头。

告别“短标识符”的圣战

对于 Go 社区经久不衰的“短标识符 vs. 长标识符”之争,Dave 引用了 Andrew Gerrand 的智慧之言,并将其作为命名第一法则:

“最好的标识符,是能够描述其存在理由的最短的那个。”

这意味着,名称的长度应与其生命周期和作用域成正比。一个只活几行的循环变量用 i 即可,而一个贯穿整个包的重要配置,则需要一个描述性的全名。

重要的部分放前面

“你不是在写惊悚小说”,Dave 强调,标识符中最重要的、最独特的部分应该放在前面,而不是让读者猜到最后。特别是在同一作用域内有多个同类事物时,清晰的前缀至关重要。

包内外视角的二元性与一致性约定

一个常见的问题是,包的作者和消费者对“好名字”的看法不同。在包内,request 可能是一个合理的变量名;但在包外,它变成了 completion.Request,显得冗长。

Dave 提出的解决方案是建立一致的缩写约定

  1. 全局约定:例如,req 永远指代 *http.Request。
  2. 包内约定:对于 completion.Request,在包内统一使用一个独特的缩写,如 creq,并将其用作接收器名、参数名和局部变量名
// 外部调用
func DoSomething(creq *completion.Request) {}

// 包内实现
func (creq *Request) Do() {}

这样,无论读者身处包内还是包外,creq 这个标识符的含义都是稳定且可预测的。

让名字代替注释

Dave 引用了 Kate Gregory 在《Beautiful C++》中的观点:如果你能给一个标识符起一个足够好的名字,你可能就不需要为它写注释了。一个名字本身就应该能自我解释。

他举了一个反例:一个名为 Validate 的函数,却没有返回 error。这本身就是一个“代码异味”(code smell),即便加上注释 // Validate validates the graph,这种“说了两遍”的重复也无法掩盖其名不副实的问题。经过检查,这个函数实际做的是“扁平化图节点”,一个更准确的名字 FlattenNodes 就能让注释变得多余。

有时,最好的名字就是没有名字

对于那些生命周期极短、仅用于临时数据传递的类型,最好的名字可能就是没有名字。例如,在处理 HTTP 请求时,如果需要先将 JSON 解码到一个中间结构体再进行验证,完全可以使用匿名结构体

var payload struct {
    Name string json:"name"
    // ...
}
if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
    // ...
}

为这个只在此函数中存活一次的类型绞尽脑汁想一个名字(如 requestClient),是完全不必要的认知负担。

支柱二:初始化与流程控制 —— 对 if-else 的厌恶

“if 很糟糕,else 更糟糕”,这是 Dave 对流程控制的核心观点。他认为,我们应该尽一切努力减少甚至消除代码中的 if-else 结构,尤其是那些用于延迟初始化的模式。

假装 Go 拥有不可变性:一次且仅一次的初始化

一个常见的反模式是“声明-后初始化”:

var thing Thing
if os.Getenv("ENV") == "prod" {
    thing = NewRealThing()
} else {
    thing = NewMockThing()
}

这不仅创造了一个 thing 未被初始化的“危险”中间状态,也增加了代码的认知负荷。Dave 的解决方案是:默认初始化,然后覆盖

thing := NewMockThing() // 默认初始化
if os.Getenv("ENV") == "prod" {
    thing = NewRealThing() // 在特定条件下覆盖
}

更进一步,将这个选择逻辑封装进一个辅助函数 NewThing() 中,这不仅让调用点的代码变得干净(thing := NewThing(isProd)),还将这个选择逻辑变成了一个可独立测试的单元。

“保持靠左” (Keep to Left) 与 switch 的偏爱

这两个由 Matt Ryer 提出的模式,被 Dave 奉为圭臬:

  • 保持靠左:即使用“防卫语句”(Guard Clauses)或前置条件检查,在函数开头处理掉所有错误和异常情况并提前返回。这能让成功路径(Happy Path)始终贴近编辑器的左侧边缘,避免代码陷入层层嵌套的 if-else “深渊”。
  • 用 switch 代替 if-else:对于选择逻辑,switch 语句通常比 if-else 链更清晰,因为它明确地表达了“基于某个值进行选择”的意图,并且更易于未来扩展(只需增加 case)。

main.run 模式:让 main 不再特殊

main 函数是每个 Go 程序的入口,但它也是最“奇怪”的函数:它不能返回 error,并且隐式地依赖于大量的全局状态(操作系统环境、标准输入输出、命令行参数等),这使得它极难测试。

Dave 强烈推荐 main.run 模式,其应用非常简单:
1. 创建一个新的、普通的 Go 函数,例如 run。
2. 将 main 函数中的所有核心逻辑都移入 run 函数。
3. 将所有之前隐式依赖的全局状态,作为参数显式地传递给 run 函数。
4. 让 run 函数返回一个 error。

func main() {
    // main 函数只负责处理最终的错误并退出
    if err := run(os.Stdout, os.Args); err != nil {
        fmt.Fprintf(os.Stderr, "error: %v\n", err)
        os.Exit(1)
    }
}

// run 函数现在是一个纯粹的、可测试的 Go 函数
func run(stdout io.Writer, args []string) error {
    // ... 你的所有核心逻辑
    // ... 检查前置条件,构建状态
    // ... 进入主循环
    // ... 遇到任何问题,只需 return err
    return nil
}

这个简单的重构,让程序的核心逻辑变得完全可测试,并且可以在测试中并行运行,极大地提升了开发和维护的效率。Dave 提到,这个模式曾帮助他的团队解决了一个棘手的问题:日志系统初始化失败,导致程序在尝试记录“日志初始化失败”这个错误时直接崩溃。

支柱三:辅助函数 (Helpers) —— 语言的延伸与表达力的提升

贯穿整个演讲的,是 Dave 对使用辅助函数的强烈推崇。他认为,辅助函数是我们扩展项目“内部语言”最强大的工具。

辅助函数的价值

  • 为匿名模式命名:像 pointer.To[T] 这样的泛型函数,为“获取一个值的指针”这个 Go 语法不支持的、在处理 Protobuf 时反复出现的模式,赋予了一个清晰的名字,避免了为每个字段都声明一个临时变量的繁琐。
  • 封装重复逻辑与避免否定:将 if err != nil && !errors.Is(err, context.Canceled) 这样的过滤逻辑,封装进一个 ignoreCancel(err) 辅助函数中,让调用点的意图一目了然。同样,对于布尔检查,if req.StreamIsFalse() 显然比 if !req.Stream 更易于朗读和理解。
  • 提升表达力 (Nicity):创建像 to.JSON(w, data) 这样的辅助函数,可以像 Ruby on Rails 一样,用更符合领域语言的方式来编写代码。这不仅是语法糖,它还能隐藏一些必要的细节(如设置 Content-Type 头),确保一致性和正确性。
  • 延迟求值:在测试中断言失败时,我们常常希望打印出失败时的详细上下文,例如完整的 HTTP 响应体。一个常见的错误是直接将 dumpBody(resp) 作为断言失败时的消息参数。这会导致 dumpBody 无论测试成功与否都会被调用,从而消耗掉响应体。通过将 dumpBody 封装进一个实现了 fmt.Stringer 接口的辅助类型中,我们可以实现延迟求值——只有在断言失败、需要打印消息时,其 String() 方法才会被调用。

内部包(internal)的妙用

Dave 建议,我们可以在项目内部的 internal 目录下创建像 to、is、list 这样的包,用来存放这些辅助函数和类型。这不仅能避免污染公共 API,还能为项目创建一套强大的、可复用的“内部标准库”。

核心:尊重人类的认知极限——神奇数字 7±2

为什么这些看似微小的细节——命名、if-else、辅助函数——如此重要?Dave 引用了著名的认知心理学结论:人类的短期记忆(working memory)只能同时处理 7±2 个信息单元。

这意味着,当我们的代码迫使读者同时记住太多事情时,他们的认知负荷就会超载,理解代码的难度就会急剧增加。

  • 一个 if status >= 400 的判断,需要大脑同时处理“大于”和“等于”两个概念。而 if status > 399 则只占用一个认知单元。
  • 一个层层嵌套的 if-else 结构,每深一层,就需要读者在记忆中压入一个新的上下文。
  • 一个需要大段注释才能解释的函数,说明其名字和签名本身就消耗了大量的认知资源。

所有这些模式——更短但精确的名字、消除 if-else、将逻辑封装进辅助函数——其最终目的都是一致的:减少读者在理解每一行代码时,需要装入短期记忆中的“东西”的数量。

小结:语言影响思维

演讲的最后,Dave 引用了“萨丕尔-沃尔夫假说”来升华他的核心论点(注:笔者在GopherChina 2017年大会上的演讲《Go coding in go way》也引用了此观点,记得那年Dave也参加了Gopher China,就坐在我的前面^_^):

“你使用的语言,直接影响你思考问题的方式。”

通过创建新的名词(类型)和动词(辅助函数),我们实际上是在扩展和塑造我们项目的内部语言。当这门内部语言变得更优雅、更精确、认知负荷更低时,我们对问题的思考也会变得更清晰、更深入。

一个难以命名的函数,或一段需要大段注释来解释的逻辑,都是设计需要改进的强烈信号。它在“恳求你进行重构”。

最终,我们编写的代码,不仅是给机器执行的指令,更是写给未来自己和同事的“信”。而 Dave Cheney 的这些建议,正是帮助我们写好这封“信”,使其清晰、优雅、易于理解的宝贵指南。


你的Go技能,是否也卡在了“熟练”到“精通”的瓶颈期?

  • 想写出更地道、更健壮的Go代码,却总在细节上踩坑?
  • 渴望提升软件设计能力,驾驭复杂Go项目却缺乏章法?
  • 想打造生产级的Go服务,却在工程化实践中屡屡受挫?

继《Go语言第一课》后,我的《Go语言进阶课》终于在极客时间与大家见面了!

我的全新极客时间专栏 《Tony Bai·Go语言进阶课》就是为这样的你量身打造!30+讲硬核内容,带你夯实语法认知,提升设计思维,锻造工程实践能力,更有实战项目串讲。

目标只有一个:助你完成从“Go熟练工”到“Go专家”的蜕变! 现在就加入,让你的Go技能再上一个新台阶!


商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求,请扫描下方公众号二维码,与我私信联系。

Gopher视角:Java 开发者转向 Go 时,最需要“掰过来”的几个习惯

本文永久链接 – https://tonybai.com/2025/06/27/from-java-to-go

大家好,我是Tony Bai。

各位Gopher以及正在望向Go世界的Java老兵们,近些年,我们能明显感觉到一股从Java等“传统豪强”语言转向Go的潮流。无论是追求极致的并发性能、云原生生态的天然亲和力,还是那份独有的简洁与高效,Go都吸引了无数开发者。然而,从Java的“舒适区”迈向Go的“新大陆”,绝不仅仅是学习一套新语法那么简单,它更像是一场思维模式的“格式化”与“重装”

作为一名在Go语言世界摸爬滚打多年的Gopher,我见过许多优秀的Java开发者在初探Go时,会不自觉地带着一些“根深蒂固”的Java习惯。这些习惯在Java中或许是最佳实践,但在Go的语境下,却可能显得“水土不服”,甚至成为理解和掌握Go精髓的绊脚石。

今天,我就从Gopher的视角,和大家聊聊那些Java开发者在转向Go时,最需要刻意“掰过来”的几个习惯。希望能帮助大家更顺畅地融入Go的生态,体会到Go语言设计的精妙之处。

习惯一:接口的“名分”执念 -> 拥抱“能力”驱动

Java的习惯:

在Java世界里,接口(Interface)是神圣的。一个类要实现一个接口,必须堂堂正正地使用 implements 关键字进行声明,验明正身,告诉编译器和所有开发者:“我,某某类,实现了某某接口!” 这是一种名义类型系统(Nominal Typing)的体现,强调“你是谁”。

// Java
interface Writer {
    void write(String data);
}

class FileWriter implements Writer { // 必须显式声明
    @Override
    public void write(String data) {
        System.out.println("Writing to file: " + data);
    }
}

Go的转变:

Go语言则推崇结构化类型系统(Structural Typing),也就是我们常说的“鸭子类型”——“如果一个东西走起来像鸭子,叫起来像鸭子,那么它就是一只鸭子。” 在Go中,一个类型是否实现了一个接口,只看它是否实现了接口所要求的所有方法,无需显式声明。

更重要的是Go社区推崇的理念:“Define interfaces where they are used, not where they are implemented.”(在使用者处定义接口,而非实现者处)。

// Go
// 使用者(比如一个日志包)定义它需要的Write能力
type Writer interface {
    Write(data string) (int, error)
}

// 实现者(比如文件写入模块)
type FileWriter struct{}

func (fw *FileWriter) Write(data string) (int, error) {
    // ... 写入文件逻辑 ...
    fmt.Println("Writing to file:", data)
    return len(data), nil
}

// 无需声明 FileWriter 实现了 Writer,编译器会自动检查
// var w Writer = &FileWriter{} // 这是合法的

为什么要“掰过来”?

  1. 解耦大师:Go的隐式接口使得实现方和使用方可以完全解耦。使用方只关心“我需要什么能力”,而不关心“谁提供了这个能力,以及它还提供了什么其他能力”。这使得代码更加灵活,依赖关系更清晰。
  2. 测试的福音:你可以轻易地为你代码中的依赖定义一个小接口,并在测试中提供一个轻量级的mock实现,而无需修改被测试代码或依赖的原始定义。
  3. 避免臃肿接口:Java中常为了通用性设计出庞大的接口,而Go鼓励定义小而美的接口,按需取材。

Gopher建议

放下对 implements 的执念。在Go中,开始思考你的函数或模块真正需要依赖对象的哪些行为(方法),然后为这些行为定义一个小巧的接口。你会发现,代码的扩展性和可维护性瞬间提升。

习惯二:错误处理的“大包大揽” -> 转向“步步为营”

Java的习惯:

Java的 try-catch-finally 异常处理机制非常强大。开发者习惯于将可能出错的代码块包裹起来,然后在一个或多个 catch 块中集中处理不同类型的异常。这种方式的好处是错误处理逻辑相对集中,但有时也容易导致错误被“吞掉”或处理得不够精确。

// Java
public void processFile(String fileName) {
    try {
        // ... 一系列可能抛出IOException的操作 ...
        FileInputStream fis = new FileInputStream(fileName);
        // ... read from fis ...
        fis.close();
    } catch (FileNotFoundException e) {
        System.err.println("File not found: " + e.getMessage());
    } catch (IOException e) {
        System.err.println("Error reading file: " + e.getMessage());
    } finally {
        // ... 资源清理 ...
    }
}

Go的转变:

Go语言对错误处理采取了截然不同的策略:显式错误返回。函数如果可能出错,会将 error 作为其多个返回值中的最后一个。调用者必须(或者说,强烈建议)检查这个 error 值。

// Go
func ProcessFile(fileName string) error {
    file, err := os.Open(fileName) // 操作可能返回错误
    if err != nil {                // 显式检查错误
        return fmt.Errorf("opening file %s failed: %w", fileName, err)
    }
    defer file.Close() // 优雅关闭

    // ... use file ...
    _, err = file.Read(make([]byte, 10))
    if err != nil {
         // 如果是 EOF,可能不算真正的错误,根据业务处理
        if err == io.EOF {
            return nil // 假设读到末尾是正常结束
        }
        return fmt.Errorf("reading from file %s failed: %w", fileName, err)
    }
    return nil // 一切顺利
}

为什么要“掰过来”?

  1. 错误也是一等公民:Go的设计哲学认为错误是程序正常流程的一部分,而不是“异常情况”。显式处理让开发者无法忽视错误,从而写出更健壮的代码。
  2. 控制流更清晰:if err != nil 的模式使得错误处理逻辑紧跟在可能出错的操作之后,代码的控制流一目了然。
  3. 没有隐藏的“炸弹”:不像Java的checked exceptions和unchecked exceptions可能在不经意间“爆炸”,Go的错误传递路径非常明确。

Gopher建议

拥抱 if err != nil!不要觉得它啰嗦。这是Go语言深思熟虑的设计。学会使用 fmt.Errorf 配合 %w 来包装错误,形成错误链;学会使用 errors.Is 和 errors.As 来判断和提取特定错误。你会发现,这种“步步为营”的错误处理方式,能让你对程序的每一个环节都更有掌控感。

习惯三:包与命名的“层峦叠嶂” -> 追求“大道至简”

Java的习惯:

Java的包(package)名往往比较长,层级也深,比如 com.mycompany.project.module.feature。类名有时为了避免与SDK或其他库中的类名冲突,也会加上项目或模块前缀,例如 MyProjectUserService。这在大型项目中是为了保证唯一性和组织性。

// Java
// package com.mycompany.fantasticdb.client;
// public class FantasticDBClient { ... }

// 使用时
// import com.mycompany.fantasticdb.client.FantasticDBClient;
// FantasticDBClient client = new FantasticDBClient();

Go的转变:

Go的包路径虽然也可能包含域名和项目路径(例如 github.com/user/project/pkgname),但在代码中引用时,通常只使用包的最后一级名称。Go强烈建议避免包名和类型名“口吃”(stuttering)。比如,database/sql 包中,类型是 sql.DB 而不是 sql.SQLDB。

// Go
// 包声明: package fantasticdb (在 fantasticdb 目录下)
type Client struct { /* ... */ }

// 使用时
// import "github.com/mycompany/fantasticdb"
// client := fantasticdb.Client{}

正如附件中提到的,fantasticdb.Client 远比 FantasticDBClient 或 io.fantasticdb.client.Client 来得清爽和表意清晰(在 fantasticdb 这个包的上下文中,Client 自然就是指 fantasticdb 的客户端)。

为什么要“掰过来”?

  1. 可读性:简洁的包名和类型名让代码读起来更流畅,减少了视觉噪音。
  2. 上下文的力量:Go鼓励你信任包名提供的上下文。在 http 包里,Request 自然就是 HTTP 请求。
  3. 避免冗余:Go的哲学是“A little copying is better than a little dependency”,同样,一点点思考换来清晰的命名,好过冗余的限定词。

Gopher建议

在Go中,给包和类型命名时,思考“在这个包的上下文中,这个名字是否清晰且没有歧义?”。如果你的包名叫 user,那么里面的类型可以直接叫 Profile,而不是 UserProfile。让包名本身成为最强的前缀。

习惯四:代码复用的“继承衣钵” -> 推崇“灵活组装”

Java的习惯:

Java是典型的面向对象语言,继承(Inheritance)是实现代码复用和多态的核心机制之一。”is-a” 关系(比如 Dog is an Animal)深入人心。开发者习惯于通过构建复杂的类继承树来共享行为和属性。

Go的转变:

Go虽然有类型嵌入(Type Embedding),可以模拟部分继承的效果,但其核心思想是组合优于继承 (Composition over Inheritance)。”has-a” 关系是主流。通过将小的、专注的组件(通常是struct或interface)组合起来,构建出更复杂的系统。

// Go - 组合示例
type Engine struct { /* ... */ }
func (e *Engine) Start() { /* ... */ }
func (e *Engine) Stop() { /* ... */ }

type Wheels struct { /* ... */ }
func (w *Wheels) Rotate() { /* ... */ }

type Car struct {
    engine Engine // Car has an Engine
    wheels Wheels // Car has Wheels
    // ...其他组件
}

func (c *Car) Drive() {
    c.engine.Start()
    c.wheels.Rotate()
    // ...
}

为什么要“掰过来”?

  1. 灵活性:组合比继承更灵活。你可以动态地替换组件,或者为一个对象组合多种不同的行为,而无需陷入复杂的继承层级。
  2. 避免“猩猩/香蕉问题”:“你需要一个香蕉,但得到的是一只拿着香蕉的大猩猩,以及整个丛林。”继承有时会引入不必要的依赖和复杂性。组合则让你按需取用。
  3. 单一职责:组合鼓励你设计小而专注的组件,每个组件都做好一件事,这符合单一职责原则。

Gopher建议

当你试图通过继承来复用代码或扩展功能时,停下来想一想:我需要的是一个“is-a”关系,还是一个“has-a”关系?我是否可以通过将现有的小组件“塞”到我的新类型中来实现目标?在Go中,更多地使用类型嵌入(模拟组合)和接口来实现多态和行为共享。

小结:一场愉快的“思维升级”

从Java到Go,不仅仅是换了一套工具,更是一次编程思维的刷新和升级。初期可能会有些不适,就像习惯了自动挡再去开手动挡,总想不起来踩离合。但一旦你真正理解并接纳了Go的设计哲学——简洁、显式、组合、并发优先——你会发现一片全新的、更高效、也更富乐趣的编程天地。

上面提到的这几个“习惯”,只是冰山一角。Go的世界还有更多值得探索的宝藏。希望这篇文章能给你带来一些启发。

你从Java(或其他语言)转向Go时,还“掰过来”了哪些习惯?欢迎在评论区分享你的故事和心得!


你的Go技能,是否也卡在了“熟练”到“精通”的瓶颈期?

  • 想写出更地道、更健壮的Go代码,却总在细节上踩坑?
  • 渴望提升软件设计能力,驾驭复杂Go项目却缺乏章法?
  • 想打造生产级的Go服务,却在工程化实践中屡屡受挫?

继《Go语言第一课》后,我的《Go语言进阶课》终于在极客时间与大家见面了!

我的全新极客时间专栏 《Tony Bai·Go语言进阶课》就是为这样的你量身打造!30+讲硬核内容,带你夯实语法认知,提升设计思维,锻造工程实践能力,更有实战项目串讲。

目标只有一个:助你完成从“Go熟练工”到“Go专家”的蜕变! 现在就加入,让你的Go技能再上一个新台阶!


商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求,请扫描下方公众号二维码,与我私信联系。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言进阶课 Go语言精进之路1 Go语言精进之路2 Go语言第一课 Go语言编程指南
商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats