标识符与关键字

标识符

标识符开发程序时定义的具有特定含义的词，如：变量名、常量名、函数名等...

组成由：字母、数字、下划线_组成，只能以字母和下划线_开头

例如：abc _123 a123

关键字

关键字时编程语言中保留定义好的具有特定含义的字符，关键字和保留字都不可用作变量名；

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

go的37个保留字

 		Constants:    true  false  iota  nil

        Types:    int  int8  int16  int32  int64  
                  uint  uint8  uint16  uint32  uint64  uintptr
                  float32  float64  complex128  complex64
                  bool  byte  rune  string  error

    	Functions:   make  len  cap  new  append  copy  close  delete
                	 complex  real  imag
               		 panic  recover

变量

变量是什么

程序中的数据，都以二进制方式，存储在内存的某个地址中，操作数据时，需要指明数据所在的内存地址，而内存地址的标识较为繁琐，因此给内存地址起个名字，就是变量名，变量名对应的就是内存地址；

变量类型

变量的作用，存储数据，数据又分多种不同的类型，常见又：整型、浮点型、布尔型、字符型、字符串型；

go中，每个变量都必须有一个类型，且变量必须先声明，再使用；

变量声明

go变量声明后，才可使用；
且，声明后必须使用；
同一个作用域内，不可重复使用；

标准声明

格式：

var 变量名 变量类型

示例：

var name string
var age int
var isOk bool

批量声明

go支持一个关键字var，声明多个变量，简化代码：

var (
	a string
	b int
	c boo
	d float32
)

变量的初始化

go在声明一个变量时，会自动对变量所在内存区进行初始化，每个变量的值会被初始化该类型的默认值：如：整型和浮点型默认值是：0；字符串变量默认值是：空字符串；布尔型变量值默认值是：false；切片、函数、指针默认为nil；

声明变量同时赋值；

格式：
var 变量名 类型 = 值表达式
   
示例：
var name string = "wang"
var age int = 18
   
批量初始化：
var name,age = "wang", 18

类型推导；

省略变量的类型时，编译器会根据=右边表达式推导变量的类型，完成初始化；
```
var name = "wang" 推导为string类型
var age  = 18 	  推导为int类型
```

短变量声明；

在函数内部，:=可以更简洁的初始化变量

package main
   
import (
 "fmt"
)
// 全局变量m，且使用了类型推导
var m = 100
   
func main () {
 n := 10
 m := 20 // 此处为局部变量m
 fmt.Println(m,n)
}

匿名变量；

多重赋值时，想忽略某值，可以用匿名变量anonymous variable，匿名变量用下划线_表示

匿名变量，不占用命令空间、不分配内存、匿名变量不存在重复声明

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main
   
import (
 "fmt"
)
func foo(){
 return 10,"wang"
}
   
func main(){
 x,_ := foo()
 _,y := foo()
 fmt.Println("x=",y)
 fmt.Println("y=",y)
}

注意事项

函数外，每个语句，需以关键字开头；var、const、func等；
:= 不能在函数外使用；
_ 多用于占位，表示想忽略的值；

常量

常量，即程序运行期间不会改变值的量，参数声明和变量一致，只需把var换为const，常量定义时必须赋值

demo1：

const pi = 3.14
const e = 2.7182

demo2:批量声明

const (
	pi = 3.14
	e = 2.7
)

demo3:批量声明时，忽略值的常量，则和上面一行相同

1
2
3
4
5


const (
	n1 = 100
	n2
	n3
)

demo:

 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


package main

import "fmt"

const (
	n = 100
	m = 200
)

const (
	i = 10
	j
)
// j和i 同值
func main() {
	fmt.Println(n)
	fmt.Println(m)
	fmt.Println(i)
	fmt.Println(j)

}
// go build 后输出
D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
100
200
10
10

iota

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

iota在const关键字出现时将被重置为0，const中每新增一行常量声明将使得iota计数加一，**iota可理解为const语句块中的行索引，**定义枚举时可用

1
2
3
4
5
6
7
8
9


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

// 根据规则，n2到n4没定义时默认和上一行保持相同，即都是iota，而iota每多一行常量定义，就+1，所以 n1 n2 n3 内
分别是 0 到 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


package main

import "fmt"

// iota demo

const (
	n1 = iota
	n2
	n3
	n4
)

func main() {
	fmt.Println(n1)
	fmt.Println(n2)
	fmt.Println(n3)
	fmt.Println(n4)
}

D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
0
1
2
3

iota示例

iota之间插入值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main
   
import "fmt"
const (
 n1 = iota // 0
 n2 = 100 // 100
 n3 = iota // 2
 n4 			// 3
)
   
func main() {
 fmt.Println(n1)
 fmt.Println(n2)
 fmt.Println(n3)
 fmt.Println(n4)
}
   
   
D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
0
100
2
3

使用_ 跳过某些不需要的值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


const (
 n1	=	iota
 _	
 n3	
 n4
)
   
func main() {
 fmt.Println(n1)
//	fmt.Println(n2)
 fmt.Println(n3)
 fmt.Println(n4)
}
   
   
D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
0
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


const (
 _  = iota
 kb = 1 << (10 * iota)
 mb = 1 << (10 * iota)
 gb = 1 << (10 * iota)
)
// 0 赋值给_
// kb 值表达式意思是：1的二进制表示，向左移动10位，即1变成了1后加10个0，即2的十次方，即1024，kb的大小
// mb 表达式意思：1 的二进制表示，向左移动 20位，即1变成了1后加20个0，即2的二十次放，即mb的大小
// gb 表达式意思：1 的二进制表示，向左移动 30位，即1变成了1后加30个0，即2的三十次方，即gb的大小
func main() {
 // fmt.Println(n1)
 // //	fmt.Println(n2)
 // fmt.Println(n3)
 // fmt.Println(n4)
 fmt.Println(kb)
 fmt.Println(mb)
 fmt.Println(gb)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
1024
1048576
1073741824

一行中，使用多个iota

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


const (
 a, b = iota + 1, iota + 2 // 同属于一行，2个表达式里的iota值一样，都是0
 c, d
 e, f
)
   
func main() {
 fmt.Println(a)
 fmt.Println(b)
 fmt.Println(c)
 fmt.Println(d)
 fmt.Println(e)
 fmt.Println(f)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
1
2
2
3
3
4

go基础语法之变量与常量

相关文章：