Go语法复习 2

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

也就是通过一个容量设警戒值，如果等于警戒值，就会自动将切片进行扩容