GoLang函數與面向接口編程全面分析講解

Posted on by

一、函數

1. 函數的基本形式

// 函數定義：a,b是形參
func add(a int, b int) { 
	a = a + b 
}
var x, y int = 3, 6
add(x, y) // 函數調用：x,y是實參
  • 形參是函數內部的局部變量，實參的值會拷貝給形參
  • 函數定義時的第一個的大括號不能另起一行
  • 形參可以有0個或多個，支持使用可邊長參數
  • 參數類型相同時可以隻寫一次，比如add(a,b int)
  • 在函數內部修改形參的值，實參的值不受影響
  • 如果想通過函數修改實參，就需要傳遞指針類型
func change(a, b *int) { 
    *a = *a + *b
    *b = 888
}
var x, y int = 3, 6
change(&x, &y)

slice、map、channel都是引用類型，它們作為函數參數時其實跟普通struct沒什麼區別，都是對struct內部的各個字段做一次拷貝傳到函數內部

package main
import "fmt"
// slice作為參數，實際上是把slice的arrayPointer、len、cap拷貝瞭一份傳進來
func sliceChange(arr []int) { 
	arr[0] = 1 // 實際是修改底層數據裡的首元素
	arr = append(arr, 1) // arr的len和cap發生瞭變化，不會影響實參
}
func main() {
	arr := []int{8}
	sliceChange(arr)
	fmt.Println(arr[0])   // 1，數組元素發生改變
	fmt.Println(len(arr)) // 1，實際的長度沒有改變
}

關於函數返回值

  • 可以返回0個或多個參數
  • 可以在func行直接聲明要返回的變量
  • return後面的語句不會執行
  • 無返回參數時return可以不寫
// 返回變量c已經聲明好瞭，在函數中可以直接使用
func returnf(a, b int) (c int) {
    a = a + b
    c = a // 直接使用c
    return // 由於函數要求有返回值，即使給c賦過值瞭，也需要顯式寫return
}

不定長參數實際上是slice類型

// other為不定長參數可傳遞任意多個參數，a是必須傳遞的參數
func args(a int, other ...int) int { 
    sum := a
    // 直接當作slice來使用
    for _, ele := range other {
        sum += ele
    }
    fmt.Printf("len %d cap %d\n", len(other), cap(other))
    return sum
}
args(1)
args(1,2,3,4)

append函數接收的就是不定長參數

arr = append(arr, 1, 2, 3)
arr = append(arr, 7)
arr = append(arr)
slice := append([]byte("hello "), "world"...) // ...自動把"world"轉成byte切片，等價於[]byte("world")...
slice2 := append([]rune("hello "), []rune("world")...) // 需要顯式把"world"轉成rune切片

在很多場景下string都隱式的轉換成瞭byte切片，而非rune切片，比如"a中"[1]獲取到的值為228而非"中"

2. 遞歸函數

最經典的斐波那契數列的遞歸求法

func fibonacci(n int) int {
    if n == 0 || n == 1 {
        return n // 凡是遞歸，一定要有終止條件，否則會進入無限循環
    }
    return fibonacci(n-1) + fibonacci(n-2) // 遞歸調用自身
}

3. 匿名函數

函數也是一種數據類型

func functionArg1(f func(a, b int) int, b int) int { // f參數是一種函數類型
	a := 2 * b
	return f(a, b)
}
type foo func(a, b int) int // foo是一種函數類型
func functionArg2(f foo, b int) int { // type重命名之後，參數類型看上去簡潔多瞭
    a := 2 * b
    return f(a, b)
}
type User struct {
    Name string
    bye foo // bye的類型是foo，也就是是函數類型
    hello func(name string) string // 使用匿名函數來聲明struct字段的類型為函數類型
}
ch := make(chan func(string) string, 10)
// 使用匿名函數向管道中添加元素
ch <- func(name string) string {
	return "hello " + name
}

4. 閉包

閉包（Closure）是引用瞭自由變量的函數，自由變量將和函數一同存在，即使已經離開瞭創造它的環境，閉包復制的是原對象的指針

package main
import "fmt"
func sub() func() {
	i := 10
	fmt.Printf("%p\n", &i)
	b := func() {
		fmt.Printf("i addr %p\n", &i) // 閉包復制的是原對象的指針
		i-- // b函數內部引用瞭變量i
		fmt.Println(i)
	}
	return b // 返回瞭b函數，變量i和函數b將一起存在，即使已經離開函數sub()
}
// 外部引用函數參數局部變量
func add(base int) func(int) int {
	return func(i int) int {
		fmt.Printf("base addr %p\n", &base)
		base += i
		return base
	}
}
func main() {
	b := sub()
	b()
	b()
	fmt.Println()
	tmp1 := add(10)
	fmt.Println(tmp1(1), tmp1(2))
	// 此時tmp1和tmp2不是一個實體瞭
	tmp2 := add(100)
	fmt.Println(tmp2(1), tmp2(2))
}

5. 延遲調用defer

  • defer用於註冊一個延遲調用（在函數返回之前調用）
  • defer典型的應用場景是釋放資源，比如關閉文件句柄，釋放數據庫連接等
  • 如果同一個函數裡有多個defer，則後註冊的先執行，相當於是一個棧
  • defer後可以跟一個func，func內部如果發生panic，會把panic暫時擱置，當把其他defer執行完之後再來執行這個
  • defer後不是跟func，而直接跟一條執行語句，則相關變量在註冊defer時被拷貝或計算
func basic() {
    fmt.Println("A")
    defer fmt.Println(1) fmt.Println("B")
    // 如果同一個函數裡有多個defer，則後註冊的先執行
    defer fmt.Println(2)
    fmt.Println("C")
}

func deferExecTime() (i int) {
	i = 9
	// defer後可以跟一個func
	defer func() {
		fmt.Printf("first i=%d\n", i) // 打印5，而非9，充分理解“defer在函數返回前執行”的含義，不是在“return語句前執行defer”
	}()
	defer func(i int) {
		fmt.Printf("second i=%d\n", i) // 打印9
	}(i)
	defer fmt.Printf("third i=%d\n", i) // 打印9，defer後不是跟func，而直接跟一條執行語句，則相關變量在註冊defer時被拷貝或計算
	return 5
}

6. 異常處理

go語言沒有try catch，它提倡直接返回error

func divide(a, b int) (int, error) {
    if b == 0 {
        return -1, errors.New("divide by zero")
    }
    return a / b, nil
}
// 函數調用方判斷error是否為nil，不為nil則表示發生瞭錯誤
if res, err := divide(3, 0); err != nil {
    fmt.Println(err.Error())
}

Go語言定義瞭error這個接口，自定義的error要實現Error()方法

// 自定義error
type PathError struct {
    path string
    op string
    createTime string
    message string
}
// error接口要求實現Error() string方法
func (err PathError) Error() string {
	return err.createTime + ": " + err.op + " " + err.path + " " + err.message
}

何時會發生panic:

  • 運行時錯誤會導致panic，比如數組越界、除0
  • 程序主動調用panic(error)

panic會執行什麼：

  • 逆序執行當前goroutine的defer鏈（recover從這裡介入）
  • 打印錯誤信息和調用堆棧
  • 調用exit(2)結束整個進程
func soo() {
	fmt.Println("enter soo")
	// 去掉這個defer試試，看看panic的流程,把這個defer放到soo函數末尾試試
	defer func() {
		// recover必須在defer中才能生效
		if err := recover(); err != nil {
			fmt.Printf("soo panic:%s\n", err)
		}
	}()
	fmt.Println("regist recover")
	defer fmt.Println("hello")
	defer func() {
		n := 0
		_ = 3 / n // 除0異常，發生panic，下一行的defer沒有註冊成功
		defer fmt.Println("how are you")
	}()
}

二、面向接口編程

1. 接口的基本概念

接口是一組行為規范的集合

// 定義接口，通常接口名以er結尾
type Transporter interface {
    // 接口裡面隻定義方法，不定義變量
    move(src string, dest string) (int, error) // 方法名 (參數列表) 返回值列表
    whistle(int) int // 參數列表和返回值列表裡的變量名可以省略
}

隻要結構體擁有接口裡聲明的所有方法，就稱該結構體“實現瞭接口”，一個struct可以同時實現多個接口

// 定義結構體時無需要顯式聲明它要實現什麼接口
type Car struct {
    price int
}
func (car Car) move(src string, dest string) (int, error) {
    return car.price, nil
}
func (car Car) whistle(n int) int {
    return n
}

接口值有兩部分組成, 一個指向該接口的具體類型的指針和另外一個指向該具體類型真實數據的指針

car := Car{"寶馬", 100}
var transporter Transporter
transporter = car

2. 接口的使用

func transport(src, dest string, transporter Transporter) error {
	 _,err := transporter.move(src, dest)
	return err
}
var car Car // Car實現瞭Transporter接口
var ship Shiper	// Shiper實現瞭Transporter接口
transport("北京", "天津", car)
transport("北京", "天津", ship)

3. 接口的賦值

// 方法接收者是值
func (car Car) whistle(n int) int {
}
// 方法接收者用指針，則實現接口的是指針類型
func (ship *Shiper) whistle(n int) int {
}
car := Car{}
ship := Shiper{}
var transporter Transporter
transporter = car 
transporter = &car // 值實現的方法，默認指針同樣也實現瞭
transporter = &ship // 但指針實現的方法，值是沒有實現的

4. 接口嵌入

type Transporter interface {
	whistle(int) int
}
type Steamer interface {
    Transporter // 接口嵌入，相當於Transporter接口定義的行為集合是Steamer的子集
    displacement() int
}

5. 空接口

空接口類型用interface{}表示，註意有{}

var i interface{<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E-->}

空接口沒有定義任何方法，因此任意類型都實現瞭空接口

var a int = 5
i = a

func square(x interface{<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E-->}){<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E-->} // 該函數可以接收任意數據類型

註意：slice的元素、map的key和value都可以是空接口類型，map中的key可以是任意能夠用==操作符比較的類型，不能是函數、map、切片，以及包含上述3中類型成員變量的的struct，map的value可以是任意類型

6. 類型斷言

// 若斷言成功，則ok為true，v是具體的類型
if v, ok := i.(int); ok {
	fmt.Printf("i是int類型，其值為%d\n", v)
} else {
	fmt.Println("i不是int類型")
}

當要判斷的類型比較多時，就需要寫很多if-else，更好的方法是使用switch i.(type)，這也是標準的寫法

switch v := i.(type) { // 隱式地在每個case中聲明瞭一個變量v
case int:  // v已被轉為int類型
	fmt.Printf("ele is int, value is %d\n", v)
	// 在 Type Switch 語句的 case 子句中不能使用fallthrough
case float64: // v已被轉為float64類型
	fmt.Printf("ele is float64, value is %f\n", v)
case int8, int32, byte: // 如果case後面跟多種type，則v還是interface{}類型
	fmt.Printf("ele is %T, value is %d\n", v, v)
}

7. 面向接口編程

電商推薦流程

為每一個步驟定義一個接口

type Recaller interface {
    Recall(n int) []*common.Product // 生成一批推薦候選集
}
type Sorter interface {
    Sort([]*common.Product) []*common.Product // 傳入一批商品，返回排序之後的商品
}
type Filter interface {
    Filter([]*common.Product) []*common.Product // 傳入一批商品，返回過濾之後的商品
}
type Recommender struct {
    Recallers []recall.Recaller
    Sorter sort.Sorter
    Filters []filter.Filter
}

使用純接口編寫推薦主流程

func (rec *Recommender) Rec() []*common.Product {
	RecallMap := make(map[int]*common.Product, 100)
	// 順序執行多路召回
	for _, recaller := range rec.Recallers {
		products := recaller.Recall(10) // 統一設置每路最多召回10個商品
		for _, product := range products {
			RecallMap[product.Id] = product // 把多路召回的結果放到map裡，按Id進行排重
		}
	}
	// 把map轉成slice
	RecallSlice := make([]*common.Product, 0, len(RecallMap))
	for _, product := range RecallMap {
		RecallSlice = append(RecallSlice, product)
	}
	SortedResult := rec.Sorter.Sort(RecallSlice) // 對召回的結果進行排序
	// 順序執行多種過濾規則
	FilteredResult := SortedResult
	for _, filter := range rec.Filters {
		FilteredResult = filter.Filter(FilteredResult)
	}
	return FilteredResult
}

面向接口編程，在框架層面全是接口。具體的實現由不同的開發者去完成，每種實現單獨放到一個go文件裡，大傢的代碼互不幹擾。通過配置選擇采用哪種實現，也方便進行效果對比

到此這篇關於GoLang函數與面向接口編程全面分析講解的文章就介紹到這瞭,更多相關GoLang函數與面向接口內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：