04.Go基础之变量和常量

文章目录

一、 变量定义规范

Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则：

  1. 一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线
  2. 大写字母和小写字母是不同的：Name和name是两个不同的变量
  3. 关键字和保留字都不建议用作变量名

二、关键字

1.标识符

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

2.关键字

关键字是指编程语言中预先定义好的具有特殊含义的标识符，关键字和保留字不能用于自定义名字，只能在特定语法结构中使用

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

3.保留字

此外，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

4.注意点

  1. 这些保留字并不是关键字，可以在定义中重新使用它们。在一些特殊的场景中重新定义它们也是有意义的，但是也要注意避免过度而引起语义混乱
  2. 如果一个名字是在函数内部定义，那么它就只在函数内部有效。如果是在函数外部定义，那么将在当前包的所有文件中都可以访问。名字的开头字母的大小写决定了名字在包外的可见性。如果一个名字是大写字母开头的（必须是在函数外部定义的包级名字；包级函数名本身也是包级名字），那么它将是导出的，也就是说可以被外部的包访问，例如fmt包的Printf函数就是导出的，可以在fmt包外部访问。包本身的名字一般总是用小写字母
  3. 名字的长度没有逻辑限制，但是Go语言的风格是尽量使用短小的名字，对于局部变量尤其是这样；你会经常看到i之类的短名字，而不是冗长的theLoopIndex命名。通常来说，如果一个名字的作用域比较大，生命周期也比较长，那么用长的名字将会更有意义
  4. 在习惯上，Go语言程序员推荐使用 驼峰式 命名，当名字由几个单词组成时优先使用大小写分隔，而不是优先用下划线分隔。因此，在标准库有QuoteRuneToASCII和parseRequestLine这样的函数命名，但是一般不会用quote_rune_to_ASCII和parse_request_line这样的命名。而像ASCII和HTML这样的缩略词则避免使用大小写混合的写法，它们可能被称为htmlEscape、HTMLEscape或escapeHTML，但不会是escapeHtml
  5. go文件的名字，建议用下划线的方式命名（参见go源码）

三、变量

1.变量的来历

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

综上：

变量就是指定了某存储单元（Memory Location）的名称，该存储单元会存储特定类型的值。在 Go 中，有多种语法用于声明变量。

2.变量的类型

变量（Variable）的功能是存储数据。不同的变量保存的数据类型可能会不一样。经过半个多世纪的发展，编程语言已经基本形成了一套固定的类型，常见变量的数据类型有：字符串、整型、浮点型、布尔类型等。

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

3.声明变量

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

4.标准声明（声明单个变量）

Go语言的变量声明格式为：

var name(变量名) type(变量类型)

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

var name string
var age int
var isOk bool

简单示例

package main

import "fmt"

func main() {
    var age int // 变量声明
    fmt.Println("my age is", age)
}

5.声明多个变量

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

var (
    a string
    b int
    c bool
    d float32
)

简单示例：

package main

import "fmt"

func main() {
	var (
		name   string = "shawn"
		age    int    = 18
		height int    = 168
	)
	fmt.Println("my name is", name, ", age is", age, "and height is", height)
}

6.变量的初始化

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值，例如： 整型和浮点型变量的默认值为0。 字符串变量的默认值为空字符串。 布尔型变量默认为false。 切片、函数、指针变量的默认为nil。

当然我们也可在声明变量的时候为其指定初始值。变量初始化的标准格式如下：

var 变量名 类型 = 表达式

举个梨子：

var name string = "babyboy"
var age int = 18

或者一次初始化多个变量:

var name, age = "babyboy", 20

简单示例：

package main

import "fmt"

func main() {
	var (
		name   string = "babyboy"
		age    int    = 18
		height int    = 168
	)
	fmt.Println("my name is", name, ", age is", age, "and height is", height)
}

在上面的程序中，name是具有初始值为babyboy的字符串类型的变量，而age和height的初始值为18和168并且为int类型。

如果你运行上面的程序，出现如下结果，说明name、age、height

分别初始化为babyboy，18,168.

my name is babyboy , age is 18 and height is 168

7.类型推导（Type Inference）

有时候我们会将变量的类型省略，这个时候编译器会根据等号右边的值来推导判断出变量的类型并完成初始化。

比如，在下面的例子中，你可以看到在第 6 行，我们省略了变量 age 的 int 类型，Go 依然推断出了它是 int 类型

package main

import "fmt"

func main() {
    var age = 29 // 可以推断类型

    fmt.Println("my age is", age)
}

8.简短声明

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

基本语法如下：

name := initialvalue

简单示例：

package main

import "fmt"

func main() {  
    name, age := "naveen", 29 // 简短声明

    fmt.Println("my name is", name, "age is", age)
}

运行上面的程序，可以看到输出为 my name is naveen age is 29。

简短声明要求 := 操作符左边的所有变量都有初始值。下面程序将会抛出错误 cannot assign 1 values to 2 variables，这是因为 age 没有被赋值。

package main

import "fmt"

func main() {  
    name, age := "naveen" //error

    fmt.Println("my name is", name, "age is", age)
}

9.匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示，例如：

func foo() (int, string) {
	return 10, "babyboy"
}
func main() {
	x, _ := foo()
	_, y := foo()
	fmt.Println("x=", x)
	fmt.Println("y=", y)
}

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

注意事项：

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

五、常量

1.常量定义

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

var a int = 50  
var b string = "I love Go"

声明了pi和e这两个常量之后，在整个程序运行期间它们的值都不能再发生变化了。

所以，常量不能再重新赋值为其他的值。因此下面的程序将不能正常工作，它将出现一个编译错误: cannot assign to a.

package main

func main() {  
    const a = 55 // 允许
    a = 89       // 不允许重新赋值
}

2.声明多个常量

多个常量也可以一起声明：

const (
    pi = 3.1415
    e = 2.7182
)

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。 例如：

const (
    n1 = 100
    n2
    n3
)

上面示例中，常量n1、n2、n3的值都是100。

3.iota

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

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

举个梨子：

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

4.几个常见的iota示例:

使用_跳过某些值

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

iota声明中间插队

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

定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。）

const (
		_  = iota
		KB = 1 << (10 * iota) // i<<10
		MB = 1 << (10 * iota) // i<<20
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)

多个iota定义在一行

const (
		a, b = iota + 1, iota + 2 //1,2
		c, d                      //2,3
		e, f                      //3,4
	)