go语言数组是值类型,切片是引用类型,定义二维数组,循环二维数组

基本数据类型和数组都是值类型

package main
import ("fmt")
// 入口函数
func main()  {
  var  arr1=[...]int{1,2,3}
  arr2 := arr1
  // 改变副本的值，不会改变本身的值
  arr1[0]=11
  fmt.Println(arr1)
  fmt.Println(arr2)
}

输出：
[11 2 3]
[1 2 3]

golang中怎么区别数组和切片？

在 Go 语言中，核心就看类型声明中方括号里有没有数字。

a := [3]int{1,2,3} // 数组;方括号里面有数字和扩展运算符是：数组
b := []int{1,2,3}  // 切片;方括号里面没有数字和扩展运算符是：切片
fmt.Printf("%T, %T", a, b) // 输出: [3]int, []int

切片是引用数据类型

package main
import ("fmt")
// 入口函数
func main()  {
  // 不是一个数组，是一个切片
  var  arr1=[]int{1,2,3}
  arr2 := arr1
  // 改变变量副本值的时候，会改变变量本身的值
  arr1[0]=1100
  fmt.Println(arr1)
  fmt.Println(arr2)
}

输出的是：
[1100 2 3]
[1100 2 3]

切片是引用数据类型(2)

package main
import ("fmt")
// 入口函数
func main()  {
  var  arr1=[]int{1,2,3}
  arr2 := arr1
  // 改变变量副本值的时候，会改变变量本身的值
  arr2[0]=1144
  fmt.Println(arr1)
  fmt.Println(arr2)
}

[1144 2 3]
[1144 2 3]

值类型和引用类型

值类型: 改变变量副本值的时候，不会改变变量本身的值
引用类型:改变变量副本值的时候，会改变变量本身的值

定义二维数组

package main
import ("fmt")
// 入口函数
func main()  {
  // 定义一个二维数组。外面3层里面2层
  var  arr=[3][2]string{
    { "A1", "A2"},
    { "B1", "B2"},
    { "C1","C2"},
  }
  fmt.Println(arr[0])
}

输出：[A1 A1]

定义二维数组的另外一种方式

package main
// 入口函数
func main()  {
  // 定义一个二维数组。外面3层里面2层
  var  arr=[...][2]string{
    { "A1", "A2"},
    { "B1", "B2"},
    { "C1","C2"},
  }
}

循环遍历二维数组

port ("fmt")
// 入口函数
func main()  {
  // 定义一个二维数组。外面3层里面2层
  var  arr=[3][2]string{
    { "A1", "A2"},
    { "B1", "B2"},
    { "C1","C2"},
  }
  for _, v1 :=range arr{
    for _, v2 :=range v1{
      fmt.Println(v2)
    }
  }
}

#### 循环遍历二维数组(2)

package main
import ("fmt")
// 入口函数
func main()  {
  // 定义一个二维数组。外面3层里面2层
  var  arr=[3][2]string{
    { "A1", "A2"},
    { "B1", "B2"},
    { "C1","C2"},
  }
  for i := 0; i < len(arr); i++ {
    for j := 0; j < len(arr[i]); j++ {
            fmt.Println(arr[i][j])
    }
  }
}