1. Toy模板网首页
  2. > Toy博客

Go 语言数组

7月前 作者：242030 分类：Toy博客 阅读(21) 违法举报

这篇具有很好参考价值的文章主要介绍了Go 语言数组。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1、Go 语言数组

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

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

串或者自定义类型。

相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ...,

numbers[99] 更加方便且易于扩展。

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

此类推。

1.1 声明数组

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

var variable_name [SIZE] variable_type

以上为一维数组的定义方式，例如以下定义了数组 balance 长度为 10 类型为 float32：

var balance [10] float32

1.2 初始化数组

以下演示了数组初始化：

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

我们也可以通过字面量在声明数组的同时快速初始化数组：

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

如果数组长度不确定，可以使用 … 代替数组的长度，编译器会根据元素个数自行推断数组的长度：

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

如果设置了数组的长度，我们还可以通过指定下标来初始化元素：

//  将索引为1和3的元素初始化
balance := [5]float32{1:2.0,3:7.0}

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

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

balance[4] = 50.0

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

索引为 0，第二个索引为 1，以此类推。

1.3 访问数组元素

数组元素可以通过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值。例如：

var salary float32 = balance[9]

以上实例读取了数组 balance 第 10 个元素的值。

// 数组完整操作（声明、赋值、访问）
package main

import "fmt"

func main() {
	/* n 是一个长度为 10 的数组 */
	var n [10]int
	var i, j int
	/* 为数组 n 初始化元素 */
	for i = 0; i < 10; i++ {
		n[i] = i + 100 /* 设置元素为 i + 100 */
	}
	/* 输出每个数组元素的值 */
	/*
		Element[0] = 100
		Element[1] = 101
		Element[2] = 102
		Element[3] = 103
		Element[4] = 104
		Element[5] = 105
		Element[6] = 106
		Element[7] = 107
		Element[8] = 108
		Element[9] = 109
	*/
	for j = 0; j < 10; j++ {
		fmt.Printf("Element[%d] = %d\n", j, n[j])
	}
}

package main

import "fmt"

func main() {
	var i, j, k int
	// 声明数组的同时快速初始化数组
	balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
	/* 输出数组元素 */
	/*
		balance[0] = 1000.000000
		balance[1] = 2.000000
		balance[2] = 3.400000
		balance[3] = 7.000000
		balance[4] = 50.000000
	*/
	for i = 0; i < 5; i++ {
		fmt.Printf("balance[%d] = %f\n", i, balance[i])
	}
	balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
	/* 输出每个数组元素的值 */
	/*
		balance2[0] = 1000.000000
		balance2[1] = 2.000000
		balance2[2] = 3.400000
		balance2[3] = 7.000000
		balance2[4] = 50.000000
	*/
	for j = 0; j < 5; j++ {
		fmt.Printf("balance2[%d] = %f\n", j, balance2[j])
	}
	//  将索引为 1 和 3 的元素初始化
	/*
		balance3[0] = 0.000000
		balance3[1] = 2.000000
		balance3[2] = 0.000000
		balance3[3] = 7.000000
		balance3[4] = 0.000000
	*/
	balance3 := [5]float32{1: 2.0, 3: 7.0}
	for k = 0; k < 5; k++ {
		fmt.Printf("balance3[%d] = %f\n", k, balance3[k])
	}
}

2、Go 语言多维数组

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

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

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

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

2.1 二维数组

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

var arrayName [ x ][ y ] variable_type

variable_type 为 Go 语言的数据类型，arrayName 为数组名，二维数组可认为是一个表格，x 为行，y 为列。二

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

package main

import "fmt"

func main() {
	// Step 1: 创建数组
	values := [][]int{}
	// Step 2: 使用 append() 函数向空的二维数组添加两行一维数组
	row1 := []int{1, 2, 3}
	row2 := []int{4, 5, 6}
	values = append(values, row1)
	values = append(values, row2)
	// Step 3: 显示两行数据
	// Row 1
	fmt.Println("Row 1")
	// [1 2 3]
	fmt.Println(values[0])
	// Row 2
	fmt.Println("Row 2")
	// [4 5 6]
	fmt.Println(values[1])
	// Step 4: 访问第一个元素
	// 第一个元素为：
	fmt.Println("第一个元素为：")
	// 1
	fmt.Println(values[0][0])
}

2.2 初始化二维数组

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

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

注意：

以上代码中倒数第二行的}必须要有逗号，因为最后一行的}不能单独一行，也可以写成这样：

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

// 初始化一个 2 行 2 列 的二维数组
package main

import "fmt"

func main() {
	// 创建二维数组
	sites := [2][2]string{}
	// 向二维数组添加元素
	sites[0][0] = "Google"
	sites[0][1] = "Baidu"
	sites[1][0] = "Taobao"
	sites[1][1] = "Weibo"
	// 显示结果
	// [[Google Baidu] [Taobao Weibo]]
	fmt.Println(sites)
}

2.3 访问二维数组

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

val := a[2][3]
或
var value int = a[2][3]

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

package main

import "fmt"

func main() {
	/* 数组 - 5 行 2 列*/
	// 多维数组初始化或赋值时需要注意 Go 语法规范，该写在一行就写在一行，一行一条语句
	var a = [5][2]int{{0, 0}, {1, 2}, {2, 4}, {3, 6}, {4, 8}}
	var i, j int
	/* 输出数组元素 */
	/*
		a[0][0] = 0
		a[0][1] = 0
		a[1][0] = 1
		a[1][1] = 2
		a[2][0] = 2
		a[2][1] = 4
		a[3][0] = 3
		a[3][1] = 6
		a[4][0] = 4
		a[4][1] = 8
	*/
	for i = 0; i < 5; i++ {
		for j = 0; j < 2; j++ {
			fmt.Printf("a[%d][%d] = %d\n", i, j, a[i][j])
		}
	}
}

package main

import "fmt"

func main() {
	// 创建空的二维数组
	animals := [][]string{}
	// 创建三一维数组，各数组长度不同
	row1 := []string{"fish", "shark", "eel"}
	row2 := []string{"bird"}
	row3 := []string{"lizard", "salamander"}
	// 使用 append() 函数将一维数组添加到二维数组中
	animals = append(animals, row1)
	animals = append(animals, row2)
	animals = append(animals, row3)
	/*
		Row: 0
		[fish shark eel]
		Row: 1
		[bird]
		Row: 2
		[lizard salamander]
	*/
	// 循环输出
	for i := range animals {
		fmt.Printf("Row: %v\n", i)
		fmt.Println(animals[i])
	}
}

range方式循环二维数组：

package main

import "fmt"

func main() {
	arr := [...][]int{
		{1, 2, 3, 4},
		{10, 20, 30, 40},
	}
	/**
	1
	2
	3
	4
	10
	20
	30
	40
	*/
	for i := range arr {
		for j := range arr[i] {
			fmt.Println(arr[i][j])
		}
	}
}

package main

import (
	"fmt"
)

func main() {
	// 二维数组
	var value = [3][2]int{{1, 2}, {3, 4}, {5, 6}}
	// 遍历二维数组的其他方法，使用 range
	// 其实，这里的 i, j 表示行游标和列游标
	// v2 就是具体的每一个元素
	// v  就是每一行的所有元素
	/*
		value[0][0]=1    value[0][1]=2   [1 2]
		value[1][0]=3    value[1][1]=4   [3 4]
		value[2][0]=5    value[2][1]=6   [5 6]
	*/
	for i, v := range value {
		for j, v2 := range v {
			fmt.Printf("value[%v][%v]=%v \t ", i, j, v2)
		}
		fmt.Print(v)
		fmt.Println()
	}
}

3、Go 语言向函数传递数组

如果你想向函数传递数组参数，你需要在函数定义时，声明形参为数组，我们可以通过以下两种方式来声明：

// 方式一：形参设定数组大小
void myFunction(param [10]int){}

// 方式二：形参未设定数组大小
void myFunction(param []int){}

实例1：

// 实例中函数接收整型数组参数，另一个参数指定了数组元素的个数，并返回平均值
package main

import "fmt"

func main() {
	/* 数组长度为 5 */
	var balance = [5]int{1000, 2, 3, 17, 50}
	var avg float32
	/* 数组作为参数传递给函数 */
	avg = getAverage(balance, 5)
	/* 输出返回的平均值 */
	// 平均值为: 214.399994
	fmt.Printf("平均值为: %f ", avg)
}

func getAverage(arr [5]int, size int) float32 {
	var i, sum int
	var avg float32
	for i = 0; i < size; i++ {
		sum += arr[i]
	}
	avg = float32(sum) / float32(size)
	return avg
}

实例2：

package main

import (
	"fmt"
)

func main() {
	var array = []int{1, 2, 3, 4, 5}
	/* 未定义长度的数组只能传给不限制数组长度的函数 */
	setArray(array)
	/* 定义了长度的数组只能传给限制了相同数组长度的函数 */
	var array2 = [5]int{1, 2, 3, 4, 5}
	setArray2(array2)
}

func setArray(params []int) {
	// params array length of setArray is :  5
	fmt.Println("params array length of setArray is : ", len(params))
}

func setArray2(params [5]int) {
	// params array length of setArray2 is :  5
	fmt.Println("params array length of setArray2 is : ", len(params))
}

初始化数组长度后，元素可以不进行初始化，或者不进行全部初始化，但未进行数组大小初始化的数组初始化结果

元素大小就为多少。

3.1 多维数组传参

package main

import (
	"fmt"
)

func prt(arr [][]float32) {
	/*
	   -1
	   -3
	   -5
	*/
	for i := 0; i < 3; i++ {
		fmt.Println(arr[i][0])
	}
}

func main() {
	var arr = [][]float32{{-1, -2}, {-3, -4}, {-5}}
	prt(arr)
}

3.2 数组和切片的区别

// 声明数组
nums := [3]int{1,2,3}
// 声明切片
nums := []int{1,2,3}

没有所谓没有声明长度的数组存在。

Go 语言的数组是值，其长度是其类型的一部分，作为函数参数时，是值传递，函数中的修改对调用者不可见。

go 的数组作为函数参数传递的是副本，函数内修改数组并不改变原来的数组。

package main

import "fmt"

func change(nums [3]int) {
	nums[0] = 100
}

func main() {
	var nums = [3]int{1, 2, 3}
	//nums并未被改变
	change(nums)
	// 1
	fmt.Println(nums[0])
	return
}

Go 语言中对数组的处理，一般采用切片的方式，切片包含对底层数组内容的引用，作为函数参数时，类似于指

针传递，函数中的修改对调用者可见。文章来源地址https://www.toymoban.com/news/detail-496931.html

package main

import "fmt"

func change(nums []int) {
	nums[0] = 100
}

func main() {
	var nums = []int{1, 2, 3}
	//nums并未被改变
	change(nums)
	// 100
	fmt.Println(nums[0])
	return
}

3.3 引用传递

package main

import "fmt"

// Go 语言的数组是值，其长度是其类型的一部分，作为函数参数时，是值传递，函数中的修改对调用者不可见
func change1(nums [3]int) {
	nums[0] = 4
}

// 传递进来数组的内存地址，然后定义指针变量指向该地址，则会改变数组的值
func change2(nums *[3]int) {
	nums[0] = 5
}

// Go 语言中对数组的处理，一般采用切片的方式，切片包含对底层数组内容的引用，作为函数参数时，类似于指针传递，函数中的修改对调用者可见
func change3(nums []int) {
	nums[0] = 6
}

func main() {
	var nums1 = [3]int{1, 2, 3}
	var nums2 = []int{1, 2, 3}
	change1(nums1)
	//  [1 2 3]
	fmt.Println(nums1)
	change2(&nums1)
	//  [5 2 3]
	fmt.Println(nums1)
	change3(nums2)
	//  [6 2 3]
	fmt.Println(nums2)
}

到了这里，关于Go 语言数组的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • C语言数据结构一：动态数组

    先说一个概念：数组是一段 连续 的内存空间。存储相同的数据类型。 数组的两个关键点： 连续内存； 相同类型。 首先连续内存：所以为了找到动态数组我们必须找到一个 首元素 地址。（内存 首地址 。） 如果不知道首地址，那无法找到并操作内存空间。 知道首地址了，

    2024年02月06日
    浏览(35)

  • Go语言数据结构（一）双向链表

    Go语言中list容器定义在\\\"container/list\\\"包中，实现了一个双向链表。本文第一部分总结源码包中的方法，第二部分展示使用list包的常见示例用法以及刷题时的用法。 食用指南：先看第二部分的常用示例用法然后再用到时在第一部分找对应的方法。 更多内容以及其他Go常用数据结

    2024年01月19日
    浏览(30)

  • 掌握Go语言：Go语言结构体，精准封装数据，高效管理实体对象（22）

    在Go语言中，结构体（Struct）是一种自定义的数据类型，用于封装不同类型的数据字段。结构体可以看作是一种用户自定义的数据结构，用于组织和管理相关的数据。结构体由一组字段（Fields）组成，每个字段可以是不同的数据类型，可以是基本类型（如整数、浮点数、布尔

    2024年03月26日
    浏览(41)

  • 掌握Go语言：Go语言范围，优雅遍历数据结构，简化代码操作实战解析（24）

    在Go语言中，范围（range）用于迭代数组、切片、映射、通道等数据结构的元素。范围的语法形式为 for range ，可以遍历集合中的每个元素，并在每次迭代中返回元素的索引（或键）和对应的值。 Go语言范围使用方法 使用范围语句的一般形式为： 其中， index 是元素的索引（或

    2024年04月17日
    浏览(34)

  • 头歌（C语言）-数据结构与算法-数组（共7关）

    任务描述 本关任务:将十个数进行从大到小的顺序进行排列。 相关知识（略） 编程要求 根据提示，在右侧编辑器 Begin-End 处补充代码。 输入 输入十个整数。 输出 以从大到小的顺序输出这个十个数。 测试说明 样例输入： 1 2 3 4 5 6 7 8 9 10 样例输出： 10 9 8 7 6 5 4 3 2 1 代码：

    2024年02月11日
    浏览(31)
  • 【C语言 数据结构】数组与对称矩阵的压缩存储

    【C语言 数据结构】数组与对称矩阵的压缩存储

    提到数组，大家首先会想到的是：很多编程语言中都提供有数组这种数据类型，比如 C/C++、Java、Go、C# 等。但本节我要讲解的不是作为数据类型的数组，而是数据结构中提供的一种叫数组的存储结构。 和线性存储结构相比，数组最大的不同是：它存储的数据可以包含多种“一

    2024年02月04日
    浏览(37)

  • 【go语言】结构体数据填充生成md错误码文件

     这里使用pongo2这个模版引擎库进行md文件渲染GitHub - flosch/pongo2: Django-syntax like template-engine for Go Go 语言原生如下示例：

    2024年01月18日
    浏览(34)
  • C语言自定义数据类型（三）结构体指针

    C语言自定义数据类型（三）结构体指针

    所谓结构体指针就是指向结构体变量的指针，一个结构体变量的起始地址就是这个结构体变量的指针。如果把一个结构体变量的起始地址存放在一个指针变量中，那么，这个指针变量就指向该结构体变量。 目录 一、指向结构体变量的指针 1.1举例说明 二、指向结构体数组的指

    2024年02月06日
    浏览(34)
  • 数据结构与算法教程，数据结构C语言版教程！（第五部分、数组和广义表详解）三

    数据结构与算法教程，数据结构C语言版教程！（第五部分、数组和广义表详解）三

    数组和广义表，都用于存储逻辑关系为“一对一”的数据。 数组存储结构，99% 的编程语言都包含的存储结构，用于存储不可再分的单一数据；而广义表不同，它还可以存储子广义表。 本章重点从矩阵的角度讨论二维数组的存储，同时讲解广义表的存储结构以及有关其广度和

    2024年01月21日
    浏览(40)
  • 数据结构与算法教程，数据结构C语言版教程！（第五部分、数组和广义表详解）五

    数据结构与算法教程，数据结构C语言版教程！（第五部分、数组和广义表详解）五

    数组和广义表，都用于存储逻辑关系为“一对一”的数据。 数组存储结构，99% 的编程语言都包含的存储结构，用于存储不可再分的单一数据；而广义表不同，它还可以存储子广义表。 本章重点从矩阵的角度讨论二维数组的存储，同时讲解广义表的存储结构以及有关其广度和

    2024年01月23日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包