go語言元組指的是什么

這篇文章主要講解了“go語言元組指的是什么”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“go語言元組指的是什么”吧！

元組是固定長度不可變的順序容器（元素序列），go語言中沒有元組類型，數組就相當于元組。在go語言中，數組是一個由固定長度的特定類型元素組成的序列，一個數組可以由零個或多個元素組成；數組的聲明語法為“var 數組變量名 [元素數量]Type”。

什么是元組

元組（tuple）：固定長度不可變的順序容器，訪問效率高，適合存儲一些長常量數據。

簡單的理解就是將一堆數據存放到一個容器中，但這個容器有一個特點，就是很固執，一旦定義了之后就不可改變，從某種意義上來說元組就是不可以改變的列表，功能和列表類似，同樣可以進行切片、修改等操作。

go語言中沒有元組類型

go語言中的數組相當于python中的元組。

數組是一個由固定長度的特定類型元素組成的序列，一個數組可以由零個或多個元素組成。

Go語言中的數組

數組的聲明

數組的聲明語法如下：

var 數組變量名 [元素數量]Type

語法說明如下所示：

• 數組變量名：數組聲明及使用時的變量名。

• 元素數量：數組的元素數量，可以是一個表達式，但最終通過編譯期計算的結果必須是整型數值，元素數量不能含有到運行時才能確認大小的數值。

• Type：可以是任意基本類型，包括數組本身，類型為數組本身時，可以實現多維數組。

在 Go 語言中 ， 要創建數組， 可聲明一個數組變量，并指定其長度和數據類型。

只包含兩個元素，無法給第 3 個元素賦值，因此這將導致編 譯階段錯誤。

var cheeses [2]string
cheeses[O] = "Mar iolles”
cheeses[l] = ” Epoisses de Bourgogne ”

數組的每個元素都可以通過索引下標來訪問，索引下標的范圍是從 0 開始到數組長度減 1 的位置，內置函數 len() 可以返回數組中元素的個數。

var a [3]int             // 定義三個整數的數組
fmt.Println(a[0])        // 打印第一個元素
fmt.Println(a[len(a)-1]) // 打印最后一個元素
// 打印索引和元素
for i, v := range a {
    fmt.Printf("%d %d\n", i, v)
}
// 僅打印元素
for _, v := range a {
    fmt.Printf("%d\n", v)
}

默認情況下，數組的每個元素都會被初始化為元素類型對應的零值，對于數字類型來說就是 0，同時也可以使用數組字面值語法，用一組值來初始化數組：

var q [3]int = [3]int{1, 2, 3}
var r [3]int = [3]int{1, 2}
fmt.Println(r[2]) // "0"

在數組的定義中，如果在數組長度的位置出現“...”省略號，則表示數組的長度是根據初始化值的個數來計算，因此，上面數組 q 的定義可以簡化為：

q := [...]int{1, 2, 3}
fmt.Printf("%T\n", q) // "[3]int"

數組的長度是數組類型的一個組成部分，因此 [3]int 和 [4]int 是兩種不同的數組類型，數組的長度必須是常量表達式，因為數組的長度需要在編譯階段確定。

q := [3]int{1, 2, 3}
q = [4]int{1, 2, 3, 4} // 編譯錯誤：無法將 [4]int 賦給 [3]int

比較兩個數組是否相等

如果兩個數組類型相同（包括數組的長度，數組中元素的類型）的情況下，我們可以直接通過較運算符（==和!=）來判斷兩個數組是否相等，只有當兩個數組的所有元素都是相等的時候數組才是相等的，不能比較兩個類型不同的數組，否則程序將無法完成編譯。

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c) // "true false false"
d := [3]int{1, 2}
fmt.Println(a == d) // 編譯錯誤：無法比較 [2]int == [3]int

遍歷數組——訪問每一個數組元素

遍歷數組也和遍歷切片類似，代碼如下所示：

var team [3]string
team[0] = "hammer"
team[1] = "soldier"
team[2] = "mum"
for k, v := range team {
    fmt.Println(k, v)
}

代碼輸出結果：

代碼說明如下：

• 第 6 行，使用 for 循環，遍歷 team 數組，遍歷出的鍵 k 為數組的索引，值 v 為數組的每個元素值。

• 第 7 行，將每個鍵值打印出來。

Golang中實現tuple（元組）功能

雖然其他語言有tuple類型，但go語言卻沒有提供。但無需失望，go的其他特性可以非常容易實現tuple功能。下面通過示例來演示Go如何實現tuple類型功能。

使用struct

tuple可以存儲不同數據類型，我們可以使用interface{}類型支持任意數據類型。

package main

import "fmt"

func main() {
	type Student struct {
		name, age interface{}
	}

	stuList1 := []Student{
		{"tom", 21},
		{"jack", 22},
	}

	stuList2 := []Student{
		{"mary", 30},
	}
	// append stuList2 to stuList1
	stuList1 = append(stuList1, stuList2...)

	for _, stu := range stuList1 {
		fmt.Println(“stuInfo:”,stu)
	}
}


/*
Output:
stuInfo: {tom 21}
stuInfo: {jack 22}
stuInfo: {mary 30}
*/

通過輸出可以看到結果為類似于tuple類型，并且還可以通過點號訪問單個屬性。雖然這些特性都于tuple相關，但實際上它不是tuple類型。

返回多個值

通過tuple 函數可以返回多個值。雖然go沒有tuple類型，但支持返回函數返回多個值：

package main

import "fmt"

func multipleValues() (string, int) {
	return "Alex", 21
}

func main() {
	name, age := multipleValues()
	fmt.Println("Name :", name)
	fmt.Println("Age :", age)
}

/*
Output:
Name : Alex
Age : 21
*/

這里可以看到一次返回多個值。

感謝各位的閱讀，以上就是“go語言元組指的是什么”的內容了，經過本文的學習后，相信大家對go語言元組指的是什么這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！