go语言中的是否为空 go语言函数

转载

AI独步天下 2023-07-11 23:20:42

文章标签 go语言中的是否为空 Go 全局变量引用传递 文章分类 Go语言后端开发

Go 语言函数

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

Go 语言最少有个 main() 函数。

你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称，返回类型，和参数。

Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的函数个数。

函数定义

Go 语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] {
   函数体
}

函数定义:

func:函数是以func为关键字
function_name：函数名称，函数名和参数列表一起构成了函数签名
parameter list：参数列表，支持传递到函数内部的参数，可以是一个参数，也可以是多个参数(可变参数，用 name ...type来标识),这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数
return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
函数体：函数定义的代码集合。

实例

写一个plus的函数，传递两个数值，用于计算两个数的和，并返回结果

1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 var (
 8     //声明全局变量num1,num2
 9     num1 float32 = 123.456
10     num2 float32 = 456.789
11 )
12 
13 //自己定义的求和函数，返回两个传递进来num1 num2的和
14 func plus(num1, num2 float32) float32 {
15     result := num1 + num2
16     return result
17 }
18 
19 //主函数
20 func main(){
21     //调用自定义求和函数的返回结果并赋值给sum变量
22     sum := plus(num1, num2)
23     fmt.Printf("%.3f + %.3f = %.3f ",num1, num2, sum)
24 }

上面代码返回的结果为:

123.456 + 456.789 = 580.245

函数返回多个值

Go 函数可以返回多个值，例如：

栗子~

1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 //自定义的交换x,y两个变量返回位置的函数
 8 func swap(x, y string) (string, string) {
 9     return y,x
10 }
11 
12 func main(){
13     //调用函数并输出结果
14     fmt.Println(swap("demon","18"))
15 }

上面代码返回的结果为:

18 demon

Go 语言函数引用传递值

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

引用传递指针参数传递到函数内，以下是交换函数 swap() 使用了引用传递：

1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 //使用了指针，这个时候，我们在函数内部修改传递进来的形参会修改外部的实际参数，因为引用的是同一个空间
 8 func swap(x *int, y *int) string{
 9     *x += 50　　　　　　//*x是为了保持x地址上的值
10     *y += 50　　　　　　//*y是为了保持y地址上的值
11     fmt.Printf("swap函数内部的x值为: %d\n",*x)
12     fmt.Printf("swap函数内部的x值为: %d",*y)
13     return ""
14 }
15 
16 func main(){
17     var x int = 10
18     var y int = 20
19     fmt.Println("未进入函数中的x值：", x)
20     fmt.Println("未进入函数中的y值：", y)
21     fmt.Println("---------------------")
22     //调用函数并输出结果，&指向x,y变量的指针地址
23     fmt.Println(swap(&x, &y))
24     fmt.Println("*********************")
25     fmt.Println("全局变量x的值为:", x)
26     fmt.Println("全局变量y的值为:", y)
27 
28 }

上面代码返回的结果为:

未进入函数中的x值： 10
未进入函数中的y值： 20
---------------------
swap函数内部的x值为: 60
swap函数内部的x值为: 70
*********************
全局变量x的值为: 60
全局变量y的值为: 70

不使用引用传递值得效果，函数内部的修改并不会影响外部的变量值

1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 //未使用引用传递值得函数，内部对值得修改并不会影响外部
 8 func swap(x int, y int) string{
 9     x += 50
10     y += 50
11      fmt.Printf("swap函数内部的x值为: %d\n", x)
12     fmt.Printf("swap函数内部的x值为: %d", y)
13     return ""
14 }
15 
16 func main(){
17     var x int = 10
18     var y int = 20
19     fmt.Println("未进入函数中的x值：", x)
20     fmt.Println("未进入函数中的y值：", y)
21     fmt.Println("---------------------")
22     //调用函数并输出结果
23     fmt.Println(swap(x, y))
24     fmt.Println("*********************")
25     fmt.Println("全局变量x的值为:", x)
26     fmt.Println("全局变量y的值为:", y)
27 
28 }

上面代码返回的结果为:

未进入函数中的x值： 10
未进入函数中的y值： 20
---------------------
swap函数内部的x值为: 60
swap函数内部的x值为: 70
*********************
全局变量x的值为: 10
全局变量y的值为: 20

Go 语言函数作为值(匿名函数的使用)

1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main(){
 8     //匿名函数，传递一个x值进去并取x得平方
 9     f := func (x int) string {
10         return fmt.Sprintf("%d * %d = %d",x,x, x * x)
11     }
12     //调用匿名函数
13     fmt.Println(f(10))
14 }

上面代码返回的结果为:

10 * 10 = 100

闭包的实现

Go 语言支持匿名函数，可作为闭包。匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。

以下实例中，我们创建了函数 getSequence() ，返回另外一个函数。该函数的目的是在闭包中递增 i 变量，代码如下：

1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func getSequence() func() int {
 8     i:=0
 9     return func() int {
10         i+=1
11         return i
12     }
13 }
14 
15 func main(){
16     //作为一个初始化函数，函数中的i初始化的值为0
17     nextNumber := getSequence()
18 
19     //每次调用都递增加1
20     fmt.Println(nextNumber())
21     fmt.Println(nextNumber())
22     fmt.Println(nextNumber())
23 }

上面代码返回的结果为:

1 2 3

Go 语言函数方法

Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。语法格式如下：

func (variable_name variable_data_type) function_name() [return_type]{
   /* 函数体*/
}

栗子~

1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 //定义结构体，类似面向对象种的类的静态变量
 8 type Circle struct {
 9     redius float64
10 }
11 
12 //定义getArea函数，并返回3.14*100.00的结果
13 func (c Circle) getArea() float64{
14     return 3.14 * c.redius
15 }
16 
17 func  main()  {
18     //给结构体赋值
19     c1 := Circle{redius:100.00}
20 
21     /*给结构体赋值的另外一种写法
22     var c1 Circle
23     c1.redius = 100.00
24     */
25 
26     fmt.Printf("Area of Circle(c1) = %.2f ", c1.getArea())
27 
28 }

上面代码返回的结果为:

Area of Circle(c1) = 314.00

Go 语言递归函数

递归，就是在运行的过程中调用自己。

Go 语言支持递归。但我们在使用递归时，开发者需要设置退出条件，否则递归将陷入无限循环中。

递归函数对于解决数学上的问题是非常有用的，就像计算阶乘，生成斐波那契数列等。

栗子~

1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func fibonacci(n int ) (resulut int){
 8     //递归必须要有退出条件，不然会成死循环
 9     if n < 2{
10         return n
11     }else{
12         return fibonacci(n - 2) + fibonacci(n - 1)
13     }
14 
15 }
16 
17 func main(){
18     //利用for循环求0到10的斐波那契数列的结果
19     for i := 0; i< 11; i++{
20         fmt.Printf("%d ",fibonacci(i))
21     }
22 }

上面代码返回的结果为:

0 1 1 2 3 5 8 13 21 34 55

1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func Factorial(n int ) (result int) {
 8     //递归必须要有退出条件，不然会成死循环
 9     if n == 0 {
10         result = 1
11     } else {
12         result = n * Factorial(n-1)
13     }
14     return result
15 }
16 
17 func main(){
18     //0-15的阶乘
19     fmt.Printf("15的阶乘为:%d ",Factorial(15))

上面代码返回的结果为: