如题，此贴记录一下学习Go时需要记的一些点。
大量参照：
Go 语言教程 | 菜鸟教程
Go 系列教程（Golang tutorial series） - 专栏 - Go语言中文网 - Golang中文社区
手把手golang教程【二】——数组与切片 - TechFlow2019 - 博客园
然后根据自己理解记录的。
仅供本人参考
控制流程
if else
if判断，简单演示：
func main() {
var one float32
for true {
fmt.Println("输入一个数值")
_, err := fmt.Scanln(&one)
if err == nil {
fmt.Printf("你输入了%v\n", one)
continue
} else { //else必须跟在}后面，由于go的自插入；机制
fmt.Printf("错误:%s\n", err)
continue
}
//如果else没有内容就省略else：
if err != nil {
fmt.Printf("错误:%s\n", err)
continue
}
}
}
switch case
根据变量的值做判断，避免重复嵌套if。简单演示：
var one int
fmt.Println("输入一个整数")
fmt.Scanln(&one)
switch one {
case 1:
fmt.Println("one的值是1")
case 2:
fmt.Println("one的值是2")
default:
fmt.Println("one的值不是1或2")
}
//其中default是默认值，当没有匹配项时就会执行这一块代码，可以省略。
for
for循环，go语言只有这一个循环语句没有while,简单演示：
//for v; p; c{}
//其中v是在执行for循环前执行的，可以把初始化放在语句放在这。
//p是循环判断表达式
//c是每循环完成一次就会执行的，一般写自相加
for i, j := 0, 100; i < j; i++{ //输出1-100
fmt.Println(i)
}
//如果想实现while true无限循环可以直接
for true {
fmt.Println("Hello")
}
for的简单实践：
package main
import "fmt"
func xx(){
for i := 9; i >= 1; i-- {
for j := 9; j >= i; j-- {
fmt.Printf("%v X %v = %v \t", i, j, j*i)
}
fmt.Println()
}
}
func one(){
for i := 0 ; i <= 100; i++{
fmt.Printf("%v\t", i)
}
fmt.Println()
for j := 100; j >= 0; j--{
fmt.Printf("%v\t", j)
}
fmt.Println()
}
func main(){
fmt.Println("99乘法表:")
xx()
fmt.Println("0-100-0")
one()
}
运行会输出：
99乘法表:
9 X 9 = 81
8 X 9 = 72 8 X 8 = 64
7 X 9 = 63 7 X 8 = 56 7 X 7 = 49
6 X 9 = 54 6 X 8 = 48 6 X 7 = 42 6 X 6 = 36
5 X 9 = 45 5 X 8 = 40 5 X 7 = 35 5 X 6 = 30 5 X 5 = 25
4 X 9 = 36 4 X 8 = 32 4 X 7 = 28 4 X 6 = 24 4 X 5 = 20 4 X 4 = 16
3 X 9 = 27 3 X 8 = 24 3 X 7 = 21 3 X 6 = 18 3 X 5 = 15 3 X 4 = 12 3 X 3 = 9
2 X 9 = 18 2 X 8 = 16 2 X 7 = 14 2 X 6 = 12 2 X 5 = 10 2 X 4 = 8 2 X 3 = 6 2 X 2 = 4
1 X 9 = 9 1 X 8 = 8 1 X 7 = 7 1 X 6 = 6 1 X 5 = 5 1 X 4 = 4 1 X 3 = 3 1 X 2 = 2 1 X 1 = 1
0-100-0
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Process finished with exit code 0
goto
跳转语句，由于是强行跳转执行，会导致阅读理解代码变得困难。常不被推荐使用。
简单演示：
package main
import "fmt"
func main() {
//流程控制-跳转goto，不常用
i := 0
xx:
if i < 99 {
i = i + 11
fmt.Printf("%v x %v = %v\n", i, i, i * i)
} else{
goto end
}
goto xx
end:
fmt.Println("END")
}
函数
func () {}
package main
//实现特定功能的方法被称为函数，封装这些方法的叫做包
import (
"fmt"
)
//fmt就是包
//fmt.Println这个Println就是函数
func main() {
/*
//Go中的函数被称为一等公民，就是支持高阶函数的函数。
//高阶函数指函数可以被存储和作为参数传递
a := Say //函数被存储
a()
Hello(a) //函数可以传递
*/
//函数调用 采用栈结构的方式，main函数始终处于栈底
//main函数需要等待内部函数调用完成 才能出栈 这就是先进后出FILO
//演示:main函数调用了say函数，say函数中又调用了name1函数，所以say函数必须要等待name1函数执行完毕，才能结束。main函数也必须要等待say函数执行完毕才能结束。
Say()
}
func Say(){
value, _ := name1(1, 2)
fmt.Println("Hello,Golang", value)
}
func Hello(f func()){
f()
}
//一个完整的函数如下，包括函数名，形参 i j和形参类型，返回值 和返回值类型，函数体
//其中函数名可以省略，省略函数名的函数叫做匿名函数，具有函数名的函数叫做具名函数。只有匿名函数可以被嵌套
//当然 形参 返回值和return也都可以省略
func name1(i, j int)(int, error){
v := i + j
fmt.Println("v", v)
return v, nil
}
包
package
import
数组
var a = [3]int{1,2,3}
var a [3]int
a[0] = 1
a[1] = 2
fmt.Print(a, "\n")
//标准数组定义及赋值方法
b := [...]int{3,5,6,0,2}
fmt.Print(b, "\n")
//简写方法
c := [2][3]string{
{"list1", "value1-1", "value1-2"},
{"list2", "value2-1", "value2-2"},
}
//多维数组
for i,v := range c {
fmt.Print(i, v, "\n")
}
//range遍历 返回索引和索引对应的值
切片
切片是一种对数组引用类型数据
常见实例：
var array[10]int //初始化一个数组
s := array[:5] //s是array的切片，长度是5