Golang学习Day2

最新推荐文章于 2024-11-01 15:45:46 发布
最新推荐文章于 2024-11-01 15:45:46 发布
阅读量421 收藏
点赞数
分类专栏： Golang 文章标签： golang 学习 开发语言 网络安全 安全 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44770698/article/details/129198939
版权
本文介绍了Go语言中的函数特性，包括普通函数、匿名函数和方法，强调了函数不能重载和不能嵌套但可以嵌套匿名函数的特点。还讲解了函数作为值、参数及返回值的用法，以及函数调用时参数的拷贝。此外，文中还讨论了Go中的返回值处理，函数参数的传址行为，变长参数，以及`type`关键字的作用。最后，文章涵盖了高阶函数、闭包、递归和`defer`语句的使用，以及`init`函数的初始化功能。
摘要由CSDN通过智能技术生成

Go语言中的函数

go语言中函数特性

  1. go语言有三种函数：普通函数、匿名函数（没有名称的函数）方法（定义在struct上的函数）。receiver

  1. go语言中不运算函数重载（overload），也就是说不允许函数同名

  1. go语言中的函数不能嵌套，但是可以嵌套匿名函数

  1. 函数是一个值，可以将函数赋值给变量，使得这个变量也成为函数

  1. 函数可以作为参数传递给另一个函数

  1. 函数的返回值可以是另一个函数

  1. 函数调用的时候，如果有参数传递给函数，则先拷贝参数的副本，再将副本传递给函数

  1. 函数参数可以没有名称

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

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

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

package main

import "fmt"

func sum(a int, b int) (res int) {
    res = a + b
    return res
}
func main() {
    res := sum(1, 2)
    fmt.Printf("res: %v\n", res)
}
package main

import "fmt"

func compare(a int, b int) (max int) {
    if a > b {
        max = a
    } else {
        max = b
    }
    return max
}
func main() {
    res := compare(1, 2)
    fmt.Printf("res: %v\n", res)
}

go语言中的return

  1. 没有返回值

  1. 有一个返回值 （例如上面的求和以及比较两个数的大小的函数）

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

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

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

package main

import "fmt"

func test() {
    fmt.Print("testing...")
}
func main() {
    test()
}
package main

import "fmt"

func test() (string, int) {
    name := "Y4y17"
    age := 24
    return name, age
}
func main() {
    name, age := test()
    fmt.Printf("name: %v\n", name)
    fmt.Printf("age: %v\n", age)
}
package main

import "fmt"

func test() (name string, age int) {
    name = "Y4y17"
    age = 24
    return		//相当于return name,age
}
func main() {
    name, age := test()
    fmt.Printf("name: %v\n", name)
    fmt.Printf("age: %v\n", age)
}
package main

import "fmt"

func test() (name string, age int) {
    n := "Y4y17"	//重新定义了n和a，那么返回的时候只能返回n和a，而不是name和age
    a := 24			//这种情况一般不这样写，一般就是直接去掉返回值中的name和age，只保留类型
    return n, a
}
func main() {
    name, age := test()
    fmt.Printf("name: %v\n", name)
    fmt.Printf("age: %v\n", age)
}

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

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

  1. 当函数有多个返回值的时候，如果其中某个或者是某几个返回值不想用，可以通过下划线_来丢弃这些返回值。

函数的参数

package main

import "fmt"

func test(a int) {
    a = 200	//test函数中修改变量a的值为200
}
func main() {
    a := 5	//定义变量a的值为5
    test(a)
    fmt.Printf("a: %v\n", a)//输出a的值，依然还是5
}

数组、切片、指针都是传地址，也就是传址的方式；

package main

import "fmt"

func test(s []int) {
    s[2] = 17
}
func main() {
    s := []int{1, 2, 3, 4}
    test(s)
    fmt.Printf("s: %v\n", s)//输出的结果为s: [1 2 17 4]
}

变长参数

package main

import "fmt"
//其实就像是传递了一个数组或者是切片
func test(args ...int) {
    for _, v := range args {
        fmt.Printf("v: %v\n", v)
    }
}
func main() {
    test(1, 2, 3, 4, 5, 6, 7)
}
package main

import "fmt"

func test(name string, b bool, args ...int) {
    fmt.Printf("name: %v\n", name)
    fmt.Printf("b: %v\n", b)
    for _, v := range args {
        fmt.Printf("v: %v\n", v)
    }
}
func main() {
    test("Y4y17", true, 1, 2, 3, 4, 5, 6, 7)
}

函数中的type关键字

相当于在c语言中的typedef关键字，说白了就是对现有的数据类型起了一个别名

package main

import "fmt"

func add(a int, b int) int {
    return a + b
}
func comp(a int, b int) int {
    if a > b {
        return a
    } else {
        return b
    }
}
func main() {
    type f func(a int, b int) int
    ff := add
    r := ff(1, 2)
    fmt.Printf("r: %v\n", r)
    ff = comp
    r = ff(1, 2)
    fmt.Printf("r: %v\n", r)
}

Go高阶函数

  1. 函数作为参数

package main

import "fmt"

func test(name string, f func(string)) {	
    f(name)
}
func sayHello(name string) {
    fmt.Printf("Hello: %v\n", name)
}
func main() {
    test("Y4y17", sayHello)
}

//test函数接受两个参数，分别是string类型的name和func（函数类型）的f（函数名）

sayHello函数接受一个参数，即string类型的name，主函数中调用test函数，传递参数Y4y17,和sayHello函数名；那么test函数中便会执行sayHello("Y4y17")

  1. 函数作为返回值

package main

import "fmt"

func add(a int, b int) int {
    return a + b
}
func sub(a int, b int) int {
    return a - b
}
func test(operate string) func(int, int) int {
    //test函数接受一个string类型的参数operate，test函数返回值是一个函数，该函数有两个int类型的参数并且返回值也是int类型
    
    switch operate {
    case "+":
        //当operate是+的时候，返回add方法
        return add
    case "-"://当operate是-的时候，返回sub方法
        return sub
    default:
        return nil
    }
}

func main() {
    f := test("-")
    res := f(1, 2)
    fmt.Printf("res: %v\n", res)
}

匿名函数

前面提到了在函数中是不允许嵌套函数的，但是我们可以使用匿名函数，来实现一些简单的功能：

package main

import "fmt"

func main() {
    //匿名函数和普通函数的区别其实就是没有了函数的名字，当在一个函数中不写函数名的时候就是匿名函数
    max := func(a int, b int) int {
        if a > b {
            return a
        } else {
            return b
        }
    }(1, 2)	//直接在最后面加上()以及实参的时候，就是自己调用自己
	//r := max(3, 8)	
	//fmt.Printf("r: %v\n", r)
	fmt.Printf("max: %v\n", max)
}

Golang闭包

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

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

package main

import "fmt"

//定义一个函数名为test，该函数返回值是一个函数，这个函数有一个int类型的参数 并且他返回值是一个int类型的数
func test() func(int) int {
    var x int
    return func(i int) int {
        x += i
        return x
    }
}
func main() {
    f := test()
    //f赋值为test的返回值，就是返回的函数，初始x为0
    fmt.Printf("f(10): %v\n", f(10))	//计算0+10=>10 这里x就变成了10 而不是0
    fmt.Printf("f(20): %v\n", f(20))	//计算10+20=>30 这里x就变成了30 而不是10
    fmt.Printf("f(30): %v\n", f(30))	//计算30+30=>60 这里x就变成了60 而不是30
}

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

package main

import (
    "fmt"
    "strings"
)

func makeSuffixFunc(suffic string) func(string) string {
    return func(name string) string {
        //这里的strings.HasSuff(name.suffic)表示判断name是否以suffic结尾
        //如果是返回true，否则false	需要导包strings
        if !strings.HasSuffix(name, suffic) {
            return name + suffic
        } else {
            return name
        }
    }
}
func main() {
    f := makeSuffixFunc("World")
    str := f("Hello")
    fmt.Printf("str: %v\n", str)
}
package main

import "fmt"

func cal(base int) (func(int) int, func(int) int) {
    add := func(a int) int {
        base += a
        return base
    }
    sub := func(a int) int {
        base -= a
        return base
    }
    return add, sub
}
func main() {
    add, sub := cal(10)
    res := add(10)
    fmt.Printf("res: %v\n", res)
    res = sub(5)
    fmt.Printf("res: %v\n", res)
}

定义了cal函数，cal函数存在一个形参base，cal函数返回值存在两个，并且这两个都是函数，之后在cal函数中定义两个匿名的函数分别赋值给add 和 sub，最终cal函数返回这两个匿名函数，之后在main函数中，令add sub为cal(10) ,其中base就是10 之后执行res=add(10)，而这个10是匿名函数的形参a=10，执行base+=a故base=20

base的值会存储下来，之后res = sub(5)，此时sub函数中的形参a就是5，再次执行base-=a，故得到base=15

Go语言中的递归函数

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

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

  1. 递归就是自己调用自己

  1. 必须先定义函数的退出条件，没有退出条件，递归将成为死循环

  1. go语言递归函数很可能会产生一大堆的goroutine，也很可能会出现占空间内存溢出的问题

package main

import "fmt"

//数的阶乘
func fc(n int) int {
    if n <= 1 {
        return 1
    } else {
        res := n * fc(n-1)
        return res
    }
}
func main() {
    res := fc(5)
    fmt.Printf("res: %v\n", res)
}
package main

import "fmt"
//f(n)=f(n-1)+f(n-2) f(2)==f(1)==1
func fb(n int) int {
    if n <= 2 {
        return 1
    } else {
        res := fb(n-1) + fb(n-2)
        return res
    }
}
func main() {
    fmt.Printf("fb(3): %v\n", fb(3))
}

Go语言中的defer语句

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

package main

import "fmt"

func main() {
    fmt.Printf("start...\n")
    defer fmt.Printf("stop1...\n")
    defer fmt.Printf("stop2...\n")
    defer fmt.Printf("stop3...\n")
    fmt.Printf("END...\n")
}

输出结果如下：

Go语言中的init函数

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

init函数额主要特点

  1. init函数先于main函数自动执行，不能被其他函数调用

  1. init函数没有输入参数、返回值

  1. 每个包可以有多个init函数

  1. 包的每个源文件也可以有多个init函数，这点比较特殊

  1. 同一个包的init执行顺序，golang没有明确的定义；

  1. 不同包的init函数按照包导入的依赖关系决定执行顺序

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

package main

import "fmt"

var i int = initVar()

func initVar() int {
    fmt.Printf("initvar...\n")
    return 100
}
func init() {
    fmt.Printf("init2...\n")
}
func init() {
    fmt.Printf("init...\n")
}
func main() {
    fmt.Printf("start...\n")
}

输出结果为：

同时存在多个init()的时候，遵循自上而下的执行顺序

Y4y17
关注
专栏目录
Golang学习笔记
技术宇宙
01-05 2051
目录特点天然并发函数可以返回多个值开发目录结构Golang 执行流程分析参考 特点 Go 语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发维护的高效率动态语言开发维护的高效率 使用一个表达式来形容 Go 语言：Go = C + Python 说明 Go 语言既有 C 静态语言程序的运行速度，又能达到 Python 动态语言的快速开发 天然并发 从语言层面支持并发，实现简单 goroutine，轻量级线程，可实现大并发处理，高效利用多核 基于 CSP 并发模型(Communicating S
Golang学习 Day_09
qq_52423136的博客
03-10 115
Golang学习 Day_09 map,面向“对象”编程，结构体，方法 “如果你无力去做那种惊天动地的大事，那就满怀热情地做好眼前的小事”
Golang学习 Day_11
qq_52423136的博客
03-12 118
Golang学习Day_11
Golang学习 Day_12
qq_52423136的博客
03-13 219
Golang学习 Day_12
Golang学习 Day_05
qq_52423136的博客
03-06 84
Golang学习 Day_05
Golang学习Day1
weixin_44770698的博客
02-23 679
Go语言入门Day1
Golang学习Day3
weixin_44770698的博客
02-25 659
Golang学习Day3
Golang学习 Day_16 Gin框架
qq_52423136的博客
03-20 123
Golang学习 Day_16 Gin框架
golang--学习day02
sky21sjwzk的博客
03-28 119
局部变量:函数内部声明/定义的变量叫局部变量，作用域仅限于函数内部全局变量: 函数外部声明/定义的变量叫全局变量，可以在整个包甚至外部包(导出)中使用。使用场景就是只要换行就结束。特别重要:形式参数只在函数调用时才会生效函数调用结束后就会被销毁，在函数未被调用时，函数的形参并不占用实际的存储单元，也没有实际值。注意点:局部变量不是一直存在的，它只在定义它的函数被调用后存在，函数调用结束后这个局部变量就会被销毁。在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。
golang学习笔记
luo0617的博客
12-04 692
Println 打印内容会换行Print 打印内容不会换行Printf 打印可以使用%v占位符动态展示数据var声明可用作全局，可先声明不赋值，但需要规定类型。也可声明赋值，同时声明多个类型使用（）包裹:= 局部声明，该方法只适用于局部变量赋值，不允许全局使用。_为匿名变量，不需要接受的内容用_,它不会分配内存，也不会存在重复声明变量问题。const 声明 定义就要赋值 不能改变同时赋值多个 const ( ) 括号包住iota配合const使用， 可出现自增情况。
Golang-100-Days:Golang - 100天从新手到大师
04-21
最近有很多小伙伴都在寻找go语言完整学习资料，但是录制视频和教程都需要不少的时间，平时也在筹备Go语言学科的事情，所以时间上比较紧张，我和Davie老师分别负责一部分Golang内容的产出。从技术文章，到视频，到...
日常学习总结golang(day1)---数组、切片、指针
lili9415的博客
03-24 267
对于go语言的语法还是简单易懂的，不过还是要多看看，加深一下印象。而只学基本语法是根本无法满足开发的需求的。最近跟着视频学习，除了基本语法还有并发、中间件、日志库、互联网协议、Mysql、redis、gin、docker等等。为了以后自己复习方便，看完后进行一些总结。有需要的同学也可以看一下！ 1. for…range(键值循环) Go语言中可以使用for...range遍历数组、切片、字符串、...
Golang学习，指针，循环控制相关
weixin_44048140的博客
04-19 958
这里总结的Golang 笔记只适合有点编程基础的人看，比如Java ==补充：==语言规范，由26个英文字符，0-9，_去做命名的，且不能以数字开头，严格区分大小写，不能出现空格。（这里需要注意的是_不能单独作为变量名去使用，单独的情况下只能作为占位符去使用）。 eg：fmt下面的这个库函数使用 func main() { var a int b,_ := fmt.Scanf("%d", &a) fmt.Println("a的值： ", a, "b的值： ", b) } // 打印的结.
Go语言学习笔记—golang标准库time包
qq_39280718的博客
07-14 927
time包提供测量和显示时间的功能。
青少年编程与数学 02-003 Go语言网络编程 02课题、网络分层模型
最新发布
明月看潮生的博客
11-01 838
本课题介绍了网络分层模型，包括OSI七层模型和TCP/IP四层模型，每层的功能和作用。OSI模型包括物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。TCP/IP模型简化为链路层、网络层、传输层和应用层。分层模型的优点包括模块化、灵活性、易于理解和维护以及促进标准化。网络分层模型对网络编程具有重要意义，提供了清晰的框架和指导原则，帮助开发者高效、系统地开发网络应用。
golang有序map
ophlr
10-31 416
go语言如何使用有序map
【Golang】Gin框架中如何使用JWT来实现登录认证
景天科技苑
11-01 1885
JWT: JSON Web Token，是一种用于身份验证和授权的开放标准，JWT可以在网络应用间安全的传输。JWT由三个部分组成:头部(Header)、载荷(Payload)和签名(Signature) JWT具有可扩展性、简单、轻量级、跨语言等优点，是前后端分离框架中最常用的验证方式。
15分钟学 Go 第 26 天：基本的Web服务
weixin_40780178的博客
10-29 1108
Go语言内置的net/http包使得构建Web服务变得迅速且简单。我们可以通过少量的代码实现一个功能齐全的HTTP服务器。响应HTTP GET请求显示简单的文本消息可以在浏览器中访问HTTP（超文本传输协议）是用于在Web上传输数据的协议。它使用请求-响应模型，客户端发送请求，服务器返回响应。常见的HTTP方法包括GET、POST、PUT和DELETE。在这一节中，你学习了如何使用Go构建一个简单的HTTP服务器。你掌握了基本的HTTP请求处理，如何定义路由，并能够处理GET和POST请求。
Go语言中的切片与集合操作：乐趣无穷的编程之旅（八）
weixin_43215013的博客
10-29 770
深入探讨了Go语言中的切片和映射，了解了它们的定义、操作及在函数中的传递方式。切片的动态特性让数据管理变得轻松，而映射则提供了高效的键值查找方式。 作为开发者，理解这些数据结构能够帮助你更有效地处理数据，提升编程效率。无论是在开发应用程序、处理数据，还是构建复杂系统，掌握切片和映射都能让你如鱼得水
Golang学习案例代码集锦分享
资源摘要信息:"本资源是一份关于Go语言（又称Golang）的学习案例代码分享，适用于对Go语言感兴趣的初学者和中级开发者。该资源以压缩包的形式存在，文件名标示为'PGJ.zip'，意在提供一系列实用的代码示例，以帮助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Y4y17

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

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

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

打赏作者

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

抵扣说明：

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

余额充值