Golang基于学习总结
生活随笔
收集整理的這篇文章主要介紹了
Golang基于学习总结
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
1、不支持繼承 重載 ,比方C++Java的接口，接口的改動會影響整個實現改接口的類行為的改動,Go 設計者覺得這一特點也許根本沒用. 2、必不論什么函數定義必須花括號跟在函數聲明后面而不能換行 如 func ?funca(a int){},在Go語言中 函數也是一種類型 能夠被推導 ?使用支持匿名函數 和閉包。? 函數的返回值支持多重返回類似Python , 假設不賦值 ?整數類型默認 0 ? ? 浮點數類型默認0.0 ? error類型 默認是nil 3、不用的包一定不要引入，這是Go的原則,就如Python的嚴格制表符對其一樣 ? ,和 unused 變量都會被 ?編譯器所報錯 4、package做為引入包用。 5、import "a" ?調用包內部的函數 a.xx() ? 6、CGo是Go語言的一個特性,能夠方便高速的在Go中調用C ?相比Java JNI簡單easy實現? 7、go通過goroutine 進行協程優化 提高并發性能。 動態線程調整。 8、6g和6l是64位版本號的Go編譯器和鏈接器，相應的32位版本號工具為8g和8l。
出如今:=左側的變量不應該是已經被聲明過的。否則會導致編譯錯誤，比方以下這個 寫法： var i int i := 2 會導致類似例如以下的編譯錯誤： no new variables on left side of := 17、支持多重賦值,i, j = j, i ?兩個值能夠如此簡單的進行交換 ?而不許引入外部變量
18、 我們在使用傳統的強類型語言編程時，常常會出現這樣的情況。即在調用函數時為了獲取一個 值，卻由于該函數返回多個值而不得不定義一堆無用的變量。在Go中這樣的情況能夠通過結合使 用多重返回和匿名變量來避免這樣的丑陋的寫法。讓代碼看起來更加優雅。 如果GetName()函數的定義例如以下，它返回3個值，分別為firstName、lastName和 nickName： func GetName() (firstName, lastName, nickName string) {??? return "May", "Chan", "Chibi Maruko" } 若僅僅想獲得nickName，則函數調用語句能夠用例如以下方式編寫：?_, _, nickName := GetName() ? 這樣的使用方法能夠讓代碼很清晰，基本上屏蔽掉了可能混淆代碼閱讀者視線的內容。從而大幅 減少溝通的復雜度和代碼維護的難度
19、 在Go語言中，常量是指編譯期間就已知且不可改變的值。常量能夠是數值類型（包含整型、 浮點型和復數類型） 、布爾類型、字符串類型等。 所謂字面常量（literal） ，是指程序中硬編碼的常量，如： -12 3.14159265358979323846?// 浮點類型的常量 ? 3.2+12i ??// 復數類型的常量 ? true ??// 布爾類型的常量 ? "foo"?// 字符串常量 ? 在其它語言中。常量通常有特定的類型，比方?12在C語言中會覺得是一個int類型的常量。 假設要指定一個值為?12的long類型常量，須要寫成-12l，這有點違反人們的直觀感覺。Go語言 的字面常量更接近我們自然語言中的常量概念，它是無類型的。僅僅要這個常量在對應類型的值域 范圍內，就能夠作為該類型的常量，比方上面的常量-12，它能夠賦值給int、uint、int32、 int64、float32、float64、complex64、complex128等類型的變量。
20、常量的定義 通過constkeyword，你能夠給字面常量指定一個友好的名字： const Pi float64 = 3.14159265358979323846 ? const zero = 0.0 ? ? ? ? ? ? // 無類型浮點常量 const ( ? ? size int64 = 1024 ? ? eof = -1 ? ? ? ? ? ? ? ?// 無類型整型常量 ) ? const u, v float32 = 0, 3 ? ?// u = 0.0, v = 3.0。常量的多重賦值 const a, b, c = 3, 4, "foo" // a = 3, b = 4, c = "foo", 無類型整型和字符串常量 Go的常量定義能夠限定常量類型，但沒必要的。假設定義常量時沒有指定類型，那么它 與字面常量一樣，是無類型常量。 常量定義的右值也能夠是一個在編譯期運算的常量表達式，比方 const mask = 1 << 3 因為常量的賦值是一個編譯期行為。 所以右值不能出現不論什么須要執行期才干得出結果的表達 式，比方試圖以例如以下方式定義常量就會導致錯誤 const Home = os.GetEnv("HOME") 原因非常easy。os.GetEnv()僅僅有在執行期才干知道返回結果。在編譯期并不能確定。所以 無法作為常量定義的右值。
21、 Go語言提前定義了這些常量：true、false和iota。
w ?= iota * 42 ??// w == 84 ?? ) ? const x = iota ????// x == 0 (由于iota又被重設為0了) ?? const y = iota ????// y == 0 (同上) ? 假設兩個const的賦值語句的表達式是一樣的，那么能夠省略后一個賦值表達式。
23、go中的布爾類型 僅僅能用 false ?true != ==不能進行強制轉換? Go語言中的布爾類型與其它語言基本一致，keyword也為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
24、Go語言支持下面的幾種比較運算符：>、<、==、>=、<=和!=。這一點與大多數其它語言相?同。與C語言全然一致。 if i!=j { ?} ? //必須帶大括號 ? ? i,j:=1,2 ? ? ? ?if i==j{ ? ? ? ? fmt.Println("i==j"); ? ? ?}else { ? ? ? fmt.Println("i!=j"); ? ? ?} 25、兩個不同類型的值不能比較 比方 int8 int16，僅僅能強制轉換 然后再做比較 ? ? ?var a int8 ? ? ?var b int16 ? ? ?a,b=1,2 ? ? ?if int16(a)==b{ ? ? ? ? fmt.Printf("a==b") ? ? ?} ? ? ? 26、盡管兩個 int8 int16不能直接比較 可是 不論什么整數類型都能和字面常量整數進行比較 ?,可是不能和字符串字面常量進行比較 var a int16? ?if a==1{ ? ? ? ?fmt.Printf("a!=\"a\""); ? ? ?}
27、Go語言中的位運算 ? ?注意 C語言中的~ 取反。
28、關于浮點數的操作 ?浮點數 自己主動推導 是float64即C語言中的double 不能直接和fload32轉換 要進行強制轉換 ? 由于浮點數的比較精度? 浮點型用于表示包括小數點的數據。比方1.234就是一個浮點型數據。Go語言中的浮點類型
採用IEEE-754標準的表達方式。?
1.?浮點數表示?
Go語言定義了兩個類型float32和float64。當中float32等價于C語言的float類型，
float64等價于C語言的double類型。
30、 Go語言中的復數類型 , real 取出 實部 ?imag取出虛部 ?虛部為0 的復數 為純虛數。 某一類數字能夠表示成這樣的復數類型 var v1 complex64 ?v1 = 2.5+15i ?v2 := 2.5+15i ?v3 :=complex(2.5,15) ?fmt.Println(v1) ?fmt.Println(v2) ?fmt.Println(v3) ?fmt.Println("real:",real(v1)) ?fmt.Println("real:",imag(v1))
31、Golang中的字符串操作? go中的字符串聲明之后僅僅能獲取 字符不能改動字符 ? 可是能夠改動整個字符串 ? ?var str string ? str = "abc" ? str += "d" ? str="1111" ?fmt.Println(str)? 我們能夠獲取單個字符可是不能改動單個字符? var str string str = "abc" str += "d" ch:=str[0] fmt.Printf("A:%c",ch) ? ? ?//println不能格式化
32、關于Go的編碼處理 僅僅支持 Unicode UTF-8格式 ? import strings 這個包中包括了處理string類型的全部工具函數函數? Go編譯器支持UTF-8的源碼文件格式。這意味著源碼中的字符串能夠包括非ANSI的字
符。比方“Hello?world.?你好，世界！?”能夠出如今Go代碼中。但須要注意的是，假設你的Go代
碼須要包括非ANSI字符。保存源文件時請注意編碼格式必須選擇UTF-8。特別是在Windows下一
般編輯器都默認存為本地編碼，比方中國地區可能是GBK編碼而不是UTF-8，假設沒注意這點在
編譯和執行時就會出現一些意料之外的情況。
33、在Go中字符串的單個字符就是 byte類型也就是 uint8 一個字符串的長度len返回的默認是int類型也就是平臺相關類型,我們在做對應的操作的收 要么自己主動推導 要么進行強制轉換? ?var str string ? str = "abcdefghijklmn" ? var length int8=int8(len(str)) ? for i:=0 ;i<int(length) ;i++{ ? ? ? fmt.Printf("%c",str[i]) ? }
34、關于遍歷Unicode字符,每一個 unicode的字符類型是 rune ? 每一個中文字符在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。
測試代碼 package main import "fmt" func main() { ? ?var strUnicode string = "hello,世界" ? ?for i,ch := range strUnicode{ ? ? ? fmt.Println(i,ch) ? ?} } 35、關于 Go語言中支持的兩種字符類型 一種是 byte 實際上是uint8的別名 ,還有一種是unicode類型的字符 keyword為 rune? 在Go語言中支持兩個字符類型，一個是byte（實際上是uint8的別名） ，代表UTF-8字符串的單個字節的值。還有一個是rune，代表單個Unicode字符。 ? 關于rune相關的操作，可查閱Go標準庫的unicode包。另外unicode/utf8包也提供了?UTF8和Unicode之間的轉換。 ? 出于簡化語言的考慮。Go語言的多數API都如果字符串為UTF-8編碼。雖然Unicode字符在標?準庫中有支持，但實際上較少使用。
36、遍歷unicode字符的還有一種是 能夠用變量占位符去掉不想要的數據 package main import "fmt" func main() { ? ?var strUnicode string = "hello,世界" ? ?for _,ch := range strUnicode{ ? ? ? fmt.Printf("%c\n",ch) ? ?} }
37、關于Go語言的指針操作 package main import "fmt" func main() { ? ?var inta int8=3 ; ? ?var pinta*int8=&inta ; ? ?fmt.Printf("%d",*pinta); } 38、 關于數組的遍歷 range 遍歷能夠選擇忽略 索引 package main import "fmt" func main() { ? byteArr:=[5]byte{1,2,3,4,5} ? for _,val:=range byteArr { ? ? ?fmt.Println(val) ? }?? ?? } //各種數組的聲明/ [32]byte ??// 長度為32的數組，每一個元素為一個字節 ? [2*N] struct { x, y int32 } // 復雜類型數組 [1000]*float64 ??// 指針數組?[3][5]int ? // 二維數組?[2][2][2]float64 ? ??// 等同于[2]([2]([2]float64))?
/關于二維數組的初始化以及聲明.................................. package main import "fmt" func main() { ? td:=[2][5]int{{1,2,3,4,5},{5,4,3,2,1}} ? for _,val:=range td{ ? ? ?for _,vall:=range val{ ? ? ? ? fmt.Println(vall) ? ? ?} ? ? ? } }
39、關于Go的數組 是一個值類型,在做為參數傳遞 或者 做為函數返回的時候 都是 數組的副本,所以不能通過傳遞 數組參數在函數內部 進行改動 。、 package main import "fmt" func modify(arr[5]int){ ? ? ?arr[1]=1 ? ? ? fmt.Printf("arr[1]=%d\n",arr[1]) } func main() { ? td:=[5]int{1,2,3,4,5} ? modify(td) ? for _,val:=range td{ ? ? ? ? fmt.Println(val) ? } } //Go Web
40、Go語言中的數組切片 ? 能夠從一個已存在的數組創建 也能夠直接手動創建一個數組切片 ? ? 一個指向原生數組的指針； ? 數組切片中的元素個數。 ? 數組切片已分配的存儲空間。 從底層實現的角度來看。數組切片實際上仍然使用數組來管理元素，因此它們之間的關系讓 C++程序猿們非常easy聯想起STL中std::vector和數組的關系。基于數組。數組切片加入了一系 列管理功能，能夠隨時動態擴充存放空間，而且能夠被任意傳遞而不會導致所管理的元素被反復
基于數組創建切片 package main import "fmt" func modify(arr[]int){ arr[1]=1 fmt.Printf("arr[1]=%d\n",arr[1]) } func main() { td:=[]int{1,2,3,4,5} //基于數組創建切片 slice:=td[:3] ? ?// ?td[:] ?td[begin:end] 都能夠創建數組切片 ?還能夠創建一個比數組還大的切片 for _,val:=range slice{ fmt.Println(val) }?? ? }? 41、主動創建數組切片 操作數組 全部的方法 都是適用于數組切片 ,合理利用切片能極大提高內存操作的速度? 數組切片支持內建的cap()函數和len()函數?
從數組切片創建數組切片的時候僅僅要不超過模板切片的大小那么創建是沒問題的,否則會報出數組切片越界的錯誤。
td:=[]int{1,2,3,4,5} ? //這樣創建出來的實際上是數組切片 數組切片做為參數傳遞給函數是能夠被改動值的 ，攻克了Go中數組屬于值類型 結果函數傳遞參數的時候值被復制? package main import "fmt" func modify(arr[]int){ ? ? ?arr[1]=1 ? ? ? fmt.Printf("arr[1]=%d\n",arr[1]) } func main() { ? td:=[]int{1,2,3,4,5} ? //基于數組創建切片 ? slice:=td[:3] ? ??//從切片創建切片 都能夠 ? modify(slice) ? for _,val:=range slice{ ? ? ?fmt.Println(val) ? }??? } 從輸出結果我們發現了 數組切片能夠作為參數傳遞到函數中而且被函數所改動 ? 并不是一定要事先準備一個數組才干創建數組切片。
//為數組切片動態添加元素 append(td1,1,2,3,4,56,6,7)? //為數組元素加入數組切片 append(td1,td2...) ?//一定要加... 附加數組切片的時候? 須要注意的是，我們在第二個參數mySlice2后面加了三個點，即一個省略號，假設沒有這個省 略號的話，會有編譯錯誤，由于按append()的語義，從第二個參數起的全部參數都是待附加的 元素。由于mySlice中的元素類型為int，所以直接傳遞mySlice2是行不通的。加上省略號相 當于把mySlice2包括的全部元素打散后傳入
42. 數組切片支持內容復制 數組切片支持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個位置
? ?old:=[]int{1,2,3,4,5,6} ? ?newSlice:=[]int{1,3,3} ? ?copy(old,newSlice) ? ?fmt.Println(old) ? ? 43、在map中使用復雜數據類型 我們能夠使用Go語言內置的函數make()來創建一個新map。以下的這個樣例創建了一個鍵? 類型為string、值類型為PersonInfo的map: myMap = make(map[string] PersonInfo) 也能夠選擇是否在創建時指定該map的初始存儲能力。以下的樣例創建了一個初始存儲能力 為100的map: myMap = make(map[string] PersonInfo, 100) 關于存儲能力的說明。能夠參見2.3.6節中的內容。 創建并初始化map的代碼例如以下： myMap = map[string] PersonInfo{ ?"1234": PersonInfo{"1", "Jack", "Room 101,..."}, ? }? package main import "fmt" type Info struct{ ? ? name string ? ? age ?int8 } func main() { ? var infoMap map[string] Info ? ? ? ? infoMap=make(map[string] Info) ? infoMap["s1"]= Info{"ydw",11} ? infoMap["s2"]=Info{"xxx",22} ? ? fmt.Println(infoMap) /假設sone 沒有查找到那么返回值應該是nil 實際上我們僅僅須要推斷 ok是否是 true or false 就可以推斷元素是否查找到 ? sone,ok:=infoMap["s1"] ? if ok { ? ? ?fmt.Println("s1 student info exists!",sone.name,":",sone.age) ? }else{ ? ? ?fmt.Println("s1 student info not exists!") ? } } /刪除一個map用? delete(map,"key") Go語言提供了一個內置函數delete()，用于刪除容器內的元素。以下我們簡介一下如 何用delete()函數刪除map內的元素： delete(myMap, "1234") 上面的代碼將從myMap中刪除鍵為“1234”的鍵值對。假設“1234”這個鍵不存在，那么這個調 用將什么都不發生，也不會有什么副作用。
44、對于函數的返回值的限制 func returnFunc(num int) int{ ? ? ?if num > 0 { ? ? ? ? return 100 ?//錯誤 返回值不能寫在if...else之中結構之中 ? ? ?} ? ? ?return 100 }
45、switch case default使用方法 switch i { ? ? case 0: ? ? ? ? fmt.Printf("0") ? ? case 1: ? ? ? ? fmt.Printf("1") ? ? case 2: ? ? ? ? fallthrough ? ? case 3: ? ? ? ? fmt.Printf("3") ? ? case 4, 5, 6: ? ? ? ? fmt.Printf("4, 5, 6") ? ? default: ? ? ? ? fmt.Printf("Default") }
46、Go語言的goto 和break Label更加的靈活處理 循環和跳轉
47、自己定義復雜數據類型 type Info struct{ ? ? name string ? ? age ?int8 } 48、關于函數返回 一個值和函數返回多個值 package main import "fmt" func ret1() int{ ? ?return 1 } func ret2()(a int,b int){ ? ?a,b=1,2 ? ?return } func main() { ? ? a,b:=ret2() ?fmt.Println(ret1(),a,b) }
48、Go的大寫和小寫規則 Go牢記這種規則：小寫字母開頭的函數僅僅在本包內可見。大寫字母開頭的函數才 能被其它包使用。 這個規則也適用于類型和變量的可見性。
49、函數的不定參數 ?實際上是一種"語法糖"? package main ? import "fmt" func show(args ...int){ ? ? for _,val:= range args{ ? ? ? ?fmt.Println(val) ? ? } } func main() { ? ? show(1,2,3) } 50、不定參數的傳遞 ? 不定參數還能夠傳遞給其它不定參數的 函數 ?而且能夠打亂傳遞 ... unc myfunc(args ...int) { ? ? // 按原樣傳遞 ? ? myfunc3(args...) ? ? ? // 傳遞片段。實際上隨意的int slice都能夠傳進去 ? ? myfunc3(args[1:]...) ? }? 51、// ... ? 傳遞隨意類型的參數 package main import "fmt" func Printfx(args ...interface{}) { ? for _,val:= range args{ ? ? ? ?fmt.Println(val) ? ? } } func main() { ? ? Printfx(1,2,3,"adsd","sdaddf") } 52、Go的不定參數語法糖 ? Go的不定參數語法糖會把 參數構成一個數組切片 當然你直接傳遞 ?切片數組是不能夠的,由于他的參數就是1,2,3,4,5,66,7, ?可是我們能夠通過...的方式打亂 數組 或者數組切片 ? ...僅僅能夠打亂數組切片,常規數組是個值類型你是無法操作的
package main import "fmt" func show(args ...int){ ? ? for _,val:= range args{ ? ? ? ?fmt.Println(val) ? ? } } // ... ? func Printfx(args ...interface{}) { ? for _,val:= range args{ ? ? ? ?fmt.Println(val) ? ? } } func main() { ? ? Printfx(1,2,3,"adsd","sdaddf") ? ? slice:=[]int{5,4,3,2,6,7,8} ? ? show(slice...) } 53、通過傳遞不定參數獲取 ?隨意類型不定參數的類型 package main import "fmt" func checkType(args...interface{}){ ? ? for _,val:=range args{ ? ? ? ?switch val.(type){ ? ? ? ? ? case int : ? ? ? ? ? fmt.Println("Type is int!") ? ? ? ? ? case string: ? ? ? ? ? fmt.Println("Type is string!") ? ? ? ? ? default: ? ? ? ? ? fmt.Println("Type is unknow!") ? ? ? ?} ? ? } } func ?main() { ? ? checkType(1,2,3,"aaaa",int64(22)) } 54、使用匿名函數和閉包 ? ? Go的匿名函數實際上就是閉包 ///定義匿名函數 而且調用 ? ? funAdd:=func(a,b int)int{ ? ? ? ?return a+b ? ? } ? ? r:=funAdd(11,22) ? ? fmt.Println("a+b=",r) 定義 +調用匿名函數 一起 ? ? r=func(a,b int)int{ ? ? ? ? ? return a-b ? ? ? }(11,2) ? ? fmt.Println("a+b=",r) Go閉包 通過函數創建匿名函數 而且返回函數 package main import "fmt" func createFunc()(func(aa,bb,cc int) int){ return func(aa,bb,cc int)int{ return aa+bb+cc } } func ?main() { add:=createFunc() addNum:=add(1,2,3) fmt.Println("addNum:",addNum) }
package main ? import ( "fmt" ) ???? ///函數的閉包定義 直接調用 .......閉包內部使用的代碼塊外部的變量 僅僅要代碼塊沒有釋放那么變量不會被釋放的 func main() { var j int = 5? a := func()(func()) { var i int = 10 return func() { fmt.Printf("i, j: %d, %d\n", i, j) } }() a() j *= 2 a() }
55、函數多返回值 ???? func ret()(int,int){ return 1,2 } a,b:=ret() fmt.Println("a,b=",a,b)
56、對于結構類型空的值是nil
57、定義結構體一定要加 type,type和C/C++的 typedef 類似也能夠 起別名 package main import "fmt" type Data struct{ ? ?name string ? ?age ?int } func ?main() { ? ? data:=Data{"a",1} ? ? fmt.Println(data) } ///給結構體起個別名 package main import "fmt" type Data struct{ name string age ?int } type DData Data func ?main() { data:=DData{"a",1} fmt.Println(data) }
58、Go的defer和資源釋放 相關問題 ? defer語句是依照 先進后出的原則,也就是說最后一個defer將會被先運行。? defer字面的意思是延遲運行,也就是說會在不須要的時候自己主動運行 而Go語言使用defer keyword簡簡單單地攻克了資源何時釋放的問題，比方下面的樣例： func CopyFile(dst, src string) (w int64, err error) { srcFile, err := os.Open(src) if err != nil { return } defer srcFile.Close() dstFile, err := os.Create(dstName) if err != nil { return } defer dstFile.Close() return io.Copy(dstFile, srcFile) ? } ? 即使當中的Copy()函數拋出異常，Go仍然會保證dstFile和srcFile會被正常關閉。 假設認為一句話干不完清理的工作。也能夠使用在defer后加一個匿名函數的做法： defer func() { // 做你復雜的清理工作 } () ? 另外，一個函數中能夠存在多個defer語句，因此須要注意的是，defer語句的調用是遵照 先進后出的原則，即最后一個defer語句將最先被運行。
59、panic()和recover() panic場景1? package main import "fmt" func ?main() { ? ? defer func(){ ? ? ? ?fmt.Println("hello,defer go") ? ? }() ? ? panic(11111) } recover場景2? package main import "fmt" func ?main() { ? ? defer func(){ ? ? ? ?fmt.Println("hello,defer go") ? ? }() ? ? panic(11111) } Go語言引入了兩個內置函數panic()和recover()以報告和處理執行時錯誤和程序中的錯 誤場景： func panic(interface{}) ? func recover() interface{} ? 當在一個函數運行過程中調用panic()函數時。正常的函數運行流程將馬上終止。但函數中 之前使用deferkeyword延遲運行的語句將正常展開運行，之后該函數將返回到調用函數，并導致 逐層向上運行panic流程，直至所屬的goroutine中全部正在運行的函數被終止。錯誤信息將被報 告。包含在調用panic()函數時傳入的參數。這個過程稱為錯誤處理流程。 從panic()的參數類型interface{}我們能夠得知，該函數接收隨意類型的數據。比方整 型、字符串、對象等。
60、panic()函數和recover()函數的調用詳細差別在哪里 在panic()開始錯誤處理流程,傳入的類型是interface{}隨意類型 ?, ?假設我們在defer 函數中調用? recover()函數那么會打斷錯誤處理流程。
recover()函數用于終止錯誤處理流程。普通情況下，recover()應該在一個使用defer keyword的函數中運行以有效截取錯誤處理流程。假設沒有在發生異常的goroutine中明白調用恢復 過程（使用recoverkeyword） ，會導致該goroutine所屬的進程打印異常信息后直接退出。?
package main import "fmt" func ?main() { //通過閉包定義 defer匿名函數 而且直接調用 ? ? defer func(){ ? ? ?//recover 結束當前錯誤處理過程 ?而且返回 panic的參數,并不結束其它goroutine的運行....... ? ? ? ?if r:=recover() ;r!=nil{ ?? ? ? ? ? ?fmt.Println("recover() called!") ? ? ? ?} ? ? ? ?fmt.Println("hello,defer go") ? ? }() ? ? panic("hello,go") } 61、關于const 和iota的使用 package main import "fmt" var str string="aaa" const( A=iota B C ) func ?main() { fmt.Println(B) defer func(){ if r:=recover() ;r!=nil{ fmt.Println("recover() called!") fmt.Println(r) } fmt.Println("hello,defer go") }() panic("hello,go") }
62、高速排序算法與數組切片的使用 package main import "fmt" import "math/rand" /冒泡排序Go實現 時間復雜富 O(n)=n~n^2 func bubbledSort(values []int){ ? var flags bool =true for i:=0 ;i<len(values);i++{ ? flags=true for j:=0;j<len(values)-i-1;j++{ if values[j]>values[j+1] { values[j],values[j+1]=values[j+1],values[j] flags=false } } if flags { break } } } ///高速排序Go實現 func quickSort(values []int,left,right int){ temp := values[left] p := left i, j := left, right for i <= j { for j >= p && values[j] >= temp { j-- } if j >= p { values[p] = values[j] p = j } if values[i] <= temp && i <= p { i++ } if i <= p { values[p] = values[i] p = i } } values[p] = temp if p - left > 1 { quickSort(values, left, p - 1) } if right - p > 1 { quickSort(values, p + 1, right) } } func ?main() { //創建初始化0個元素 ?容量1000的 切片 假設用索引直接訪問切片會越界的 ?容量必須大于等于 初始化元素個數 ? ? //val[1]=11 val:=make([]int,0,1000) for i:=0;i<1000;i++{ val=append(val,rand.Intn(1000)) } fmt.Println("冒泡排序前:",val) bubbledSort(val) ? fmt.Println("冒泡排序后:",val) ? }
63、Go中的import和package 等等的關系? //import僅僅是引入的目錄而已,,,能夠使用相對路徑或者絕對路徑 //他會把目錄中的全部.go文件引入 ,,,,,, ///package xx 實際上是 在外不用調用用的 比方xx.A() 并非給import使用 ? package內部的小寫所有是私有 大寫所有是公有 //外部包不能和主模塊放到一起會編譯只是的 import "./bubble" ?
Go還有另外一個?GCC版本號的編譯器。名為 gccgo。
9、注意多個go文件能夠用同一個包名字,假設要為 Go生成可運行文件 那么必須 進行 package main main函數的聲明 func main()? { ? ? ? ? ? args := os.Args ? ? ? if args == nil || len(args) < 2 { ? ? return ? } 10、Linux 為了可以構建這個project， 須要先把這個project的根文件夾加入到環境變量GOPATH中。 如果calcproj?文件夾位于~/goyard下，則應編輯~/.bashrc文件。并加入以下這行代碼： ?export GOPATH=~/goyard/calcproj 然后運行下面命令應用該設置：?$ source ~/.bashrc ,GOPATH和PATH環境變量一樣。也能夠接受多個路徑。而且路徑和路徑之間用冒號切割。 ?設置完GOPATH后，如今我們開始構建project。如果我們希望把生成的可運行文件放到?calcproj/bin文件夾. 11、GoRoot go安裝路徑 ....上面的時候project路徑 12、GDB調試 不用設置什么編譯選項， Go語言編譯的二進制程序直接支持GDB調試， 比方之前用go build?calc編譯出來的可執行文件calc。就能夠直接用下面命令以調試模式執行： ??$ gdb calc ? 由于GDB的標準使用方法與Go沒有特別關聯，這里就不具體展開了，有興趣的讀者能夠自行查 看相應的文檔。須要注意的是，Go編譯器生成的調試信息格式為DWARFv3，僅僅要版本號高于7.1 的GDB應該都支持它。 13、Go語言會被稱為“更好的C語言” ? 14、每一行不須要加分號自己主動加入? 15 、加入了map[string] int? 16、加入了類型推導 ? var a int =1 等價 ?a:=1? var v1 int = 10 // 正確的使用方式1 ? var v2 = 10?// 正確的使用方式2，編譯器能夠自己主動推導出v2的類型 ? v3 := 10?// 正確的使用方式3，編譯器能夠自己主動推導出v3的類型出如今:=左側的變量不應該是已經被聲明過的。否則會導致編譯錯誤，比方以下這個 寫法： var i int i := 2 會導致類似例如以下的編譯錯誤： no new variables on left side of := 17、支持多重賦值,i, j = j, i ?兩個值能夠如此簡單的進行交換 ?而不許引入外部變量
18、 我們在使用傳統的強類型語言編程時，常常會出現這樣的情況。即在調用函數時為了獲取一個 值，卻由于該函數返回多個值而不得不定義一堆無用的變量。在Go中這樣的情況能夠通過結合使 用多重返回和匿名變量來避免這樣的丑陋的寫法。讓代碼看起來更加優雅。 如果GetName()函數的定義例如以下，它返回3個值，分別為firstName、lastName和 nickName： func GetName() (firstName, lastName, nickName string) {??? return "May", "Chan", "Chibi Maruko" } 若僅僅想獲得nickName，則函數調用語句能夠用例如以下方式編寫：?_, _, nickName := GetName() ? 這樣的使用方法能夠讓代碼很清晰，基本上屏蔽掉了可能混淆代碼閱讀者視線的內容。從而大幅 減少溝通的復雜度和代碼維護的難度
19、 在Go語言中，常量是指編譯期間就已知且不可改變的值。常量能夠是數值類型（包含整型、 浮點型和復數類型） 、布爾類型、字符串類型等。 所謂字面常量（literal） ，是指程序中硬編碼的常量，如： -12 3.14159265358979323846?// 浮點類型的常量 ? 3.2+12i ??// 復數類型的常量 ? true ??// 布爾類型的常量 ? "foo"?// 字符串常量 ? 在其它語言中。常量通常有特定的類型，比方?12在C語言中會覺得是一個int類型的常量。 假設要指定一個值為?12的long類型常量，須要寫成-12l，這有點違反人們的直觀感覺。Go語言 的字面常量更接近我們自然語言中的常量概念，它是無類型的。僅僅要這個常量在對應類型的值域 范圍內，就能夠作為該類型的常量，比方上面的常量-12，它能夠賦值給int、uint、int32、 int64、float32、float64、complex64、complex128等類型的變量。
20、常量的定義 通過constkeyword，你能夠給字面常量指定一個友好的名字： const Pi float64 = 3.14159265358979323846 ? const zero = 0.0 ? ? ? ? ? ? // 無類型浮點常量 const ( ? ? size int64 = 1024 ? ? eof = -1 ? ? ? ? ? ? ? ?// 無類型整型常量 ) ? const u, v float32 = 0, 3 ? ?// u = 0.0, v = 3.0。常量的多重賦值 const a, b, c = 3, 4, "foo" // a = 3, b = 4, c = "foo", 無類型整型和字符串常量 Go的常量定義能夠限定常量類型，但沒必要的。假設定義常量時沒有指定類型，那么它 與字面常量一樣，是無類型常量。 常量定義的右值也能夠是一個在編譯期運算的常量表達式，比方 const mask = 1 << 3 因為常量的賦值是一個編譯期行為。 所以右值不能出現不論什么須要執行期才干得出結果的表達 式，比方試圖以例如以下方式定義常量就會導致錯誤 const Home = os.GetEnv("HOME") 原因非常easy。os.GetEnv()僅僅有在執行期才干知道返回結果。在編譯期并不能確定。所以 無法作為常量定義的右值。
21、 Go語言提前定義了這些常量：true、false和iota。
?
iota比較特殊。能夠被覺得是一個可被編譯器改動的常量，在每個constkeyword出現時被
重置為0。然后在下一個const出現之前。每出現一次iota。其所代表的數字會自己主動增1。?
從下面的樣例能夠基本理解iota的使用方法：?
const?(??????????//?iota被重設為0?
?c0?=?iota?//?c0?==?0?
?c1?=?iota?//?c1?==?1?
?c2?=?iota??//?c2?==?2??
)???
const?(?
?a?=?1?<<?iota?//?a?==?1?(iota在每一個const開頭被重設為0)?
b?=?1?<<?iota?//?b?==?2?
c?=?1?<<?iota?//?c?==?4??
)???
const?(?
u =?iota?*?42???//?u?==?0?
w ?= iota * 42 ??// w == 84 ?? ) ? const x = iota ????// x == 0 (由于iota又被重設為0了) ?? const y = iota ????// y == 0 (同上) ? 假設兩個const的賦值語句的表達式是一樣的，那么能夠省略后一個賦值表達式。
因此，上
面的前兩個const語句可簡寫為： const ( ????// iota被重設為0 ? c0 = iota ??// c0 == 0 ? c1 ??// c1 == 1 ? c2 ????// c2 == 2 ? )??? const ( a = 1 <<iota ????// a == 1 (iota在每一個const開頭被重設為0) ? b???// b == 2 ? c???// c == 4 ? ) 22、 關于枚舉 ?全部符號 以大寫開頭在包外是可見的 ? 小寫僅僅能在包內部使用 枚舉指一系列相關的常量，比方以下關于一個星期中每天的定義。通過上一節的樣例。我們 看到能夠用在const后跟一對圓括號的方式定義一組常量， 這樣的定義法在Go語言中通經常使用于定義 枚舉值。Go語言并不支持眾多其它語言明白支持的enumkeyword。 以下是一個常規的枚舉表示法，當中定義了一系列整型常量： const ( ? ? Sunday = iota ? ? Monday ? ? Tuesday ? ? Wednesday ? ? Thursday ? ? Friday ? ? Saturday ? ? numberOfDays ? ? ? ?// 這個常量沒有導出 ? ) ? 同Go語言的其它符號（symbol）一樣。以大寫字母開頭的常量在包外可見。 以上樣例中numberOfDays為包內私有，其它符號則可被其它包訪問。23、go中的布爾類型 僅僅能用 false ?true != ==不能進行強制轉換? Go語言中的布爾類型與其它語言基本一致，keyword也為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
24、Go語言支持下面的幾種比較運算符：>、<、==、>=、<=和!=。這一點與大多數其它語言相?同。與C語言全然一致。 if i!=j { ?} ? //必須帶大括號 ? ? i,j:=1,2 ? ? ? ?if i==j{ ? ? ? ? fmt.Println("i==j"); ? ? ?}else { ? ? ? fmt.Println("i!=j"); ? ? ?} 25、兩個不同類型的值不能比較 比方 int8 int16，僅僅能強制轉換 然后再做比較 ? ? ?var a int8 ? ? ?var b int16 ? ? ?a,b=1,2 ? ? ?if int16(a)==b{ ? ? ? ? fmt.Printf("a==b") ? ? ?} ? ? ? 26、盡管兩個 int8 int16不能直接比較 可是 不論什么整數類型都能和字面常量整數進行比較 ?,可是不能和字符串字面常量進行比較 var a int16? ?if a==1{ ? ? ? ?fmt.Printf("a!=\"a\""); ? ? ?}
27、Go語言中的位運算 ? ?注意 C語言中的~ 取反。
而Go中變成了^
Go語言支持表2-2所看到的的位運算符。 表 2-2 運 ?算 ? ? ?含 ?義 ? ? ?樣 ?例 ? x << y ? ?左移 ? ? ? ?124 << 2 ? ?// 結果為496 ? x >> y ? ??右移 ? ? ? ?124 >> 2 ? ?// 結果為31 ? x ^ y ? ? ??異或 ? ? ? ??124 ^ 2 ? ? // 結果為126? ?x & y ?? ??與 ? ? ? ? ? ?124 & 2 ???// 結果為0 ? x | y ? ? ? ? ??或 ? ? ? ? ??124 | 2 ? ? // 結果為126 ? ^x ? ? ? ? ?取反 ? ? ? ??^2 ? ? ? ? ?// 結果為-3 ? Go語言的大多數位運算符與C語言都比較類似，除了取反在C語言中是~x。而在Go語言中?是^x28、關于浮點數的操作 ?浮點數 自己主動推導 是float64即C語言中的double 不能直接和fload32轉換 要進行強制轉換 ? 由于浮點數的比較精度? 浮點型用于表示包括小數點的數據。比方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??
30、 Go語言中的復數類型 , real 取出 實部 ?imag取出虛部 ?虛部為0 的復數 為純虛數。 某一類數字能夠表示成這樣的復數類型 var v1 complex64 ?v1 = 2.5+15i ?v2 := 2.5+15i ?v3 :=complex(2.5,15) ?fmt.Println(v1) ?fmt.Println(v2) ?fmt.Println(v3) ?fmt.Println("real:",real(v1)) ?fmt.Println("real:",imag(v1))
復數實際上由兩個實數（在計算機中用浮點數表示）構成。一個表示實部（real），一個表示虛部（imag）。
對于什么是復數能夠參考：http://baike.baidu.com/view/10078.htm
復數實際上由兩個實數（在計算機中用浮點數表示）構成，一個表示實部（real） ，一個表示
虛部（imag） 。假設了解了數學上的復數是怎么回事。那么Go語言的復數就很easy理解了。
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。
很多其它關于復數的函數。請查閱math/cmplx標準庫的文檔。
31、Golang中的字符串操作? go中的字符串聲明之后僅僅能獲取 字符不能改動字符 ? 可是能夠改動整個字符串 ? ?var str string ? str = "abc" ? str += "d" ? str="1111" ?fmt.Println(str)? 我們能夠獲取單個字符可是不能改動單個字符? var str string str = "abc" str += "d" ch:=str[0] fmt.Printf("A:%c",ch) ? ? ?//println不能格式化
32、關于Go的編碼處理 僅僅支持 Unicode UTF-8格式 ? import strings 這個包中包括了處理string類型的全部工具函數函數? Go編譯器支持UTF-8的源碼文件格式。這意味著源碼中的字符串能夠包括非ANSI的字
符。比方“Hello?world.?你好，世界！?”能夠出如今Go代碼中。但須要注意的是，假設你的Go代
碼須要包括非ANSI字符。保存源文件時請注意編碼格式必須選擇UTF-8。特別是在Windows下一
般編輯器都默認存為本地編碼，比方中國地區可能是GBK編碼而不是UTF-8，假設沒注意這點在
編譯和執行時就會出現一些意料之外的情況。
?
字符串的編碼轉換是處理文本文檔（比方TXT、XML、HTML等）很常見的需求。只是可
惜的是Go語言僅支持UTF-8和Unicode編碼。對于其它編碼。Go語言標準庫并沒有內置的編碼轉
換支持。只是，所幸的是我們能夠非常easy基于iconv庫用Cgo包裝一個。這里有一個開源項目：
https://github.com/xushiwei/go-iconv
33、在Go中字符串的單個字符就是 byte類型也就是 uint8 一個字符串的長度len返回的默認是int類型也就是平臺相關類型,我們在做對應的操作的收 要么自己主動推導 要么進行強制轉換? ?var str string ? str = "abcdefghijklmn" ? var length int8=int8(len(str)) ? for i:=0 ;i<int(length) ;i++{ ? ? ? fmt.Printf("%c",str[i]) ? }
34、關于遍歷Unicode字符,每一個 unicode的字符類型是 rune ? 每一個中文字符在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。
測試代碼 package main import "fmt" func main() { ? ?var strUnicode string = "hello,世界" ? ?for i,ch := range strUnicode{ ? ? ? fmt.Println(i,ch) ? ?} } 35、關于 Go語言中支持的兩種字符類型 一種是 byte 實際上是uint8的別名 ,還有一種是unicode類型的字符 keyword為 rune? 在Go語言中支持兩個字符類型，一個是byte（實際上是uint8的別名） ，代表UTF-8字符串的單個字節的值。還有一個是rune，代表單個Unicode字符。 ? 關于rune相關的操作，可查閱Go標準庫的unicode包。另外unicode/utf8包也提供了?UTF8和Unicode之間的轉換。 ? 出于簡化語言的考慮。Go語言的多數API都如果字符串為UTF-8編碼。雖然Unicode字符在標?準庫中有支持，但實際上較少使用。
?
36、遍歷unicode字符的還有一種是 能夠用變量占位符去掉不想要的數據 package main import "fmt" func main() { ? ?var strUnicode string = "hello,世界" ? ?for _,ch := range strUnicode{ ? ? ? fmt.Printf("%c\n",ch) ? ?} }
37、關于Go語言的指針操作 package main import "fmt" func main() { ? ?var inta int8=3 ; ? ?var pinta*int8=&inta ; ? ?fmt.Printf("%d",*pinta); } 38、 關于數組的遍歷 range 遍歷能夠選擇忽略 索引 package main import "fmt" func main() { ? byteArr:=[5]byte{1,2,3,4,5} ? for _,val:=range byteArr { ? ? ?fmt.Println(val) ? }?? ?? } //各種數組的聲明/ [32]byte ??// 長度為32的數組，每一個元素為一個字節 ? [2*N] struct { x, y int32 } // 復雜類型數組 [1000]*float64 ??// 指針數組?[3][5]int ? // 二維數組?[2][2][2]float64 ? ??// 等同于[2]([2]([2]float64))?
/關于二維數組的初始化以及聲明.................................. package main import "fmt" func main() { ? td:=[2][5]int{{1,2,3,4,5},{5,4,3,2,1}} ? for _,val:=range td{ ? ? ?for _,vall:=range val{ ? ? ? ? fmt.Println(vall) ? ? ?} ? ? ? } }
39、關于Go的數組 是一個值類型,在做為參數傳遞 或者 做為函數返回的時候 都是 數組的副本,所以不能通過傳遞 數組參數在函數內部 進行改動 。、 package main import "fmt" func modify(arr[5]int){ ? ? ?arr[1]=1 ? ? ? fmt.Printf("arr[1]=%d\n",arr[1]) } func main() { ? td:=[5]int{1,2,3,4,5} ? modify(td) ? for _,val:=range td{ ? ? ? ? fmt.Println(val) ? } } //Go Web
40、Go語言中的數組切片 ? 能夠從一個已存在的數組創建 也能夠直接手動創建一個數組切片 ? ? 一個指向原生數組的指針； ? 數組切片中的元素個數。 ? 數組切片已分配的存儲空間。 從底層實現的角度來看。數組切片實際上仍然使用數組來管理元素，因此它們之間的關系讓 C++程序猿們非常easy聯想起STL中std::vector和數組的關系。基于數組。數組切片加入了一系 列管理功能，能夠隨時動態擴充存放空間，而且能夠被任意傳遞而不會導致所管理的元素被反復
基于數組創建切片 package main import "fmt" func modify(arr[]int){ arr[1]=1 fmt.Printf("arr[1]=%d\n",arr[1]) } func main() { td:=[]int{1,2,3,4,5} //基于數組創建切片 slice:=td[:3] ? ?// ?td[:] ?td[begin:end] 都能夠創建數組切片 ?還能夠創建一個比數組還大的切片 for _,val:=range slice{ fmt.Println(val) }?? ? }? 41、主動創建數組切片 操作數組 全部的方法 都是適用于數組切片 ,合理利用切片能極大提高內存操作的速度? 數組切片支持內建的cap()函數和len()函數?
從數組切片創建數組切片的時候僅僅要不超過模板切片的大小那么創建是沒問題的,否則會報出數組切片越界的錯誤。
td:=[]int{1,2,3,4,5} ? //這樣創建出來的實際上是數組切片 數組切片做為參數傳遞給函數是能夠被改動值的 ，攻克了Go中數組屬于值類型 結果函數傳遞參數的時候值被復制? package main import "fmt" func modify(arr[]int){ ? ? ?arr[1]=1 ? ? ? fmt.Printf("arr[1]=%d\n",arr[1]) } func main() { ? td:=[]int{1,2,3,4,5} ? //基于數組創建切片 ? slice:=td[:3] ? ??//從切片創建切片 都能夠 ? modify(slice) ? for _,val:=range slice{ ? ? ?fmt.Println(val) ? }??? } 從輸出結果我們發現了 數組切片能夠作為參數傳遞到函數中而且被函數所改動 ? 并不是一定要事先準備一個數組才干創建數組切片。
Go語言提供的內置函數make()能夠用于
靈活地創建數組切片。以下的樣例示范了直接創建數組切片的各種方法。
創建一個初始元素個數為5的數組切片，元素初始值為0： mySlice1 := make([]int, 5) ? 創建一個初始元素個數為5的數組切片，元素初始值為0，并預留10個元素的存儲空間： mySlice2 := make([]int, 5, 10) ? 直接創建并初始化包括5個元素的數組切片： mySlice3 := []int{1, 2, 3, 4, 5} ? 當然，其實還會有一個匿名數組被創建出來，僅僅是不須要我們來擔心而已。? 數組切片支持Go語言內置的cap()函數和len()函數，代碼清單2-2簡單示范了這兩個內置 函數的使用方法。能夠看出，cap()函數返回的是數組切片分配的空間大小，而len()函數返回的是
數組切片中當前所存儲的元素個數 ?動態創建 一個 初始化五個0 而且 內存儲空間初始化20的 數組切片 ? td1:=make([]int,5,20) ? fmt.Println(cap(td1)) ? fmt.Println(len(td1))//為數組切片動態添加元素 append(td1,1,2,3,4,56,6,7)? //為數組元素加入數組切片 append(td1,td2...) ?//一定要加... 附加數組切片的時候? 須要注意的是，我們在第二個參數mySlice2后面加了三個點，即一個省略號，假設沒有這個省 略號的話，會有編譯錯誤，由于按append()的語義，從第二個參數起的全部參數都是待附加的 元素。由于mySlice中的元素類型為int，所以直接傳遞mySlice2是行不通的。加上省略號相 當于把mySlice2包括的全部元素打散后傳入
42. 數組切片支持內容復制 數組切片支持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個位置
? ?old:=[]int{1,2,3,4,5,6} ? ?newSlice:=[]int{1,3,3} ? ?copy(old,newSlice) ? ?fmt.Println(old) ? ? 43、在map中使用復雜數據類型 我們能夠使用Go語言內置的函數make()來創建一個新map。以下的這個樣例創建了一個鍵? 類型為string、值類型為PersonInfo的map: myMap = make(map[string] PersonInfo) 也能夠選擇是否在創建時指定該map的初始存儲能力。以下的樣例創建了一個初始存儲能力 為100的map: myMap = make(map[string] PersonInfo, 100) 關于存儲能力的說明。能夠參見2.3.6節中的內容。 創建并初始化map的代碼例如以下： myMap = map[string] PersonInfo{ ?"1234": PersonInfo{"1", "Jack", "Room 101,..."}, ? }? package main import "fmt" type Info struct{ ? ? name string ? ? age ?int8 } func main() { ? var infoMap map[string] Info ? ? ? ? infoMap=make(map[string] Info) ? infoMap["s1"]= Info{"ydw",11} ? infoMap["s2"]=Info{"xxx",22} ? ? fmt.Println(infoMap) /假設sone 沒有查找到那么返回值應該是nil 實際上我們僅僅須要推斷 ok是否是 true or false 就可以推斷元素是否查找到 ? sone,ok:=infoMap["s1"] ? if ok { ? ? ?fmt.Println("s1 student info exists!",sone.name,":",sone.age) ? }else{ ? ? ?fmt.Println("s1 student info not exists!") ? } } /刪除一個map用? delete(map,"key") Go語言提供了一個內置函數delete()，用于刪除容器內的元素。以下我們簡介一下如 何用delete()函數刪除map內的元素： delete(myMap, "1234") 上面的代碼將從myMap中刪除鍵為“1234”的鍵值對。假設“1234”這個鍵不存在，那么這個調 用將什么都不發生，也不會有什么副作用。
可是假設傳入的map變量的值是nil，該調用將導致
程序拋出異常（panic）?44、對于函數的返回值的限制 func returnFunc(num int) int{ ? ? ?if num > 0 { ? ? ? ? return 100 ?//錯誤 返回值不能寫在if...else之中結構之中 ? ? ?} ? ? ?return 100 }
45、switch case default使用方法 switch i { ? ? case 0: ? ? ? ? fmt.Printf("0") ? ? case 1: ? ? ? ? fmt.Printf("1") ? ? case 2: ? ? ? ? fallthrough ? ? case 3: ? ? ? ? fmt.Printf("3") ? ? case 4, 5, 6: ? ? ? ? fmt.Printf("4, 5, 6") ? ? default: ? ? ? ? fmt.Printf("Default") }
46、Go語言的goto 和break Label更加的靈活處理 循環和跳轉
47、自己定義復雜數據類型 type Info struct{ ? ? name string ? ? age ?int8 } 48、關于函數返回 一個值和函數返回多個值 package main import "fmt" func ret1() int{ ? ?return 1 } func ret2()(a int,b int){ ? ?a,b=1,2 ? ?return } func main() { ? ? a,b:=ret2() ?fmt.Println(ret1(),a,b) }
48、Go的大寫和小寫規則 Go牢記這種規則：小寫字母開頭的函數僅僅在本包內可見。大寫字母開頭的函數才 能被其它包使用。 這個規則也適用于類型和變量的可見性。
49、函數的不定參數 ?實際上是一種"語法糖"? package main ? import "fmt" func show(args ...int){ ? ? for _,val:= range args{ ? ? ? ?fmt.Println(val) ? ? } } func main() { ? ? show(1,2,3) } 50、不定參數的傳遞 ? 不定參數還能夠傳遞給其它不定參數的 函數 ?而且能夠打亂傳遞 ... unc myfunc(args ...int) { ? ? // 按原樣傳遞 ? ? myfunc3(args...) ? ? ? // 傳遞片段。實際上隨意的int slice都能夠傳進去 ? ? myfunc3(args[1:]...) ? }? 51、// ... ? 傳遞隨意類型的參數 package main import "fmt" func Printfx(args ...interface{}) { ? for _,val:= range args{ ? ? ? ?fmt.Println(val) ? ? } } func main() { ? ? Printfx(1,2,3,"adsd","sdaddf") } 52、Go的不定參數語法糖 ? Go的不定參數語法糖會把 參數構成一個數組切片 當然你直接傳遞 ?切片數組是不能夠的,由于他的參數就是1,2,3,4,5,66,7, ?可是我們能夠通過...的方式打亂 數組 或者數組切片 ? ...僅僅能夠打亂數組切片,常規數組是個值類型你是無法操作的
package main import "fmt" func show(args ...int){ ? ? for _,val:= range args{ ? ? ? ?fmt.Println(val) ? ? } } // ... ? func Printfx(args ...interface{}) { ? for _,val:= range args{ ? ? ? ?fmt.Println(val) ? ? } } func main() { ? ? Printfx(1,2,3,"adsd","sdaddf") ? ? slice:=[]int{5,4,3,2,6,7,8} ? ? show(slice...) } 53、通過傳遞不定參數獲取 ?隨意類型不定參數的類型 package main import "fmt" func checkType(args...interface{}){ ? ? for _,val:=range args{ ? ? ? ?switch val.(type){ ? ? ? ? ? case int : ? ? ? ? ? fmt.Println("Type is int!") ? ? ? ? ? case string: ? ? ? ? ? fmt.Println("Type is string!") ? ? ? ? ? default: ? ? ? ? ? fmt.Println("Type is unknow!") ? ? ? ?} ? ? } } func ?main() { ? ? checkType(1,2,3,"aaaa",int64(22)) } 54、使用匿名函數和閉包 ? ? Go的匿名函數實際上就是閉包 ///定義匿名函數 而且調用 ? ? funAdd:=func(a,b int)int{ ? ? ? ?return a+b ? ? } ? ? r:=funAdd(11,22) ? ? fmt.Println("a+b=",r) 定義 +調用匿名函數 一起 ? ? r=func(a,b int)int{ ? ? ? ? ? return a-b ? ? ? }(11,2) ? ? fmt.Println("a+b=",r) Go閉包 通過函數創建匿名函數 而且返回函數 package main import "fmt" func createFunc()(func(aa,bb,cc int) int){ return func(aa,bb,cc int)int{ return aa+bb+cc } } func ?main() { add:=createFunc() addNum:=add(1,2,3) fmt.Println("addNum:",addNum) }
package main ? import ( "fmt" ) ???? ///函數的閉包定義 直接調用 .......閉包內部使用的代碼塊外部的變量 僅僅要代碼塊沒有釋放那么變量不會被釋放的 func main() { var j int = 5? a := func()(func()) { var i int = 10 return func() { fmt.Printf("i, j: %d, %d\n", i, j) } }() a() j *= 2 a() }
55、函數多返回值 ???? func ret()(int,int){ return 1,2 } a,b:=ret() fmt.Println("a,b=",a,b)
56、對于結構類型空的值是nil
57、定義結構體一定要加 type,type和C/C++的 typedef 類似也能夠 起別名 package main import "fmt" type Data struct{ ? ?name string ? ?age ?int } func ?main() { ? ? data:=Data{"a",1} ? ? fmt.Println(data) } ///給結構體起個別名 package main import "fmt" type Data struct{ name string age ?int } type DData Data func ?main() { data:=DData{"a",1} fmt.Println(data) }
58、Go的defer和資源釋放 相關問題 ? defer語句是依照 先進后出的原則,也就是說最后一個defer將會被先運行。? defer字面的意思是延遲運行,也就是說會在不須要的時候自己主動運行 而Go語言使用defer keyword簡簡單單地攻克了資源何時釋放的問題，比方下面的樣例： func CopyFile(dst, src string) (w int64, err error) { srcFile, err := os.Open(src) if err != nil { return } defer srcFile.Close() dstFile, err := os.Create(dstName) if err != nil { return } defer dstFile.Close() return io.Copy(dstFile, srcFile) ? } ? 即使當中的Copy()函數拋出異常，Go仍然會保證dstFile和srcFile會被正常關閉。 假設認為一句話干不完清理的工作。也能夠使用在defer后加一個匿名函數的做法： defer func() { // 做你復雜的清理工作 } () ? 另外，一個函數中能夠存在多個defer語句，因此須要注意的是，defer語句的調用是遵照 先進后出的原則，即最后一個defer語句將最先被運行。
僅僅只是，當你須要為defer語句究竟哪
個先運行這樣的細節而煩惱的時候。說明你的代碼架構可能須要調整一下了59、panic()和recover() panic場景1? package main import "fmt" func ?main() { ? ? defer func(){ ? ? ? ?fmt.Println("hello,defer go") ? ? }() ? ? panic(11111) } recover場景2? package main import "fmt" func ?main() { ? ? defer func(){ ? ? ? ?fmt.Println("hello,defer go") ? ? }() ? ? panic(11111) } Go語言引入了兩個內置函數panic()和recover()以報告和處理執行時錯誤和程序中的錯 誤場景： func panic(interface{}) ? func recover() interface{} ? 當在一個函數運行過程中調用panic()函數時。正常的函數運行流程將馬上終止。但函數中 之前使用deferkeyword延遲運行的語句將正常展開運行，之后該函數將返回到調用函數，并導致 逐層向上運行panic流程，直至所屬的goroutine中全部正在運行的函數被終止。錯誤信息將被報 告。包含在調用panic()函數時傳入的參數。這個過程稱為錯誤處理流程。 從panic()的參數類型interface{}我們能夠得知，該函數接收隨意類型的數據。比方整 型、字符串、對象等。
調用方法非常easy，以下為幾個樣例：
panic(404) ? panic("network broken") ? panic(Error("file not exists")) recover()函數用于終止錯誤處理流程。普通情況下，recover()應該在一個使用defer keyword的函數中運行以有效截取錯誤處理流程。假設沒有在發生異常的goroutine中明白調用恢復 過程（使用recoverkeyword） 。會導致該goroutine所屬的進程打印異常信息后直接退出。 下面為一個常見的場景。 我們對于foo()函數的運行要么心里沒底感覺可能會觸發錯誤處理，或者自己在當中明白加 入了按特定條件觸發錯誤處理的語句，那么能夠用例如以下方式在調用代碼中截取recover()： defer func() { ? ? if r := recover(); r != nil { ? ? ? ? log.Printf("Runtime error caught: %v", r) ? ? } ? }() foo() 不管foo()中是否觸發了錯誤處理流程。該匿名defer函數都將在函數退出時得到運行。假 如foo()中觸發了錯誤處理流程。recover()函數運行將使得該錯誤處理過程終止。假設錯誤處 理流程被觸發時，程序傳給panic函數的參數不為nil。則該函數還會打印具體的錯誤信息。?60、panic()函數和recover()函數的調用詳細差別在哪里 在panic()開始錯誤處理流程,傳入的類型是interface{}隨意類型 ?, ?假設我們在defer 函數中調用? recover()函數那么會打斷錯誤處理流程。
panic的調用會終止正常的程序流程
recover()函數用于終止錯誤處理流程。普通情況下，recover()應該在一個使用defer keyword的函數中運行以有效截取錯誤處理流程。假設沒有在發生異常的goroutine中明白調用恢復 過程（使用recoverkeyword） ，會導致該goroutine所屬的進程打印異常信息后直接退出。?
package main import "fmt" func ?main() { //通過閉包定義 defer匿名函數 而且直接調用 ? ? defer func(){ ? ? ?//recover 結束當前錯誤處理過程 ?而且返回 panic的參數,并不結束其它goroutine的運行....... ? ? ? ?if r:=recover() ;r!=nil{ ?? ? ? ? ? ?fmt.Println("recover() called!") ? ? ? ?} ? ? ? ?fmt.Println("hello,defer go") ? ? }() ? ? panic("hello,go") } 61、關于const 和iota的使用 package main import "fmt" var str string="aaa" const( A=iota B C ) func ?main() { fmt.Println(B) defer func(){ if r:=recover() ;r!=nil{ fmt.Println("recover() called!") fmt.Println(r) } fmt.Println("hello,defer go") }() panic("hello,go") }
62、高速排序算法與數組切片的使用 package main import "fmt" import "math/rand" /冒泡排序Go實現 時間復雜富 O(n)=n~n^2 func bubbledSort(values []int){ ? var flags bool =true for i:=0 ;i<len(values);i++{ ? flags=true for j:=0;j<len(values)-i-1;j++{ if values[j]>values[j+1] { values[j],values[j+1]=values[j+1],values[j] flags=false } } if flags { break } } } ///高速排序Go實現 func quickSort(values []int,left,right int){ temp := values[left] p := left i, j := left, right for i <= j { for j >= p && values[j] >= temp { j-- } if j >= p { values[p] = values[j] p = j } if values[i] <= temp && i <= p { i++ } if i <= p { values[p] = values[i] p = i } } values[p] = temp if p - left > 1 { quickSort(values, left, p - 1) } if right - p > 1 { quickSort(values, p + 1, right) } } func ?main() { //創建初始化0個元素 ?容量1000的 切片 假設用索引直接訪問切片會越界的 ?容量必須大于等于 初始化元素個數 ? ? //val[1]=11 val:=make([]int,0,1000) for i:=0;i<1000;i++{ val=append(val,rand.Intn(1000)) } fmt.Println("冒泡排序前:",val) bubbledSort(val) ? fmt.Println("冒泡排序后:",val) ? }
63、Go中的import和package 等等的關系? //import僅僅是引入的目錄而已,,,能夠使用相對路徑或者絕對路徑 //他會把目錄中的全部.go文件引入 ,,,,,, ///package xx 實際上是 在外不用調用用的 比方xx.A() 并非給import使用 ? package內部的小寫所有是私有 大寫所有是公有 //外部包不能和主模塊放到一起會編譯只是的 import "./bubble" ?
版權聲明：本文博主原創文章，博客，未經同意不得轉載。
轉載于:https://www.cnblogs.com/zfyouxi/p/4839489.html
總結
以上是生活随笔為你收集整理的Golang基于学习总结的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： c语言习题---（循环语句）
- 下一篇： l5630鲁大师跑分_不用花钱 动一动手