Go问答101

在编写Go代码时，我们不能随意断行。 请阅读代码断行规则一文以了解Go代码断行规则。 一般来说，根据这些规则，在左括号之前断行是不合法的。

if true
{
}

for i := 0; i < 10; i++
{
}

var _ = []int
{
	1, 2, 3
}

if true;
{
}

for i := 0; i < 10; i++;
{
}

var _ = []int;
{
	1, 2, 3;
}

if true {
}

for i := 0; i < 10; i++ {
}

var _ = []int {
	1, 2, 3,
}

对于标准编译器，在局部代码块中声明的每一个变量必须被至少一次用做r-value（right-hand-side value，右值）。

func f(x bool) {
	var y = 1 // y被声明了但没有被用做右值
	if x {
		y = 2 // 这里，y被用做左值
	}
}

一个可寻址的结构值的所有字段都可以被取地址。 如果非零尺寸的结构体值的最后一个字段的尺寸是零，那么取此最后一个字段的地址将会返回一个越出了为此结构体值分配的内存块的地址。 这个返回的地址可能指向另一个被分配的内存块。 在目前的官方Go标准运行时的实现中，如果一个内存块被至少一个依然活跃的指针引用，那么这个内存块将不会被视作垃圾因而肯定不会被回收。 所以只要有一个活跃的指针存储着此非零尺寸的结构体值的最后一个字段的越界地址，它将阻止垃圾收集器回收另一个内存块，从而可能导致内存泄漏。

为避免上述问题，标准的Go编译器会确保取一个非零尺寸的结构体值的最后一个字段的地址时，绝对不会返回越出分配给此结构体值的内存块的地址。 Go标准编译器通过在需要时在结构体最后的零尺寸字段之后填充一些字节来实现这一点。

如果一个结构体的全部字段的类型都是零尺寸的(因此整个结构体也是零尺寸的)，那么就不需要再填充字节，因为标准编译器会专门处理零尺寸的内存块。

package main

import (
	"unsafe"
	"fmt"
)

func main() {
	type T1 struct {
		a struct{}
		x int64
	}
	fmt.Println(unsafe.Sizeof(T1{})) // 8

	type T2 struct {
		x int64
		a struct{}
	}
	fmt.Println(unsafe.Sizeof(T2{})) // 16
}

对于大部分类型，答案是肯定的。不过事实上，这依赖于编译器。 例如，对于标准编译器，对于字符串或者浮点数类型的某些零值，此结论并不十分正确。

package main

import (
	"unsafe"
	"fmt"
)

func main() {
	// case 1:
	var s = "abc"[0:0]
	fmt.Println(s == "") // true
	var addr = *(*uintptr)(unsafe.Pointer(&s))
	fmt.Println(addr) // 

	// case 2:
	var x = 0.0
	var y = -x
	fmt.Println(y == 0) // true
	var n = *(*uintptr)(unsafe.Pointer(&y))
	fmt.Println(n) // 9223372036854775808
}

• 没有显式的方式来在用户代码中指定哪些函数应该被内联。
• 尽管编译参数-gcflags "-l"可以阻止任何函数被内联， 但是并没有一个正式的方式来避免某个特定的用户函数被内联。 目前我们可以在函数声明前增加一行//go:noinline 指令来避免这个函数被内联。 但是此方式不保证永久有效。

days := time.Date(year, month+1, 0, 0, 0, 0, 0, time.UTC).Day()

传递给time.Date函数的实参可以超出它们的正常范围，此函数将这些实参进行规范化。 例如，1月32日会被转换成2月1日。

package main

import (
	"time"
	"fmt"
)

func main() {
	// 2017-02-01 00:00:00 +0000 UTC
	fmt.Println(time.Date(2017, 1, 32, 0, 0, 0, 0, time.UTC))

	// 2017-01-31 23:59:59.999999999 +0000 UTC
	fmt.Println(time.Date(2017, 1, 32, 0, 0, 0, -1, time.UTC))

	// 2017-01-31 00:00:00 +0000 UTC
	fmt.Println(time.Date(2017, 2, 0, 0, 0, 0, 0, time.UTC))

	// 2016-12-31 00:00:00 +0000 UTC
	fmt.Println(time.Date(2016, 13, 0, 0, 0, 0, 0, time.UTC))

	// 2017-02-01 00:00:00 +0000 UTC
	fmt.Println(time.Date(2016, 13, 32, 0, 0, 0, 0, time.UTC))
}

1. Trim、TrimLeft、TrimRight、TrimSpace、TrimFunc、TrimLeftFunc和TrimRightFunc。 这些函数将修剪首尾所有满足指定（或隐含）条件的utf-8编码的Unicode码点(即rune)。（TrimSpace隐含了修剪各种空格符。） 这些函数将检查每个开头或结尾的rune值，直到遇到一个不满足条件的rune值为止。
2. TrimPrefix和TrimSuffix。 这两个函数会把指定前缀或后缀的子字符串（或子切片）作为一个整体进行修剪。

部分程序员会把TrimLeft和TrimRight函数当作TrimPrefix和TrimSuffix函数而误用。 自然地，函数返回的结果很可能不是预期的那样。

package main

import (
	"fmt"
	"strings"
)

func main() {
	var s = "abaay森z众xbbab"
	o := fmt.Println
	o(strings.TrimPrefix(s, "ab")) // aay森z众xbbab
	o(strings.TrimSuffix(s, "ab")) // abaay森z众xbb
	o(strings.TrimLeft(s, "ab"))   // y森z众xbbab
	o(strings.TrimRight(s, "ab"))  // abaay森z众x
	o(strings.Trim(s, "ab"))       // y森z众x
	o(strings.TrimFunc(s, func(r rune) bool {
		return r < 128 // trim all ascii chars
	})) // 森z众
}

1. 内置的print/println函数总是写入标准错误。 fmt标准包里的打印函数总是写入标准输出。 log标准包里的打印函数会默认写入标准错误，然而也可以通过log.SetOutput函数来配置。
2. 内置print/println函数的调用不能接受数组和结构体参数。
3. 对于组合类型的参数，内置的print/println函数将输出参数的底层值部的地址，而fmt和log标准库包中的打印函数将输出接口参数的动态值的字面形式。
4. 调用内置的print/println函数不会使调用参数引用的值逃逸到堆上，而fmt和log标准库包中的打印函数将使调用参数引用的值逃逸到堆上。
5. 如果一个实参有String() string或Error() string方法，那么fmt和log标准库包里的打印函数在打印参数时会调用这两个方法，而内置的print/println函数则会忽略参数的这些方法。
6. 内置的print/println函数不保证在未来的Go版本中继续存在。

• 映射（map）
• 切片
• 函数
• 包含不可比较字段的结构体类型
• 元素类型为不可比较类型的数组类型

不支持比较的类型不能用做映射类型的键值类型。

• 尽管映射，切片和函数值不支持比较，但是它们的值可以与类型不确定的nil标识符比较。
• 如果两个接口值的动态类型相同且不可比较，那么在运行时比较这两个接口的值会产生一个恐慌。

关于为什么映射，切片和函数不支持比较，请阅读Go的官方FAQ中关于这个问答。

一个接口值可以看作是一个包裹非接口值的盒子。被包裹在一个接口值中的非接口值的类型必须实现了此接口值的类型。 在Go中，很多种类型的类型的零值都是用nil来表示的。 一个什么都没包裹的接口值为一个零值接口值，即nil接口值。 一个包裹着其它非接口类型的nil值的接口值并非什么都没包裹，所以它不是（或者说它不等于）一个nil接口值。

当对一个nil接口值和一个nil非接口值进行比较时（假设它们可以比较），此nil非接口值将先被转换为nil接口值的类型，然后再进行比较； 此转换的结果为一个包裹了此nil非接口值的一个副本的接口值，此接口值不是（或者说它不等于）一个nil接口值，所以此比较不相等。

关于更详细的解释请阅读接口和关于Go中的nil两篇文章。

package main

import "fmt"

func main() {
	var pi *int = nil
	var pb *bool = nil
	var x interface{} = pi
	var y interface{} = pb
	var z interface{} = nil

	fmt.Println(x == y)   // false
	fmt.Println(x == nil) // false
	fmt.Println(y == nil) // false
	fmt.Println(x == z)   // false
	fmt.Println(y == z)   // false
}

在Go语言中，仅当两个切片类型共享相同的底层类型时，其中一个切片类型才可以转换成另一个切片的类型而不需要使用unsafe机制。

一个无名组合类型的底层类型是此组合类型本身。 所以即便两个不同的类型T1和T2共享相同的底层类型，类型[]T1和[]T2也依然是不同的类型，因此它们的底层类型也是不同的。这意味着其中一个的值不能转换为另一个。

• 把[]T1和[]T2的值相互转换的需求在实践中并不常见。
• 使得底层类型的溯源规则更加简单。

同样的原因也适用于其它组合类型。 例如：类型map[T]T1 和 map[T]T2同样不共享相同的底层类型，即便T1 和 T2共享相同的底层类型。

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	type MyInt int

	var a = []int{7, 8, 9}
	var b = *(*[]MyInt)(unsafe.Pointer(&a))
	b[0]= 123
	fmt.Println(a) // [123 8 9]
	fmt.Println(b) // [123 8 9]
	fmt.Printf("%T \n", a) // []int
	fmt.Printf("%T \n", b) // []main.MyInt
}

• 字符串的字节元素
• 映射元素
• 接口值的动态值（类型断言的结果）
• 常量（包括具名常量和字面量）
• 声明的包级别函数
• 方法（用做函数值）
• 中间结果值
  • 函数调用
  • 显式值转换
  • 各种操作，不包含指针解引用（dereference）操作，但是包含：
    • 通道接收操作
    • 子字符串操作
    • 子切片操作
    • 加法、减法、乘法、以及除法等等。

• 变量
• 可寻址的结构体的字段
• 可寻址的数组的元素
• 任意切片的元素（无论是可寻址切片或不可寻址切片）
• 指针解引用（dereference）操作

struct {
	elements unsafe.Pointer // 引用着一个元素序列
	length   int
	capacity int
}

每一个切片间接引用一个元素序列。 尽管一个非空切片是不可取地址的，它的内部元素序列需要开辟在内存中的某处因而必须是可取地址的。 取一个切片的元素地址事实上是取内部元素序列上的元素地址。 因此，不可寻址的非空切片的元素也是可以被取地址的。

• 一个T类型的值可以调用为*T类型的方法，但是仅当此T的值是可寻址的情况下。 编译器在调用指针属主方法前，会自动取此T值的地址。 因为不是任何T值都是可寻址的，所以并非任何T值都能够调用为类型*T的方法。 这种便利只是一个语法糖，而不是一种固有的规则。
• 一个*T类型的值可以调用为类型T的方法。 这是因为解引用指针总是合法的。 这种便利不仅仅是一个语法糖，它也是一种固有的规则。

所以很合理的， *T的方法集总是T方法集的超集，但反之不然。

func (t T) MethodX(v0 ParamType0, ...) (ResultType0, ...) {
	...
}

// 编译器将会为*T隐式声明一个如下的方法。
func (pt *T) MethodX(v0 ParamType0, ...) (ResultType0, ...) {
	return (*pt).MethodX(v0, ...)
}

1. 没有地址的值（所以它们不可以寻址）。
2. 有地址但是因为种种原因在语法上不可以寻址的值。
3. 可寻址但不允许在语法上被修改的值。

在Go语言中，直到现在（Go 1.23），没有值满足第三种定义。 但是零尺寸类型的变量值可以被视为事实上的（可被取地址的）不变量。

具名常量值满足第一种定义。

方法和包级函数可以被视为声明的不可变值。它们满足第二种定义。 字符串的字节元素和映射条目中的元素值同样满足第二种定义。

在Go中没有办法声明其它不可变值。

package main

import "fmt"

func main() {
	var s0 = "Go"

	var bs = []byte(s0)
	var s1 = string(bs)

	var rs = []rune(s0)
	var s2 = string(rs)

	fmt.Println(s0 == s1) // true
	fmt.Println(s0 == s2) // true
}

更多关于字符串的信息，请阅读Go中的字符串一文。