devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Go语言入门

作者：运维做开发 | 2024-07-31 22:09:21

赞

踩

Go语言入门

目录

前言——碎碎念

环境安装

配置环境变量

变量的定义

 数据类型 

 数字型

字符与字符串

数据类型转换

运算符 

算术运算符

关系运算符

逻辑运算符

位运算符（二进制）

赋值运算符 

其他运算符（指针）

键盘的输入与输出（交互）

流程控制

选择结构

循环结构

函数

函数的定义

函数的声明和调用

可变参数 

参数传递

值传递

引用传递

递归函数

延迟函数 

 函数的类型

匿名函数

回调函数

闭包

教程

前言——碎碎念

  大学时期的我一直纠结于编程语言的选择，直到我关注的一个博主 “英雄哪里出来”  他解答过这个问题。

  原话我记不清了大概意思是不管哪种语言都会有 “很厉害或者很菜的人” ，最重要的是先学好一门语言（不管哪种），然后拥有能快速入门其他语言并应用起来的能力。

最近空闲时间我就看了Go的基础语法（先简单入了个门，Go也应用于游戏服务端，万一以后会用到呢）。

环境安装

地址：Go安装包下载

下载完是一个安装包直接安装，使用安装包安装在系统变量的环境变量Path中会自动把Go环境配置好

用户变量的Path可能会自动配置到C盘，可以自己改一下

安装完成后测试 

配置环境变量

打开高级系统设置——》环境变量

在自己设置的GOPATH目录里新建三个文件夹 

打开命令行窗口查看有没有配置好

开发工具可以下载GoLand或者VSCode（我用的VSCode）

【go】一、go语言vscode开发环境_vscode 运行go-CSDN博客

变量的定义

有些变量名重复我都注释掉了，可以打开注释自己练习一下

  1. package main
  2.  
  3. import "fmt"
  4.  
  5.  
  6. //全局变量
  7. var name string = "李四"
  8.  
  9.  
  10. func main(){
  11. 	//fmt.Println("hello world!")  //输出语句
  12. 	// var name string = "www"     //定义变量  
  13. 	// var age int = 23
  14. 	// fmt.Println(name)
  15. 	// fmt.Println(age)
  16. 	// var (
  17. 	// 	name1 string
  18. 	// 	age1 int
  19. 	// 	addr string
  20. 	// )
  21. 	// fmt.Println(name1,age1,addr)
  22. 	// name1 = "111"
  23. 	// age1 = 24
  24. 	// addr = "222"
  25. 	// fmt.Println(name1,age1,addr)
  26. 	// // := 自动推导数据类型
  27. 	// name3 := "www"
  28. 	// age3 := 23
  29. 	// fmt.Println(name3,age3)
  30. 	// fmt.Printf("%T,%T",name3,age3) //打印什么类型
  31.  
  32. 	// var num int
  33. 	// num=100
  34. 	// fmt.Printf("num:%d,内存地址:%p",num,&num)  //取地址符号 &  num:100,内存地址:0xc00000a0b8
  35.  
  36. 	/*变量交换*/
  37. 	// var a int = 100
  38. 	// var b int = 200
  39.     // b,a = a,b   //a,b的值互换
  40. 	// fmt.Println(a,b)  //200 100
  41.  
  42. 	// a,b := test()
  43. 	// fmt.Println(a,b)
  44.  
  45. 	// c,_ := test()  // _(匿名变量) 当不用第二个返回值时用 _ 接收 
  46. 	// fmt.Println(c) 
  47.  
  48. 	/*局部变量*/
  49. 	// var name string = "李五"
  50. 	// fmt.Println(name)  //优先打印局部变量
  51.  
  52. 	/*常量*/
  53. 	// const URL string = "www.baidu.com"  //显示定义（明确什么类型）
  54. 	// const URL2 = "www.baidu.com"        //隐式定义（不明确类型）
  55. 	// const a,b,c = 3.14,"www",false
  56. 	/*
  57. 	  iota，特殊常量，可以认为是一个可以被编译器修改的常量。
  58. 	  iota是go语言的常量计数器iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
  59.       iota 可以被用作枚举值
  60. 	*/
  61. 	// const(
  62. 	// 	d = iota
  63. 	// 	e = iota
  64. 	// 	f = iota
  65. 	// )
  66. 	// fmt.Println(URL,URL2)
  67. 	// fmt.Println(a,b,c,d,e,f)  //3.14 www false 0 1 2
  68.  
  69. 	// const(
  70. 	// 	a = iota       //0
  71. 	// 	b              //1
  72. 	// 	c              //2
  73. 	// 	d = "hahaha"   //hahaha   iota 3
  74. 	// 	e              //hahaha   iota 4
  75. 	// 	f = 100        //100      iota 5
  76. 	// 	g              //100      iota 6
  77. 	// 	h = iota       //iota 7
  78. 	// 	i              //iota 8
  79. 	// )
  80. 	// fmt.Println(a,b,c,d,e,f,g,h,i) //0 1 2 hahaha hahaha 100 100 7 8
  81. }
  82.  
  83. func test()(int,int){
  84. 	return 100,200
  85. }

 数据类型 

 数字型

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6.    //定义一个整型
  7.    var age int = 18
  8.    fmt.Printf("%T,%d\n",age,age)
  9.  
  10.    //定义一个浮点型
  11.    //默认保留六位小数
  12.    var money float64 = 3.14
  13.    fmt.Printf("%T,%f\n",money,money)
  14.  
  15.    /*
  16.       int,18
  17.       float64,3.140000
  18.    */
  19.  
  20.    var num1 float32 = -123.0000901
  21.    var num2 float64 = -123.0000901
  22.    fmt.Println("num1 = ",num1,"num2 =",num2)
  23.    //num1 =  -123.00009 num2 = -123.0000901        float32内存空间不够精度丢失
  24. }

字符与字符串

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6.    var str string 
  7.    str = "hello,www"
  8.    fmt.Printf("%T,%s\n",str,str)
  9.  
  10.    //单引号
  11.    v1 := 'A'
  12.    v2 := "A"
  13.    fmt.Printf("%T,%s\n",v1,v1)
  14.    fmt.Printf("%T,%d\n",v1,v1)
  15.    fmt.Printf("%T,%s\n",v2,v2)
  16.  
  17.    /*
  18.       string,hello,www
  19.       int32,%!s(int32=65)
  20.       int32,65
  21.       string,A
  22.    */
  23.  
  24.    //所有的中国字的编码表： GBK
  25.    //全世界的编码表： Unicode编码表
  26.  
  27.    //字符串拼接
  28.    fmt.Println("hello" + ",www")
  29.  
  30.    //转义字符
  31.    fmt.Println("hello\",www")   //hello",www
  32. }
  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6.    
  7. 	str := "hello,www"
  8. 	fmt.Println(str)
  9.  
  10. 	// 获取字符串的长度 len
  11. 	fmt.Println("字符串的长度为：",len(str))  //字符串的长度为： 9
  12.  
  13. 	// 获取指定的字节
  14. 	fmt.Println("字节打印：",str[0])  //输出结果为104对应'h'的ascii码
  15.     fmt.Printf("%c",str[0])         //h
  16.  
  17. 	// for
  18. 	for i := 0; i < len(str); i++{
  19. 		fmt.Printf("%c",str[i]) 
  20. 	}
  21.  
  22. 	// for range 循环，遍历数组、切片...
  23. 	for i,v := range str{
  24. 		fmt.Print(i)        //i表示下标
  25. 		fmt.Printf("%c",v)  //v对应的字符
  26. 	}
  27. 	//0h1e2l3l4o5,6w7w8w
  28. }

数据类型转换

在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显示的声明。

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6.    a := 3  //int
  7.    b := 5.0 //float64
  8.    fmt.Printf("%T\n",a)
  9.    fmt.Printf("%T\n",b)
  10.  
  11.    //将int类型的a转换为 float64 类型
  12.    c := float64(a)
  13.    d := int(b)
  14.    fmt.Printf("%T\n",c)
  15. }

运算符 

算术运算符

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6. 	var a int = 10
  7. 	var b int = 3
  8. 	//var c int
  9.  
  10. 	//+ - * / % ++ --
  11. 	fmt.Println(a+b)
  12. 	fmt.Println(a-b)
  13. 	fmt.Println(a*b)
  14. 	fmt.Println(a%b)
  15. 	a++ // a = a+1
  16. 	fmt.Println(a)
  17. 	a-- // a = a-1
  18. 	fmt.Println(a)
  19. }
  20.  
  21. 13
  22. 7
  23. 30
  24. 1
  25. 11
  26. 10

关系运算符

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6. 	var a int = 11
  7. 	var b int = 10
  8.  
  9. 	//关系运算符
  10. 	fmt.Println(a==b)
  11. 	fmt.Println(a!=b)
  12. 	fmt.Println(a>b)
  13. 	fmt.Println(a<b)
  14. 	fmt.Println(a>=b)
  15. 	fmt.Println(a<=b)
  16.  
  17.     //判断if
  18.     if a>b{
  19.     
  20.     }
  21. }
  22. false
  23. true
  24. true
  25. false
  26. true
  27. false

逻辑运算符

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6. 	var a bool = true
  7. 	var b bool = false
  8.  
  9. 	// 逻辑  &&  与
  10. 	if a==true && b==true{
  11.         fmt.Println(a && b)
  12. 	}
  13. 	fmt.Println(a && b)
  14. 	// 逻辑  || 或 都为假才会返回假
  15. 	fmt.Println(a || b)
  16. 	//逻辑  ！ 非
  17. 	fmt.Println(!a)
  18. }

位运算符（二进制）

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6. 	
  7. 	// 二进制  0  1   逢二进一
  8.  
  9. 	// 位运算： 二进制上的 0 false 1 true
  10. 	// & 我和你 都为1 结果才为1
  11. 	// | 我或者你 有一个为1 结果才为1
  12. 	// ^ 不同为 1，相同为0
  13. 	// 60 二进制： 0011 1100
  14. 	// 13 二进制： 0000 1101
  15. 	//------------------------------
  16. 	//      & :   0000  1100 
  17. 	//      | :   0011  1101
  18. 	//      ^ :   0011  0001
  19. 	//      >>:   1111  0000
  20. 	 var a uint = 60
  21. 	 var b uint = 13
  22. 	 // 位运算
  23. 	 var c uint = 0
  24.  
  25. 	 c = a&b // 位运算符&
  26. 	 fmt.Println("%d,二进制%b",c,c)  //12，二进制 1100
  27.  
  28. 	 c = a|b // 位运算符|
  29. 	 fmt.Println("%d,二进制%b",c,c)  //61，二进制 111101
  30.  
  31. 	 c = a^b
  32. 	 fmt.Println("%d,二进制%b",c,c)  //49，二进制 110001
  33.  
  34. 	 c = a << 2
  35. 	 fmt.Println("%d,二进制%b",c,c)  //240 二进制 1111 0000
  36.  
  37. 	 c = a >> 2
  38. 	 fmt.Println("%d,二进制%b",c,c)  //15 二进制 0000 1111
  39. }

赋值运算符 

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6. 	var a int = 21
  7. 	var b int
  8.  
  9. 	// =赋值
  10. 	b = a  // b = 21
  11. 	fmt.Println(b)
  12.  
  13. 	// += b = a+b = 42
  14. 	b += a
  15. 	fmt.Println(b)
  16. }

其他运算符（指针）

键盘的输入与输出（交互）

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6. 	
  7. 	var x int
  8. 	var y float64
  9.  
  10. 	// 定义了两个变量，想用键盘来录入这两个变量
  11. 	// fmt.Println()  打印并换行
  12. 	// fmt.Printf()   格式化输出
  13. 	// fmt.Print()    打印输出
  14. 	// fmt.Scanln()   换行接收输入
  15. 	// fmt.Scanf()    格式化输入
  16. 	// fmt.Scan()     接收输入
  17.  
  18. 	fmt.Println("请输入两个数：1、整数，2、浮点数：")
  19.  
  20. 	// 变量取地址  &变量 通过指针地址来操作变量
  21. 	fmt.Scanln(&x,&y)  // 接收输入  Scan 
  22.     
  23. 	fmt.Scanln(&x,&y)
  24. 	fmt.Println("x:",x)
  25. 	fmt.Println("y:",y)
  26. }

流程控制

程序的流程控制结构一共有三种：顺序结构，选择结构，循环结构

顺序结构：从上到下，逐行执行。默认的逻辑

选择结构

：条件满足某些代码才会执行

  • if
  1. var a int = 15
  2. if a>20 {
  3.    fmt.Println("a>20")
  4. }
  5. else if a>10{
  6.    fmt.Println("a>10")
  7. }
  8. else{
  9.    fmt.Println("a")
  10. }
  • switch
  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6. 	var score int = 60
  7.  
  8. 	switch score {
  9. 	   case 90:
  10. 		  fmt.Println("A")
  11. 	   case 80:
  12. 		  fmt.Println("B")
  13. 	   case 50,60,70:
  14. 		  fmt.Println("C")
  15. 	   default:
  16. 	      fmt.Println("D")
  17. 	}
  18.  
  19.     switch {
  20. 	   case false:
  21. 		  fmt.Println("false")
  22. 	   case true:
  23. 		  fmt.Println("true")
  24.        default:
  25. 	      fmt.Println("其他")
  26. 	}
  27. }

fallthrough  贯穿；直通

switch 默认情况下匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough穿透case,使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6.  
  7.     a := false
  8. 	switch a {
  9. 	case false:
  10. 	   fmt.Println("false")
  11. 	   fallthrough //case穿透，不管下个条件满不满足都会执行(只判断fallthrough的下一个条件)
  12. 	case true:
  13. 	   fmt.Println("true")
  14. 	default:
  15. 	   fmt.Println("其他")
  16.    }
  17.  
  18.    //输出结果
  19.    //false
  20.    //true
  21. }
  • select

循环结构

：条件满足某些代码会被反复执行0-N次

  • for
  1. count := 5
  2. // for 条件的起始值；循环条件；控制变量自增或自减
  3. for i := 0; i < count; i++ {
  4.    fmt.Println("----",i);
  5. }
  6.  
  7.  
  8. //break 跳出整个循环
  9. //continue 跳过本次循环

打印方阵练习：

  1. count := 5
  2. for i := 0; i < count; i++ {
  3. 	for j := 0;j < count;j++{
  4. 		fmt.Print("* ")
  5. 	}
  6. 	fmt.Println()
  7. }

打印九九乘法表： 

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6.    count := 9
  7.    for i := 1; i <= count; i++ {
  8. 	   for j := 1;j <= i;j++{
  9. 		  fmt.Print(j,"*",i,"=",j*i,"  ")
  10. 	   }
  11. 	   fmt.Println()
  12.    }
  13. }

函数

函数的定义

  • 函数是基本的代码块，用于执行一个任务
  • Go语言最少有个main（）函数
  • 可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务
  • 函数声明告诉了编译器函数的名称，返回类型，和参数

函数的声明和调用

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. //func 函数名 (参数,参数...)  (返回值类型){ 函数体  return 返回结果}
  6.  
  7. func main(){
  8. 	printinfo()
  9. 	c := add(1,2)
  10. 	myprint(c)
  11. 	x,y := swap("aaa","bbb")  //不想用y可以用匿名变量只接收一个返回值  x,_ := swap("aaa","bbb")
  12. 	fmt.Println(x,y)
  13. }
  14.  
  15. //无参无返回值函数
  16. func printinfo(){
  17. 	fmt.Println("printinfo")
  18. }
  19.  
  20. //有一个参数的函数
  21. func myprint(num int){
  22. 	fmt.Println(num)
  23. }
  24.  
  25. //有两个参数一个返回值的函数
  26. func add(a,b int)(int){
  27. 	c := a+b
  28. 	return c
  29. }
  30.  
  31. //多个返回值的函数
  32. func swap(x,y string)(string,string){
  33. 	return y,x
  34. }
  35.  
  36. // max 两个数字比大小
  37. // 形式参数：定义函数时，用来接收外部传入数据的参数，就是形式参数
  38. // 实际参数：调用函数时，传给形参的实际数据叫做实际参数
  39. func max(num1,num2 int) int{
  40. 	var result int 
  41. 	if num1 > num2 {
  42. 		result = num1
  43. 	} else {
  44. 		result = num2
  45. 	}
  46.  
  47. 	//函数定义上有返回值，函数中必须有return
  48. 	return result
  49. }

可变参数 

注意事项：

  • 如果一个函数的参数是可变参数，同时还有其他的参数，可变参数要放在列表的最后
  • 一个函数的参数列表中最多只能有一个可变参数
  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6.     getSum(1,2,3,4,5,6,7)
  7. }
  8.  
  9.  
  10. // ...可变参数
  11. func getSum(nums ...int){
  12.     
  13. 	sum:=0
  14.  
  15. 	for i := 0; i < len(nums); i++ {
  16. 		fmt.Println(nums[i])
  17. 		sum += nums[i]
  18. 	}
  19.  
  20. 	fmt.Println("sum:",sum)
  21. }
  22.  
  23.  
  24. // 1
  25. // 2
  26. // 3
  27. // 4
  28. // 5
  29. // 6
  30. // 7
  31. // sum: 28

参数传递

按照数据的存储特点分：

  • 值类型的数据：操作的是数据本身、int、string、bool、float64、array...
  • 引用类型的数据：操作的是数据的地址slice、map、chan...

值传递

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6.     //值传递：传递的是数据的副本，修改数据对原始数据无影响
  7. 	//值传递类型：基础类型、array、struct(结构体)
  8. 	//定义一个数组  [个数]类型
  9. 	arr := [4]int{1,2,3,4}
  10. 	fmt.Println(arr)
  11. 	//传递：arr2的数据是复制arr来的的，arr2并不影响arr
  12. 	update(arr)
  13. 	fmt.Println("调用后的数据",arr)
  14. }
  15.  
  16. func update(arr2 [4]int){
  17.     
  18. 	fmt.Println("arr2接收的数据：",arr2)
  19. 	arr2[0] = 100
  20. 	fmt.Println("arr2修改后的数据：",arr2)
  21. }
  22.  
  23. // [1 2 3 4]
  24. // arr2接收的数据： [1 2 3 4]
  25. // arr2修改后的数据： [100 2 3 4]
  26. // 调用后的数据 [1 2 3 4]

引用传递

变量在内存中是存放在一定的地址上的，修改变量实际是修改变量地址的内存

  1. package main
  2.  
  3. import "fmt"
  4.  
  5. func main(){
  6. 	//引用传递：传递的是数据的地址，导致多个变量指向同一块内存
  7.     //切片，可以扩容的数组
  8. 	s1 := []int{1,2,3,4}
  9. 	fmt.Println("默认的数据",s1)
  10. 	update2(s1)
  11. 	fmt.Println("调用后的数据",s1)
  12. }
  13.  
  14. func update2(s2 []int){
  15.     fmt.Println("传递的数据",s2)
  16. 	s2[0] = 100
  17. 	fmt.Println("修改后的数据",s2)
  18. }
  19.  
  20. // 默认的数据 [1 2 3 4]
  21. // 传递的数据 [1 2 3 4]
  22. // 修改后的数据 [100 2 3 4]
  23. // 调用后的数据 [100 2 3 4]

递归函数

定义：一个函数自己调用自己

注意：递归函数要有一个出口，逐渐向出口靠近，没有出口就会形成死循环

  1. package main
  2.  
  3. import "fmt"
  4. //求和：1,2,3,4,5
  5. func main(){
  6. 	sum := getSum(5)
  7. 	fmt.Println(sum)
  8. }
  9.  
  10. func getSum(n int) int{
  11. 	if n == 1 {
  12.        return 1
  13. 	}
  14.     return getSum(n - 1) + n
  15. }
  16.  
  17. //15

延迟函数 

defer：推迟、延迟

在go语言中，使用defer关键字来延迟一个函数或者方法的执行

  1. package main
  2. import "fmt"
  3. func main(){
  4. 	f("1")
  5. 	fmt.Println("2")
  6. 	defer f("3") //会被延迟到最后执行
  7. 	fmt.Println("4")
  8. }
  9.  
  10. func f(s string){
  11. 	fmt.Println(s)
  12. }
  13.  
  14. // 1
  15. // 2
  16. // 4
  17. // 3

defer函数或者方法:一个函数或方法的执行被延迟了

  • 你可以在函数中添加多个defer语句，当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回，特别是当你在进行一些打开资源的操作时，遇到错误需要提前返回，在返回前你需要关闭相应的资源，不然很容易造成资源泄露等问题
  • 如果有很多调用 defer，那么 defer 是采用 后进先出(栈) 模式。
  1. package main
  2. import "fmt"
  3. func main(){
  4. 	f("1")
  5. 	fmt.Println("2")
  6. 	defer f("3") //会被延迟到最后执行
  7. 	fmt.Println("4")
  8. 	defer f("5") //会被延迟到最后执行
  9. 	fmt.Println("6")
  10. 	defer f("7") //会被延迟到最后执行
  11. 	fmt.Println("8")
  12. }
  13.  
  14. func f(s string){
  15. 	fmt.Println(s)
  16. }
  17.  
  18. // 1
  19. // 2
  20. // 4
  21. // 6
  22. // 8
  23. // 7
  24. // 5
  25. // 3
  1. package main
  2. import "fmt"
  3. func main(){
  4. 	a := 10
  5. 	fmt.Println("a=",a)
  6. 	defer f(a)
  7. 	a++
  8. 	fmt.Println("end a=",a)
  9. }
  10.  
  11. func f(s int){
  12. 	fmt.Println("函数里面的a:",s)  //a在执行defer的时候就已经传递进来了
  13. }
  14.  
  15. // a= 10
  16. // end a= 11
  17. // 函数里面的a: 10

defer的用法:

  • 对象.close()临时文件的删除

文件.open()

defer.close()

读或写

  • go语言中关于异常的处理，使用panic()和recover()

panic函数用于引发恐慌，导致程序中断执行

recover函数用于恢复程序的执行，recover()语法上要求必须在defer中执行

 函数的类型

  1. package main
  2. import "fmt"
  3. func main(){
  4. 	//f() 如果加了括号就成了函数的调用
  5. 	//f   如果不加括号，函数就是一个变量
  6. 	fmt.Printf("%T",f)          //func() 本身就是一个数据类型
  7. 	fmt.Printf("%T",10)
  8. 	fmt.Printf("%T","hello")
  9. 	fmt.Printf("%T",f1)         // func(int, int)
  10. 	fmt.Printf("%T",f2)         // func(int, int) int
  11.  
  12.  
  13. 	//定义函数类型的变量
  14. 	var f5 func(int, int)
  15. 	f5 = f1
  16. 	//给变量赋值然后尝试调用它
  17. 	f5(1,2)                    // 1 2
  18.  
  19. 	//打印 f1 和 f5 的地址发现是一样的，f1 和 f5 指向同一块地址,是引用类型
  20. 	fmt.Println(f5)           // 0x71b1a0 
  21. 	fmt.Println(f1)           // 0x71b1a0
  22. }
  23. func f(){
  24. 	
  25. }
  26.  
  27. func f1(a,b int){
  28. 	fmt.Println(a,b)
  29. }
  30.  
  31. func f2(a,b int) int {
  32. 	return 0
  33. }
  34.  
  35. // func()
  36. // int
  37. // string
  38. // func(int, int)
  39. //func(int, int) int
  40. //1 2
  41. // 0x71b1a0
  42. // 0x71b1a0

函数在Go语言中是复合类型，可以看做是一种特殊的变量

函数名(): 调用返回结果

函数名(): 指向函数体的内存地址，一种特殊类型的指针变量

匿名函数

  1. package main
  2. import "fmt"
  3.  
  4. //匿名函数
  5. func main(){
  6.  
  7.    f() 
  8.    f1 := f  // 函数本身也是一个变量
  9.    f1()
  10.  
  11.    //匿名函数
  12.    f2 := func(){
  13. 	fmt.Println("我是f2函数")
  14.    }
  15.    f2()
  16.  
  17.    //匿名函数自己调用自己
  18.    func(){
  19. 	fmt.Println("我是f3函数")
  20.    }()          //加()相当于直接调用函数
  21.  
  22.    //匿名函数可以传递参数
  23.    func(a,b int){
  24. 	fmt.Println(a,b)
  25. 	fmt.Println("我是f4函数")
  26.    }(1,2)          //加()相当于直接调用函数
  27.  
  28.    //匿名函数可以有返回值
  29.    r1 := func(a,b int) int {
  30. 	fmt.Println("我是f5函数")
  31. 	return a+b
  32.    }(1,2)          //加()相当于直接调用函数
  33.    fmt.Println(r1)
  34. }
  35.  
  36. func f(){
  37. 	fmt.Println("我是f函数")  
  38. }
  39.  
  40. // 我是f函数
  41. // 我是f函数
  42. // 我是f2函数
  43. // 我是f3函数
  44. // 1 2
  45. // 我是f4函数
  46. // 我是f5函数
  47. // 3

回调函数

高阶函数: 根据go语言的数据类型的特点，可以将一个函数作为另外一个函数的参数。

fun1()，fun2()

将 fun1 函数作为 fun2 这个函数的参数

fun2函数: 就叫做高阶函数，接收了一个函数作为参数的函数

fun1函数: 就叫做回调函数，作为另外一个函数的参数

  1. package main
  2. import "fmt"
  3.  
  4. func main(){
  5.    r1 := add(1,2)
  6.    fmt.Println(r1)
  7.  
  8.    r2 := oper(3,4,add)
  9.    fmt.Println(r2)
  10.  
  11.    r3 := oper(8,4,sub)
  12.    fmt.Println(r3)
  13.  
  14.    r4 := oper(8,4,func(a int,b int) int{
  15.       if b == 0{
  16. 		fmt.Println("除数不能为0")
  17. 		return 0
  18. 	  }
  19.       return a/b
  20.    })
  21.    fmt.Println(r4)
  22. }
  23.  
  24. //高阶函数： 可以接收一个函数作为参数
  25. func oper(a,b int,fun func(int,int) int) int{
  26.     r := fun(a,b)
  27. 	return r
  28. }
  29.  
  30. func add(a,b int) int{
  31. 	return a+b
  32. }
  33.  
  34. func sub(a,b int) int{
  35. 	return a-b
  36. }
  37.  
  38. // 3
  39. // 7
  40. // 4
  41. // 2

闭包

  1. package main
  2. import "fmt"
  3.  
  4. /*
  5. 一个外层函数中，有内层函效，该内层函数中，会操作外层函数的局部变量。
  6. 并且该外层函数的返回值就是这个内层函数。
  7. 这个内层函数和外层函数的局部变量，统称为闭包结构。
  8. */
  9.  
  10. /*
  11. 局部变量的生命周期就会发生改变，正常的局部变量会随着函数的调用而创建，随着函数的
  12. 结束而销毁，但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还在继续使用。
  13. */
  14. func main(){
  15.    r1 := increment()
  16.    fmt.Println(r1)
  17.  
  18.    v1 := r1()
  19.    fmt.Println(v1)
  20.  
  21.    v2 := r1()
  22.    fmt.Println(v2)
  23.  
  24.    fmt.Println(r1())
  25.    fmt.Println(r1())
  26.    fmt.Println(r1())
  27.  
  28.    //定义r2
  29.    r2 := increment()
  30.    v3 := r2()
  31.    fmt.Println(v3)
  32.    fmt.Println(r1())
  33.    fmt.Println(r2())
  34. }
  35.  
  36. // 自增
  37. func increment() func() int {
  38. 	// 局部变量i
  39. 	i := 0
  40. 	// 定义一个匿名函数，给变量自增并返回
  41. 	fun := func() int {  // 内层函数，没有执行的
  42. 		i++
  43. 		return i
  44. 	}
  45. 	return fun
  46. }
  47.  
  48. // 0xa398a0
  49. // 1
  50. // 2
  51. // 3
  52. // 4
  53. // 5
  54. // 1
  55. // 6
  56. // 2

教程

遇见狂神说：狂神聊Go001：Go语言的发展史_哔哩哔哩_bilibili

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/910917
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号