Go语言圣经：基础数据类型、复合数据类型、函数、方法章节摘录

概述Go语言将数据类型分为四类：基础类型、复合类型、引用类型和接口类型。本章介绍基础类型，包括：数字、字符串和布尔型。复合数据类型——数组（§4.1）和结构体（§4.2）——是通过组合简单类型，来表达更加复杂的数据结构。引用类型包括指针（§2.3.2）、切片（§4.2)）字典（§4.3）、函数（§5）、通道（§8），虽然数据种类很多，但它们都是对程序中一个变量或状态的间接引用。这意味着对任一引用类型数

Go语言将数据类型分为四类：基础类型、复合类型、引用类型和接口类型。本章介绍基础类型，包括：数字、字符串和布尔型。复合数据类型——数组（§4.1）和结构体（§4.2）——是通过组合简单类型，来表达更加复杂的数据结构。引用类型包括指针（§2.3.2）、切片（§4.2)）字典（§4.3）、函数（§5）、通道（§8），虽然数据种类很多，但它们都是对程序中一个变量或状态的间接引用。这意味着对任一引用类型数据的修改都会影响所有该引用的拷贝。我们将在第7章介绍接口类型。

当使用fmt包打印一个数值时，我们可以用%d、%o或%x(%X)参数控制输出的进制格式

fmt.Printf("%d %[1]x %#[1]x %#[1]X\n",0xdeadbeef)// 3735928559 deadbeef 0xdeadbeef 0XDEADBEEF

注意fmt的两个使用技巧。通常Printf格式化字符串包含多个%参数时将会包含对应相同数量的额外 *** 作数，但是%之后的[1]副词告诉Printf函数再次使用第一个 *** 作数。第二，%后的#副词告诉Printf在用%o、%x或%X输出时生成0、0x或0X前缀。

一个float32类型的浮点数可以提供大约6个十进制数的精度，而float64则可以提供约15个十进制数的精度；通常应该优先使用float64类型，因为float32类型的累计计算误差很容易扩散，并且float32能精确表示的正整数并不是很大（译注：因为float32的有效bit位只有23个，其它的bit位用于指数和符号；当整数大于23bit能表达的范围时，float32的表示将出现误差）

var f float32 = 16777216 // 1 << 24fmt.Println(f == f+1)    // "true"!

用Printf函数的%g参数打印浮点数，将采用更紧凑的表示形式打印，并提供足够的精度，但是对应表格的数据，使用%e（带指数）或%f的形式打印可能更合适。所有的这三个打印形式都可以指定打印的宽度和控制打印精度。

fmt.Printf("%g,%[1]e,%[1]f",float64(0.11111111111111111111))// 0.1111111111111111,1.111111e-01,0.111111

math包中除了提供大量常用的数学函数外，还提供了IEEE754浮点数标准中定义的特殊值的创建和测试：正无穷大和负无穷大，分别用于表示太大溢出的数字和除零的结果；还有NaN非数，一般用于表示无效的除法 *** 作结果0/0或Sqrt(-1)

var z float64fmt.Println(z,-z,1/z,-1/z,z/z) // "0 -0 +Inf -Inf NaN"

布尔值并不会隐式转换为数字值0或1，反之亦然。必须使用一个显式的if语句辅助转换

i := 0if b { i = 1 }

如果需要经常做类似的转换,包装成一个函数会更方便

// btoi returns 1 if b is true and 0 if false.func btoi(b bool) int {    if b {        return 1    }    return 0}// itob reports whether i is non-zero.func itob(i int) bool { return i != 0 }

因为字符串是不可修改的，因此尝试修改字符串内部数据的 *** 作也是被禁止的
s[0] = 'L' // compile error: cannot assign to s[0]
不变性意味如果两个字符串共享相同的底层数据的话也是安全的，这使得复制任何长度的字符串代价是低廉的。同样，一个字符串s和对应的子字符串切片s[7:]的 *** 作也可以安全地共享相同的内存，因此字符串切片 *** 作代价也是低廉的。在这两种情况下都没有必要分配新的内存

原生字符串面值用于编写正则表达式会很方便，因为正则表达式往往会包含很多反斜杠。原生字符串面值同时被广泛应用于HTML模板、JsON面值、命令行提示信息以及那些需要扩展到多行的场景。

UTF8编码使用1到4个字节来表示每个Unicode码点，ASCII部分字符只使用1个字节，常用字符部分使用2或3个字节表示。每个符号编码后第一个字节的高端bit位用于表示总共有多少编码个字节。如果第一个字节的高端bit为0，则表示对应7bit的ASCII字符，ASCII字符每个字符依然是一个字节，和传统的ASCII编码兼容。如果第一个字节的高端bit是110，则说明需要2个字节；后续的每个高端bit都以10开头。更大的Unicode码点也是采用类似的策略处理

0xxxxxxx                             runes 0-127    (ASCII)110xxxxx 10xxxxxx                    128-2047       (values <128 unused)1110xxxx 10xxxxxx 10xxxxxx           2048-65535     (values <2048 unused)11110xxx 10xxxxxx 10xxxxxx 10xxxxxx  65536-0x10ffff (other values unused)

字符串包含13个字节，以UTF8形式编码，但是只对应9个Unicode字符

import "unicode/utf8"s := "Hello,世界"fmt.Println(len(s))                    // "13"fmt.Println(utf8.RuneCountInString(s)) // "9"

for i := 0; i < len(s); {    r,size := utf8.DecodeRuneInString(s[i:])    fmt.Printf("%d\t%c\n",i,r)    i += size}等价for i,r := range "Hello,世界" {    fmt.Printf("%d\t%q\t%d\n",r,r)}

每一个UTF8字符解码，不管是显式地调用utf8.DecodeRuneInString解码或是在range循环中隐式地解码，如果遇到一个错误的UTF8编码输入，将生成一个特别的Unicode字符’\uFFFD’，在印刷中这个符号通常是一个黑色六角或钻石形状，里面包含一个白色的问号（?）。当程序遇到这样的一个字符，通常是一个危险信号，说明输入并不是一个完美没有错误的UTF8字符串

标准库中有四个包对字符串处理尤为重要：bytes、strings、strconv和unicode包。strings包提供了许多如字符串的查询、替换、比较、截断、拆分和合并等功能。

bytes包也提供了很多类似功能的函数，但是针对和字符串有着相同结构的[]byte类型。因为字符串是只读的，因此逐步构建字符串会导致很多分配和复制。在这种情况下，使用bytes.Buffer类型将会更有效，稍后我们将展示。

strconv包提供了布尔型、整型数、浮点数和对应字符串的相互转换，还提供了双引号转义相关的转换。

unicode包提供了IsDigit、IsLetter、IsUpper和IsLower等类似功能，它们用于给字符分类。每个函数有一个单一的rune类型的参数，然后返回一个布尔值。而像toupper和Tolower之类的转换函数将用于rune字符的大小写转换。所有的这些函数都是遵循Unicode标准定义的字母、数字等分类规范。strings包也有类似的函数，它们是toupper和Tolower，将原始字符串的每个字符都做相应的转换，然后返回新的字符串。

字符串和字节slice之间可以相互转换

s := "abc"b := []byte(s)s2 := string(b)

从概念上讲，一个[]byte(s)转换是分配了一个新的字节数组用于保存字符串数据的拷贝，然后引用这个底层的字节数组。编译器的优化可以避免在一些场景下分配和复制字符串数据，但总的来说需要确保在变量b被修改的情况下，原始的s字符串也不会改变。将一个字节slice转到字符串的string(b) *** 作则是构造一个字符串拷贝，以确保s2字符串是只读的

bytes包还提供了Buffer类型用于字节slice的缓存。一个Buffer开始是空的，但是随着string、byte或[]byte等类型数据的写入可以动态增长，一个bytes.Buffer变量并不需要处理化，因为零值也是有效的

如果在数组的长度位置出现的是“…”省略号，则表示数组的长度是根据初始化值的个数来计算

q := [...]int{1,2,3}fmt.Printf("%T\n",q) // "[3]int"

数组的长度是数组类型的一个组成部分，因此[3]int和[4]int是两种不同的数组类型。数组的长度必须是常量表达式，因为数组的长度需要在编译阶段确定。

要删除slice中间的某个元素并保存原有的元素顺序，可以通过内置的copy函数将后面的子slice向前依次移动一位完成

func remove(slice []int,i int) []int {    copy(slice[i:],slice[i+1:])    return slice[:len(slice)-1]}func main() {    s := []int{5, 6, 7, 8, 9}    fmt.Println(remove(s, 2)) // "[5 6 8 9]"}

如果删除元素后不用保持原来顺序的话，我们可以简单的用最后一个元素覆盖被删除的元素

func remove(slice []int,i int) []int {    slice[i] = slice[len(slice)-1]    return slice[:len(slice)-1]}func main() {    s := []int{5, 2)) // "[5 6 9 8]}

但是map中的元素并不是一个变量，因此我们不能对map的元素进行取址 *** 作：
_ = &ages["bob"] // compile error: cannot take address of map element
禁止对map元素取址的原因是map可能随着元素数量的增长而重新分配更大的内存空间，从而可能导致之前的地址无效。

Map的迭代顺序是不确定的，并且不同的哈希函数实现可能导致不同的遍历顺序。在实践中，遍历的顺序是随机的，每一次遍历的顺序都不相同。这是故意的，每次都使用随机的遍历顺序可以强制要求程序不会依赖具体的哈希函数实现。如果要按顺序遍历key/value对，我们必须显式地对key进行排序，可以使用sort包的Strings函数对字符串slice进行排序。

var names []stringfor name := range ages {    names = append(names,name)}sort.Strings(names)for _,name := range names {    fmt.Printf("%s\t%d\n",name,ages[name])}

因为我们一开始就知道names的最终大小，因此给slice分配一个合适的大小将会更有效。下面的代码创建了一个空的slice，但是slice的容量刚好可以放下map中全部的key
names := make([]string,len(ages))

一个命名为S的结构体类型将不能再包含S类型的成员：因为一个聚合的值不能包含它自身。（该限制同样适应于数组。）但是S类型的结构体可以包含*S指针类型的成员，这可以让我们创建递归的数据结构，比如链表和树结构等

我们将看到如何使用Go语言提供的不同寻常的结构体嵌入机制让一个命名的结构体包含另一个结构体类型的匿名成员，这样就可以通过简单的点运算符x.f来访问匿名成员链中嵌套的x.d.e.f成员

type Point struct { X,Y int }type Circle struct { Point Radius int }type Wheel struct { Circle Spokes int }var w Wheelw.X = 8            // equivalent to w.Circle.Point.X = 8w.Y = 8            // equivalent to w.Circle.Point.Y = 8w.Radius = 5       // equivalent to w.Circle.Radius = 5w.Spokes = 20

结构体字面值必须遵循形状类型声明时的结构，所以我们只能用下面的两种语法，它们彼此是等价的

w = Wheel{Circle{Point{8,8},5},20}w = Wheel{    Circle: Circle{        Point:  Point{X: 8,Y: 8},Radius: 5,},Spokes: 20,// NOTE: trailing comma necessary here (and at Radius)}

到目前为止，我们看到匿名成员特性只是对访问嵌套成员的点运算符提供了简短的语法糖。稍后，我们将会看到匿名成员并不要求是结构体类型；其实任何命令的类型都可以作为结构体的匿名成员。但是为什么要嵌入一个没有任何子成员类型的匿名成员类型呢？

答案是匿名类型的方法集。简短的点运算符语法可以用于选择匿名成员嵌套的成员，也可以用于访问它们的方法。实际上，外层的结构体不仅仅是获得了匿名成员类型的所有成员，而且也获得了该类型导出的全部的方法。这个机制可以用于将一个有简单行为的对象组合成有复杂行为的对象。组合是Go语言中面向对象编程的核心

另一个Json.Marshalindent函数将产生整齐缩进的输出。该函数有两个额外的字符串参数用于表示每一行输出的前缀和每一个层级的缩进
data,err := Json.Marshalindent(movIEs,""," ")

结构体的成员Tag可以是任意的字符串面值，但是通常是一系列用空格分隔的key:”value”键值对序列；因为值中含有双引号字符，因此成员Tag一般用原生字符串面值的形式书写。Json开头键名对应的值用于控制enCoding/Json包的编码和解码的行为，并且enCoding/…下面其它的包也遵循这个约定。成员Tag中Json对应值的第一部分用于指定JsON对象的名字，比如将Go语言中的TotalCount成员对应到JsON中的total_count对象。color成员的Tag还带了一个额外的omitempty选项，表示当Go语言结构体成员为空或零值时不生成JsON对象（这里false为零值）

Year  int  `Json:"released"`color bool `Json:"color,omitempty"`

golang.org/x/… 目录下存储了一些由Go团队设计、维护，对网络编程、国际化文件处理、移动平台、图像处理、加密解密、开发者工具提供支持的扩展包。未将这些扩展包加入到标准库原因有二，一是部分包仍在开发中，二是对大多数Go语言的开发者而言，扩展包提供的功能很少被使用

虽然Go的垃圾回收机制会回收不被使用的内存，但是这不包括 *** 作系统层面的资源，比如打开的文件、网络连接。因此我们必须显式的释放这些资源。

fmt.Errorf函数使用fmt.Sprintf格式化错误信息并返回。我们使用该函数前缀添加额外的上下文信息到原始错误信息。当错误最终由main函数处理时，错误信息应提供清晰的从原因到后果的因果链，就像美国宇航局事故调查时做的那样
genesis: crashed: no parachute: G-switch Failed: bad relay orIEntation
由于错误信息经常是以链式组合在一起的，所以错误信息中应避免大写和换行符

处理错误的第二种策略。如果错误的发生是偶然性的，或由不可预知的问题导致的。一个明智的选择是重新尝试失败的 *** 作。在重试时，我们需要限制重试的时间间隔或重试的次数，防止无限制的重试

// WaitForServer attempts to contact the server of a URL. // It trIEs for one minute using exponential back-off. // It reports an error if all attempts fail.func WaitForServer(url string) error {    const timeout = 1 * time.Minute    deadline := time.Now().Add(timeout)    for trIEs := 0; time.Now().Before(deadline); trIEs++ {        _,err := http.head(url)        if err == nil {            return nil // success        }        log.Printf("server not responding (%s);retrying…",err)        time.Sleep(time.Second << uint(trIEs)) // exponential back-off    }    return fmt.Errorf("server %s Failed to respond after %s",url,timeout)}

处理错误的第三种策略：输出错误信息并结束程序。需要注意的是，这种策略只应在main中执行。对库函数而言，应仅向上传播错误，除非该错误意味着程序内部包含不一致性，即遇到了BUG，才能在库函数中结束程序

// (In function main.)if err := WaitForServer(url); err != nil {    fmt.Fprintf(os.Stderr,"Site is down: %v\n",err)    os.Exit(1)}或log.Fatalf("Site is down: %v\n",err)

我们应该在每次函数调用后，都养成考虑错误处理的习惯，当你决定忽略某个错误时，你应该在清晰的记录下你的意图

在Go中，错误处理有一套独特的编码风格。检查某个子函数是否失败后，我们通常将处理失败的逻辑代码放在处理成功的代码之前。如果某个错误会导致函数返回，那么成功时的逻辑代码不应放在else语句块中，而应直接放在函数体中。Go中大部分函数的代码结构几乎相同，首先是一系列的初始检查，防止错误发生，之后是函数的实际逻辑

在Go中，函数被看作第一类值（first-class values）：函数像其他值一样，拥有类型，可以被赋值给其他变量，传递给函数，从函数返回。对函数值（function value）的调用类似函数调用

fmt.Printf的一个小技巧控制输出的缩进。%*s中的*会在字符串之前填充一些空格。在例子中，每次输出会先填充depth*2数量的空格，再输出""，最后再输出HTML标签
fmt.Printf("%*s</%s>\n",depth*2,n.Data)

func squares() func() int {    var x int    return func() int {        x++        return x * x    }}func main() {    f := squares()    fmt.Println(f()) // "1"    fmt.Println(f()) // "4"    f := squares()    fmt.Println(f()) // "1"    fmt.Println(f()) // "4"}

函数squares返回另一个类型为 func() int 的函数。对squares的一次调用会生成一个局部变量x并返回一个匿名函数。每次调用时匿名函数时，该函数都会先使x的值加1，再返回x的平方。第二次调用squares时，会生成第二个x变量，并返回一个新的匿名函数。新匿名函数 *** 作的是第二个x变量。

squares的例子证明，函数值不仅仅是一串代码，还记录了状态。在squares中定义的匿名内部函数可以访问和更新squares中的局部变量，这意味着匿名函数和squares中，存在变量引用。这就是函数值属于引用类型和函数值不可比较的原因。Go使用闭包（closures）技术实现函数值，Go程序员也把函数值叫做闭包。

当匿名函数需要被递归调用时，我们必须首先声明一个变量（在上面的例子中，我们首先声明了 visitAll），再将匿名函数赋值给这个变量。如果不分成两部，函数字面量无法与visitAll绑定，我们也无法递归调用该匿名函数。

visitAll := func(items []string) {    // ...    visitAll(m[item]) // compile error: undefined: visitAll    // ...}而是var visitAll func(items []string)visitAll = func(items []string) {    // ...    visitAll(m[item])    // ...}

var rmdirs []func()for _,d := range tempDirs() {    dir := d // NOTE: necessary!    os.MkdirAll(dir, 0755) // creates parent directorIEs too    rmdirs = append(rmdirs,func() {        os.RemoveAll(dir)    })}for _,rmdir := range rmdirs {    rmdir() // clean up}

问题的原因在于循环变量的作用域。在上面的程序中，for循环语句引入了新的词法块，循环变量dir在这个词法块中被声明。在该循环中生成的所有函数值都共享相同的循环变量。需要注意，函数值中记录的是循环变量的内存地址，而不是循环变量某一时刻的值。以dir为例，后续的迭代会不断更新dir的值，当删除 *** 作执行时，for循环已完成，dir中存储的值等于最后一次迭代的值。这意味着，每次对os.RemoveAll的调用删除的都是相同的目录。

通常，为了解决这个问题，我们会引入一个与循环变量同名的局部变量，作为循环变量的副本。比如下面的变量dir，虽然这看起来很奇怪，但却很有用。

这个问题不仅存在基于range的循环，在下面的例子中，对循环变量i的使用也存在同样的问题

var rmdirs []func()dirs := tempDirs()for i := 0; i < len(dirs); i++ {    os.MkdirAll(dirs[i], 0755) // OK    rmdirs = append(rmdirs,func() {        os.RemoveAll(dirs[i]) // NOTE: incorrect!    })}

如果你使用go语句（第八章）或者defer语句（5.8节）会经常遇到此类问题。这不是go或defer本身导致的，而是因为它们都会等待循环结束后，再执行函数值。

在声明可变参数函数时，需要在参数列表的最后一个参数类型之前加上省略符号“…”，这表示该函数会接收任意数量的该类型参数。

func sum(vals...int) int {    total := 0    for _,val := range vals {        total += val    }    return total}fmt.Println(sum())           // "0"fmt.Println(sum(1,3,4)) // "10"

在上面的代码中，调用者隐式的创建一个数组，并将原始参数复制到数组中，再把数组的一个切片作为参数传给被调函数。如果原始参数已经是切片类型，我们该如何传递给sum？只需在最后一个参数后加上省略符

values := []int{1,4}fmt.Println(sum(values...)) // "10"

调试复杂程序时，defer机制也常被用于记录何时进入和退出函数。下例中的bigSlowOperation函数，直接调用trace记录函数的被调情况。bigSlowOperation被调时，trace会返回一个函数值，该函数值会在bigSlowOperation退出时被调用。通过这种方式， 我们可以只通过一条语句控制函数的入口和所有的出口，甚至可以记录函数的运行时间，如例子中的start。需要注意一点：不要忘记defer语句后的圆括号，否则本该在进入时执行的 *** 作会在退出时执行，而本该在退出时执行的，永远不会被执行。

func bigSlowOperation() {    defer trace("bigSlowOperation")() // don't forget the    extra parentheses    // ...lots of work…    time.Sleep(10 * time.Second) // simulate slow    operation by sleePing}func trace(msg string) func() {    start := time.Now()    log.Printf("enter %s",msg)    return func() {         log.Printf("exit %s (%s)",msg,time.Since(start))     }}

我们知道，defer语句中的函数会在return语句更新返回值变量后再执行，又因为在函数中定义的匿名函数可以访问该函数包括返回值变量在内的所有变量，所以，对匿名函数采用defer机制，可以使其观察函数的返回值。

func double(x int) (result int) {    defer func() { fmt.Printf("double(%d) = %d\n",x,result) }()    return x + x}_ = double(4)// Output:// "double(4) = 8"

被延迟执行的匿名函数甚至可以修改函数返回给调用者的返回值：

func triple(x int) (result int) {    defer func() { result += x }()    return double(x)}fmt.Println(triple(4)) // "12"

在每一个合法的方法调用表达式中，也就是下面三种情况里的任意一种情况都是可以的：
不论是接收器的实际参数和其接收器的形式参数相同，比如两者都是类型T或者都是类型*T：

Point{1,2}.distance(q) //  Pointpptr.ScaleBy(2)         // *Point

或者接收器形参是类型T，但接收器实参是类型*T，这种情况下编译器会隐式地为我们取变量的地址：
p.ScaleBy(2) // implicit (&p)
或者接收器形参是类型*T，实参是类型T。编译器会隐式地为我们解引用，取到指针指向的实际变量：
pptr.distance(q) // implicit (*pptr)

如果类型T的所有方法都是用T类型自己来做接收器(而不是*T)，那么拷贝这种类型的实例就是安全的；调用他的任何一个方法也就会产生一个值的拷贝。比如time.Duration的这个类型，在调用其方法时就会被全部拷贝一份，包括在作为参数传入函数的时候。但是如果一个方法使用指针作为接收器，你需要避免对其进行拷贝，因为这样可能会破坏掉该类型内部的不变性。比如你对bytes.Buffer对象进行了拷贝，那么可能会引起原始对象和拷贝对象只是别名而已，但实际上其指向的对象是一致的。紧接着对拷贝后的变量进行修改可能会有让你意外的结果。
译注： 作者这里说的比较绕，其实有两点：
不管你的method的receiver是指针类型还是非指针类型，都是可以通过指针/非指针类型进行调用的，编译器会帮你做类型转换。
在声明一个method的receiver该是指针还是非指针类型时，你需要考虑两方面的内部，第一方面是这个对象本身是不是特别大，如果声明为非指针变量时，调用会产生一次拷贝；第二方面是如果你用指针类型作为receiver，那么你一定要注意，这种指针类型指向的始终是一块内存地址，就算你对其进行了拷贝。熟悉C或者C艹的人这里应该很快能明白。

在类型中内嵌的匿名字段也可能是一个命名类型的指针，这种情况下字段和方法会被间接地引入到当前的类型中(译注：访问需要通过该指针指向的对象去取)。添加这一层间接关系让我们可以共享通用的结构并动态地改变对象之间的关系

type coloredPoint struct {    *Point    color color.RGBA}p := coloredPoint{&Point{1,1},red}q := coloredPoint{&Point{5,4},blue}fmt.Println(p.distance(*q.Point)) // "5"q.Point = p.Point                 // p and q Now share the same Pointp.ScaleBy(2)fmt.Println(*p.Point,*q.Point) // "{2 2} {2 2}"

一个struct类型也可能会有多个匿名字段

type coloredPoint struct { Point color.RGBA }

然后这种类型的值便会拥有Point和RGBA类型的所有方法，以及直接定义在coloredPoint中的方法。当编译器解析一个选择器到方法时，比如p.ScaleBy，它会首先去找直接定义在这个类型里的ScaleBy方法，然后找被coloredPoint的内嵌字段们引入的方法，然后去找Point和RGBA的内嵌字段引入的方法，然后一直递归向下找。如果选择器有二义性的话编译器会报错，比如你在同一级里有两个同名的方法

下面这个例子展示了简单的cache，其使用两个包级别的变量来实现，一个mutex互斥量和它所 *** 作的cache：

var (    mu sync.Mutex // guards mapPing    mapPing = make(map[string]string))func Lookup(key string) string {    mu.Lock()    v := mapPing[key]    mu.Unlock()    return v}等价var cache = struct {    sync.Mutex    mapPing map[string]string}{    mapPing: make(map[string]string),}func Lookup(key string) string {    cache.Lock()    v := cache.mapPing[key]    cache.Unlock()    return v}

我们经常选择一个方法，并且在同一个表达式里执行，比如常见的p.distance()形式，实际上将其分成两步来执行也是可能的。p.distance叫作“选择器”，选择器会返回一个方法”值”->一个将方法(Point.distance)绑定到特定接收器变量的函数。这个函数可以不通过指定其接收器即可被调用；即调用时不需要指定接收器(译注：因为已经在前文中指定过了)，只要传入函数的参数即可：

p := Point{1,2}q := Point{4,6}distanceFromP := p.distance        // method valuefmt.Println(distanceFromP(q))      // "5"

type Rocket struct { /* ... */ }func (r *Rocket) Launch() { /* ... */ }r := new(Rocket)time.AfterFunc(10 * time.Second,func() { r.Launch() })等价time.AfterFunc(10 * time.Second,r.Launch)

当T是一个类型时，方法表达式可能会写作T.f或者(*T).f，会返回一个函数”值”，这种函数会将其第一个参数用作接收器，所以可以用通常(译注：不写选择器)的方式来对其进行调用：

p := Point{1,6}distance := Point.distance   // method Expressionfmt.Println(distance(p,q))  // "5"fmt.Printf("%T\n",distance) // "func(Point,Point) float64"

总结

以上是内存溢出为你收集整理的Go语言圣经：基础数据类型、复合数据类型、函数、方法章节摘录全部内容，希望文章能够帮你解决Go语言圣经：基础数据类型、复合数据类型、函数、方法章节摘录所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。