、數(shù)組
成都創(chuàng)新互聯(lián)長期為上千余家客戶提供的網(wǎng)站建設(shè)服務(wù)，團(tuán)隊(duì)從業(yè)經(jīng)驗(yàn)10年，關(guān)注不同地域、不同群體，并針對不同對象提供差異化的產(chǎn)品和服務(wù)；打造開放共贏平臺，與合作伙伴共同營造健康的互聯(lián)網(wǎng)生態(tài)環(huán)境。為雨花臺企業(yè)提供專業(yè)的網(wǎng)站設(shè)計(jì)制作、做網(wǎng)站，雨花臺網(wǎng)站改版等技術(shù)服務(wù)。擁有十年豐富建站經(jīng)驗(yàn)和眾多成功案例,為您定制開發(fā)。
與其他大多數(shù)語言類似，Go語言的數(shù)組也是一個(gè)元素類型相同的定長的序列。
（1）數(shù)組的創(chuàng)建。
數(shù)組有3種創(chuàng)建方式：[length]Type 、[N]Type{value1, value2, ... , valueN}、[...]Type{value1, value2, ... , valueN} 如下：
復(fù)制代碼代碼如下:
func test5() {
var iarray1 [5]int32
var iarray2 [5]int32 = [5]int32{1, 2, 3, 4, 5}
iarray3 := [5]int32{1, 2, 3, 4, 5}
iarray4 := [5]int32{6, 7, 8, 9, 10}
iarray5 := [...]int32{11, 12, 13, 14, 15}
iarray6 := [4][4]int32{{1}, {1, 2}, {1, 2, 3}}
fmt.Println(iarray1)
fmt.Println(iarray2)
fmt.Println(iarray3)
fmt.Println(iarray4)
fmt.Println(iarray5)
fmt.Println(iarray6)
}
結(jié)果：
[0 0 0 0 0]
[1 2 3 4 5]
[1 2 3 4 5]
[6 7 8 9 10]
[11 12 13 14 15]
[[1 0 0 0] [1 2 0 0] [1 2 3 0] [0 0 0 0]]
我們看數(shù)組 iarray1，只聲明，并未賦值，Go語言幫我們自動賦值為0。再看 iarray2 和 iarray3 ，我們可以看到，Go語言的聲明，可以表明類型，也可以不表明類型，var iarray3 = [5]int32{1, 2, 3, 4, 5} 也是完全沒問題的。
（2）數(shù)組的容量和長度是一樣的。cap() 函數(shù)和 len() 函數(shù)均輸出數(shù)組的容量（即長度）。如：
復(fù)制代碼代碼如下:
func test6() {
iarray4 := [5]int32{6, 7, 8, 9, 10}
fmt.Println(len(iarray4))
fmt.Println(cap(iarray4))
}
輸出都是5。
（3）使用：
復(fù)制代碼代碼如下:
func test7() {
iarray7 := [5]string{"aaa", `bb`, "可以啦", "叫我說什么好", "()"}
fmt.Println(iarray7)
for i := range iarray7 {
fmt.Println(iarray7[i])
}
}
二、切片
Go語言中，切片是長度可變、容量固定的相同的元素序列。Go語言的切片本質(zhì)是一個(gè)數(shù)組。容量固定是因?yàn)閿?shù)組的長度是固定的，切片的容量即隱藏?cái)?shù)組的長度。長度可變指的是在數(shù)組長度的范圍內(nèi)可變。
（1）切片的創(chuàng)建。
切片的創(chuàng)建有4種方式：
1）make ( []Type ,length, capacity )
2) make ( []Type, length)
3) []Type{}
4) []Type{value1 , value2 , ... , valueN }
從3)、4)可見，創(chuàng)建切片跟創(chuàng)建數(shù)組唯一的區(qū)別在于 Type 前的“ [] ”中是否有數(shù)字，為空，則代表切片，否則則代表數(shù)組。因?yàn)榍衅情L度可變的。如下是創(chuàng)建切片的示例：
復(fù)制代碼代碼如下:
func test8() {
slice1 := make([]int32, 5, 8)
slice2 := make([]int32, 9)
slice3 := []int32{}
slice4 := []int32{1, 2, 3, 4, 5}
fmt.Println(slice1)
fmt.Println(slice2)
fmt.Println(slice3)
fmt.Println(slice4)
}
輸出為：
[0 0 0 0 0]
[0 0 0 0 0 0 0 0 0]
[]
[1 2 3 4 5]
如上，創(chuàng)造了4個(gè)切片，3個(gè)空切片，一個(gè)有值的切片。
（2）切片與隱藏?cái)?shù)組：
一個(gè)切片是一個(gè)隱藏?cái)?shù)組的引用，并且對于該切片的切片也引用同一個(gè)數(shù)組。如下示例，創(chuàng)建了一個(gè)切片slice0，并根據(jù)這個(gè)切片創(chuàng)建了2個(gè)切片 slice1 和 slice2：
復(fù)制代碼代碼如下:
func test9() {
slice0 := []string{"a", "b", "c", "d", "e"}
slice1 := slice0[2 : len(slice0)-1]
slice2 := slice0[:3]
fmt.Println(slice0, slice1, slice2)
slice2[2] = "8"
fmt.Println(slice0, slice1, slice2)
}
輸出為：
[a b c d e] [c d] [a b c]
[a b 8 d e] [8 d] [a b 8]
可見，切片slice0 、 slice1 和 slice2是同一個(gè)底層數(shù)組的引用，所以slice2改變了，其他兩個(gè)都會變。
（3）遍歷、修改切片：
復(fù)制代碼代碼如下:
func test10() {
slice0 := []string{"a", "b", "c", "d", "e"}
fmt.Println("\n~~~~~~元素遍歷~~~~~~")
for _, ele := range slice0 {
fmt.Print(ele, " ")
ele = "7"
}
fmt.Println("\n~~~~~~索引遍歷~~~~~~")
for index := range slice0 {
fmt.Print(slice0[index], " ")
}
fmt.Println("\n~~~~~~元素索引共同使用~~~~~~")
for index, ele := range slice0 {
fmt.Print(ele, slice0[index], " ")
}
fmt.Println("\n~~~~~~修改~~~~~~")
for index := range slice0 {
slice0[index] = "9"
}
fmt.Println(slice0)
}
如上，前三種循環(huán)使用了不同的for range循環(huán)，當(dāng)for后面，range前面有2個(gè)元素時(shí)，第一個(gè)元素代表索引，第二個(gè)元素代表元素值，使用 “_” 則表示忽略，因?yàn)間o語言中，未使用的值會導(dǎo)致編譯錯(cuò)誤。
只有一個(gè)元素時(shí)，該元素代表索引。
只有用索引才能修改元素。如在第一個(gè)遍歷中，賦值ele為7，結(jié)果沒有作用。因?yàn)樵谠乇闅v中，ele是值傳遞，ele是該切片元素的副本，修改它不會影響原本值，而在第四個(gè)遍歷——索引遍歷中，修改的是該切片元素引用的值，所以可以修改。
結(jié)果為：
~~~~~~元素遍歷~~~~~~
a b c d e
~~~~~~索引遍歷~~~~~~
a b c d e
~~~~~~元素索引共同使用~~~~~~
aa bb cc dd ee
~~~~~~修改~~~~~~
[9 9 9 9 9]
（4）、追加、復(fù)制切片：
復(fù)制代碼代碼如下:
func test11() {
slice := []int32{}
fmt.Printf("slice的長度為：%d,slice為：%v\n", len(slice), slice)
slice = append(slice, 12, 11, 10, 9)
fmt.Printf("追加后，slice的長度為：%d,slice為：%v\n", len(slice), slice)
slicecp := make([]int32, (len(slice)))
fmt.Printf("slicecp的長度為：%d,slicecp為：%v\n", len(slicecp), slicecp)
copy(slicecp, slice)
fmt.Printf("復(fù)制賦值后，slicecp的長度為：%d,slicecp為：%v\n", len(slicecp), slicecp)
}
追加、復(fù)制切片，用的是內(nèi)置函數(shù)append和copy，copy函數(shù)返回的是最后所復(fù)制的元素的數(shù)量。
（5）、內(nèi)置函數(shù)append
內(nèi)置函數(shù)append可以向一個(gè)切片后追加一個(gè)或多個(gè)同類型的其他值。如果追加的元素?cái)?shù)量超過了原切片容量，那么最后返回的是一個(gè)全新數(shù)組中的全新切片。如果沒有超過，那么最后返回的是原數(shù)組中的全新切片。無論如何，append對原切片無任何影響。如下示例：
復(fù)制代碼代碼如下:
func test12() {
slice := []int32{1, 2, 3, 4, 5, 6}
slice2 := slice[:2]
_ = append(slice2, 50, 60, 70, 80, 90)
fmt.Printf("slice為：%v\n", slice)
fmt.Printf("操作的切片：%v\n", slice2)
_ = append(slice2, 50, 60)
fmt.Printf("slice為：%v\n", slice)
fmt.Printf("操作的切片：%v\n", slice2)
}
如上，append方法用了2次，結(jié)果返回的結(jié)果完全不同，原因是第二次append方法追加的元素?cái)?shù)量沒有超過 slice 的容量。而無論怎樣，原切片slice2都無影響。結(jié)果：
slice為：[1 2 3 4 5 6]
操作的切片：[1 2]
slice為：[1 2 50 60 5 6]
操作的切片：[1 2]
Go 中的分片數(shù)組，實(shí)際上有點(diǎn)類似于Java中的ArrayList,是一個(gè)可以擴(kuò)展的數(shù)組，但是Go中的切片由比較靈活，它和數(shù)組很像，也是基于數(shù)組，所以在了解Go切片前我們先了解下數(shù)組。
數(shù)組簡單描述就由相同類型元素組成的數(shù)據(jù)結(jié)構(gòu), 在創(chuàng)建初期就確定了長度，是不可變的。
但是Go的數(shù)組類型又和C與Java的數(shù)組類型不一樣， NewArray 用于創(chuàng)建一個(gè)數(shù)組，從源碼中可以看出最后返回的是 Array{}的指針，并不是第一個(gè)元素的指針，在Go中數(shù)組屬于值類型，在進(jìn)行傳遞時(shí)，采取的是值傳遞，通過拷貝整個(gè)數(shù)組。Go語言的數(shù)組是一種有序的struct。
Go 語言的數(shù)組有兩種不同的創(chuàng)建方式，一種是顯示的初始化，一種是隱式的初始化。
注意一定是使用 [...]T 進(jìn)行創(chuàng)建，使用三個(gè)點(diǎn)的隱式創(chuàng)建，編譯器會對數(shù)組的大小進(jìn)行推導(dǎo)，只是Go提供的一種語法糖。
其次，Go中數(shù)組的類型，是由數(shù)值類型和長度兩個(gè)一起確定的。[2]int 和 [3]int 不是同一個(gè)類型，不能進(jìn)行傳參和比較，把數(shù)組理解為類型和長度兩個(gè)屬性的結(jié)構(gòu)體，其實(shí)就一目了然了。
Go中的數(shù)組屬于值類型，通常應(yīng)該存儲于棧中，局部變量依然會根據(jù)逃逸分析確定存儲棧還是堆中。
編譯器對數(shù)組函數(shù)中做兩種不同的優(yōu)化：
在靜態(tài)區(qū)完成賦值后復(fù)制到棧中。
總結(jié)起來，在不考慮逃逸分析的情況下，如果數(shù)組中元素的個(gè)數(shù)小于或者等于 4 個(gè)，那么所有的變量會直接在棧上初始化，如果數(shù)組元素大于 4 個(gè)，變量就會在靜態(tài)存儲區(qū)初始化然后拷貝到棧上。
由于數(shù)組是值類型，那么賦值和函數(shù)傳參操作都會復(fù)制整個(gè)數(shù)組數(shù)據(jù)。
不管是賦值或函數(shù)傳參，地址都不一致，發(fā)生了拷貝。如果數(shù)組的數(shù)據(jù)較大，則會消耗掉大量內(nèi)存。那么為了減少拷貝我們可以主動的傳遞指針呀。
地址是一樣的，不過傳指針會有一個(gè)弊端，從打印結(jié)果可以看到，指針地址都是同一個(gè)，萬一原數(shù)組的指針指向更改了，那么函數(shù)里面的指針指向都會跟著更改。
同樣的我們將數(shù)組轉(zhuǎn)換為切片，通過傳遞切片，地址是不一樣的，數(shù)組值相同。
切片是引用傳遞，所以它們不需要使用額外的內(nèi)存并且比使用數(shù)組更有效率。
所以，切片屬于引用類型。
通過這種方式可以將數(shù)組轉(zhuǎn)換為切片。
中間不加三個(gè)點(diǎn)就是切片,使用這種方式創(chuàng)建切片，實(shí)際上是先創(chuàng)建數(shù)組，然后再通過第一種方式創(chuàng)建。
使用make創(chuàng)建切片，就不光編譯期了，make創(chuàng)建切片會涉及到運(yùn)行期。1. 切片的大小和容量是否足夠小；
切片是否發(fā)生了逃逸，最終在堆上初始化。如果切片小的話會先在?；蜢o態(tài)區(qū)進(jìn)行創(chuàng)建。
切片有一個(gè)數(shù)組的指針，len是指切片的長度, cap指的是切片的容量。
cap是在初始化切片是生成的容量。
發(fā)現(xiàn)切片的結(jié)構(gòu)體是數(shù)組的地址指針array unsafe.Pointer，而Go中數(shù)組的地址代表數(shù)組結(jié)構(gòu)體的地址。
slice 中得到一塊內(nèi)存地址，array[0]或者unsafe.Pointer(array[0])。
也可以通過地址構(gòu)造切片
nil切片：指的unsafe.Pointer 為nil
空切片：
創(chuàng)建的指針不為空，len和cap為空
當(dāng)一個(gè)切片的容量滿了，就需要擴(kuò)容了。怎么擴(kuò)，策略是什么？
如果原來數(shù)組切片的容量已經(jīng)達(dá)到了最大值，再想擴(kuò)容， Go 默認(rèn)會先開一片內(nèi)存區(qū)域，把原來的值拷貝過來，然后再執(zhí)行 append() 操作。這種情況對現(xiàn)數(shù)組的地址和原數(shù)組地址不相同。
從上面結(jié)果我們可以看到，如果用 range 的方式去遍歷一個(gè)切片，拿到的 Value 其實(shí)是切片里面的值拷貝,即淺拷貝。所以每次打印 Value 的地址都不變。
由于 Value 是值拷貝的，并非引用傳遞，所以直接改 Value 是達(dá)不到更改原切片值的目的的，需要通過 slice[index] 獲取真實(shí)的地址。
隊(duì)列的概念在 順序隊(duì)列 中，而使用循環(huán)隊(duì)列的目的主要是規(guī)避假溢出造成的空間浪費(fèi)，在使用循環(huán)隊(duì)列處理假溢出時(shí)，主要有三種解決方案
本文提供后兩種解決方案。
順序隊(duì)和循環(huán)隊(duì)列是一種特殊的線性表，與順序棧類似，都是使用一組地址連續(xù)的存儲單元依次存放自隊(duì)頭到隊(duì)尾的數(shù)據(jù)元素，同時(shí)附設(shè)隊(duì)頭(front)和隊(duì)尾(rear)兩個(gè)指針，但我們要明白一點(diǎn)，這個(gè)指針并不是指針變量，而是用來表示數(shù)組當(dāng)中元素下標(biāo)的位置。
本文使用切片來完成的循環(huán)隊(duì)列，由于一開始使用三個(gè)參數(shù)的make關(guān)鍵字創(chuàng)建切片，在輸出的結(jié)果中不包含nil值(看起來很舒服)，而且在驗(yàn)證的過程中發(fā)現(xiàn)使用append()函數(shù)時(shí)切片內(nèi)置的cap會發(fā)生變化，在消除了種種障礙后得到了一個(gè)四不像的循環(huán)隊(duì)列，即設(shè)置的指針是順序隊(duì)列的指針，但實(shí)際上進(jìn)行的操作是順序隊(duì)列的操作。最后是對make()函數(shù)和append()函數(shù)的一些使用體驗(yàn)和小結(jié)，隊(duì)列的應(yīng)用放在鏈隊(duì)好了。
官方描述(片段)
即切片是一個(gè)抽象層，底層是對數(shù)組的引用。
當(dāng)我們使用
構(gòu)建出來的切片的每個(gè)位置的值都被賦為interface類型的初始值nil，但是nil值也是有大小的。
而使用
來進(jìn)行初始化時(shí)，雖然生成的切片中不包含nil值，但是無法通過設(shè)置的指針變量來完成入隊(duì)和出隊(duì)的操作，只能使用append()函數(shù)來進(jìn)行操作
在go語言中，切片是一片連續(xù)的內(nèi)存空間加上長度與容量的標(biāo)識，比數(shù)組更為常用。使用 append 關(guān)鍵字向切片中追加元素也是常見的切片操作
正是基于此，在使用go語言完成循環(huán)隊(duì)列時(shí)，首先想到的就是使用make(type, len, cap)關(guān)鍵字方式完成切片初始化，然后使用append()函數(shù)來操作該切片，但這一方式出現(xiàn)了很多問題。在使用append()函數(shù)時(shí)，切片的cap可能會發(fā)生變化，用不好就會發(fā)生擴(kuò)容或收縮。最終造成的結(jié)果是一個(gè)四不像的結(jié)果，入隊(duì)和出隊(duì)操作變得與指針變量無關(guān)，失去了作為循環(huán)隊(duì)列的意義，用在順序隊(duì)列還算合適。
參考博客：
Go語言中的Nil
Golang之nil
Go 語言設(shè)計(jì)與實(shí)現(xiàn)
Go語言標(biāo)準(zhǔn)庫中提供了sort包對整型，浮點(diǎn)型，字符串型切片進(jìn)行排序，檢查一個(gè)切片是否排好序，使用二分法搜索函數(shù)在一個(gè)有序切片中搜索一個(gè)元素等功能。
關(guān)于sort包內(nèi)的函數(shù)說明與使用，請查看
在這里簡單講幾個(gè)sort包中常用的函數(shù)
在Go語言中，對字符串的排序都是按照字節(jié)排序，也就是說在對字符串排序時(shí)是區(qū)分大小寫的。
二分搜索算法
Go語言中提供了一個(gè)使用二分搜索算法的sort.Search(size,fn)方法：每次只需要比較㏒?n個(gè)元素，其中n為切片中元素的總數(shù)。
sort.Search(size,fn)函數(shù)接受兩個(gè)參數(shù)：所處理的切片的長度和一個(gè)將目標(biāo)元素與有序切片的元素相比較的函數(shù)，該函數(shù)是一個(gè)閉包，如果該有序切片是升序排列，那么在判斷時(shí)使用 有序切片的元素 = 目標(biāo)元素。該函數(shù)返回一個(gè)int值，表示與目標(biāo)元素相同的切片元素的索引。
在切片中查找出某個(gè)與目標(biāo)字符串相同的元素索引
注：本文是對 golang-101-hacks 中文翻譯。
在Go語言中，函數(shù)參數(shù)是值傳遞。使用slice作為函數(shù)參數(shù)時(shí)，函數(shù)獲取到的是slice的副本:一個(gè)指針，指向底層數(shù)組的起始地址，同時(shí)帶有slice的長度和容量。既然各位熟知數(shù)據(jù)存儲的內(nèi)存的地址，現(xiàn)在可以對切片數(shù)據(jù)進(jìn)行修改。讓我們看看下面的例子:
In Go, the function parameters are passed by value. With respect to use slice as a function argument, that means the function will get the copies of the slice: a pointer which points to the starting address of the underlying array, accompanied by the length and capacity of the slice. Oh boy! Since you know the address of the memory which is used to store the data, you can tweak the slice now. Let's see the following example:
運(yùn)行結(jié)果如下
由此可見，執(zhí)行modifyValue函數(shù)，切片s的元素發(fā)生了變化。盡管modifyValue函數(shù)只是操作slice的副本，但是任然改變了切片的數(shù)據(jù)元素，看另一個(gè)例子:
You can see, after running modifyValue function, the content of slice s is changed. Although the modifyValue function just gets a copy of the memory address of slice's underlying array, it is enough!
See another example:
The result is like this:
而這一次，addValue函數(shù)并沒有修改main函數(shù)中的切片s的元素。這是因?yàn)樗皇遣僮髑衅瑂的副本，而不是切片s本身。所以如果真的想讓函數(shù)改變切片的內(nèi)容，可以傳遞切片的地址:
This time, the addValue function doesn't take effect on the s slice in main function. That's because it just manipulate the copy of the s, not the "real" s.
So if you really want the function to change the content of a slice, you can pass the address of the slice:
運(yùn)行結(jié)果如下
Go語言作為出現(xiàn)比較晚的一門編程語言，在其原生支持高并發(fā)、云原生等領(lǐng)域的優(yōu)秀表現(xiàn)，像目前比較流行的容器編排技術(shù)Kubernetes、容器技術(shù)Docker都是用Go語言寫的，像Java等其他面向?qū)ο蟮恼Z言，雖然也能做云原生相關(guān)的開發(fā)，但是支持的程度遠(yuǎn)沒有Go語言高，憑借其語言特性和簡單的編程方式，彌補(bǔ)了其他編程語言一定程度上的不足，一度成為一個(gè)熱門的編程語言。
最近在學(xué)習(xí)Go語言，我之前使用過C#、Java等面向?qū)ο缶幊痰恼Z言，發(fā)現(xiàn)其中有很多的編程方式和其他語言有區(qū)別的地方，好記性不如爛筆頭，總結(jié)一下，和其他語言做個(gè)對比。這里只總結(jié)差異的地方，具體的語法不做詳細(xì)的介紹。
種一棵樹最好的時(shí)間是十年前，其次是現(xiàn)在。
3)變量初始化時(shí)候可以和其他語言一樣直接在變量后面加等號，等號后面為要初始化的值，也可以使用變量名：=變量值的簡單方式
3）變量賦值 Go語言的變量賦值和多數(shù)語言一致，但是Go語言提供了多重賦值的功能，比如下面這個(gè)交換i、j變量的語句：
在不支持多重賦值的語言中，交換兩個(gè)變量的值需要引入一個(gè)中間變量：
4)匿名變量
在使用其他語言時(shí)，有時(shí)候要獲取一個(gè)值，卻因?yàn)樵摵瘮?shù)返回多個(gè)值而不得不定義很多沒有的變量，Go語言可以借助多重返回值和匿名變量來避免這種寫法，使代碼看起來更優(yōu)雅。
假如GetName()函數(shù)返回3個(gè)值，分別是firstName,lastName和nickName
若指向獲得nickName，則函數(shù)調(diào)用可以這樣寫
這種寫法可以讓代碼更清晰，從而大幅降低溝通的復(fù)雜度和維護(hù)的難度。
1）基本常量
常量使用關(guān)鍵字const 定義，可以限定常量類型，但不是必須的，如果沒有定義常量的類型，是無類型常量
2）預(yù)定義常量
Go語言預(yù)定義了這些常量 true、false和iota
iota比較特殊，可以被任務(wù)是一個(gè)可被編譯器修改的常量，在每個(gè)const關(guān)鍵字出現(xiàn)時(shí)被重置為0，然后在下一個(gè)const出現(xiàn)之前每出現(xiàn)一個(gè)iota，其所代表的數(shù)字會自動加1.
3)枚舉
1）int 和int32在Go語言中被認(rèn)為是兩種不同類型的類型
2）Go語言定義了兩個(gè)浮點(diǎn)型float32和float64，其中前者等價(jià)于C語言的float類型，后者等價(jià)于C語言的double類型
3）go語言支持復(fù)數(shù)類型
復(fù)數(shù)實(shí)際上是由兩個(gè)實(shí)數(shù)（在計(jì)算機(jī)中使用浮點(diǎn)數(shù)表示）構(gòu)成，一個(gè)表示實(shí)部（real）、一個(gè)表示虛部（imag）。也就是數(shù)學(xué)上的那個(gè)復(fù)數(shù)
復(fù)數(shù)的表示
實(shí)部與虛部
對于一個(gè)復(fù)數(shù)z=complex(x,y),就可以通過Go語言內(nèi)置函數(shù)real(z)獲得該復(fù)數(shù)的實(shí)部，也就是x，通過imag(z)獲得該復(fù)數(shù)的虛部，也就是y
4）數(shù)組(值類型，長度在定義后無法再次修改，每次傳遞都將產(chǎn)生一個(gè)副本。)
5）數(shù)組切片（slice）
數(shù)組切片（slice）彌補(bǔ)了數(shù)組的不足，其數(shù)據(jù)結(jié)構(gòu)可以抽象為以下三個(gè)變量：
6）Map 在go語言中Map不需要引入任何庫，使用很方便
Go循環(huán)語句只支持for關(guān)鍵字，不支持while和do-while
goto語句的語義非常簡單，就是跳轉(zhuǎn)到本函數(shù)內(nèi)的某個(gè)標(biāo)簽
今天就介紹到這里，以后我會在總結(jié)Go語言在其他方面比如并發(fā)編程、面向?qū)ο?、網(wǎng)絡(luò)編程等方面的不同及使用方法。希望對大家有所幫助。
重慶分公司
重慶分公司
