Go变量和常量详细讲解

Go变量和常量

标识符和关键字

1. 标识符

   标识符就是在编程中具有特殊意义的词，比如变量名，常量名，函数名等。Go语言中标识符由字母，数字和下划线组成，而且不能以数字开头。

2. 关键字

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

一：变量

Go语言中的变量必须先声明再使用。在Go中推荐使用小驼峰命名法，即第一个单词首字母小写，第二个单词首字母大写，如goodsName

注：

• 如果在函数内声明了一个变量但是没有使用，就无法进行编译，会报错。在函数外部声明时无影响，因为全局声明的变量可能会作为一个包变量被使用，所以不会报错
• 同一个作用域（一对{}）中不能重复声明同一个变量

1. 单个声明变量

var name string  
var age int
var isOk bool

2. 批量声明变量

var (
	name string
	age int
	isOk bool
)

​ 声明后的变量默认是一个空值

string ""
int 0
bool false

3. 为变量赋值

package main

var (
	name string
	age int
	isOk bool
)

func main()  {
	name = "kid"
	age = 25
	isOk = true
}

4. 声明变量同时赋值

var gender string = "男"

5. 类型推导，根据值判断该变量是什么类型

var hobby = "skate"

6. 简短变量声明，只能在函数内使用

job := "manong"

7. 匿名变量

​ 在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量。匿名变量用一个下划线 _ 表示。匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

​ 用处：如果一个函数的返回值有两个，而我们只需要使用一个变量，这时就用到了匿名变量。若没有匿名变量的话就会报错，这里匿名变量就起到了一个占位的用处。

9. 变量使用方法：

   ​ 在函数外，我们通常会使用批量声明对象的方式来声明变量；在函数内通常会使用简短变量声明的方式来声明变量，特定情况下使用var关键字声明变量

10. 参考代码

    package main
    
    import "fmt"
    
    //批量声明变量
    var (
    	name string  // ""
    	age int  // 0
    	isok bool  // false
    )
    
    func main()  {
    	name = "kid"
    	age = 25
    	isok = true
    	// Go中，变量定义后就必须使用，否则无法进行编译
    	fmt.Print(isok)  // 在终端中输出要打印的内容
    	fmt.Println()  // 打印空行
    	fmt.Println(age)  // 打印完指定的内容后会在后面添加一个换行符
    	fmt.Printf("name:%s",name)  // %s:占位符，使用name去替换这个占位符
    	fmt.Println()
    	// 声明变量同时赋值
    	var gender string = "男"
    	fmt.Println(gender)
    	// 类型推导（根据值判断该变量是什么类型）
    	var hobby = "skate"	
    	fmt.Println(hobby)
    	// 简短变量声明,只能在函数中使用
    	job := "manong"
    	fmt.Println(job) 
    }
    

    运行结果

二：常量

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

常量定义之后不能修改，在程序运行期间常量不会改变

1. 单个声明常量

const age = 20

2. 批量声明常量

const (
	country = "China"
	skin = "yellow"
)

批量声明常量时，如果某一行声明后没有赋值，默认就和上一行一致

package main

import "fmt"

const (
	x1 = 100
	x2
	x3
)

func main()  {
	fmt.Println(x1)  // --> 100
	fmt.Println(x2)	 // --> 100
	fmt.Println(x3)  // --> 100
} 

3. iota用法

iota是go语言中的常量计数器，只能在常量的表达式中使用

iota在const关键字出现时将被重置为0。const中每新增一行常量，iota就会计数一次。使用iota能简化定义，在定义枚举时很有用。

package main

import "fmt"

// iota,在一个const中出现时会被重置为0，每新增一行常量，iota就会加1
const (
	n1 = iota  // n1=0
	n2  // n2=1
	n3  // n3=2
)

func main()  {
	fmt.Println(n1)  // --> 0
	fmt.Println(n2)  // --> 1
	fmt.Println(n3)  // --> 2
}

多个常量声明在一行

只有每新增一行iota的值才会加1，当多个常量在一行时，iota的值不会改变

package main

import "fmt"

// 多个变量声明在一行
const (
	a1,a2 = iota+1, iota+2
	a3,a4 = iota+1, iota+2
)

func main()  {
	fmt.Println(a1)  // --> 1
	fmt.Println(a2)  // --> 2
	fmt.Println(a3)  // --> 2
	fmt.Println(a4)  // --> 3
}

利用iota定义数量级

讲解：

_ = iota 代表将0丢弃

KB = 1 << (10 * iota) 代表将1向前移动（10*iota）位，即向前移动10位，移动后为10000000000，转换为10进制数即为1024

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

KB = 1 << (10 * iota) 代表将1向前移动（10*iota）位，即向前移动10位，移动后为10000000000，转换为10进制数即为1024

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