函數(shù)是基于功能或者邏輯進(jìn)行聚合的可復(fù)用的代碼塊。將一些復(fù)雜的、冗長的代碼抽離封裝成多個代碼片段，即函數(shù)，有助于提高代碼邏輯的可讀性和可維護(hù)性。不同于Python，由于 Go lang是編譯型語言，編譯之后再運(yùn)行，所以函數(shù)的定義順序無關(guān)痛癢。
創(chuàng)新互聯(lián)建站主要從事網(wǎng)站制作、網(wǎng)站建設(shè)、網(wǎng)頁設(shè)計、企業(yè)做網(wǎng)站、公司建網(wǎng)站等業(yè)務(wù)。立足成都服務(wù)木壘哈薩克,十余年網(wǎng)站建設(shè)經(jīng)驗,價格優(yōu)惠、服務(wù)專業(yè),歡迎來電咨詢建站服務(wù):13518219792
在 Go lang里，函數(shù)聲明語法如下：
重慶分公司
重慶分公司
func function_name(parameter_list) (result_list) {
//函數(shù)邏輯
}
這里使用function的簡寫形式 func關(guān)鍵詞，后面依次接 function_name(函數(shù)名) ， parameter_list(參數(shù)列表) ， result_list(返回值列表)以及函數(shù)體 。
parameter_list(參數(shù)列表)成員：函數(shù)的參數(shù)名以及參數(shù)類型，這些參數(shù)作為局部變量，其值由參數(shù)調(diào)用者提供，函數(shù)中的參數(shù)列表和返回值并非是必須的。
result_list(返回值列表)：函數(shù)返回值的變量名以及類型，如果函數(shù)返回一個無名變量或者沒有返回值，返回值列表的括號是可以省略的。
如果有連續(xù)若干個參數(shù)的類型一致，那么只需在最后一個參數(shù)后添加該類型：
package main
import "fmt"
// 函數(shù)返回一個無名變量，返回值列表的括號省略
func sum(x int, y int) int {
return x + y
}
// 無參數(shù)列表和返回值
func printBookName() {
fmt.Println("go lang1.18")
}
// 參數(shù)的類型一致，只在最后一個參數(shù)后添加該類型
func sub(x, y int) int {
return x - y
}
func main() {
fmt.Println("1 + 1 = ", sum(1, 1))
printBookName()
fmt.Println("2 - 1 =", sub(2, 1))
}
程序返回：
command-line-arguments
1 + 1 = 2
go lang1.18
2 - 1 = 1
和Python一樣，Go lang也支持不定長參數(shù)，即參數(shù)有多少個并不確定的情況。
在參數(shù)類型前面加 ... 表示一個切片，用來接收調(diào)用者傳入的參數(shù)。注意，如果該函數(shù)下有其他類型的參數(shù)，這些其他參數(shù)必須放在參數(shù)列表的前面，切片必須放在最后：
package main
import "fmt"
func show(args ...string) int {
sum := 0
for _, item := range args {
fmt.Println(item)
sum += 1
}
return sum
}
func main() {
fmt.Println(show("1", "2", "3"))
}
和Python的*args用法差不多，但需要注意必須要聲明函數(shù)的數(shù)據(jù)類型，程序返回：
1
2
3
3
如果傳多個參數(shù)的數(shù)據(jù)類型都不一樣，可以指定類型為 ...interface{} ，然后再進(jìn)行遍歷：
package main
import "fmt"
func PrintType(args ...interface{}) {
for _, arg := range args {
switch arg.(type) {
case int:
fmt.Println(arg, "type is int.")
case string:
fmt.Println(arg, "type is string.")
case float64:
fmt.Println(arg, "type is float64.")
default:
fmt.Println(arg, "is an unknown type.")
}
}
}
func main() {
PrintType(1, 3.1415, "go lang 1.18")
}
此外，還可以使用 ... 可以用來解序列，能將函數(shù)的可變參數(shù)(即切片)一個一個取出來，傳遞給另一個可變參數(shù)的函數(shù)，而不是傳遞可變參數(shù)變量本身：
package main
import "fmt"
func main() {
var s []string
s = append(s, []string{"1", "2", "3"}...)
fmt.Println(s)
}
這里將字符串切片取出來后，傳遞給內(nèi)置的append方法，程序返回：
[1 2 3]
一個函數(shù)可以沒有返回值，也可以有一個返回值，也可以有返回多個值：
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func SumAndProduct(A, B int) (add int, Multiplied int) {
add = A + B
Multiplied = A * B
return
}
func main() {
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
fmt.Println(SumAndProduct(1, 2))
}
程序返回：
Kumar Mahesh
3 2
_ 是Go lang里的空白標(biāo)識符。它可以代替任何類型的任何值。我們可以利用它來忽略某些別人會用到但我們不會用到的函數(shù)返回值：
package main
import (
"fmt"
)
func rectProps(length, width float64) (float64, float64) {
var area = length * width
var perimeter = (length + width) * 2
return area, perimeter
}
func main() {
area, _ := rectProps(10.8, 5.6) // perimeter is discarded
fmt.Printf("Area %f ", area)
}
程序返回：
Area 60.
有點(diǎn)類似Python中的lambda表達(dá)式，但實際上并不是作為語法糖而存在：
package main
import (
"fmt"
)
func main() {
f := func() {
fmt.Println("hello world")
}
f() //hello world
fmt.Printf("%T\n", f) //打印 func()
}
程序返回：
hello world
func()
一望而知，只是匿名而已，但通過變量可調(diào)用，另外也可以擁有參數(shù)：
package main
import (
"fmt"
)
func main() {
f:=func(args string){
fmt.Println(args)
}
f("hello world")//hello world
//或
(func(args string){
fmt.Println(args)
})("hello world")//hello world
//或
func(args string) {
fmt.Println(args)
}("hello world") //hello world
}
程序返回：
hello world
hello world
hello world
基本上，匿名函數(shù)和命名函數(shù)用法上并無二致。
很多語言都有閉包的概念，簡單理解就是函數(shù)的嵌套：
package main
import "fmt"
func main() {
a := Fun()
b:=a("hello ")
c:=a("hello ")
fmt.Println(b)//worldhello
fmt.Println(c)//worldhello hello
}
func Fun() func(string) string {
a := "world"
return func(args string) string {
a += args
return a
}
}
程序返回：
worldhello
worldhello hello
這里我們將方法作為參數(shù)傳遞到方法內(nèi)部執(zhí)行，這樣內(nèi)層的函數(shù)可以使用外層函數(shù)的所有變量，即使外層函數(shù)已經(jīng)執(zhí)行完畢。
延遲其實是延遲（defer）語句，延遲語句被用于執(zhí)行一個函數(shù)調(diào)用，在這個函數(shù)之前，延遲語句返回：
package main
import "fmt"
func main() {
a := 1
b := 2
defer fmt.Println(b)
fmt.Println(a)
}
程序返回：
1
2
說白了就是一種倒裝的形式，非延遲語句先執(zhí)行，最后再執(zhí)行延遲語句。
延遲也并不僅僅局限于函數(shù)內(nèi)部語句，延遲一個方法調(diào)用也是可以的：
package main
import (
"fmt"
)
type person struct {
firstName string
lastName string
}
func (p person) fullName() {
fmt.Printf("%s %s", p.firstName, p.lastName)
}
func main() {
p := person{
firstName: "go lang",
lastName: "python",
}
defer p.fullName()
fmt.Printf("Welcome ")
}
程序返回：
Welcome go lang python
顧名思義，和Python中的魔法方法init一樣，可以提前做一些初始化操作：
package main
import "fmt"
var a int = initVar()
func init() {
fmt.Println("init2")
}
func init() {
fmt.Println("init")
}
func initVar() int {
fmt.Println("init var...")
return 100
}
func main() {
fmt.Println("main...")
}
程序返回：
init var...
init2
init
這里的初始化順序是：變量初始化->init()->main()
和Python不同的是，每個包可以有多個初始化函數(shù)。
歸根結(jié)底，函數(shù)可以被認(rèn)為是Go lang中的一種數(shù)據(jù)類型，可以作為另一個函數(shù)的參數(shù)，也可以作為另一個函數(shù)的返回值，使用起來相當(dāng)靈活，但我們也不能矯枉過正，毫無節(jié)制地用函數(shù)封裝邏輯，造成過度封裝的現(xiàn)象。
