本篇內容主要講解“go語言有哪些類型及怎么表示”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“go語言有哪些類型及怎么表示”吧!

在做網站、網站設計中從網站色彩、結構布局、欄目設置、關鍵詞群組等細微處著手，突出企業的產品/服務/品牌，幫助企業鎖定精準用戶，提高在線咨詢和轉化，使成都網站營銷成為有效果、有回報的無錫營銷推廣。創新互聯公司專業成都網站建設十余年了，客戶滿意度97.8%，歡迎成都創新互聯客戶聯系。

go語言的類型有布爾型（bool）、整型（int8、byte、int16等）、浮點型（float32、float64）、復數類型（complex64、complex128）、字符串、字符型、錯誤型、指針、數組、切片、字典、通道、結構體、接口。浮點類型采用IEEE-754標準的表達方式；復數實際上由兩個實數（在計算機中用浮點數表示）構成，一個表示實部，一個表示虛部。

Go語言的類型

Go語言內置以下這些基礎類型：

• 布爾類型：bool。

• 整型：int8、byte、int16、int、uint、uintptr等。

• 浮點類型：float32、float64。

• 復數類型：complex64、complex128。

• 字符串：string。

• 字符類型：rune。

• 錯誤類型：error。

此外，Go語言也支持以下這些復合類型：

• 指針（pointer）

• 數組（array）

• 切片（slice）

• 字典（map）

• 通道（chan）

• 結構體（struct）

• 接口（interface）

在這些基礎類型之上Go還封裝了下面這幾種類型：

int、uint和uintptr等。這些類型的特點在于使用方便，但使用者不能對這些類型的長度做任何假設。對于常規的開發來說，用int和uint就可以了，沒必要用int8之類明確指定長度的類型，以免導致移植困難。【相關推薦：Go視頻教程】

布爾類型

Go 語言中以 bool 類型進行聲明布爾類型數據，布爾型數據只有 true

和 false 兩個值，需要注意的是：

• go 語言中不允許將整型強制轉換為布爾型

• 布爾類型變量默認值為 false

• 布爾型無法參與數值運算，也無法與其他類型進行轉換

Go語言中的布爾類型與其他語言基本一致，關鍵字也為bool，可賦值為預定義的true和false示例代碼如下：

var v1 bool
v1 = true
v2 := (1 == 2) // v2也會被推導為bool類型

布爾類型不能接受其他類型的賦值，不支持自動或強制的類型轉換。
以下的示例是一些錯誤的用法，會導致編譯錯誤：

var b bool
b = 1 // 編譯錯誤
b = bool(1) // 編譯錯誤
以下的用法才是正確的：
var b bool
b = (1!=0) // 編譯正確 
fmt.Println("Result:", b) // 打印結果為Result: true

整型

整型是所有編程語言里最基礎的數據類型。Go語言支持表2-1所示的這些整型類型。

1. 類型表示

需要注意的是，int和int32在Go語言里被認為是兩種不同的類型，編譯器也不會幫你自動做類型轉換，比如以下的例子會有編譯錯誤：

var value2 int32
value1 := 64 // value1將會被自動推導為int類型
value2 = value1 // 編譯錯誤

編譯錯誤類似于：

cannot use value1 (type int) as type int32 in assignment

使用強制類型轉換可以解決這個編譯錯誤：

value2 = int32(value1) // 編譯通過

當然，開發者在做強制類型轉換時，需要注意數據長度被截短而發生的數據精度損失（比如將浮點數強制轉為整數）和值溢出（值超過轉換的目標類型的值范圍時）問題。

類型轉換

Go 語言中只有強類型轉換，沒有隱式轉換。該語法只能在兩個類型
之間支持相互轉換的時候使用。強制轉換的語法如下：

示例如下：

2. 數值運算

Go語言支持下面的常規整數運算：+、-、*、/和%

加減乘除就不詳細解釋了，需要說下的是，% 和在C語言中一樣是求余運算，比如：

5 % 3 // 結果為：2

3. 比較運算

Go語言支持以下的幾種比較運算符：>、<、==、>=、<=和!=

這一點與大多數其他語言相同，與C語言完全一致。

下面為條件判斷語句的例子：

i, j := 1, 2 
if i == j { 
 fmt.Println("i and j are equal.") 
}

兩個不同類型的整型數不能直接比較，比如int8類型的數和int類型的數不能直接比較，但各種類型的整型變量都可以直接與字面常量（literal）進行比較，比如

var i int32
var j int64
i, j = 1, 2 
if i == j { // 編譯錯誤
 fmt.Println("i and j are equal.") 
} 
if i == 1 || j == 2 { // 編譯通過
 fmt.Println("i and j are equal.") 
}

4. 位運算

Go語言支持表2-2所示的位運算符。

Go語言的大多數位運算符與C語言都比較類似，除了取反在C語言中是~x，而在Go語言中是^x。

編程語言中表示固定值的符號叫做字面量常量，簡稱字面量。如整形

字面量八進制：“012”或者“0o17”，十六進制: “0x12”，二進制：”0b101”，

輸出表示如下圖：

浮點型

字面量八進制：“012”或者“0o17”，十六進制: “0x12”，二進制：”0b101”，
輸出表示如下圖：
浮點型用于表示包含小數點的數據，比如1.234就是一個浮點型數據。Go語言中的浮點類型采用IEEE-754標準的表達方式

1. 浮點數表示

Go語言定義了兩個類型float32和float64，其中float32等價于C語言的float類型，float64等價于C語言的double類型

在Go語言里，定義一個浮點數變量的代碼如下：

var fvalue1 float32
fvalue1 = 12 
fvalue2 := 12.0 // 如果不加小數點，fvalue2會被推導為整型而不是浮點型

對于以上例子中類型被自動推導的fvalue2，需要注意的是其類型將被自動設為float64，而不管賦給它的數字是否是用32位長度表示的。因此，對于以上的例子，下面的賦值將導致編譯錯誤：

fvalue1 = fvalue2

而必須使用這樣的強制類型轉換：

fvalue1 = float32(fvalue2)

2. 浮點數比較

因為浮點數不是一種精確的表達方式，所以像整型那樣直接用==來判斷兩個浮點數是否相等是不可行的，這可能會導致不穩定的結果
下面是一種推薦的替代方案：

import "math" 
// p為用戶自定義的比較精度，比如0.00001 
func IsEqual(f1, f2, p float64) bool { 
 return math.Fdim(f1, f2) < p 
}

復數類型

復數實際上由兩個實數（在計算機中用浮點數表示）構成，一個表示實部（real），一個表示虛部（imag）。如果了解了數學上的復數是怎么回事，那么Go語言的復數就非常容易理解了。

復數有實部和虛部，complex64 的實部和虛部為 32 位，complex128的實部和虛部為 64 位。

1. 復數表示

復數表示的示例如下：

var value1 complex64 // 由2個float32構成的復數類型
value1 = 3.2 + 12i 
value2 := 3.2 + 12i // value2是complex128類型
value3 := complex(3.2, 12) // value3結果同 value2

2. 實部與虛部

對于一個復數z = complex(x, y)，就可以通過Go語言內置函數real(z)獲得該復數的實部，也就是x，通過imag(z)獲得該復數的虛部，也就是y。

字符串

Go 語言中的字符串以原生數據類型出現，使用字符串就像使用其他

原生數據類型一樣。Go 語言里的字符串的內部實現使用 utf-8 編碼。字符串的值為雙引號中的內容，如

在Go語言中，字符串也是一種基本類型。相比之下， C/C++語言中并不存在原生的字符類型，通常使用字符數組來表示，并以字符指針來傳遞。

Go語言中字符串的聲明和初始化非常簡單，舉例如下：

var str string // 聲明一個字符串變量
str = "Hello world" // 字符串賦值
ch := str[0] // 取字符串的第一個字符
fmt.Printf("The length of \"%s\" is %d \n", str, len(str)) 
fmt.Printf("The first character of \"%s\" is %c.\n", str, ch)

輸出結果為：

The length of "Hello world" is 11 
The first character of "Hello world" is H.

字符串的內容可以用類似于數組下標的方式獲取，但與數組不同，字符串的內容不能在初始化后被修改，比如以下的例子：

str := "Hello world" // 字符串也支持聲明時進行初始化的做法
str[0] = 'X' // 編譯錯誤

編譯器會報類似如下的錯誤：

cannot assign to str[0]

在這個例子中我們使用了一個Go語言內置的函數len()來取字符串的長度。這個函數非常有用，我們在實際開發過程中處理字符串、數組和切片時將會經常用到。

Printf()函數的用法與C語言運行庫中的printf()函數如出一轍。

Go編譯器支持UTF-8的源代碼文件格式。這意味著源代碼中的字符串可以包含非ANSI的字符，比如“Hello world. 你好，世界！”可以出現在Go代碼中。但需要注意的是，如果你的Go代碼需要包含非ANSI字符，保存源文件時請注意編碼格式必須選擇UTF-8。特別是在Windows下一般編輯器都默認存為本地編碼，比如中國地區可能是GBK編碼而不是UTF-8，如果沒注意這點在編譯和運行時就會出現一些意料之外的情況。

字符串的編碼轉換是處理文本文檔（比如TXT、XML、HTML等）非常常見的需求，不過可惜的是Go語言僅支持UTF-8和Unicode編碼。對于其他編碼，Go語言標準庫并沒有內置的編碼轉換支持。不過，所幸的是我們可以很容易基于iconv庫用Cgo包裝一個。這里有一個開源項目：https://github.com/xushiwei/go-iconv。

1. 字符串操作

平時常用的字符串操作如表2-3所示。

更多的字符串操作，請參考標準庫strings包。

2. 字符串遍歷

Go語言支持兩種方式遍歷字符串。一種是以字節數組的方式遍歷：

str := "Hello,世界"n := len(str) for i := 0; i < n; i++ { 
 ch := str[i] // 依據下標取字符串中的字符，類型為byte 
 fmt.Println(i, ch) }

這個例子的輸出結果為：

0 72 1 101 2 108 3 108 4 111 5 44 6 32 7 228 8 184 9 150 10 231 11 149 12 140

可以看出，這個字符串長度為13。盡管從直觀上來說，這個字符串應該只有9個字符。這是因為每個中文字符在UTF-8中占3個字節，而不是1個字節

另一種是以Unicode字符遍歷：

str := "Hello,世界"for i, ch := range str { 
 fmt.Println(i, ch)//ch的類型為rune }

輸出結果為：

0 72 1 101 2 108 3 108 4 111 5 44 6 32 7 19990 10 30028

以Unicode字符方式遍歷時，每個字符的類型是rune（早期的Go語言用int類型表示Unicode字符），而不是byte。

字符串的常見操作

字符類型

在Go語言中支持兩個字符類型，一個是byte（實際上是uint8的別名），代表UTF-8字符串的單個字節的值；另一個是rune，代表單個Unicode字符。

關于rune相關的操作，可查閱Go標準庫的unicode包。另外unicode/utf8包也提供了UTF8和Unicode之間的轉換。

出于簡化語言的考慮，Go語言的多數API都假設字符串為UTF-8編碼。盡管Unicode字符在標準庫中有支持，但實際上較少使用。

byte 和 rune 類型

字符指類字形單位或符號，包括字母、數字、運算符號、標點符

號和其他符號，以及一些功能性符號。每個字符在計算機中都有相應的二進制代碼

Go 語言內置兩種字符類型：

• 一種是 byte 的字節類型，它是 uint8 的別名。

• 另一種是 Unicode 編碼的 rune 類型，它是 int32 類型的別名。

Go 語言默認的字符編碼就是 UTF-8 類型的。

遍歷字符串

如下：

UTF-8 編碼下一個中文漢字由 3-4 個字節組成，所以我們不能簡
單的按照字節去遍歷一個包含中文字符的字符串。
字符串底層是一個 byte 數組，所以可以和[]byte 類型相互轉換。
字符串是不能修改的，字符串由 byte 字節組成，所以字符串的長度
就是 byte 字節的長度。rune 類型用來表示 utf-8 字符，一個 rune 字
符由一個或多個 byte 組成。

修改字符串

要修改字符串，需要先將其轉換成[]rune 或者[]byte，修改以后，再轉換為 string。

無論哪種轉換，都會重新分配內存并復制字節數組。如下：

常見的轉義字符

多行字符串的顯示，可以使用反引號進行，需要注意的是反引號間換行將被作為字符串中的換行，但是所有的轉義字符均無效，文本將會原樣輸出

數組

數組是Go語言編程中最常用的數據結構之一。顧名思義，數組就是指一系列同一類型數據的集合。數組中包含的每個數據被稱為數組元素（element），一個數組包含的元素個數被稱為數組的長度。

以下為一些常規的數組聲明方法：

[32]byte // 長度為32的數組，每個元素為一個字節
[2*N] struct { x, y int32 } // 復雜類型數組
[1000]*float64 // 指針數組
[3][5]int // 二維數組
[2][2][2]float64 // 等同于[2]([2]([2]float64))

從以上類型也可以看出，數組可以是多維的，比如[3][5]int就表達了一個3行5列的二維整型數組，總共可以存放15個整型元素。
在Go語言中，數組長度在定義后就不可更改，在聲明時長度可以為一個常量或者一個常量表達式（常量表達式是指在編譯期即可計算結果的表達式）。數組的長度是該數組類型的一個內置常量，可以用Go語言的內置函數len()來獲取。

下面是一個獲取數組arr元素個數的寫法：

arrLength := len(arr)

1. 元素訪問

可以使用數組下標來訪問數組中的元素。與C語言相同，數組下標從0開始，len(array)-1則表示最后一個元素的下標。下面的示例遍歷整型數組并逐個打印元素內容：

for i := 0; i < len(array); i++ { 
 fmt.Println("Element", i, "of array is", array[i]) 
}

Go語言還提供了一個關鍵字range，用于便捷地遍歷容器中的元素。當然，數組也是range的支持范圍。上面的遍歷過程可以簡化為如下的寫法：

for i, v := range array { 
 fmt.Println("Array element[", i, "]=", v) 
}

在上面的例子里可以看到

range具有兩個返回值，第一個返回值是元素的數組下標，第二個返回值是元素的值。

2. 值類型

需要特別注意的是，在Go語言中數組是一個值類型（value type）。所有的值類型變量在賦值和作為參數傳遞時都將產生一次復制動作。

如果將數組作為函數的參數類型，則在函數調用時該參數將發生數據復制。因此，在函數體中無法修改傳入的數組的內容，因為函數內操作的只是所傳入數組的一個副本。

下面用例子來說明這一特點：

package main 
import "fmt" 
func modify(array [10]int) { 
 array[0] = 10 // 試圖修改數組的第一個元素
 fmt.Println("In modify(), array values:", array) 
} 
func main() { 
 array := [5]int{1,2,3,4,5} // 定義并初始化一個數組
 modify(array) // 傳遞給一個函數，并試圖在函數體內修改這個數組內容
 fmt.Println("In main(), array values:", array) 
}

該程序的執行結果為：

In modify(), array values: [10 2 3 4 5] 
In main(), array values: [1 2 3 4 5]

從執行結果可以看出，函數modify()內操作的那個數組跟main()中傳入的數組是兩個不同的實例。

數組切片

我們已經提過數組的特點：數組的長度在定義之后無法再次修改；數組是值類型，每次傳遞都將產生一份副本。顯然這種數據結構無法完全滿足開發者的真實需求。

不用失望，Go語言提供了數組切片（slice）這個非常酷的功能來彌補數組的不足。

初看起來，數組切片就像一個指向數組的指針，實際上它擁有自己的數據結構，而不僅僅是個指針。

數組切片的數據結構可以抽象為以下3個變量：

• 一個指向原生數組的指針；

• 數組切片中的元素個數；

• 數組切片已分配的存儲空間。

從底層實現的角度來看，數組切片實際上仍然使用數組來管理元素，因此它們之間的關系讓C++程序員們很容易聯想起STL中std::vector和數組的關系。基于數組，數組切片添加了一系列管理功能，可以隨時動態擴充存放空間，并且可以被隨意傳遞而不會導致所管理的元素被重復復制。

1. 創建數組切片

創建數組切片的方法主要有兩種——基于數組和直接創建，下面我們來簡要介紹一下這兩種方法。

• 基于數組

數組切片可以基于一個已存在的數組創建。數組切片可以只使用數組的一部分元素或者整個數組來創建，甚至可以創建一個比所基于的數組還要大的數組切片。代碼清單2-1演示了如何基于一個數組的前5個元素創建一個數組切片。

代碼清單2-1 slice.go

package main 
import "fmt" 
func main() { 
 // 先定義一個數組
 var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 
 // 基于數組創建一個數組切片
 var mySlice []int = myArray[:5] 
 fmt.Println("Elements of myArray: ") 
 for _, v := range myArray { 
 fmt.Print(v, " ") 
 } 
 fmt.Println("\nElements of mySlice: ") 
 for _, v := range mySlice { 
 fmt.Print(v, " ") 
 } 
 fmt.Println() 
}

運行結果為：

Elements of myArray: 
1 2 3 4 5 6 7 8 9 10 
Elements of mySlice: 
1 2 3 4 5

Go語言支持用myArray[first:last]這樣的方式來基于數組生成一個數組切片，而且這個用法還很靈活，比如下面幾種都是合法的。

基于myArray的所有元素創建數組切片：

mySlice = myArray[:]

基于myArray的前5個元素創建數組切片：

mySlice = myArray[:5]

基于從第5個元素開始的所有元素創建數組切片：

mySlice = myArray[5:]

• 直接創建

并非一定要事先準備一個數組才能創建數組切片。Go語言提供的內置函數make()可以用于靈活地創建數組切片。下面的例子示范了直接創建數組切片的各種方法。

創建一個初始元素個數為5的數組切片，元素初始值為0：

mySlice1 := make([]int, 5)

創建一個初始元素個數為5的數組切片，元素初始值為0，并預留10個元素的存儲空間：

mySlice2 := make([]int, 5, 10)

直接創建并初始化包含5個元素的數組切片：

mySlice3 := []int{1, 2, 3, 4, 5}

當然，事實上還會有一個匿名數組被創建出來，只是不需要我們來操心而已。

2. 元素遍歷

操作數組元素的所有方法都適用于數組切片，比如數組切片也可以按下標讀寫元素，用len()函數獲取元素個數，并支持使用range關鍵字來快速遍歷所有元素。

傳統的元素遍歷方法如下:

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

使用range關鍵字可以讓遍歷代碼顯得更整潔。range表達式有兩個返回值，第一個是索引，第二個是元素的值：

for i, v := range mySlice { 
 fmt.Println("mySlice[", i, "] =", v) 
}

對比上面的兩個方法，我們可以很容易地看出使用range的代碼更簡單易懂。

3. 動態增減元素

可動態增減元素是數組切片比數組更為強大的功能。與數組相比，數組切片多了一個存儲能力（capacity）的概念，即元素個數和分配的空間可以是兩個不同的值。合理地設置存儲能力的值，可以大幅降低數組切片內部重新分配內存和搬送內存塊的頻率，從而大大提高程序性能。

假如你明確知道當前創建的數組切片最多可能需要存儲的元素個數為50，那么如果你設置的存儲能力小于50，比如20，那么在元素超過20時，底層將會發生至少一次這樣的動作——重新分配一塊“夠大”的內存，并且需要把內容從原來的內存塊復制到新分配的內存塊，這會產生比較明顯的開銷。給“夠大”這兩個字加上引號的原因是系統并不知道多大才是夠大，所以只是一個簡單的猜測。比如，將原有的內存空間擴大兩倍，但兩倍并不一定夠，所以之前提到的內存重新分配和內容復制的過程很有可能發生多次，從而明顯降低系統的整體性能。但如果你知道最大是50并且一開始就設置存儲能力為50，那么之后就不會發生這樣非常耗費CPU的動作，從而達到空間換時間的效果。

數組切片支持Go語言內置的cap()函數和len()函數，代碼清單2-2簡單示范了這兩個內置函數的用法。可以看出，cap()函數返回的是數組切片分配的空間大小，而len()函數返回的是數組切片中當前所存儲的元素個數。

代碼清單2-2 slice2.go

package main 
import "fmt" 
func main() { 
 mySlice := make([]int, 5, 10) 
 fmt.Println("len(mySlice):", len(mySlice)) 
 fmt.Println("cap(mySlice):", cap(mySlice)) 
}

該程序的輸出結果為：

len(mySlice): 5 
cap(mySlice): 10

如果需要往上例中mySlice已包含的5個元素后面繼續新增元素，可以使用append()函數。
下面的代碼可以從尾端給mySlice加上3個元素，從而生成一個新的數組切片：

mySlice = append(mySlice, 1, 2, 3)

函數append()的第二個參數其實是一個不定參數，我們可以按自己需求添加若干個元素，甚至直接將一個數組切片追加到另一個數組切片的末尾：

mySlice2 := []int{8, 9, 10} 
// 給mySlice后面添加另一個數組切片
mySlice = append(mySlice, mySlice2...)

需要注意的是，我們在第二個參數mySlice2后面加了三個點，即一個省略號，如果沒有這個省略號的話，會有編譯錯誤，因為按append()的語義，從第二個參數起的所有參數都是待附加的元素。因為mySlice中的元素類型為int，所以直接傳遞mySlice2是行不通的。加上省略號相當于把mySlice2包含的所有元素打散后傳入。

上述調用等同于：

mySlice = append(mySlice, 8, 9, 10)

數組切片會自動處理存儲空間不足的問題。如果追加的內容長度超過當前已分配的存儲空間（即cap()調用返回的信息），數組切片會自動分配一塊足夠大的內存。

4. 基于數組切片創建數組切片

類似于數組切片可以基于一個數組創建，數組切片也可以基于另一個數組切片創建。下面的例子基于一個已有數組切片創建新數組切片：

oldSlice := []int{1, 2, 3, 4, 5} 
newSlice := oldSlice[:3] // 基于oldSlice的前3個元素構建新數組切片

有意思的是，選擇的oldSlicef元素范圍甚至可以超過所包含的元素個數，比如newSlice可以基于oldSlice的前6個元素創建，雖然oldSlice只包含5個元素。只要這個選擇的范圍不超過oldSlice存儲能力（即cap()返回的值），那么這個創建程序就是合法的。newSlice中超出oldSlice元素的部分都會填上0。

5. 內容復制

數組切片支持Go語言的另一個內置函數copy()，用于將內容從一個數組切片復制到另一個數組切片。如果加入的兩個數組切片不一樣大，就會按其中較小的那個數組切片的元素個數進行復制。下面的示例展示了copy()函數的行為：

slice1 := []int{1, 2, 3, 4, 5} 
slice2 := []int{5, 4, 3} 
copy(slice2, slice1) // 只會復制slice1的前3個元素到slice2中
copy(slice1, slice2) // 只會復制slice2的3個元素到slice1的前3個位置

map

在C++/Java中，map一般都以庫的方式提供，比如在C++中是STL的std::map<>，在C#中是Dictionary<>，在Java中是Hashmap<>，在這些語言中，如果要使用map，事先要引用相應的庫。而在Go中，使用map不需要引入任何庫，并且用起來也更加方便。

map是一堆鍵值對的未排序集合。比如以身份證號作為唯一鍵來標識一個人的信息，則這個map可以定義為代碼清單 2-3所示的方式。

代碼清單2-3 map1.go

package main 
import "fmt" 
// PersonInfo是一個包含個人詳細信息的類型
type PersonInfo struct { 
 ID string
 Name string
 Address string
} 
func main() { 
var personDB map[string] PersonInfo 
 personDB = make(map[string] PersonInfo) 
 // 往這個map里插入幾條數據
 personDB["12345"] = PersonInfo{"12345", "Tom", "Room 203,..."} 
 personDB["1"] = PersonInfo{"1", "Jack", "Room 101,..."} 
 // 從這個map查找鍵為"1234"的信息
 person, ok := personDB["1234"]
 // ok是一個返回的bool型，返回true表示找到了對應的數據
 if ok { 
 fmt.Println("Found person", person.Name, "with ID 1234.") 
 } else { 
 fmt.Println("Did not find person with ID 1234.") 
 } 
}

上面這個簡單的例子基本上已經覆蓋了map的主要用法，下面對其中的關鍵點進行細述。

1. 變量聲明

map的聲明基本上沒有多余的元素，比如：

var myMap map[string] PersonInfo

其中，myMap是聲明的map變量名，string是鍵的類型，PersonInfo則是其中所存放的值類型。

2. 創建

我們可以使用Go語言內置的函數make()來創建一個新map。下面的這個例子創建了一個鍵類型為string、值類型為PersonInfo的map:

myMap = make(map[string] PersonInfo)

也可以選擇是否在創建時指定該map的初始存儲能力，下面的例子創建了一個初始存儲能力為100的map:

myMap = make(map[string] PersonInfo, 100)

創建并初始化map的代碼如下：

myMap = map[string] PersonInfo{ 
 "1234": PersonInfo{"1", "Jack", "Room 101,..."}, 
}

3. 元素賦值

賦值過程非常簡單明了，就是將鍵和值用下面的方式對應起來即可：

myMap["1234"] = PersonInfo{"1", "Jack", "Room 101,..."}

4. 元素刪除

Go語言提供了一個內置函數delete()，用于刪除容器內的元素。下面我們簡單介紹一下如何用delete()函數刪除map內的元素：

delete(myMap, "1234")

上面的代碼將從myMap中刪除鍵為“1234”的鍵值對。如果“1234”這個鍵不存在，那么這個調用將什么都不發生，也不會有什么副作用。但是如果傳入的map變量的值是nil，該調用將導致程序拋出異常（panic）

5. 元素查找

在Go語言中，map的查找功能設計得比較精巧。而在其他語言中，我們要判斷能否獲取到一個值不是件容易的事情。判斷能否從map中獲取一個值的常規做法是：

(1) 聲明并初始化一個變量為空；

(2) 試圖從map中獲取相應鍵的值到該變量中；

(3) 判斷該變量是否依舊為空，如果為空則表示map中沒有包含該變量。

這種用法比較啰唆，而且判斷變量是否為空這條語句并不能真正表意（是否成功取到對應的值），從而影響代碼的可讀性和可維護性。有些庫甚至會設計為因為一個鍵不存在而拋出異常，讓開發者用起來膽戰心驚，不得不一層層嵌套try-catch語句，這更是不人性化的設計。在Go語言中，要從map中查找一個特定的鍵，可以通過下面的代碼來實現：

value, ok := myMap["1234"] 
if ok { // 找到了
 // 處理找到的value 
}

判斷是否成功找到特定的鍵，不需要檢查取到的值是否為nil，只需查看第二個返回值ok，這讓表意清晰很多。配合:=操作符，讓你的代碼沒有多余成分，看起來非常清晰易懂。

到此，相信大家對“go語言有哪些類型及怎么表示”有了更深的了解，不妨來實際操作一番吧！這里是創新互聯網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！

本文標題：go語言有哪些類型及怎么表示
鏈接分享：http://www.2m8n56k.cn/article20/giosco.html

成都網站建設公司_創新互聯，為您提供網站維護、App設計、網站內鏈、標簽優化、企業建站、App開發

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：[email protected]。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯