后端实习の准备：小白从零学习Go语言第三天

---

往期链接

小白从零学习Go语言第一天

小白从零学习Go语言第二天

---

Day3

3.1 变量的声明与赋值

• 变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。
• 变量可以通过变量名访问。
• 之前提到过，Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。

• 声明变量的一般形式是使用 var关键字：

var identifier type
var a string = "变量"

• 可以一次声明多个变量：

var identifier1, identifier2 type
var b, c int = 1, 2

• 指定变量类型后，如果没有初始化，则变量默认为零值。

var b int
fmt.Println(b)
//0

var c bool
fmt.Println(c)
//false

• 关于默认的零值，数值类型（包括complex64/128）为 0， 布尔类型为 false， 字符串为 “”（空字符串）， 指针、切片、映射、通道、函数和接口的零值则是 nil
• 关于nil可以看这篇文章进行更深的了解
• 如果初始化变量后，Go语言会由编译器自动判断变量类型，和 python 相似

var v_name = value
var vname1, vname2, vname3 = v1, v2, v3
var d = 1
var e = true

• 不过我更偏向于这样声明变量：（但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值。）

v_name := value
vname1, vname2, vname3 := v1, v2, v3

这样定义省略了 var，也省略了变量类型, 不过要注意 := 左侧如果没有声明新的变量，会产生编译错误

intVal := 1 

等价于

var intVal int 
intVal =1 

• 这种因式分解关键字的写法一般用于声明全局变量

var (
    vname1 v_type1
    vname2 v_type2
)

• 多变量可以在同一行进行赋值，如：（并行/同时 赋值）

var a, b int
var c string
a, b, c = 5, 7, "abc"

或者

a, b, c := 5, 7, "abc"

并行赋值可以被用于一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)。

• 如果你想要交换两个变量的值，则可以简单地使用 a, b = b, a，但是两个变量的类型必须是相同。

3.2 心碎的变量

• 如果你声明了一个局部变量却没有在相同的代码块中使用它，会得到编译错误a declared and not used所以不要浪费变量的感情 ，但是全局变量允许声明但不使用。
• 你也可以抛弃一些不想使用的值: 因为 Go 语言中必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。使用空白标识符 _来抛弃值（ _ 是一个只写变量，你不能得到它的值。），如：

_, b = 5, 7 中将 5 抛弃。

3.3 常量

• 常量是一个简单值的标识符，在程序运行时不会被修改。

• 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

• 常量的定义格式（显式类型定义）：

const identifier [type] = value
const c_name1, c_name2 = value1, value2
const Pi  = 3.1415926

• 你可以省略类型说明符[type]（即隐式类型定义），因为编译器可以根据变量的值来推断其类型。

const (
    Unknown = 0
    Female = 1
    Male = 2
)

• 常量可以用len(), cap(), unsafe.Sizeof() 函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：

package main

import "unsafe"

const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main(){
     
    println(a, b, c)
    //abc 3 16
}

3.4 iota

• iota，特殊常量，可以认为是一个可以被编译器修改的常量。

• iota 在 const 关键字出现时将被重置为 0( const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次( iota 可理解为 const 语句块中的行索引)。

const (
    a = iota // 0
    b = iota // 1
    c = iota // 2
)

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1

所以 a=0, b=1, c=2 可以简写为如下形式（定义常量组时，如果不提供初始值，则表示将使用上行的表达式。）：

const (
    a = iota
    b
    c
)

• iota 只是在同一个 const 常量组内递增，每当有新的 const 关键字时，iota 计数会重新开始。

package main

const (
    i = iota
    j = iota
    x = iota
)
const y = iota
const z = iota

func main(){
     
    println(i, j, x, y, z)
    // 输出是 0 1 2 0 0
}

实例1：

package main

import "fmt"

func main() {
     
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota = 3
            e          //"ha"   iota = 4
            f = 100    //iota = 5
            g          //100  iota = 6
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
    //0 1 2 ha ha 100 100 7 8
}

实例2：

package main

import "fmt"

const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
     
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
    //i= 1
    //j= 6
    //k= 12
    //l= 24
}

• iota 表示从 0 开始自动加 1，所以 i = 1<<0 = 1, j = 3<<1 = 6。

  • 左移运算符 << 是双目运算符。左移 n 位就是乘以 2 的 n 次方。 该操作将 << 左边的运算数的各二进位全部左移若干位，由 << 右边的数指定移动的位数，高位丢弃，低位补 0。
  • 右移运算符 >> 是双目运算符。右移 n 位就是除以 2 的 n 次方。 其功能是把 >> 左边的运算数的各二进位全部右移若干位， >> 右边的数指定移动的位数。
  • 更多的细节可以看这里

• 而根据定义常量组时，如果不提供初始值，则表示将使用上行的表达式， k = 3<<2 = 12，l = 3<<3 = 24。