【go语言基础】-函数

1. 函数定义

1. 函数的定义方法

 

package main

import (
    "errors"
    "fmt"
)

//相比较其他静态语言，go语言的函数有很多两点
//函数的几个要素： 1. 函数名 2. 参数 3. 返回值
//函数第一种定义方法
func add(a, b int) int {
    var sum int
    sum = a + b
    return sum
}

//函数的第二种定义方法
func add2(a, b int) (sum int) {
    sum = a + b
    return sum
}

//函数的第三种定义方法
func add3(a, b int) (sum int) {
    sum = a + b
    return
}

//函数的第4种定义方法
// 被除数等于0 ，要返回多个值 -一个非常有用的特性
//go语言的返回设置花样很多
func div(a, b int) (int, error) {
    var result int
    var err error
    if b == 0 {
        err = errors.New("被除数不能为0")
    } else {
        result = a / b
    }

    return result, err
}

func div2(a, b int) (result int, err error) {
    if b == 0 {
        err = errors.New("被除数不能为0")
    } else {
        result = a / b
    }

    return
}

func main() {
    result, err := div2(12, 3)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(result)
        fmt.Println(a1)
    }
}

 2. 函数的一等公民特性

1. 省略号的用途

1. 函数参数不定长

2. 将slice打散，传递INT值

3. 设置数组不定长 arr:=[...]int{1,2,3}

 

2. 匿名函数

go中也可以将函数赋值给一个变量

//匿名函数

myFunc := func(a, b int) (c int){
   c = a + b
   return 
}
fmt.Println(myFunc(1,2))

//简化

fmt.Println(func(a, b int) int {
  return a + b
}(1, 2))

函数也可以当做参数传递给一个函数

sub就等同于int map， 其实就是强制要求代码风格

type sub func(a, b int) int //sub就等同于int map
func subImpl(a, b int) int {
    return a - b
}

func main() {

var mySub1 sub = subImpl
fmt.Println(mySub1(3, 4))

var mySub sub = func(a, b int) int {
   return a - b
}
fmt.Println(mySub(1, 2))

}

写一个函数用于过滤一部分数据， 函数也可以当做参数传递给一个函数，

写一个函数过滤掉不合格的成绩

package main

import "fmt"

func filter(score []int, f func(int) bool) []int {
    reSlice := make([]int, 0)
    for _, v := range score {
        if f(v) {
            reSlice = append(reSlice, v)
        }
    }
    return reSlice
}

func main() {
    //将函数作为另一个函数的参数
    //写一个函数用于过滤一部分数据
    score := []int{10, 50, 80, 90, 85}
    //写一个函数过滤掉不合格的成绩
    fmt.Println(filter(score, func(a int) bool {
        if a >= 90 {
            return true
        } else {
            return false
        }
    }))

}

全部代码

package main

import "fmt"

//省略号
//省略号的用途 1. 函数参数不定长 2. 将slice打散 3. 设置数组不定长

func add(params ...int) (sum int) {
    //不能解决一个问题，我可能有不定个int值传递进来
    for _, v := range params {
        sum += v
    }
    params[0] = 9
    return
}

type sub func(a, b int) int //sub就等同于int map
func subImpl(a, b int) int {
    return a - b
}

func filter(score []int, f func(int) bool) []int {
    reSlice := make([]int, 0)
    for _, v := range score {
        if f(v) {
            reSlice = append(reSlice, v)
        }
    }
    return reSlice
}

func main() {
    //通过省略号去动态设置多个参数值
    fmt.Println(add(1, 2, 4)) //将slice打散

    slice := []int{1, 2, 3, 4, 5}
    fmt.Println(add(slice...)) //将slice打散,，传递多个INT类型
    fmt.Println(slice)
    //这种效果slice
    //区别，slice是一种类型， 还是引用传递， 我们要慎重

    //省略号的用途 1. 函数参数不定长 2. 将slice打散 3. 设置数组不定长
    arr := [...]int{1, 2, 3}
    fmt.Printf("%T\n", arr)

    //匿名函数
    fmt.Println(func(a, b int) int {
        return a + b
    }(1, 2))
    //fmt.Println(result)
    //fmt.Printf("%T", myFunc)

    //go语言中非常重要的特性 函数 一些trick 一些语法糖 函数的一等公民特性 - 可以作为参数 返回值 复制给另一个变量
    //函数也可以当做参数传递给一个函数

    var mySub sub = func(a, b int) int {
        return a - b
    }
    fmt.Println(mySub(1, 2))
    //另一种赋值
    var mySub1 sub = subImpl
    fmt.Println(mySub1(2, 4))


    //将函数作为另一个函数的参数
    //写一个函数用于过滤一部分数据
    score := []int{10, 50, 80, 90, 85}
    //写一个函数过滤掉不合格的成绩
    fmt.Println(filter(score, func(a int) bool {
        if a >= 90 {
            return true
        } else {
            return false
        }
    }))
    //gin, python的装饰器

    //go语言并没有提供try except finally
    //1. 大量的嵌套try finally 2. 打开和关系逻辑离的太远

}