一篇文章带你了解Go语言基础之数组

开发 后端
这篇文章我们继续介绍Go语言基础知识,今天跟大家分享的是基础数据类型之数组,一起来学习下吧~

[[347712]]

 前言
Hey,大家好呀,我是星期八,这次咱们继续学习Go基础之数组扒。

 

什么是数组
我的总结:一个变量,指向一块连续的,具有长度的,并且是相同类型的一块内存。

如何定义数组

  1. var 变量名 [元素个数]元素类型 

示例:

  1. package main 
  2.  
  3. func main() { 
  4.     //声明一个name_list数组,长度为100,里面只能放字符串 
  5.     var name_list [100]string 

注:

  1. var 变量名 [元素个数]元素类型 等同于 var 变量名 变量类型 
  2. 所以 
  3. var name1 [3]int != var name2 [4]int 
  4. 因为变量类型是不一样,不可以直接进行赋值 

数组初始化

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func main() { 
  6.     //方式一,声明不赋值 
  7.     //var name_list [10]int 
  8.     //fmt.Println(name_list) //结果:[0 0 0 0 0 0 0 0 0 0] 声明不赋值,int类型默认是0,其他类型也有默认值 
  9.     // 
  10.     //方式二, 声明没有赋值完 
  11.     //var name_list [10]int = [10]int{1, 3} 
  12.     //fmt.Println(name_list) //结果:[1 3 0 0 0 0 0 0 0 0],没有赋值完的,其他仍然是默认值 
  13.  
  14.     //方式三,声明完完全赋值 
  15.     //var name_list = [3]int{1, 6, 10} //使用类型推断方式,同上 
  16.     //fmt.Println(name_list)           //结果:[1 6 10],每个都有值,没啥可说的 
  17.  
  18.     //方式四,自动推断个数 
  19.     //var name_list = [...]int{1, 2, 4, 5, 19} //...表示自动推断个数,不会存在过多或者过少 
  20.     //fmt.Println(name_list)                   //结果:[1 2 4 5 19] 
  21.  
  22.     //方式五,指定索引方式赋值,用的很少 
  23.     var name_list = [...]int{1: 66, 4: 11} //下标1赋值为66,下标4赋值11,其他默认值 
  24.     fmt.Println(name_list)                 //结果:[0 66 0 0 11] 

数组遍历

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func main() { 
  6.     var name_list = [...]string{"张三", "李四", "王五", "小刘"
  7.     //方式一,普通for遍历 
  8.     //for i := 0; i < len(name_list); i++ { 
  9.     //fmt.Println(name_list[i]) 
  10.     //} 
  11.  
  12.     //方式二,for range方式 
  13.     for index, name := range name_list { 
  14.         //index是每个的下标,name是值 
  15.         fmt.Println(index, name
  16.   } 

多维数组
二维数组
通常情况下,二维数组基本够用,最多三维数组,再套娃就完犊子了。

定义一个二维数组

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func main() { 
  6.     //定义一个三行两列的一个数组 
  7.     var student_list = [3][2]string{ 
  8.         // 列     列 
  9.         {"张三", "李四"}, //行 
  10.         {"王五", "小刘"}, //行 
  11.         {"小七", "王八"}, //行 
  12.     fmt.Println(student_list) 

循环二维数组
同理,定义一个二维数组需要两层,循环也需要两层。

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func main() { 
  6.     //定义一个三行两列的一个数组 
  7.     var student_list = [3][2]string{ 
  8.         // 列     列 
  9.         {"张三", "李四"}, //行 
  10.         {"王五", "小刘"}, //行 
  11.         {"小七", "王八"}, //行 
  12.     //方式一,普通for循环 
  13.     //for i := 0; i < len(student_list); i++ { 
  14.     ////fmt.Println(student_list[i])//每行 
  15.     ///* 
  16.     //      [张三 李四] 
  17.     //      [王五 小刘] 
  18.     //      [小七 王八] 
  19.     //*/ 
  20.     //for j := 0; j < len(student_list[i]); j++ { 
  21.     //      //每列 
  22.     //      fmt.Println(student_list[i][j]) 
  23.     //} 
  24.     //} 
  25.  
  26.     //方式二,for range 
  27.     for _, v := range student_list { 
  28.         //fmt.Println(v) //每行 
  29.         /* 
  30.             [张三 李四] 
  31.             [王五 小刘] 
  32.             [小七 王八] 
  33.         */ 
  34.         for _, b := range v { 
  35.             //每列 
  36.             fmt.Println(b) 
  37.         } 
  38.   } 

多维数组是否可以长度推导
代码

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func main() { 
  6.     //定义一个三行两列的一个数组 
  7.     var student_list = [...][...]string{ 
  8.         // 列     列 
  9.         {"张三", "李四"}, //行 
  10.         {"王五", "小刘"}, //行 
  11.         {"小七", "王八"}, //行 
  12.     fmt.Println(student_list) 

报错

似乎是不可以的,那我只用第一层试试呢。

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func main() { 
  6.   //定义一个三行两列的一个数组 
  7.   var student_list = [...][2]string{ 
  8.     // 列     列 
  9.     {"张三", "李四"}, //行 
  10.     {"王五", "小刘"}, //行 
  11.     {"小七", "王八"}, //行 
  12.   } 
  13.   fmt.Println(student_list) 

注:可以得出结论,在第一层时,是可以实现长度自动推导的。

 

责任编辑:姜华 来源: Go语言进阶学习
相关推荐

2020-11-05 09:58:16

Go语言Map

2022-02-16 10:03:06

对象接口代码

2020-11-11 10:52:54

Go语言C语言

2020-12-09 09:59:32

Go语言技术

2020-10-25 07:33:13

Go语言

2022-04-27 10:01:43

切片Go封装

2020-10-23 08:38:19

Go语言

2020-12-27 10:15:44

Go语言channel管道

2020-12-30 09:04:32

Go语言TCPUDP

2021-10-09 07:10:31

Go语言基础

2021-10-30 10:43:04

语言Go函数

2021-11-03 10:02:07

Go基础函数

2020-12-07 05:59:02

语言Go接口

2021-09-29 10:00:07

Go语言基础

2021-10-13 10:00:52

Go语言基础

2020-10-22 11:15:47

Go语言变量

2021-10-16 10:17:51

Go语言数据类型

2020-12-23 08:39:11

Go语言基础技术

2021-02-20 10:06:14

语言文件操作

2021-01-13 08:40:04

Go语言文件操作
点赞
收藏

51CTO技术栈公众号