02-Go语言基础变量和常量

标识符与关键字

标识符

在编程语言中标识符就是程序员定义的具有特殊意义的词，比如变量名，常量名，函数名等等。Go语言中标识符由字母数字和_组成，并且只能以字母和_开头。举几个例子：abc,_,_123。

关键字

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
1
2
3
4
5

变量

变量的类型

常见的数据类型有：整型，浮点型，布尔型。

变量的声明

go语言中变量必须先声明才能使用。而且声明后，必须使用。

标准声明

var 变量名 变量类型

批量声明

var (
		v3 int
		v4 float32
		v5 string
		v6 bool
	)
1
2
3
4
5
6

变量初始化

GO语言在声明变量的时候，会自动对变量进行初始化。每个变量会被初始化成其类型的默认值。例如：整型和浮点型初始值为0.字符串变量的默认值为空字符串。布尔型变量默认为false.切片，函数，指针变量的默认值为nil

声明并赋值

  var v7 int = 68
	var v8 string = "wanglei"
	var (
		v9  bool    = true
		v10 float32 = 3.32
	)
	fmt.Printf("v7:%d\nv8:%v\nv9:%v\nv10:%f", v7, v8, v9, v10)
1
2
3
4
5
6
7

类型推导

有时候将变量类型省略，编译器会根据等号右边值类型来推断变量类型

//类型推导
	var v11, v12 = "wl", 26
	fmt.Println(v11, v12)
1
2
3

短变量赋值

在函数内部可以使用更简洁的:=来声明赋值变量，但是仅仅限于函数内部。

package main

import (
	"fmt"
)
// 全局变量m
var m = 100

func main() {
	n := 10
	m := 200 // 此处声明局部变量m
	fmt.Println(m, n)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示.

//匿名变量
	v16, _ := 23, "string"
	fmt.Println(v16)
1
2
3

完整练习代码

package main

import "fmt"

var version string
var age11 = 18

// name12 := "小王子"  // 函数外语句必须以关键字开头

func main() {
	fmt.Println("Hello world!")

	/*
		多行注释
	*/
	// 变量的声明
	var name string // 声明变量

	// 批量声明
	var (
		age  int  // 0
		isOk bool // false
	)
	// var age int
	// var isOk bool

	age = 100 // 变量赋值
	fmt.Println(name, age, isOk)

	var age2 int = 18 // 声明变量并赋值
	fmt.Println(age2)

	// 没有指定类型？
	var name3, age3 = "jade", 28

	// var (
	// 	name3 string = "jade"
	// 	age3 int = 28
	// )

	fmt.Println(name3, age3)

	var age4 int8 = 28 // 如果不想用编译器推导的类型，就需要显式指定变量的类型
	fmt.Println(age4)

	// 双引号表示字符串，单引号表示字符

	var x byte = 'a'   // 字符
	var s string = "a" // 字符串
	fmt.Println(x, s)

	// 短变量声明
	s2 := "jade" // var s2 string s2="jade"
	fmt.Println(s2)
	s2 = "小王子"
	fmt.Println(s2)

	// var x2 string
	// x2 = 18 // 只能给变量赋正确类型的值
	// fmt.Println(x2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。常量在定义时必须赋值。

常量声明

package main

import "fmt"

func f2() {
	const c1 = 3.1415
	const c2 = 2.78
	//批量定义
	const (
		c3 = 100
		c4 //如果省略了，那么都和上面值一样
		c5
	)
	fmt.Println(c1, c2, c3, c4, c5)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Iota

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

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

使用_跳过某些值：

func f3() {
	//使用_跳过某些值
	const (
		c1 = iota //0
		c2        //1
		_
		c4 //3
	)
	fmt.Println(c4)
}
1
2
3
4
5
6
7
8
9
10

iota声明中间插队:

//iota插队
func f4() {
	const (
		c1 = iota //0
		c2 = 100  //100
		c3 = iota //2
		c4        //3
	)
	fmt.Println(c4)

}
1
2
3
4
5
6
7
8
9
10
11

定义数量级：

func f5() {
	const (
		_  = iota
		KB = 1 << (10 * iota) //<<向左偏移 eg:1<<10=2^10
		MB = 1 << (10 * iota)
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)
	fmt.Println(KB, MB, GB, TB, PB)
}
1
2
3
4
5
6
7
8
9
10
11

多个iota定义一行：

//多个iota定义在一起

func f6() {
	const (
		c1, c2 = iota + 1, iota + 2 //1,2
		c3, c4                      //2,3
		c5, c6                      //3,4
	)
	fmt.Println(c3, c4, c5, c6)
}
1
2
3
4
5
6
7
8
9
10

完整练习代码

// const.go

package main

const pi = 3.14

const (
	v = "v1.0"
	v2
	v3
	v4
)

const (
	week1 = 1
	week2 = 2
	week3 = 3
)

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

const (
	z1 = iota // 0
)

// 利用iota声明存储的单位常量
const (
	_  = iota             // 0
	KB = 1 << (10 * iota) // 1<<10 <=> 10000000000
	MB = 1 << (10 * iota) // 1<<20
	GB = 1 << (10 * iota) // 1<<30
	TB = 1 << (10 * iota)
	PB = 1 << (10 * iota)
)

// 声明中插队
const (
	c1 = iota // 0
	c2        // 1
	c3 = 100  // 插队
	c4 = iota // 3
)

const (
	d1, d2 = iota + 1, iota + 2 // 1,2
	d3, d4 = iota + 1, iota + 2 // 2,3
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53