Go进阶之路——基础了解三

变量

var 语句定义了一个变量的列表；跟函数的参数列表一样，类型在后面。

就像在这个例子中看到的一样，`var` 语句可以定义在包或函数级别。

package main

import "fmt"

var c, python, java bool

func main() {
	var i int
	fmt.Println(i, c, python, java)
}

输出结果：

零值

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

零值是：

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

package main

import "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 main

import "fmt"

var i, j int = 1, 2

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

短声明变量

在函数中，`:=` 简洁赋值语句在明确类型的地方，可以用于替代 var 定义。

函数外的每个语句都必须以关键字开始（`var`、`func`、等等），`:=` 结构不能使用在函数外。

package main

import "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 的基本类型有：

---

bool

string

uint8       无符号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)

//预先声明的数字类型，长度由操作系统的位数决定
uint        32位或64位
int         同uint
uintptr     一个无符号整数，其大小足以存储指针值的范围，32位下为4字节，64位下为8字节

byte        uint8 的别名，用于表示二进制数据的 bytes

rune        int32 的别名，代表一个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 main

import (
	"fmt"
	"math/cmplx"
)

var (
	ToBe   bool       = false
	MaxInt uint64     = 1<<64 - 1
	z      complex128 = 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 main

import (
	"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 main

import "fmt"

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

运行后：

溢出了，类型推导认为 18446744073709551615 是一个int的类型，但是编译时又发现这个数超出了int类型的范围。然而，我却可以说这个数是一个uint64类型的数，因为咱刚才才用过（基本类型内容中）。

常量

常量的定义与变量类似，只不过使用 const 关键字。

常量可以是字符、字符串、布尔或数字类型的值。

常量不能使用 := 语法定义。

package main

import "fmt"

const Pi = 3.14

func main() {
	const World = "世界"
	fmt.Println("Hello", World)
	fmt.Println("Happy", Pi, "Day")

	const Truth = true
	fmt.Println("Go rules?", Truth)
}

 输出结果：

数值常量

数值常量是高精度的 _值_。

一个未指定类型的常量由上下文来决定其类型。

package main

import "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))
}

 输出结果：

但是 ，数值常量也不能是随意大的值。

当移位运算 1<<512 时，会报错：

当这个数达到8.5e183左右，会出现内部编译器错误：

以上可能是我闲的。。。