人生苦短我使用GO——GO函数

目录

前言

基础函数

函数传参

函数做为实参

        回调函数

闭包函数

函数方法

---

前言

        函数是基本的代码块，用于执行一个任务。

        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