标签 gomodule 下的文章

Go项目目录该怎么组织?官方终于出指南了!

本文永久链接 – https://tonybai.com/2023/10/05/the-official-guide-of-organizing-go-project

长久以来,在Go语言进阶的学习和实践之路上,Go项目目录究竟如何布局一直是困扰大家的一个问题,这是因为Go官方针对这个问题迟迟没有给出说法,更没有提供标准供大家参考。仅有Go语言项目技术负责人Russ Cox在一个开源项目的issue中给出了他关于Go项目结构的最小标准布局的想法

熟悉我的博客/公众号的读者可能会知道,关于Go项目目录布局,我在以往文章中曾写过多次。在我的纸版书《Go语言精进之路》、极客时间的专栏Go语言第一课以及Go高级工程师训练营中,对Go项目目录组织与布局方式也都有过全面系统地说明。

我虽然很努力为大家答疑,提供的建议也很具参考价值,但这仅是我的个人观点,权威性有限,大家依然期待Go官方的说法。

近期Go官方文档集合中新增了一篇名为“Organizing a Go module”的文档,细读之后,我发现这不就是大家期待已久的Go项目目录布局的官方指南吗!

在这篇文章中,我们就来看看这份官方指南,看看官方推荐的Go项目目录布局是什么样子的。

1. Go项目的类型

我们知道Go项目(project)一般有两类:library和executable。library是以构建库为目的的Go项目,而executable则是以构建二进制可执行文件为目的的Go项目。

“Organizing a Go module”这篇文档也是按照Go项目类型为Gopher提供项目布局建议的。这篇文档将library类的项目叫作package类,executable类的项目叫作command。下面的示意图展示了“Organizing a Go module”这篇文档的说明顺序:

从图中看到,“Organizing a Go module”这篇文档总共给出7种项目的布局建议。接下来,我们就来逐一看一下。

2. 官方版Go项目目录布局指南

2.1 basic package

我们先从package类开始。最简单的package类的Go项目是basic package,下面就是一个basic package类的项目目录布局的示例:

project-root-directory/
├── go.mod
├── modname.go
└── modname_test.go

或

project-root-directory/
├── go.mod
├── modname.go
├── modname_test.go
├── auth.go
├── auth_test.go
├── hash.go
└── hash_test.go

我们看到basic package类项目非常简单,repo下面只有一个导出package,这个package包含一个或多个包源文件。以repo托管在github上为例,如果这个repo的url为github.com/someuser/modname,那么该repo下的module root和导出package的导入路径通常与repo url一致,都为github.com/someuser/modname。

你的代码要依赖该module,直接通过下面import语句便可以将该module导入:

import "github.com/someuser/modname"

注:本文的Go项目目录布局示例均来自或改自“Organizing a Go module”那篇文档。

2.2 basic command

和basic package一样,basic command类项目是以构建可执行二进制程序为目的的Go项目中最简单的一类。下面是basic command类项目的一个示例:

project-root-directory/
├── go.mod
└── main.go

或

project-root-directory/
├── go.mod
├── main.go
├── auth.go
├── auth_test.go
├── hash.go
└── hash_test.go

从示例我们可以看到,basic command类项目的repo下面只可构建出一个可执行文件,main函数放在main.go中,其他源文件也在repo根目录下,并同样放在main包中。

还是以repo托管在github上为例,如果这个repo的url为github.com/someuser/modname,那么我们可以通过下面命令安装这个command的可执行程序:

$go install github.com/someuser/modname@latest

2.3 package with supporting packages

稍复杂或规模稍大的一些package类项目,会将很多功能分拆到supporting packages中,并且通常项目作者是不希望导出这些supporting packages的,这样这些supporting packages便可以不作为暴露的API的一部分,后续重构和优化起来十分方便,对package的用户也是无感的。这样Go官方建议将这些supporting packages放入internal目录

注:internal目录是Go 1.4版本引入的机制,简单来说放在internal中的包是local的,不能导出到module之外,但module下的某些内部代码可以导入internal下的包。如今一般都会将internal放在项目的根目录下,所以项目下的所有代码都可以导入internal下的包。

下面是一个带有supporting packages的package类项目的目录布局示例:

project-root-directory/
├── go.mod
├── modname.go
├── modname_test.go
└── internal/
    ├── auth/
    │   ├── auth.go
    │   └── auth_test.go
    └── hash/
        ├── hash.go
        └── hash_test.go

modname.go或modname_test.go可以通过下面导入语句使用internal下面的包:

import "github.com/someuser/modname/internal/auth"

2.4 command with supporting packages

有了package with supporting packages的说明后,再来看command with supporting packages就更简单了,下面是一个示例:

project-root-directory/
├── go.mod
├── main.go
└── internal/
    ├── auth/
    │   ├── auth.go
    │   └── auth_test.go
    └── hash/
        ├── hash.go
        └── hash_test.go

和package with supporting packages不同的是,main.go使用的包名为main,这样Go编译器才能将其构建为command。

2.5 multiple packages

作为一个库项目,作者可能要暴露不止一个package,可能是多个packages。这不会给Go项目目录布局带来过多复杂性,我们只需多建立几个导出package的目录就ok了。下面是一个multiple packages的示例:

project-root-directory/
├── go.mod
├── modname.go
├── modname_test.go
├── auth/
│   ├── auth.go
│   ├── auth_test.go
│   └── token/
│       ├── token.go
│       └── token_test.go
├── hash/
│   ├── hash.go
│   └── hash_test.go
└── internal/
    └── trace/
        ├── trace.go
        └── trace_test.go

我们看到这个示例在repo(以托管在github.com/user/modname下为例)顶层放置了多个导出包:

github.com/user/modname
github.com/user/modname/auth
github.com/user/modname/hash

并且顶层的auth目录下还有一个二级的导出包token,其导入路径为:

github.com/user/modname/auth/token

所有这些导出包的supporting packages还是按惯例放在了internal目录下,比如:github.com/user/modname/internal/trace,这些包是local的,不能被该module之外的代码所依赖。

2.6 multiple commands

有multiple packages类型的项目,就会有multiple commands类的项目,下面是一个这类项目的示例:

project-root-directory/
├── go.mod
├── prog1/
│   └── main.go
├── prog2/
│   └── main.go
└── internal/
    └── trace/
        ├── trace.go
        └── trace_test.go

这个示例将每个command放置在一个单独的目录下(比如prog1、prog2等),supporting packages和之前的建议一样,统一放到internal下面。这样我们可以通过下面步骤来编译command:

$go build github.com/someuser/modname/prog1
$go build github.com/someuser/modname/prog2

command的用户通过下面步骤可以安装这些命令:

$go install github.com/someuser/modname/prog1@latest
$go install github.com/someuser/modname/prog2@latest

2.7 multiple packages and commands

最后我们来看看最复杂的一种项目类型:multiple packages and commands,即在同一个项目下面,既有多个可导出的packages,又有多个commands。下面是一个此类复杂项目的示例:

project-root-directory/
├── go.mod
├── modname.go
├── modname_test.go
├── auth/
│   ├── auth.go
│   ├── auth_test.go
│   └── token/
│       ├── token.go
│       └── token_test.go
├── hash/
│   ├── hash.go
│   └── hash_test.go
├── internal/
│       └── trace/
│           ├── trace.go
│           └── trace_test.go
└── cmd/
    ├── prog1/
    │   └── main.go
    └── prog2/
        └── main.go

我们看到:为了区分导出package和command,这个示例增加了一个专门用来存放command的cmd目录,prog1和prog2两个command都放在这个目录下。这也是Go语言的一个惯例。

这样,这个示例项目既导出了下面的包:

github.com/user/modname
github.com/user/modname/auth
github.com/user/modname/hash

又包含了两个可安装使用的command,用户按下面步骤安装即可:

$go install github.com/someuser/modname/cmd/prog1@latest
$go install github.com/someuser/modname/cmd/prog2@latest

3. 小结

经过对“Organizing a Go module”的文档这篇Go官方项目目录布局指南的学习,我发现指南中的建议与我个人在以往文章、书和专栏中对Go项目目录布局的建议非常相近,几乎一致,唯独不同的是在pkg目录的使用上。

在multiple packages类型项目中,如果要导出的package非常多,那么项目顶层目下会有大量的目录,这让项目顶层目录显得很“臃肿”,我个人建议将这些导出包统一放置到project-root-directory/pkg下面,这样项目顶层目录就会显得很简洁。

注:无论是“Organizing a Go module”这篇文档中的官方建议,还是我个人对Go项目目录布局的建议,针对的都是Go项目的基础布局。而像很多Gopher经常问的采用DDD、clean architecture或Hexagonal Architecture(六边形架构)设计的项目的目录布局是一种业务层面的布局,是在基础布局之上进行再设计的,不在本篇的说明范围之内。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • Gopher Daily归档 – https://github.com/bigwhite/gopherdaily

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

聊聊Go语言的向前兼容性和toolchain规则

本文永久链接 – https://tonybai.com/2023/09/10/understand-go-forward-compatibility-and-toolchain-rule

Go语言在发展演进过程中一直十分注重向后兼容性(backward compatibility),在Go 1.0版本发布之初就发布了Go1兼容性承诺,简单来说就是保证使用新版本Go(比如Go 1.21版本)可以正常编译和运行老版本的Go代码(比如使用Go 1.18版本语法编写的go代码),不会出现breaking change(其实也不是绝对的不会出现)。

但是在Go 1.21版本之前,Go语言在向前兼容性方面却存在一定的不确定性问题。Go 1.21版本对此进行了改进,并引入了go toolchain规则。本文就和大家详细聊聊Go语言的向前兼容性以及Go 1.21中新引入的toolchain的使用规则。

1. Go 1.21版本之前的向前兼容性问题

在Go 1.21版本之前,Go module中的go directive用于声明建议的Go版本,但并不强制实施。例如:

// go.mod
module demo1

go 1.20

上面go.mod文件中的go directive表示建议使用Go 1.20及以上版本编译本module代码,但并不强制禁止使用低于1.20版本的Go对module进行编译。你也可以使用Go 1.19版本,甚至是Go 1.15版本编译这个module的代码。

但Go官方对于这种使用低版本(比如L)编译器编译go directive为高版本(比如H)的Go module的结果没有作出任何承诺和保证,其结果也是不确定的

如果你比较幸运,在module中没有使用高版本(从L+1到H)引入go的新语法特性,那么编译是可以通过的。

如果你更加幸运,你module中的代码没有使用到任何从L+1到H版本中带有语法行为变更、bug或安全漏洞的代码,那么编译出的可执行程序运行起来也可以是正常的。

相反,你可能会遇到编译失败、运行失败甚至运行时行为出现breaking change的问题,而这些都是不确定的

有gopher可能会说:我自己的代码可以控制,我可以保证避免掉这些问题。但如果你的module有外部依赖,你能保证你的依赖不存在这种向前兼容性的问题吗!

向前兼容性问题会导致Go开发者的体验不佳!因此,从Go 1.21版本开始,Go团队在向前兼容性方面对Go进行了改善,尽量以确定性代替上述的问题带来的不确定性。

下面我们就来看看Go 1.21版本在向前兼容性方面的策略调整。

2. Go 1.21版本后的向前兼容性策略

Go从Go 1.11版本引入go module,在go 1.16版本go module构建模式正式成为默认构建模式,替代了原先的GOPATH构建模式。

注:《Go语言第一课》专栏的第6讲第7讲对Go module构建模式与6类常规操作做了全面系统的讲解,感兴趣的童鞋可移步阅读。

通过go module,结合语义导入版本(semantic import versioning)最小版本选择(Minimal version selection)等机制,go build可以实现精确的依赖管控。

Go 1.21版本后的向前兼容性策略的调整就是参考了go module对依赖的管理方法:即将go版本和go toolchain版本作为一个module的“依赖”来管理。如果你真正理解了这个,那理解后面那些具体的规则就容易多了!

如果Russ Cox当初设计Go module就想到了今天这个思路,估计就会直接使用go.mod文件中的require语法像管理依赖module那样来管理go version和go toolchain了:

// go.mod (假想的)

module demo1

require (
    go 1.20.5
    toolchain go1.21.1
)

require (
    github.com/gomodule/redigo v1.8.5
    github.com/google/gops v0.3.19
    github.com/panjf2000/ants v1.2.1
)

但时间无法倒流,历史不能重来,Russ Cox现在只能使用go directive和toolchain directive来提供对go版本和go工具链的依赖信息:

// go.mod

module demo1

go 1.20.5
toolchain 1.21.1

同时和使用go get可以改变go.mod的require块中的依赖的版本一样,通过go get也可以修改go.mod中go和toolchain指示的版本:

$go get go@1.21.1
$go get toolchain@go1.22.1

基于上述策略调整,为解决向前兼容不确定性的问题,Go从1.21版本开始,改变了go.mod中go directive的语义:它不再是建议,而是指定了module最小可用的Go版本。

这样在仅使用本地go工具链的情况下,如果Go编译器版本低于go.mod中的go版本,将无法编译代码:

// go.mod

module demo1

go 1.21.1 // 指定最小可用版本为Go 1.21.1

$GOTOOLCHAIN=local go build
go: go.mod requires go >= 1.21.1 (running go 1.21.0; GOTOOLCHAIN=local)

细心的读者可能会注意到了,这里我用了一个前提:“在仅使用本地go工具链的情况下(即设置了GOTOOLCHAIN=local)”,在Go 1.21版本之前,我们遇到的都属于这种情况。遇到这种情况后,我们一般的作法是手动下载对应版本的Go工具链(比如这里的go 1.21.1),然后用新版工具链重新编译。

Go团队考虑到手动管理go工具链带来的体验不佳问题,在Go 1.21版本及以后,go还提供了自动Go工具链管理,如果go发现本地工具链版本低于go module要求的最低go版本,那么go会自动下载高版本的go工具链,缓存到go module cache中(不会覆盖本地安装的go工具链),并用新下载的go工具链对module进行编译构建:

// go.mod

module demo1

go 1.21.1 // 指定最小可用版本为Go 1.21.1

$go build
go: downloading go1.21.1 (darwin/amd64)

注:从兼容性方面考虑,如果go.mod中没有显式的用go指示go版本,那么默认go版本为1.16。

对应module有依赖的情况,比如下图:

这里要正确编译图中的main module,我们至少需要go 1.21.0版本,这个版本是main所有依赖中version最大的那个。

当然最终选择哪个版本的go工具链对module进行编译,则有一个选择决策的过程。

go module构建模式下,go工具链选择依赖module的版本时有一套机制,比如最小版本选择等,Go 1.21以后,go工具链版本的选择,也有一套类似的逻辑。接下来我们就来简单看一下。

3. module依赖的Go toolchain版本的选择过程

我们先来回顾一下go module中依赖module的版本选择机制:最小版本选择(mvs),下面的图是讲解这个机制时经常引用的图:


上图来自https://go.dev/ref/mod

以module C的版本选择为例,A依赖C 1.3,B依赖C 1.4,那么满足应用依赖需求的最小版本就是1.4。如果选择1.3,则不满足B对依赖的要求。

对Go toolchain的选择过程也遵循mvs方法,我们把前面的那个例子拿过来:

现在我们帮这个例子选择go toolchain版本。

注:如果go.mod中没有显式用toolchain指示工具链版本,那我们可以认为go.mod中有一个隐含的toolchain指示版本,该版本与go directive指示的版本一致。

上面的例子中对toolchain version的最高要求为module D的go 1.21.0,当startup toolchain(执行的那个go命令的版本)得到这个信息后,就会在当前可用的toolchain版本列表中选出满足go 1.21.0的最小版本的go toolchain,然后会有一个叫Go toolchain switches(Go工具链切换)的过程,切换后,选出的新版go toolchain会继续后面的工作(编译和链接)。例如,如果可用的toolchain版本有如下三个:

  • go 1.22.7
  • go 1.21.3
  • go 1.21.5

那么startup toolchain会根据mvs原则选出满足go 1.21.0的最小版本,即go 1.21.3。

这里大家可能会马上问:什么是可用的toolchain版本?别急!接下来我们就来回答这个问题。

4. GOTOOLCHAIN环境变量与toolchain版本选择

是否执行自动工具链下载和缓存、Go toolchain switches(Go工具链切换)以及切换的工具链的版本取决于GOTOOLCHAIN环境变量的设置、go.mod中go和toolchain指示的版本。

当go命令捆绑的工具链与module的go.mod的go或工具链版本一样时或更新时,go命令会使用自己的捆绑工具链。例如,当在main module的go.mod包含有go 1.21.0时,如果go命令绑定的工具链是Go 1.21.3版本,那么将继续使用初始toolchain的版本,即Go 1.21.3。

而如果go.mod中的go版本写着go 1.21.9,那么go命令捆绑的工具链版本1.21.3显然不能满足要求,那此时就要看GOTOOLCHAIN环境变量的配置。

GOTOOLCHAIN的设置以及对结果的影响略复杂,下面是GOTOOLCHAIN的多种设置形式以及对toolchain选择的影响说明(以下示例中本地go命令捆绑的工具链版本为Go 1.21.0):

  • \<name>

例如,GOTOOLCHAIN=go1.21.0。go命令将始终运行该特定版本的go工具链。如果本地存在该版本工具链,就使用本地的。如果不存在,会下载、缓存起来并使用。如果go.mod中的工具链版本高于name版本,则停止编译:

$cat go.mod
module demo1

go 1.23.1
toolchain go1.23.1 

$GOTOOLCHAIN=go1.21.0 go build
go: go.mod requires go >= 1.23.1 (running go 1.21.0; GOTOOLCHAIN=go1.21.0)
  • \<name>+auto

当GOTOOLCHAIN设置为\<name>+auto时,go命令会根据需要选择并运行较新的Go版本。具体来说,它会查询go.mod文件中的工具链版本和go version。如果go.mod 文件中有toolchain行,且toolchain指示的版本比默认的Go工具链(name)新,那么系统就会调用toolchain指示的工具链版本;反之会使用默认工具链。

当本地不存在决策后的工具链版本时,会自动下载、缓存,并使用该缓存工具链进行后续编译。

$cat go.mod
module demo1

go 1.23.1
toolchain go1.23.1 

$GOTOOLCHAIN=go1.24.1+auto go build
go: downloading go1.24.1 (darwin/amd64) // 使用name指定工具链,但该工具链本地不存在,于是下载。

$GOTOOLCHAIN=go1.20.1+auto go build
go: downloading go1.23.1 (darwin/amd64) // 使用go.mod中的版本的工具链
  • \<name>+path

当GOTOOLCHAIN设置为\<name>+path时,go命令会根据需要选择并运行较新的Go版本。具体来说,它会查询go.mod文件中的工具链版本和go version。如果go.mod 文件中有toolchain行,且toolchain指示的版本比默认的Go工具链(name)新,那么系统就会调用toolchain指示的工具链版本;反之会使用默认工具链。当使用\<name>+path时,如果决策得到的工具链版本在PATH路径下没有找到,那么go命令执行过程将终止。

$cat go.mod
module demo1

go 1.23.1
toolchain go1.23.1 

$GOTOOLCHAIN=go1.24.1+path go build // 使用name指定工具链,但该工具链本地不存在,于是编译停止
go: cannot find "go1.24.1" in PATH

$GOTOOLCHAIN=go1.20.1+path go build // 使用go.mod中的版本的工具链,但该工具链本地不存在,于是编译停止
go: cannot find "go1.23.1" in PATH
  • auto (等价于 local+auto,这也是默认值)

auto的语义是当go.mod中工具链版本低于go命令捆绑的工具链版本,则使用go命令运行捆绑的工具链;反之,自动下载对应的工具链版本,缓存起来并使用。

$cat go.mod
module demo1

go 1.23.1
toolchain go1.23.1 

$GOTOOLCHAIN=auto go build
go: downloading go1.23.1 (darwin/amd64)
  • path (等价于 local+path)

path的语义是当go.mod中工具链版本低于go命令捆绑的工具链版本,则使用go命令运行捆绑的工具链;反之,在PATH中找到满足go.mod中工具链版本的go版本。如果没找到,则会停止编译过程:

$cat go.mod
module demo1

go 1.23.1
toolchain go1.23.1 

$GOTOOLCHAIN=path go build
go: cannot find "go1.23.1" in PATH
  • local

当GOTOOLCHAIN设置为local时,go命令总是运行捆绑的 Go 工具链。如果go.mod中工具链版本高于local的版本,则会停止编译过程。

$cat go.mod
module demo1

go 1.23.1
toolchain go1.23.1 

$GOTOOLCHAIN=local go build
go: go.mod requires go >= 1.23.1 (running go 1.21.0; GOTOOLCHAIN=local)

就像之前说的,当Go工具在编译module依赖项时发现当前go toolchain版本无法满足要求时,会进行go toolchain switches(切换),切换的过程就是从可用的go toolchain列表中取出一个最适合的。

那么“可用的go toolchain列表”究竟是如何组成的呢? go命令有三个候选版本(以当前发布的最新版Go 1.21.1为例,这些版本也是Go当前承诺提供support的版本):

  • 尚未发布的Go语言版本的最新候选版本(1.22rc1)
  • 最近发布的 Go 语言版本的最新补丁 (1.21.1)
  • 上一个Go语言版本的最新补丁版本(1.20.8)。

当GOTOOLCHAIN设置为带auto形式的值的时候,Go会下载这些版本;当GOTOOLCHAIN设置为代path形式的值的时候,Go会在PATH路径搜索适合的go工具链列表。

接下来,go会用mvs(最小版本选择)来确定究竟使用哪个toolchain版本。Go toolchain reference中就有这样一个例子。

假设example.com/widget@v1.2.3需要Go 1.24rc1或更高版本。go命令会获取可用工具链列表,并发现两个最新Go工具链的最新补丁版本是Go 1.28.3和Go 1.27.9,候选版本Go 1.29rc2也可用。在这种情况下,go 命令会选择Go 1.27.9。

如果 widget 需要 Go 1.28或更高版本,go命令会选择 Go 1.28.3,因为 Go 1.27.9 太旧了。如果widget需要Go 1.29或更高版本,go命令会选择Go 1.29rc2,因为Go 1.27.9和Go 1.28.3都太老了。

5. 小结

Go 1.21通过增强go语句语义和添加工具链管理,大幅改进了Go语言的向前兼容性。开发者可以放心使用新语言特性,无需担心旧版本编译器带来的问题。go命令会自动处理不同module使用不同go版本和不同工具链版本的情况,使用Go语言变得更简单。

总之,要理解本文内容,重要的是要把握住一点:Go 1.21版本对Go向前兼容性的改进是参考了go module对依赖的管理方法:即将go版本和go toolchain版本作为一个module的“依赖”来管理

6. 参考资料


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • Gopher Daily归档 – https://github.com/bigwhite/gopherdaily

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 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