前言

圖片來自Wallpaper Engine 如果侵權聯系我立刪

博主介紹：

– 本人是了凡，意思為希望本人任何時候以善良為先，以人品為重，喜歡了凡四訓中的立命之學、改過之法、積善之方、謙德之效四訓，更喜歡每日在簡書上投稿每日的讀書感悟筆名：三月_劉超，專注于 Go Web 后端，輔學Python、Java、演算法、前端等領域，

保姆系列

基礎篇

ONE：https://blog.csdn.net/weixin_45765795/article/details/117278889
TWO：https://blog.csdn.net/weixin_45765795/article/details/117548389

進階篇

ONE：https://blog.csdn.net/weixin_45765795/article/details/117257325

什么是函式？

生活中的函式

函式（function）的定義通常分為傳統定義和近代定義，函式的兩個定義本質是相同的，只是敘述概念的出發點不同，傳統定義是從運動變化的觀點出發，而近代定義是從集合、映射的觀點出發，函式的近代定義是給定一個數集A，假設其中的元素為x，對A中的元素x施加對應法則f，記作f（x），得到另一數集B，假設B中的元素為y，則y與x之間的等量關系可以用y=f（x）表示，函式概念含有三個要素：定義域A、值域C和對應法則f，其中核心是對應法則f，它是函式關系的本質特征，

程式中的函式

1、函式是一個可以多次使用的功能代碼塊，一個封閉的（空間），它可以在代碼里隨意呼叫，利用函式的封裝可以減少重復代碼的開發，提高代碼的利用率，函式可以傳參，利用函式內預先定義的內容對傳入的不同資料引數進行處理，

2、函式也是物件，也可以為值，它可以存在于變數，陣列和物件之中，

3、函式可以當參傳遞給函式，并且由函式回傳，另外函式擁有屬性，

4、函式總會有回傳值（除了建構式之外，建構式默認回傳構造器函式呼叫，當建構式呼叫執行時，會顯示回傳）

邏輯角度

能夠完成特定功能的獨立代碼塊

物理角度

能夠接收資料
能夠對接受的資料進行處理
能夠將資料處理的結果回傳

為什么需要函式？

1.避免了重復性操作,實作了代碼的可重復性
2.有利于程式的模塊化
3.易于維護

函式怎么用？

函式定義

這里以最近比較火的一門Golang語言為例：

函式特點

無需宣告原型，
支持不定 變參，
支持多回傳值，
支持命名回傳引數，
支持匿名函式和閉包，
函式也是一種型別，一個函式可以賦值給變數，

不支持 嵌套 (nested) 一個包不能有兩個名字一樣的函式，
不支持 多載 (overload)
不支持 默認引數 (default parameter)，

函式定義

函式宣告包含一個函式名，引數串列， 回傳值串列和函式體，如果函式沒有回傳值，則回傳串列可以省略，函式從第一條陳述句開始執行，直到執行return陳述句或者執行函式的最后一條陳述句，

定義函式使用func關鍵字基本格式：

func 函式名(引數)(回傳值){
    函式體
}

函式名：由字母、數字、下劃線組成，但函式名的第一個字母不能是數字，在同一個包內，函式名也稱不能重名（包的概念詳見后文），

引數：引數由引數變數和引數變數的型別組成，多個引數之間使用,分隔，

回傳值：回傳值由回傳值變數和其變數型別組成，也可以只寫回傳值的型別，多個回傳值必須用()包裹，并用,分隔，

函式體：實作指定功能的代碼塊，

引數

型別簡寫

函式的引數中如果相鄰變數的型別相同，則可以省略型別

func intSum(x, y int) int {
	return x + y
}

型別均為int，因此可以省略x的型別，因為y后面有型別說明，x引數也是該型別

可變引數

可變引數是指函式的引數數量不固定，Go語言中的可變引數通過在引數名后加…來標識，

注意：可變引數通常要作為函式的最后一個引數，

回傳值

Go語言中通過return關鍵字向外輸出回傳值，

多回傳值

Go語言中函式支持多回傳值，函式如果有多個回傳值時必須用()將所有回傳值包裹起來

回傳值命名

函式定義時可以給回傳值命名，并在函式體中直接使用這些變數，最后通過return關鍵字回傳

回傳值補充

當我們的一個函式回傳值型別為slice時，nil可以看做是一個有效的slice，沒必要顯示回傳一個長度為0的切片

匿名函式

定義
函式可以作為回傳值，但在函式內部不能再像之前那樣定義函式了，只能定義匿名函式，匿名函式就是沒有函式名的函式格式：

func(引數)(回傳值){
    函式體
}

函式具體深層演練

閉包、遞回

閉包

定義
閉包指的是一個函式和與其相關的參考環境組合而成的物體，閉包=函式+參考環境

func adder() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}

變數f是一個函式并且它參考了其外部作用域中的x變數，此時f就是一個閉包， 在f的生命周期內，變數x也一直有效

func adder2(x int) func(int) int {
	return func(y int) int {
		x += y
		return x
	}
}

func makeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}

func calc(base int) (func(int) int, func(int) int) {
	add := func(i int) int {
		base += i
		return base
	}

	sub := func(i int) int {
		base -= i
		return base
	}
	return add, sub
}

牢記閉包=函式+參考環境

遞回

遞回，就是在運行的程序中呼叫自己， 一個函式呼叫自己，就叫做遞回函式，

遞回形成條件：

• 子問題須與原始問題為同樣的事，且更為簡單，
• 不能無限制地呼叫本身，須有個出口，化簡為非遞回狀況處理，

題目：

用遞回寫一個累加和函式

代碼案例：

package main

import "fmt"

func main() {
	fmt.Println(add(3))  // 用戶輸入一個數字
}
func add(k int) int{
	if k == 0 { // 直到等于零結束累加
		return 0
	}
	return k + add(k - 1)
}

輸出結果：

題目：

請查詢相關資料或獨自完成斐波那契數列

延遲呼叫（defer）

定義
defer陳述句會將其后面跟隨的陳述句進行延遲處理，在defer歸屬的函式即將回傳時，將延遲處理的陳述句按defer定義的逆序進行執行，也就是說，先被defer的陳述句最后被執行，最后被defer的陳述句，最先被執行

使用
defer陳述句延遲呼叫的特性，所以defer陳述句能非常方便的處理資源釋放問題，比如：資源清理、檔案關閉、解鎖及記錄時間等，

我的理解
defer的底層像一個堆疊一樣，先入后出

執行時機
return陳述句在底層并不是原子操作，它分為給回傳值賦值和RET指令兩步，而defer陳述句執行的時機就在回傳值賦值操作后，RET指令執行前

面試題:

package main

import "fmt"

func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	x := 1
	y := 2
	defer calc("AA", x, calc("A", x, y))
	x = 10
	defer calc("BB", x, calc("B", x, y))
	y = 20
}

請問應該輸出什么？

答案：

例外處理

Go語言沒有結構化例外，使用 panic 拋出錯誤，recover 捕獲錯誤，

panic：

• 內置函式
• 假如函式F中書寫了panic陳述句，會終止其后要執行的代碼，在panic所在函式F內如果存在要執行的defer函式串列，按照defer的逆序執行
• 回傳函式F的呼叫者G，在G中，呼叫函式F陳述句之后的代碼不會執行，假如函式G中存在要執行的defer函式串列，按照defer的逆序執行
• 直到goroutine整個退出，并報告錯誤

recover：

1、內置函式
2、用來控制一個goroutine的panicking行為，捕獲panic，從而影回應用的行為
3、一般的呼叫建議
(1) 在defer函式中，通過recever來終止一個goroutine的panicking程序，從而恢復正常代碼的執行
(2) 可以獲取通過panic傳遞的error

什么是方法？

生活中的方法

方法是一個漢語詞匯，方法的含義較廣泛，一般是指為獲得某種東西或達到某種目的而采取的手段與行為方式，方法在哲學，科學及生活中有著不同的解釋與定義

從廣義上講：方法是解決問題的條件【解決問題就是使問題發生改變，使其達到所需標準】，
方法的本質是一個據有性質的框架，此框架的性質決定需要解決的問題怎樣隨著需要解決問題方面的能量【這里指廣義上的能量】改變而改變，
不同方法相對于解決的問題的框架不同，所以不同方法解決問題的效率不同，

程式中的方法

• 方法是陳述句的集合，他們在一起執行一個功能
• 方法是解決一類問題的步驟的有序組合
• 方法包含于物件中
• 方法在程式中被創建，在其他地方被參考

為什么需要方法？

當某個功能被多次（重復）使用的時候，為了簡化代碼，方便操作，通常會將該功能封裝起來，直接使用，用戶可以不用考慮功能實作的細節，只需要知道該功能如何使用即可，

方法與方法之間的關系：

并列的，平級的關系，所有的方法都在類中，方法中不能包含另一個方法，但是可以呼叫另一個方法

方法問題擴展

方法定義好之后，一定要使用嗎？（如果不用，為啥要寫？）

功能的定義并非是一定要去使用的，定義方法的目的是為了在后續的使用程序中有可能會用的到該功能

定義好的功能，如果要使用一定要通過main函式嗎？

如果是要直接運行的的功能，那么必須通過主函式，如果不是直接運行的而是通過其他方法間接運行的，那么考慮的是其所在的方法是否需要直接在主函式中直接運行

方法怎么用？

方法定義

方法特點

Go語言方法總是系結物件實體，并隱式將實體作為第一實參（recevier ）
一個方法就是一個包含了接受者的函式，接受者可以是命名型別或者結構體型別的一個值或者是一個指標，

只能為當前包內命名型別定義方法，
引數 receiver 可任意命名，如方法中未曾使用 ，可省略引數名，
引數 receiver 型別可以是 T 或 *T，基型別 T 不能是介面或指標，
不支持方法多載，receiver 只是引數簽名的組成部分，
可用實體 value 或 pointer 呼叫全部方法，編譯器自動轉換，

方法定義

 func (recevier type) method(引數串列)(回傳值串列){}

 引數和回傳值可以省略

代碼案例：

package main

import "fmt"

// 定義結構體
type Students struct {
	name string

}

// 主方法
func main()  {
	a := new(Students)
	a.name = "你好"
	a.method()
}

// 定義方法
func (a Students)method()  {
	fmt.Println(a.name)
}

輸入結果：

匿名欄位

可以像欄位成員那樣訪問匿名欄位方法，編譯器負責查找

代碼案例:

package main

import "fmt"

type User struct {
	id   int
	name string
}

type Student struct {
	User
}

func (a *User) ToString() string { // receiver = &(Manager.User)
	return fmt.Sprintf("User: %v" , a)
}

func main() {
	m := Student{User{1, "你好"}}
	fmt.Println(m.ToString())
}

輸入結果：

方法具體深層演練

方法集

方法集：每個型別都有與之關聯的方法集，這會影響到介面實作規則

所有給定型別的方法屬于該型別的方法集，

型別 T 方法集包含全部 receiver T 方法，
型別 *T 方法集包含全部 receiver T + *T 方法，
如型別 S 包含匿名欄位 T，則 S 和 *S 方法集包含 T 方法，
如型別 S 包含匿名欄位 *T，則 S 和 *S 方法集包含 T + *T 方法，
不管嵌入 T 或 *T，*S 方法集總是包含 T + *T 方法，

用實體 value 和 pointer 呼叫方法 (含匿名欄位) 不受方法集約束，編譯器總是查找全部方法，并自動轉換 receiver 實參，

package main

import (
	"fmt"
)

type Students struct {
	int
}

func (t Students) test1() {
	fmt.Println("型別 *T 方法集包含全部 receiver T 方法，")
}

func (t *Students) test2() {
	fmt.Println("型別 *T 方法集包含全部 receiver *T 方法，")
}

func main() {
	t1 := Students{1}
	t2 := &t1
	fmt.Printf("t2 is : %v\n", t2)
	t2.test1()
	t2.test2()
}

總結：簡單來講方法集類似于java中的類思想，就是Students這個結構體可以new出來一個物件，這個物件可以調取它下面的所有方法，那Students就是方法集

自定義error

這里參考一個中文檔案的自定義error的方法：
舉例：

package main

import (
	"fmt"
	"os"
	"time"
)

type PathError struct {
	path       string
	op         string
	createTime string
	message    string
}

func (p *PathError) Error() string {
	return fmt.Sprintf("path=%s \nop=%s \ncreateTime=%s \nmessage=%s", p.path,
		p.op, p.createTime, p.message)
}

func Open(filename string) error {

	file, err := os.Open(filename)
	if err != nil {
		return &PathError{
			path:       filename,
			op:         "read",
			message:    err.Error(),
			createTime: fmt.Sprintf("%v", time.Now()),
		}
	}

	defer file.Close()
	return nil
}

func main() {
	err := Open("/Users/5lmh/Desktop/go/src/test.txt")
	switch v := err.(type) {
	case *PathError:
		fmt.Println("get path error,", v)
	default:

	}

}

這次就先講到這里，如果想要了解更多的golang語言內容一鍵三連后序每周持續更新！