函数声明和注释
1、函数声明： func 函数名字 (参数列表) [(返回值列表)] {}
func add(a, b int) (int, int) {
}
2. 注释，两种注释，单行注释: // 和多行注释 /* */
3、 一个.go文件初始化，先执行全局变量，再执行init()函数，init()函数自动调用
4、多个包引用，如果引用顺序是main -> add -> test，初始化顺序：test.go的全局变量->test.go的init()->add全局变量->add.go的init()->main.go全局变量->main.go的init()
函数特点
- 不支持重载，一个包不能有两个名字一样的函数
- 函数是一等公民，函数也是一种类型，一个函数可以赋值给变量
- 匿名函数
- 多返回值
样例：
package main
import "fmt"
type op_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 op_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 d op_func
d = sub
fmt.Println(d)
sub := operator(d, 100, 200)
fmt.Println(sub)
}
自定义函数
demo
package main
import "fmt"
type add_func func(int, int) int
func add(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)
}
函数参数传递方式
- 值传递
- 引用传递
注意：无论是值传递，还是引用传递，传递给函数的都是变量的副本。不过，值传递是值的拷贝。引用传递是地址的拷贝，一般来说，地址拷贝更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能越低。
map、slice、chan、指针、interface默认以引用的方式传递。
命名返回值的名字
func add(a, b int) (c int) {
c = a + b
return
}
func calc(a, b int) (sum int, avg int) {
sum = a + b
avg = (a + b)/2
return
}
_标识符，用来忽略返回值
func calc(a, b int) (sum int, avg int) {
sum = a + b
avg = (a + b) / 2
return
}
func main() {
sum, _ := calc(100, 200)
}
可变参数
- 0个或多个参数
func add(arg…int) int {
}
- 1个或多个参数
func add(a int, arg…int) int {
}
- 2个或多个参数
func add(a int, b int, arg…int) int {
}
注意：其中arg是一个slice，我们可以通过arg[index]依次访问所有参数，通过len(arg)来判断传递参数的个数。
样例：
package main
import "fmt"
func add(a int, arg...int) int{
var sum int = a
for i := 0; i < len(arg); i ++ {
sum += arg[i]
}
return sum
}
func add_string(a string, arg...string) (result string) {
result = a
for i := 0; i < len(arg); i ++ {
result += arg[i]
}
return
}
func main() {
sum := add(10, 1 , 2, 3)
fmt.Println(sum)
str := add_string("hello ", "world ", "wang")
fmt.Println(str)
}
匿名函数
样例：
package main
import "fmt"
var(
result = func(a1, b1 int) int{
return a1 + b1
}
)
func test(a, b int) int {
result := func(a1, b1 int) int{
return a1 + b1
}(a, b)
return result
}
func test1(a, b int) int {
result := func(a1, b1 int) int{
return a1 + b1
}
return result(a, b)
}
func main() {
sum := test(10 , 20)
fmt.Println(sum)
sum1 := test1(1, 2)
fmt.Println(sum1)
fmt.Println(result(3,4))
}
defer用途
- 当函数返回时，执行defer语句。因此，可以用来做资源清理
- 多个defer语句，按先进后出的方式执行
- defer语句中的变量，在defer声明时就决定了
样例：
package main
import "fmt"
func main() {
var i int = 0
defer fmt.Println(i)
defer fmt.Println("second")
i = 10
fmt.Println(i)
}
说明：上面代码执行，先将defer压入栈中，当main函数执行完成后，再执行defer内容。多个defer语句，按先进后出的方式执行。同时defer语句的变量i声明时为0，所以结果也为0
使用场景举例：
1、关闭文件句柄
func read() {
//文件操作
file := open(filename)
defer file.Close()
}
2、锁资源释放
func read() {
mc.Lock()
defer mc.Unlock()
// 其他操作
}
3、数据库连接释放
func read() {
conn := openDatabase()
defer conn.Close()
//其他操作
}
内置函数
- close：主要用来关闭channel
- len：用来求长度，比如string、array、slice、map、channel
- new：用来分配内存，主要用来分配值类型，比如int、struct。返回的是指针
- make：用来分配内存，主要用来分配引用类型，比如chan、map、slice
- append：用来追加元素到数组、slice中
- panic和recover：用来做错误处理
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)
return
}
func main() {
test()
}
递归函数
函数调用自己，就叫做递归。
递归的设计原则
- 一个大的问题能够分解成相似的小问题
- 定义好出口条件
样例：
package main
import (
"fmt"
"time"
)
func recusive(n int) {
fmt.Println("hello", n)
time.Sleep(time.Second)
if n > 10 {
return
}
recusive(n + 1)
}
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))
recusive(0)
/*for i := 0; i < 10; i++ {
fmt.Println(fab(i))
}*/
}
闭包
一个函数和与其相关的引⽤用环境组合⽽而成的实体。
demo1:
func Adder() func(int) int {
var x int
f := func(i int) int {
x = x + i
return x
}
return f
}
func testClosure() {
f1 := Adder()
fmt.Println(f1(10))
fmt.Println(f1(20))
fmt.Println(f1(30))
f2 := Adder()
fmt.Println(f2(10))
fmt.Println(f2(20))
fmt.Println(f2(30))
}
demo2:
package main
import (
"fmt"
"strings"
)
func makeSuffixFunc(suffix string) func(string) string {
return func(name string) string {
if !strings.HasSuffix(name, suffix) {
return name + suffix
}
return name
}
}
func main() {
bmp := makeSuffixFunc(".bmp")
jpg := makeSuffixFunc(".jpg")
fmt.Println(bmp("test"))
fmt.Println(jpg("test"))
}