标识符

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

关键字

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

标识符：

1
2
3
4
5
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
6
7
8
9
10
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语言中的变量需要声明后才能使用，同一作用域内不支持重复声明。 并且Go语言的非全局变量声明后必须使用，全局变量声明了但是可以不使用。

  • 标准声明

    var 变量名 类型

    变量声明以关键字var开头，变量类型放在变量名的后面，行尾无需分号。

    1
    2
    3
    var name string
    var age int
    var isOk bool

  • 批量声明

    每声明一个变量就需要写var关键字会比较繁琐，go语言中支持批量声明

    1
    2
    3
    4
    5
    var (
    	name string
        age int
        isOk bool
    )

  • 变量的初始化

Go语言在声明变量的时候，自动会对变量的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值。

1
2
3
4
5
6
string ""
int 0
bool false
切片 nil
函数 nil
指针变量 nil

标准初始化

1
2
3
var 变量名 类型 = 表达式
var name string = "张三"
var age int = 16

一次初始化多个变量

1
var name, age = "李四", 20

  • 类型推导

    将变量的类型进行省略，这时候编译器会根据等号右边的值来推导变量的类型完成初始化。

    1
    2
    var age = 17
    var name = "王二"

  • 短变量声明

    在函数内部，可以使用:=的方式声明并初始化变量。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    package main

    import ("fmt")

    // 全局变量 m
    var m = 100

    func main(){
        n := 10
        m := 200//此处声明局部变量m
        fmt.Println(m,n)
    }

  • 匿名变量

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

1
2
3
4
5
6
7
8
9
10
func foo()(int, string){
    return 10, "张三"
}

func main(){
    x,_ := foo()
    _,y := foo()
    fmt.Println("x=", x)
    fmt.Println("y=", y)
}

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

注意事项：

​ 1、函数外的每个语句都必须以关键字开始(var, const, func等)

​ 2、:=不能在函数外使用

​ 3、_多用于占位符，表示忽略值。

常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值。

在整个程序运行期间它们的值都不能再发生变化了

  • 普通声明
1
2
//常量普通定义
const pi = 3.1415926

  • 批量声明

    1
    2
    3
    4
    5
    //批量声明常量
    const(
    	StatusOk       = 200
    	StatusNotfound = 404
    )
    1
    2
    3
    4
    5
    6
    //批量声明常量时，如果在某一行声明后没有赋值，默认就和上一行一致
    const(
    	a = 100 //100
    	b		//100
    	c		//100
    )

    iota

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

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

    1
    2
    3
    4
    5
    6
    //iota关键字在const出现时将被重制为0，当前const中每增加一行将使iota计数加1
    const(
    	a1 = iota //0
    	a2		  //1
    	a3		  //2
    )

    使用_跳过某些值

    1
    2
    3
    4
    5
    6
    7
    //使用匿名变量`_`跳过某些赋值，但iota任会加1
    const(
    	b1 = iota //0
    	b2		  //1
    	_		  //2，但被丢弃
    	b3		  //3
    )

    插队

    1
    2
    3
    4
    5
    6
    7
    //插队
    const(
    	c1 = iota //0
    	c2 = 100 //c2=100,iota =1
    	c3 = iota //2 在同一个const不会被重置为0
    	c4 //3
    )

    多个const定义在一行

    1
    2
    3
    4
    5
    //多个iota定义在一行
    const(
    	d1, d2 = iota + 1, iota + 2 // d1=1, d2=2  const中初次出现iota=0,同一行，iota只加一次
    	d3, d4 = iota + 1, iota + 2 // d3=2, d4=3
    )

    定义数量级

    1
    2
    3
    4
    5
    6
    7
    8
    9
    //定义数量级
    const(
    	_ = iota
    	KB = 1 << (10 * iota) //1Kb
    	MB = 1 << (10 * iota) //1Mb
    	GB = 1 << (10 * iota) //1Gb
    	TB = 1 << (10 * iota) //1Tb
    	PB = 1 << (10 * iota) //1Pb
    )