07《Go语言入门》测试用例、变量和常量

从这篇文章开始，为了方便测试代码，我将基本上所有示例代码都写成了测试用例，因此需要先学下测试用例怎么编写，这真的很重要，这是任何工程的开始必做的步骤。
然后讲解了单个或多个变量和常量的定义，常量的讲解包括枚举、常量表达式、iota常量、比特位常量等。

重要知识点：

• 全局变量声明后不使用，程序能够编译成功；而局部变量不可以，声明后必须得使用。
• 变量短声明方式只能在函数内使用，函数外使用会报错 unexpected
• 常量不管全局还是局部，声明后可以不使用。

⚡️这是我纯手写的《Go语言入门》，源码+文章，手把手教你入门Go。看了你就会！
⚡️文章中所有的代码我都放到了 github.com/GanZhiXiong/go_learning 这个仓库中！
⚡️看文章时，对照仓库中代码学习效果更佳哦！

测试用例

在开始讲解变量和常量之前，先简单讲下Go测试程序如何编写。
在Go中对测试程序作了如下规定：

• Go文件名以_test结尾，如：my_test.go
• 测试方法名以Test开头，如：func TestMy(t *testing.T)

例如下图所示

命令行中运行请使用go test -v xxx_test.go，不能使用go run xxx_test.go，这个问题在03《Go语言入门》GoPath 和 GoRoot简介也有讲过。

如果闲func TestMy(t *testing.T)输入麻烦，使用GoLand的话，直接输入tes后，按tab即可自动输入。

后面我也会专门写一篇测试用例的文章。

变量

注意：全局变量声明后不使用，程序能够编译成功；而局部变量不可以，声明后必须得使用。

定义单个变量

• 使用var

  var v int
  var a int = 1

• 不使用var和变量类型
  但是这种短声明方式只能在函数内使用，函数外使用会报错 unexpected

  b := 2

定义多个变量

var (
	c int = 3
	d int = 4
)

var (
	c1 int
	d1 string
)

var e, f = 5, "f"

定义变量的时候如果在声明的时候初始化，推荐省略变量类型，因为编译器会根据初始化值自动推导类型。

示例

斐波拉契数列

为了熟悉变量的定义，我编写了用Go语言实现斐波拉契数列的代码。

07_var_test.go

func TestFibList(t *testing.T) {
	var a = 1
	var b = 1
	t.Log(a)
	for i := 0; i < 5; i++ {
		t.Log(b)
		tmp := a
		a = b
		b = tmp + a
	}
}

交换两个变量的值

在Go中交换两个变量可以不需要中间变量，通过a, b = b, a即可实现。

07_var_test.go

func TestExchange(t *testing.T) {
	a := 1
	b := 2
	t.Log(a, b)

	tmp := a
	a = b
	b = tmp
	t.Log(a, b)

	a, b = b, a
	t.Log(a, b)
}

常量

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：

const identifier [type] = value

你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

• 显式类型定义： const b string = “abc”
• 隐式类型定义： const b = “abc”

多个相同类型的声明可以简写为：

const c_name1, c_name2 = value1, value2

注意：常量不管全局还是局部，声明后可以不使用。

枚举

常量还可以用作枚举：

const (
    Unknown = 0
    Female = 1
    Male = 2
)

常量表达式

常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：

const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

iota常量

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值：

const (
    a = iota
    b = iota
    c = iota
)
// 或简写为
const (
    a = iota
    b
    c
)

比特位常量

使用iota可以给连续的比特位常量赋值，如：

const (
	Readable   = 1 << iota // 0001 可读
	Writable               // 0010 可写
	Executable             // 0100 可执行
)

07_constant_test.go

func TestConstant1(t *testing.T) {
	t.Log(Readable, Writable, Executable)
	//a := 7 // 7%2=1 3%2=1 1%2=1 111
	a := 1 // 1%2=1 1
	t.Log(a&Readable == Readable, a&Writable == Writable, a&Executable == Executable)
}

考察

如果下面这道题的结果你算对了，那你就理解了iota在枚举中的使用。

07_constant_test.go

func TestConstant3(t *testing.T) {
	const (
		a = iota //0
		b        //1
		c        //2
		d = "ha" //独立值，iota += 1
		e        //"ha"   iota += 1
		f = 100  //iota +=1
		g        //100  iota +=1
		h = iota //7,恢复计数
		i        //8
	)
	fmt.Println(a, b, c, d, e, f, g, h, i)
}