?

Go語言學習點

go?mod搭建開發環境

基礎語法要熟悉

gin框架與公司的trpc-go框架

?

?

快速開始

在真正開始之前，首先需要掌握基本理論知識，包括但不限于：

• Go語言基礎，所有一切的基石，務必遵循RPC-Go研發規范。
• context原理，必須提前了解，特別是對超時控制的理解會很有幫助。
• rpc概念，調用遠程服務接口就像調用本地函數一樣，能讓你更容易創建分布式應用。
• proto3知識，描述服務接口的跨語言協議，簡單，方便，通用。
• ?

推薦書籍

《Go語言圣經（中文版）》

https://books.studygolang.com/gopl-zh/

《Go程序設計語言》The Go programming language

?

《Go語言圣經（中文版）》學習筆記

前言

Go語言是從Ken Thompson發明的B語言、Dennis M. Ritchie發明的C語言逐步演化過來的，是C語言家族的成員，因此很多人將Go語言稱為21世紀的C語言。縱觀這幾年來的發展趨勢，Go語言已經成為云計算、云存儲時代最重要的基礎編程語言。

同時，單憑閱讀和學習其語法結構并不能真正地掌握一門編程語言，必須進行足夠多的編程實踐——親自編寫一些程序并研究學習別人寫的程序。要從利用Go語言良好的特性使得程序模塊化，充分利用Go的標準函數庫以Go語言自己的風格來編寫程序。

Go語言由來自Google公司的Robert Griesemer，Rob Pike和Ken Thompson三位大牛于2007年9月開始設計和實現，然后于2009年的11月對外正式發布。

Go語言中和并發編程相關的特性是全新的也是有效的，同時對數據抽象和面向對象編程的支持也很靈活。 Go語言同時還集成了自動垃圾收集技術用于更好地管理內存。?

Go語言已經成為受歡迎的作為無類型的腳本語言的替代者： 因為Go編寫的程序通常比腳本語言運行的更快也更安全，而且很少會發生意外的類型錯誤。

?

Go從C語言繼承了相似的表達式語法、控制流結構、基礎數據類型、調用參數傳值、指針等很多思想，還有C語言一直所看中的編譯后機器碼的運行效率以及和現有操作系統的無縫適配。

“軟件的復雜性是乘法級相關的”，通過增加一個部分的復雜性來修復問題通常將慢慢地增加其他部分的復雜性。通過增加功能、選項和配置是修復問題的最快的途徑，但是這很容易讓人忘記簡潔的內涵，即從長遠來看，簡潔依然是好軟件的關鍵因素。

Go語言的這些地方都做的還不錯：擁有自動垃圾回收、一個包系統、函數作為一等公民、詞法作用域、系統調用接口、只讀的UTF8字符串等。

但是Go語言本身只有很少的特性，也不太可能添加太多的特性。例如，它沒有隱式的數值轉換，沒有構造函數和析構函數，沒有運算符重載，沒有默認參數，也沒有繼承，沒有泛型，沒有異常，沒有宏，沒有函數修飾，更沒有線程局部存儲。但是，語言本身是成熟和穩定的，而且承諾保證向后兼容：用之前的Go語言編寫程序可以用新版本的Go語言編譯器和標準庫直接構建而不需要修改代碼。

入門

先了解幾個Go程序，涉及的主題從簡單的文件處理、圖像處理到互聯網客戶端和服務端并發。

Go語言在代碼格式上采取了很強硬的態度。gofmt工具把代碼格式化為標準格式（譯注：這個格式化工具沒有任何可以調整代碼格式的參數，Go語言就是這么任性），并且go工具中的fmt子命令會對指定包，否則默認為當前目錄中所有.go源文件應用gofmt命令。

1.1. Hello, World

Go語言的代碼通過包（package）組織，包類似于其它語言里的庫（libraries）或者模塊（modules）。一個包由位于單個目錄下的一個或多個.go源代碼文件組成，目錄定義包的作用。每個源文件都以一條package聲明語句開始，這個例子里就是package main，表示該文件屬于哪個包，緊跟著一系列導入（import）的包，之后是存儲在這個文件里的程序語句。

import聲明必須跟在文件的package聲明之后。隨后，則是組成程序的函數、變量、常量、類型的聲明語句（分別由關鍵字func、var、const、type定義）。

一個函數的聲明由func關鍵字、函數名、參數列表、返回值列表以及包含在大括號里的函數體組成。

1.2. 命令行參數

os包以跨平臺的方式，提供了一些與操作系統交互的函數和變量。程序的命令行參數可從os包的Args變量獲取；os包外部使用os.Args訪問該變量。os.Args變量是一個字符串（string）的切片（slice）。os.Args的第一個元素：os.Args[0]，是命令本身的名字；其它的元素則是程序啟動時傳給它的參數。

?

注釋語句以//開頭。按照慣例，我們在每個包的包聲明前添加注釋；對于main package，注釋包含一句或幾句話，從整體角度對程序做個描述。

?

?

符號:=是短變量聲明（short variable declaration）的一部分，這是定義一個或多個變量并根據它們的初始值為這些變量賦予適當類型的語句。

Go語言只有for循環這一種循環語句。for循環有多種形式，其中一種如下所示：

for initialization; condition; post {// zero or more statements }

• initialization語句是可選的，在循環開始前執行。initalization如果存在，必須是一條簡單語句（simple statement），即，短變量聲明、自增語句、賦值語句或函數調用。
• condition是一個布爾表達式（boolean expression），其值在每次循環迭代開始時計算。如果為true則執行循環體語句。
• post語句在循環體執行結束后執行，之后再次對condition求值。condition值為false時，循環結束。

?

range產生一對值；索引以及在該索引處的元素值。（blank identifier），即_（也就是下劃線）。空標識符可用于在任何語法需要變量名但程序邏輯不需要的時候（如：在循環里）丟棄不需要的循環索引

?

聲明一個變量有好幾種方式，主要用下面的前兩種，下面這些都等價：

s := "" // 短變量聲明，最簡潔，但只能用在函數內部，而不能用于包變量 var s string // 依賴于字符串的默認初始化零值機制，被初始化為"" var s = "" var s string = ""

?

1.3. 查找重復的行

從功能和實現上說，Go的map類似于Java語言中的HashMap，Python語言中的dict，通常使用hash實現。map中不含某個鍵時不用擔心，首次讀到新行時，等號右邊的表達式counts[line]的值將被計算為其類型的零值，對于int即0。

?

bufio包，它使處理輸入和輸出方便又高效。Scanner類型是該包最有用的特性之一，它讀取輸入并將其拆成行或單詞；通常是處理行形式的輸入最簡單的方法。

每次調用input.Scan()，即讀入下一行，并移除行末的換行符；讀取的內容可以調用input.Text()得到。Scan函數在讀到一行時返回true，不再有輸入時返回false。

?

fmt.Printf函數對一些表達式產生格式化輸出。該函數的首個參數是個格式字符串，指定后續參數被如何格式化。各個參數的格式取決于“轉換字符”（conversion character），形式為百分號后跟一個字母。舉個例子，%d表示以十進制形式打印一個整型操作數，而%s則表示把字符串型操作數的值展開。

默認情況下，Printf不會換行。按照慣例，以字母f結尾的格式化函數，如log.Printf和fmt.Errorf，都采用fmt.Printf的格式化準則。

而以ln結尾的格式化函數，則遵循Println的方式，以跟%v差不多的方式格式化參數，并在最后添加一個換行符。（譯注：后綴f指format，ln指line。）

Printf有一大堆這種轉換，Go程序員稱之為動詞（verb）。下面的表格雖然遠不是完整的規范，但展示了可用的很多特性：

%d 十進制整數 %x, %o, %b 十六進制，八進制，二進制整數。 %f, %g, %e 浮點數： 3.141593 3.141592653589793 3.141593e+00 %t 布爾：true或false %c 字符（rune） (Unicode碼點) %s 字符串 %q 帶雙引號的字符串"abc"或帶單引號的字符'c' %v 變量的自然形式（natural format） %T 變量的類型 %% 字面上的百分號標志（無操作數）

?

os.Open函數返回兩個值。第一個值是被打開的文件(*os.File），其后被Scanner讀取。

os.Open返回的第二個值是內置error類型的值。如果err的值不是nil，說明打開文件時出錯了。如果err等于內置值nil（譯注：相當于其它語言里的NULL），那么文件被成功打開。讀取文件，直到文件結束，然后調用Close關閉該文件，并釋放占用的所有資源。

?

?

1.5. 獲取URL

對于很多現代應用來說，訪問互聯網上的信息和訪問本地文件系統一樣重要。Go語言在net這個強大package的幫助下提供了一系列的package來做這件事情，使用這些包可以更簡單地用網絡收發信息，還可以建立更底層的網絡連接，編寫服務器程序。在這些情景下，Go語言原生的并發特性（在第八章中會介紹）顯得尤其好用。

• net/http和io/ioutil包，http.Get函數是創建HTTP請求的函數，如果獲取過程沒有出錯，那么會在resp這個結構體中得到訪問的請求結果。resp的Body字段包括一個可讀的服務器響應流。
• ioutil.ReadAll函數從response中讀取到全部內容；將其結果保存在變量b中。
• resp.Body.Close關閉resp的Body流，防止資源泄露，Printf函數會將結果b寫出到標準輸出流中。

// Fetch prints the content found at a URL. package mainimport ("fmt""io/ioutil""net/http""os" )func main() {for _, url := range os.Args[1:] {resp, err := http.Get(url)if err != nil {fmt.Fprintf(os.Stderr, "fetch: %v\n", err)os.Exit(1)}b, err := ioutil.ReadAll(resp.Body)resp.Body.Close()if err != nil {fmt.Fprintf(os.Stderr, "fetch: reading %s: %v\n", url, err)os.Exit(1)}fmt.Printf("%s", b)} }

1.6. 并發獲取多個URL

Go語言最有意思并且最新奇的特性就是對并發編程的支持。

goroutine是一種函數的并發執行方式，

而channel是用來在goroutine之間進行參數傳遞。

main函數本身也運行在一個goroutine中，而go function則表示創建一個新的goroutine，并在這個新的goroutine中執行這個函數。

// Fetchall fetches URLs in parallel and reports their times and sizes. package mainimport ("fmt""io""io/ioutil""net/http""os""time" )func main() {start := time.Now()ch := make(chan string)for _, url := range os.Args[1:] {go fetch(url, ch) // start a goroutine}for range os.Args[1:] {fmt.Println(<-ch) // receive from channel ch}fmt.Printf("%.2fs elapsed\n", time.Since(start).Seconds()) }func fetch(url string, ch chan<- string) {start := time.Now()resp, err := http.Get(url)if err != nil {ch <- fmt.Sprint(err) // send to channel chreturn}nbytes, err := io.Copy(ioutil.Discard, resp.Body)resp.Body.Close() // don't leak resourcesif err != nil {ch <- fmt.Sprintf("while reading %s: %v", url, err)return}secs := time.Since(start).Seconds()ch <- fmt.Sprintf("%.2fs %7d %s", secs, nbytes, url) }

main函數中用make函數創建了一個傳遞string類型參數的channel，對每一個命令行參數，我們都用go這個關鍵字來創建一個goroutine，并且讓函數在這個goroutine異步執行http.Get方法。這個程序里的io.Copy會把響應的Body內容拷貝到ioutil.Discard輸出流中（譯注：可以把這個變量看作一個垃圾桶，可以向里面寫一些不需要的數據），因為我們需要這個方法返回的字節數，但是又不想要其內容。每當請求返回內容時，fetch函數都會往ch這個channel里寫入一個字符串，由main函數里的第二個for循環來處理并打印channel里的這個字符串。

?

1.7. Web服務

?

1.8. 本章要點

if控制和for，進一步提到switch多路選擇。

switch coinflip() { case "heads":heads++ case "tails":tails++ default:fmt.Println("landed on edge!") }// example: tagless switch func Signum(x int) int {switch {case x > 0:return +1default:return 0case x < 0:return -1} }

break和continue語句會改變控制流。和其它語言中的break和continue一樣，break會中斷當前的循環，并開始執行循環之后的內容，而continue會跳過當前循環，并開始執行下一次循環。這兩個語句除了可以控制for循環，還可以用來控制switch和select語句（之后會講到）

多行注釋可以用?/* ... */

現成的包

在你開始寫一個新程序之前，最好先去檢查一下是不是已經有了現成的庫可以幫助你更高效地完成這件事情。你可以在?https://golang.org/pkg?和?https://godoc.org?中找到標準庫和社區寫的package。

godoc這個工具可以讓你直接在本地命令行閱讀標準庫的文檔。比如下面這個例子。

?

程序結構

2.1. 命名

命名規則：一個名字必須以一個字母（Unicode字母）或下劃線開頭，后面可以跟任意數量的字母、數字或下劃線。

如果一個名字是在函數內部定義，那么它就只在函數內部有效。如果是在函數外部定義，那么將在當前包的所有文件中都可以訪問。

名字的開頭字母的大小寫決定了名字在包外的可見性。如果一個名字是大寫字母開頭的（譯注：必須是在函數外部定義的包級名字；包級函數名本身也是包級名字），那么它將是導出的，也就是說可以被外部的包訪問，例如fmt包的Printf函數就是導出的，可以在fmt包外部訪問。包本身的名字一般總是用小寫字母。

2.2. 聲明

Go語言主要有四種類型的聲明語句：var、const、type和func，分別對應變量、常量、類型和函數實體對象的聲明。

一個Go語言編寫的程序對應一個或多個以.go為文件后綴名的源文件。每個源文件中以包的聲明語句開始，說明該源文件是屬于哪個包。包聲明語句之后是import語句導入依賴的其它包，然后是包一級的類型、變量、常量、函數的聲明語句，

2.3. 變量

聲明一個變量有好幾種方式，主要用下面的前兩種，下面這些都等價：

s := "" // 短變量聲明，最簡潔，但只能用在函數內部，而不能用于包變量 var s string // 依賴于字符串的默認初始化零值機制，被初始化為"" var s = "" var s string = ""

可以在一個聲明語句中同時聲明一組變量，或用一組初始化表達式聲明并初始化一組變量。

一組變量也可以通過調用一個函數，由函數返回的多個返回值初始化：

var i, j, k int // int, int, int var b, f, s = true, 2.3, "four" // bool, float64, stringvar f, err = os.Open(name) // os.Open returns a file and an error

2.3.1. 簡短變量聲明

請記住“:=”是一個變量聲明語句，而“=”是一個變量賦值操作。

?

在下面的代碼中，第一個語句聲明了in和err兩個變量。在第二個語句只聲明了out一個變量，然后對已經聲明的err進行了賦值操作。

in, err := os.Open(infile) // ... out, err := os.Create(outfile)

簡短變量聲明語句中必須至少要聲明一個新的變量，下面的代碼將不能編譯通過：

f, err := os.Open(infile) // ... f, err := os.Create(outfile) // compile error: no new variables

解決的方法是第二個簡短變量聲明語句改用普通的多重賦值語句。

2.3.2. 指針

一個指針的值是另一個變量的地址。一個指針對應變量在內存中的存儲位置。

并不是每一個值都會有一個內存地址，但是對于每一個變量必然有對應的內存地址。

通過指針，我們可以直接讀或更新對應變量的值，而不需要知道該變量的名字（如果變量有名字的話）。

?

• “var x int”聲明語句聲明一個x變量，
• &x表達式（取x變量的內存地址）將產生一個指向該整數變量的指針，指針對應的數據類型是*int，指針被稱之為“指向int類型的指針”。
• p為指針名字，那么可以說“p指針指向變量x”，或者說“p指針保存了x變量的內存地址”。
• *p表達式對應p指針指向的變量的值。一般*p表達式讀取指針指向的變量的值，這里為int類型的值，同時因為*p對應一個變量，所以該表達式也可以出現在賦值語句的左邊，表示更新指針所指向的變量的值。

x := 1 p := &x // p, of type *int, points to x fmt.Println(*p) // "1" *p = 2 // equivalent to x = 2 fmt.Println(x) // "2"

?

變量有時候被稱為可尋址的值。

2.3.3. new函數

另一個創建變量的方法是調用內建的new函數。表達式new(T)將創建一個T類型的匿名變量，初始化為T類型的零值，然后返回變量地址，返回的指針類型為*T。

p := new(int) // p, *int 類型, 指向匿名的 int 變量 fmt.Println(*p) // "0" *p = 2 // 設置 int 匿名變量的值為 2 fmt.Println(*p) // "2"

new函數類似是一種語法糖，而不是一個新的基礎概念。下面的兩個newInt函數有著相同的行為：

func newInt() *int {return new(int) }func newInt() *int {var dummy intreturn &dummy }

每次調用new函數都是返回一個新的變量的地址，因此下面兩個地址是不同的：

p := new(int) q := new(int) fmt.Println(p == q) // "false"

new函數使用通常相對比較少，因為對于結構體來說，直接用字面量語法創建新變量的方法會更靈活

?

3.4. 布爾型

&&的優先級比||高

布爾值并不會隱式轉換為數字值0或1，反之亦然。必須使用一個顯式的if語句輔助轉換：

i := 0 if b {i = 1 }

3.5. 字符串

第i個字節并不一定是字符串的第i個字符，因為對于非ASCII字符的UTF8編碼會要兩個或多個字節。

因為字符串是不可修改的，因此嘗試修改字符串內部數據的操作也是被禁止的。但是可以 += 拼接新的字符串。

3.5.5. 字符串和數字的轉換

整數轉為字符串，一種方法是用fmt.Sprintf返回一個格式化的字符串；另一個方法是用strconv.Itoa(“整數到ASCII”)：

x := 123 y := fmt.Sprintf("%d", x) z := strconv.Itoa(x)) // "123"

字符串解析為整數，可以使用strconv包的Atoi或ParseInt函數，還有用于解析無符號整數的ParseUint函數：

x, err := strconv.Atoi("123") // x is an int y, err := strconv.ParseInt("123", 10, 64) // base 10, up to 64 bits

3.6. 常量

const (e = 2.71828182845904523536028747135266249775724709369995957496696763pi = 3.14159265358979323846264338327950288419716939937510582097494459 )

如果是批量聲明的常量，除了第一個外其它的常量右邊的初始化表達式都可以省略，如果省略初始化表達式則表示使用前面常量的初始化表達式寫法，對應的常量類型也一樣的。例如：

const (a = 1bc = 2d )fmt.Println(a, b, c, d) // "1 1 2 2"

3.6.1. iota 常量生成器

定義了一個Weekday命名類型，然后為一周的每天定義了一個常量，從周日0開始。在其它編程語言中，這種類型一般被稱為枚舉類型。

type Weekday intconst (Sunday Weekday = iotaMondayTuesdayWednesdayThursdayFridaySaturday )

?

第四章　復合數據類型

4.1. 數組

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

“...”省略號，則表示數組的長度是根據初始化值的個數來計算。

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

數組、slice、map和結構體字面值的寫法都很相似。

symbol := [...]string{USD: "$", EUR: "€", GBP: "￡", RMB: "￥"}r := [...]int{99: -1} // 定義了一個含有100個元素的數組r，最后一個元素被初始化為-1，其它元素都是用0初始化。

?

4.2. Slice

一個slice由三個部分構成：指針、長度和容量。

• 指針指向第一個slice元素對應的底層數組元素的地址，要注意的是slice的第一個元素并不一定就是數組的第一個元素。
• 長度對應slice中元素的數目；長度不能超過容量.
• 容量一般是從slice的開始位置到底層數據的結尾位置。內置的len和cap函數分別返回slice的長度和容量。

?

slice的元素是間接引用的，一個固定的slice值（譯注：指slice本身的值，不是元素的值）在不同的時刻可能包含不同的元素，因為底層數組的元素可能會被修改。

如果你需要測試一個slice是否是空的，使用len(s) == 0來判斷

內置的make函數創建一個指定元素類型、長度和容量的slice。容量部分可以省略，在這種情況下，容量將等于長度。

make([]T, len) make([]T, len, cap) // same as make([]T, cap)[:len]

?

內置的append函數則可以追加多個元素，甚至追加一個slice。

var x []int x = append(x, 1) x = append(x, 2, 3) x = append(x, 4, 5, 6) x = append(x, x...) // append the slice x

4.3. Map

一個map就是一個哈希表的引用，map類型可以寫為map[K]V，其中K和V分別對應key和value。

map中所有的key都有相同的類型，所有的value也有著相同的類型，但是key和value之間可以是不同的數據類型。

map中的元素并不是一個變量，因此我們不能對map的元素進行取址操作

ages := make(map[string]int) // mapping from strings to intsges := map[string]int{"alice": 31,"charlie": 34, }delete(ages, "alice") // remove element ages["alice"]ages["bob"]++ // 等價于ages["bob"] += 1/*所有這些操作是安全的，即使這些元素不在map中也沒有關系；如果一個查找失敗將返回value類型對應的零值，例如，即使map中不存在“bob”下面的代碼也可以正常工作，因為ages["bob"]失敗時將返回0。*/ ages["bob"] = ages["bob"] + 1 // happy birthday!

Map的迭代順序是不確定的.

如果要按順序遍歷key/value對，我們必須顯式地對key進行排序，可以使用sort包的Strings函數對字符串slice進行排序。下面是常見的處理方式

// 我們必須顯式地對key進行排序，可以使用sort包的Strings函數對字符串slice進行排序。import "sort"var names []stringsort.Strings(names)

因為我們一開始就知道names的最終大小，因此給slice分配一個合適的大小將會更有效。下面的代碼創建了一個空的slice，但是slice的容量剛好可以放下map中全部的key：

names := make([]string, 0, len(ages))

?

4.4. 結構體

type Employee struct {ID intName stringAddress stringDoB time.TimePosition stringSalary intManagerID int }var dilbert Employeeposition := &dilbert.Position *position = "Senior " + *position // promoted, for outsourcing to Elboniavar employeeOfTheMonth *Employee = &dilbert employeeOfTheMonth.Position += " (proactive team player)"

?

4.4.1. 結構體字面值

結構體值也可以用結構體字面值表示，結構體字面值可以指定每個成員的值。

type Point struct{ X, Y int }p := Point{1, 2}

?

第五章　函數

函數的類型被稱為函數的簽名。

如果兩個函數形式參數列表和返回值列表中的變量類型一一對應，那么這兩個函數被認為有相同的類型或簽名。

?

5.4. 錯誤

在Go的錯誤處理中，錯誤是軟件包API和應用程序用戶界面的一個重要組成部分

內置的error是接口類型。error類型可能是nil或者non-nil。nil意味著函數運行成功，non-nil表示失敗。

對于non-nil的error類型，我們可以通過調用error的Error函數或者輸出函數獲得字符串類型的錯誤信息。

fmt.Println(err) fmt.Printf("%v", err)

5.4.1. 錯誤處理策略

最常用的方式是傳播錯誤。這意味著函數中某個子程序的失敗，會變成該函數的失敗。

doc, err := html.Parse(resp.Body) resp.Body.Close() if err != nil {return nil, fmt.Errorf("parsing %s as HTML: %v", url,err) }

fmt.Errorf函數使用fmt.Sprintf格式化錯誤信息并返回。我們使用該函數添加額外的前綴上下文信息到原始錯誤信息。當錯誤最終由main函數處理時，錯誤信息應提供清晰的從原因到后果的因果鏈。

由于錯誤信息經常是以鏈式組合在一起的，所以錯誤信息中應避免大寫和換行符。

第二種策略：重試機制

// WaitForServer attempts to contact the server of a URL. // It tries for one minute using exponential back-off. // It reports an error if all attempts fail. func WaitForServer(url string) error {const timeout = 1 * time.Minutedeadline := time.Now().Add(timeout)for tries := 0; time.Now().Before(deadline); tries++ {_, err := http.Head(url)if err == nil {return nil // success}log.Printf("server not responding (%s);retrying…", err)time.Sleep(time.Second << uint(tries)) // exponential back-off}return fmt.Errorf("server %s failed to respond after %s", url, timeout) }

第三種策略：輸出錯誤信息并結束程序。這種策略只應在main中執行

if err := WaitForServer(url); err != nil {log.Fatalf("Site is down: %v\n", err) }

第四種策略：有時，我們只需要輸出錯誤信息就足夠了，不需要中斷程序的運行。我們可以通過log包提供函數

if err := Ping(); err != nil {log.Printf("ping failed: %v; networking disabled",err) }

或者標準錯誤流輸出錯誤信息。log包中的所有函數會為沒有換行符的字符串增加換行符。

if err := Ping(); err != nil {fmt.Fprintf(os.Stderr, "ping failed: %v; networking disabled\n", err) }

第五種，也是最后一種策略：我們可以直接忽略掉錯誤。

dir, err := ioutil.TempDir("", "scratch") if err != nil {return fmt.Errorf("failed to create temp dir: %v",err) } // ...use temp dir… os.RemoveAll(dir) // ignore errors; $TMPDIR is cleaned periodically

Go中大部分函數的代碼結構幾乎相同，首先是一系列的初始檢查，防止錯誤發生，之后是函數的實際邏輯

5.7. 可變參數

在聲明可變參數函數時，需要在參數列表的最后一個參數類型之前加上省略符號“...”，這表示該函數會接收任意數量的該類型參數。

gopl.io/ch5/sum

func sum(vals ...int) int {total := 0for _, val := range vals {total += val}return total }

?

?

?

?

?

?

?

總結

以上是生活随笔為你收集整理的GO 编程语言的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。