Go进阶之路——变量 Go

变量
var 语句定义了一个变量的列表；跟函数的参数列表一样，类型在后面。
就像在这个例子中看到的一样，`var` 语句可以定义在包或函数级别。

package mainimport "fmt"var c, python, java boolfunc main() { var i int fmt.Println(i, c, python, java) }

输出结果：

文章图片

零值
变量在定义时没有明确的初始化时会赋值为零值。
零值是：

数值类型为 `0`，
布尔类型为 `false`，
字符串为 `""`（空字符串）。

package mainimport "fmt"func main() { var i int var f float64 var b bool var s string fmt.Printf("%v %v %v %q\n", i, f, b, s) }

输出结果：

文章图片

%v the value in a default format（对应值的默认格式） when printing structs, the plus flag (%+v) adds field names（打印结构体时，用%+v的方式会添加字段名）

初始化变量
变量定义可以包含初始值，每个变量对应一个。
如果初始化是使用表达式，则可以省略类型；变量从初始值中获得类型。

package mainimport "fmt"var i, j int = 1, 2func main() { var c, python, java = true, false, "no!" fmt.Println(i, j, c, python, java) }

短声明变量
在函数中，`:=` 简洁赋值语句在明确类型的地方，可以用于替代 var 定义。
函数外的每个语句都必须以关键字开始（`var`、`func`、等等），`:=` 结构不能使用在函数外。

package mainimport "fmt"func main() { var i, j int = 1, 2 k := 3 c, python, java := true, false, "no!" fmt.Println(i, j, k, c, python, java) }

基本类型
Go 的基本类型有：

boolstringuint8无符号8位整数 (0 to 255) uint16无符号16位整数 (0 to 65535) uint32无符号32位整数 (0 to 4294967295) uint64无符号64位整数 (0 to 18446744073709551615)int8有符号8位整数 (-128 to 127) int16有符号16位整数 (-32768 to 32767) int32有符号32位整数 (-2147483648 to 2147483647) int64有符号64位整数 (-9223372036854775808 to 9223372036854775807)//预先声明的数字类型，长度由操作系统的位数决定 uint32位或64位 int同uint uintptr一个无符号整数，其大小足以存储指针值的范围，32位下为4字节，64位下为8字节byteuint8 的别名，用于表示二进制数据的 bytesruneint32 的别名，代表一个Unicode码float32所有IEEE-754 32位浮点数的集合。math.MaxFloat32表示float32能表示的最大数值，大约是 3.4e38。最小值近似为1.4e-45。 float64所有IEEE-754 64位浮点数的集合。math.MaxFloat64常量大约是 1.8e308。最小值近似为4.9e-324。complex64包含float32实部和虚部的复数 complex128包含float64实部和虚部的复数

为避免可移植性问题，所有数字类型都是特定的类型，除了byte是unit8的别名，rune是int32的别名外，每个类型都是不同的。因此，在表达式或赋值中混合使用不同的数字类型时，需要进行显示转换。例如，即使int32和int在特定体系结构上可能具有相同的大小，也依然是不同的类型。
下面的例子演示了将不同类型的变量的定义，像导入语句一样，“打包”在一个语法块中。

package mainimport ( "fmt" "math/cmplx" )var ( ToBebool= false MaxInt uint64= 1<<64 - 1 zcomplex128 = cmplx.Sqrt(-5 + 12i) )func main() { const f = "%T(%v)\n" fmt.Printf(f, ToBe, ToBe) fmt.Printf(f, MaxInt, MaxInt) fmt.Printf(f, z, z) }

输出结果：

文章图片

cmplx包提供了复数的常用常数和常用函数。

%T a Go-syntax representation of the type of the value（对应值的Go语法表示形式的值类型）

类型转换
表达式 T(v) 将值 v 转换为类型 `T`。
一些关于数值的转换：

var i int = 42 var f float64 = float64(i) var u uint = uint(f)

或者，更加简单的形式：

i := 42 f := float64(i) u := uint(f)

与 C 不同的是 Go 在对不同类型之间的项赋值时，总是需要显式转换。

package mainimport ( "fmt" "math" )func main() { var x, y int = 3, 4 var f float64 = math.Sqrt(float64(x*x + y*y)) var z int = int(f) fmt.Println(x, y, z) }

上面例子中，如果不进行显示转换的话是会出现编译错误的。
类型推导在定义一个变量但不指定其类型时（使用没有类型的 var 或 := 语句），变量的类型由右值推导得出。
当右值定义了类型时，新变量的类型与其相同：

var i int j := i // j 也是一个 int

但是当右边包含了未指名类型的数字常量时，新的变量就可能是 int 、 float64 或 `complex128`。这取决于常量的精度：

i := 42// int f := 3.142// float64 g := 0.867 + 0.5i // complex128

我发现Go的类型推导也不是万能的，例如，上文说到Go的int类型的大小在64位操作系统中的范围是（-9223372036854775808 ， 9223372036854775807），看如下代码：

package mainimport "fmt"func main() { var v= 1<<64 -1 fmt.Printf("%T(%v)\n", v,v) }

运行后：

文章图片

溢出了，类型推导认为 18446744073709551615 是一个int的类型，但是编译时又发现这个数超出了int类型的范围。然而，我却可以说这个数是一个uint64类型的数，因为咱刚才才用过（基本类型内容中）。
常量常量的定义与变量类似，只不过使用 const 关键字。
常量可以是字符、字符串、布尔或数字类型的值。
常量不能使用 := 语法定义。

package mainimport "fmt"const Pi = 3.14func main() { const World = "世界" fmt.Println("Hello", World) fmt.Println("Happy", Pi, "Day") const Truth = true fmt.Println("Go rules?", Truth) }

输出结果：

文章图片

数值常量数值常量是高精度的 _值_。
一个未指定类型的常量由上下文来决定其类型。

package mainimport "fmt"const ( Big= 1 << 100 Small = Big >> 99 )func needInt(x int) int { return x*10 + 1 } func needFloat(x float64) float64 { return x * 0.1 }func main() { //fmt.Println(Big) fmt.Println(needInt(Small)) //fmt.Println(needInt(Big)) fmt.Println(needFloat(Small)) fmt.Println(needFloat(Big)) fmt.Println(float64(Big)) }

输出结果：