标签 Pointer 下的文章

Go 1.24新特性前瞻:语法、编译器与运行时

本文永久链接 – https://tonybai.com/2024/12/16/go-1-24-foresight-part1

自2020年底撰写《Go 1.16版本新特性前瞻》以来,四年转瞬而逝。在这段时间里,每当Go的大版本开发进入新特性冻结(freeze)阶段,我都会为大家带来该版本的特性前瞻,旨在让大家更早地了解和实验这些新特性,从而在版本正式发布时能够准确评估是否应用它们。

11月末,Go 1.24的新特性开发已经冻结,我认为是时候对Go 1.24新特性进行前瞻了。本次前瞻将分为两篇进行,本文,也就是第一篇将讲解语法、编译器与运行时方面的变化,而第二篇将聚焦工具链和标准库。本次前瞻可以引导大家了解即将在明年3月份发布的Go 1.24版本中的重要变化,希望能给大家带去帮助。

注:Go每六个月发布一次。每个发布周期都分为持续约4个月的开发阶段,然后是为期3个月的测试和完善阶段(称为发布冻结期)。当前的发布周期预计于每年一月中旬和七月中旬开始,如下图所示。以Go 1.24为例,2024年7月开始plan,经过4个月开发,11月下旬冻结,再经历3个月的测试完善,预计2025年2月发布。


图来自go.dev/wiki/Go-Release-Cycle

注:大家可以使用Go playground体验dev branch的最新特性,或在本地安装GoTip版本进行体验。2024年12月14日,Go 1.24RC1版本发布,大家也可以直接用go install golang.org/dl/go1.24rc1@latest体验,或到Go官方下载站unstable version中直接下载安装。

1. 语法

Go 1.18引入了泛型Go 1.21版本新增了max、min和clear等预定义函数,而Go 1.23版本则引入了自定义迭代器。与这些创新相比,Go 1.24似乎又回归到了我们熟悉的“静默期”,没有显著的语法特性更新。

唯一一个值得提及的还是Go 1.23版本引入的实验特性:“带有类型参数的type alias”。如果你已经忘记这是一个什么语法特性,下面我就带你简单地回顾一下。

传统的类型别名的形式是这样的:

type P = Q

在《“类型名称”在Go语言规范中的演变》一文中我们介绍过,Q是Named Type,包括Predeclared Type、Anonymous Type、Existing Defined Type以及Existing Alias Type,甚至可以用泛型类型实例化后的类型作为Q,比如:

type MySlice[T any] []T

func main() {
    type P = MySlice[int]  // MySlice[int]作为Q
    var p P
    fmt.Println(len(p)) // 0
}

但P中不能包含类型参数!下面这样的类型别名定义是不合法的:

type P[T any] = []T

不过Go 1.23版本以实验特性(需显式使用GOEXPERIMENT=aliastypeparams)支持了带有类型参数的类型别名,在Go 1.24中,这个实验特性转正了,成为了默认特性。我们看看下面这个示例:

// go1.24-foresight/lang/generic_type_alias.go

package main

import "fmt"

type MySlice[T any] = []T

func main() {
    // 使用int类型实例化MySlice
    intSlice := MySlice[int]{1, 2, 3, 4, 5}
    fmt.Println("Int Slice:", intSlice)

    // 使用string类型实例化MySlice
    stringSlice := MySlice[string]{"hello", "world"}
    fmt.Println("String Slice:", stringSlice)

    // 使用自定义类型实例化MySlice
    type Person struct {
        Name string
        Age  int
    }

    personSlice := MySlice[Person]{
        {Name: "Alice", Age: 30},
        {Name: "Bob", Age: 25},
    }

    fmt.Println("Person Slice:", personSlice)
}

使用Gotip直接运行上面示例,我们可以得到如下结果:

Int Slice: [1 2 3 4 5]
String Slice: [hello world]
Person Slice: [{Alice 30} {Bob 25}]

怎么理解带有类型参数的类型别名呢?在《Go 1.23中值得关注的几个变化》一文中,我们也介绍了Russ Cox给出的理解,即可以将其看成是一种“类型宏”(类似c中的#define):

type MySlice[T any] = []T

就是在任何出现MySlice[T]的地方,将其换成[]T

在Go 1.23以实验特性出现的带类型参数的别名还有一些问题,比如下面这个本不该正常运行的示例(int切片类型是不满足comparable的),在Go 1.23.0版本中是可以正常编译运行的:

// go1.24-examples/lang/strict_alias.go

package main

import "fmt"

type MySlice[T any] = []T
type YourSlice[T comparable] = MySlice[T]

func main() {
    // 使用int类型实例化MySlice
    intSlice := MySlice[int]{1, 2, 3, 4, 5}
    fmt.Println("Int Slice:", intSlice)

    intsliceSlice := YourSlice[[]int]{
        []int{1, 2, 3},
        []int{4, 5, 6},
    }
    fmt.Println("IntSlice Slice:", intsliceSlice)
}

不过在Go 1.24中该问题被修正,如果你使用gotip运行该示例,你将得到类似下面编译错误:

./strict_alias.go:13:29: []int does not satisfy comparable

gotip版go spec(截至2024.12.09)中,对带有类型参数的type alias有如下约束:

type A[P any] = P    // illegal: P is a type parameter

即类型别名声明中的右侧已知类型不能是类型参数自身。但目前的gotip实现似乎忽略了这一条,下面代码在gotip下是可以正常编译运行的:

package main

import "fmt"

type A[P any] = P

func main() {
    var a A[int] = 5 // identical to int
    fmt.Println(a) // 5
}

此外Go 1.23.0中,带有类型参数的别名类型是不能跨包使用的,但Go 1.24中这条限制被取消了,带有类型参数的别名类型可以与常规类型别名一样跨包使用

在Go 1.24中,你也可以通过设置GOEXPERIMENT=noaliastypeparams来禁用这一特性,但该设置将在Go 1.25中被移除。

2. 编译器与运行时

2.1 运行时性能优化

Go 1.24版本在运行时方面实现了多个优化,包括采用基于Swiss Tables的原生map实现(#54766)、更高效的小对象内存分配以及改进的内部互斥锁实现,整体降低了2-3%的CPU开销。

Swiss Table是由Google工程师于2017年开发的一种高效哈希表实现,旨在优化内存使用和提升性能,解决Google内部代码库中广泛使用的std::unordered_map所面临的性能问题。目前,Swiss Table已被应用于多种编程语言,包括C++ Abseil库的flat_hash_map(可替换std::unordered_map)Rust标准库Hashmap的默认实现等。在字节工程师的提案下,Go runtime团队决定替换原生map的底层实现,改为基于Swiss Table。通过基于gotip的实测,大多数测试项中,新版基于swiss table的map的性能都有大幅提升,有些甚至接近50%!之前写过一篇《Go map使用Swiss Table重新实现,性能最高提升近50%》,大家可以移步到那里了解关于基于Swiss Table实现的map的原理的详情,这里就不赘述了。

另外一个重要的性能优化是runtime: improve scaling of lock2中的提案,旨在针对当前runtime.lock2实现的问题进行优化,具体的propsal在design/68578-mutex-spinbit.md文件中。下面简略说一下该优化的背景、方案原理以及取得的效果。

当前runtime.lock2的实现通过三态设计(未锁定、锁定、锁定且有等待线程),在高竞争情况下,多个线程反复轮询mutex的状态字,产生大量缓存一致性流量。每个轮询线程需要从内存中加载状态字,并在更新时触发缓存行失效,这导致性能大幅下降。而每次释放锁时,无论是否已有线程在轮询mutex状态字,都会尝试唤醒一个线程,这进一步增加了系统负载。总之,现有的三态设计不能有效限制线程的忙等待行为。即使锁的临界区操作非常短,线程依然会因为抢占资源而竞争加剧

新提案引入“spinbit”机制,扩展mutex状态字,增加一个”spinning”位,表示是否有线程处于忙等待状态。一个线程可以独占此位,在轮询状态字时拥有优先权。其他线程无需忙等待,直接进入休眠。同时提案优化了唤醒逻辑,当unlock2检测到已有线程正在忙等待时,不再唤醒休眠线程,从而减少不必要的线程切换和上下文切换。

目前该优化提供了基于futex和非futex系统调用的两个实现,基于futex的版本适用于Linux平台,通过精细控制休眠线程的列表,进一步减少竞争。

状态字中使用独立的位分别表示锁定状态、休眠线程存在与否、忙等待标志等,并通过位操作和Xchg8原子操作,确保性能和线程安全。

新方案在高竞争状况下取得了显著的可扩展性提升,新实现的spinbit机制能维持性能稳定,而不是像现有实现那样随线程数增加而急剧下降。基准测试表明,在GOMAXPROCS=20时,性能提升达3倍。大部分线程可以按设计预期那样,直接休眠而非忙等待,减少了电力消耗和处理器资源占用。同时,通过对休眠线程的显式管理,可实现有针对性的唤醒,降低线程长期休眠的风险(避免饿死)。

上述的基于Swiss table的map实现以及lock2优化是实验特性,但都是默认生效的,在Go 1.24中,你可以在构建阶段,通过显式设置GOEXPERIMENT=noswissmap和GOEXPERIMENT=nospinbitmutex关闭这两个实验特性。

2.2 cgo:优化C代码调用

如果你决定不碰cgo,那么你大可略过这节的说明。

传统cgo机制下调用c函数时,Go会保证传递给C函数的go指针指向的对象位于堆上。但如果C函数不保留Go指针的副本,并且不将该指针传递回Go代码,那么这个保证就是没有必要的。Go 1.24增加了下面注解用于显式告诉go编译器:不会有指针通过特定的C函数逃逸。

// #cgo noescape cFunctionName

此外,当Go函数调用C函数时,它默认会为C函数中再调用Go函数做好准备,这当然会有一些额外开销。这对于那些不会调回Go函数的C函数也是没有必要的。在Go 1.24中新增的#cgo nocallback注解就是用于告诉编译器这些准备工作不是必需的:

// #cgo nocallback cFunctionName

更多关于上述cgo优化c代码调用的新机制的说明,请参见cgo增加#cgo noescape和#cgo nocallback注解(#56378)

2.3 编译器禁止为C类型别名添加方法

Go 1.24之前,Go编译器允许在C类型的别名上声明方法,虽然某些时候它可以正常工作,如下面示例:

package main

/*
typedef int foo;
*/
import "C"

type foo = C.foo

func (foo) method() int { return 123 }

func main() {
    var x foo
    println(x.method()) // "123"
}

但这可能引入了潜在的类型安全性以及运行时错误问题,尽管目前为C类型别名添加方法的情形非常少。

Go 1.24通过引入了一个新的编译器检查修复了该问题,该检查利用了isCgoGeneratedFile函数和类型名称的特征(如_Ctype_前缀)来识别C类型别名,并禁止在C类型别名上声明方法。

3. 小结

本文对即将发布的Go 1.24版本的新特性进行了全面的展望。主要内容包括:

语法更新:Go 1.24未显著增加新语法特性,但实验性特性“带有类型参数的类型别名”已转正为默认特性,允许更灵活的类型别名定义。

编译器与运行时优化:

  • 运行时性能优化:引入了基于Swiss Tables的新原生map实现,显著提高了性能。还优化了内部互斥锁的实现,改善了高竞争情况下的性能。
  • cgo改进:新增了#cgo noescape和#cgo nocallback注解,优化C代码调用的效率。
  • 编译器限制:禁止在C类型别名上声明方法,以提高类型安全性。

Go 1.24版本在语法上保持稳定,但在性能和安全性方面进行了多项关键优化,旨在提升开发者的体验和代码的效率。

在接下来的“Go 1.24新特性前瞻:工具链和标准库”一文中,我将继续为大家带来更丰富详尽的Go 1.24新特性,敬请期待!

本文涉及的源码可以在这里下载。

4. 参考资料


Gopher部落知识星球在2024年将继续致力于打造一个高品质的Go语言学习和交流平台。我们将继续提供优质的Go技术文章首发和阅读体验。同时,我们也会加强代码质量和最佳实践的分享,包括如何编写简洁、可读、可测试的Go代码。此外,我们还会加强星友之间的交流和互动。欢迎大家踊跃提问,分享心得,讨论技术。我会在第一时间进行解答和交流。我衷心希望Gopher部落可以成为大家学习、进步、交流的港湾。让我相聚在Gopher部落,享受coding的快乐! 欢迎大家踊跃加入!

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
  • Gopher Daily Feed订阅 – https://gopherdaily.tonybai.com/feed

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

Go:值与指针

本文永久链接 – 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核心技术,并继续加强与星友的互动。欢迎大家加入!

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://github.com/bigwhite/gopherdaily

我的联系方式:

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

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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言进阶课 AI原生开发工作流实战 从 0 开始构建 Agent Harness 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