三天掌握Go语言入门知识之第二天

数组

---

数组的定义

Go 语言提供了数组类型的数据结构

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。

相对于去声明number0, number1, …, and number99的变量，使用数组形式numbers[0], numbers[1] …, numbers[99]更加方便且易于扩展。

数组元素可以通过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为 0，第二个索引为 1，以此类推

---

声明数组

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type

以上为一维数组的定义方式。数组长度必须是整数且大于 0。例如以下定义了数组 balance 长度为 10 类型为 float32：

var balance [10] float32

---

数组的初始化

以下演示了数组初始化：

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

初始化数组中 {} 中的元素个数不能大于 [] 中的数字。

如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

 var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

该实例与上面的实例是一样的，虽然没有设置数组的大小。

 balance[4] = 50.0

以上实例读取了第五个元素。数组元素可以通过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为 0，第二个索引为 1，以此类推

---

访问数组元素

Go语言中的数组访问同其他语言中的数组一样，都是通过数组下标进行访问

---

多维数组

Go 语言支持多维数组，以下为常用的多维数组声明方式：

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

以下实例声明了三维的整型数组：

var threedim [5][10][4]int

---

二维数组

二维数组是最简单的多维数组，二维数组本质上是由一维数组组成的。二维数组定义方式如下：

var arrayName [ x ][ y ] variable_type

variable_type 为 Go 语言的数据类型，arrayName 为数组名，二维数组可认为是一个表格，x 为行，y 为列，下图演示了一个二维数组 a 为三行四列：

二维数组中的元素可通过 a[ i ][ j ] 来访问。

---

初始化二维数组

多维数组可通过大括号来初始值。以下实例为一个 3 行 4 列的二维数组：

a = [3][4]int{   {0, 1, 2, 3} ,   /*  第一行索引为 0 */ 
{4, 5, 6, 7} ,   /*  第二行索引为 1 */ 
{8, 9, 10, 11}   /*  第三行索引为 2 */
}

---

访问二维数组

二维数组通过指定坐标来访问。如数组中的行索引与列索引，例如：

int val = a[2][3]

以上实例访问了二维数组 val 第三行的第四个元素

二维数组的遍历是通过嵌套循环进行访问的

package main import "fmt" func main() {   
    /* 数组 - 5 行 2 列*/   
    var a = [5][2]int{ {0,0}, {1,2}, {2,4}, {3,6},{4,8}}   
    var i, j int    
    /* 输出数组元素 */   
    for  i = 0; i < 5; i++ {      
        for j = 0; j < 2; j++ {         
            fmt.Printf("a[%d][%d] = %d\n", i,j, a[i][j] )      
        }   
    }
}

切片

---

Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

---

定义切片

你可以声明一个未指定大小的数组来定义切片：

var identifier []type

切片不需要说明长度。

或使用make()函数来创建切片:

var slice1 []type = make([]type, len) 也可以简写为 slice1 := make([]type, len)

也可以指定容量，其中capacity为可选参数。

make([]T, length, capacity)

这里 len 是数组的长度并且也是切片的初始长度。

---

切片初始化

s :=[] int {1,2,3 } 

直接初始化切片，[]表示是切片类型，{1,2,3}初始化值依次是1,2,3.其cap=len=3

s := arr[:] 

初始化切片s,是数组arr的引用

s := arr[startIndex:endIndex] 

将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片

s := arr[startIndex:] 

缺省endIndex时将表示一直到arr的最后一个元素

s := arr[:endIndex] 

缺省startIndex时将表示从arr的第一个元素开始

s1 := s[startIndex:endIndex] 

通过切片s初始化切片s1

s :=make([]int,len,cap) 

通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片

---

len() 和 cap() 函数

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

以下为具体实例：

package main import "fmt" func main() {   
    var numbers = make([]int,3,5)    
    printSlice(numbers)
} 
func printSlice(x []int){   
    fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

以上实例运行输出结果为:

len=3 cap=5 slice=[0 0 0]

---

空(nil)切片

一个切片在未初始化之前默认为 nil，长度为 0，实例如下：

package main import "fmt" func main() {   
    var numbers []int    
    printSlice(numbers)    
    if(numbers == nil){      
        fmt.Printf("切片是空的")   
    }
}
func printSlice(x []int){   
    fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

以上实例运行输出结果为:

len=0 cap=0 slice=[]  //切片是空的

---

切片截取

可以通过设置下限及上限来设置截取切片 [lower-bound:upper-bound]，实例如下：

package main import "fmt" func main() {   
    /* 创建切片 */   
    numbers := []int{0,1,2,3,4,5,6,7,8}
    printSlice(numbers)    	/* 打印原始切片 */   
    fmt.Println("numbers ==", numbers)    /* 打印子切片从索引1(包含) 到索引4(不包含)*/
    fmt.Println("numbers[1:4] ==", numbers[1:4])	/* 默认下限为 0*/   
    fmt.Println("numbers[:3] ==", numbers[:3])    /* 默认上限为 len(s)*/   
    fmt.Println("numbers[4:] ==", numbers[4:])    numbers1 := make([]int,0,5)   
    printSlice(numbers1)    /* 打印子切片从索引  0(包含) 到索引 2(不包含) */   
    number2 := numbers[:2]   printSlice(number2)    /* 打印子切片从索引 2(包含) 到索引 5(不包含) */   
    number3 := numbers[2:5]   printSlice(number3) 
}
func printSlice(x []int){   
    fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

执行以上代码输出结果为：

len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len=0 cap=5 slice=[]
len=2 cap=9 slice=[0 1]
len=3 cap=7 slice=[2 3 4]

---

append() 和 copy() 函数

如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。

下面的代码描述了从拷贝切片的 copy 方法和向切片追加新元素的 append 方法。

package main import "fmt" func main() {   
    var numbers []int   
    printSlice(numbers)    
    /* 允许追加空切片 */  
    numbers = append(numbers, 0)   
    printSlice(numbers)   
    /* 向切片添加一个元素 */   
    numbers = append(numbers, 1)   
    printSlice(numbers)    
    /* 同时添加多个元素 */   
    numbers = append(numbers, 2,3,4)  
    printSlice(numbers)    
    /* 创建切片 numbers1 是之前切片的两倍容量*/   
    numbers1 := make([]int, len(numbers), (cap(numbers))*2)   
    /* 拷贝 numbers 的内容到 numbers1 */   
    copy(numbers1,numbers)   
    printSlice(numbers1)   
}
func printSlice(x []int){   
    fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

注： append添加数据 (不超过切片的容量，切片地址不会改变)，append添加数据 (超过切片的容量，切片地址可能会改变) (扩容，容量成倍数进行扩容(偶数);1024字节以上，每次扩容1/4)

---

键值对 Map

map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用

map定义

Go语言中 map的定义语法如下

    map[KeyType]ValueType

其中，

• ​ KeyType:表示键的类型。

• ​ ValueType:表示键对应的值的类型。

map类型的变量默认初始值为nil，需要使用make()函数来分配内存。语法为：

    make(map[KeyType]ValueType, [cap])

其中cap表示map的容量，该参数虽然不是必须的，但是我们应该在初始化map的时候就为其指定一个合适的容量

map初始化

map初始化可以通过定义时直接填充初始化，例如

func main() {
    userInfo := map[string]string{
        "username": "halley",
        "sex": "man",
    }
    fmt.Println(userInfo) 
}

map也可以通过Go内嵌的make方法进行初始化：

func main() {
    scoreMap := make(map[string]int, 8)
    scoreMap["张三"] = 90
    scoreMap["小明"] = 100
    fmt.Println(scoreMap)
    fmt.Println(scoreMap["小明"])
    fmt.Printf("type of a:%T\n", scoreMap)
}   

判断某个键是否存在

Go语言中有个判断map中键是否存在的特殊写法，格式如下:

value, ok := map[key]   

举个例子：

func main() {
    scoreMap := make(map[string]int)
    scoreMap["张三"] = 90
    scoreMap["小明"] = 100
    // 如果key存在ok为true,v为对应的值；不存在ok为false,v为值类型的零值
    v, ok := scoreMap["张三"]
    if ok {
        fmt.Println(v)
    } else {
        fmt.Println("查无此人")
    }
}  

map的遍历

Go语言中使用for range遍历map。

func main() {
    scoreMap := make(map[string]int)
    scoreMap["张三"] = 90
    scoreMap["小明"] = 100
    scoreMap["王五"] = 60
    for k, v := range scoreMap {	//顺序键前值后
        fmt.Println(k, v)
    }
}  

但我们只想遍历key的时候，可以按下面的写法：

func main() {
    scoreMap := make(map[string]int)
    scoreMap["张三"] = 90
    scoreMap["小明"] = 100
    scoreMap["王五"] = 60
    for k := range scoreMap {
        fmt.Println(k)
    }
}  

注意： 遍历map时的元素顺序与添加键值对的顺序无关，遍历会随机访问

使用delete()函数删除键值对

使用delete()内建函数从map中删除一组键值对，delete()函数的格式：delete(map, key) ，其中，

• map: 表示要删除键值对的
• mapkey: 表示要删除的键值对的键

示例代码如下：

func main(){
    scoreMap := make(map[string]int)
    scoreMap["张三"] = 90
    scoreMap["小明"] = 100
    scoreMap["王五"] = 60
    delete(scoreMap, "小明")//将小明:100从map中删除
    for k,v := range scoreMap{
        fmt.Println(k, v)
    }
}  

元素为map类型的切片

下面的代码演示了切片中的元素为map类型时的操作：

func main() {
    var mapSlice = make([]map[string]string, 3)
    for index, value := range mapSlice {
        fmt.Printf("index:%d value:%v\n", index, value)
    }
    fmt.Println("after init")
    // 对切片中的map元素进行初始化
    mapSlice[0] = make(map[string]string, 10)
    mapSlice[0]["name"] = "王五"
    mapSlice[0]["password"] = "123456"
    mapSlice[0]["address"] = "红旗大街"
    for index, value := range mapSlice {
        fmt.Printf("index:%d value:%v\n", index, value)
    }
} 

值为切片类型的map

下面的代码演示了map中值为切片类型的操作：

func main() {
    var sliceMap = make(map[string][]string, 3)
    fmt.Println(sliceMap)
    fmt.Println("after init")
    key := "中国"
    value, ok := sliceMap[key]
    if !ok {
        value = make([]string, 0, 2)
    }
    value = append(value, "北京", "上海")
    sliceMap[key] = value
    fmt.Println(sliceMap)
}

通道 channel

单纯地将函数并发执行是没有意义的。函数与函数间需要交换数据才能体现并发执行函数的意义。

虽然可以使用共享内存进行数据交换，但是共享内存在不同的goroutine中容易发生竞态问题。为了保证数据交换的正确性，必须使用互斥量对内存进行加锁，这种做法势必造成性能问题。

Go语言的并发模型是CSP（Communicating Sequential Processes），提倡通过通信共享内存而不是通过共享内存而实现通信。

如果说goroutine是Go程序并发的执行体，channel就是它们之间的连接。channel是可以让一个goroutine发送特定值到另一个goroutine的通信机制。

Go 语言中的通道（channel）是一种特殊的类型。通道像一个传送带或者队列，总是遵循先入先出（First In First Out）的规则，保证收发数据的顺序。每一个通道都是一个具体类型的导管，也就是声明channel的时候需要为其指定元素类型

声明通道

channel是一种引用类型，通道声明格式如下：

var 变量名 chan 类型

例如：

 var ch1 chan int   // 声明一个传递整型的通道
 var ch2 chan bool  // 声明一个传递布尔型的通道
 var ch3 chan []int // 声明一个传递int切片的通道    

创建通道

通道是引用类型，通道类型的空值是nil，如果不对通道进行初始化，分配内存空间，那么通道无法进行接收和发送操作

var ch chan int
fmt.Println(ch) // <nil>

声明的通道后需要使用make函数初始化之后才能使用。

创建channel的格式如下：

    make(chan 元素类型, [缓冲大小])   

channel的缓冲大小是可选的。

举几个例子：

ch4 := make(chan int,10)	//创建能够容纳10个int型变量的通道
ch5 := make(chan bool,2)
ch6 := make(chan []int,4)   // 

通道的操作

通道有发送（send）、接收(receive）和关闭（close）三种操作。

发送和接收都使用<-符号。

现在我们先使用以下语句定义一个通道：

ch := make(chan int)    

发送

将一个值发送到通道中。

ch <- 10 // 把10发送到ch中   

接收

从一个通道中接收值。

x := <- ch // 从ch中接收值并赋值给变量x
<-ch       // 从ch中接收值，忽略结果   

关闭

我们通过调用内置的close函数来关闭通道。

 close(ch)   //关闭通道

关于关闭通道需要注意的事情是，只有在通知接收方goroutine所有的数据都发送完毕的时候才需要关闭通道。通道是可以被垃圾回收机制回收的，它和关闭文件是不一样的，在结束操作之后关闭文件是必须要做的，但关闭通道不是必须的。

关闭后的通道有以下特点：

1. 对一个关闭的通道再发送值就会导致panic。
2. 对一个关闭的通道进行接收会一直获取值直到通道为空。
3. 对一个关闭的并且没有值的通道执行接收操作会得到对应类型的零值。
4. 关闭一个已经关闭的通道会导致panic。

通道的简单使用

func main() {
	//var ch1 = make(chan int, 2)
	var ch1 chan int			//声明一个int型的通道
	ch1 = make(chan int, 2)		//给通道分配内存（必须）存入数据不能大于分配空间
	defer close(ch1)			//延迟关闭通道
	go func() { ch1 <- calculate(3, 4); ch1 <- calculate(5, 6) }()	//开启协程
	for i := range ch1 {		//主线程
		fmt.Println(i)
	}
}
func calculate(a int, b int) int {
	return a + b
}