一文带你熟悉Go语言中函数的使用

目录
  • 函数
  • 函数的声明
  • Go 函数支持变长参数
  • 匿名函数
  • 闭包
  • init 函数
  • 函数参数详解
    • 形式参数与实际参数
    • 值传递
  • 函数是一种数据类型
  • 小结

函数

函数的英文单词是 Function,这个单词还有着功能的意思。在 Go 语言中,函数是实现某一特定功能的代码块。函数代表着某个功能,可以在同一个地方多次使用,也可以在不同地方使用。因此使用函数,可以提高代码的复用性,减少代码的冗余。

函数的声明

通过案例了解函数的声明有哪几部分:

定义一个函数,实现两个数相加的功能,并将相加之后的结果返回。

func Add(num1 int, num2 int) int {
    var sum int
    sum += num1
    sum += num2
    return sum
}

通过案例可以发现,函数的声明有5部分:

1、关键字

函数的关键字是 func,声明函数必须以 func 关键字开始。

2、函数名

Go 推荐使用驼峰命名的方式,和变量的命名规则一样,首字母大写的函数名可以在包外访问,小写的只能在包内访问。

3、参数列表

参数列表中声明了在函数体里所使用到的变量。参数列表位于函数名后面,用括号包裹着,多个参数使用逗号分隔开。

4、返回值列表

返回值为函数执行后的一个结果,上述代码只有一个返回值,如果有多个返回值,需要用括号包裹着,返回值之间用逗号分隔开。

少数情况下,我们会声明返回值的的名称如 func Add(num1 int, num2 int) sum int {},多数情况下是不用声明返回值的名称的。

5、函数体

大括号内就是函数体,存放着函数的具体实现。 函数的第 34 部分可有可无,也就是说一个函数可以没有参数和返回值。

Go 函数支持变长参数

在上面的案例中,实现的功能是对两数求和,如果我们需要对多个数求和,但又不知道具体的数量,函数的参数该怎么声明呢?这时可以声明变长参数去接收多个参数。

func main() {
    sum := Add(1, 2, 3, 4)
    println(sum) // 10
}

func Add(nums ...int) int {
    var sum int
    for _, num := range nums {
	sum += num
    }
    return sum
}

变长参数作为形式参数可以接收不定的实际参数,声明变长参数需要在类型面前加上 ... 。可变参数实际上是一个切片,可以通过 for-range 去操作。

匿名函数

通常情况下,如果一个函数只使用一次,我们就可以定义成匿名函数。

func main() {
    // 定义匿名函数,直接调用
    result := func(num1, num2 int) int {
	return num1 + num2
    }(1, 2)
    println(result)
    // 2、将匿名函数赋值给一个变量,由变量调用
    resultFunc := func(num1, num2 int) int {
	return num1 + num2
    }
    println(resultFunc(1, 2))
}

声明函数时,不指定函数名的函数,叫做匿名函数。匿名函数可以直接调用,也可以通过赋值给变量,由变量调用。

闭包

闭包就是一个函数和其相关引用环境组合的一个整体。

import "fmt"

// 返回值为一个匿名函数
func getSum() func(int) int {
    var sum int = 0
    // 匿名函数
    result := func(num int) int {
	sum += num
	return sum
    }
    return result
}

func main() {
    f := getSum()
    fmt.Println(f(1)) // 1
    fmt.Println(f(2)) // 3
}
  • 闭包的本质就是一个匿名函数,匿名函数里使用了定义它的函数(getSum)里面的变量 sum,就组成了闭包。
  • 由上述代码可知,匿名函数中所引用的变量 sum 会一直保存在内存中。

init 函数

每个 go 文件都可以包含一个 init 函数,它是一个初始化函数,用于进行初始化的操作。

var print = getNum()

func getNum() int {
    println("初始化变量")
    return 1
}

func main() {
    println("main...")
}

func init() {
    println("init...")
}

执行结果:

初始化变量
init...
main...

  • 根据执行结果可知,它们的执行顺序为:全局变量 → init 函数 → main 函数。
  • 多个 go 文件都有 init 函数时,执行顺序为:先执行所导入的模块的 init 函数,再执行本文件的 init 函数。

函数参数详解

形式参数与实际参数

在函数声明的地方,参数列表中的参数被称为形式参数,简称形参;而在函数调用的时候所传递的参数被称为实际参数,简称实参。举例说明:

func main() {
    sum := Add(1, 2)
    println(sum) // 3
}
func Add(num1 int, num2 int) int {
    var sum int
    sum += num1
    sum += num2
    return sum
}

Add 后面的参数被称为形参,而在 main 方法里,12 被称为实参。

值传递

基本数据类型和数组作为实参时,默认是按 值传递,即进行值拷贝,在函数内修改它们的值,原来的值不会改变。举例说明:

func main() {
    num1, num2 := 1, 2
    Swap(1, 2)
    fmt.Printf("main 函数体内打印:num1: %d, num2: %d", num1, num2)
}

func Swap(num1 int, num2 int) {
    num2, num1 = num1, num2
    fmt.Printf("Swap 函数体内打印:num1: %d, num2: %d\n", num1, num2)
}

执行结果:

Swap 函数体内打印:num1: 2, num2: 1
main 函数体内打印:num1: 1, num2: 2

Swap 函数内,num1num2 的值已经相互交换,但是在 main 函数里,num1num2 的值没有发生变化。

func main() {
    nums := [3]int{0, 1, 2}
    Swap(nums)
    fmt.Println("main 函数体内打印:nums: ", nums)
}

func Swap(nums [3]int) {
    nums[0] = 1
    fmt.Println("Swap 函数体内打印:nums: ", nums)
}

同样传递数组,在函数内修改数组的值,原数组的值并不会改变。 前面的文章有对指针进行了介绍,指出了通过 * 操作符,可以对指针所指向的变量的值进行修改,因此如果我们想要在函数内改变外部传过来的参数的值,函数声明时,形参类型指定为指针类型。

func main() {
    num1, num2 := 1, 2
    Swap(&num1, &num2)
    fmt.Printf("main 函数体内打印:num1: %d, num2: %d", num1, num2)
}

func Swap(num1 *int, num2 *int) {
    *num2, *num1 = *num1, *num2
    fmt.Printf("Swap 函数体内打印:num1: %d, num2: %d\n", *num1, *num2)
}

执行结果:

Swap 函数体内打印:num1: 2, num2: 1
main 函数体内打印:num1: 2, num2: 1

通过结果可知,使用指针变量作为形参,在函数里是可以改变外部的参数的值的。

函数是一种数据类型

Go 里面,函数是一种数据类型,因此函数还可以有很多用法,如创建一个函数变量、将函数作为函数的形参,将函数作为函数的返回值等。

创建函数变量

func main() {
    // 创建函数变量
    hl := Hello
    fmt.Printf("%T\n", hl) // func(string)
    hl("cmy")
}

func Hello(name string) {
    fmt.Printf("Hello %s", name)
}

创建一个函数变量 hl,打印 hl 的类型 → func(string),通过 hl 变量调用函数。

作为函数的形参

import "fmt"

func main() {
    Print("cmy", Hello)
}

func Hello(name string) {
    fmt.Printf("Hello %s", name)
}

func Print(name string, f func(string)) {
    f(name)
}

定义函数 Print ,声明两个参数,一个参数是 name,为 string 类型的,另一个参数是 f,为函数类型。传入 cmyHello 函数,由 Print 函数去执行 Hello 函数。

作为函数的返回值

import "fmt"

func main() {
    f := Print()
    f()
}

func Print() func() {
    return func() {
	fmt.Println("Hello,World!")
    }
}

通过Print 函数返回一个匿名函数函数,这个匿名函数的功能是输出 Hello,World!,使用 f 变量接收这个函数并调用。

基于函数自定义类型

type AddHandleFunc func(num1, num2 int) int

func main() {
    sum := GetSum(1, 2, Add)
    println(sum)
}

func Add(num1, num2 int) int {
    return num1 + num2
}

func GetSum(num1, num2 int, handleFunc AddHandleFunc) int {
    return handleFunc(num1, num2)
}

基于函数 func(num1, num2 int) int 自定义一个类型 AddHandleFunc,将它声明为 GetSum 的形参,然后调用 GetSum 时,因为 Add 函数和 AddHandleFunc 是等价的,因此可以将 Add 当做实参传进去。

小结

本文对函数的声明进行介绍,根据一个案例了解了其组成的5部分。然后介绍了其一些特点如支持变长参数、传递参数时,实参按值传递等,最后根据函数在Go中是一种数据类型的特点,说明了其一些特别用法。

以上就是一文带你熟悉Go语言中函数的使用的详细内容,更多关于Go语言函数的资料请关注我们其它相关文章!

(0)

相关推荐

  • Go语言编程通过dwarf获取内联函数

    目录 dwarf组成 如何将 addr 转换为行号 内联函数 如何展开内联函数 使用 parca 展开内联函数 parca 输出有以下问题 dwarf组成 dwarf 由 The Debugging Information Entry . type Entry struct { Offset Offset Tag Tag // 描述其类型 Children bool Field []Field // 包含的字段 } 不同的 entry 有不同的类型: tag compile unit, 在 go

  • GO语言函数(func)的声明与使用详解

    GO语言函数介绍 GO是编译性语言,所以函数的顺序是无关紧要的,为了方便阅读,建议入口函数main写在最前面,其余函数按照功能需要进行排列 GO的函数不支持嵌套,重载和默认参数GO的函数支持 无需声明变量,可变长度,多返回值,匿名,闭包等GO的函数用func来声明,且左大括号{不能另起一行 一个简单的示例: package main import "fmt" func main(){ fmt.Println("调用函数前...") hello() fmt.Print

  • golang中的defer函数理解

    目录 golang的defer 什么是defer 理解defer defer什么时间执行(defer. return.返回值 三者的执行顺序) defer输出的值,就是定义时的值.而不是defer真正执行时的变量值(注意引用情况) 多个defer,执行顺序 defer的函数一定会执行么? panic情况 os.Exit情况 kill情况(Ctrl+C) 参考文献 golang的defer 什么是defer defer的的官方文档:https://golang.org/ref/spec#Defer

  • go语言编程实现递归函数示例详解

    目录 前言 函数中的 return 递归的问题 总结 前言 本篇文章主要是记录一下在 GScript 中实现递归调用时所遇到的坑,类似的问题在中文互联网上我几乎没有找到相关的内容,所以还是很有必要记录一下. 在开始之前还是简单介绍下本次更新的 GScript v0.0.9 所包含的内容: 支持可变参数 优化 append 函数语义 优化编译错误信息 最后一个就是支持递归调用 先看第一个可变参数: //formats according to a format specifier and writ

  • Go语言入门之函数的定义与使用

    目录 1.前言 2.函数声明 2.1 函数例子 2.2 Go 函数支持多返回值 2.3 变量函数 2.4 闭包 2.5 递归 3.总结 1.前言 函数是一段代码的片段,包含连续的执行语句,它可以将零个或多个输入参数映射到零个或多个参数输出.函数像一个黑盒,对它的使用者隐藏实现细节.还可以在代码中通过函数调用来执行它们. 学到现在,我们使用的 Go 函数只有 main 函数: func main() { } 2.函数声明 每个函数都包含 func 关键字.函数名.输入参数列表.一个可选的返回列表以

  • Go编译原理之函数内联

    目录 前言 函数内联概述 函数内联底层实现 visitBottomUp caninl inlcalls 前言 在前一篇文章中分享了编译器优化的变量捕获部分,本文分享编译器优化的另一个内容—函数内联.函数内联是指将将较小的函数内容,直接放入到调用者函数中,从而减少函数调用的开销 函数内联概述 我们知道每一个高级编程语言的函数调用,成本都是在与需要为它分配栈内存来存储参数.返回值.局部变量等等,Go的函数调用的成本在于参数与返回值栈复制.较小的栈寄存器开销以及函数序言部分的检查栈扩容(Go语言中的栈

  • 一文带你轻松学会Go语言动态调用函数

    目录 前言 JavaScript 动态调用函数 Go 中动态调用方法 前言 经常在开发的时候会遇到这样的场景,几个模块的都有相同的方法,但会因为不同的类型的需要调用不同模块的方法.使用一个 switch 可以很方便的解决问题.但是当你遇到的场景是几个模块的方法都是需要的执行,同时它需要在不同的配置下执行相对应的方法. func m1(){} func m2(){} func m3(){} c := cron.New(cron.WithSeconds()) c.addFunc(config1,fu

  • 一文带你熟悉Go语言中函数的使用

    目录 函数 函数的声明 Go 函数支持变长参数 匿名函数 闭包 init 函数 函数参数详解 形式参数与实际参数 值传递 函数是一种数据类型 小结 函数 函数的英文单词是 Function,这个单词还有着功能的意思.在 Go 语言中,函数是实现某一特定功能的代码块.函数代表着某个功能,可以在同一个地方多次使用,也可以在不同地方使用.因此使用函数,可以提高代码的复用性,减少代码的冗余. 函数的声明 通过案例了解函数的声明有哪几部分: 定义一个函数,实现两个数相加的功能,并将相加之后的结果返回. f

  • 一文带你熟悉Go语言中的分支结构

    目录 分支结构 if 单分支 if 双分支 if-else 多分支 if - else if - else 在 if 语句中声明变量 switch 示例 switch 分支当 if 分支使用 在 switch 语句中声明变量 fallthrough 小结 分支结构 分支结构是结构化程序设计中的基础.针对分支结构,Go 提供了两种语句形式,一种是 if,另一种是 switch. if if 语句是 Go 中最常用.最简单的分支控制结构,它分为单分支.双分支以及多分支三种用法.if 语句会根据布尔变

  • 一文带你了解Go语言中方法的调用

    目录 前言 方法 方法的调用 Receiver 参数类型的选择 方法的约束 小结 前言 在前面的 一文熟悉 Go 函数 文章中,介绍了 Go 函数的声明,函数的几种形式如匿名函数.闭包.基于函数的自定义类型和函数参数详解等,而本文将对方法进行介绍,方法的本质就是函数,介绍方法的同时也会顺带对比其与函数的不同之处. 方法 在 Go 中,我们可以为任何的数据类型定义方法(指针或接口除外),现在让我们看一看方法的声明和组成部分以及与函数有什么不同之处. type Person struct { age

  • 一文带你了解Go语言中的单元测试

    目录 基本概念 示例一:取整函数基本测试 示例二:Fail()函数 示例三:FailNow函数 实例四:Log和Fetal函数 基本概念 上一节提到,代码完成的标准之一还包含了单元测试,这部分也是很多开发流程中不规范的地方.写过单元测试的开发人员应该理解,单元测试最核心的价值是为了证明:为什么我写的代码是正确的?也就是从逻辑角度帮你检查你的代码.但是另外一方面,如果从单元测试覆盖率角度来看,单元测试也是非常耗时的,几乎是三倍于你代码的开发时间,所以在很多迭代速度非常快的项目中,单元测试就几乎没人

  • 一文带你入门Go语言中定时任务库Cron的使用

    目录 前言 快速开始 安装 导入 Demo Cron表达式格式 标准格式 预定义时间表 常用的方法介绍 new() AddJob() AddFunc() Start() 相关推荐 Go第三方库之cronexpr——解析 crontab 表达式 总结 前言 在平时的开发需求中,我们经常会有一些重复执行的操作需要触发执行,和系统约个时间,在几点几分几秒或者每隔几分钟跑一个任务,说白了就是定时任务,,想必大家第一反应都是linux的Crontab.其实定时任务不止使用系统自带的Crontab,在Go语

  • 一文带你了解Go语言中的类型断言和类型转换

    目录 类型断言 类型判断 为什么需要断言 类型转换 什么时候使用类型转换 类型为什么称为转换 类型结论 在Go中,类型断言和类型转换是一个令人困惑的事情,他们似乎都在做同样的事情. 下面是一个类型断言的例子: var greeting interface{} = "hello world" greetingStr := greeting.(string) 接着看一个类型转换的例子: greeting := []byte("hello world") greeting

  • 一文带你了解Go语言中的指针和结构体

    目录 前言 指针 指针的定义 获取和修改指针所指向变量的值 结构体 结构体定义 结构体的创建方式 小结 前言 前面的两篇文章对 Go 语言的基础语法和基本数据类型以及几个复合数据类型进行介绍,本文将对 Go 里面的指针和结构体进行介绍,也为后续文章做铺垫. 指针 在 Go 语言中,指针可以简单理解是一个地址,指针类型是依托于某一个类型而存在的,例如 Go 里面的基本数据类型 int.float64.string 等,它们所对应的指针类型为 *int.*float64.*string等. 指针的定

  • 一文带你了解Go语言中接口的使用

    目录 接口 接口的实现 接口类型变量 空接口 类型断言 类型断言变种 type switch 小结 接口 在 Go 语言中,接口是一种抽象的类型,是一组方法的集合.接口存在的目的是定义规范,而规范的细节由其他对象去实现.我们来看一个例子: import "fmt" type Person struct { Name string } func main() { person := Person{Name: "cmy"} fmt.Println(person) //

  • 一文带你掌握Go语言中的文件读取操作

    目录 os 包 和 bufio 包 os.Open 与 os.OpenFile 以及 File.Read 读取文件操作 bufio.NewReader 和 Reader.ReadString 读取文件操作 小结 os 包 和 bufio 包 Go 标准库的 os 包,为我们提供很多操作文件的函数,如 Open(name) 打开文件.Create(name) 创建文件等函数,与之对应的是 bufio 包,os 包是直接对磁盘进行操作的,而 bufio 包则是带有缓冲的操作,不用每次都去操作磁盘.

  • 一文带你了解C语言中的动态内存管理函数

    目录 1.什么是动态内存管理 2.为什么要有动态内存管理 3.如何进行动态内存管理 3.1 malloc 3.2 free 3.3 calloc 3.4 realloc 总结 1.什么是动态内存管理 平时我们写代码,一种非常常见的写法是: int a = 0; // 创建一个变量 int arr[10] = {0}; // 创建一个数组 当你创建变量a的时候,其实是向内存中申请了4个字节的空间来存放一个整数.而当你创建数组arr的时候,是向内存中申请了40个字节的空间来存放10个整数.当你这么写

随机推荐