go語言支援什麼函數
Go語言支援普通函數、匿名函數和閉包，從設計上對函數進行了優化和改進，讓函數使用起來更加方便。在Go語言中，定義函數使用func關鍵字，語法「func 函數名(引數)(返回值){函數體}」；定義了函數之後，我們可以通過「函數名()」的方式呼叫函數。
php入門到就業線上直播課：進入學習
Apipost = Postman + Swagger + Mock + Jmeter 超好用的API偵錯工具：
本教學操作環境：windows7系統、GO 1.18版本、Dell G3電腦。
函數是組織好的、可重複使用的、用來實現單一或相關聯功能的程式碼段，其可以提高應用的模組性和程式碼的重複利用率。
Go 語言支援普通函數、匿名函數和閉包，從設計上對函數進行了優化和改進，讓函數使用起來更加方便。
Go 語言的函數屬於「一等公民」（first-class），也就是說：
函數本身可以作為值進行傳遞。
支援匿名函數和閉包（closure）。
函數可以滿足介面。
函數定義
Go語言中定義函數使用func關鍵字，具體格式如下：
func 函數名(引數)(返回值){
函數體
}登入後複製其中：
- 函數名：由字母、數位、下劃線組成。但函數名的第一個字母不能是數位。在同一個包內，函數名也稱不能重名（包的概念詳見後文）。
- 引數：引數由引數變數和引數變數的型別組成，多個引數之間使用
,分隔。 - 返回值：返回值由返回值變數和其變數型別組成，也可以只寫返回值的型別，多個返回值必須用
()包裹，並用,分隔。 - 函數體：實現指定功能的程式碼塊。
我們先來定義一個求兩個數之和的函數：
func intSum(x int, y int) int {
return x + y
}登入後複製函數的引數和返回值都是可選的，例如我們可以實現一個既不需要引數也沒有返回值的函數：
func sayHello() {
fmt.Println("Hello 沙河")
}登入後複製函數的呼叫
定義了函數之後，我們可以通過函數名()的方式呼叫函數。 例如我們呼叫上面定義的兩個函數，程式碼如下：
func main() {
sayHello()
ret := intSum(10, 20)
fmt.Println(ret)
}登入後複製注意，呼叫有返回值的函數時，可以不接收其返回值。
引數
型別簡寫
函數的引數中如果相鄰變數的型別相同，則可以省略型別，例如：
func intSum(x, y int) int {
return x + y
}登入後複製上面的程式碼中，intSum函數有兩個引數，這兩個引數的型別均為int，因此可以省略x的型別，因為y後面有型別說明，x引數也是該型別。
可變引數
可變引數是指函數的引數數量不固定。Go語言中的可變引數通過在引數名後加...來標識。
注意：可變引數通常要作為函數的最後一個引數。
舉個例子：
func intSum2(x ...int) int {
fmt.Println(x) //x是一個切片
sum := 0
for _, v := range x {
sum = sum + v
}
return sum
}登入後複製呼叫上面的函數：
ret1 := intSum2()
ret2 := intSum2(10)
ret3 := intSum2(10, 20)
ret4 := intSum2(10, 20, 30)
fmt.Println(ret1, ret2, ret3, ret4) //0 10 30 60
登入後複製固定引數搭配可變引數使用時，可變引數要放在固定引數的後面，範例程式碼如下：
func intSum3(x int, y ...int) int {
fmt.Println(x, y)
sum := x
for _, v := range y {
sum = sum + v
}
return sum
}登入後複製呼叫上述函數：
ret5 := intSum3(100)
ret6 := intSum3(100, 10)
ret7 := intSum3(100, 10, 20)
ret8 := intSum3(100, 10, 20, 30)
fmt.Println(ret5, ret6, ret7, ret8) //100 110 130 160
登入後複製本質上，函數的可變引數是通過切片來實現的。
函數返回值
Go語言中通過return關鍵字向外輸出返回值。
多返回值
Go語言中函數支援多返回值，函數如果有多個返回值時必須用()將所有返回值包裹起來。
舉個例子：
func calc(x, y int) (int, int) {
sum := x + y
sub := x - y
return sum, sub
}登入後複製返回值命名
函數定義時可以給返回值命名，並在函數體中直接使用這些變數，最後通過return關鍵字返回。
例如：
func calc(x, y int) (sum, sub int) {
sum = x + y
sub = x - y
return
}登入後複製返回值補充
當我們的一個函數返回值型別為slice時，nil可以看做是一個有效的slice，沒必要顯示返回一個長度為0的切片。
func someFunc(x string) []int {
if x == "" {
return nil // 沒必要返回[]int{}
}
...
}登入後複製變數作用域
全域性變數
全域性變數是定義在函數外部的變數，它在程式整個執行週期內都有效。 在函數中可以存取到全域性變數。
package main
import "fmt"
//定義全域性變數num
var num int64 = 10
func testGlobalVar() {
fmt.Printf("num=%d\n", num) //函數中可以存取全域性變數num
}
func main() {
testGlobalVar() //num=10
}登入後複製區域性變數
區域性變數又分為兩種： 函數內定義的變數無法在該函數外使用，例如下面的範例程式碼main函數中無法使用testLocalVar函數中定義的變數x：
func testLocalVar() {
//定義一個函數區域性變數x,僅在該函數內生效
var x int64 = 100
fmt.Printf("x=%d\n", x)
}
func main() {
testLocalVar()
fmt.Println(x) // 此時無法使用變數x
}登入後複製如果區域性變數和全域性變數重名，優先存取區域性變數。
package main
import "fmt"
//定義全域性變數num
var num int64 = 10
func testNum() {
num := 100
fmt.Printf("num=%d\n", num) // 函數中優先使用區域性變數
}
func main() {
testNum() // num=100
}登入後複製接下來我們來看一下語句塊定義的變數，通常我們會在if條件判斷、for迴圈、switch語句上使用這種定義變數的方式。
func testLocalVar2(x, y int) {
fmt.Println(x, y) //函數的引數也是隻在本函數中生效
if x > 0 {
z := 100 //變數z只在if語句塊生效
fmt.Println(z)
}
//fmt.Println(z)//此處無法使用變數z
}登入後複製還有我們之前講過的for迴圈語句中定義的變數，也是隻在for語句塊中生效：
func testLocalVar3() {
for i := 0; i < 10; i++ {
fmt.Println(i) //變數i只在當前for語句塊中生效
}
//fmt.Println(i) //此處無法使用變數i
}登入後複製函數型別與變數
定義函數型別
我們可以使用type關鍵字來定義一個函數型別，具體格式如下：
type calculation func(int, int) int
登入後複製上面語句定義了一個calculation型別，它是一種函數型別，這種函數接收兩個int型別的引數並且返回一個int型別的返回值。
簡單來說，凡是滿足這個條件的函數都是calculation型別的函數，例如下面的add和sub是calculation型別。
func add(x, y int) int {
return x + y
}
func sub(x, y int) int {
return x - y
}登入後複製add和sub都能賦值給calculation型別的變數。
var c calculation
c = add
登入後複製函數型別變數
我們可以宣告函數型別的變數並且為該變數賦值：
func main() {
var c calculation // 宣告一個calculation型別的變數c
c = add // 把add賦值給c
fmt.Printf("type of c:%T\n", c) // type of c:main.calculation
fmt.Println(c(1, 2)) // 像呼叫add一樣呼叫c
f := add // 將函數add賦值給變數f1
fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int
fmt.Println(f(10, 20)) // 像呼叫add一樣呼叫f
}登入後複製高階函數
高階函數分為函數作為引數和函數作為返回值兩部分。
函數作為引數
函數可以作為引數：
func add(x, y int) int {
return x + y
}
func calc(x, y int, op func(int, int) int) int {
return op(x, y)
}
func main() {
ret2 := calc(10, 20, add)
fmt.Println(ret2) //30
}登入後複製函數作為返回值
函數也可以作為返回值：
func do(s string) (func(int, int) int, error) {
switch s {
case "+":
return add, nil
case "-":
return sub, nil
default:
err := errors.New("無法識別的操作符")
return nil, err
}
}登入後複製匿名函數和閉包
匿名函數
函數當然還可以作為返回值，但是在Go語言中函數內部不能再像之前那樣定義函數了，只能定義匿名函數。匿名函數就是沒有函數名的函數，匿名函數的定義格式如下：
func(引數)(返回值){
函數體
}登入後複製匿名函數因為沒有函數名，所以沒辦法像普通函數那樣呼叫，所以匿名函數需要儲存到某個變數或者作為立即執行函數:
func main() {
// 將匿名函數儲存到變數
add := func(x, y int) {
fmt.Println(x + y)
}
add(10, 20) // 通過變數呼叫匿名函數
//自執行函數：匿名函數定義完加()直接執行
func(x, y int) {
fmt.Println(x + y)
}(10, 20)
}登入後複製匿名函數多用於實現回撥函數和閉包。
閉包
閉包指的是一個函數和與其相關的參照環境組合而成的實體。簡單來說，閉包=函數+參照環境。 首先我們來看一個例子：
func adder() func(int) int {
var x int
return func(y int) int {
x += y
return x
}
}
func main() {
var f = adder()
fmt.Println(f(10)) //10
fmt.Println(f(20)) //30
fmt.Println(f(30)) //60
f1 := adder()
fmt.Println(f1(40)) //40
fmt.Println(f1(50)) //90
}登入後複製變數f是一個函數並且它參照了其外部作用域中的x變數，此時f就是一個閉包。 在f的生命週期內，變數x也一直有效。 閉包進階範例1：
func adder2(x int) func(int) int {
return func(y int) int {
x += y
return x
}
}
func main() {
var f = adder2(10)
fmt.Println(f(10)) //20
fmt.Println(f(20)) //40
fmt.Println(f(30)) //70
f1 := adder2(20)
fmt.Println(f1(40)) //60
fmt.Println(f1(50)) //110
}登入後複製閉包進階範例2：
func makeSuffixFunc(suffix string) func(string) string {
return func(name string) string {
if !strings.HasSuffix(name, suffix) {
return name + suffix
}
return name
}
}
func main() {
jpgFunc := makeSuffixFunc(".jpg")
txtFunc := makeSuffixFunc(".txt")
fmt.Println(jpgFunc("test")) //test.jpg
fmt.Println(txtFunc("test")) //test.txt
}登入後複製閉包進階範例3：
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
}
func main() {
f1, f2 := calc(10)
fmt.Println(f1(1), f2(2)) //11 9
fmt.Println(f1(3), f2(4)) //12 8
fmt.Println(f1(5), f2(6)) //13 7
}登入後複製閉包其實並不複雜，只要牢記閉包=函數+參照環境。
defer語句
Go語言中的defer語句會將其後面跟隨的語句進行延遲處理。在defer歸屬的函數即將返回時，將延遲處理的語句按defer定義的逆序進行執行，也就是說，先被defer的語句最後被執行，最後被defer的語句，最先被執行。
舉個例子：
func main() {
fmt.Println("start")
defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
fmt.Println("end")
}登入後複製輸出結果：
start
end
3
2
1
登入後複製由於defer語句延遲呼叫的特性，所以defer語句能非常方便的處理資源釋放問題。比如：資源清理、檔案關閉、解鎖及記錄時間等。
defer執行時機
在Go語言的函數中return語句在底層並不是原子操作，它分為給返回值賦值和RET指令兩步。而defer語句執行的時機就在返回值賦值操作後，RET指令執行前。具體如下圖所示：
defer經典案例
閱讀下面的程式碼，寫出最後的列印結果。
func f1() int {
x := 5
defer func() {
x++
}()
return x
}
func f2() (x int) {
defer func() {
x++
}()
return 5
}
func f3() (y int) {
x := 5
defer func() {
x++
}()
return x
}
func f4() (x int) {
defer func(x int) {
x++
}(x)
return 5
}
func main() {
fmt.Println(f1())
fmt.Println(f2())
fmt.Println(f3())
fmt.Println(f4())
}登入後複製defer面試題
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
}登入後複製問，上面程式碼的輸出結果是？（提示：defer註冊要延遲執行的函數時該函數所有的引數都需要確定其值）
擴充套件知識：
內建函數介紹
| 內建函數 | 介紹 |
|---|---|
| close | 主要用來關閉channel |
| len | 用來求長度，比如string、array、slice、map、channel |
| new | 用來分配記憶體，主要用來分配值型別，比如int、struct。返回的是指標 |
| make | 用來分配記憶體，主要用來分配參照型別，比如chan、map、slice |
| append | 用來追加元素到陣列、slice中 |
| panic和recover | 用來做錯誤處理 |
panic/recover
Go語言中目前（Go1.12）是沒有異常機制，但是使用panic/recover模式來處理錯誤。 panic可以在任何地方引發，但recover只有在defer呼叫的函數中有效。 首先來看一個例子：
func funcA() {
fmt.Println("func A")
}
func funcB() {
panic("panic in B")
}
func funcC() {
fmt.Println("func C")
}
func main() {
funcA()
funcB()
funcC()
}登入後複製輸出：
func A
panic: panic in B
goroutine 1 [running]:
main.funcB(...)
.../code/func/main.go:12
main.main()
.../code/func/main.go:20 +0x98登入後複製程式執行期間funcB中引發了panic導致程式崩潰，異常退出了。這個時候我們就可以通過recover將程式恢復回來，繼續往後執行。
func funcA() {
fmt.Println("func A")
}
func funcB() {
defer func() {
err := recover()
//如果程式出出現了panic錯誤,可以通過recover恢復過來
if err != nil {
fmt.Println("recover in B")
}
}()
panic("panic in B")
}
func funcC() {
fmt.Println("func C")
}
func main() {
funcA()
funcB()
funcC()
}登入後複製注意：
recover()必須搭配defer使用。defer recover一定要在可能引發panic的語句之前定義。
練習題
分金幣
/*
你有50枚金幣，需要分配給以下幾個人：Matthew,Sarah,Augustus,Heidi,Emilie,Peter,Giana,Adriano,Aaron,Elizabeth。
分配規則如下：
a. 名字中每包含1個'e'或'E'分1枚金幣
b. 名字中每包含1個'i'或'I'分2枚金幣
c. 名字中每包含1個'o'或'O'分3枚金幣
d: 名字中每包含1個'u'或'U'分4枚金幣
寫一個程式，計算每個使用者分到多少金幣，以及最後剩餘多少金幣？
程式結構如下，請實現 ‘dispatchCoin’ 函數
*/
var (
coins = 50
users = []string{
"Matthew", "Sarah", "Augustus", "Heidi", "Emilie", "Peter", "Giana", "Adriano", "Aaron", "Elizabeth",
}
distribution = make(map[string]int, len(users))
)
/*
func main() {
left := dispatchCoin()
fmt.Println("剩下：", left)
}
*/
func main() {
for _, v := range users {
distribution[v] = 0
for _, k := range v {
if k == 'e' || k == 'E' {
distribution[v]++
}
if k == 'i' || k == 'I' {
distribution[v] += 2
}
if k == 'o' || k == 'O' {
distribution[v] += 3
}
if k == 'u' || k == 'U' {
distribution[v] += 4
}
}
}
pay := 0
for i, v := range distribution {
fmt.Printf("%s 分到:%d\n", i, v)
pay += v
}
fmt.Printf("剩餘：%d", (coins - pay))
}登入後複製【相關推薦：Go視訊教學】
以上就是go語言支援什麼函數的詳細內容，更多請關注TW511.COM其它相關文章！
