100天精通Golang（基础入门篇）——第14天：深入解析Go语言函数-＞从概念到实践，助您精通基础知识！（基础）

猫头虎

发布于 2024-04-08 16:37:17

970

发布于 2024-04-08 16:37:17

摘要:

本篇文章是《100天精通Golang（基础入门篇）》系列的第14天，我们将深入解析Go语言中的函数。文章围绕函数的概念、参数、返回值、作用域、本质和defer函数展开讲解，并探讨Go语言函数与Java函数的区别。通过学习本文，读者将对Go语言函数的基本概念和特性有更深入的了解。

前言:

函数是编程中的重要概念之一，对于掌握一门编程语言来说，深入理解和灵活运用函数是必不可少的。本篇文章将带领读者深入解析Go语言中的函数，从基础的概念、声明和使用开始，逐步探讨参数的使用和传递、返回值的处理、作用域和变量的可见性等关键内容。我们还将介绍函数的本质以及延迟执行的概念和注意事项。最后，我们将对比Go语言函数和Java函数的差异，帮助读者更好地理解两者之间的区别。

100天精通Golang（基础入门篇）——第14天：深入解析Go语言中的函数

一、函数的概念

1.1 什么是函数

函数是执行特定任务的代码块。

1.2 函数的声明

go语言至少有一个main函数

语法格式：

func funcName(parametername type1, parametername type2) (output1 type1, output2 type2) {
//这里是处理逻辑代码
//返回多个值
return value1, value2
}

func：函数由 func 开始声明
funcName：函数名称，函数名和参数列表一起构成了函数签名。
parametername type：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
output1 type1, output2 type2：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
上面返回值声明了两个变量output1和output2，如果你不想声明也可以，直接就两个类型。
如果只有一个返回值且不声明返回值变量，那么你可以省略包括返回值的括号（即一个返回值可以不声明返回类型）
函数体：函数定义的代码集合。

1.3 函数的使用

示例代码：

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int = 200
   var ret int

   /* 调用函数并返回最大值 */
   ret = max(a, b)

   fmt.Printf( "最大值是 : %d\n", ret )
}

/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
   /* 定义局部变量 */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

运行结果：

最大值是 : 200

二、函数的参数

2.1 参数的使用

形式参数：定义函数时，用于接收外部传入的数据，叫做形式参数，简称形参。

实际参数：调用函数时，传给形参的实际的数据，叫做实际参数，简称实参。

函数调用：

A：函数名称必须匹配

B：实参与形参必须一一对应：顺序，个数，类型

2.2 可变参

Go函数支持变参。接受变参的函数是有着不定数量的参数的。为了做到这点，首先需要定义函数使其接受变参：

func myfunc(arg ...int) {}

arg ...int告诉Go这个函数接受不定数量的参数。注意，这些参数的类型全部是int。在函数体中，变量arg是一个int的slice：

for _, n := range arg {
fmt.Printf("And the number is: %d\n", n)
}

2.3 参数传递

go语言函数的参数也是存在值传递和引用传递

函数运用场景

值传递

package main

import (
   "fmt"
   "math"
)

func main(){
   /* 声明函数变量 */
   getSquareRoot := func(x float64) float64 {
      return math.Sqrt(x)
   }

   /* 使用函数 */
   fmt.Println(getSquareRoot(9))

}

引用传递

这就牵扯到了所谓的指针。我们知道，变量在内存中是存放于一定地址上的，修改变量实际是修改变量地址处的内存。只有add1函数知道x变量所在的地址，才能修改x变量的值。所以我们需要将x所在地址&x传入函数，并将函数的参数的类型由int改为*int，即改为指针类型，才能在函数中修改x变量的值。此时参数仍然是按copy传递的，只是copy的是一个指针。请看下面的例子

package main
import "fmt"
//简单的一个函数，实现了参数+1的操作
func add1(a *int) int { // 请注意，
*a = *a+1 // 修改了a的值
return *a // 返回新值
} f
unc main() {
x := 3
fmt.Println("x = ", x) // 应该输出 "x = 3"
x1 := add1(&x) // 调用 add1(&x) 传x的地址
fmt.Println("x+1 = ", x1) // 应该输出 "x+1 = 4"
fmt.Println("x = ", x) // 应该输出 "x = 4"
}

传指针使得多个函数能操作同一个对象。
传指针比较轻量级 (8bytes),只是传内存地址，我们可以用指针传递体积大的结构体。如果用参数值传递的话, 在每次copy上面就会花费相对较多的系统开销（内存和时间）。所以当你要传递大的结构体的时候，用指针是一个明智的选择。
Go语言中slice，map这三种类型的实现机制类似指针，所以可以直接传递，而不用取地址后传递指针。（注：若函数需改变slice的长度，则仍需要取地址传递指针）

三、函数的返回值

3.1 什么是函数的返回值

一个函数被调用后，返回给调用处的执行结果，叫做函数的返回值。

调用处需要使用变量接收该结果

3.2 一个函数可以返回多个值

一个函数可以没有返回值，也可以有一个返回值，也可以有返回多个值。

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

func SumAndProduct(A, B int) (add int, Multiplied int) {
add = A+B
Multiplied = A*B
return
}

3.3 空白标识符

_是Go中的空白标识符。它可以代替任何类型的任何值。让我们看看这个空白标识符的用法。

比如rectProps函数返回的结果是面积和周长，如果我们只要面积，不要周长，就可以使用空白标识符。

示例代码：

package main

import (  
    "fmt"
)

func rectProps(length, width float64) (float64, float64) {  
    var area = length * width
    var perimeter = (length + width) * 2
    return area, perimeter
}
func main() {  
    area, _ := rectProps(10.8, 5.6) // perimeter is discarded
    fmt.Printf("Area %f ", area)
}

四、函数的作用域

作用域：变量可以使用的范围。

4.1 局部变量

一个函数内部定义的变量，就叫做局部变量

变量在哪里定义，就只能在哪个范围使用，超出这个范围，我们认为变量就被销毁了。

4.2 全局变量

一个函数外部定义的变量，就叫做全局变量

所有的函数都可以使用，而且共享这一份数据

五、函数的本质

函数也是Go语言中的一种数据类型，可以作为另一个函数的参数，也可以作为另一个函数的返回值。

六、defer函数

6.1 延迟是什么?

即延迟（defer）语句，延迟语句被用于执行一个函数调用，在这个函数之前，延迟语句返回。

6.2 延迟函数

你可以在函数中添加多个defer语句。当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回。特别是当你在进行一些打开资源的操作时，遇到错误需要提前返回，在返回前你需要关闭相应的资源，不然很容易造成资源泄露等问题

如果有很多调用defer，那么defer是采用后进先出模式
在离开所在的方法时，执行（报错的时候也会执行）

func ReadWrite() bool {
    file.Open("file")
    defer file.Close()
    if failureX {
          return false
    } i
    f failureY {
          return false
    } 
    return true
}

最后才执行file.Close()

示例代码：

package main

import "fmt"

func main() {
	a := 1
	b := 2
	defer fmt.Println(b)
	fmt.Println(a)
}

运行结果：

1
2

示例代码：

package main

import (  
    "fmt"
)

func finished() {  
    fmt.Println("Finished finding largest")
}

func largest(nums []int) {  
    defer finished()    
    fmt.Println("Started finding largest")
    max := nums[0]
    for _, v := range nums {
        if v > max {
            max = v
        }
    }
    fmt.Println("Largest number in", nums, "is", max)
}

func main() {  
    nums := []int{78, 109, 2, 563, 300}
    largest(nums)
}

运行结果：

Started finding largest  
Largest number in [78 109 2 563 300] is 563  
Finished finding largest

6.3 延迟方法

延迟并不仅仅局限于函数。延迟一个方法调用也是完全合法的。让我们编写一个小程序来测试这个。

示例代码：

package main

import (  
    "fmt"
)


type person struct {  
    firstName string
    lastName string
}

func (p person) fullName() {  
    fmt.Printf("%s %s",p.firstName,p.lastName)
}

func main() {  
    p := person {
        firstName: "John",
        lastName: "Smith",
    }
    defer p.fullName()
    fmt.Printf("Welcome ")  
}

运行结果：

Welcome John Smith

6.4 延迟参数

延迟函数的参数在执行延迟语句时被执行，而不是在执行实际的函数调用时执行。

让我们通过一个例子来理解这个问题。

示例代码：

package main

import (  
    "fmt"
)

func printA(a int) {  
    fmt.Println("value of a in deferred function", a)
}
func main() {  
    a := 5
    defer printA(a)
    a = 10
    fmt.Println("value of a before deferred function call", a)

}

运行结果：

value of a before deferred function call 10  
value of a in deferred function 5

6.5 堆栈的推迟

当一个函数有多个延迟调用时，它们被添加到一个堆栈中，并在Last In First Out（LIFO）后进先出的顺序中执行。

我们将编写一个小程序，它使用一堆defers打印一个字符串。示例代码：

package main

import (  
    "fmt"
)

func main() {  
    name := "Naveen"
    fmt.Printf("Orignal String: %s\n", string(name))
    fmt.Printf("Reversed String: ")
    for _, v := range []rune(name) {
        defer fmt.Printf("%c", v)
    }
}

运行结果：

Orignal String: Naveen  
Reversed String: neevaN

6.6 defer注意点

defer函数：当外围函数中的语句正常执行完毕时，只有其中所有的延迟函数都执行完毕，外围函数才会真正的结束执行。当执行外围函数中的return语句时，只有其中所有的延迟函数都执行完毕后，外围函数才会真正返回。当外围函数中的代码引发运行恐慌时，只有其中所有的延迟函数都执行完毕后，该运行时恐慌才会真正被扩展至调用函数。

七. Go语言的函数和Java的函数有一些区别:

以下是它们之间的几个主要区别：

声明和调用方式：在Go语言中，函数的声明以关键字func开头，后面跟着函数名、参数列表和返回值类型。函数的调用则直接通过函数名加上参数列表来进行，不需要使用对象或类名。而在Java中，函数声明需要在类中进行，通过关键字public、private等修饰符来定义访问权限，函数的调用需要通过对象或类名来进行。
参数传递方式：Go语言中的函数参数传递默认采用值传递方式，即函数内部对参数的修改不会影响到外部的变量。但是可以通过传递指针来实现引用传递。而Java中的函数参数传递方式一般是值传递，但对于对象类型参数，实际传递的是引用的副本，因此在函数内部修改对象的属性会影响到原始对象。
多返回值：Go语言支持函数返回多个值，这在某些情况下非常方便，可以避免使用临时变量或者自定义数据结构。而Java中函数只能返回一个值，如果需要返回多个值，可以使用数组、集合或自定义对象来实现。
错误处理机制：Go语言通过在函数的返回值列表中添加error类型来支持错误处理。函数可以返回一个错误值，调用者可以根据返回的错误值来判断函数是否执行成功，并采取相应的处理措施。Java中的错误处理机制一般是通过抛出异常来处理，函数可以声明可能抛出的异常类型，调用者需要使用try-catch块来捕获和处理异常。
匿名函数和闭包：Go语言支持匿名函数和闭包的概念，可以在函数内部定义函数，并且可以访问外部函数的变量。Java中没有直接支持匿名函数和闭包的语法，但可以通过使用内部类或Lambda表达式来实现类似的功能。

这些是Go语言函数与Java函数之间的一些主要区别。尽管有一些语法和行为上的差异，但两种语言的函数都具有相似的目的，即封装可重用的代码块，实现特定的功能。如果您已经熟悉Java的函数，理解Go语言函数的概念应该不会太困难。

今日学习总结:

在本篇文章中，我们深入学习了Go语言中函数的各个方面。我们了解了函数的基本概念和声明方式，掌握了参数的使用方法和传递方式。我们还学习了如何处理函数的返回值，包括多返回值和空白标识符的应用。通过讨论作用域和变量的可见性，我们对函数的作用范围有了更清晰的认识。此外，我们研究了函数的本质以及延迟执行的特性和使用方法。最后，我们对比了Go语言函数和Java函数之间的差异，帮助读者更好地理解两者的不同之处。

结语

通过今天的学习，您已经踏上了Golang的学习之旅。在未来的日子里，您将探索Golang的各个方面，从基础概念到高级技巧，从实际应用到性能优化。学习一门编程语言是一个持续的过程，每一天都是您向Golang的精通迈进的重要一步。我鼓励您坚持每天学习，保持热情和好奇心，解决挑战并享受成功的喜悦。

在您的学习旅程中，不要忘记参与社区和与其他Golang开发者交流。分享您的见解和经验，向他人学习，并在开源项目或实际应用中展示您的技能。

如果您在学习过程中遇到困难或有任何问题，不要犹豫向社区和专家寻求帮助。持续学习，勇敢探索，您将在Golang领域取得令人瞩目的成就。

最后，感谢您的阅读和支持！祝愿您在未来的每一天中都能够成为一名精通Golang的开发者！

期待听到您在学习过程中的进展和成就。如果您需要进一步的帮助，请随时告诉我。祝您在学习Golang的旅程中取得巨大成功！

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2023-07-07，如有侵权请联系 cloudcommunity@tencent.com 删除

基础

实践

变量

函数

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度