Go语言基础教程之函数和方法详解

目录

• 一、函数的基本操作
• 1.1 定义与语法
• 1.2 函数的返回值
• 1.3 函数参数传递
• 二、匿名函数与闭包
• 2.1 匿名函数
• 2.2 闭包
• 三、函数作为参数和返回值
• 3.1 函数作为参数
• 3.2 函数作为返回值
• 四、Go语言中方法详解

一、函数的基本操作

1.1 定义与语法

Go 语言中的函数是程序的基本组成单元，它允许将代码组织成可重用的模块，提高代码的可读性和可维护性。Go 语言的函数由 func 关键字定义，基本语法如下：

func functionName(parameterList) (returnTypeList) {
    // 函数体
}

示例代码

package main
import "fmt"
// 定义一个简单的加法函数
func add(a int, b int) int {
    return a + b
}
func main() {
    result := add(3, 5)
    fmt.Println("3 + 5 =", result)  // 输出：3 + 5 = 8
}

1.2 函数的返回值

1. 多返回值：Go 语言支持函数返回多个值，这在处理错误或返回多个结果时非常实用。示例代码

package main
import "fmt"
// 返回两个数的和与差
func sumAndDiff(a, b int) (int, int) {
    sum := a + b
    diff := a - b
    return sum, diff
}
func main() {
    sum, diff := sumAndDiff(10, 5)
    fmt.Println("Sum:", sum, "Diff:", diff)  // 输出：Sum: 15 Diff: 5
}

2. 命名返回值 ： 函数可以命名返回值，这样在函数体中可以直接使用这些变量，并在 return 时省略表达式。示例代码

package main
import "fmt"
// 使用命名返回值
func divide(a, b int) (quotient int, remainder int) {
    quotient = a / b
    remainder = a % b
    return
}
func main() {
    q, r := divide(10, 3)
    fmt.Println("Quotient:", q, "Remainder:", r)  // 输出：Quotient: 3 Remainder: 1
}

1.3 函数参数传递

1. 按值传递

默认情况下，Go 语言的函数参数是按值传递的，即函数内部对参数的修改不会影响外部变量。示例代码

package main
import "fmt"
// 按值传递
func modifyValue(x int) {
    x = 100
}
func main() {
    a := 10
    modifyValue(a)
    fmt.Println("a after modifyValue:", a)  // 输出：a after modifyValue: 10
}

2编程. 按指针传递： 通过指针传递参数，可以在函数内部修改外部变量的值。示例代码

package main
import "fmt"
// 按指针传递
func modifyPointer(x *int) {
    *x = 100
}
func main() {
    a := 10
    modifyPointer(&a)
    fmt.Println("a after modifyPointer:", a)  // 输出：a after modifyPointer: 100
}

二、匿名函数与闭包

2.1 匿名函数

匿名函数是没有名字的函数，通常用于需要临时定义函数的场景。示例代码

package main
import "fmt"
func main() {
    // 定义并调用匿名函数
    func() {
        fmt.Println("Hello from anonymous function!")
    }()
}

输出：

Hello from anonymous function!

2.2 闭包

闭包是由函数及其相关引用环境组合而成的实体。闭包可以访问外部作用域中的变量，即使外部函数已经返回。示例代码

package main
import "fmt"
// 返回一个闭包
func getandroidCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}
func main() {
    counter := getCounter()
    fmt.Println(counter()) // 输出 1
    fmt.Println(counter()) // 输出 2
    fmt.Println(counter()) // 输出 3
}

三、函数作为参数和返回值

3.1 函数作为参数

Go 语言支持将函数作为参数传递给其他函数。示例代码

package main
import "fmt"
// 定义一个函数类型
type operation func(int, int) int
// 将函数作为参数
func compute(a, b int, op operation) int {
    return op(a, b)
}
func main() {
    sum := compute(3, 5, func(编程客栈a, b int) int {
        return a + b
    })
    fmt.Println("Sum:", sum)  // 输出：Sum: 8
}

3.2 函数作为返回值

函数也可以作为其他函数的返回值。示例代码

package main
import "fmt"
// 返回一个函数
func getMultiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}
func main() {
    multiplyBy2 :编程客栈= getMultiplier(2)
    fmt.Println(multiplyBy2(5)) // 输出 10
}

四、Go语言中方法详解

在 Go 语言中，方法和函数是两个概念，但又非常相似，不同点在于方法必须要有一个接收者，这个接收者是一个类型，这样方法就和这个类型绑定在一起，称为这个类型的方法。函数属于一个包，方法属于一个类型，所以方法也可以简单地理解为和一个类型关联的函数。

不管是函数还是方法，它们都是代码复用的第一步，也是代码职责分离的基础。掌握好函数和方法，可以让你写出职责清晰、任务明确、可复用的代码，提高开发效率、降低 Bug 率。

在下面的示例中，type Age uint 表示定义一个新类型 Age，该类型等价于 uint，可以理解为类型 uint 的重命名。其中 type 是 Go 语言关键字，表示定义一个类型。

type Age uint
func (age Age) String(){
    fmt.Println("the age is",age)
}

示例中方法 String() 就是类型 Age 的方法，类型 Age 是方法 String() 的接收者。和函数不同，定义方法时会在关键字 func 和方法名 String 之间加一个接收者 (age Age) ，接收者使用小括号包围。

接收者的定义和普通变量、函数参数等一样，前面是变量名，后面是接收者类型。现在方法 String() 就和类型 Age 绑定在一起了，String() 是类型 Age 的方法。定义了接收者的方法后，就可以通过点操作符调用方法，如下面的代码所示：

www.devze.com

func main() {
    age:=Age(25)
    age.String()
}

运行这段代码，可以看到如下输出：

the age is 25

接收者就是函数和方法的最大不同，此外，上面所讲到的函数具备的能力，方法也都具备。

到此这篇关于Go语言基础教程之函数和方法详解的文章就介绍到这了,更多相关Go语言函数和方法内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！