golang函数总结

最新推荐文章于 2024-01-10 18:39:41 发布
最新推荐文章于 2024-01-10 18:39:41 发布
阅读量712 收藏 2
点赞数
文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/geek99_guo/article/details/121799470
版权

golang 函数

本文视频教程：https://www.bilibili.com/video/BV1zR4y1t7Wj?from=search&seid=16274857202889440267&spm_id_from=333.337.0.0

关注公众号，领取课程资料及源码

file

golang函数简介

函数的go语言中的一级公民，我们把所有的功能单元都定义在函数中，可以重复使用。函数包含函数的名称、参数列表和返回值类型，这些构成了函数的签名（signature）。

go语言中函数特性

  1. go语言中有3种函数：普通函数、匿名函数(没有名称的函数)、方法(定义在struct上的函数)。receiver
  2. go语言中不允许函数重载(overload)，也就是说不允许函数同名。
  3. go语言中的函数不能嵌套函数，但可以嵌套匿名函数。
  4. 函数是一个值，可以将函数赋值给变量，使得这个变量也成为函数。
  5. 函数可以作为参数传递给另一个函数。
  6. 函数的返回值可以是一个函数。
  7. 函数调用的时候，如果有参数传递给函数，则先拷贝参数的副本，再将副本传递给函数。
  8. 函数参数可以没有名称。

go语言中函数的定义和调用

函数在使用之前必须先定义，可以调用函数来完成某个任务。函数可以重复调用，从而达到代码重用。

go语言函数定义语法

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

语法解析：

  • func：函数由 func 开始声明
  • function_name：函数名称，函数名和参数列表一起构成了函数签名。
  • [parameter list]：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
  • return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
  • 函数体：函数定义的代码集合。

go语言函数定义实例

定义一个求和函数

func sum(a int, b int) (ret int) {
    ret = a + b
    return ret
}

定义一个比较两个数大小的函数

func compare(a int, b int) (max int) {
    if a > b {
        max = a
    } else {
        max = b
    }
    return max
}

go语言函数调用

当我们要完成某个任务时，可以调用函数来完成。调用函数要传递参数，如何有返回值可以获得返回值。

func main() {
    s := sum(1, 2)
    fmt.Printf("s: %v\n", s)

    max := compare(1, 2)
    fmt.Printf("max: %v\n", max)
}

运行结果

s: 3
max: 2

golang函数的返回值

函数可以有0或多个返回值，返回值需要指定数据类型，返回值通过return关键字来指定。

return可以有参数，也可以没有参数，这些返回值可以有名称，也可以没有名称。go中的函数可以有多个返回值。

  1. return关键字中指定了参数时，返回值可以不用名称。如果return省略参数，则返回值部分必须带名称
  2. 当返回值有名称时，必须使用括号包围，逗号分隔，即使只有一个返回值
  3. 但即使返回值命名了，return中也可以强制指定其它返回值的名称，也就是说return的优先级更高
  4. 命名的返回值是预先声明好的，在函数内部可以直接使用，无需再次声明。命名返回值的名称不能和函数参数名称相同，否则报错提示变量重复定义
  5. return中可以有表达式，但不能出现赋值表达式，这和其它语言可能有所不同。例如return a+b是正确的，但return c=a+b是错误的。

go语言函数返回值实例

没有返回值

func f1() {
    fmt.Printf("我没有返回值，只是进行一些计算")
}

有一个返回值

func sum(a int, b int) (ret int) {
    ret = a + b
    return ret
}

多个返回值，且在return中指定返回的内容

func f2() (name string, age int) {
    name = "老郭"
    age = 30
    return name, age
}

多个返回值，返回值名称没有被使用

func f3() (name string, age int) {
    name = "老郭"
    age = 30
    return // 等价于return name, age
}

return覆盖命名返回值，返回值名称没有被使用

func f4() (name string, age int) {
    n := "老郭"
    a := 30
    return n, a
}

Go中经常会使用其中一个返回值作为函数是否执行成功、是否有错误信息的判断条件。例如return value,exists、return value,ok、return value,err等。

当函数的返回值过多时，例如有4个以上的返回值，应该将这些返回值收集到容器中，然后以返回容器的方式去返回。例如，同类型的返回值可以放进slice中，不同类型的返回值可以放进map中。

但函数有多个返回值时，如果其中某个或某几个返回值不想使用，可以通过下划线_来丢弃这些返回值。例如下面的f1函数两个返回值，调用该函数时，丢弃了第二个返回值b，只保留了第一个返回值a赋值给了变量a。

package main

import "fmt"

func f1() (int, int) {
    return 1, 2
}
func main() {
    _, x := f1()
    fmt.Printf("x: %v\n", x)
}

运行结果

x: 2

golang函数的参数

go语言函数可以有0或多个参数，参数需要指定数据类型。

声明函数时的参数列表叫做形参，调用时传递的参数叫做实参。

go语言是通过传值的方式传参的，意味着传递给函数的是拷贝后的副本，所以函数内部访问、修改的也是这个副本。

go语言可以使用变长参数，有时候并不能确定参数的个数，可以使用变长参数，可以在函数定义语句的参数部分使用ARGS...TYPE的方式。这时会将...代表的参数全部保存到一个名为ARGS的slice中，注意这些参数的数据类型都是TYPE。

go语言函数的参数实例

go语言传参

// 形参列表
func f1(a int, b int) int {
    if a > b {
        return a
    } else {
        return b
    }
}

func main() {
    // 实参列表
    r := f1(1, 2)
    fmt.Printf("r: %v\n", r)
}

演示参数传递，按值传递

func f1(a int) {
    a = 200
    fmt.Printf("a1: %v\n", a)
}

func main() {
    a := 100
    f1(a)
    fmt.Printf("a: %v\n", a)
}

运行结果

a1: 200
a: 100

从运行结果可以看到，调用函数f1后，a的值并没有被改变，说明参数传递是拷贝了一个副本，也就是拷贝了一份新的内容进行运算。

map、slice、interface、channel这些数据类型本身就是指针类型的，所以就算是拷贝传值也是拷贝的指针，拷贝后的参数仍然指向底层数据结构，所以修改它们可能会影响外部数据结构的值。

package main

import "fmt"

func f1(a []int) {
    a[0] = 100
}

func main() {
    a := []int{1, 2}
    f1(a)
    fmt.Printf("a: %v\n", a)
}

运行结果

a: [1 2]
a: [100 2]

从运行结果发现，调用函数后，slice内容被改变了。

变长参数

package main

import "fmt"

func f1(args ...int) {
    for _, v := range args {
        fmt.Printf("v: %v\n", v)
    }
}
func f2(name string, age int, args ...int) {
    fmt.Printf("name: %v\n", name)
    fmt.Printf("age: %v\n", age)
    for _, v := range args {
        fmt.Printf("v: %v\n", v)
    }
}
func main() {
    f1(1, 2, 3)
    fmt.Println("------------")
    f1(1, 2, 3, 4, 5, 6)
    fmt.Println("------------")
    f2("tom", 20, 1, 2, 3)
}

运行结果

v: 1
v: 2
v: 3
------------
v: 1
v: 2
v: 3
v: 4
v: 5
v: 6
------------
name: tom
age: 20
v: 1
v: 2
v: 3

golang函数类型与函数变量

可以使用type关键字来定义一个函数类型，语法格式如下：

type fun func(int, int) int

上面语句定义了一个fun函数类型，它是一种函数类型，这种函数接收两个int类型的参数，并且返回一个int类型的返回值。

下面我们定义两个这样结构的两个函数，一个求和，一个比较大小：

func sum(a int, b int) int {
    return a + b
}

func max(a int, b int) int {
    if a > b {
        return a
    } else {
        return b
    }
}

下面定义一个fun函数类型，把sum和max赋值给它

package main

import "fmt"

type fun func(int, int) int

func sum(a int, b int) int {
    return a + b
}

func max(a int, b int) int {
    if a > b {
        return a
    } else {
        return b
    }
}

func main() {
    var f fun
    f = sum
    s := f(1, 2)
    fmt.Printf("s: %v\n", s)
    f = max
    m := f(3, 4)
    fmt.Printf("m: %v\n", m)
}

运行结果

s: 3
m: 4

golang高阶函数

go语言的函数，可以作为函数的参数，传递给另外一个函数，可以可以作为，另外一个函数的返回值返回。

go语言函数作为参数

package main

import "fmt"

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

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

func main() {
    f1("tom", sayHello)
}

运行结果

Hello,tom

go语言函数作为返回值

package main

import "fmt"

func add(x, y int) int {
    return x + y
}

func sub(x, y int) int {
    return x - y
}

func cal(s string) func(int, int) int {
    switch s {
    case "+":
        return add
    case "-":
        return sub
    default:
        return nil
    }
}

func main() {
    add := cal("+")
    r := add(1, 2)
    fmt.Printf("r: %v\n", r)

    fmt.Println("-----------")

    sub := cal("-")
    r = sub(100, 50)
    fmt.Printf("r: %v\n", r)
}

运行结果

r: 3
-----------
r: 50

golang匿名函数

go语言函数不能嵌套，但是在函数内部可以定义匿名函数，实现一下简单功能调用。

所谓匿名函数就是，没有名称的函数。

语法格式如下：

func (参数列表)(返回值)

当然可以既没有参数，可以没有返回值

匿名函数实例

func main() {
    max := func (a int, b int) int {
        if a > b {
            return a
        } else {
            return b
        }
    }

    i := max(1, 2)
    fmt.Printf("i: %v\n", i)
}

运行结果

i: 2

自己执行

func main() {
    // 自己执行
    func(a int, b int) {
        max := 0
        if a > b {
            max = a
        } else {
            max = b
        }
        fmt.Printf("max: %v\n", max)
    }(1, 2)
}

运行结果

max: 2

golang闭包

闭包可以理解成定义在一个函数内部的函数。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。或者说是函数和其引用环境的组合体。

闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，闭包=函数+引用环境。 首先我们来看一个例子：

package main

import "fmt"

// 返回一个函数
func add() func(int) int {
    var x int
    return func(y int) int {
        x += y
        return x
    }
}

func main() {
    var f = add()
    fmt.Println(f(10))
    fmt.Println(f(20))
    fmt.Println(f(30))
    fmt.Println("-----------")
    f1 := add()
    fmt.Println(f1(40))
    fmt.Println(f1(50))
}

运行结果

10
30
60
-----------
40
90

变量f是一个函数并且它引用了其外部作用域中的x变量，此时f就是一个闭包。 在f的生命周期内，变量x也一直有效。 闭包进阶示例1：

package main

import "fmt"

func add(x int) func(int) int {
    return func(y int) int {
        x += y
        return x
    }
}
func main() {
    var f = add(10)
    fmt.Println(f(10))
    fmt.Println(f(20))
    fmt.Println(f(30))

    fmt.Println("----------")

    f1 := add(20)
    fmt.Println(f1(40))
    fmt.Println(f1(50))
}

运行结果

20
40
70
----------
60
110

闭包进阶示例2：

func makeSuffixFunc(suffix string) func(string) string {
    return func(name string) string {
        if !strings.HasSuffix(name, suffix) {
            return name + suffix
        }
        return name
    }
}

func main() {
    jpgFunc := makeSuffixFunc(".jpg")
    txtFunc := makeSuffixFunc(".txt")
    fmt.Println(jpgFunc("test")) 
    fmt.Println(txtFunc("test")) 
}

运行结果

test.jpg
test.txt

闭包进阶示例3：

func calc(base int) (func(int) int, func(int) int) {
    add := func(i int) int {
        base += i
        return base
    }

    sub := func(i int) int {
        base -= i
        return base
    }
    return add, sub
}

func main() {
    f1, f2 := calc(10)
    fmt.Println(f1(1), f2(2)) 
    fmt.Println(f1(3), f2(4)) 
    fmt.Println(f1(5), f2(6)) 
}

运行结果

11 9
12 8
13 7

闭包其实并不复杂，只要牢记闭包=函数+引用环境。

golang递归

函数内部调用函数自身的函数称为递归函数。

使用递归函数最重要的三点：

  1. 递归就是自己调用自己。
  2. 必须先定义函数的退出条件，没有退出条件，递归将成为死循环。
  3. go语言递归函数很可能会产生一大堆的goroutine，也很可能会出现栈空间内存溢出问题。

go语言递归实例

阶乘

package main

import "fmt"

func a(n int) int {
    // 返回条件
    if n == 1 {
        return 1
    } else {
        // 自己调用自己
        return n * a(n-1)
    }
}

func main() {
    n := 5
    r := a(n)
    fmt.Printf("r: %v\n", r)
}

运行结果

r: 120

斐波那契数列

它的计算公式为f(n)=f(n-1)+f(n-2)且f(2)=f(1)=1

package main

func f(n int) int {
    // 退出点判断
    if n == 1 || n == 2 {
        return 1
    }
    // 递归表达式
    return f(n-1) + f(n-2)
}

func main() {
    r := f(5)
    fmt.Printf("r: %v\n", r)
}

运行结果

r: 5

golang defer语句

go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。stack

defer特性

  1. 关键字 defer 用于注册延迟调用。
  2. 这些调用直到 return 前才被执。因此，可以用来做资源清理。
  3. 多个defer语句，按先进后出的方式执行。
  4. defer语句中的变量，在defer声明时就决定了。

defer用途

  1. 关闭文件句柄
  2. 锁资源释放
  3. 数据库连接释放

go语言defer语句实例

查看执行顺序

func main() {
    fmt.Println("start")
    defer fmt.Println("step1")
    defer fmt.Println("step2")
    defer fmt.Println("step3")
    fmt.Println("end")
}

运行结果

start
end
step3
step2
step1

golang init函数

golang有一个特殊的函数init函数，先于main函数执行，实现包级别的一些初始化操作。

init函数的主要特点

  • init函数先于main函数自动执行，不能被其他函数调用；
  • init函数没有输入参数、返回值；
  • 每个包可以有多个init函数；
  • 包的每个源文件也可以有多个init函数，这点比较特殊；
  • 同一个包的init执行顺序，golang没有明确定义，编程时要注意程序不要依赖这个执行顺序。
  • 不同包的init函数按照包导入的依赖关系决定执行顺序。

golang 初始化顺序

初始化顺序：变量初始化->init()->main()

实例

package main

import "fmt"

var a int = initVar()

func init() {
    fmt.Println("init2")
}

func init() {
    fmt.Println("init")
}

func initVar() int {
    fmt.Println("init var...")
    return 100
}

func main() {
    fmt.Println("main...")
}

运行结果

init var...
init2
init
main...
多课网_老郭
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
通过汇编看golang函数的多返回值问题
09-16
当我们编写一个如下的Golang函数： ```go func one(a int) (int, int) { return a, a + 5 } ``` 这个函数返回两个整数。在汇编中，可以看到Golang并不直接将返回值存储在某个寄存器中，而是通过调用者提供的内存...
go语言返回值
tiancityycf的专栏
07-09 615
https://www.phpmianshi.com/?id=569
golang函数的返回值
赵凯月的博客
12-01 933
函数可以有0或多个返回值，返回值需要指定数据类型，返回值通过return关键字来指定。return可以有参数，也可以没有参数，这些返回值可以有名称，也可以没有名称。go中的函数可以有多个返回值。return关键字中指定了参数时，返回值可以不用名称。如果return省略参数，则返回值部分必须带名称当返回值有名称时，必须使用括号包围，逗号分隔，即使只有一个返回值但即使返回值命名了，return中也可以强制指定其它返回值的名称，也就是说return的优先级更高。
GO语言--返回值
最新发布
qq_51722211的博客
01-10 525
没有参数的 return 语句返回各个返回变量的当前值。这种用法被称作“裸”返回。直接返回语句仅应当用在像下面这样的短函数中。在长的函数中它们会影响代码的可读性。命名返回参数可看做与形参类似的局部变量，最后由 return 隐式返回。Go 的返回值可以被命名，并且就像在函数体开头声明的变量那样使用。命名返回参数允许 defer 延迟调用通过闭包读取和修改。命名返回参数可被同名局部变量遮蔽，此时需要显式返回。返回值的名称应当具有一定的意义，可以作为文档使用。显式 return 返回前，会先修改命名返回参数。
Golang中函数的多返回值的三种写法
weixin_51920241的博客
05-03 3237
Golang中函数的多返回值的三种写法 第一种方法 func fool(a string, b int) int { fmt.Println("fool1------------") fmt.Println("a1 = ", a) fmt.Println("b1 = ", b) c := 100 return c } 第二种方法 //返回多个返回值，形参匿名的 func fool2(a string, b int) (int, int) { fmt.Println(
Golang语言基础教程：函数的返回值
qfliweimin的博客
07-02 1543
函数的返回值 1.1 什么是函数的返回值 一个函数被调用后，返回给调用处的执行结果，叫做函数的返回值。 调用处需要使用变量接收该结果 1.2 一个函数可以返回多个值 一个函数可以没有返回值，也可以有一个返回值，也可以有返回多个值。 package main ​ import "fmt" ​ func swap(x, y string) (string, string) { return y, x } ​ func main() { a, b := swap("Mahesh", "K
golang学习路线总结
10-07
本文档旨在为读者提供一个系统的Golang学习路线总结，涵盖了Golang的基础知识、语法、流程控制、函数、指针、内置容器、常用内置包等方面的内容，旨在帮助读者快速掌握Golang语言。 基础知识 Golang是一种静态类型...
golang模板template自定义函数用法示例
09-21
在Golang中，`text/template`包提供了一个强大的模板引擎，用于生成动态文本输出，如HTML、XML或其他格式的文本文件。模板引擎允许我们定义变量和控制结构，并且可以使用自定义函数来扩展其功能。本篇文章将深入探讨...
golang 函数以及函数和方法的区别.docx
07-20
总结来说，Go 语言中的函数和方法的区别在于： 1. 函数是独立的代码块，不与任何特定类型关联。 2. 方法是与特定类型绑定的函数，有一个接收者参数。 3. 接收者可以是结构体、接口或自定义类型，甚至是基本类型。 4....
golang中strconv.ParseInt函数用法示例
09-21
在Golang中，`strconv`包提供了一系列用于字符串和基本类型之间转换的函数。其中，`ParseInt`函数是将字符串解析为整数的一个重要工具。本文将深入探讨`strconv.ParseInt`函数的用法、参数含义以及如何处理可能的...
Go语言之函数,返回值,作用域,传参,匿名函数,高阶函数,闭包函数
凯歌技术控团队
07-17 576
真正运行函数内的代码还需要对声明的函数进行调用，一个函数可以在任意位置多次调用。调用一次，即执行一次该函数内的代码。这样当然可以实现，但是是不是依然有大量重复代码，一会发现三个函数出了一个变量值不同以外其他都是相同的，所以为了能够在函数调用的时候动态传入一些值给函数，就有了参数的概念。这就涉及到了函数参数。函数每次调用可以传入不同的实际参数，传参的过程其实就是变量赋值的过程，将实际参数按位置分别赋值给形参。这样是不是就灵活很多了呢，所以基本上一个功能强大的函数都会有自己需要的参数，让整个业务实现更加灵活。
Go 函数返回值
weixin_40123451的博客
10-14 678
一个返回值 func add(a, b int) int { return a+b } 多个返回值 func add(a,b int) (int int) { return a+1,b+1 } 命名返回值 func add(a,b int) (min int) { if a>b { return b } return a }
Go/Golang函数做返回值
qq_62390970的博客
05-20 169
函数做函数的返回值。
GoLang 函数返回值
ALakers的博客
03-11 1166
看看下面几个函数返回结果都是什么： package main import "fmt" func f0() (int) { var r int defer func() { r++ }() return r } func f1() (r int) { defer func() { r++ }() return 0 } func f2() (r int) { t := 5 defer func() { t = t + 5 }() return t } func f.
GO语言————6.9 应用闭包：将函数作为返回值
Fly_鹏程万里
06-30 792
6.9 应用闭包：将函数作为返回值在程序 function_return.go 中我们将会看到函数 Add2 和 Adder 均会返回签名为 func(b int) int 的函数：func Add2() (func(b int) int) func Adder(a int) (func(b int) int)函数 Add2 不接受任何参数，但函数 Adder 接受一个 int 类型的整数作为参数...
＜Zhuuu_ZZ＞HIVE(十一)函数
Zhuuu_ZZ的博客
09-22 2105
Hive内置函数一 Hive函数分类二 字符函数二 类型转换函数和数学函数三 日期函数四 集合函数五 条件函数六 聚合函数和表生成函数6.1 聚合函数6.2 表生成函数：输出可以作为表使用 一 Hive函数分类 从输入输出角度分类 标准函数：一行数据中的一列或多列为输入，结果为单一值 聚合函数：多行的零列到多列为输入，结果为单一值 表生成函数：零个或多个输入，结果为多列或多行 从实现方式分类 内置函数 自定义函数 UDF：自定义标准函数 UDAF：自定义聚合函数 UDTF：自定义表生成函数
【GoLang】3.4 Map
你的指尖有改变世界的力量
08-23 938
学习GoLang Map类型的笔记,包含了map的定义、迭代和查询。
go语言学习笔记 — 基础 — 高级数据类型 — 函数（2）：函数的返回值
yjk13703623757的博客
10-18 1791
go语言支持多返回值，可方便地获取函数调用后的多个返回值。 go语言经常使用多返回值中的最后一个参数返回函数执行中可能发生的错误。conn, err := connectToNetwork()，上面的代码返回两个参数，conn表示连接对象，err返回错误。 下文中的”指定返回值”，仅指return后面直接跟着返回值。 1. 函数不指定返回值 package main import ( ...
Golang中协程的使用
h___q的博客
07-02 1687
原文链接： https://www.ahaoaha.top/2019/05/09/Golang中协程的使用/ 本文相关demo，请点击此处 协程与函数返回值 golang中的协程是由Go routime进行管理的，如果函数有返回值，则这个函数的返回值会被丢弃。 Golang协程的创建 使用go FUNC_NAME(PARAMETER_LIIST)可以很简单的创建出一个协程来执行相应的操作 Gola...
golang 测试函数
05-31
在 Golang 中，可以使用内置的 `testing` 包来编写单元测试代码。以下是编写测试函数的步骤： 1. 在需要测试的文件中，创建一个名为 `xxx_test.go` 的文件，其中 `xxx` 表示需要测试的文件名。 2. 在该文件中定义名...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

多课网_老郭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值