• 1、列印資訊print各個區別
• 2、檢視型別-TypeOf
• 3、檢視長度-len
• 4、String-int相互轉換
• 5、檢視容量-cap
• 6、Map
• 7、iota列舉
• 8、Constants
• 9、func append
• 10、func cap
• 11、func close
• 12、func complex
• 13、func copy
• 14、func delete
• 15、func len
• 16、func make
• 17、func new
• 18、func panic
• 19、func imag
• 20、func real
• 21、func recover
• 22、type ComplexType
• 23、type FloatType
• 24、type IntegerType
• 25、type Type
• 26、type Type1
• 27、type bool
• 28、type byte
• 29、type complex128
• 30、type complex64
• 31、type error
• 32、type float32
• 33、type float64
• 34、type int
• 35、type int16
• 36、type int32
• 37、type int64
• 38、type int8
• 39、type rune
• 40、type string
• 41、type uint
• 42、type uint16
• 43、type uint32
• 44、type uint64
• 45、type uint8
• 46、type uintptr

1、列印資訊print各個區別

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碼

2、檢視型別-TypeOf

reflect.TypeOf(num)

3、檢視長度-len

fmt.Println(len(a))

4、String-int相互轉換

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)
 

5、檢視容量-cap

test:=[3]int{1,2,3}
fmt.Println(test)
fmt.Println(cap(test))  //3

6、Map

如下定義：只能儲存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，然後在每一個有常量宣告的行加一。

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

panic所定義的異常，是在程式執行到這裡才觸發，所以屬於執行時異常
我們在程式碼段中定義了一個error，這個error我們可以處理也可以不處理，它並不會影響程式繼續往下執行；但是如果在程式中定義了一個panic，那程式是一定不會往下執行。

Go語言追求簡潔優雅，所以，Go語言不支援傳統的 try…catch…finally 這種異常，因為Go語言的設計者們認為，將異常與控制結構混在一起會很容易使得程式碼變得混亂。因為開發者很容易濫用異常，甚至一個小小的錯誤都丟擲一個異常。在Go語言中，使用多值返回來返回錯誤。不要用異常代替錯誤，更不要用來控制流程。在極個別的情況下，也就是說，遇到真正的異常的情況下（比如除數為 0了）。才使用Go中引入的Exception處理：defer, panic, recover。

這幾個異常的使用場景可以這麼簡單描述：Go中可以丟擲一個panic的異常，然後在defer中通過recover捕獲這個異常，然後正常處理。

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是一個整數型別，其大小足以容納任何指標的位模式。