Go语言规格说明书 之 内建函数（Built-in functions）

go version go1.11 windows/amd64

 

本文为阅读Go语言中文官网的规则说明书（https://golang.google.cn/ref/spec）而做的笔记，介绍Go语言的 内建函数（Built-in functions）。

 

规格说明书中的目录如下：

Built-in functions
  -Close
  -Length and capacity
  -Allocation
  -Making slices, maps and channels
  -Appending to and copying slices
  -Deletion of map elements
  -Manipulating complex numbers
  -Handling panics
  -Bootstrapping

 

在规格说明书中，介绍了15个内建函数，如下所示：

close, len, cap, new, make, append, copy, delete,
complex, real, imag, panic, recover,
print, println

 

下面简要介绍各个函数：

close

关闭信道（channel）。

在没有更多数据 要 发送 的时候关闭信道。

close(channel)

也就是说，channel必须是 只发 或 双向类型的才可以，否则错误。

发送 或 关闭 一个已经关闭的 信道 会出现 运行时错误（run-time panic）。

关闭 nil 信道 也会导致 运行时错误。

在调用close函数，并且之前发送的数据都已被接收到 之后，接收操作 会 返回 信道类型的0值，且不会阻塞，，多个值的接收操作 会返回 一个接收值 和 信道是否关闭的标志。

// 单个值接收操作
v1 := <-ch
v2 = <-ch

// 多（两）个值接收操作
x, ok = <-ch
x, ok := <-ch
var x, ok = <-ch
var x, ok T = <-ch

 

len，cap

这两个函数接收各种类型的参数，返回一个int型的结果。

len函数返回参数的 长度、元素个数，cap返回参数的 容量。

官文介绍：

Call      Argument type    Result

len(s)    string type      string length in bytes
          [n]T, *[n]T      array length (== n)
          []T              slice length
          map[K]T          map length (number of defined keys)
          chan T           number of elements queued in channel buffer

cap(s)    [n]T, *[n]T      array length (== n)
          []T              slice capacity
          chan T           channel buffer capacity

从官文介绍可以看出，len函数 的参数可以为 字符串、数组类型、数组指针、分片、映射类型、信道——在信道缓存中排队的元素数量，

                                    cap函数 的参数可以为 数组、数组指针、分片、信道——缓存容量大小。

分片类型 的容量是指 分配给它的 底层数组 的元素的数量。在任何时候，下面的公式是成立的：

0 <= len(s) <= cap(s)

值为 nil 的 分片、映射、信道 的长度为0，值为 nil 的分片的容量为 0。

 

如果 s 是 字符串常量，那么，表达式 len(s) 也是常量；

如果 s 是 数组 或者 指向数组的指针，那么，表达式 len(s) 和 cap(s) 也是常量，并且 s 的元素类型不是 接收信道 或 函数类型，在这种情况下，s 是无法被估值的（evaluated）；

除了上面的情况外，调用 len 和 cap 得到的都不是常量，而且s是可以估值的（翻译的有些不准确，这个evaluated到底是什么意思？）。

 

官文示例：

const (
	c1 = imag(2i)                    // imag(2i) = 2.0 is a constant
	c2 = len([10]float64{2})         // [10]float64{2} contains no function calls
	c3 = len([10]float64{c1})        // [10]float64{c1} contains no function calls
	c4 = len([10]float64{imag(2i)})  // imag(2i) is a constant and no function call is issued
	c5 = len([10]float64{imag(z)})   // invalid: imag(z) is a (non-constant) function call
)
var z complex128

 

new

new函数 在学习接口类型时遇到了，使用new，可以新建一个类型的实例。

new函数 属于 Allocation（分配） 小节，分配 什么呢？内存空间了。

官文翻译：

在 运行时，给 变量 分配一个 存储空间，这个空间大小由 变量类型决定，并且 返回 一个 变量类型的指针 指向分配的空间。

在分配完存储空间后，再进行初始化——分配完毕后是0值。

 

疑问，不能在分配时进行初始化吗？需要试验！

type S1 struct {
	int
	float32
}

var sv2 = new(S1{23, 32.0}) // 错误：S1 literal is not a type
fmt.Println(sv2)
fmt.Println(sv2.int, sv2.float32)

看来不能在调用new函数时赋值！或者俺的方法不对！

更改代码后测试：

var sv2 = new(S1)
sv2.int = 23
sv2.float32 = 32.0
fmt.Println(sv2)
fmt.Println(sv2.int, sv2.float32)

// 测试结果
// 注意第一行的 & 符号！
// 返回的 sv2 是一个 指针
&{23 32}
23 32

 

官文示例：

type S struct { a int; b float64 }
new(S)

 

make

make函数 属于 Making slices, maps and channels 一节的唯一函数，用于常见 分片、映射和信道。

make函数 的第一个参数为 类型T，可以选择跟着一个表达式的指明类型的列表（原文：optionally followed by a type-specific list of expressions，翻译存在问题）。

返回 类型T，而不是 *T，，空间初始化可以参考initial values。

官文中介绍的用法：

Call             Type T     Result

make(T, n)       slice      slice of type T with length n and capacity n // 第二个参数n表示长度，没有第三个参数时，n也表示容量
make(T, n, m)    slice      slice of type T with length n and capacity m // 第二个参数n表示长度，第三个参数m表示容量

make(T)          map        map of type T // 映射，但没有分配初始空间
make(T, n)       map        map of type T with initial space for approximately n elements // 分配了初始空间的映射，可以容纳n个元素，但可以自动扩展（需确认）

make(T)          channel    unbuffered channel of type T // 无缓冲信道
make(T, n)       channel    buffered channel of type T, buffer size n // 缓冲区大小为 n（字节吗？）的信道，关于信道的资料，自己还需dig

每一个n、m都必须是 整型（integer type，各种整型吗？），或者一个 无类型的常量。一个常量大小参数不能是非负数，并且可以被类型int的值表示，，如果是无类型的常量，会被分配类型int。

n不能大于m。

如果n在运行时 为 负数 或 大于m，会产生一个运行时错误。

 

官文示例——合法、非法使用的都有：

s := make([]int, 10, 100)       // slice with len(s) == 10, cap(s) == 100
s := make([]int, 1e3)           // slice with len(s) == cap(s) == 1000
s := make([]int, 1<<63)         // illegal: len(s) is not representable by a value of type int // 1<<63超过类型int的范围了
s := make([]int, 10, 0)         // illegal: len(s) > cap(s)
c := make(chan int, 10)         // channel with a buffer size of 10
m := make(map[string]int, 100)  // map with initial space for approximately 100 elements

 

调用指定了类型和参数n的make函数创建映射时，会创建一个可以包含n个元素的初始化空间，但是，空间大小是和编译器的实现相关的（implementation-dependent）——这个大小是无法统一。

 

append，copy

这两个函数用来操作分片。从函数名可知，append用来给分片添加元素，copy用来从分片拷贝元素，拷贝到哪里呢？拷贝到分片中。

对于这两个函数，其返回结果是和 参数指向的内存是否覆盖（whether the memory referenced by the arguments overlaps） 没有关系的。

 

可变参函数append添加0到多个到分片，并返回 结果分片。

参数x中的值得类型T，必须是分片S的元素类型，但有一个特例，第一个参数为 []byte类型，第二个参数为string类型——但其结尾添加三个英文句号（...），这种情况表示将添加字符串的字节数组到第一个参数。

append(s S, x ...T) S  // T is the element type of S

如果分片s的容量不足于包含新添加的值，appen将分配新的、足够大的 底层数组 来满足 存在的分片和新增值 的空间，，否则，appen函数将使用 底层数组。

疑问，前面讲到，append会返回新的分片，那么，这个分片和旧的分片是什么关系呢？是在旧的分片上操作的吗？需要dig！之前自己操作时，是需要把append的返回值 赋值给 旧分片的变量的。

官文示例：

s0 := []int{0, 0}
s1 := append(s0, 2)                // append a single element     s1 == []int{0, 0, 2}
s2 := append(s1, 3, 5, 7)          // append multiple elements    s2 == []int{0, 0, 2, 3, 5, 7}
s3 := append(s2, s0...)            // append a slice              s3 == []int{0, 0, 2, 3, 5, 7, 0, 0}
s4 := append(s3[3:6], s3[2:]...)   // append overlapping slice    s4 == []int{3, 5, 7, 2, 3, 5, 7, 0, 0}

// 下面这个很有意思！用到了 空接口，分片可以包含 任何类型 的数据了
var t []interface{}
t = append(t, 42, 3.1415, "foo")   //                             t == []interface{}{42, 3.1415, "foo"}

var b []byte
b = append(b, "bar"...)            // append string contents      b == []byte{'b', 'a', 'r' }

 

copy函数从 源分片拷贝若干元素到目的分片，并返回拷贝的元素的数量。源分片和目的分片的元素类型T必须相同，并可以被赋值给[]T。

拷贝的元素的数量是 len(src)、len(dst) 中的最小值。

和append函数类似，copy函数也存在特例，目的分片为 []byte类型，源分片为字符串类型（string），这表示将字符串的字节数组拷贝到字符分片中。注意，特例不需要三个英文句号（...），这和append函数不同。

copy函数签名：

copy(dst, src []T) int
copy(dst []byte, src string) int

copy函数官文示例：

var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
var s = make([]int, 6)
var b = make([]byte, 5)
n1 := copy(s, a[0:])            // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
n2 := copy(s, s[2:])            // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
n3 := copy(b, "Hello, World!")  // n3 == 5, b == []byte("Hello")

 

delete

删除一个映射 m 中的键值为 k 的元素。k 的类型 必须是 可以赋值（assignable，这个不是很清楚什么意思，类型相同 或 结果的类型相同） 给 映射 m 的键类型的。

delete(m, k)  // remove element m[k] from map m

如果映射 m 的值为 nil，或者，m[k] 不存在，那么，调用函数 delete 将什么也不做（no-op）。

 

complex，real，imag

这三个函数属于 操作复数（Manipulating complex numbers） 这一节。

大概意思：

complex函数 根据参数的 浮点类型的 实部、虚部 建立复数，real函数 获取一个复数的 实部，imag函数 获取一个复数的 虚部。

官文的三个函数签名：

complex(realPart, imaginaryPart floatT) complexT
real(complexT) floatT
imag(complexT) floatT

 

complex的两个参数必须是相同的浮点类型——float32、float64，float32生成复数类型为complex64，float64生产的复数类型为complex128。

如果一个参数是 没有类型的常量（untyped constant），它的类型就被转换为另一个参数的类型；

如果两个参数都是 没有类型的常量，它们必须 不是复数、或者它们的虚部为0，并且返回的是一个 没有类型的复数（特别）。

 

对于real、imag函数，参数必须是复数类型，返回值的类型由参数的类型决定，对应关系：complex64-->float32，complex128-->float64。

如果参数时一个 没有类型的常量，那么，参数必须是数，并且返回值是 没有类型的浮点常量（特别）。

 

real、imag函数 一起 形成了 complex函数 的反函数，对于一个复数类型Z的值z，下面的公式是成立的：

z == Z(complex(real(z), imag(z)))

 

如果这些函数的操作数都是 常量，那么，返回值也是常量。

 

官文示例：

var a = complex(2, -2)             // complex128
const b = complex(1.0, -1.4)       // untyped complex constant 1 - 1.4i
x := float32(math.Cos(math.Pi/2))  // float32
var c64 = complex(5, -x)           // complex64
var s uint = complex(1, 0)         // untyped complex constant 1 + 0i can be converted to uint
_ = complex(1, 2<<s)               // illegal: 2 assumes floating-point type, cannot shift // 整数才可以做 位运算
var rl = real(c64)                 // float32
var im = imag(a)                   // float64
const c = imag(b)                  // untyped constant -1.4
_ = imag(3 << s)                   // illegal: 3 assumes complex type, cannot shift // 整数才可以做 位运算

 

panic，recover

这两个函数分别用于 报告 和 处理 运行时错误 或 程序自定义的错误条件，签名如下：

func panic(interface{})
func recover() interface{}

当然，panic函数 就是 报告一个错误，recover函数 就是负责处理的函数。

 

特别提醒，要读懂这一节，需要理解 Go语言中 的 Defer statements（延迟语句？）。

 

下面是官文翻译：

在执行 函数F 的时候，显式调用panic函数或者发生运行时错误（run-time panic）都会 终断函数F的执行，但是，任何被 函数F 延迟的函数 会立即被执行。

也就是说，函数F中发生错误了，如果没有 延迟函数，那么，函数F 被终断，如果有延迟函数，则执行完延迟函数后再终断。

前面讲到 函数F 的延迟函数被调用，所有的延迟函数执行完毕后，，接下来，函数F 的调用者 的延迟函数 开始执行，，直到goroutine的顶级函数的延迟函数被执行。

看到了吧，发生了错误，就一直是 延迟函数 在执行，直到goroutine的顶级函数的延迟函数被执行。那么，什么事goroutine呢？goroutine的顶级函数的延迟函数被执行 之后怎么样呢？销毁goroutine？

在这个时刻，程序被终止，错误条件被报告，同时被报告的还有函数panic的参数的值。这个终止序列被称为 panicking（翻译为什么好呢？惊险追踪？错误追踪？）。

官文示例——调用panic函数：

panic(42)
panic("unreachable")
panic(Error("cannot parse"))

上面讲了panic函数，用于 显示制造错误，在错误发生后，延迟函数开始执行，直到goroutine的顶级函数的延迟函数被执行完毕。

注意，延迟函数 在没有发生错误时也会执行，时机为 函数返回前（有返回return语句的） 和 函数结束前。

 

从上面也看到了，如果不阻止panic的扩散，程序（goroutine？这个自己还不完全清楚）会被终止！那么，怎么阻止呢？这就需要 recover函数 了！

 

recover函数 使用一段程序 去管理一个panicking goroutine的行为。

设想一下，函数G 延迟了 函数D 的执行，函数D中调用了 recover函数。

在同一个goroutine中，函数G发生了panic（错误），此时，被函数G延迟的函数开始执行——其中包括函数D，当执行到函数D时，函数D 中调用recover函数 的返回值 是传递到 调用panic函数中的值。

如果 函数D 正常返回，也没有产生新的panic，panicking这个过程就结束了！

在这种情况下，调用函数G到调用函数panic（发生错误）期间的函数状态就被忽略了，并且继续程序的正常执行。

前面到了函数D被执行了， 返回了，panicking结束了，此时，在函数D之前被函数G 延迟的 函数开始执行——如果有，函数G的执行被终止，返回它的调用者。

以上，便是执行recover函数的“内幕”！调用recover且没有产生新的panic就表示错误被处理了。程序还是在函数G中执行，但执行的是函数G的延迟函数，执行完延迟函数了，就返回到它的调用者。

 

前面提到 recover函数 有返回值，值为panic函数的参数。那么，recover函数调用后什么时候其返回值为 nil 呢？下面几种情况之一满足即返回 nil：

-panic函数的参数为 nil （空吗？）

-goroutine没有发生panicking——就是没错的时候调用recover恢复；

-recover函数不是被延迟函数直接调用的——这是什么情况？还需dig！

 

官文示例：protect函数 调用了 参数中的 函数g，并延迟了一个函数 用于处理 调用函数g 引发的panic（run-time panics）。

func protect(g func()) {
	defer func() { // 延迟函数定义，关键字 defer
		log.Println("done")  // Println executes normally even if there is a panic
		if x := recover(); x != nil { // 调用recover：如果发生错误，返回值 x 就不是 nil，此时，处理错误，只是打印一条信息
			log.Printf("run time panic: %v", x)
		}
	}()
	log.Println("start")
	g()
}

 

几乎理解了，还需要熟悉 goroutine，以及阅读和练习更多Go代码才行啊！

 

print，println

目前的Go语言实现提供了一些在引导时有用的内建函数，文档为了完整性会介绍这些函数，但是，不保证它们会存在于Go语言中，而且它们不会返回结果。

比如，本节的print、println两个函数，都用来输出 参数。

官文函数说明：

Function   Behavior

print      prints all arguments; formatting of arguments is implementation-specific
println    like print but prints spaces between arguments and a newline at the end

实现（所谓的实现，是指，各个软件开发组织 根据 这份规格说明书 来开发Go语言编译器的实现吧）要求：

print、pringln不需要接受所有的参数类型，但是，打印 布尔、数值、字符串类型 是必须支持的。

 

后记

又是小半个下午加晚上的一两个小时，这篇博文可是花了5个小时左右啊！

缺少一些示例，自己的实践，不够完美，但是呢，大部分知识点是讲清楚了，不清楚的也是有标记的。