1、不支持繼承 重載 ,比如C++Java的接口，接口的修改會影響整個實現(xiàn)改接口的類行為的修改,Go 設計者認為這一特點或許根本沒用. 2、必任何函數(shù)定義必須花括號跟在函數(shù)聲明后面而不能換行 如 func ?funca(a int){},在Go語言中 函數(shù)也是一種類型 可以被推導 ?使用支持匿名函數(shù) 和閉包。? 函數(shù)的返回值支持多重返回類似Python , 如果不賦值 ?整數(shù)類型默認 0 ? ? 浮點數(shù)類型默認0.0 ? error類型 默認是nil 3、不用的包一定不要引入，這是Go的原則,就如Python的嚴格制表符對其一樣 ? ,和 unused 變量都會被 ?編譯器所報錯 4、package做為引入包用。 5、import "a" ?調(diào)用包內(nèi)部的函數(shù) a.xx() ? 6、CGo是Go語言的一個特性,可以方便快速的在Go中調(diào)用C ?相比Java JNI簡單容易實現(xiàn)? 7、go通過goroutine 進行協(xié)程優(yōu)化 提高并發(fā)性能。 動態(tài)線程調(diào)整。 8、6g和6l是64位版本的Go編譯器和鏈接器，對應的32位版本工具為8g和8l。Go還有另外一個?GCC版本的編譯器，名為 gccgo。 9、注意多個go文件可以用同一個包名字,如果要為 Go生成可執(zhí)行文件 那么必須 進行 package main main函數(shù)的聲明 func main()? { ? ? ? ? ? args := os.Args ? ? ? if args == nil || len(args) < 2 { ? ? return ? } 10、Linux 為了能夠構(gòu)建這個工程， 需要先把這個工程的根目錄加入到環(huán)境變量GOPATH中。 假設calcproj?目錄位于~/goyard下，則應編輯~/.bashrc文件，并添加下面這行代碼： ?export GOPATH=~/goyard/calcproj 然后執(zhí)行以下命令應用該設置：?$ source ~/.bashrc ,GOPATH和PATH環(huán)境變量一樣，也可以接受多個路徑，并且路徑和路徑之間用冒號分割。 ?設置完GOPATH后，現(xiàn)在我們開始構(gòu)建工程。假設我們希望把生成的可執(zhí)行文件放到?calcproj/bin目錄. 11、GoRoot go安裝路徑 ....上面的時候工程路徑 12、GDB調(diào)試 不用設置什么編譯選項， Go語言編譯的二進制程序直接支持GDB調(diào)試， 比如之前用go build?calc編譯出來的可執(zhí)行文件calc，就可以直接用以下命令以調(diào)試模式運行： ??$ gdb calc ? 因為GDB的標準用法與Go沒有特別關(guān)聯(lián)，這里就不詳細展開了，有興趣的讀者可以自行查 看對應的文檔。需要注意的是，Go編譯器生成的調(diào)試信息格式為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的類型

出現(xiàn)在:=左側(cè)的變量不應該是已經(jīng)被聲明過的，否則會導致編譯錯誤，比如下面這個 寫法： var i int i := 2 會導致類似如下的編譯錯誤： no new variables on left side of := 17、支持多重賦值,i, j = j, i ?兩個值可以如此簡單的進行交換 ?而不許引入外部變量
18、 我們在使用傳統(tǒng)的強類型語言編程時，經(jī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)容，從而大幅 降低溝通的復雜度和代碼維護的難度
19、 在Go語言中，常量是指編譯期間就已知且不可改變的值。常量可以是數(shù)值類型（包括整型、 浮點型和復數(shù)類型） 、布爾類型、字符串類型等。 所謂字面常量（literal） ，是指程序中硬編碼的常量，如： -12 3.14159265358979323846?// 浮點類型的常量 ? 3.2+12i ??// 復數(shù)類型的常量 ? true ??// 布爾類型的常量 ? "foo"?// 字符串常量 ? 在其他語言中，常量通常有特定的類型，比如?12在C語言中會認為是一個int類型的常量。 如果要指定一個值為?12的long類型常量，需要寫成-12l，這有點違反人們的直觀感覺。Go語言 的字面常量更接近我們自然語言中的常量概念，它是無類型的。只要這個常量在相應類型的值域 范圍內(nèi)，就可以作為該類型的常量，比如上面的常量-12，它可以賦值給int、uint、int32、 int64、float32、float64、complex64、complex128等類型的變量。
20、常量的定義 通過const關(guān)鍵字，你可以給字面常量指定一個友好的名字： 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 由于常量的賦值是一個編譯期行為， 所以右值不能出現(xiàn)任何需要運行期才能得出結(jié)果的表達 式，比如試圖以如下方式定義常量就會導致錯誤 const Home = os.GetEnv("HOME") 原因很簡單，os.GetEnv()只有在運行期才能知道返回結(jié)果，在編譯期并不能確定，所以 無法作為常量定義的右值。
21、 Go語言預定義了這些常量：true、false和iota。?
iota比較特殊，可以被認為是一個可被編譯器修改的常量，在每一個const關(guān)鍵字出現(xiàn)時被
重置為0，然后在下一個const出現(xiàn)之前，每出現(xiàn)一次iota，其所代表的數(shù)字會自動增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? v?float64?=?iota?*?42???//?v?==?42.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、 關(guān)于枚舉 ?所有符號 以大寫開頭在包外是可見的 ? 小寫只能在包內(nèi)部使用 枚舉指一系列相關(guān)的常量，比如下面關(guān)于一個星期中每天的定義。通過上一節(jié)的例子，我們 看到可以用在const后跟一對圓括號的方式定義一組常量， 這種定義法在Go語言中通常用于定義 枚舉值。Go語言并不支持眾多其他語言明確支持的enum關(guān)鍵字。 下面是一個常規(guī)的枚舉表示法，其中定義了一系列整型常量： const ( ? ? Sunday = iota ? ? Monday ? ? Tuesday ? ? Wednesday ? ? Thursday ? ? Friday ? ? Saturday ? ? numberOfDays ? ? ? ?// 這個常量沒有導出 ? ) ? 同Go語言的其他符號（symbol）一樣，以大寫字母開頭的常量在包外可見。 以上例子中numberOfDays為包內(nèi)私有，其他符號則可被其他包訪問。
23、go中的布爾類型 只能用 false ?true != ==不能進行強制轉(zhuǎn)換? Go語言中的布爾類型與其他語言基本一致，關(guān)鍵字也為bool，可賦值為預定義的true和 false示例代碼如下： var v1 bool v1 = true v2 := (1 == 2) // v2也會被推導為bool類型 布爾類型不能接受其他類型的賦值，不支持自動或強制的類型轉(zhuǎn)換。以下的示例是一些錯誤 的用法，會導致編譯錯誤： 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語言中?是^x
28、關(guān)于浮點數(shù)的操作 ?浮點數(shù) 自動推導 是float64即C語言中的double 不能直接和fload32轉(zhuǎn)換 要進行強制轉(zhuǎn)換 ? 因為浮點數(shù)的比較精度? 浮點型用于表示包含小數(shù)點的數(shù)據(jù)，比如1.234就是一個浮點型數(shù)據(jù)。Go語言中的浮點類型
采用IEEE-754標準的表達方式。?
1.?浮點數(shù)表示?
Go語言定義了兩個類型float32和float64，其中float32等價于C語言的float類型，
float64等價于C語言的double類型。?
在Go語言里，定義一個浮點數(shù)變量的代碼如下：?
var?fvalue1?float32?
?
fvalue1?=?12??
fvalue2?:=?12.0?//?如果不加小數(shù)點，fvalue2會被推導為整型而不是浮點型?
對于以上例子中類型被自動推導的fvalue2，需要注意的是其類型將被自動設為float64，
而不管賦給它的數(shù)字是否是用32位長度表示的。因此，對于以上的例子，下面的賦值將導致編譯
錯誤：?
fvalue1?=?fvalue2??

對于以上例子中類型被自動推導的fvalue2，需要注意的是其類型將被自動設為float64， 而不管賦給它的數(shù)字是否是用32位長度表示的。因此，對于以上的例子，下面的賦值將導致編譯 錯誤： fvalue1 = fvalue2 ? 而必須使用這樣的強制類型轉(zhuǎn)換： fvalue1 = float32(fvalue2) 29、自定義精準的?浮點數(shù)比較 ,由于浮點數(shù)不是一種精確的表達方式 所以比較精度 可能不準確 因為浮點數(shù)不是一種精確的表達方式， 所以像整型那樣直接用==來判斷兩個浮點數(shù)是否相等 是不可行的，這可能會導致不穩(wěn)定的結(jié)果。 下面是一種推薦的替代方案： import "math" ? // p為用戶自定義的比較精度，比如0.00001 func IsEqual(f1, f2, p float64) bool?{ ?? return math.Fdim(f1, f2) < p ? }
30、 Go語言中的復數(shù)類型 , real 取出 實部 ?imag取出虛部 ?虛部為0 的復數(shù) 為純虛數(shù)。 某一類數(shù)字可以表示成這種復數(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))

復數(shù)實際上由兩個實數(shù)（在計算機中用浮點數(shù)表示）構(gòu)成，一個表示實部（real），一個表示虛部（imag）。

對于什么是復數(shù)可以參考：http://baike.baidu.com/view/10078.htm

復數(shù)實際上由兩個實數(shù)（在計算機中用浮點數(shù)表示）構(gòu)成，一個表示實部（real） ，一個表示

虛部（imag） 。如果了解了數(shù)學上的復數(shù)是怎么回事，那么Go語言的復數(shù)就非常容易理解了。

1. 復數(shù)表示

復數(shù)表示的示例如下：

var value1 complex64 ?

?

// 由2個float32構(gòu)成的復數(shù)類型

?

value1 = 3.2 + 12i

value2 := 3.2 + 12i ?

?

// value2是complex128類型

value3 := complex(3.2, 12) ?

// value3結(jié)果同 value2

2. 實部與虛部

對于一個復數(shù)z = complex(x, y)，就可以通過Go語言內(nèi)置函數(shù)real(z)獲得該復數(shù)的實

部，也就是x，通過imag(z)獲得該復數(shù)的虛部，也就是y。

更多關(guān)于復數(shù)的函數(shù)，請查閱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、關(guān)于Go的編碼處理 只支持 Unicode UTF-8格式 ? import strings 這個包中包含了處理string類型的所有工具函數(shù)函數(shù)? Go編譯器支持UTF-8的源代碼文件格式。這意味著源代碼中的字符串可以包含非ANSI的字
符，比如“Hello?world.?你好，世界！?”可以出現(xiàn)在Go代碼中。但需要注意的是，如果你的Go代
碼需要包含非ANSI字符，保存源文件時請注意編碼格式必須選擇UTF-8。特別是在Windows下一
般編輯器都默認存為本地編碼，比如中國地區(qū)可能是GBK編碼而不是UTF-8，如果沒注意這點在
編譯和運行時就會出現(xiàn)一些意料之外的情況。?
字符串的編碼轉(zhuǎn)換是處理文本文檔（比如TXT、XML、HTML等）非常常見的需求，不過可
惜的是Go語言僅支持UTF-8和Unicode編碼。對于其他編碼，Go語言標準庫并沒有內(nèi)置的編碼轉(zhuǎn)
換支持。不過，所幸的是我們可以很容易基于iconv庫用Cgo包裝一個。這里有一個開源項目：
https://github.com/xushiwei/go-iconv
33、在Go中字符串的單個字符就是 byte類型也就是 uint8 一個字符串的長度len返回的默認是int類型也就是平臺相關(guān)類型,我們在做相應的操作的收 要么自動推導 要么進行強制轉(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類型的字符 關(guān)鍵字為 rune? 在Go語言中支持兩個字符類型，一個是byte（實際上是uint8的別名） ，代表UTF-8字符串的單個字節(jié)的值；另一個是rune，代表單個Unicode字符。 ? 關(guān)于rune相關(guān)的操作，可查閱Go標準庫的unicode包。另外unicode/utf8包也提供了?UTF8和Unicode之間的轉(zhuǎn)換。 ? 出于簡化語言的考慮，Go語言的多數(shù)API都假設字符串為UTF-8編碼。盡管Unicode字符在標?準庫中有支持，但實際上較少使用。?
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 } // 復雜類型數(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++程序員們很容易聯(lián)想起STL中std::vector和數(shù)組的關(guān)系。基于數(shù)組，數(shù)組切片添加了一系 列管理功能，可以隨時動態(tài)擴充存放空間，并且可以被隨意傳遞而不會導致所管理的元素被重復
基于數(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ù)的時候值被復制? 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ù)所修改 ? 并非一定要事先準備一個數(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，并預留10個元素的存儲空間： mySlice2 := make([]int, 5, 10) ? 直接創(chuàng)建并初始化包含5個元素的數(shù)組切片： mySlice3 := []int{1, 2, 3, 4, 5} ? 當然，事實上還會有一個匿名數(shù)組被創(chuàng)建出來，只是不需要我們來操心而已。? 數(shù)組切片支持Go語言內(nèi)置的cap()函數(shù)和len()函數(shù)，代碼清單2-2簡單示范了這兩個內(nèi)置 函數(shù)的用法。可以看出，cap()函數(shù)返回的是數(shù)組切片分配的空間大小，而len()函數(shù)返回的是 數(shù)組切片中當前所存儲的元素個數(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后面加了三個點，即一個省略號，如果沒有這個省 略號的話，會有編譯錯誤，因為按append()的語義，從第二個參數(shù)起的所有參數(shù)都是待附加的 元素。因為mySlice中的元素類型為int，所以直接傳遞mySlice2是行不通的。加上省略號相 當于把mySlice2包含的所有元素打散后傳入
42. 數(shù)組切片支持內(nèi)容復制 數(shù)組切片支持Go語言的另一個內(nèi)置函數(shù)copy()，用于將內(nèi)容從一個數(shù)組切片復制到另一個 數(shù)組切片。如果加入的兩個數(shù)組切片不一樣大，就會按其中較小的那個數(shù)組切片的元素個數(shù)進行 復制。下面的示例展示了copy()函數(shù)的行為： 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中使用復雜數(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) /如果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語言提供了一個內(nèi)置函數(shù)delete()，用于刪除容器內(nèi)的元素。下面我們簡單介紹一下如 何用delete()函數(shù)刪除map內(nèi)的元素： delete(myMap, "1234") 上面的代碼將從myMap中刪除鍵為“1234”的鍵值對。如果“1234”這個鍵不存在，那么這個調(diào) 用將什么都不發(fā)生，也不會有什么副作用。但是如果傳入的map變量的值是nil，該調(dià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、自定義復雜數(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ù)組切片 當然你直接傳遞 ?切片數(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將會被先執(zhí)行。? defer字面的意思是延遲執(zhí)行,也就是說會在不需要的時候自動執(zhí)行 而Go語言使用defer 關(guān)鍵字簡簡單單地解決了資源何時釋放的問題，比如以下的例子： 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()函數(shù)拋出異常，Go仍然會保證dstFile和srcFile會被正常關(guān)閉。 如果覺得一句話干不完清理的工作，也可以使用在defer后加一個匿名函數(shù)的做法： defer func() { // 做你復雜的清理工作 } () ? 另外，一個函數(shù)中可以存在多個defer語句，因此需要注意的是，defer語句的調(diào)用是遵照 先進后出的原則，即最后一個defer語句將最先被執(zhí)行。只不過，當你需要為defer語句到底哪 個先執(zhí)行這種細節(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()以報告和處理運行時錯誤和程序中的錯 誤場景： func panic(interface{}) ? func recover() interface{} ? 當在一個函數(shù)執(zhí)行過程中調(diào)用panic()函數(shù)時，正常的函數(shù)執(zhí)行流程將立即終止，但函數(shù)中 之前使用defer關(guān)鍵字延遲執(zhí)行的語句將正常展開執(zhí)行，之后該函數(shù)將返回到調(diào)用函數(shù)，并導致 逐層向上執(zhí)行panic流程，直至所屬的goroutine中所有正在執(zhí)行的函數(shù)被終止。錯誤信息將被報 告，包括在調(diào)用panic()函數(shù)時傳入的參數(shù)，這個過程稱為錯誤處理流程。 從panic()的參數(shù)類型interface{}我們可以得知，該函數(shù)接收任意類型的數(shù)據(jù)，比如整 型、字符串、對象等。調(diào)用方法很簡單，下面為幾個例子： panic(404) ? panic("network broken") ? panic(Error("file not exists")) recover()函數(shù)用于終止錯誤處理流程。一般情況下，recover()應該在一個使用defer 關(guān)鍵字的函數(shù)中執(zhí)行以有效截取錯誤處理流程。如果沒有在發(fā)生異常的goroutine中明確調(diào)用恢復 過程（使用recover關(guān)鍵字） ，會導致該goroutine所屬的進程打印異常信息后直接退出。 以下為一個常見的場景。 我們對于foo()函數(shù)的執(zhí)行要么心里沒底感覺可能會觸發(fā)錯誤處理，或者自己在其中明確加 入了按特定條件觸發(fā)錯誤處理的語句，那么可以用如下方式在調(diào)用代碼中截取recover()： defer func() { ? ? if r := recover(); r != nil { ? ? ? ? log.Printf("Runtime error caught: %v", r) ? ? } ? }() foo() 無論foo()中是否觸發(fā)了錯誤處理流程，該匿名defer函數(shù)都將在函數(shù)退出時得到執(zhí)行。假 如foo()中觸發(fā)了錯誤處理流程，recover()函數(shù)執(zhí)行將使得該錯誤處理過程終止。如果錯誤處 理流程被觸發(fā)時，程序傳給panic函數(shù)的參數(shù)不為nil，則該函數(shù)還會打印詳細的錯誤信息。?
60、panic()函數(shù)和recover()函數(shù)的調(diào)用具體區(qū)別在哪里 在panic()開始錯誤處理流程,傳入的類型是interface{}任意類型 ?, ?如果我們在defer 函數(shù)中調(diào)用? recover()函數(shù)那么會打斷錯誤處理流程。 panic的調(diào)用會終止正常的程序流程
recover()函數(shù)用于終止錯誤處理流程。一般情況下，recover()應該在一個使用defer 關(guān)鍵字的函數(shù)中執(zhí)行以有效截取錯誤處理流程。如果沒有在發(fā)生異常的goroutine中明確調(diào)用恢復 過程（使用recover關(guān)鍵字） ，會導致該goroutine所屬的進程打印異常信息后直接退出。?
package main import "fmt" func ?main() { //通過閉包定義 defer匿名函數(shù) 并且直接調(diào)用 ? ? defer func(){ ? ? ?//recover 結(jié)束當前錯誤處理過程 ?并且返回 panic的參數(shù),并不結(jié)束其他goroutine的執(zhí)行....... ? ? ? ?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) 時間復雜富 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ù) ? ? //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" ?

總結(jié)

以上是生活随笔為你收集整理的Golang基础学习总结的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。