Go語言學習筆記1/2

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

書籍：《Go語言編程》

Chap 1 初識Go語言

1.Go語言主要特性：自動記憶體回收，更豐富內建類型，函數多傳回值，錯誤處理，匿名函數和閉包，類型和介面（不支援繼承和重載，僅支援組合），並發貶稱，反射，語言互動性。
2.Go語言的main函數不能帶有參數也不能有傳回值。Go語言函數定義：
func 函數名(參數列表) (傳回值列表){//函數體}
3.編譯：go build hello.go；編譯運行，不產生中間編譯檔案和執行檔案：go run hello.go

Chap 2 順序編程
1.Go語言不需要使用分號。
2.變數聲明使用關鍵字var，格式為：var 變數名 變數類型 
3.變數初始化的三種方式：
var v1 int = 10
var v2 = 20//自動推導
v3 := 30//自動推導，完成聲明和初始化，會產生變數v3，因此v3不能是已經聲明的變數
雖然能自動推導，但是Go語言是強型別語言。
4.支援多重賦值，例如：i,j=j,i//交換i、j變數的值
5.函數參數中的變數是匿名變數。
6.定義常量：使用const關鍵字：const Pi float64 = 3.1415926
7.預定義常量：true、false和iota（可被編譯器修改的常量，在每一個const關鍵字出現時重設為0，在下一個const出現時，沒出現一次iota，其值加1）。
8.枚舉類型：
const(
Sunday=iota
Monday//會自動推導，Monday等於1
Tuesday
numberOfDays//只有大寫字母的對外包發布，小寫字母開頭的不對外發布
)
9.類型：
1)布爾類型bool：v2 := (1==2) 布爾類型不支援類型轉換
2)整形：int32、int64等是固定大小的，int、uint是平台相關的，建議使用平台相關的類型。不同類型如int和int32是不能比較的，會編譯錯誤，但是可以和字面常量（如i==1）進行比較。
3)浮點型：不能直接==進行比較，可以匯入math後根據相差的大小設定範圍進行相等的比較。
4)複數類型complex:var a complex
5)字串string：var str string
通過類似數組下標訪問，但是不能修改。預設為UTF-8字元，中文包括三個位元組。遍曆中文是可使用range函數對字串進行Unicode字元遍曆。
6)字元類型：byte代表單個utf-8位元組（一個漢字三個位元組），rune代表單個unicode字元（一個漢字一個字元）。
7)數群組類型：數組名 [number]類型
數群組類型是實值型別，因此函數參數如果是數組，會發生內部的複製過程。
8)切片slice：理解為可以動態擴充的數組，函數參數傳遞時不會發生複製過程。
A.基於數組創造切片：mySlice=myArray[n:m]
B.使用make函數：mySlice:=make([]int,5)
9)map類型：var myMap map[Key] Value，可以使用make函數建立。
檢查是否存在：value,ok := myMap["key"] 判斷ok即可
10.流程式控制制
1)條件陳述式：
A.if：條件無括弧，大括弧要緊跟if、else行。
func calc(x int,y int) int {
        if x>y {
                return x
        } else {
                return y
        }
}
B.switch：switch後面的變數可以不寫，case可以是運算式（i>5 && i<10），不用謝break，fallthrough緊跟執行。
func calc(i int) int {
        switch i {
                case 0:
                        fallthrough
                case 1:
                        fmt.Println("1")
                case 2:
                        fmt.Println("2")
                case 3:
                        fmt.Println("3")
                default:
                        fmt.Println("Default")
        }
        return 7
}
2)迴圈語句：僅支援for語句。for不需要用()，甚至可以不使用i(直接迴圈，使用break，類似於while)
func calc(x int) int {
        sum := 0
        for i:=0;i<x;i++ {
                sum+=i
        }
        return sum
}
3)跳轉goto：
func calc() int {
        sum := 0
        HERE:
                fmt.Println(sum)
        sum++
        if sum<100 {
                goto HERE
        }
        return 7
}
11.函數：
1)可接受不定參數func myfunc(args ...int)然後使用range遍曆(文法糖結構，調用時更方便，不必使用new int[]{1,2,3}樣式傳入參數)
2)不定參數支援切片操作
3)支援多傳回值，使用_跳過不想使用的傳回值
package main 
import (
"errors"
"fmt"
)
func Add(a,b int) (ret int, err error) {
        if a<0 || b<0 {
                err = errors.New("Should be non-negative numbers!")
                return
        }
        return a+b,nil
}
func main(){
        fmt.Println(Add(1,3))
}
12.匿名函數和閉包:
1)匿名函數可以直接賦值給某個變數
f:=func(x,y int) int {
return x+y
}
2)閉包：理解為匿名函數+系統內容（代碼中的變數等內容不再代碼中定義）
f:=func()(func()){
var i int = 10
return func(){
fmt.Printf("i,j:%d,%d\n",i,j)
}
}()
f()
j*=2
f()
注意：定義函數func，傳回型別為func()，最後需要加()，這樣i外部不能訪問，之後定義的j在f的多次調用後可以不同。
13.defer（延遲函數）定義後將以先進後出的方法進行調用。panic()函數調用後：正常的函數執行流程將立即終止，但函數中之前使用defer關鍵字順延強制的語句將正常展開執行，之後該函數將返回到調用函數，並導致

逐層向上執行panic流程，直至所屬的goroutine中所有正在執行的函數被終止。recover()函數用於終止錯誤處理流程。

chap03 物件導向編程
1.定義類型使用type關鍵字，例如：
type Integer int
為Integer添加方法，如下：
func (a Integer) Less(b Integer) bool{
return a<b
}
如果要修改類型的值，需要使用指標，如func (a *Integer)...
2.Go語言中大多數為值引用（包括數組），引用的修改不改變被引用的值。
3.定義類型使用struct關鍵字，執行個體如下：
package main
import "fmt"
type Rect struct {
        x, y float64
}
//定義方法
func (r Rect) Area() float64 {
        return  r.x * r.y
}


func main(){
        r := &Rect{10,20} //初始化1
        fmt.Print(r.Area())
        fmt.Print("\n")
        s := new (Rect) //初始化2
        fmt.Print(s.Area())
        fmt.Print("\n")
        t := &Rect{x:30,y:40} //初始化3
        fmt.Print(t.Area())
}
4.Go通過組合的方式提供繼承特性，稱之為匿名組合。可以直接調用組合的方法。
package main
import "fmt"


type Base struct{
        Name string 
}
func (b *Base) SayHi() {
        fmt.Print("Hi, Base!\n")
}


type Child struct{
        Base
}


type Child1 struct{
        *Base
}
func (c *Child1) SayHi1(){
        c.Base.SayHi()
}
func (c *Child1) SayHi2(){
        c.SayHi()
}


func main(){
        b := &Base{}
        b.SayHi()
        c := &Child{*b}
        c.SayHi()
        d := &Child1{b}
        d.SayHi()
        d.Base.SayHi()
        d.SayHi1()
        d.SayHi2()
}
5.可見度方面，大寫表示對外可見，小寫只是包內可見。
6.Go語言中，只要一個類實現了介面所有的方法，就說明該類實現了介面。介面定義如下：
package main
import "fmt"


type  File  struct{
        Name string
}
func (f *File) Read() {
        fmt.Print("Read")
}


type IFile interface {
        Read()
}


func main(){
        var ifc IFile = new(File)
        ifc.Read()
}
7.介面賦值類似類型轉換，可以從介面多的轉換為介面少的。
8.介面查詢：
if file,ok:file1.(IStream);ok{
...
}
檢查file1是否實現IStream介面，如果實現，執行{}中語句。
9.類型查詢：
var v1 interface{} = ...
switch v:=v1.(type){
case int:
case string:
...
}
10.介面可以組合，跟類的組合一致。
11.interface{}可以用於定義Any類型。