Go基础语法0x01-数组

2021年7月6日 5点热度 0条评论 来源: JasonCeng

数组

1、Go数组简介

数组是Go语言编程中最常用的数据结构之一。顾名思义,数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素(element),一个数组包含的元素个数被称为数组的长度。

在Go语言中数组是一个值类型(value type)。是真真实实的数组,而不是一个指向数组内存起始位置的指针,也不能和同类型的指针进行转化,这一点严重不同于C语言。所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。如果将数组作为函数的参数类型,则在函数调用时该参数将发生数据复制。因此,在函数体中无法修改传入的数组的内容,因为函数内操作的只是所传入数组的一个副本。

2、数组定义

定义方式如下

var arr [n]type

n表示数组长度,type表示数组存储类型。

在Go语言中,数组长度在定义后就不可更改,在声明时长度可以为一个常量或者一个常量表达式(常量表达式是指在编译期即可计算结果的表达式)。数组的长度是该数组类型的一个内置常量,可以用Go语言的内置函数len()来获取。

arrLength := len(arr)

3、常规声明方法

var a [5]byte //长度为5的数组,每个元素为一个字节
var b [2*N] struct { x, y int5 } //复杂类型数组
var c [5]*int // 指针数组
var d [2][3]int //二维数组
var e [2][3][4]int //等同于[2]([3]([4]int))

4、数组初始化

(1)先声明再初始化

a = {'1','2','3'}
d = {{1,2,3},{4,5,6}} 

(2)直接声明并初始化

a := [3]byte{'1', '2', '3'} //声明并初始化一个长度为3的byte数组
a := [...]byte{'1', '2', '3'} //可以省略长度而采用`...`的方式,Go会自动根据元素个数来计算长度
d := [2][3]int{[3]int{1,2,3},[3]int{4,5,6}}
d := [2][3]int{{1,2,3},{4,5,6}} //如果内部的元素和外部的一样,那么上面的声明可以简化,直接忽略内部的
类型

(3)示例

package main

import(
"fmt"
)

func main(){
    var arr1 [5]int
    arr2 := [5]int{1, 2, 3, 4, 5}   //指定长度为5,并赋5个初始值
    arr3 := [5]int{1, 2, 3}         //指定长度为5,对前3个元素进行赋值,其他元素为零值
    arr4 := [5]int{4: 1}            //指定长度为5,对第5个元素赋值
    arr5 := [...]int{1, 2, 3, 4, 5} //不指定长度,对数组赋以5个值
    arr6 := [...]int{8: 1}          //不指定长度,对第9个元素(下标为8)赋值1
    fmt.Println(arr1, arr2, arr3, arr4, arr5, arr6)
}

输出结果为:

[root@localhost mygo]# go run test.go 
[0 0 0 0 0] [1 2 3 4 5] [1 2 3 0 0] [0 0 0 0 1] [1 2 3 4 5] [0 0 0 0 0 0 0 0 1]

(4)创建并初始化数组的多种方式

package main

import "fmt"

func arraySliceTest()  {
	//数组初始化的各种方式

	//创建数组(声明长度)
	var array1 = [5]int{1, 2, 3}
	fmt.Printf("array1--- type:%T \n", array1)
	rangeIntPrint(array1[:])

	//创建数组(不声明长度)
	var array2 = [...]int{6, 7, 8}
	fmt.Printf("array2--- type:%T \n", array2)
	rangeIntPrint(array2[:])

	//创建数组切片
	var array3 = []int{9, 10, 11, 12}
	fmt.Printf("array3--- type:%T \n", array3)
	rangeIntPrint(array3)

	//创建数组(声明长度),并仅初始化其中的部分元素
	var array4 = [5]string{3: "Chris", 4: "Ron"}
	fmt.Printf("array4--- type:%T \n", array4)
	rangeObjPrint(array4[:])

	//创建数组(不声明长度),并仅初始化其中的部分元素,数组的长度将根据初始化的元素确定
	var array5 = [...]string{3: "Tom", 2: "Alice"}
	fmt.Printf("array5--- type:%T \n", array5)
	rangeObjPrint(array5[:])

	//创建数组切片,并仅初始化其中的部分元素,数组切片的len将根据初始化的元素确定
	var array6 = []string{4: "Smith", 2: "Alice"}
	fmt.Printf("array6--- type:%T \n", array6)
	rangeObjPrint(array6)
}

//输出整型数组切片
func rangeIntPrint(array []int) {
	for i, v := range array {
		fmt.Printf("index:%d  value:%d\n", i, v)
	}
}

//输出字符串数组切片
func rangeObjPrint(array []string) {
	for i, v := range array {
		fmt.Printf("index:%d  value:%s\n", i, v)
	}
}

func main()  {
	arraySliceTest();
}

输出如下:

array1--- type:[5]int 
index:0  value:1
index:1  value:2
index:2  value:3
index:3  value:0
index:4  value:0
array2--- type:[3]int 
index:0  value:6
index:1  value:7
index:2  value:8
array3--- type:[]int 
index:0  value:9
index:1  value:10
index:2  value:11
index:3  value:12
array4--- type:[5]string 
index:0  value:
index:1  value:
index:2  value:
index:3  value:Chris
index:4  value:Ron
array5--- type:[4]string 
index:0  value:
index:1  value:
index:2  value:Alice
index:3  value:Tom
array6--- type:[]string 
index:0  value:
index:1  value:
index:2  value:Alice
index:3  value:
index:4  value:Smith

5、数组元素访问

可以使用数组下标来访问数组中的元素。数组下标从0开始,len(arr)-1则表示最后一个元素的下标。

(1) 计算数组长度

通过go语言内置函数len

package main

import(
"fmt"
)

func main(){
    arr := [...]int {9: 1}
    fmt.Println(arr)
    fmt.Println(len(arr))
}

输出结果为:

[root@localhost mygo]# go run test.go 
[0 0 0 0 0 0 0 0 0 1]
10

(2)普通访问方式

for i := 0; i < len(arr); i++ {
    fmt.Println(i, arr[i])
}

例如:

package main

import(
"fmt"
)

func main(){
    arr := [5]int {1, 2, 3, 4, 5}
    for i := 0; i < len(arr); i++{
        fmt.Printf("arr[%d]=%d\n", i, arr[i])
    }
}

打印结果如下:

[root@localhost mygo]# go run test.go 
arr[0]=1
arr[1]=2
arr[2]=3
arr[3]=4
arr[4]=5

(3)通过range访问

for i, v := range arr {
    fmt.Println(i, v)
}

range具有两个返回值,第一个返回值i是元素的数组下标,第二个返回值v是元素的值。

例如:

package main

import(
"fmt"
)

func main(){
    arr := [5]int {1, 2, 3, 4, 5}
    for i, v := range(arr) {
        fmt.Printf("arr[%d]=%d\n", i, v)
    }
}

打印结果如下:

[root@localhost mygo]# go run test.go 
arr[0]=1
arr[1]=2
arr[2]=3
arr[3]=4
arr[4]=5

6、数组值传递

例如:

package main

import(
"fmt"
)

func modify(arr [5]int){
   arr[0] = 10
   fmt.Println("In modify(), arr values:", arr)
}

func main(){
    arr := [5]int{1, 2, 3, 4, 5}
    modify(arr)
    fmt.Println("In main(), arr values:", arr)
}

输出结果为:

[root@localhost mygo]# go run test.go 
In modify(), arr values: [10 2 3 4 5]
In main(), arr values: [1 2 3 4 5]

参考

[1]https://studygolang.com/articles/1177

[2]https://studygolang.com/articles/3816

(全文完)

更多关于大数据、分布式、存储、区块链、Linux相关文章请关注微信公众号:asympTech渐进线实验室

Github、知乎、博客园、CSDN、简书全网唯一id:JasonCeng

技术人,不白嫖,如果您觉得文章对您有帮助,帮忙点个推荐吧~

    原文作者:JasonCeng
    原文地址: https://www.cnblogs.com/JasonCeng/p/14974180.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。