1.Go语言-变量，常量

1.go语言的变量

• 静态语言
• 声明后才能使用
• 同一个作用域不允许声明同一个变量2次

1.关键字

• 关键字是指编程语言中预先定义好的具有特殊含义的标识符。关键字和保留字都不建议用作变量名。Go语言中有25个关键字：

  break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var	
  

2.保留字

• 此外，Go语言中还有37个保留字

3.变量定义

• 函数外面语句必须以关键字开头

  var a = 10
  

• :=符号不能在函数外面使用

• _表示忽略掉某个值

1.标准变量

• 声明变量格式：var 变量名 变量类型

func main() {
	//标准声明格式
	var name string
	var age int
	var isOk bool
	fmt.Println(name, age, isOk)
	}
//  0 false

2.批量声明变量

• 每声明一个变量就需要写var关键字比较繁琐，go语言中还支持批量变量声明：

func main() {
	var (
		a string
		b int
		c bool
		d float32
	)
	fmt.Println(a, b, c, d)
	}

3.声明变量同时制定初始值

• 变量的初始化： var 变量名 类型 = 表达式
• 每个变量会被初始化成其类型默认值，例如：整型和浮点型变量的默认为0，字符串变量的默认值为空字符串。布尔型变量默认为false。切片，函数，指针变量默认为nil。

func main() {
	//声明变量同时制定初始值
	var myname string = "小刚"
	var myage int = 18
	fmt.Println(myname, myage)
	var myname2, myage2 = "小洪", 22
	fmt.Println(myname2, myage2)
	}

4.类型推导：根据变量定义初始值

• 有时我们会将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

func main(){
	//类型推导
	//根据变量定义初始值，推导出变量类型
	var name3 = "张三"
	var age3 = 22
	fmt.Println(name3, age3)
}

5.短变量（必须定义在函数内部）

• 可以使用:=方式声明并初始化变量。

func main() {
	m := 10
	fmt.Println(m)
}

6.匿名变量

• 再使用多重赋值时，如果要忽略某个值，可以使用匿名变量。匿名变量用_表示。

func main() {
	_,b = 1,2
	fmt.Println(b)
}

• 注意事项：
  • 函数外的每个语句都必须以关键字开始(var const,func等)
  • := 不能使用再函数外面。
  • _ 多用于占位，表示忽略值。

4.fmt格式“占位符”

• Go语言的fmt包实现了格式化I/O函数，类似于C的printf和scanf
• 普通占位符

%v			相应值
%T			相应类型
%%			字面上的百分号
%t			true或false
%b			二进制
%o			八进制
%X			十六进制大写
%f			浮点数，有小数点无指数
%s			输出字符串
%p			地址

2.常量

• 相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值。

1.常量声明

• 声明的pi和A这两个常量之后，再整个程序运行期间它们值都不能发生变化

package main
import "fmt"
//常量的声明
const pi = 3.1415
const A = 2.7
func main(){
    fmt.Println(pi,A)
}

2.批量创建常量

• 同时声明多个常量，如果省略了值则表示和上面一行的值相同。例如：

//批量创建常量
const (
    pi = 3,14
    A = 2.7
)

3.iota

• iota是go语言的常量计数器，在常量的表达式中使用。
• iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。

const (
    n1 = iota //0
    n2        //1
    n3        //2
    n4        //3
)

• 常见iota示例：
  • 使用_跳过某些值。

const (
n1 = iota //0
n2        //1
_
n4   	  //3
)

• iota声明中间插队：

const (
n1 = iota //0
n2 = iota //1
n3 = 100  //100
n4 = iota //3
)
const n5 = iota //0

• 多个iota定义在一行

const (
	a, b = iota + 1, iota + 2 //iota=0, 1,2
	c, d = iota + 1, iota + 2 //iota=1,  2,3
	e, f                      //iota=2 , 3,4
)

• 定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。）

const (
	_          = iota
	KB float64 = 1 << (10 * iota)
	MB
	GB
	TB
	PB
)

func main() {
	fmt.Println(KB, MB, GB, TB, PB)

}