本文永久链接 – https://tonybai.com/2023/05/05/go-value-and-pointer

1. 计算机中的值

在百万年的演化历史中，人类对事物的属性进行了抽象，有了数量、精度、信息等概念的表示，对应的我们称之为整数、小数、文本文字等。计算机出现后，我们使用计算机对真实世界的问题进行建模，通过计算机的高效计算解决这些问题并输出答案。为了建模，计算机需要建立对上述基本概念的抽象和表示，于是有了类型与值的概念。

计算机中所有数据都存储在内存中并参与问题解决的计算，真实世界的概念表示与内存中的数据的转换关系如下图：

图中的有界比特序列(bounded bit sequence)就是真实世界概念表示在计算机内存中的存储形式，我们可以统称它为一个值(value)。这个值的比特序列形式由类型决定。举个例子：一个公司的员工数量为1000人，这个真实世界的概念在计算机中的表示过程如下：

我们用uint16类型来表示员工数量，这样它在内存存储形式为0000 0011 1110 1000。如果你用不同的类型来表示员工数量，那么在内存中表示员工数量的值的比特序列将是不同的。

反之，对于内存中的一段有界比特序列，在不同类型guided的decode下，得到的结果也是不同的，如下图。

我们看到：在uint64的guided下，0000 0011 1110 1000这个比特序列被解释为1000；而在[2]byte的guided下，0000 0011 1110 1000这个同样的比特序列则被解释成了2个数字。

计算机中的值不仅仅可以表示一个数字，也可以表示一个字符串，甚至是像结构体这样的复合类型，它本质上就是一块儿连续的内存，内存单元是有地址的，通过该地址访问和更新内存单元中的值。

但在编程过程中直接使用内存地址是十分不便的，因此在高级编程语言中，编程语言通过具名的标识符与内存单元建立“绑定”关系，就得到了我们通常说的常量和变量，而内存单元中存储的数据(即值)也可说成是常量持有的数据和变量持有的数据。

当然也有一些不和任何标识符“绑定”的值，我们称之为字面值(literal value)。我们通常用字面值为变量和常量赋[初]值：

var a int = 17
s := "hello"
const f float64 = 3.1415926

原生类型的字面值，可以简单理解为汇编中的立即数；而复杂类型(比如结构体)的字面值，则一般是临时存储在栈上的有界比特序列。

2. 一切皆是值

根据上一节关于值的定义，我们可以认为：在Go语言中，所有东西都是以值的形式存在的。在Go语言中，不仅仅是基本类型如整数、浮点数、布尔值等，就连复杂的数据结构，如结构体、数组、切片、map、channel等都以值的形式存在。

到这里有小伙伴可能会问：“不对啊，map、channel等应该是指针吧”。别急，要解答这个问题，我们就要来看看值的分类。

2.1 值的分类

在Go中，值可分为以下几种类型：

• 基本类型值

基本类型是Go语言中最基础的数据类型，它们是直接由语言定义的。基本类型的值通常是简单的值，比如整数、浮点数、布尔值等。在Go语言中，基本类型的值可以进行各种运算和比较操作。

• 复合类型值

复合类型则是由基本类型组成的更复杂的数据类型。它们的值由多个基本类型值组合而成，并且可以使用结构化的方式进行访问和操作。在Go语言中，复合类型包括分为数组、切片、map、结构体、接口、channel等多种类型。这些复合类型在不同的场景下都有不同的用途，可以用于表示不同的数据结构或者实现不同的算法。

字符串在Go中是一个特殊的存在，从Go类型角度来看，它应该属于原生内置的基本类型，但从值的角度考虑，由于在运行时字符串类型表示为一个两字段的结构(如下)

type StringHeader struct {
    Data uintptr
    Len  int
}

因此，我们将其归为复合类型值范畴。

• 指针类型值

有一类值十分特殊，它自身是一个基本类型值，更准确的说是一个整型值，但这个整型值的含义却是另外一个值所在内存单元的地址。如下图所示：

我们看到：指针类型值为0×12345678，这个值是另外一个内存块(值为0×17)的地址。指针类型值在Go语言以及C、C++这一的静态语言中扮演着极其重要的角色。

回答前面小伙伴的问题：map、channel是不是值? 是值，只不过是指针类型值。从Go语法上来说，map、channel是某个runtime指针类型的实例。

2.2 值的可变性

在继续深入指针之前，我们先来插播一个内容：值的可变性。

前面说过值是一段连续内存，是一个有界比特序列。原理上来说，内存中的值都是可变的。但现实中，考虑到操作系统管理以及应用安全的需要，暴露给开发人员的值被做了限定，即有些值(内存单元中的数据)是可变的，而有一些值是不可变的。

首先，操作系统负责物理内存与虚拟内存的映射，应用开发人员面对的是平坦的虚拟内存。这部分平坦的虚拟内存也被分为了几个段(segment)，比如：BSS段、数据段、代码段、堆栈等，有些segment上的值是只读的，不可变的，比如代码段，有些则是可读写的可变的，比如堆栈。

此外，Go在编程语言层面也对值做了限制，常量值是不可变的，字符串类型值是不可变的，其他则为可变值。

2.3 指针类型

针对指针这类值，编程语言抽象出了一种类型：指针类型，指针类型的变量与指针类型值绑定，它内部存储的是另外一个内存单元的地址。这样就衍生出通过指针读取和更新指针指向的值的操作方法：

var a int = 5 // 基础类型值
var p = &a    // p为指针类型变量(*int)，其值为变量a的地址。

println(*p)   // 通过指针读取其指向的变量a的值
*p = 15       // 通过指针更新其指向的变量a的值

不过，指针更大的好处在于传递开销低，且传递后，接收指针的函数/方法体中依然可以修改指针指向的内存单元的值。

接下来，我们来详细说一下值的传递。

2.4. 值的传递

无论是赋值还是传参，Go语言中的所有值的传递的方法都是值拷贝，也称为逐位拷贝(bitwise copy)。

不过即便是值拷贝，也会带来三种不同效果：

• 传值：你是你，我是我

效果：传递前后的变量各自独立更新，互不影响。

示例：传整型、浮点型、布尔值等。

• 传指针：你是你，我是我，但我们共同指向他

效果：传递前后的指针变量拥有相同的指针值，因此共同指向同一个内存对象(d)。通过其中一个指针变量对指向的内存对象进行更新后(e)，另一个指针变量可以感知到相同的变化。

示例：传*T指针类型变量。包括在Go runtime层面本质是一个指针的类型，比如map、channel等。

• 传“引用”：你是你，我是我，但我们有一部分共同指向他

首先要注意，Go语言规范中没有“引用类型”这一表述。其次，也不要将这里的“引用”与其他语言的“引用类型”相提并论。

这里传“引用”的效果是：传递前后的变量一部分是独立更新互不影响的，一部分则是有共同指向，相互影响的。最典型的例子就是切片。当我们将切片传入函数后，函数内对切片的更新操作会影响到原切片，包括更新切片元素的值、向切片追加元素等。尤其是向切片追加(append)元素后，会导致传递前后的两个切片出现“不一致”，详情可以参考我之前写的一篇文章《当函数设计遇到切片》。

这里之所以使用的“引用”来形容这种效果，主要是像slice这样的类型与我们熟知的其他语言中的引用(reference)很像，都是它们以“值”的形态传递，但却能干着“指针”的活儿。

3. 关于值的一些tips

3.1 零值

在Go语言中，每个变量都有一个默认的零值，即在变量未被初始化时的默认值。这个默认值取决于变量的类型，可以是一个数字、布尔值、字符串、指针、数组、结构体等等。

在Go语言中，零值可以用来初始化变量的默认值，也可以用来清空变量的值。

var i int // i的零值为0
var s string // s的零值为""
var p *int // p的零值为nil
var a [3]int // a的零值为[0 0 0]
var b struct { x int; y float64 } // b的零值为{0 0.0}

在这个例子中，我们使用var关键字声明了5个变量，并使用它们的零值来初始化这些变量的值。

另外，我们可以使用零值来清空变量的值，例如：

var i int = 10 // 初始化i的值为10
i = 0 // 使用i的零值来清空它的值

在使用零值时，需要注意以下两个问题：

• 指针类型的零值为nil，不能直接使用nil指针来访问变量的值，否则会导致panic。
• 可声明零长度数组类型，这样的类型的实例不占用内存空间，这在一些特殊场合下会很有用。

3.2 值的比较

Go语言的值比较是通过比较两个值的二进制表示来实现的。在Go语言中，值比较主要用于判断两个值是否相等。下面是Go语言值比较的场景、规则和注意事项：

场景

• 判断两个值是否相等；
• 判断两个值是否不相等；
• 判断一个值是否为nil；
• 判断两个指针是否指向同一个对象。

规则

• 对于基本类型（如int、float、bool等），只需要比较它们的值就可以了；
• 对于复合类型（如数组、切片、map等），需要递归比较它们的元素或键值对；
• 对于结构体类型，需要递归比较它们的字段；
• 对于接口类型，需要判断它们是否指向同一个动态类型以及动态值是否相等。

注意事项

• 对于浮点数类型，不能使用“==”运算符进行比较，因为浮点数的精度问题可能导致比较结果不正确，应该使用math包中的函数进行比较；
• 对于切片类型，Go不支持直接使用“==”运算符进行比较，因为它们的底层数据结构可能不同，应该使用reflect包中的函数DeepEqual进行比较；
• 对于结构体类型，如果其中包含不可比较的字段（如切片、映射、函数等），则整个结构体类型也是不可比较的；
• 对于指针类型，需要注意空指针的情况，应该先判断指针是否为nil，再进行比较。

3.3 method receiver的值与指针类型的选择

在Go语言中，method receiver可以是值类型或指针类型。这个选择可能会影响代码的性能、正确性和可读性等方面。

当一个方法的receiver是一个值类型时，receiver的传递会出现“传值”效果，方法体中对这个值的修改不会影响原来的值。但是，如果这个值类型的对象非常大，每次调用方法都需要进行复制，这会导致一定的性能损失。

当一个方法的receiver是一个指针类型时，这个方法操作的就是原来的对象，并且可以修改原来的对象。这种方式可以避免复制对象的开销，并且可以访问和修改对象的内部状态。但是，如果多个goroutine同时访问同一个对象时，就会发生竞争条件，导致程序出现不可预料的行为。

在选择method receiver的类型时，可考虑以下几个因素：

• 对象的大小：如果对象很小，可以选择值类型的method receiver，避免复制对象的开销；如果对象很大，可以选择指针类型的method receiver，避免复制整个对象的开销。
• 对象的可变性：如果对象需要被修改，应该选择指针类型的method receiver；如果对象不需要被修改，可以选择值类型的method receiver，保证代码的可预测性和可读性。
• 对象类型或对象的指针类型是否需要实现特定的接口。

注：关于method receiver的类型选择问题，在《Go语言第一课》专栏的第25讲有系统的讲解。

3.4 使用unsafe.Pointer进行不同type guided的值decode

前面说过，值是一个“有界比特序列”，在不同类型guided的decode下，得到的结果也是不同的。我们可以通过unsafe.Pointer来进行不同的decode，比如下面例子将一个uint32的值重新分别decode为一个[2]uint16和[4]uint8数组：

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var a uint32 = 0x12345678

    b := (*[2]uint16)(unsafe.Pointer(&a))
    c := (*[4]uint8)(unsafe.Pointer(&a))

    fmt.Println(*b) // [22136 4660]
    fmt.Println(*c) // [120 86 52 18]
}

4. 小结

本文对Go语言中值做了重新解读，我们认为Go中的值就是一个有界比特序列(bounded bit sequence)，是真实世界概念表示在计算机内存中的存储形式。

围绕着值这个概念，我们指出Go中一切皆是值。在这一观点的基础上，重新了解了值的分类、值的可变性、指针类型以及重要的值的传递，学习了值的传递的本质：bitwise-copy，以及这个传递过程针对不同类型值所取得的不同效果。

最后，我们了解了一些与值有关的tips，包括零值、值比较、method receiver类型选择以及值decode。

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

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

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式：

• 微博(暂不可用)：https://weibo.com/bigwhite20xx
• 微博2：https://weibo.com/u/6484441286
• 博客：tonybai.com
• github: https://github.com/bigwhite

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

本文永久链接 – https://tonybai.com/2023/03/12/is-go-object-oriented

Go语言已经开源13年了，在近期TIOBE发布的2023年3月份的编程语言排行榜中，Go再次冲入前十，相较于Go在2022年底的排名提升了2个位次：

《Go语言第一课》专栏中关于Go在这两年开始飞起的“预言”也正在逐步成为现实^_^，大家学习Go的热情也在快速提升， 《Go语言第一课》专栏的学习的人数年后也快速增加，快突破2w了。

很多专栏的订阅者都是第一次接触Go，他们中的很多是来自像Java, Ruby这样的OO(面向对象)语言阵营的，他们学习Go之后的第一个问题便是：Go是一门OO语言吗？在这篇博文中，我们就来探讨一下。

一. 溯源

在公认的Go语言“圣经”《Go程序设计语言》一书中，有这样一幅Go语言与其主要的先祖编程语言的亲缘关系图：

从图中我们可以清晰看到Go语言的“继承脉络”：

• 从C语言那里借鉴了表达式语法、控制语句、基本数据类型、值参数传递、指针等；
• 从Oberon-2语言那里借鉴了package、包导入和声明的语法，而Object Oberon提供了方法声明的语法。
• 从Alef语言以及Newsqueak语言中借鉴了基于CSP的并发语法。

我们看到，从Go先祖溯源的情况来看，Go并没有从纯面向对象语言比如Simula、SmallTalk等那里取经。

Go诞生于2007年，开源于2009年，那正是面向对象语言和OO范式大行其道的时期。不过Go设计者们觉得经典OO的继承体系对程序设计与扩展似乎并无太多好处，还带来了较多的限制，因此在正式版本中并没有支持经典意义上的OO语法，即基于类和对象实现的封装、继承和多态这三大OO主流特性。

但这是否说明Go不是一门OO语言呢？也不是！ 带有面向对象机制的Object Oberon也是Go的先祖语言之一，虽然Object Oberon的OO语法又与我们今天常见的语法有较大差异。

就此问题，我还特意咨询了ChatGPT^_^，得到的答复如下：

ChatGPT认为：Go支持面向对象，提供了对面向对象范式基本概念的支持，但支持的手段却并不是类与对象。

那么针对这个问题Go官方是否有回应呢？有的，我们来看一下。

二. 官方声音

Go官方在FAQ中就Go是否是OO语言做了简略回应：

Is Go an object-oriented language?

Yes and no. Although Go has types and methods and allows an object-oriented style of programming, there is no type hierarchy. The concept of “interface” in Go provides a different approach that we believe is easy to use and in some ways more general. There are also ways to embed types in other types to provide something analogous—but not identical—to subclassing. Moreover, methods in Go are more general than in C++ or Java: they can be defined for any sort of data, even built-in types such as plain, “unboxed” integers. They are not restricted to structs (classes).

Also, the lack of a type hierarchy makes “objects” in Go feel much more lightweight than in languages such as C++ or Java.

粗略翻译过来就是：

Go是一种面向对象的语言吗？

是，也不是。虽然Go有类型和方法，并且允许面向对象的编程风格，但却没有类型层次。Go中的“接口”概念提供了一种不同的OO实现方案，我们认为这种方案更易于使用，而且在某些方面更加通用。还有一些可以将类型嵌入到其他类型中以提供类似子类但又不等同于子类的机制。此外，Go中的方法比C++或Java中的方法更通用：Go可以为任何数据类型定义方法，甚至是内置类型，如普通的、“未装箱的”整数。Go的方法并不局限于结构体（类）。

此外，由于去掉了类型层次，Go中的“对象”比C++或Java等语言更轻巧。

“是，也不是”！我们看到Go官方给出了一个“对两方都无害”的中庸的回答。那么Go社区是怎么认为的呢？我们来看看Go社区的一些典型代表的观点。

三. 社区声音

Jaana Dogan和Steve Francia都是前Go核心团队成员，他们在加入Go团队之前对“Go是否是OO语言”这一问题也都有自己的观点论述。

Jaana Dogan在《The Go type system for newcomers》一文中给出的观点是：Go is considered as an object-oriented language even though it lacks type hierarchy，即“Go被认为是一种面向对象的语言，即使它缺少类型层次结构”。

而更早一些的是Steve Francia在2014年发表的文章《Is Go an Object Oriented language?》中的结论观点：Go，没有对象或继承的面向对象编程，也可称为“无对象”的OO编程模型。

两者表达的遣词不同，但含义却异曲同工，即Go支持面向对象编程，但却不是通过提供经典的类、对象以及类型层次来实现的。

那么Go究竟是以何种方式实现对OOP的支持的呢？我们继续看！

四. Go的“无对象”OO编程

经典OO的三大特性是封装、继承与多态，这里我们看看Go中是如何对应的。

1. 封装

封装就是把数据以及操作数据的方法“打包”到一个抽象数据类型中，这个类型封装隐藏了实现的细节，所有数据仅能通过导出的方法来访问和操作。 这个抽象数据类型的实例被称为对象。经典OO语言，如Java、C++等都是通过类(class)来表达封装的概念，通过类的实例来映射对象的。熟悉Java的童鞋一定记得《Java编程思想》一书的第二章的标题：“一切都是对象”。在Java中所有属性、方法都定义在一个个的class中。

Go语言没有class，那么封装的概念又是如何体现的呢？来自OO语言的初学者进入Go世界后，都喜欢“对号入座”，即Go中什么语法元素与class最接近！于是他们找到了struct类型。

Go中的struct类型中提供了对真实世界聚合抽象的能力，struct的定义中可以包含一组字段(field)，如果从OO角度来看，你也可以将这些字段视为属性，同时，我们也可以为struct类型定义方法(method)，下面例子中我们定义了一个名为Point的struct类型，它拥有一个导出方法Length：

type Point struct {
    x, y float64
}

func (p Point) Length() float64 {
    return math.Sqrt(p.x * p.x + p.y * p.y)
}

我们看到，从语法形式上来看，与经典OO声明类的方法不同，Go方法声明并不需要放在声明struct类型的大括号中。Length方法与Point类型建立联系的纽带是一个被称为receiver参数的语法元素。

那么，struct是否就是对应经典OO中的类呢? 是，也不是！从数据聚合抽象来看，似乎是这样, struct类型可以拥有多个异构类型的、代表不同抽象能力的字段(比如整数类型int可以用来抽象一个真实世界物体的长度，string类型字段可以用来抽象真实世界物体的名字等)。

但从拥有方法的角度，不仅是struct类型，Go中除了内置类型的所有其他具名类型都可以拥有自己的方法，哪怕是一个底层类型为int的新类型MyInt：

type MyInt int

func(a MyInt)Add(b int) MyInt {
    return a + MyInt(b)
}

2. 继承

就像前面说的，Go设计者在Go诞生伊始就重新评估了对经典OO的语法概念的支持，最终放弃了对诸如类、对象以及类继承层次体系的支持。也就是说：在Go中体现封装概念的类型之间都是“路人”，没有亲爹和儿子的关系的“牵绊”。

谈到OO中的继承，大家更多想到的是子类继承了父类的属性与方法实现。Go虽然没有像Java extends关键字那样的显式继承语法，但Go也另辟蹊径地对“继承”提供了支持。这种支持方式就是类型嵌入(type embedding)，看一个例子：

type P struct {
    A int
    b string
}

func (P) M1() {
}

func (P) M2() {
}

type Q struct {
    c [5]int
    D float64
}

func (Q) M3() {
}

func (Q) M4() {
}

type T struct {
    P
    Q
    E int
}

func main() {
    var t T
    t.M1()
    t.M2()
    t.M3()
    t.M4()
    println(t.A, t.D, t.E)
}

我们看到类型T通过嵌入P、Q两个类型，“继承”了P、Q的导出方法(M1~M4)和导出字段(A、D)。

关于类型嵌入的具体语法说明，大家可以温习一下《十分钟入门Go语言》或《Go语言第一课》专栏。

不过实际Go中的这种“继承”机制并非经典OO中的继承，其外围类型(T)与嵌入的类型(P、Q)之间没有任何“亲缘”关系。P、Q的导出字段和导出方法只是被提升为T的字段和方法罢了，其本质是一种组合，是组合中的代理（delegate）模式的一种实现。T只是一个代理（delegate），对外它提供了它可以代理的所有方法，如例子中的M1~M4方法。当外界发起对T的M1方法的调用后，T将该调用委派给它内部的P实例来实际执行M1方法。

以经典OO理论话术去理解就是T与P、Q的关系不是is-a，而是has-a的关系。

3. 多态

经典OO中的多态是尤指运行时多态，指的是调用方法时，会根据调用方法的实际对象的类型来调用不同类型的方法实现。

下面是一个C++中典型多态的例子：

#include <iostream>

class P {
        public:
                virtual void M() = 0;
};

class C1: public P {
        public:
                void M();
};

void C1::M() {
        std::cout << "c1.M()\n";
}

class C2: public P {
        public:
                void M();
};

void C2::M() {
        std::cout << "c2.M()\n";
}

int main() {
        C1 c1;
        C2 c2;
        P *p = &c1;
        p->M(); // c1.M()
        p = &c2;
        p->M(); // c2.M()
}

这段代码比较清晰，一个父类P和两个子类C1和C2。父类P有一个虚拟成员函数M，两个子类C1和C2分别重写了M成员函数。在main中，我们声明父类P的指针，然后将C1和C2的对象实例分别赋值给p并调用M成员函数，从结果来看，在运行时p实际调用的函数会根据其指向的对象实例的实际类型而分别调用C1和C2的M。

显然，经典OO的多态实现依托的是类型的层次关系。那么对应没有了类型层次体系的Go来说，它又是如何实现多态的呢？Go使用接口来解锁多态！

和经典OO语言相比，Go更强调行为聚合与一致性，而非数据。因此Go提供了对类似duck typing的支持，即基于行为集合的类型适配，但相较于ruby等动态语言，Go的静态类型机制还可以保证应用duck typing时的类型安全。

Go的接口类型本质就是一组方法集合(行为集合)，一个类型如果实现了某个接口类型中的所有方法，那么就可以作为动态类型赋值给接口类型。通过该接口类型变量的调用某一方法，实际调用的就是其动态类型的方法实现。看下面例子：

type MyInterface interface {
    M1()
    M2()
    M3()
}

type P struct {
}

func (P) M1() {}
func (P) M2() {}
func (P) M3() {}

type Q int
func (Q) M1() {}
func (Q) M2() {}
func (Q) M3() {}

func main() {
    var p P
    var q Q
    var i MyInterface = p
    i.M1() // P.M1
    i.M2() // P.M2
    i.M3() // P.M3

    i = q
    i.M1() // Q.M1
    i.M2() // Q.M2
    i.M3() // Q.M3
}

Go这种无需类型继承层次体系、低耦合方式的多态实现，是不是用起来更轻量、更容易些呢！

五. Gopher的“OO思维”

到这里，来自经典OO语言阵营的小伙伴们是不是已经找到了当初在入门Go语言时“感觉到别扭”的原因了呢！这种“别扭”就在于Go对于OO支持的方式与经典OO语言的差别：秉持着经典OO思维的小伙伴一上来就要建立的继承层次体系，但Go没有，也不需要。

要转变为正宗的Gopher的OO思维其实也不难，那就是“prefer接口，prefer组合，将习惯了的is-a思维改为has-a思维”。

六. 小结

是时候给出一些结论性的观点了：

• Go支持OO，只是用的不是经典OO的语法和带层次的类型体系；
• Go支持OO，只是用起来需要换种思维；
• 在Go中玩转OO的思维方式是：“优先接口、优先组合”。

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

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

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式：

• 微博(暂不可用)：https://weibo.com/bigwhite20xx
• 微博2：https://weibo.com/u/6484441286
• 博客：tonybai.com
• github: https://github.com/bigwhite

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