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