1、Go 語言最主要的特性

• 自動垃圾回收
• 更豐富的內置型別
• 函式多回傳值
• 錯誤處理
• 匿名函式和閉包
• 型別和介面
• 并發編程
• 反射
• 語言互動性

2、$GOPATH目錄約定有三個子目錄

• src存放源代碼(比如：.go .c .h .s等) 按照golang默認約定，go run，go install等命令的當前作業路徑（即在此路徑下執行上述命令），
• pkg編譯時生成的中間檔案（比如：.a）　　golang編譯包時
• bin編譯后生成的可執行檔案（為了方便，可以把此目錄加入到 $PATH 變數中，如果有多個gopath，那么使用${GOPATH//??/bin:}/bin添加所有的bin目錄）

3、$GOROOT GO安裝目錄，為了直接使用go命令，設定環境變數 $GOROOT/bin

4、程式入口

• main 識別符號是隨處可見的，每一個 Go 程式都是從一個叫 main 的包中的 main 函式開始的，當 main 函式回傳時，程式執行結束，

fun main() {
	//執行陳述句
}

?? init 函式

• 1、init函式用于包的初始化，如初始化包中的變數，這個初始化在package xxx的時候完成，也就是在main之前完成，如果只是呼叫 init() 函式邏輯，通過 import _ "model"；
• 2、每個包可以擁有多個init函式， 每個包的源檔案也可以擁有多個init函式；
• 3、同一個包中多個init函式的執行順序是沒有明確定義的，但是不同包的init函式是根據包匯入的依賴關系決定的，
• 4、init函式不能被其他函式呼叫，其實在main函式之前自動執行的，

main() init(),都沒有引數和回傳值

5、import

• 相對路徑 import "./model"
• 絕對路徑 impoert "a/b/model"
• 點操作,這個點操作的作用就是這個包匯入后，當你想要呼叫這個包的函式的時候，你就能夠省略它的包名了，即fmt.Println()可以省略成Println()

	import (
    . "fmt"
	)

• __操作，其作用就是引入該包，而不直接使用包里面的函式或變數，會先呼叫包中的init函式，這種使用方式僅讓匯入的包做初始化，而不使用包中其他功能

import(
    _ "github.com/ziutek/mymysal/godrv"
)

6、在go中++和--等運算子只會用于陳述句而非運算式中，可能只可以做成后綴運算子而非前綴運算子，即go中不會出現 f(i++) 或 A[i]=b[++i] 這樣的運算式

7、在go語言中只講型別和值，而非類、物件或實體

• 相同結構的自定義型別等價，可以相互替換，但是不能有任何方法，
• 任何命名的自定義型別都可以有方法，并且和這些方法一起構成該型別的介面，命名的自定義型別即時結構完全相同，也不能相互替換
  介面也是一種型別，可以通過指定一組方法的方式定義，介面是抽象的，因此不可實體化，如果某個具體型別實作了某個介面所有的方法，那么這個型別就被認為實作了該介面，一個型別可以實作多個介面，
• 空介面（即沒有定義方法的介面），用interface{}來表示，由于空介面沒有做任何要求（因為它不需要任何方法），它可以用來表示任意值（效果相當于一個指向任意型別值的指標），無論這個值是一個內置型別的值還是一個自定義型別的值

8、變數宣告

• 全域申明

varname  type =

var   varname  type =

var  (
       varname  type
       varname  type
)

-函式體內部區域宣告：varname :=

func m() {
   a = "O" //全域修改變數的值
   a := "p" //函式體內部的簡短宣告，為區域變數
   print(a)
}

9、資料型別

1）整型

• 按長度：int8 int32 ....
• 無符號： uint8

2) float

3) bool

4)字串 string "雙引號書寫"，“ ` 反引號支持多行”

• 底層字串是位元組的定長陣列，
• len() 來獲取字串所占的位元組長度，例如：len(str)，一個漢字是三個位元組（三個字符），
• 字串、陣列、切片底層原始資料有相同的記憶體結構，但是切片是指標參考型別
• 字串無法轉整型，但是可以轉陣列[ ]byte,[ ]rune（中文處理轉 [ ]rune）
• 字串處理函式，strings包 Contains(s,substr string) bool

5）字符 單引號

• byte uint8別名，代表ASCII碼的一個字符 var a byte = 'a'
• rune int32, 代表utf8的一個字符，一般涉及中文，var b rune = '二'

10、常量

const name type = ' s'

隱式宣告 const name = "adAD"
存盤在常量中的資料型別只可以是布爾型、數字型（整數型、浮點型和復數complex）和字串型，
Go 中不允許不同型別之間的混合使用，但是對于常量的型別限制非常少，因此允許常量之間的混合使用，

	var a int
	var b int32
	a = 15
	b = a + a	 // 編譯錯誤
	b = b + 5    // 因為 5 是常量，所以可以通過編譯

宣告多個常量,未賦值則從上面獲取,iota ,常量計數器，從0開始，可用作列舉

const (
	a = 10
	b
	c
)

11、條件控制

if  num%2 == 0  {

} else if  {

}

//特殊寫法
if   varname,ok := mapdata[key]; ok {
}

switch  var1{
	case val1: 
		statement
	case val2:
		statement
	default:
		statement
}

//select 類似switch，隨機執行一個分支
select {
    case <- c:
        fmt.Printf("Unblocked %v later.\n", time.Since(start))

    case <- ch1:
        fmt.Printf("ch1 case...")

    case <- ch2:
        fmt.Printf("ch1 case...")

    default:
        fmt.Printf("default go...")
    }

12、回圈

for 回圈：

for 初始陳述句int；條件陳述句；post陳述句變數增值變動 {
			statement
}
//post陳述句是每次回圈的最后執行；
for i:= 0;i<=10;i++{
}

形式一、這三條陳述句可以省略，但是分號；不可省略
形式二、只有條件陳述句
 var i int
 for i <= 10 {
	}
形式三、相當于python中的while True:
for  {
   }
形式四：for key,value := range oldmap{
 			statement
	}

break continue goto 可以控制回圈

labelname: statement
goto labelname

13、函式

func funcname(paramname type1,paramname type2) (output1 type1, ...) {
	statement
	return output1,...   //可回傳多個值
}

不定數量的引數（可變長引數）
func funcname( arg ...int) (output1 type1,) {

}   //arg 本質是 int型的slice，相當于 [ ]int，若傳入slice時，需展開（[ ]int...）

變數宣告的地方：

• 函式內的區域變數
• 函式外的全域變數
• 函式中的形式引數

14、指標（一個變數的記憶體地址）

var name *int     //指標宣告
var a int = 100
name = &a    //獲取地址值
*name   //獲取指標指向的值

• 值傳遞：完全復制一份，開辟新的記憶體 (包含簡單資料型別，陣列，struct) ， new()方法創建，該方法也用于創建自定義型別（ 如：type newtype int ），回傳指標
• 參考傳遞： 參考原來的記憶體，若操作修改，將修改原來的值，有利于性能的提高 make()創建，回傳指標

15、GO語言內置容器

1）陣列

var varname [ 陣列長度 資料型別

var nums = [5]int{1,2,3,5,6}    
var nums = [...]int{1,2,3,5,6} 
//只能放統一型別的資料,陣列一旦定義后，大小不能改變

2)切片

• 本質是陣列，展示一部分，但是切片大小可變，若容量不夠時，可再申請空間

var  varname []type    
var slice []type = make([]type,len,capacity)

//也可以截取陣列來初始化切片
arr := [5]int{1,2,35,5,6}
slice := arr[start:end]

• len() 回傳切片長度
• cap() 回傳切片起始位置到陣列最后位置的長度
• 若是截取切片，形成的切片，對外是截取的資料，其本質是從截取的開始位置，到陣列的最后位置

append(slice,addnumber)函式，注意：

• 可以追加一個或多個元素，或一個切片
• append 會改變slice所參考的陣列內容，對于其他參考該陣列的切片（類似于python的淺拷貝），也會受到影響
• 當容量不夠時，GO 會創建一個新的記憶體地址來存盤元素，擯棄原來的地址

copy(var1,var2)

將var2 的內容拷貝到 var1, 完全復制過去，操作時互不影響，
通過切片、append 實作slice洗掉元素

3）map

• map 是一種無序鍵值對的集合，map通過key來快速檢索資料，類似于索引；
• 長度不定，可以像slice一樣擴展，可用len(), 不可用cap();

切片，函式等參考型別資料不能做鍵值

宣告
var  mapname  map[string]string  //該初始是一個 nil 空指標，無法存盤值，除非宣告的同時初始化資料
var  country = map[string]string{
	"china":"beijing",
}

name := make(map[key型別]value型別)   //提前申請了空間

//遍歷
for  k,v := range map{

}

value,ok := map[key]    //獲取value，  如果 ok is true,則存在,否則回傳空字串“”；
delete(map,key)   //洗掉一個鍵值對
//清空 map  可以創建一個空的map，將原值覆寫；

4）list

• list是一種非連續鏈式存盤的容器，雙向鏈表；最大特點：可以存盤任意型別的資料
• list 包下主要兩種型別，Eelement\List ,以下核心方法

//宣告
name  := list.New()  建議使用； 參考型別
var name list.List     值型別


//Element
func ( e  *Element)  Next()  *Element
func ( e  *Element)  Prev()  *Element

//List
func  New() *List    //List包創建list
func ( l  *List)  Init()  *List
func ( l  *List)  Len()  *List
func ( l  *List)  Front()  *Element    //獲取首個元素
func ( l  *List)  Back()  *Element    //獲取最后一個元素
func ( l  *List)  PushFront( v  interface{})  *Element    //頭部添加一個元素
func ( l  *List)  PushFrontList( v  *LIst)  *List   
func ( l  *List)  InsertBefore( v insterface{},mark *Element) * Element
func ( l  *List) MoveToFront(mark *Element) //將一個元素移到頭部
func ( l  *List) MoveBefore(v isnterface{}, mark *Element).
func ( l  *List) Remove(e *Element)  interface{}

16、面向物件

• 通過結構體、介面實作，結構體是由一系列具有相同型別或不同型別的資料構成的資料集合

type

• type 用于給型別起別名 type newname_type = oldtype
• type 用于型別定義 type newname_type oldtype

定義一個結構體
type Teaher struct {
	name string
	age int8
	sex byte
}

5種宣告方式
1. var 宣告
 
var  p Teacher
p.name = ''david"
p.age = 30
p.sex = 1

2. 簡短宣告
p := Teacher{}
p.name = ''david"
p.age = 30
p.sex = 1

3. 直接宣告并賦值
p = Teacher{ name：‘’sdff“,age: 25,sex:1}

4.不寫屬性名，但是需按照順序
p = Teacher{ "sdhn",30,0}

5.創建指標型別結構體  new( )
p := new( Teacher)
*p.name = "fjgns"
*p.age = 31
p.sex = 0   語法糖簡寫

匿名結構體和匿名欄位

//沒有名字的結構體：
	a := struct {欄位的定義}{賦值}
//匿名欄位，可以理解為欄位名和欄位型別一致
        type A struct{
		string
		int
	}
	b := A{"字串", 20}
	b.string, b.int

type  A struct{
      
}

//匿名欄位可以模擬繼承關系
type B struct{
	A  //匿名欄位的繼承關系,一個類作為另一個類的子類，定義一個匿名欄位struct.file, 繼承屬性和方法
}

// 聚合關系,一個類作為另一個類的屬性，定義一個欄位其型別是一個結構體,訪問相關屬性，struct.filestruct.file
type B struct{
	filedname  A
}

方法（包含接收者的函式)

方法可以同名，只要接受者不同就可以

func  (接受者變數  接受者型別)   方法名（ 引數串列） （回傳值串列）{
			//方法體
}   

介面，無法直接實體化

• 面向物件中，介面用于定義物件的行為，介面只指定物件應該做什么，實作這種行為的方法是由物件來決定
• 介面定義一組方法，如果某個物件實作了該介面的所有方法，則此物件就是實作了該介面；
• 介面剛好體現了多型，該介面可以被實作這個介面的任意物件賦值，同一介面，不同物件，同一方法的不同表現形態

1.定義介面
type  介面名字  interface {
	方法1（引數串列）回傳值串列
	方法2（引數串列）回傳值串列
}

2.定義結構體
type 結構體名 struct {
	//屬性
}

3.實作介面的方法
func (變數名  結構體型別)  方法1（引數串列） 回傳值

func main( ) {
	var  port  定義的介面型別
	port = new( 定義的實作該介面的結構體)
}

4、介面斷言
nstance,ok := 介面物件 . (實際型別） //一般配合switch\case 使用

注意：介面型別物件，不能訪問其實作類中的屬性欄位
	 定義方法時，修改屬性欄位，由于struct傳參時，是值型別，所以需要傳入指標，
	 定義一個介面變數，那么實際上可以賦值實作這個介面的任意物件（一般利用一個空介面）
如定義一個介面型別容器（陣列或切片），實際上該容器中可以存盤實作這個介面的任意物件
	   //要改變物件的值必須用指標
		func (b *User) SetName(name string) {
   		  	b.Name = name
		}

17、錯誤處理

• error 本質是一個介面型別，其中只含有一個Error() 方法

創建error物件的幾種方式
 1)  errors包下的New()函式回傳error物件
	errors.New()  //創建一個新的錯誤

package errors
//回傳一個新定義的錯誤結構體
func New( text string) error {
	return &errorString{ text}
}


2) fmt包下的Errorf()函式回傳error物件，其本質還是呼叫 errors.New(）
func  Errorf (formmat string,a ...interface{}) error {
return errors.New(Sprintf(format, a...))
}

3)自定義錯誤
  定義一個結構體，表示自定義的錯誤
  type errorString struct {
		s  string
	}

	func ( e *errorString)  Error() string {
		return e.s
	}

18.defer 延遲

• defer 陳述句在該函式內最后執行，即使報錯陳述句也會執行，當有多個defer陳述句時，采用先進后出模式
• 注意：延遲引數，延遲函式的引數在執行延遲陳述句時被執行，相當于引數已傳入，但是函式內的邏輯被延后執行

defer 應用

• panic和recover機制，以此來實作極特殊的例外處理
• panic（）讓程式進入恐慌，中斷程式的執行，但是延遲函式會正常執行
• recover（）讓程式恢復，必須在defer函式中執行，即僅在延.遲函式中有效， 正常的程式執行程序中，呼叫recover會回傳 nil ,并且沒有其他任何效果，如果當前程式進入恐慌，呼叫recover可以捕獲到panic的輸入值，并且恢復正常的執行

下面這個函式檢查作為其引數的函式執行時是否會  panic

func throwsPanic( f  func() )  b bool {
defer func( ） {
if x: = recover( ）；x != nil {
	b = true
	}()    //宣告一個匿名函式并呼叫
	f( ) // 執行函式f,如果出現 panic  ,程式中止，執行延遲陳述句，恢復回來
	return
}

19、閉包 環境變數 + 函式，具有資料的行為，回傳函式

func  getSequence()  func( )  int {
	i := 0
	return func() int {
		i += 1
		return i
	}
}

func main( ) {
nextNumber := getSequence( )
// 呼叫nextNumber 函式， i 變數自增 1 并回傳
fmt.Println( nextNumber( ) )
fmt.Println( nextNumber( ) )

nextNumber1 := getSequence( )
// 新創建nextNumber1函式， i 變數從0開始，自增 1 并回傳
fmt.Println( nextNumber1( ) )
fmt.Println( nextNumber1( ) )

輸出結果
>>> 	1
>>>  2
>>> 	1
>>>  2

20、go的并發

• 通過go關鍵字開啟goroutine，goroutine是輕量級的執行緒
• go 函式名( 引數串列)

21、通道channel

• channel 是用來傳遞資料的一個資料結構，channel可以用于兩個goroutine之間 傳遞一個指定型別的值來同步運行和通訊，

運算子 <- 用于指定通道方向，表示發送或接收，若未指定方向，則為雙向通道

ch <- v  //把 v 發送到通道ch
v := <- ch  // 從ch 接收資料 并賦值給v
ch : = make( chan int )  宣告一個帶快取通道，默認通道是不帶緩沖區的，
- 帶緩沖區的通道允許發送端的資料發送和接收端的資料獲取處于異步狀態，就是說發送端發送的資料可以放在緩沖區里面，可以等待接收端去獲取資料，而不是立刻需要接收端去獲取資料，
- 不過由于緩沖區的大小是有限的，所以還是必須有接收端來接收資料的，否則緩沖區一滿，資料發送端就無法再發送資料了，
- 如果緩沖區已滿，發送方阻塞；緩沖區無資料，接收方阻塞

package main

import "fmt"
func sum(s []int, c chan int) {
        sum := 0
        for _, v := range s {
                sum += v
        }
        c <- sum // 把 sum 發送到通道 c
}

func main() {
        s := []int{7, 2, 8, -9, 4, 0}
        c := make(chan int)
        go sum(s[:len(s)/2], c)
        go sum(s[len(s)/2:], c)
        x, y := <-c, <-c // 從通道 c 中接收
        fmt.Println(x, y, x+y)
}

Go 通過 range 關鍵字來實作遍歷讀取到的資料，類似于與陣列或切片，格式如下：

import (
        "fmt"
)

func fibonacci(n int, c chan int) {
        x, y := 0, 1
        for i := 0; i < n; i++ {
                c <- x
                x, y = y, x+y
        }
        close(c)
}

func main() {
        c := make(chan int, 10)
        go fibonacci(cap(c), c)
        // range 函式遍歷每個從通道接收到的資料，因為 c 在發送完 10 個
        // 資料之后就關閉了通道，所以這里我們 range 函式在接收到 10 個資料
        // 之后就結束了，如果上面的 c 通道不關閉close()，那么 range 函式就不
        // 會結束，將一直處于阻塞狀態，
        for i := range c {
                fmt.Println(i)
        }
}

標籤：Go

上一篇：Go語言net/http包的簡單使用

下一篇：channel的基本使用