Golang01-go函数

函数

函数在go中是一等公民，这里和js一样。

普通函数需要声明之后才能调用:

var str string="this is a string!"         //全局变量
//这是一个a+b的函数
    func addAtoB(a,b int b)(sumAB int){
        sumAB=a+b
        return sumAB
    }
复制代码

1.1 变量作用域

在函数体内声明的变量称为局部变量，它的作用域只在函数体内，声明周期也只在函数体内，参数和返回值也是局部变量。在函数体外声明的变量称为全局变量

1.2 匿名函数

1.2.1 匿名函数的使用方式1

package main

import "fmt"

func main()  {
	func(data int){
		fmt.Printf("this is a func%d",data)
	}(100)
}
复制代码

1.2.2 匿名函数使用方式2，将函数赋值给变量

package main

import "fmt"

func main()  {
	str:= func(name string) {
		fmt.Println("hello,"+name)
	}
	str("JackMa")
	
}

复制代码

1.2.3 匿名函数作为回调函数

简单的回调函数案例

package main

import "fmt"

type funcType func(float64,float64)float64

//实现函数，实现求和
func sum(a,b float64)(c float64)  {
	c=a+b
	return c
}
//实现函数实现减法
func difference(a,b float64)(c float64)  {
	c=a-b
	return c
}
//实现函数，实现乘法
func product(a,b float64)(c float64) {
	c=a*b
	return c
}
//这里calc是回调函数
func calc(f funcType,a,b float64)( ret float64)  {
	ret=f(a,b)
	return ret
}
func main()  {

	ret:=calc(sum,10.0,20)
	fmt.Println(ret)
	ret=calc(difference,10,20)
	fmt.Println(ret)
	ret=calc(product,100,200)
	fmt.Println(ret)
}

复制代码

1.2.4 闭包

闭包是一个比较老的概念了，在JS中也有，rust也有。闭包实际上就是返回一个函数，这个函数可以访问函数作用域的变量，这样就产生了闭包。

package main

import "fmt"

func main()  {
	pos:=adder()
	for i:=1;i<10;i++ {
		fmt.Printf("i=%d\t",i)
		fmt.Println(pos(i))
	}
	fmt.Println("----------------")
	for i:=0;i<10;i++{
		fmt.Printf("i=%d",i)
		fmt.Println(pos(i))
	}
}

func adder() func(int)int {       //这里是一个adder函数，adder返回一个函数。adder返回的函数是带一个int参数，同时返回的值为int型
	sum:=0
	return func(x int) int {     //这里就形成了闭包，sum是在adder函数作用域内部的，返回的函数可以访问sum
		fmt.Printf("sum=%d\t",sum)
		sum+=x
		fmt.Printf("sum2=%d\t",sum)
		return sum
	}
}

/*
前两次返回的结果：
i=1	sum=0	sum2=1	1
i=2	sum=1	sum2=3	3
*/

复制代码

1.2.5 可变参数

可变参数就是函数的个数不定，类型一样，可以使用可变参数。

sample不同个数的求和函数

package main

import "fmt"

func getSum(val ...float64)(sum float64)  {   //这里的val就是一个可变参数
	sum=0
	for _,value:=range val{
		sum+=value
	}
	return sum
}
func main()  {
	fmt.Println(getSum(1,3,5,7,9))    //返回25
	fmt.Println(getSum(2,4,6,8,10))   //返回30
}

复制代码

1.2.6 递归

递归这个东西就是函数自己调用自己

sample计算阶乘递归

package main

func prod(val,sum int)(s int)  {
	if(val==1){
		return sum
	}
	sum*=val
	val--
	return prod(val,sum)
}

func main()  {

	ret:=prod(10,1)
	println(ret)
}

复制代码