目录
前言
基础函数
函数传参
函数做为实参
回调函数
闭包函数
函数方法
前言
函数是基本的代码块，用于执行一个任务。
Go程序中最少有个main()函数。
可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
函数声明告诉了编译器函数的名称，返回类型，和参数。
Go中的标准库提供了多种可动用的内置的函数。例如，len()函数可以接受不同类型参数并返回该类型的长度。如果传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。
安装完go编译器就可以直接被调用的内置函数 用户自定义函数名字自行命名注意:大小写控制权限 安装地方组件，才拥有的函数，插件中的函数框架
基础函数
语法: func函数名(参数列表)(返回值列表)
无参数无返回值
func test() { }
传参有返回值
func test(int,b int) int { return n }
传参有多个返回值
func result(a int,b int)(int ,int) { return a+b,a*b }
示例:定义max()函数传入两个整型参数num1和num2，并返回这两个参数的最大值:
func max(num1,num2 int) int {
if num1 > num2{
return num1
}else {
return num2
}
}函数的调用:
package main
import "fmt"
func main(){
var testi int = 100
var test2 int = 200
var result int
//函数调用,注意返回值和接收值的类型必须相同result = max(test1, test2)
fmt.Println("最大值:", result)
}
/*返回最大值*/
func max(num1,num2 int) int {
if num1 > num2{
return num1
}else {
return num2
}
}运行结果:
最大值:200示例:函数返回多个值。
package main
import "fmt""
func main(){
a, b := multi_value(3，5)
fmt.Println("和: ",a,"积:", b)
}
func multi_value(num1,num2 int) (int,int){
result1 := num1 + num2
//返回两数和,两数乘积
result2 := num1 * num2
return result1,result2
}
运行结果
和：8 积:15函数传参
函数如果使用参数，该变量可称为函数的形参。
形参就像定义在函数体内的局部变量。
调用函数，可以通过两种方式来传递参数:
传递类型 | 描述 |
[值传递] | 值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。 |
[引用传递 | 引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。 |
默认情况下，Go语言使用的是值传递，即在调用过程中不会影响到实际参数。
小demo
package main
import "fmt"
func main(){
var(
a = 10
b = 20 //实际参数
)
fmt. Println("交换前:a=", a,"b=", b)
}
swap(a,b)
fmt. Println("交换后:a=", a， "b=", b)
func swap(x, y int){
x,y=y,x
}
运行结果:
交换前:a= 10 b= 20
交换后:a= 10 b= 20
使用引用类型进行两数交换（指针）。
package main
import "fmt"
func main() {
var (
a = 10
b = 20
)
fmt.Println("引用参数之前的a,b值", a, b)
test(&a, &b)
fmt.Println("引用参数之后的a,b值", a, b)
}
func test(a, b *int) {
*a, *b = *b, *a
}
运行结果
引用参数之前的a,b值 10 20
引用参数之后的a,b值 20 10函数做为实参
可以很灵活的创建函数，并作为另外一个函数的实参。
示例：(灵活使用math数学包)
package main
import (
"fmt"
"math"
)
func main() {
//声明函数变量
getroute := func(x float64) float64 {
return math.Sqrt(x)
}
//直接使用变量名调用函数
fmt.Println("9的开平方为:", getroute(9))
fmt.Println("-10的绝对值", math.Abs(-10))
fmt.Println("5.2的上限值为:", math.Ceil(5.2))
fmt.Println("5.2的下限值为:", math.Floor(5.2))
fmt.Println("取余", math.Mod(11, 3))
fmt.Print("取整数,取小数")
fmt.Println(math.Modf(5.24))
fmt.Println("3的2次方", math.Pow(3, 2))
fmt.Println("10的n次方", math.Pow10(3))
fmt.Println("开平方", math.Sqrt(9))
fmt.Println("开立方", math.Cbrt(27))
fmt.Println("圆周率", math.Pi)
}
运行结果
9的开平方为: 3
-10的绝对值 10
5.2的上限值为: 6
5.2的下限值为: 5
取余 2
取整数,取小数5 0.2400000000000002
3的2次方 9
10的n次方 1000
开平方 3
开立方 3
圆周率 3.141592653589793回调函数
回调函数作为初始函数的参数传入，当调用初始函数的时候，自动调用函数
初始函数——》回调函数
示例
package main
import "fmt"
//声明形式函数
type Cback func(int) int
func main() {
//对回调函数进行了隐匿，起到安全保护作用之余，提高程序运行效率
test_back(1,Call_back)
test_back(2,func(c int) int{
fmt.Println("主函数输出",c)
return c
})
}
//测试函数,用来调用回调函数
func test_back(a int ,b Cback) {
fmt.Println("测试函数1")
b(a)
fmt.Println("测试函数2")
}
//回调函数
func Call_back(x int)int {
fmt.Println("Call_back回调函数",x)
return x
}
运行结果
测试函数1
Call_back回调函数 1
测试函数2
测试函数1
主函数输出 2
测试函数2闭包函数
匿名函数，可作为闭包。匿名函数是一个""内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。
示例:
package main
import "fmt"
func main() {
number := close_package()
fmt.Println("使用number做自增")
fmt.Println("number值", number())
fmt.Println("number值", number())
fmt.Println("number值", number())
fmt.Println("number值", number())
number1 := close_package()
fmt.Println("使用number1做自增")
fmt.Println("number值", number1())
fmt.Println("number值", number1())
fmt.Println("number值", number1())
}
func close_package() func() int {
i := 0
return func() int {
i++
return i
}
}
运行结果
使用number做自增
number值 1
number值 2
number值 3
number值 4
使用number1做自增
number值 1
number值 2
number值 3函数方法
同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。
语法如下:
func (variable_name variable_data_type) function_name()[return_type]{ /*函数体*/ }
示例:定义一个结构体类型和该类型的一个方法。
实例函数
package means
import (
"fmt"
"math"
)
type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
area := math.Pi*c.Radius*c.Radius
fmt.Println("圆的面积为:",area)
return 0
}
func (c Circle) Perimeter() float64 {
per := math.Pi*2*c.Radius
fmt.Println("圆的周长为:",per)
return 0
}
主函数
package main
import (
"day09/demo2/means"
)
//求圆的面积及周长
func main() {
c1 := new(means.Circle)
c1.Radius = 10
c1.Area()
c1.Perimeter()
}
运行结果
圆的面积为: 314.1592653589793
圆的周长为: 62.83185307179586
