7. Go之函数

1.普通函数

func 函数名(参数)(返回值){
	函数体
}

创建函数

函数名的第一个字母要大写！！！

func Add(x, y int) int {
	return x + y
}
func Sub(x, y int) int {
	return x - y
}

func main(){
fmt.Println(Add(10, 20))
}

//output
30

2. 可变参数

可变参数变的是参数的数量而不是参数的类型。

func KbADD(x ...int) int {
	sum := 0
	for _, i := range x {
		sum += i
	}
	return sum
}

func main(){
fmt.Println(KbADD(10,20,30))
}

//output
60

3. 对象数组

创建对象数组的参数的第一个字母都要大写!!!!,像Name,Sex,Age都需要大写!!!!!!!!!

type Person struct {
	Name string
	Sex  string
	Age  int
}

func main(){
	c := make([]Person, 0, 100)
	c = append(c, Person{"apang", "man", 22})
	c = append(c, Person{"Lcs", "nan", 23})
	c = append(c, Person{"Mina", "woman", 20})
	for _, x := range c {
		if x.Name == "Lcs" {
			fmt.Println(x)
			break
		}
	}
}

//output
{Lcs nan 23}

4. 将函数作为参数

func AddPro(x, y int, op func(int, int) int) int {
	return op(x, y)
}

func main(){
	fmt.Println(AddPro(20, 20, Add))
}

//output
40

5.方法

type MyType struct {
    Value int
}

func (m MyType) add(a int) int {
    return m.Value + a
}

在这种情况下，add 依然是函数名，但是在函数名前面有一个参数 (m MyType)。这个参数被称为接收器，这意味着 add 函数是 MyType 类型的一个方法。接收器可以是任何类型，不仅仅是结构体。

举例:

package main

import "fmt"

// 定义一个结构体类型
type Rect struct {
    width, height int
}

// 为 Rect 类型定义一个方法 area
func (r Rect) area() int {
    return r.width * r.height
}

func main() {
    // 创建一个 Rect 类型的值
    rect := Rect{width: 10, height: 5}

    // 使用 Rect 的值调用 area 方法
    fmt.Println(rect.area()) // 输出: 50
}

6. 匿名函数

匿名函数声明

func(参数)(返回值){
	函数体
}

因为匿名函数没有函数名，所以匿名函数只能在某个变量或者函数中

匿名函数多用于实现回调函数和闭包.

func Nm() {
	//匿名函数寄存在变量中，此时add相当于变量名，但只在Nm函数中可以调用。
	add := func(x, y int) int {
		return x + y
	}
	sum := add(20, 30)
	fmt.Println(sum)
	//自执行函数：匿名函数定义完加()直接执行
	func(x, y int) {
		fmt.Println(x + y)
	}(50, 20)
}

func main(){
    Nm()
}

//output
50
70

7. 闭包

闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，闭包=函数+引用环境

闭包：

func Adder() func(int) int {
	var x int
	fmt.Println("x=:", x)
	return func(y int) int {
		fmt.Println("y=:", y)
		x += y
        fmt.Println("x=:",x)
		return x
	}
}

func main(){
    f := hanshu.Adder()
	fmt.Println(f(10))
	fmt.Println(f(20))
	
    fmt.Println("Next f1")
	f1 := hanshu.Adder()
	fmt.Println(f1(30))
	fmt.Println(f1(40))
}

//output
x=: 0
y=: 10
10
y=: 20
30
Next f1
x=: 0
y=: 30
30
y=: 40
70

闭包进阶1：

func adder2(x int) func(int) int {
	return func(y int) int {
		x += y
		return x
	}
}

func main(){
	f := hanshu.Adder2(10)
	fmt.Println(f(5))
	fmt.Println(f(3))
	fmt.Println(f(2))
}


//output
15
18
20

闭包进阶2

//闭包进阶2
func MakeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		//strings.HasSuffix是strings包中的函数，用于检查字符串是否以指定的后缀结尾。 其传入参数为(string,string)两个字符串,返回值为bool一个布尔类型.
		//假如我传入x和y(strings.HasSuffix(x, y)),如果x的后缀为y，那么返回true；否则为false
		if !strings.HasSuffix(name, suffix) {
			return "照片类型-错误"
		}
		return "照片类型-正确"
	}
}

func main(){
	hz := hanshu.MakeSuffixFunc(".png")
	println(hz("1.png"))
	println(hz("2.png"))
	println(hz("3.jpg"))
	println(hz("4.png"))
	println(hz("5.jpg"))
}

//output
照片类型-正确
照片类型-正确
照片类型-错误
照片类型-正确
照片类型-错误

闭包进阶3

func Calc(base int) (func(int) int, func(int) int) {
	add := func(i int) int {
		base += i
		return base
	}

	sub := func(i int) int {
		base -= i
		return base
	}
	return add, sub
}

func main(){
	add1, sub1 := hanshu.Calc(10)
	fmt.Println(add1(5))
	fmt.Println(sub1(3))
	fmt.Println(add1(4))
	fmt.Println(sub1(2))
}

//output
15
12
16
14