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

一.标识符和关键字

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)
}