1. GO 语言变量
1.1 变量类型
- 整型 包含的 go 的变量类型有：int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64,fmt 输出为 %d。
- 浮点型 包含的 go 的变量类型有：float32 float64,fmt 输出为 %f %e %g。
- 复数型 包含的 go 的变量类型有：complex128 complex64,fmt 输出为 %v。
- 布尔型 包含的 go 的变量类型有：bool,fmt 输出为 %t。
- 指针型 包含的 go 的变量类型有：uintptr,fmt 输出为 %p。
- 引用型 包含的 go 的变量类型有：map slice channel,fmt 输出为 %v。
- 字节型 包含的 go 的变量类型有：byte,fmt 输出为 %c。
- 任意字符型 包含的 go 的变量类型有：rune,fmt 输出为 %c。
- 字符串型 包含的 go 的变量类型有：string,fmt 输出为 %d。
- 错误型 包含的 go 的变量类型有：error,fmt 输出为 %v。
1.2 变量声明
第一种：如果声明后未显示初始化，数值型初始值为 0，字符型初始值为 空字符串，布尔型初始值为 false，引用类型、函数、指针、接口初始化为 nil。
package main
import "fmt"
func main() {
// 声明 a 是字符串型，但未赋值则为空
var a string
fmt.Printf("a = [%s]\n\r", a)
// 没有初始化就为零值
var b int
fmt.Printf("b = [%d]\n\r", b)
// bool 零值为 false
var c bool
fmt.Printf("c = [%t]\n\r", c)
}以上实例执行结果为：
a = []
b = [0]
c = [false]以下几种类型为 nil：
var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口第二种：根据值自行判定变量类型。
package main
import "fmt"
func main() {
//系统自动判定为 bool
var d = true
fmt.Printf("d = [%t]\n\r", d)
//系统自动判定为 int
var e = 3
fmt.Printf("e = [%d]\n\r", e)
//系统自动判定为 string
var f = "hello"
fmt.Printf("f = [%s]\n\r", f)
}以上实例执行结果为：
d = [true]
e = [3]
f = [hello]第三种，如果变量已经使用 var 声明过了，再使用 := 声明变量，就产生编译错误，例如：
var intVal int
intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明直接使用下面的语句即可：
intVal := 1 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句intVal := 1 相等于：
var intVal int //先声明
intVal =1 //再赋值可以将 var f string = "Runoob" 简写为 f := "Runoob"：
package main
import "fmt"
func main() {
f := "Runoob" // var f string = "Runoob"
fmt.Println(f)
}以上实例执行结果为：
Runoob1.3 多变量声明
//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断
vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误
// 这种因式分解关键字的写法一般用于声明全局变量
var (
vname1 v_type1
vname2 v_type2
)package main
var x, y int
var ( // 这种因式分解关键字的写法一般用于声明全局变量
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
func main(){
g, h := 123, "hello"
println(x, y, a, b, c, d, e, f, g, h)
}以上实例执行结果为：
0 0 0 false 1 2 123 hello 123 hello2. GO 语言常量
常量是一个简单值的标识符，在程序运行时，不会被修改的量。一般建议用大写来表示！
常量中的数据类型直可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
常量的定义格式：const identifier [type] = value
你可以胜率类型说明符 [type]，因为比那一其可以根据变量的值来推断其类型。
- 显式类型定义：
const b string = "abc" - 隐式类型定义：
const b = "abc"
多个相同的类型的声明可以简写为：const c_name1,c_name2 = value1,value2
以下实例演示了常量的应用：
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
const a, b, c = 1, false, "str"
area = LENGTH * WIDTH
fmt.Printf("面积为：%d\n\r", area)
println(a, b, c)
}以上实例运行结果为：
面积为：50
1 false strpackage main
import "fmt"
func main() {
const (
A = 0
B = 1
C = 2
D //2 跟上一行的值相同
E //2 跟上一行的值相同
F //2 跟上一行的值相同
)
fmt.Println(A, B, C, D, E, F)
}以上实例运行结果为：
0 1 2 2 2 2iota
iota，特殊常量，可以认为是一个可以被编译器修改的常量。
iota 在 const 关键字出现时将被重置为 0（const 内部的第一行之前），const 中每新增一行常量声明将使 iota 计数一次（iota 可理解为 const 语句块中的行索引）。
iota 可以被用作枚举值：
const (
a = iota
b = iota
c = iota
)第一个 iota 等于0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0,b=1,c=2 可以简写为如下形式：
const (
a = iota
b
c
)iota 用法
import "fmt"
func main() {
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)
}以上实例运行结果为：
0 1 2 ha ha 100 100 7 8我们再做一个有趣的 iota 实验
package main
import (
"fmt"
)
func main() {
const (
i = 1 << iota //i=1：左移 0 位，不变仍为 1
j = 3 << iota //j=3：左移 1 位，变为二进制 110，即 6
x //x=3：左移 2 位，变为二进制 1100，即 12
y //y=3：左移 3 位，变为二进制11000.即 24
)
fmt.Println("i=", i)
fmt.Println("j=", j)
fmt.Println("x=", x)
fmt.Println("y=", y)
}*注：<<n==(2^n)**
3. GO 字面量
字面量即为没有出现变量名，直接出现的量。基础类型的字面量相当于是常量
fmt.Printf("%t\n", 04 == 4.00) //用到了整型字面量和浮点型字面量
fmt.Printf("%v\n", .4i) //虚数字面量 0.4i
fmt.Printf("%t\n", '\u4f17' == '众') //Unicode和rune字面量
fmt.Printf("Hello\nWorld\n!\n") //字符串字面量