Golang学习笔记（五）：函数

函数

Go语言里面的核心设计，通过关键字func来声明

func funcName(input type1, input2 type2) (output1 type1, output2 type2) {

    //logical code

    return value1, value2

}

基本语法

1.语法

//一般函数

func func_name(a int) {

    println(a)

}

//多参数，无返回值

func func_name(a, b int, c string) {

    println(a, b, c)

}
//单个返回值

func func_name(a, b int) int { //同类型，可以省略  a, b int

    return a + b

}
//多个返回值

func func_name(a, b int) (c int, err error) {  //返回值还可以是   (int, error)

    return a+b, nil

}
func SumAndProduct(A, B int) (int, int) {

    return A+B, A*B

}

2.说明：

关键字func声明

可以有一个或多个参数，每个参数后面带有类型,通过","分隔函数可以返回多个值

返回值声明，可以只声明类型

    如果没有返回值，可以省略最后的返回信息

    如果有返回值，必须在外层添加return



Go函数不支持嵌套(nested),重载（overload）和默认参数(default parameters)

支持：

    1.无需声明原型

    2.不定长度变参

    3.多返回值

    4.命名返回值参数

    5.匿名函数

    6.闭包
注意：

    函数使用func开头，左大括号不能另起一行

小写字母开头的函数指在本包内可见，大写字母开头的函数才能被其他包调用

多返回值及命名返回参数

可以像python那样返回多个结果，只是非tuple

对于不想要的返回值，可以扔垃圾桶_

如果用命名返回参数，return语句可以为空。return 不为空，返回值顺序是return的顺序而非在函数头声明的顺序

package main

func change(a, b int) (x, y int) {

    x = a + 100

    y = b + 100
    return   //101, 102

    //return x, y  //同上

    //return y, x  //102, 101

}
func main(){

    a := 1

    b := 2

    c, d := change(a, b)

    println(c, d)

如果命名返回参数被代码块中的同名变量覆盖了，就必须使用显式return返回结果

不需要强制命名返回值，但是命名后的返回值可以让代码更加清晰，可读性更强

参数传递:传值与传指针

指针, Go保留指针，用"."而非"->"操作指针目标对象成员 操作符

& 取变量地址

* 通过指针间接访问目标函数

func add1(a int) int {

    a = a + 1

    return a

}
x := 3

x1 := add1(x)

x //3

x1 //4

传值，x1的值没有改变
func add2(a *int) int {

    *a = *a + 1

    return *a

}

x := 3

x1 := add2(&x)

x // 4

x1 // 4

传指针多个函数能操作同一个对象

传指针比较轻量级(8byte)，只是传内存地址，我饿们可以用指针来传递体积大的结构体

Go语言中，string,slice,map这三种类型的实现机制类似指针，所以可以直接传递，而不用取地址后传指针

注意，若函数需要改变 slice长度，仍需要取地址传指针

参数传递:可变参数

变参本质上就是一个slice，且必须是最后一个形参

将slice传递给变参函数时，注意用…展开，否则会被当做dang单个参数处理，和python类似

package main

func sum(s string, args ...int)  {

    var x int

    for _, n := range args {

        x += n

    }

    println(s, x)

}

func main(){

   sum("1+2+3=", 1, 2, 3)
   x := []int{0,1,2,3,4}

   sum("0+1+2+3=", x[:4]...)

}
...type类型只能作为函数的参数类型存在，并且是最后一个参数

本质上是一个数组切片，即[]type

任意类型的不定参数

func Printf(format string, args ...interface{}) {

}

匿名函数

f := func(x,y int) int {

    return x + y

}

函数作为值、类型

在Go语言中，函数也是一种变量，可以通过type来定义它,它的类型就是所有拥有相同的参数，相同的返回值

语法

type typeName func (input1 inputType1, input2 inputType2 [, ....]) (result1 resultType1 [,....])

用法e.g.1

type testInt func(int) bool //声明了一个函数类型

func filter(slice []int, f testInt) []int {

    var result []int

    for _, value := range slice {

        if f(value) {

            result = append(result, value)

        }

    }

}
func isOdd(integer int) bool {

    if integer % 2 == 0 {

        return false

    }

    return true

}
filter(a, isOdd)

这种用法，在写接口的时候非常有用

用法e.g.2

可以定义函数类型，也可以将函数作为值进行传递(默认值nil)

package main

//定义函数类型callback

type callback func(s string)
//定义一个函数，可以接收另一个函数作为参数

// sum为参数名称， func(int, int) int为参数类型

func test(a, b int, sum func(int, int) int)  {

    println( sum(a,b) )

}
func main(){

    //演示1

    var cb callback

    cb = func(s string) {

        println(s)

    }

    cb("hello world")
    //演示2

    test(1, 2, func(a, b int) int {return a + b})

}

结果：

hello world

3