1.if语句
在go语言中，有一种特殊的if语句用法。
if statement，condition{
}
实例：
package main
import "fmt"
func main() {
//此处num为局部变量
if num := 4; num > 0 {
fmt.Printf("number=%d\n", num)
}
//此处为全局变量
num1 := 2
fmt.Println(num1)
}
结果：
number=4
2
2.随机数
调用rand关键字可以生成随机数，随机数是由一个源产生的，我们习惯叫它为种子。类型为整型。假如种子数相同，那么生成的随机数就相同。如果我们想让随机数不相同，那么就调用seed来改变随机数。
实例1：
package main
import (
"fmt"
"math/rand"
)
func main() {
num1 := rand.Int()
fmt.Println(num1)
}
结果：
5577006791947779410
注：因为种子数是固定的，所以不管运行多少次，结果都是一样的。
实例2：
for i := 0; i < 10; i++ {
num := rand.Intn(10) //Intn(n)代表的意思是随机生成一个[0,n)的数
fmt.Println(num)
}结果：
7
7
9
1
8
5
0
6
0
4
实例3(设置种子数)：
rand.Seed(10)
num := rand.Intn(10)
fmt.Println(num)结果：
4
实例4(改变种子数)：
rand.Seed(100)
num := rand.Intn(10)
fmt.Println(num)结果：
3
3.时间戳
那么，我们要想生成不同的随机数，该怎么操作呢。此时，我们便可想到时间，它是随机改变的。因此，我们可以利用时间来生成不同的随机数。时间戳：指定时间，距离1970年1月1日0时0分0秒之间的时间差值。有秒和纳秒，分别用Unix和Unixnano来访问。
实例1：
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now() //访问当前时间
fmt.Println(t)
fmt.Printf("%T", t)
}
结果：
2022-01-25 11:48:23.2344592 +0800 CST m=+0.003721801
time.Time（类型）
实例2：
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now() //访问当前时间
fmt.Println(t)
fmt.Printf("%T\n", t)
t1 := t.Unix()
fmt.Println(t1)
t2 := t.UnixNano()
fmt.Println(t2)
}结果：
2022-01-25 13:14:41.4386937 +0800 CST m=+0.003747301
time.Time
1643087681
1643087681438693700
实例3：
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
//设置种子数
rand.Seed(time.Now().UnixNano())
for i := 0; i < 10; i++ {
fmt.Println(rand.Intn(10))
}
}
结果：
9
2
7
9
9
0
9
2
8
6
实例4：
若想设置随机数在[n,m)之间（n！=0），那么格式如下：
rand.Seed(time.Now().Unix())
for i := 0; i < 10; i++ {
fmt.Println("-->",
rand.Intn(10)+3) //[3,13)
}4.遍历数组
实例1：
package main
import (
"fmt"
)
func main() {
var arr [5]int
for i := 0; i < len(arr); i++ {
arr[i] = 2*i + 1
}
fmt.Println(arr)
for index, number := range arr {
fmt.Printf("下标是：%d,数值是：%d\n", index, number)
}
}结果：
[1 3 5 7 9]
下标是：0,数值是：1
下标是：1,数值是：3
下标是：2,数值是：5
下标是：3,数值是：7
下标是：4,数值是：9
实例2：
//不想取值可以用下划线代替
for _, v := range arr {
sum += v
}
fmt.Println(sum)
sum1 := 0
for index1, _ := range arr {
sum1 += index1
}
fmt.Println(sum1)结果：
25
10
5.数组和切片复制
package main
import "fmt"
func main() {
arr := [4]int{0, 1, 2, 3}
arr1 := arr //值传递
arr[0] = 100
fmt.Println(arr, arr1)
s := []int{0, 1, 2, 3}
s1 := s
s[0] = 100
fmt.Println(s, s1)
}
结果：
[100 1 2 3] [0 1 2 3]
[100 1 2 3] [100 1 2 3]
可见，数组的复制是创建新地址来储存相同的数据，因此原数组arr改变不导致arr1改变。
而，切片的s是先获取数据的地址，s1的地址与s相同，因此两者一起改变。
如图：
6.map与slice的结合
package main
import "fmt"
func main() {
//第一个人
map1 := make(map[string]string)
map1["name"] = "Curry"
map1["number"] = "30"
map1["team"] = "Warriors"
//第二个人
map2 := make(map[string]string)
map2["name"] = "Thompson"
map2["number"] = "11"
map2["team"] = "Warriors"
//第三个人
map3 := make(map[string]string)
map3["name"] = "Doncic"
map3["number"] = "77"
map3["team"] = "Mavericks"
//将map存入slice中
s1 := make([]map[string]string, 0, 6)
s1 = append(s1, map1)
s1 = append(s1, map2)
s1 = append(s1, map3)
//遍历切片
for i, imfor := range s1 {
fmt.Printf("第%d个人的信息是：\n", i+1)
fmt.Printf("\t姓名:%s\n", imfor["name"])
fmt.Printf("\t号码:%s\n", imfor["number"])
fmt.Printf("\t球队:%s\n", imfor["team"])
}
}
结果：
第1个人的信息是：
姓名:Curry
号码:30
球队:Warriors
第2个人的信息是：
姓名:Thompson
号码:11
球队:Warriors
第3个人的信息是：
姓名:Doncic
号码:77
球队:Mavericks
7.长度和容量
切片的长度，显而易见的就是元素的个数，根据元素的个数进行返回具体的长度。
切片的长度，更像是一个警戒值，如果长度与容量相等，就会进行容量的扩容，比如
des :=make([]int , 3 , 5)
//此时，长度为3，容量为5，但是如果使用append()，
//切片长度会变为4，再次使用append()切片长度变为5。
//此时，切片长度与容量相同，此时，切片的容量增大变为cap = len*2
也就是通过一个容量设警戒值，如果等于警戒值，就会自动将切片进行扩容