数组

数组是一个长度固定的数据类型，用于存储一段具有相同类型的元素的连续块。其占有的内存是连续的。

基础使用

package main
​
import "fmt"
​
func main(){
​
  // 声明一个数组，并设置为0值
  var arr[5] int
  fmt.Println(arr)
​
  // 使用数组字面量声明
  arr1 := [5]int{1,2,3,4,5}
  fmt.Println(arr1)
​
  // 让编译器自动计算数组长度
  arr2 := [...]int{5,4,3,2,1,0}
  fmt.Println(arr2)
​
  // 声明数组并制定特定元素的值
  arr3 := [...]int{1:10 ,2:20}
  fmt.Println(arr3)
​
  arr3[0] = 50
​
  // 声明二维数组并初始化
  var arr4 [4][2]int
  fmt.Println(arr4)
​
  arr5 := [4][2]int{{1,2},{3,4},{5,6},{7,8}}
  fmt.Println(arr5)
​
​
  // 数组可以直接拷贝
  var str1[3] string
  str2 := [3]string{"binshow" , "zkd" , "love"}
  str1 = str2
  fmt.Println("str1 = " , str1)
  fmt.Println("str2 = " , str2)
​
}
​
​

函数间传递

在Go中函数之间传递变量时，都是以值的方式来进行传递的。如果变量时一个数组，那拷贝整个数组开销太大了！

所以一般数组的传递就只传递数组的指针就好了，这样只需要8个字节：

package main
​
import "fmt"
​
func main(){
  str := [3]string{"binshow" , "zkd" , "love"}
  fmt.Println("str = " , str)
  foo(&str)
  fmt.Println("After foo : str = " , str)
}
​
// 因为传递的是指针，所以在函数中修改数组，原数组也会跟着一起变
func foo(arr *[3]string) {
  arr[2] = "forever"
  return
}
​
​

切片

切片是一个很小的对象，对底层数组进行了抽象并提供了相应了操作方法。

切片由三个字段组成：指向底层数组的指针、长度、容量。

基本使用

package main
​
import "fmt"
​
func main(){
​
  // 创建一个字符串切片，其长度和容量都是5
  slice1 := make([]string , 5)
  fmt.Println(slice1)
​
  // 创建一个字符串切片，长度为3，容量为5
  slice2 := make([]string , 3 , 5)
  fmt.Println(slice2)
​
  // 声明切片
  slice3 := []string{"binshow" , "zkd" ,"love"}
  fmt.Println(slice3)
​
  // 声明数组和声明切片的区别
  arr := [3]int{1,2,3}
  slice4 := []int{1,2,3}
  fmt.Println(arr , slice4)
​
  // 切片增长： 如果切片的底层数组还有额外的容量可以使用，append操作就会将可用的元素合并到切片的长度，并进行赋值。
  //      和原来的slice共享同一个底层数组。 如果切片的底层数组没有足够的额外容量，则append函数会创建一个新的底层数组。将现有的值复制到新数组中
  slice4 = append(slice4 , 5)
  fmt.Println(slice4)
​
  // 迭代切片
  for i ,v := range slice4{
    fmt.Printf("index : %d , value : %d \n" , i , v)
  }
​
}
​
​

函数间传递

映射

基本使用

package main
​
import "fmt"
​
func main(){
​
  // 创建一个map , key 为string，value为int类型
  dict1 := make(map[string]int)
  fmt.Println(dict1)
​
  // 初始化一个map
  dict2 := map[string]string{"Red" : "#da1337" , "Orange" : "#e95a22"}
  fmt.Println(dict2)
​
  // 添加映射
  dict2["Blue"] = "#da3735"
  fmt.Println(dict2)
​
  // 判断键是否存在
  value , exists := dict2["Yellow"]
  if exists {
    fmt.Println("value = " , value)
  }
​
  value = dict2["Blue"]
  if value != " " {
     fmt.Println("value = " , value)
  }
​
  // 迭代map
  for key , value := range dict2{
    fmt.Printf("key : %s , value : %s \n" , key ,value)
  }
​
  // map中删除键值对
  delete(dict2 , "Red")
  fmt.Println("after delete red: ")
  for key , value := range dict2{
    fmt.Printf("key : %s , value : %s \n" , key ,value)
  }
​
}
​
​

函数间传递

package main
​
import "fmt"
​
func main(){
​
  // 创建一个map , key 为string，value为int类型
  dict1 := make(map[string]int)
  fmt.Println(dict1)
​
  // 初始化一个map
  dict2 := map[string]string{"Red" : "#da1337" , "Orange" : "#e95a22"}
  fmt.Println(dict2)
​
  // 添加映射
  dict2["Blue"] = "#da3735"
  fmt.Println(dict2)
​
​
  // 迭代map
  for key , value := range dict2{
    fmt.Printf("key : %s , value : %s \n" , key ,value)
  }
​
  // 传递参数,原来的map也改变了，说明和切片一样，传递的是地址
  removeColor(dict2 , "Blue")
​
  fmt.Println("after removeColor function: ")
  for key , value := range dict2{
    fmt.Printf("key : %s , value : %s \n" , key ,value)
  }
​
}
​
func removeColor(dict map[string]string , key string){
  delete(dict , key)
}
​