[toc] # 1、列印資訊print各個區別 ```go 1. Println 列印的每一項之間都會有回車空行，Print 沒有 2. Printf是格式化輸出 func main() { a:=10 b:=20 c:=30 fmt.Println("a=", a , ",b=" , b , ",c=" , c) fmt.Printf("a=%d,b=%d,c=%d" , a , b , c) } 不加fmt，轉成ascill碼 ``` ## **1.1格式說明** | **格式** | **含義** | | :------- | :----------------------------------------------------------- | | %% | 一個%字面量 | | %b | 一個二進位制整數值(基數為2)，或者是一個(高階的)用科學計數法表示的指數為2的浮點數 | | %c | 字元型。可以把輸入的數字按照ASCII碼相應轉換為對應的字元 | | %d | 一個十進位制數值(基數為10) | | %e | 以科學記數法e表示的浮點數或者複數值 | | %E | 以科學記數法E表示的浮點數或者複數值 | | %f | 以標準記數法表示的浮點數或者複數值 | | %g | 以%e或者%f表示的浮點數或者複數，任何一個都以最為緊湊的方式輸出 | | %G | 以%E或者%f表示的浮點數或者複數，任何一個都以最為緊湊的方式輸出 | | %o | 一個以八進位制表示的數字(基數為8) | | %p | 以十六進位制(基數為16)表示的一個值的地址，字首為0x,字母使用小寫的a-f表示 | | %q | 使用Go語法以及必須時使用轉義，以雙引號括起來的字串或者位元組切片[]byte，或者是以單引號括起來的數字 | | %s | 字串。輸出字串中的字元直至字串中的空字元（字串以'\0‘結尾，這個'\0'即空字元） | | %t | 以true或者false輸出的布林值 | | %T | 使用Go語法輸出的值的型別 | | %U | 一個用Unicode表示法表示的整型碼點，預設值為4個數字字元 | | %v | 使用預設格式輸出的內建或者自定義型別的值，或者是使用其型別的String()方式輸出的自定義值，如果該方法存在的話 | | %x | 以十六進位制表示的整型值(基數為十六)，數字a-f使用小寫表示 | | %X | 以十六進位制表示的整型值(基數為十六)，數字A-F使用小寫表示 | ## **1.2輸出** ```go //整型 a := 15 fmt.Printf("a = %b\n", a) //a = 1111 fmt.Printf("%%\n") //只輸出一個% //字元 ch := 'a' fmt.Printf("ch = %c, %c\n", ch, 97) //a, a //浮點型 f := 3.14 fmt.Printf("f = %f, %g\n", f, f) //f = 3.140000, 3.14 fmt.Printf("f type = %T\n", f) //f type = float64 //複數型別 v := complex(3.2, 12) fmt.Printf("v = %f, %g\n", v, v) //v = (3.200000+12.000000i), (3.2+12i) fmt.Printf("v type = %T\n", v) //v type = complex128 //布林型別 fmt.Printf("%t, %t\n", true, false) //true, false //字串 str := "hello go" fmt.Printf("str = %s\n", str) //str = hello go ``` ## **1.3輸人** ```go var v int fmt.Println("請輸入一個整型：") fmt.Scanf("%d", &v) //fmt.Scan(&v) fmt.Println("v = ", v) ``` # 2、檢視型別-TypeOf ```go reflect.TypeOf(num) ``` # 3、檢視長度-len ```go fmt.Println(len(a)) ``` # 4、String-int相互轉換 ```go string轉成int： int, err := strconv.Atoi(string) string轉成int64： int64, err := strconv.ParseInt(string, 10, 64) int轉成string： string := strconv.Itoa(int) int64轉成string： string := strconv.FormatInt(int64,10) ``` ## 4.1型別轉換 Go語言中不允許隱式轉換，所有型別轉換必須顯式宣告，而且轉換隻能發生在兩種相互相容的型別之間。 ```go var ch byte = 97 //var a int = ch //err, cannot use ch (type byte) as type int in assignment var a int = int(ch) ``` ## 4.2類型別名 ```go type bigint int64 //int64型別改名為bigint var x bigint = 100 type ( myint int //int改名為myint mystr string //string改名為mystr ) ``` # 5、檢視容量-cap ```go test:=[3]int{1,2,3} fmt.Println(test) fmt.Println(cap(test)) //3 ``` # 6、Map ```go 如下定義：只能儲存string型別的value。 mapStr := make(map[string]string) 如下定義：只能儲存int型別的value。 mapInt := make(map[string]int) 如下定義：可以儲存string、int等不同型別的value。 mapInterface := make(map[string]interface{}) 注意： 但是最後一種方法定義的map通過key取出來的value是一個interface{}型別，需要轉化才能直接使用。 eg: user := make(map[string]interface{})//可以存放string的key和任意型別的value user["age"] = 18 user["name"] = "jeff" //fmt.Println(user["id"]+1) 會報錯(mismatched types interface {} and int) fmt.Println(Args["id"].(int) +1) # 轉換 ``` # 7、iota列舉 常量宣告可以使用iota常量生成器初始化，它用於生成一組以相似規則初始化的常量，但是不用每行都寫一遍初始化表示式。 **在一個const宣告語句中，在第一個宣告的常量所在的行，iota將會被置為0，然後在每一個有常量宣告的行加一。** ```go const ( x = iota // x == 0 y = iota // y == 1 z = iota // z == 2 w // 這裡隱式地說w = iota，因此w == 3。其實上面y和z可同樣不用"= iota" ) const v = iota // 每遇到一個const關鍵字，iota就會重置，此時v == 0 const ( h, i, j = iota, iota, iota //h=0,i=0,j=0 iota在同一行值相同 ) const ( a = iota //a=0 b = "B" c = iota //c=2 d, e, f = iota, iota, iota //d=3,e=3,f=3 g = iota //g = 4 ) const ( x1 = iota * 10 // x1 == 0 y1 = iota * 10 // y1 == 10 z1 = iota * 10 // z1 == 20 ) ``` # 8、Constants ``` const ( true = 0 == 0 // Untyped bool. false = 0 != 0 // Untyped bool. ) ``` true and false are the two untyped boolean values. ``` const iota = 0 // Untyped int. ``` iota是一個預先宣告的識別符號，表示（通常帶括號的）const宣告中當前const規範的未型別化整數序號。 它是零索引的。 # 9、func append ``` func append(slice []Type, elems ...Type) []Type ``` append內建函式將元素追加到切片的末尾。 如果具有足夠的容量，則將目標切片為容納新元素。 如果沒有，將分配一個新的基礎陣列。 追加返回更新的切片。 因此，有必要將新增的結果儲存在通常包含切片本身的變數中： ``` slice = append(slice, elem1, elem2) slice = append(slice, anotherSlice...) ``` 作為一種特殊情況，將字串附加到位元組片是合法的，如下所示： ``` slice = append([]byte("hello "), "world"...) ``` # 10、func cap ``` func cap(v Type) int ``` cap內建函式根據其型別返回v的容量： ``` 陣列：v中的元素數（與len（v）相同）。 指向陣列的指標：* v中的元素數（與len（v）相同）。 切片：切片後可以達到的最大長度； 如果v為零，則cap（v）為零。 Channel：通道緩衝容量，以元素為單位； 如果v為零，則cap（v）為零。 ``` # 11、func close ``` func close(c chan<- Type) ``` close內建函式關閉一個通道，該通道必須為雙向或僅傳送。 它只能由傳送者執行，而不能由接收者執行，並且具有在接收到最後一個傳送的值之後關閉通道的作用。 從關閉的通道c接收到最後一個值之後，從c進行的任何接收都將成功完成而不會阻塞，返回通道元素的零值。 ``` x, ok := <-c ``` 對於關閉的頻道，也會將ok設定為false。 # 12、func complex ``` func complex(r, i FloatType) ComplexType func main() { //func complex(r, i FloatType) ComplexType x := complex(1,2) y := complex(3,4) fmt.Println(x) //(1+2i) fmt.Println(y) //(3+4i) fmt.Println(x*y) // (-5+10i) fmt.Println(real(x*y)) //-5 fmt.Println(imag(x*y)) //10 } ``` 複雜的內建函式根據兩個浮點值構造一個複雜的值。 實部和虛部必須具有相同的大小，即float32或float64（或可分配給它們），並且返回值將是對應的複數型別（對於float32，complex64，對於float64，complex128）。 # 13、func copy ``` func copy(dst, src []Type) int func main() { x := []int{1,2} y := []int{6,6,6,6,6} copy(x,y) //從y拷貝到x fmt.Println(x) // [6 6] fmt.Println(y) // [6 6 6 6 6] } ``` 內建複製功能將元素從源切片複製到目標切片。 （作為一種特殊情況，它還會將位元組從字串複製到位元組的一部分。）源和目標可能會重疊。 複製返回複製的元素數量，該數量將是len（src）和len（dst）的最小值。 # 14、func delete ``` func delete(m map[Type]Type1, key Type) ``` delete內建函式從map中刪除具有指定鍵（m [key]）的元素。 如果m為nil或沒有這樣的元素，則delete為no-op。 # 15、func len ``` func len(v Type) int x := []int{1,2} fmt.Println(len(x)) //2 } ``` len內建函式根據其型別返回v的長度： ``` 陣列：v中的元素數。 指向陣列的指標：* v中的元素數（即使v為零）。 切片或map：v中的元素數量； 如果v為零，則len（v）為零。 字串：v中的位元組數。 Channel：在通道緩衝區中排隊（未讀）的元素數； 如果v為零，則len（v）為零。 ``` # 16、func make ``` func make(Type, size IntegerType) Type ``` make內建函式分配和初始化slice，map或chan型別的物件（僅）。 像new一樣，第一個引數是型別，而不是值。 與new不同，make的返回型別與其引數的型別相同，而不是指向它的指標。 結果的規格取決於型別： ``` 切片：大小指定長度。 切片的容量為等於它的長度。 可以提供第二個整數引數指定不同的容量； 它必須不小於長度，因此make（[] int，0，10）分配長度為0的切片，容量10。 map：根據大小進行初始分配，但生成的map的長度為0。在這種情況下，可以省略大小 分配的起始大小較小。 Channel：使用指定的值初始化通道的緩衝區緩衝容量。 如果為零或忽略大小，則通道為 無緩衝的。 ``` # 17、func new ``` func new(Type) *Type ``` 新的內建函式分配記憶體。 第一個引數是型別，而不是值，返回的值是指向該型別新分配的零值的指標。 # 18、func panic ```go panic所定義的異常，是在程式執行到這裡才觸發，所以屬於執行時異常 我們在程式碼段中定義了一個error，這個error我們可以處理也可以不處理，它並不會影響程式繼續往下執行；但是如果在程式中定義了一個panic，那程式是一定不會往下執行。 ``` ``` Go語言追求簡潔優雅，所以，Go語言不支援傳統的 try…catch…finally 這種異常，因為Go語言的設計者們認為，將異常與控制結構混在一起會很容易使得程式碼變得混亂。因為開發者很容易濫用異常，甚至一個小小的錯誤都丟擲一個異常。在Go語言中，使用多值返回來返回錯誤。不要用異常代替錯誤，更不要用來控制流程。在極個別的情況下，也就是說，遇到真正的異常的情況下（比如除數為 0了）。才使用Go中引入的Exception處理：defer, panic, recover。 這幾個異常的使用場景可以這麼簡單描述：Go中可以丟擲一個panic的異常，然後在defer中通過recover捕獲這個異常，然後正常處理。 ``` ```go package main import "fmt" func main(){ defer func(){ // 必須要先宣告defer，否則不能捕獲到panic異常 fmt.Println("c") if err:=recover();err!=nil{ fmt.Println(err) // 這裡的err其實就是panic傳入的內容，55 } fmt.Println("d") }() //程式中斷，不會列印“b”,"f" f() } func f(){ fmt.Println("a") panic(55) fmt.Println("b") //程式中斷，不會走 fmt.Println("f") //程式中斷，不會走 } 輸出結果： a c 55 d ``` # 19、func imag ``` func imag(c ComplexType) FloatType ``` imag內建函式返回複數c的虛部。 返回值將是對應於c型別的浮點型別。 # 20、func real ``` func real(c ComplexType) FloatType ``` 實數內建函式返回複數c的實數部分。 返回值將是對應於c型別的浮點型別。 # 21、func recover ``` func recover() interface{} ``` 恢復內建功能允許程式管理緊急恐慌例程的行為。 在延遲函式（但不是由它呼叫的任何函式）中執行恢復呼叫將通過恢復正常執行來停止恐慌序列，並檢索傳遞給panic呼叫的錯誤值。 如果在延遲函式之外呼叫了restore，它將不會停止緊急處理序列。 在這種情況下，或者當goroutine沒有驚慌時，或者如果提供給panic的引數為nil，則restore返回nil。 因此，來自recovery的返回值將報告goroutine是否感到恐慌。 # 22、type ComplexType ``` type ComplexType complex64 ``` ComplexType在此處僅用於文件目的。 它是複雜型別（complex64或complex128）的替代。 # 23、type FloatType ``` type FloatType float32 ``` FloatType此處僅用於文件目的。 它是浮點型別的替代：float32或float64。 # 24、type IntegerType ``` type IntegerType int ``` IntegerType此處僅用於文件目的。 它是任何整數型別的替代：int，uint，int8等。 # 25、type Type ``` type Type int ``` 型別僅在此處用於文件目的。 它是任何Go型別的替代，但對於任何給定的函式呼叫都表示相同的型別。 ``` var nil Type // Type must be a pointer, channel, func, interface, map, or slice type ``` nil是預先宣告的識別符號，表示指標，通道，函式，介面，對映或切片型別的零值。 # 26、type Type1 ``` type Type1 int ``` Type1僅在此處用於文件目的。 它是任何Go型別的替代，但對於任何給定的函式呼叫都表示相同的型別。 # 27、type bool ``` type bool bool ``` bool是布林值（真和假）的集合。 # 28、type byte ``` type byte byte ``` byte是uint8的別名，在所有方面都等同於uint8。 按照慣例，它用於區分位元組值和8位無符號整數值。 # 29、type complex128 ``` type complex128 complex128 ``` complex128是具有float64實部和虛部的所有複數的集合。 # 30、type complex64 ``` type complex64 complex64 ``` complex64是具有float32實部和虛部的所有複數的集合。 # 31、type error ``` type error interface { Error() string } ``` 錯誤內建介面型別是用於表示錯誤情況的常規介面，其中nil值表示沒有錯誤。 # 32、type float32 ``` type float32 float32 ``` float32是所有IEEE-754 32位浮點數的集合。 # 33、type float64 ``` type float64 float64 ``` float64是所有IEEE-754 64位浮點數的集合。 # 34、type int ``` type int int ``` int是有符號整數型別，其大小至少為32位。 但是，它是一個獨特的型別，而不是int32的別名。 # 35、type int16 ``` type int16 int16 ``` int16是所有帶符號的16位整數的集合。 範圍：-32768至32767。 # 36、type int32 ``` type int32 int32 ``` int32是所有帶符號的32位整數的集合。 範圍：-2147483648至2147483647。 # 37、type int64 ``` type int64 int64 ``` int64是所有帶符號的64位整數的集合。 範圍：-9223372036854775808至9223372036854775807。 # 38、type int8 ``` type int8 int8 ``` int8是所有帶符號的8位整數的集合。 範圍：-128至127。 # 39、type rune ``` type rune rune ``` 符文是int32的別名，在所有方面都等同於int32。 按照慣例，它用於區分字元值和整數值。 # 40、type string ``` type string string ``` 字串是所有8位位元組字串的集合，通常是但不一定表示UTF-8編碼的文字。 字串可以為空，但不能為nil。 字串型別的值是不可變的。 # 41、type uint ``` type uint uint ``` uint是無符號整數型別，其大小至少為32位。 但是，它是一種獨特的型別，而不是uint32的別名。 # 42、type uint16 ``` type uint16 uint16 ``` uint16是所有無符號16位整數的集合。 範圍：0到65535。 # 43、type uint32 ``` type uint32 uint32 ``` uint32是所有無符號32位整數的集合。 範圍：0到4294967295。 # 44、type uint64 ``` type uint64 uint64 ``` uint64是所有無符號64位整數的集合。 範圍：0至18446744073709551615。 # 45、type uint8 ``` type uint8 uint8 ``` uint8是所有無符號的8位整數的集合。 範圍：0到255。 # 46、type uintptr ``` type uintptr uintptr ``` uintptr是一個整數型別，其大小足以容納任何指標的位