Go细节101

索引:

一个包可以在一个源文件里被引入多次。

一个Go源文件可以多次引入同一个包。但是每次的引入名称必须不同。这些相同的包引入引用着同一个包实例。

示例:
package main

import "fmt"
import "io"
import inout "io"

func main() {
	fmt.Println(&inout.EOF == &io.EOF) // true
}

package mypkg之后的注释// import "x.y.z/mypkg"对标准Go编译器是有意义的。

例如,当标准编译器编译导入此包的源文件时,以下包的导入路径必须是 "x.y.z/mypkg"
package mypkg // import "x.y.z/mypkg"
...

但是,从Go SDK 1.11开始,此约束对于支持模块(modules)的Go项目不起作用。

switchselect流程控制代码块中,default分支可以放在所有的case分支之前或者所有的case分支之后,也可以放在case分支之间。

示例:
	switch n := rand.Intn(3); n {
	case 0: fmt.Println("n == 0")
	case 1: fmt.Println("n == 1")
	default: fmt.Println("n == 2")
	}

	switch n := rand.Intn(3); n {
	default: fmt.Println("n == 2")
	case 0: fmt.Println("n == 0")
	case 1: fmt.Println("n == 1")
	}

	switch n := rand.Intn(3); n {
	case 0: fmt.Println("n == 0")
	default: fmt.Println("n == 2")
	case 1: fmt.Println("n == 1")
	}

	var x, y chan int

	select {
	case <-x:
	case y <- 1:
	default:
	}

	select {
	case <-x:
	default:
	case y <- 1:
	}

	select {
	default:
	case <-x:
	case y <- 1:
	}

switch流程控制代码块中的数字常量case表达式不能重复,但是布尔常量case表达式可以重复。

例如,下面的代码在编译时会失败。
package main

func main() {
	switch 123 {
	case 123:
	case 123: // error: duplicate case
	}
}
但是下面的代码在编译时是没问题的。
package main

func main() {
	switch false {
	case false:
	case false:
	}
}

关于原因,请阅读这个issue。 此行为依赖于编译器。事实上,标准编译器同样不允许重复的字符串case表达式,但是gccgo编译器却允许。

switch流程控制代码块里的switch表达式总是被估值为类型确定值。

例如,在下列switch代码块中的switch表达式123被视为一个int值,而不是一个类型不确定的整数。
package main

func main() {
	switch 123 {
	case int64(123):  // error: 类型不匹配
	case uint32(789): // error: 类型不匹配
	}
}

switch流程控制代码块中的switch表达式的缺省默认值为类型确定值true(其类型为预定义类型bool)。

例如,下列程序会打印出true
package main

import "fmt"

func main() {
	switch { // <=> switch true {
	case true:  fmt.Println("true")
	case false: fmt.Println("false")
	}
}

有时候,显式代码块的开括号{可以放在下一行。

例如:
package main

func main() {
	var i = 0
Outer:
	for
	{ // 在这里断行是没问题的
		switch
		{ // 在这里断行是没问题的
		case i == 5:
			break Outer
		default:
			i++
		}
	}
}

下面程序的结果会打印什么?true还是false? 答案是true。 关于原因请阅读Go中的代码断行规则一文。
package main

import "fmt"

func False() bool {
	return false
}

func main() {
	switch False()
	{
	case true:  fmt.Println("true")
	case false: fmt.Println("false")
	}
}

有些case分支代码块必须是显式的。

例如,下面的程序会在编译时将失败。
func demo(n, m int) (r int) {
	switch n {
	case 123:
		if m > 0 {
			goto End
		}
		r++

		End: // syntax error: 标签后缺少语句
	default:
		r = 1
	}
	return
}
为了编译通过,case分支代码块必须改成显式的:
func demo(n, m int) (r int) {
	switch n {
	case 123: {
		if m > 0 {
			goto End
		}
		r++

		End:
	}
	default:
		r = 1
	}
	return
}
另外,我们可以在标签End:之后加一个分号:
func demo(n, m int) (r int) {
	switch n {
	case 123:
		if m > 0 {
			goto End
		}
		r++

		End:;
	default:
		r = 1
	}
	return
}

关于原因,请阅读Go的代码断行规则一文。

嵌套的延迟函数调用可以修改外层函数的返回结果。

例如:
package main

import "fmt"

func F() (r int) {
	defer func() {
		r = 789
	}()

	return 123 // <=> r = 123; return
}

func main() {
	fmt.Println(F()) // 789
}

某些recover函数调用是空操作。

我们需要在正确的地方调用recover函数。 关于细节,请阅读 在正确的位置调用内置函数recover一文。

我们可以使用os.Exit函数调用退出一个程序和使用runtime.Goexit函数调用退出一个协程。

我们可以通过调用os.Exit函数从任何函数里退出一个程序。 os.Exit函数调用接受一个int代码值做为参数并将此代码返回给操作系统。

示例:
// exit-example.go
package main

import "os"
import "time"

func main() {
	go func() {
		time.Sleep(time.Second)
		os.Exit(1)
	}()
	select{}
}
运行:
$ go run a.go
exit status 1
$ echo $?
1

我们可以通过调用runtime.Goexit函数退出一个goroutine。 runtime.Goexit函数没有参数。

在下面的示例中,文字Java将不会被打印出来。
package main

import "fmt"
import "runtime"

func main() {
	c := make(chan int)
	go func() {
		defer func() {c <- 1}()
		defer fmt.Println("Go")
		func() {
			defer fmt.Println("C")
			runtime.Goexit()
		}()
		fmt.Println("Java")
	}()
	<-c
}

递增运算符++和递减运算符--的优先级低于解引用运算符*和取地址运算符&,解引用运算符和取地址运算符的优先级低于选择器.中的属性选择操作符。

例如:
package main

import "fmt"

type T struct {
	x int
	y *int
}

func main() {
	var t T
	p := &t.x // <=> p := &(t.x)
	fmt.Printf("%T\n", p) // *int

	*p++ // <=> (*p)++
	*p-- // <=> (*p)--

	t.y = p
	a := *t.y // <=> *(t.y)
	fmt.Printf("%T\n", a) // int
}

移位运算中的左类型不确定操作数的类型推断规则取决于右操作数是否是常量。

package main

func main() {
}

const M  = 2
var _ = 1.0 << M // 编译没问题。1.0将被推断为一个int值。

var N = 2
var _ = 1.0 << N // 编译失败。1.0将被推断为一个float64值。

关于原因请阅读运算操作符一文。

如果两个指针的类型具有不同的底层类型但是它们的基类型却共享相同的底层类型,则这两个指针值可以间接相互转换为对方的类型。

例如:
package main

type MyInt int64
type Ta    *int64
type Tb    *MyInt

func main() {
	var a Ta
	var b Tb

	//a = Ta(b) // error: 直接转换是不允许的。

	// 但是间接转换是允许的。
	y := (*MyInt)(b)
	x := (*int64)(y)
	a = x           // 等价于下一行
	a = (*int64)(y) // 等价于下一行
	a = (*int64)((*MyInt)(b))
	_ = a
}

两个零尺寸值的地址可能相等,也可能不相等。

两个零尺寸值的地址是否相等时依赖于具体编译器实现以及具体编译器版本。
package main

import "fmt"

func main() {
	a := struct{}{}
	b := struct{}{}
	x := struct{}{}
	y := struct{}{}
	m := [10]struct{}{}
	n := [10]struct{}{}
	o := [10]struct{}{}
	p := [10]struct{}{}

	fmt.Println(&x, &y, &o, &p)

	// 对于标准编译器1.12,x、y、o和p将逃逸到堆上,
	// 但是a、b、m和n则开辟在栈上。

	fmt.Println(&a == &b) // false
	fmt.Println(&x == &y) // true
	fmt.Println(&a == &x) // false

	fmt.Println(&m == &n) // false
	fmt.Println(&o == &p) // true
	fmt.Println(&n == &p) // false
}

上面代码中所示的输出是针对标准编译器1.12的。

一个指针类型的基类型可以为此指针类型自身。

例如:
package main

func main() {
	type P *P
	var p P
	p = &p
	p = **************p
}

类似的,
  • 一个切片类型的元素类型可以是此切片类型自身,
  • 一个映射类型的元素类型可以是此映射类型自身,
  • 一个数据通道类型的元素类型可以是此数据通道类型自身,
  • 一个函数类型的输入参数和返回结果值类型可以是此函数类型自身。
package main

func main() {
	type S []S
	type M map[string]M
	type C chan C
	type F func(F) F

	s := S{0:nil}
	s[0] = s
	m := M{"Go": nil}
	m["Go"] = m
	c := make(C, 3)
	c <- c; c <- c; c <- c
	var f F
	f = func(F)F {return f}

	_ = s[0][0][0][0][0][0][0][0]
	_ = m["Go"]["Go"]["Go"]["Go"]
	<-<-<-c
	f(f(f(f(f))))
}

有关选择器缩写形式的细节。

无论一个指针值的类型是定义的还是非定义的,如果它的(指针)类型的基类型为一个结构体类型,则我们可以使用此指针值来选择它所引用着的结构体中的字段。 但是,如果此指针的类型为一个定义的类型,则我们不能使用此指针值来选择它所引用着的结构体中的方法。

我们总是不能使用二级以上指针来选择结构体字段和方法。

package main

type T struct {
	x int
}
func (T) m(){} // T有一个方法m。

type P *T  // P为一个定义的一级指针。
type PP *P // PP为一个定义的二级指针。

func main() {
	var t T
	var tp = &t
	var tpp = &tp
	var p P = tp
	var pp PP = &p
	tp.x = 12  // 没问题
	p.x = 34   // 没问题
	pp.x = 56  // error: 类型PP没有名为x的字段或者方法。
	tpp.x = 78 // error: 类型**T没有名为x的字段或者方法。

	tp.m()  // 没问题,因为类型*T也有一个m方法。
	p.m()   // error: 类型P没有名为m的字段或者方法。
	pp.m()  // error: 类型PP没有名为m的字段或者方法。
	tpp.m() // error: 类型**T没有名为m的字段或者方法。
}

有时候,嵌套组合字面值可以被简化。

关于细节,请阅读内嵌组合字面形式可以被简化这一章节。

在某些情形下,我们可以将数组指针当作数组来用。

关于细节,请阅读把数组指针当做数组来使用这一章节。

从nil映射中读取元素不会导致崩溃,读取结果是一个零元素值。

例如,函数Foo1Foo2是等价的,但是函数Foo2比函数Foo1简洁得多。
func Foo1(m map[string]int) int {
	if m != nil {
		return m["foo"]
	}
	return 0
}

func Foo2(m map[string]int) int {
	return m["foo"]
}

从一个nil映射中删除一个条目不会导致崩溃,这是一个空操作。

例如,下面这个程序不会因为恐慌而崩溃。
package main

func main() {
	var m map[string]int // nil
	delete(m, "foo")
}

append函数调用的结果可能会与原始切片共享一些元素,也可能不共享任何元素。

关于细节,请阅读添加和删除容器元素这一章节。

从一个基础切片派生出的子切片的长度可能大于基础切片的长度。

例如:
package main

import "fmt"

func main() {
	s := make([]int, 3, 9)
	fmt.Println(len(s)) // 3
	s2 := s[2:7]
	fmt.Println(len(s2)) // 5
}

关于细节,请阅读从数组或者切片派生切片这一章节。

从一个nil切片中派生子切片是允许的,只要子切片表达式中使用的所有索引都为零,则不会有恐慌产生,结果子切片同样是一个nil切片。

例如,下面的程序在运行时刻不会产生恐慌。
package main

import "fmt"

func main() {
	var x []int // nil
	a := x[:]
	b := x[0:0]
	c := x[:0:0]
	// 下一行将打印出三个true。
	fmt.Println(a == nil, b == nil, c == nil)
}

关于细节,请阅读从数组或者切片派生切片这一章节。

range遍历nil映射或者nil切片是没问题的,这属于空操作。

例如,下面的程序可以编译是没问题的。
package main

func main() {
	var s []int // nil
	for range s {
	}

	var m map[string]int // nil
	for range m {
	}
}

range遍历nil数组指针时,如果忽略或省略第二个迭代变量,则此遍历是没问题的。遍历中的循环步数为相应数组类型的长度。

例如,下面的程序会输出01234
package main

import "fmt"

func main() {
	var a *[5]int // nil
	for i, _ := range a {
		fmt.Print(i)
	}
}

切片的长度和容量可以被单独修改。

我们可以通过反射途径单独修改一个切片的长度或者容量。 关于细节,请阅读单独修改一个切片的长度或者容量这一章节。

切片和数组组合字面值中的索引必须是非负常量。

例如,下面的程序将编译失败。
var k = 1
var x = [2]int{k: 1} // error: 索引必须为一个常量
var y = []int{k: 1}  // error: 索引必须为一个常量

注意,映射组合字面值中的键值不必为常量。

切片/数组/映射组合字面值的常量索引和键值不能重复。

例如,下面的程序将编译失败。
// error: 重复的索引:1
var a = []bool{0: false, 1: true, 1: true}
// error: 重复的索引:0
var b = [...]string{0: "foo", 1: "bar", 0: "foo"}
// error: 重复的键值:"foo"
var c = map[string]int{"foo": 1, "foo": 2}

这个特性可以用于在编译时刻断言某些条件

不可寻址的数组的元素依旧是不可寻址的,但是不可寻址的切片的元素总是可寻址的。

原因是一个数组值的元素和此数组存储在同一个内存块中。 但是切片的情况大不相同

一个例子:
package main

func main() {
	// 组合字面值是不可寻址的。

	/* 取容器元素的地址。 */

	// 取不可寻址的切片的元素的地址是没问题的
	_ = &[]int{1}[0]
	// error: 不能取不可寻址的数组的元素的地址
	_ = &[5]int{}[0]

	/* 修改元素值。 */

	// 修改不可寻址的切片的元素是没问题的
	[]int{1,2,3}[1] = 9
	// error: 不能修改不可寻址的数组的元素
	[3]int{1,2,3}[1] = 9
}

可以从不可寻址的切片派生子切片,但是不能从不可寻址的数组派生子切片。

原因和上一个细节是一样的。

例如:
package main

func main() {
	// 映射元素是不可寻址的。

	// 下面几行编译没问题。
	_ = []int{6, 7, 8, 9}[1:3]
	var ms = map[string][]int{"abc": {0, 1, 2, 3}}
	_ = ms["abc"][1:3]

	// 下面几行将编译失败,因为不可从不可寻址的数组派生切片。
	/*
	_ = [...]int{6, 7, 8, 9}[1:3] // error
	var ma = map[string][4]int{"abc": {0, 1, 2, 3}}
	_ = ma["abc"][1:3]  // error
	*/
}

把以NaN做为键值的条目放如映射就宛如把条目放入黑洞一样。

原因是下面的另一个细节中提到的NaN != NaN。 但是,在Go1.12之前,以NaN作为键值的元素只能在for-range循环中被找到; 从Go1.12开始,以NaN作为键值的元素也可以通过类似fmt.Print的函数打印出来。
package main

import "fmt"
import "math"

func main() {
	var a = math.NaN()
	fmt.Println(a) // NaN

	var m = map[float64]int{}
	m[a] = 123
	v, present := m[a]
	fmt.Println(v, present) // 0 false
	m[a] = 789
	v, present = m[a]
	fmt.Println(v, present) // 0 false

	fmt.Println(m) // map[NaN:789 NaN:123]
	delete(m, a)   // no-op
	fmt.Println(m) // map[NaN:789 NaN:123]

	for k, v := range m {
		fmt.Println(k, v)
	}
	// the above loop outputs:
	// NaN 123
	// NaN 789
}

注意:在Go1.12之前,两个fmt.Println(m)调用均打印出map[NaN:<nil> NaN:<nil>]

字符串转换为byte切片或rune切片后的结果切片的容量可能会大于长度。

我们不应该假设结果切片的长度和容量总是相等的。

在下面的例子中,如果最后一个fmt.Println行被删除,在其前面的两行会打印相同的值32,否则,一个打印32,一个打印8(对于标准编译器1.12来说)。
package main

import "fmt"

func main() {
	s := "a"
	x := []byte(s)              // len(s) == 1
	fmt.Println(cap([]byte(s))) // 32
	fmt.Println(cap(x))         // 8
	fmt.Println(x)
}

如果我们假设结果切片的长度和容量总是相等,就可能写出一些有bug的代码

对于切片s,循环for i = range s {...}并不等价于循环for i = 0; i < len(s); i++ {...}

对于这两个循环,迭代变量i的最终值可能是不同的。
package main

import "fmt"

var i int

func fa(s []int, n int) int {
	i = n
	for i = 0; i < len(s); i++ {}
	return i
}

func fb(s []int, n int) int {
	i = n
	for i = range s {}
	return i
}

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	fmt.Println(fa(s, -1), fb(s, -1)) // 6 5
	s = nil
	fmt.Println(fa(s, -1), fb(s, -1)) // 0 -1
}

一个多返回值函数调用表达式不能和其它表达式混用在一个赋值语句的右侧或者另一个函数调用的实参列表中。

关于细节,请阅读有返回值的函数的调用是一种表达式这一章节。

某些函数调用是在在编译时刻被估值的。

关于细节,请阅读哪些函数调用将在编译时刻被估值?这一总结。

每一个方法都对应着一个隐式声明的函数。

关于细节,请阅读每个方法对应着一个隐式声明的函数这一章节。

如果两个接口值具有相同的动态类型并且此动态类型不支持比较,则比较这两个接口值将导致一个恐慌。

例如:
package main

func main() {
	var x interface{} = []int{}
	_ = x == x // panic
}

类型断言可以用于将一个接口值转换为另一个接口类型,即使此接口值的类型并未实现另一个接口类型。

例如:
package main

type Foo interface {
	foo()
}

type T int
func (T) foo() {}

func main() {
	var x interface{} = T(123)
	// 下面这两行将编译失败。
	/*
	var _ Foo = x   // error: interface{}类型没有实现Foo类型
	var _ = Foo(x)  // error: interface{}类型没有实现Foo类型
	*/
	// 但是下面这行可以编译通过。
	var _ = x.(Foo) // okay
}

一个失败的类型断言的可选的第二个结果是否被舍弃将影响此类型断言的行为。

如果第二个可选结果出现在失败的类型断言中,那么此类型断言不会导致恐慌。否则,恐慌将产生。 例如:
package main

func main() {
	var x interface{} = true
	_, _ = x.(int) // 断言失败,但不会导致恐慌。
	_ = x.(int)    // 断言失败,并导致一个恐慌。
}

以相同实参调用两次errors.New函数返回的两个error值是不相等的。

原因是errors.New函数会复制输入的字符串实参至一个局部变量并取此局部变量的指针作为返回error值的动态值。 两次调用会产生两个不同的指针。
package main

import "fmt"
import "errors"

func main() {
	notfound := "not found"
	a, b := errors.New(notfound), errors.New(notfound)
	fmt.Println(a == b) // false
}

单向接收数据通道无法被关闭。

例如,下面的代码会在编译时候失败。
package main

func main() {
}

func foo(c <-chan int) {
	close(c) // error: 不能关闭单向接收数据通道
}

发送一个值到一个已关闭的数据通道被视为一个非阻塞操作,该操作会导致恐慌。

例如,在下面的程序里,如果第二个case分支会被选中,则在运行时刻将产生一个恐慌。
package main

func main() {
	var c = make(chan bool)
	close(c)
	select {
	case <-c:
	case c <- true: // panic: 向已关闭的数据通道发送数据
	default:
	}
}

类型可以在声明函数体内。

类型可以声明在函数体内。例如,
package main

func main() {
	type T struct{}
	type S = []int
}

对于标准编译器,结构体中的某些零尺寸字段的尺寸有可能会被视为一个字节。

关于细节,请阅读这个FAQ条目

NaN != NaN,Inf == Inf。

此规则遵循IEEE-754标准,并与大多数其它语言是一致的。
package main

import "fmt"
import "math"

func main() {
	var a = math.Sqrt(-1.0)
	fmt.Println(a)      // NaN
	fmt.Println(a == a) // false

	var x = 0.0
	var y = 1.0 / x
	var z = 2.0 * y
	fmt.Println(y, z, y == z) // +Inf +Inf true
}

不同代码包中的两个非导出方法名和结构体字段名总是被视为不同的名称。

例如,在包foo中声明了如下的类型:
package foo

type I = interface {
	about() string
}

type S struct {
	a string
}

func (s S) about() string {
	return s.a
}
在包bar中声明了如下的类型:
package bar

type I = interface {
	about() string
}

type S struct {
	a string
}

func (s S) about() string {
	return s.a
}
那么,
  • 两个包中的两个类型S的值不能相互转换。
  • 两个包中的两个接口类型指定了两个不同的方法集。
  • 类型foo.S没有实现接口类型 bar.I
  • 类型bar.S没有实现接口类型foo.I
package main

import "包2/foo"
import "包2/bar"

func main() {
	var x foo.S
	var y bar.S
	var _ foo.I = x
	var _ bar.I = y

	// 下面这些行将编译失败。
	x = foo.S(y)
	y = bar.S(x)
	var _ foo.I = y
	var _ bar.I = x
}

在某些很少见的场景中,圆括号是必需的。

例如:
package main

type T struct{x, y int}

func main() {
	// 因为{}的烦扰,下面这三行均编译失败。
	/*
	if T{} == T{123, 789} {}
	if T{} == (T{123, 789}) {}
	if (T{}) == T{123, 789} {}
	var _ = func()(nil) // nil被认为是一个类型
	*/

	// 必须加上一对小括号()才能编译通过。
	if (T{} == T{123, 789}) {}
	if (T{}) == (T{123, 789}) {}
	var _ = (func())(nil) // nil被认为是一个值
}

栈溢出不会造成恐慌,它将使程序崩溃。

栈溢出在Go里是致命错误,不会造成恐慌。一旦栈溢出发生,程序将不可恢复地崩溃。
package main

func f() {
	f()
}

func main() {
	defer func() {
		recover() // 无法防止程序崩溃
	}()
	f()
}
运行结果:
runtime: goroutine stack exceeds 1000000000-byte limit
fatal error: stack overflow

runtime stack:
...

某些表达式的估值顺序取决于具体编译器实现。

关于细节,请阅读表达式估值顺序规则一文。

reflect.DeepEqual(x, y)x == y的结果可能会不同。

如果表达式xy的类型不相同,则函数调用DeepEqual(x, y)的结果总为false,但x == y的估值结果有可能为true

如果xy为(同类型的)两个引用着不同其它值的指针值,则x == y的估值结果总为false,但函数调用DeepEqual(x, y)的结果可能为true,因为函数reflect.DeepEqual将比较xy所引用的两个值。

第三个区别是当xy处于一个循环引用链中时,DeepEqual调用的结果可能未必正确。

第四个区别是一个DeepEqual(x, y)调用无论如何不应该产生一个恐慌,但是如果xy是两个动态类型相同的接口值并且它们的动态类型是不可比较类型的时候,x == y将产生一个恐慌。

一个展示了这些不同的例子:
package main

import "fmt"
import "reflect"

func main() {
	type Book struct {page int}
	x := struct {page int}{123}
	y := Book{123}
	fmt.Println(reflect.DeepEqual(x, y)) // false
	fmt.Println(x == y)                  // true

	z := Book{123}
	fmt.Println(reflect.DeepEqual(&z, &y)) // true
	fmt.Println(&z == &y)                  // false

	type T struct{p *T}
	t := &T{&T{nil}}
	t.p.p = t // form a cyclic reference chain.
	fmt.Println(reflect.DeepEqual(t, t.p)) // true
	fmt.Println(t == t.p)                  // false

	var f1, f2 func() = nil, func(){}
	fmt.Println(reflect.DeepEqual(f1, f1)) // true
	fmt.Println(reflect.DeepEqual(f2, f2)) // false

	var a, b interface{} = []int{1, 2}, []int{1, 2}
	fmt.Println(reflect.DeepEqual(a, b)) // true
	fmt.Println(a == b)                  // panic
}

注意:如果传递给一个DeepEqual调用的两个实参均为函数类型值,则此调用只有在这两个实参都为nil并且它们的类型相同的情况下才返回true

所以,当使用reflect.DeepEqual函数比较两个值时,我们必须清楚地知道这两个值的类型的结构。

reflect.Value.Bytes()方法返回一个[]byte值,它的元素类型byte可能并非属主参数代表的Go切片值的元素类型。

假设一个自定义类型MyByte的底层类型为内置类型byte,我们知道Go类型系统禁止切片类型[]MyByte的值转换为类型[]byte。 但是,当前的reflect.Value类型的Bytes方法的实现可以帮我们绕过这个限制。 此实现应该是违反了Go类型系统的规则。

例子:
package main

import "bytes"
import "fmt"
import "reflect"

type MyByte byte

func main() {
	var mybs = []MyByte{'a', 'b', 'c'}
	var bs []byte

	// bs = []byte(mybs) // this line fails to compile

	v := reflect.ValueOf(mybs)
	bs = v.Bytes() // okay. Violating Go type system.
	fmt.Println(bytes.HasPrefix(bs, []byte{'a', 'b'})) // true

	bs[1], bs[2] = 'r', 't'
	fmt.Printf("%s \n", mybs) // art
}

虽然这违反了Go类型系统的规则,但是貌似此违反并没有什么害处,相反,它带来了一些好处。 比如,我们可以将bytes标准库包中提供的函数(间接)应用到[]MyByte值上,如上例所示。

注意:reflect.Value.Bytes()方法以后可能会被移除

我们应该使用os.IsNotExist(err)而不是err == os.ErrNotExist来检查文件是否存在。

使用err == os.ErrNotExist可能漏掉一些错误。
package main

import (
	"fmt"
	"os"
)

func main() {
	_, err := os.Stat("a-nonexistent-file.abcxyz")
	fmt.Println(os.IsNotExist(err))    // true
	fmt.Println(err == os.ErrNotExist) // false
}

flag标准库包对待布尔命令选项不同于数值和字符串选项。

传递程序选项有三种形式。
  1. -flag:仅适用于布尔选项。
  2. -flag=x:用于任何类型的选项。.
  3. -flag x:仅用于非布尔选项。

请注意,使用第一种形式的布尔选项将被视为最后一个选项,其后面的所有项都被视为参数。

package main

import "fmt"
import "flag"

var b = flag.Bool("b", true, "一个布尔选项")
var i = flag.Int("i", 123, "一个整数选项")
var s = flag.String("s", "hi", "一个字符串选项")

func main() {
	flag.Parse()
	fmt.Print("b=", *b, ", i=", *i, ", s=", *s, "\n")
	fmt.Println("arguments:", flag.Args())
}

如果我们用下面显示的标志和参数运行下面的程序
./exampleProgram -b false -i 789 -s bye arg0 arg1
输出结果会是:
b=true, i=123, s=hi
arguments: [false -i 789 -s bye arg0 arg1]

这个输出显然不是我们所期望的。

我们应该像这样传递选项和参数:
./exampleProgram -b=false -i 789 -s bye arg0 arg1
或者
./exampleProgram -i 789 -s bye -b arg0 arg1
以获取我们期望的输出:
b=true, i=789, s=bye
arguments: [arg0 arg1]

[Sp|Fp|P]rintf函数支持位置参数。

下面的程序会打印3, 2, 1
package main

import "fmt"

func main() {
	fmt.Printf("%[3]v, %[2]v, %[1]v", 1, 2, 3) // 3, 2, 1
}

Go语言101项目目前同时托管在GithubGitlab上。 欢迎各位在这两个项目中通过提交bug和PR的方式来改进完善Go语言101中的各篇文章。

本书微信公众号名称为"Go 101"。每个工作日此公众号将尽量发表一篇和Go语言相关的原创短文。各位如果感兴趣,可以搜索关注一下。

赞赏