Go语言学习笔记（1）——顺序编程

Go语言学习笔记这一堆主要是《Go语言编程》（人民邮电出版社）的读书笔记。中间会穿插一些零碎的点，比如源码学习之类的。大概就是这样吧。

1. 顺序编程

1.1 变量

变量的声明：

var 变量名 类型

var v1 int

也可以把若干变量的声明用大括号括起来

var {
    v1 int
    v2 string
}

变量初始化：

变量的初始化可以用如下的方法：

var v1 int = 10
var v2 = 10
v3 := 10

这三种方法的效果大体上是一样的。需要注意的有：第三种方法不能用于声明全局变量；以及:=赋值符号不能用于已声名过的变量名。

变量的赋值：

赋值这里唯一特别的是，Go语言支持多重赋值，比如交换i和j的值：

i, j = j, i

匿名变量：

Go语言有一个特性，就是在引入的包和变量在没有使用的时候，会在编译阶段报错。所以对于不需要的变量，可以使用匿名变量进行处理。

两个例子，第一个是多重返回函数的返回值的处理：

func GetName() (firstName, lastName, nickName string) {
    return "May", "Chan", "Chibi Maruko"
}

_, _, nickName := GetName()

如果只需要函数的部分返回值的时候，就可以利用匿名变量。

第二个是for循环：

var a int[] = {5, 4, 3, 2, 1}
for _, value := range(a) {
    balabala
}

当我们不需要range返回的部分结果的时候，就可以利用匿名变量。

1.2 常量

字面常量：大概只有一点要说，就是不需要额外做特别的声明。比如对于long类型的12，不存在12l这种写法。

常量定义：通过const关键字进行定义。

const Pi float64 = 3.1415926

需要注意的大概有：声明的时候可以不限定类型；常量定义的右值也可以是编译期运算的常量表达式。

const Zero = 0.0
const mask = 1 << 3
const Home = os.GetEnv("HOME")

这里第三句会导致错误。因为右值只有在运行期才能知道结果。

预定义常量：true，false，iota。

这里true和false没有什么说的。

iota可以被认为是一个可被编译器修改的常量，该常量在每一个const关键字出现的时候被重置为0。在下一个const出现之前，每出现一次iota，其所代表的数字自动加1。

Golang不支持enum关键字的枚举类型，通常把const和iota结合起来表示枚举，例如：

const {
    Sunday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    numberOfDays
}

这样就将星期与整数对应了起来。

注意，numberOfDays并没有被导出。

1.3 类型

Golang支持以下类型：

基本类型：布尔型，整型，浮点型，复数型，字符串，字符型，错误型。

复合类型：指针，数组，切片，字典，通道，结构体，接口。

基本类型中，需要注意的问题如下；

int和int32在Golang中被认为是不同的两个类型。所以二者不能互相赋值（编译期不会自动做类型转换），需要进行强制的类型转换。

自动推导的浮点数类型是float64。

复数类型是其他大部分语言不支持的。例子如下：

var value1 complex64

value1 = 3.2 + 12i
value2 := 3.2 + 12i
value3 := complex(3.2, 12)

x := real(value1)
y := imag(value1)

字符串可以用下表的方式获取其内容，但是字符串在初始化之后，其内容就不能进行修改了。

字符串的遍历，这还跟len()函数作用在字符串上的返回值有关，例子如下：

str := "Hello, 世界"
n := len(str)     //n = 13
for i:=0, i<n, i++ {
    fmt.Println(i, str[i])
}

for i, ch := range str {
    fmt.Println(i, ch)
}      //该段代码输出了9行结果

另外需要注意的，range有两个返回值，第一个是下标，第二个是下标对应的值。

数组在声明了以后，就不能再修改其长度。

数组切片的实质可以理解成3部分：一个指向原数组的指针；数组切片中的元素个数；数组切片已分配的存储空间。

数组切片的声明方式如下：

//基于数组创建数组切片
var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
var mySlice []int
mySlice = myArray[:]    //基于所有数组元素创建切片
mySlice = myArray[:5]    //基于数组的前5个（0～4）元素创建切片
mySlice = myArray[5:]    //基于数组第5个开始（5～end）的元素创建切片

//直接创建数组切片
mySlice1 := make([]int, 5)    //创建一个初始长度为5的数组切片，元素初始值是0
mySlice2 := make([]int, 5, 10)    //除以上之外，预留了10个元素的存储空间
mySlice3 := []int{1, 2, 3, 4, 5}    //直接创建并初始化一个包含5个元素的数组切片

append函数可以增加切片的元素。注意append函数并不是原地的。其应用例子如下：

mySlice := make([]int, 2, 10)

mySlice = append(mySlice, 1)
mySlice = append(mySlice, 2, 3)

mySlice2 := []int{4, 5}
mySlice = append(mySlice, mySlice2...)

注意最后的...，它将mySlice2的元素打散做为append的参数。

也可以通过数组切片来创建切片。例如：

oldSlice := make([]int, 5, 10)
newSlice1 := oldSlice[:3]    //用oldSlice的前三个元素创建新的切片
newSlice2 := oldSlice[:7]    //也可以超出原切片的数量，但是不能超过cap，超出的部分填0

copy函数可以将一个数组切片的内容复制到另一个数组切片。例如：

slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{6, 7, 8}

copy(slice2, slice1)    //复制slice1的前三个元素到slice2
copy(slice1, slice2)    //复制slice2到slice1的前三个位置

map的元素查找可以用以下方法：

myMap := make(map[string]int, 100)    //声明一个map，cap为100

value, ok := myMap["1234"]
if ok {    //找到了
    //对value的处理
}

1.4 流程控制

条件语句if的例子如下：

if a < 5 {
    return 0
} else {
    return 1
}

需要注意的有：条件语句不需要括号；花括号必须存在；以及最重要的，不允许将最终的return包含在if...else...结构中。

选择语句switch的例子如下：

switch i {
    case 0:
        fmt.Println(0)
    case 1:
        fmt.Println(1)
        fallthrough
    case 3:
        fmt.Println(3)
    default:
        fmt.Println("Default")
}

需要注意的有：除非明确的标明fallthrough，否则认为分支默认break；另外，switch后面的条件表达式也可以不设定，这时可以将switch看作是多个if...else...。

循环语句if的例子如下：

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

j := 0
for j<10 {
    fmt.Print(j)
    j++
}

k := 0
for {
    fmt.Print(k)
    k++
    if k>10 {
        break
    }
}

总之，Golang是把for和while结合到了一起。同时，也有break和continue。break也可以选择中断哪个循环。

goto就是跳转到label。这个很少用，先写在这里。

1.5 函数

函数的定义和调用：

package mymath
import "errors"

func Add(a int, b int) (ret int, err error) {
    if a<0 || b<0 {
        err = errors.New("Should be non-negative numbers!")
        return
    }
    return a + b, nil
}

c := mymath.Add(1, 2)

需要注意的有：函数、类型和变量的可见性是由其首字母的大小写来确定的，大写开头的是public，小写开头的是private；函数的返回值的变量名可以先声明出来，在函数体内对变量进行处理后直接return即可；函数可以同时返回多个值。

同时，Golang的函数也支持不定参数，例如：

func myfunc(args ...int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

myfunc(2, 3, 4)
myfunc(1, 3, 7, 13)

func myfunc2(args ...int) {
    myfunc(args...)
    myfunc(args[1:]...)
}

通过例子可以看到不定参数的函数的遍历方法和调用方法。以及作为变参函数嵌套的传参方法。我觉得最关键的是记住，...在跟类型一起出现的时候，表明的是变参类型；...在跟变量名一起出现的时候，表明是将该变量内容打散。这种记法与*和&的区别方法一致。

如果希望传递任意类型的不定参数，可以利用interface{}。这里先举一个例子，后面会再具体描述interface{}。

func MyPrintf(args ...interface{}) {
    for _, arg := range args {
        switch arg.(type) {
            case int:
                fmt.Println(arg, "int")
            case string:
                fmt.Println(arg, "string")
            default:
                fmt.Println(arg, "unknown")
        }
    }
}

匿名函数简单的说就是没有函数名的函数。匿名函数可以赋值给一个变量名，也可以直接执行。例如：

f := func(x, y int) int {
    return x + y
}

func (ch chan int) {
    ch <- ACK
} (reply_chan)

立即执行的匿名函数，需要把传入的参数放到函数后面的括号中。

这里还有一个闭包的概念，目前还没太懂，待补充。

错误处理，Golang提供了error，defer，panic和recover工具。

error是一个接口，其定义如下：

type error interface {
    Error() string
}

对于需要返回错误的函数，多数情况下定义成下面的形式，并按以下方式调用：

func Foo(param int) (n int, err error) {
    // ...
}

n, err := Foo(0)
if err != nil {
    //  错误处理
} else {
    //  使用返回值n
}

那么，对于自定义的error类型（即实现了error接口的类型），通常定义的形式如下：

type PathError struct {
    Op string
    Path string
    Err error
}

func (e *PathError) Error() string {
    return e.Op + " " + e.Path + ": " + e.Err.Error()
}

func Stat (name string) (fi FileInfo, err error) {
    var stat syscall.Stat_t

    err =syscall.Stat(name, &stat)
    if err != nil {
        return nil, &PathError{"stat", name, err}
    }

    return fileInfoFromStat(&stat, name), nil
}

defer关键字主要是用来处理代码中需要在最后完成的任务，比如关闭管道，关闭文件等。例子如下：

func CopyFile(dst, src string) (w int64, err error) {
    srcFile, err := os.Open(src)
    if err != nil {
        return
    }
    defer srcFile.Close()
    return io.Copy(dstFile, srcFile)
}

另外，如果一个函数中有多个defer关键字，那么它们是以后进先出的方式（即自下而上的）执行。

panic和recover两个函数是Golang中用来处理异常的函数。其流程大致为：当在一个函数执行过程中调用panic()函数时，正常的函数执行流程将立即终止，但函数中之前使用defer关键字延迟执行的语句将正常展开执行，之后该函数将返回到调用函数，并导致逐层向上执行panic流程，直至所属的goroutine中所有正在执行的函数被终止。recover()函数用于终止错误流程。一般情况下，recover()应该在一个使用defer关键字的函数中执行以有效截取错误处理流程。如果没有在发生异常的goroutine中明确调用恢复过程，会导致该goroutine所属的进程打印异常信息后直接退出。

常见的recover()调用方法如下：

defer func() {
    if r := recover(); r != nil {
        log.Printf("Runtime error caught: %v", r)
    }
}()

这样写，无论函数中是否出发了错误处理流程，该匿名函数都将在函数退出时得到执行。

第一节大概是这样~如果有任何问题还会及时更新~~~