（二）Golang的变量

发布时间：2020-07-29 02:43:52 来源：网络阅读：287 作者：运维路栏目：编程语言

为什么需要变量：

变量是程序的基本组成单位
不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位，比如：下面代码中sum、sub都是变量。

func getVal(num1 int, num2 int) (int, int) {
sum := num1 + mum2
sub := num1 - num2
return sum, sub
}
func main() {
sum, sub := getVal(30, 30)
fmt.Println("sum=", sum, "sub=", sub)
sum2, _ := getVal(10, 30)
fmt.Println("sum=", sum2)
}

变量的介绍：

变量的概念
变量相当于内存中一个数据存储空间的表示，可以把变量看做是一个房间的门牌号，通过门牌号可以找到房间，同样的道理，通过变量名可以访问到变量（值）。

变量的使用步骤
1）定义变量
2）给变量赋值
3）使用变量

package main
import "fmt"
func main() {
//定义变量
var i int
//给i赋值
i = 10
//使用变量
fmt.Println("i=",i) 
}
D:\goproject\src\go_code\chapter02\demon01>go run main.go
i= 10

变量使用注意事项：

变量表示内存中的一个存储区域；
该区域有自己的名称（变量名）和类型（数据类型）；

Golang变量使用的三种方式：
1）第一种，指定变量类型，定义后若不赋值，使用默认值；

package main
import "fmt"
func main() {
//golang的变量使用方式
//第一种：指定变量类型，定义后若不赋值，使用默认值
//init的默认值是0
var i int
fmt.Println("i=", i)
}
D:\goproject\src\go_code\chapter02\demon02>go run main.go
i= 0

2）第二种，根据值自行判断变量类型（类型引导）

package main
import "fmt"
func main() {   
//第二种：根据值自行判断变量类型（类型推导）
var num = 10.11
fmt.Println("num=", num)
}
D:\goproject\src\go_code\chapter02\demon02>go run main.go
num= 10.11

3）第三种，省略var定义变量并赋值

package main
import "fmt"
func main() {
//第三种：省略var,:= 的:不能省略，否则报错
//下面的方式等价于 var name string   name = "tom"
name := "tom"
fmt.Println("name=", name)
}
D:\goproject\src\go_code\chapter02\demon02>go run main.go
name= tom

多变量定义
1）在编程中，有时我们需要一次性定义多个变量，Golang也提供了这样的语法【在函数里面定义】

package main
import "fmt"
func main() {
//该案例演示Golang如何一次性定义多个变量
var a1, a2, a3 int
fmt.Println("a1=", a1, "a2=", a2, "a3=", a3)

//一次性定义多个变量的方式二
var b1, b2, b3 = 100, "tom", 888
fmt.Println("b1=", b1,"b2=", b2,"b3=", b3)

//一次性定义多个变量的方式三，同样可以使用类型推导
c1, name, c3 := 200, "mary", 999
fmt.Println("c1=", c1,"name=", name,"c3=", c3)
}
D:\goproject\src\go_code\chapter02\demon03>go run main.go
a1= 0 a2= 0 a3= 0
b1= 100 b2= tom b3= 888
c1= 200 name= mary c3= 999

2）一次性定义全局变量【在go中函数外部定义变量就是全局变量】

package main
import "fmt"
//定义全局变量
var n1 = 100
var n2 = 200
var name = "jack"
//上面的定义方式，也可以改成一次性定义
var (
n3 = 300
n4 = 400
name2 = "zhangsan"
)
func main() {
fmt.Println("n1=", n1,"n2=", n2,"name=", name)
fmt.Println("n3=", n3,"n4=", n4,"name2=", name2)
}
D:\goproject\src\go_code\chapter02\demon03>go run var.go
n1= 100 n2= 200 name= jack
n3= 300 n4= 400 name2= zhangsan

该区域的数据值可以在同一类型范围内不断变化

package main
import "fmt"
func main() {
//该区域的数据值可以在同一类型范围内不断变化
var i int = 10
i = 30
i = 50
fmt.Println("i=", i)
}
D:\goproject\src\go_code\chapter02\demon03>go run var02.go
i= 50

变量在同一个作用域（在一个函数或者代码块）内不能重名；
变量的三要素
变量=变量名+值+数据类型
Golang的变量如果没有赋初值，编译器会使用默认值，比如，int默认值为0；string默认值为空串；小数默认值为0。

程序中+号的使用
1）当左右两边都是数值型时，则做加法运算；
2）当左右两边都是字符串时，则做字符串拼接；

package main
import "fmt"
//演示golang中+号的使用
func main() {
var i = 1
var j = 2
var r = i + j //做加法运算
fmt.Println("r=", r)

var str1 = "hello"
var str2 = "world"
var res = str1 + str2 //做拼接操作
fmt.Println("res=", res)
}
D:\goproject\src\go_code\chapter02\demon04>go run main.go
r= 3
res= helloworld

数据类型的基本介绍：

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间。
（二）Golang的变量

整数类型：

基本介绍
简单的说，就是用于存放整数值的，比如0，-1,2345等等。
整型的类型

整数的使用细节
1）Golang各整数类型分：有符合和无符号，int uint的大小和系统有关；
2）Golang的整数默认声明为int型；

package main
import(
"fmt"
)
func main() {
var n1 = 100
//%T表示内容的数据类型
fmt.Printf("n1 的类型是 %T\n", n1)
}

D:\gocode\goproject02\main01>go run main.go
n1 的类型是 int

3）如何在程序查看某个变量的字节大小和数据类型

package main
import(
"fmt"
"unsafe" //前提引入unsafe函数
)
func main() {
var n1 = 100
//%T表示内容的数据类型
fmt.Printf("n1 的类型是 %T\n", n1)
//如何在程序查看某个变量的占用字节大小和数据类型
var n2 int64 = 10
//unsafe.Sizeof(n2) 是unsafe包的一个函数，可以返回n2变量占用的字节数
fmt.Printf("n2 的数据类型是 %T\nn2占用的字节大小是 %d", n2, unsafe.Sizeof(n2))
}

D:\gocode\goproject02\main01>go run main.go
n1 的类型是 int
n2 的数据类型是 int64
n2占用的字节大小是 8

4）Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。
5）bit：计算机中的最小存储单位；byte：计算机中基本存储单元；1byte=8bit

小数类型/浮点型：

基本介绍
小数类型就是用来存放小数的，比如：1.2 0.12-1.94

package main
import(
"fmt"
)
//演示golang中小数类型使用
func main() {
var price float32 = 87.23
fmt.Println("price", price)
}

D:\gocode\goproject02\main02>go run main.go
price 87.23

小数类型分类

对上图的说明：
1）浮点数=符号位+指数位+尾数位；说明浮点数都是有符号的。
2）尾数部分可能会丢失，造成精度损失，如：-123.0000901
//尾数部分可能会丢失，造成精度损失
```
var num3 float32 = -123.00000901
var num4 float64 = -123.00000901
fmt.Println("num3=", num3,"num4=", num4)
```
```
D:\goproject\src\go_code\chapter02\floatdemo06>go run main.go
num3= -123.00001 num4= -123.00000901
```
说明：float64 的精度比float32 的要准确。

浮点型使用细节
1）Golang浮点类型有固定的范围和字段长度，不受具体OS（操作系统）的影响；
2）Golang的浮点类型默认为float64类型；

//Golang的浮点类型默认声明为float64类型
var a = 1.1
fmt.Printf("a的数据类型为 %T \n", a)

D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
a的数据类型为 float64

3）浮点型常量有两种表示形式；
① 十进制数形式：如 5.12 .512（必须有小数点）

//十进制数形式
b := 5.12
c := .123
fmt.Println("b=", b, "c=", c)

D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
b= 5.12 c= 0.123

② 科学计数法形式：如 5.1234e2 ==== 5.12 * 10的2次方； 5.12E-2 ==== 5.12/10的2次方

//科学计数法形式
d := 5.1234e2 // 5.1234 * 10的2次方
e := 5.1234E2 // 5.1234 * 10的2次方
f := 5.1234E-2 // 5.1234 / 10的2次方
fmt.Println("d=", d, "e=", e, "f=",f)

D:\goproject\src\go_code\chapter02\floatdemo06>go run main03.go
d= 512.34 e= 512.34 f= 0.051234

4）Golang浮点型只有这两种类型，float32 和 float64，float64 比 float32 更精确。

字符类型：

基本介绍
Golang中没有专门的字符类型，如果要存储单个字符（字母），一般使用byte来保存；
字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的；也就是说对于传统的字符串是由字符组成的，而Go的字符串不同，它是由字节组成的。

案例演示

package main
import(
"fmt"
)
//演示golang中字符类型使用
func main() {
var c1 byte = 'a'
var c2 byte = '0' //字符的0
//当直接输出byte值，就是输出了对应字符的码值
fmt.Println("c1=", c1)
fmt.Println("c2=", c2)

//如果希望输出对应字符，需要格式化输出
fmt.Printf("c1=%c c2=%c\n", c1, c2)

//如果输出的码值高于byte（0-255）的范围，输出就会溢出,可以用int
var c3 int = '北'
fmt.Printf("c3=%c c3对应码值=%d", c3, c3)
}

D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
c1= 97
c2= 48
c1=a c2=0
c3=北 c3对应码值=21271

对上面代码说明：
1）如果保存的字符在ASCII表，比如【0-1，a-z，A-Z...】直接可以保存到byte；
2）如果保存的字符对应码值大于255，这时可以考虑使用int类型保存；比如中文；
3）如果需要按照字符的方式输出，这时需要格式化输出，即 fmt.Printf("%c", c1)。

字符类型使用细节
1）字符常量是用单引号（‘’）括起来的单个字符；如：var c1 byte = 'a' 里面的“a”
2）Go中允许使用转义字符“\”来将其后的字符转变为特殊字符型常量；如：var c2 char = '\n' ============='\n'表示换行符
3）Go语言的字符使用UTF-8编码，查询字符对应的utf8码值=====直接搜索”utf8 编码“；UTF-8 编码包含 ASCII 编码；
英文字母——1个字节；汉字——3个字节
4）在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8码值；
5）可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode字符；
```
//可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode字符；
var c4 int = 22269  //22269 -> '国'
fmt.Printf("c4=%c\n", c4)
```
```
D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
c4=国
```
6）字符类型是可以进行运算的，相当于一个整数，因为它都有对应的Unicode码；
```
//字符类型是可以进行运算的，相当于一个整数，运算时按照码值运行；
var n1 = 10 + 'a' // 相当于 10 + 97 = 107
fmt.Println("n1=", n1)
```
```
D:\goproject\src\go_code\chapter02\chardemon07>go run main.go
n1= 107
```
字符类型的本质探讨
1）字符型存储到计算机中，需要将字符对应的码值（整数）找出来；
存储：字符 ——> 对应码值 ——> 二进制 ——> 存储
读取：二进制 ——> 码值 ——> 字符 ——> 读取
2）字符和码值的对应关系是通过字符编码表决定的（规定好的）；
3）Go语言的编码统一使用UTF-8，非常的方便、统一，不会出现编码乱码的问题。
布尔类型：
基本介绍
1）布尔类型也叫bool类型，bool类型数据只允许取值true或者false；
2）bool类型占1个字节；
3）bool类型适于逻辑运算，一般用于程序流程控制【if条件控制语句和for循环控制语句】
4）不可以用0或非0的整数替代false和true。

案例演示

package main
import(
"fmt"
"unsafe"
) 
//演示golang中bool类型使用
func main() {
var b = false
fmt.Println("b=", b)
//注意事项
//1. bool类型占用存储空间为1个字节
fmt.Println("b 的占用字节 =", unsafe.Sizeof(b))
//2. bool类型只能取true或者false
}

D:\goproject\src\go_code\chapter02\booldemo08>go run main.go
b= false
b 的占用字节 = 1

字符串类型：

基本介绍
字符串就是一串固定长度的字符连接起来的字符序列；Go的字符串是由单个字节连接起来的；Go语言的字符串的字节使用UTF-8编码标识Unicode文本。

案例演示

//演示golang中string类型使用
func main() {
//string的基本使用
var address string = "北京长城 112 helloworld！"
fmt.Println(address)
}

D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
北京长城 112 helloworld！

string使用细节和注意事项
1）字符串一旦赋值，字符串就不能修改了：在Go中，字符串是不可变的；
2）字符串的两种表示形式
①双引号，会识别转义字符；

//使用双引号，支持转义字符
str1 := "abc\nbcd"
fmt.Println(str1)

D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
abc
bcd

②反引号，以字符串的原生形式输出，包括换行和特殊字符，可以输出源代码等效果。

//使用反引号，以字符串的原生形式输出，适用于输出源码
str2 := `
package main
import(
    "fmt"
)
`
fmt.Println(str2)

D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
    package main
    import(
            "fmt"
    )

3）字符串拼接方式

//字符串拼接方式
var str3 = "hello" + "world!"
fmt.Println(str3)

D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
helloworld!

4）当拼接字符串太长时，需要使用到多行字符串，可以如下处理【注意，将+号留在上一行】

//当拼接的字符串很长时，可以分行写，注意将+保留在上一行
var str4 = "hello" + "world!" + "world!" + "world!" + 
"hello" + "world!" + "world!" + "world!" + "hello" + 
"world!" + "world!" + "world!" + "hello" + "world!" + 
"world!" + "world!"
fmt.Println(str4)

D:\goproject\src\go_code\chapter02\stringdemo09>go run main.go
helloworld!world!world!helloworld!world!world!helloworld!world!world!helloworld!
world!world!

基本数据类型的默认值

基本介绍
在go中，数据类系都有一个默认值，当程序员没有赋值时，就会保留默认值；在go中，默认值又叫零值。
基本数据类型的默认值如下：

案例

package main
import(
"fmt"
)
//基本数据类型的默认值
func main() {
var a int  // =0
var b float32   // =0
var c float64   // =0
var d bool  // false
var name string  // ""
//这里的%v 表示按照变量的值输出
fmt.Printf("a=%d,b=%v,c=%v,d=%v,name=%v", a,b,c,d,name)
}

D:\goproject\src\go_code\chapter02\defaultdemo10>go run main.go
a=0,b=0,c=0,d=false,name=

基本数据类型的相互转换

基本介绍
Golang和 Java/c 不同，Go在不同类型的变量之间赋值时需要显示转换；也就是说Golang中数据类型不能自动转换。
基本语法
表达式 T(v) 将值 v 转换为类型 T。
T：就是数据类型，比如 int32，int64，float32 等等；
v：就是需要转换的变量。

案例演示

package main
import(
"fmt"
)
//演示golang中基本数据类型的转换
func main() {
var i int32 = 100
//将 i => float32
var n1 float32 = float32(i)
//低精度 => 高精度
var n2 int64 = int64(i)
fmt.Printf("i=%v n1=%v n2=%v", i,n1,n2)
}

D:\goproject\src\go_code\chapter02\transtype11>go run main.go
i=100 n1=100 n2=100

基本数据类型相互转换的注意事项
1）Go语言中，数据类型的转换可以是从表示范围小---->表示范围大，也可以范围大----->范围小；
2）被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化！

package main
import(
"fmt"
)
//演示golang中基本数据类型的转换
func main() {
var i int32 = 100
//将 i => float32
var n1 float32 = float32(i)
//低精度 => 高精度
var n2 int64 = int64(i)
fmt.Printf("i=%v n1=%v n2=%v\n", i,n1,n2)
//被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化！！！
fmt.Printf("i type is %T", i)
}

D:\goproject\src\go_code\chapter02\transtype11>go run main.go
i=100 n1=100 n2=100
i type is int32

3）在转换中，比如将 int64 转换成 int8（-128----127），编译时不会出错，只是转换的结果是按溢出处理，和我们希望的结果不一样，因此在转换时，需要考虑范围。

//在转换中，比如将 int64 转换成 int8（-128----127），编译时不会出错;
//只是转换的结果是按溢出处理，和我们希望的结果不一样;因此在转换时，需要考虑范围。
var num1 int64 = 999999
var num2 int8 = int8(num1)
fmt.Println("num2=", num2)

D:\goproject\src\go_code\chapter02\transtype11>go run main.go
num2= 63

课堂练习
1）以下代码编译不能通过和解决方案

package main
import(
"fmt"
)
func main() {
var n1 int32 = 12
var n2 int64
var n3 int8

//不能编译通过，因为没有进行数据类型转换
n2 = n1 + 20    //int32 ----> int64 错误
n3 = n1 + 20    //int32 ----> int8 错误

//以下是解决方案
n2 = int64(n1) + 20
n3 = int8(n1) + 20
fmt.Println("n2=", n2, "n3=", n3)
}

2）如果相加的值大于本身的数据类型范围，则编译不通过

func main() {
//如果相加的值大于本身的数据类型范围，则编译不通过
var n4 int32 = 12
var n5 int8
var n6 int8
n5 = int8(n4) + 127 //【编译通过，但是结果按溢出处理】
n6 = int8(n4) + 128 //【编译不通过，因为128超出int8数据类型的范围】
fmt.Println("n5=", n5)
}

基本数据类型和string的转换

基本介绍
在程序开发中，经常将基本数据类型转换成string，或者将string转换成基本数据类型。

基本数据类型转换string类型
1）方式一：fmt.Sprintf("%参数"，表达式)
函数介绍：

func Sprintf
func Sprintf(format string, a ...interface{}) string
Sprintf根据format参数生成格式化的字符串并返回该字符串。

参数需要和表达式的数据类型相匹配；fmt.Sprintf().. 会返回转换后的字符串。
案例演示：

package main
import(
"fmt"
)
//演示golang中基本数据类型转换string类型
func main() {
var num1 int = 99
var num2 float64 = 23.456
var b bool = true
var myChar byte = 'h'
var str string  //空的string

//使用第一种方式 fmt.Sprintf 来转换
str = fmt.Sprintf("%d", num1)
fmt.Printf("str type %T; str=%q\n", str, str)

str = fmt.Sprintf("%f", num2)
fmt.Printf("str type %T; str=%q\n", str, str)

str = fmt.Sprintf("%t", b)
fmt.Printf("str type %T; str=%q\n", str, str)

str = fmt.Sprintf("%c", myChar)
fmt.Printf("str type %T; str=%q", str, str)
}

D:\goproject\src\go_code\chapter02\basictype2string12>go run main.go
str type string; str="99"
str type string; str="23.456000"
str type string; str="true"
str type string; str="h"

2）方式二：使用strconv包的函数
函数介绍：

func FormatBool(b bool) string
func FormatInt(i int64, base int) string
func FormatUint(i uint64, base int) string
func FormatFloat(f float64, fmt byte, prec, bitSize int) string

案例说明：

package main
import(
"fmt"
"strconv"
)
func main() {
//使用第二种方式 strconv 函数来转换
var num3 int = 99
var num4 float64 = 23.456
var b2 bool = true

str = strconv.FormatInt(int64(num3), 10)
fmt.Printf("str type %T; str=%q\n", str, str)

//说明:'f'格式；10：表示小数位保留10位；64：表示这个小数是float64；
str = strconv.FormatFloat(num4, 'f', 10, 64)
fmt.Printf("str type %T; str=%q\n", str, str)

str = strconv.FormatBool(b2)
fmt.Printf("str type %T; str=%q", str, str)

//strconv包中有一个函数 Itoa，可以将int类型转换成string；
var num5 int = 3456
str = strconv.Itoa(num5)
fmt.Printf("str type %T; str=%q", str, str)
}

D:\goproject\src\go_code\chapter02\basictype2string12>go run main.go
str type string; str="99"
str type string; str="23.4560000000"
str type string; str="true"
str type string; str="3456"

string类型转换基本数据类型
使用strconv包的函数，函数介绍：

func ParseBool(str string) (value bool, err error)
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
func ParseFloat(s string, bitSize int) (f float64, err error)

案例演示：

package main
import(
"fmt"
"strconv"
)
//演示golang中string类型转换基本数据类型
func main(){
var str string = "true"
var a bool
//strconv.ParseBool(str) 函数会返回两个值（value bool，err error）
//因为只想获取到value bool，使用_忽略第二个值；
a, _ = strconv.ParseBool(str)
fmt.Printf("a type %T; a=%v\n", a, a)

var str2 string = "1234566"
var b int64
b, _ = strconv.ParseInt(str2, 10, 64)
fmt.Printf("b type %T; b=%v\n", b, b)

var str3 string = "124.324"
var c float64
c, _ = strconv.ParseFloat(str3, 64)
fmt.Printf("c type %T; c=%v", c, c)
}

D:\goproject\src\go_code\chapter02\string2basictype13>go run main.go
a type bool; a=true
b type int64; b=1234566
c type float64; c=124.324

说明一下，由于strconv函数返回的是int64或float64，如果希望得到int32，float64等，如下处理：

var d int64
d = int32(d)

指针：

基本介绍
1）基本数据类型，变量存的就是值，也叫值类型；变量存值都对应一个地址。
2）获取变量的地址，用 &，比如：var num int，获取num的地址：&num
分析一下基本数据类型在内存的布局:
（二）Golang的变量
3）指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值。比如：var ptr int = &num
举例说明：指针在内存中的布局

4）获取指针类型所指向的值，使用星号，*ptr

package main
import(
"fmt"
)
//演示golang中指针类型
func main() {
//基本数据类型在内存布局
var i int = 10
//i的地址是什么，&i
fmt.Println("i的地址=", &i)

//ptr是一个指针变量；ptr的类型是*int；
//ptr本身的值为&i（变量i对应的地址）;
var ptr *int = &i
fmt.Printf("ptr=%v\n", ptr)
fmt.Printf("ptr的地址=%v\n", &ptr)

//获取指针类型所指向的值，使用 *
fmt.Printf("ptr指向的值=%v", *ptr)
}

D:\gocode\goproject02\pointerdemo>go run main.go
i的地址= 0xc042050058
ptr=0xc042050058
ptr的地址=0xc04206e020
ptr指向的值=10

案例演示
1）写一个程序，获取一个int变量num的地址，并显示到终端；
2）将num的地址赋给指针ptr，并通过ptr去修改num的值。

package main
import(
"fmt"
)
func main() {
var num int = 100
fmt.Println("num的地址=", &num)

var ptr *int = &num
fmt.Printf("ptr=%v\n", ptr)
*ptr = 200
fmt.Println("num=", num)
}

D:\gocode\goproject02\pointerdemo>go run main02.go
num的地址= 0xc042050058
ptr=0xc042050058
num= 200

指针课堂练习
指针的使用细节
1）值类型，都有对应的指针类型，形式为*数据类型，比如int对应的指针就是 *int，float32对应的指针就是 *float32，以此类推。
2）值类型包括：基本数据类型 int系列，float系列，bool，string，数组和结构体struct。
值类型和引用类型
值类型和引用类型的说明
1）值类型：基本数据类型 int系列，float系列，bool，string，数组和结构体struct；
2）引用类型：指针，slice切片，map，管道chan，interface等都是引用类型。
值类型和引用类型的使用特点
1）值类型：变量直接存储值，内存通常在栈中分配；
示意图：

2）引用类型：变量存储的是一个地址，这个地址对应的空间才是真正存储数据（值），内存通过在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收。
示意图：

3）内存的桟区和堆区示意图

标识符的命名规范
标识符概念
1）Golang对各种变量、方法、函数等命名时使用的字符序列称为标识符；
2）凡是自己可以起名字的地方都叫标识符。
标识符的命名规则
1）由26个英文字母大小写，0-9，_组成；
2）数字不可以开头；var num int //ok; var 3num int //error
3）Golang中严格区分大小写；
var num int
var Num int
说明：在golang中，num和Num是两个不同的变量。
4）标识符不能包含空格；

5）下划线“_”本身在Go中是一个特殊的标识符，称为空标识符。可以代表任何其他的标识符，但是对应的值会被忽略（比如：忽略某个返回值）。所以仅能被作为占位符使用，不能作为标识符使用。
6）不能以系统保留关键字作为标识符（一共有25个），比如：break，if 等等。
标识符命名注意事项
1）包名：保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和标准库冲突 fmt
2）变量名、函数名、常量名：采用驼峰法
举例：var stuName string = "tom" 形式：xxxYyyyZzzz...
3）如果变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用。
系统保留关键字
在go中，为了简化代码编译过程中对代码的解析，其定义的保留关键字只有25个。
系统的预定义标识符
除了保留关键字外，go还提供了36个预订的标识符，其包括基础数据类型和系统内嵌函数。