Golang语言基础之标识符和变量定义

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

目录

• 一.标识符和关键字
  • 1.命名方式
  • 2.标识符
  • 3.关键字
• 二.变量
  • 1.变量的来历
  • 2.变量类型
  • 3.变量声明
    • 3.1 标准声明
    • 3.2 批量声明
    • 3.3 声明变量时进行初始化及默认值
    • 3.4 变量声明之类型推导
    • 3.5 在函数内部定义短变量声明
    • 3.6 匿名变量
• 三.变量的作用域

一.标识符和关键字

1.命名方式

GO变量，常量，自定义类型，包，函数的命名方式必须遵循以下规则:
	- 首字符可以是任意Unicode字符或下划线;
	- 首字符之外的部分可以是Unicode字符，下划线或数字;
	- 名称的长度无限制

理论上名字里可以有汉字，甚至全是汉字，但实际开发中建议不要这么做。

2.标识符

在编程语言中标识符就是程序员定义的具有特殊意义的词，比如变量名、常量名、函数名等等。 

Go语言中标识符由字母数字和_(下划线）组成，并且只能以字母和_开头。 举几个例子：abc, _, _123, a123。

举个例子:
	数据类型和标识符的关系可以理解为房间类型和房间号，比如你出去旅游，入住宾馆:
		房间类型: 单人床，双人床，大床房，海景房，总统套房等。
		房间编号: 8101，8202，8303，8404，8505，...
		
  其中房间类型可以理解为数据类型，房间编号就是我们所说的标识符。
  
  
标识符定义规则:
	- 1.组成部分三个可以
			数字，字母，下划线。
	- 2.四个注意
			不可以以数字开头，严格区分大小写，不能包含空格，不可以使用Go中的保留字或关键字。
	- 3.见名知意
			增加可读性。
	- 4.下划线("_")本身在Go中是一个特殊的标识符，称为"空标识符"
			可以代表任意其他的标识符，但是它对应的值会被忽略(比如: 忽略某个返回值)，所以仅能被作为占位符使用，不能单独作为标识符使用。
	- 5.长度无限制
			但是不建议命名太长。
	- 6.不要使用关键字
			比如"var int int64 = 100"，此处的int标识符是Go语言中的关键字，尽量不要使用。
	- 7.起名规则
			包名: 
				尽量保持package的名称和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和标准库冲突。
			变量名，函数名，常量名: 
				采用驼峰法,就是单词按照大小写区分开。
			大小写:
				如果变量名，函数名，常量名首字母大写，则可以被其他的包访问，如果首字母小写，则只能在本包中使用，利用首字母大小写完成访问权限控制。
			
			温馨提示:
				1.import导入语句通常放在文件开头包声明语句的下面。
				2.导入的包名需要使用双引号包裹起来。
				3.包名是从"$GOPATH/src"后开始计算的，使用"/"进行路径分隔；但前提是你已经配置了"GOPATH"环境变量。
				4.main包是一个程序的入口包，所以你main函数它所在的包建议定义为main包，如果不定义main包，那么就不能得到可执行文件。
				5.包名称不要和标准库冲突;

3.关键字

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

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

二.变量

1.变量的来历

变量相当于内存中一个数据存储空间的表示，程序运行过程中的数据都是保存在内存中，我们想要在代码中操作某个数据时就需要去内存上找到这个变量。

但是如果我们直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了。

2.变量类型

变量（Variable）的功能是存储数据，不同的变量保存的数据类型可能会不一样。

经过半个多世纪的发展，编程语言已经基本形成了一套固定的类型，常见变量的数据类型有：整型、浮点型、布尔型、字符串等。

Go语言中的每一个变量都有自己的类型，并且变量必须经过声明才能开始使用。

数据类型分为基本数据类型和高级(派生)数据类型:
	基本数据类型:
		- 数值型:
				- 整数类型(int,int8,int16,int32,int64,uint8,uint16,uint32,uint64,byte)
				- 浮点类型(float32,float64)
		- 字符型:
				- 没有单独的字符型，使用byte类型来保存单个字母字符。
		- 布尔型:
				- 对应的类型为bool，有效值为: true|false
		- 字符串:
				- 对应string。
	
	高级数据类型:
		- 指针
		- 数组
		- 结构体
		- 管道
		- 函数
		- 切片
		- 接口
		- map

3.变量声明

Go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明，并且Go语言的变量声明后必须使用。

变量的使用步骤:
	- 声明
	- 赋值
	- 使用

3.1 标准声明

Go语言的变量声明格式为：
	"var 变量名 变量类型"
		

变量声明以关键字var开头，变量类型放在变量的后面，行尾无需分号。 举个例子：
	var name string
  var age int
  var isOk bool

3.2 批量声明

每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量声明，如下所示：
	var (
		a string
		b int
		c bool
		d float32
	)

3.3 声明变量时进行初始化及默认值

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。

每个变量会被初始化成其类型的默认值，例如： 
	(1)整型和浮点型变量的默认值为0; 
	(2)字符串变量的默认值为空字符串; 
	(3)布尔型变量默认为false;
	(4)切片、函数、指针变量的默认为nil;
	(5)...

当然我们也可在声明变量的时候为其指定初始值。变量初始化的标准格式如下：
	"var 变量名 类型 = 表达式"
	
	
举个例子：
	var name string = "JasonYin"
	var age int = 18
	
或者一次初始化多个变量
	var name, age = "JasonYin", 20

3.4 变量声明之类型推导

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

3.5 在函数内部定义短变量声明

在函数内部，可以使用更简略的":="方式声明并初始化变量。但在全局变量不支持这种写法哟~

举个例子:
  package main

  import "fmt"

  // 声明全局变量
  var school string = "清华大学"
  var class = 99

  func main(){
    // 短变量，仅在函数内部可以这样写
    school := "哈尔滨工程大学"
    xixi := "嘻嘻"
    id := 100

    fmt.Println(school,class,xixi,id)
  }

3.6 匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）也可以称之为"空标识符"。 
	
匿名变量用一个下划线"_"(空标识符)表示，例如：
    package main

    import "fmt"

    func foo() (int, string) {
      return 18, "Jason Yin"
    }

    func bar() (bool, string) {
      return true, "尹正杰"
    }

    func main() {
      // 此处的"_"我们称之为空标识符，用于忽略变量，我们称之为匿名变量。一般情况下该变量用于忽略，起到占位作用。
      age, _ := foo()
      _, name := bar()

      fmt.Println("姓名: ", name, "年龄: ", age)
    }

        
匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。 (在Lua等编程语言里，匿名变量也被叫做哑元变量。)

注意事项：
	(1)函数外的每个语句都必须以关键字开始（var、const、func等）
	(2)":="不能使用在函数外。
	(3)"_"多用于占位，表示忽略值。

三.变量的作用域

package main

import "fmt"

var (
	// 全局变量，大写字母开头，所有地方都可以访问，跨package访问时需要带上package名称。
	A = 3
	// 全局变量，小写字母，本package内部都可以访问
	b = 4
)

func foo() {
	// 局部变量，仅本函数内可以访问，内部声明的变量可以跟外部声明的变量有冲突，以内部的为准
	b := 5
	fmt.Println("foo outter", b)

	{
		// 仅"{}"圈定的作用于内可以访问，可以跟外部的变量有冲突
		b := 6

		fmt.Println("foo inner", b)
	}

	fmt.Println("foo end", b)

}

func main() {
	b = 7
	foo()

	// 变量的作用域遵循"就近原则"。
	fmt.Println("A = ", A)
	fmt.Println("b = ", b)
}