函数
1.声明语法：func 函数名 (参数列表) [(返回值列表)] {}
2.golang函数特点：
a. 不支持重载，一个包不能有两个名字一样的函数
b. 函数是一等公民，函数也是一种类型，一个函数可以赋值给变量
c. 匿名函数
d. 多返回值
定义函数类型type：
package main
import "fmt"
type add_func func(int, int) int
func add(a, b int) int {
return a + b
}
func sub(a, b int) int {
return a - b
}
func operator(op add_func, a int, b int) int {
return op(a, b)
}
func main() {
c := add
fmt.Println(c)
sum := operator(c, 100, 200)
fmt.Println(sum)
var x add_func
x=sub
fmt.Println(x)
sub := operator(x, 100, 200)
fmt.Println(sub)
}
3.函数参数传递方式：
1). 值传递
2). 引用传递
注意1：无论是值传递，还是引用传递，传递给函数的都是变量的副本，不过，值传递是值的拷贝。
引用传递是地址的拷贝，一般来说，地址拷贝更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能越低。
注意2：map、slice、chan、指针、interface默认以引用的方式传递
package main
import "fmt"
func modify(a *int) {
*a = 100
}
func main() {
a := 8
fmt.Println(a)
modify(&a)
fmt.Println(a)
}
参数类型省略：
func f(i, j, k int, s, t string)
func f(i int, j int, k int, s string, t string)
4.命名返回值的名字：
package main
import "fmt"
func split(sum int) (x, y int) {
x = sum / 10
y = sum % 10
return
}
func main() {
fmt.Println(split(17))
}
_标识符，用来忽略返回值
5.可变参数：
func add(arg …int) int {
}//0个或多个参数
func add(a int, arg …int) int {
}//1个或多个参数
func add(a int, b int, arg …int) int {
}//2个或多个参数
注意：其中arg是一个slice，我们可以通过arg[index]依次访问所有参数，通过len(arg)来判断传递参数的个数
练习：写一个函数add，支持1个或多个int相加，并返回相加结果
练习：写一个函数concat，支持1个或多个string相拼接，并返回结果
defer
1.当函数返回时，执行defer语句。可以用来做资源清理
2.多个defer语句，按先进后出的方式执行，即最后一个defer语句将最先被执行
3.defer语句中的变量，在defer声明时就决定了。
在函数将要返回前执行：
package main
import "fmt"
func print() {
defer func() {
fmt.Println("defer")
}()
fmt.Println("hello")
}
func main() {
print()
}
多个defer语句：
package main
import "fmt"
func main() {
var i int =1
fmt.Println(i)
defer fmt.Println(i)
//不会立即执行，压到栈里面，函数执行结束后，再执行栈里的
defer fmt.Println("a")
i=10
fmt.Println(i)
}
用途：
1.关闭文件句柄
2.锁资源释放
3.数据库连接释放
内置函数
1.close：主要用来关闭channel
2.len：用来求长度，比如string、array、slice、map、channel
3.new：用来分配内存，主要用来分配值类型，比如int、struct。返回的是指针
package main
import "fmt"
func main() {
var i int
fmt.Println(i)
j := new(int)
fmt.Println(j)
fmt.Println(*j)
*j = 100
fmt.Println(*j)
}
4.make：用来分配内存，主要用来分配引用类型，比如chan、map、slice
new和make的区别：
package main
import "fmt"
func test() {
s1 := new([]int)
fmt.Println(s1)
s2 := make([]int, 10)
fmt.Println(s2)
*s1 = make([]int, 5)
(*s1)[0] = 100
s2[0] = 100
fmt.Println(s1)
fmt.Println(s2)
return
}
func main() {
test()
}
5.append：用来追加元素到数组、slice中
package main
import "fmt"
func main() {
var a []int
a = append(a,10,20,30)
a = append(a,a...)
fmt.Println(a)
}
错误处理error
Go语言引入了一个关于错误处理的标准模式，即error接口，该接口的定义如下：
type error interface {
Error() string
}
1.初始化失败，退出
2.重试，比如if err ！=nil，重试3次
3.异常上抛
package main
import "fmt"
func print() {
var p *int
fmt.Println(*p)
}
func main() {
defer func() {
err := recover()
fmt.Println(err)
}()
panic("不想执行下去了")
//print()//1.空指针引用错误
//var n int
//fmt.Println(10 / n) //2.除数为0
/*
var i=3
var slice [3]int
fmt.Println(slice[i])//3.下标越界
*/
}
EOF error
recover.go：
Go语言引入了两个内置函数panic()和recover()以报告和处理运行时错误和程序中的错误场景：
当在一个函数执行过程中调用panic()函数时，正常的函数执行流程将立即终止，但函数中之前使用defer关键字延迟执行的语句将正常展开执行，之后该函数将返回到调用函数，并导致逐层向上执行panic流程，直至所属的goroutine中所有正在执行的函数被终止。错误信息将被报告，包括在调用panic()函数时传入的参数，这个过程称为错误处理流程。
recover()函数用于终止错误处理流程。一般情况下， recover()应该在一个使用defer关键字的函数中执行以有效截取错误处理流程。如果没有在发生异常的goroutine中明确调用恢复过程（使用recover关键字） ，会导致该goroutine所属的进程打印异常信息后直接退出。
package main
import (
"fmt"
"time"
)
func test() {
defer func() {
if err := recover(); err != nil {
fmt.Println(err)
}
}()
b:=0
a := 1/b
fmt.Println(a)
return
}
func main() {
for {
test()
time.Sleep(time.Second)
}
}
panic.go
package main
import (
"fmt"
"time"
"errors"
)
func initConfig() (err error) {
return errors.New("init config failed")
}
err := initConfig()
if err != nil {
panic(err)
}
return
}
func main() {
for {
test()
time.Sleep(time.Second)
}
}
递归
一个函数调用自己，就叫做递归。
package main
import (
"fmt"
"time"
)
func recusive(n int) {
fmt.Println("hello golang", n)
time.Sleep(time.Second)
if n > 10 {
return
}
recusive(n + 1)
}
func main() {
recusive(0)
}
递归实现阶乘和斐波那契数列：
package main
import (
"fmt"
"time"
)
func factor(n int) int {
if n == 1 {
return 1
}
return factor(n-1) * n
}
func fab(n int) int {
if n <= 1 {
return 1
}
return fab(n-1) + fab(n-2)
}
func main() {
fmt.Println(factor(5))
for i := 0; i < 10; i++ {
fmt.Println(fab(i))
}
}
函数类型
package main
import "fmt"
func print1(){
fmt.Println("print1")
}
func print2() {
fmt.Println("print2")
}
func func1(n int) int {
return n+1
}
func main() {
//变量是个筐，装这个变量类型的数据
//函数也是个筐，容器，装的函数
var f func()
f = print1
f()
f=print2
f()
var flist [3]func(int) int
flist[0]=func1
m:=flist[0](10)
fmt.Println(m)
fmt.Println(flist[0](10))
}
加减乘除：
package main
import (
"fmt"
"os"
"strconv"
)
func add(m, n int) int {
return m + n
}
func sub(m, n int) int {
return m - n
}
func comp(m,n int) int {
return m * n
}
func div(m,n int) int {
return m/n
}
func main() {
funcmap := map[string]func(int, int) int{
"+": add,
"-": sub,
"*":comp,
"/":div,
}
m, _ := strconv.Atoi(os.Args[1])
n, _ := strconv.Atoi(os.Args[3])
f := funcmap[os.Args[2]]
if f != nil {
fmt.Println(f(m, n))
}
}
匿名函数
匿名函数是指不需要定义函数名的一种函数实现方式
在Go里面，函数可以像普通变量一样被传递或使用，这与C语言的回调函数比较类似。不同的是， Go语言支持随时在代码里定义匿名函数。
package main
import (
"fmt"
"strings"
)
func toupper(s string) string {
return strings.Map(func(r rune) rune {
return r - ('a' - 'A')
}, s)
}
func main() {
f := func(x,y int) int {
return x + y
}
fmt.Println(f(1,2))
f1:=func(x,y int) int {
return x + y
}(1,3)
fmt.Println(f1)
fmt.Println(toupper("hello"))
}
闭包
闭包：一个函数和与其相关的引用环境组合而成的实体
package main
import (
"fmt"
)
func addn(n int) func(int) int {
return func(m int) int {
return m+n
}
}
func main() {
f := addn(3)
fmt.Println(f(12))
}
生成器：
package main
import "fmt"
func iter(s []int) func() int {
var i = 0
return func() int {
if i >= len(s) {
return 0
}
n := s[i]
i += 1
return n
}
}
func main() {
f := iter([]int{1, 2, 3})
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
}