Golang基础-流程控制(六)

最新推荐文章于 2024-08-14 17:52:55 发布
最新推荐文章于 2024-08-14 17:52:55 发布
阅读量95 收藏
点赞数
分类专栏： GoLang 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45858439/article/details/120471838
版权

Golang-流程控制

文章目录

【1】流程控制的作用：
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
【2】控制语句的分类：

 控制语句分为三类：顺序、选择和循环。
“顺序结构”代表“先执行a，再执行b”的逻辑。
“条件判断结构”代表“如果…，则…”的逻辑。
“循环结构”代表“如果…，则再继续…”的逻辑。

三种流程控制语句就能表示所有的事情！不信，你可以试试拆分你遇到的各种事情。这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。所以任何一种高级语言都具备上述两种结构。
本章是大家真正进入编程界的“门票”。
【3】流程控制的流程：

在这里插入图片描述

1.分支结构

1.1 if分支

1.1.1 单分支

【1】基本语法

if 条件表达式 {
  逻辑代码
}

当条件表达式为ture时，就会执行得的代码。
PS：条件表达式左右的()可以不写，也建议不写
PS：if和表达式中间，一定要有空格
PS：在Golang中，{}是必须有的,就算你只写一行代码。

【2】代码练习：

方法1

package main
import "fmt"

func main(){
	//实现功能：如果口罩的库存小于30个，提示：库存不足：
	var count int = 20
	//单分支
	if count < 30 {
		fmt.Println("您的口罩库存不足")
	}

	//if后面表达式，返回结果一定是true或者false
	//如果返回结果为true的话，那么{}中的代码就会执行
	//如果返回结果为false的话，那么{}中的代码就不会执行
	//if后面一定要有空格，和条件表达式分隔开来
	//{}一定不能省略
	//条件表达式左右的()是建议省略的
	//在golang里，if后面可以并列的加入变量的定义
}

在这里插入图片描述

方法2

package main
import "fmt"

func main(){

	if count := 20;count < 30 {
		fmt.Println("您的口罩库存不足")
	}
}

在这里插入图片描述

1.1.2 双分支

【1】基本语法

if 条件表达式 {
   逻辑代码1
} else {
   逻辑代码2
}
当条件表达式成立，即执行逻辑代码1，否则执行逻辑代码2。{}也是必须有的。

PS：下面的格式是错误的：

if 条件表达式 {
   逻辑代码1
}
else {
   逻辑代码2
}

PS：空格加上，美观规范

【2】代码练习：

当if条件成立

package main
import "fmt"

func main(){
	//实现功能：如果口罩的库存小于30个，提示：库存不足,否则提示：库存充足
	//定义口罩的数量
	var count int = 20
	if count < 30 { //这个条件表达式返回的是true（即条件成立），执行{}中的fmt.Println("库存不足")
		fmt.Println("库存不足")
	} else {  //条件就相当于count >=30,执行{}中的fmt.Println("库存充足")
		fmt.Println("库存充足")
	}
     //双分支一定会二选一，走其中一个分支
}

在这里插入图片描述

当else条件成立

package main
import "fmt"

func main(){
	//实现功能：如果口罩的库存小于30个，提示：库存不足,否则提示：库存充足
	//定义口罩的数量
	var count int = 60
	if count < 30 { //这个条件表达式返回的是true（即条件成立），执行{}中的fmt.Println("库存不足")
		fmt.Println("库存不足")
	} else {  //条件就相当于count >=30,执行{}中的fmt.Println("库存充足")
		fmt.Println("库存充足")
	}
     //双分支一定会二选一，走其中一个分支
}

在这里插入图片描述

1.1.3 多分支

【1】基本语法

if 条件表达式1 {
    逻辑代码1
} else if 条件表达式2 {
    逻辑代码2
}
.......
else {
                逻辑代码n
}

【2】代码练习：

方式1

package main
import "fmt"
func main(){
	//实现功能：根据给出的学生分数，判断学生的等级；
	// >=90 ------A
	// >=80 ------B
	// >=70 ------C
	// >=60 ------D
	// <60  ------E
	//方式1：利用if单分支实现：
	//定义一个学生成绩
	var count int = 88
	//对学生的成绩进行判定：
	if count >= 90 {
		fmt.Println("您的成绩为A级别")
	}
	if count >= 80 && count <= 90 {
		fmt.Println("您的成绩为B级别")
	}
	if count >= 70 && count <= 80 {
		fmt.Println("您的成绩为C级别")
	}
	if count >= 60 && count <= 70 {
		fmt.Println("您的成绩为D级别")
	}
	if count <60 {
		fmt.Println("您的成绩为E级别")
	}
	//上面方式1利用多个单分支拼凑出多个选择，多个选择是并列的，依次从上而下顺序执行，
	//即使走了第一个分支，那么其他分支也是需要判断
}

在这里插入图片描述

方式2

package main
import "fmt"
func main(){
	//实现功能：根据给出的学生分数，判断学生的等级；
	// >=90 ------A
	// >=80 ------B
	// >=70 ------C
	// >=60 ------D
	// <60  ------E
var count int = 59
	//方式2：多分支：如果走了一个分支，那么下面的分支就不会走了
	if count >= 90 {
		fmt.Println("您的成绩为A级别")
	}  else if count >= 80 {
		fmt.Println("您的成绩为B级别")
	}  else if count >= 70 {
		fmt.Println("您的成绩为C级别")
	}  else if count >= 60 {
		fmt.Println("您的成绩为D级别")
	}  else {
		fmt.Println("您的成绩为E级别")
	}	//建议保证else的存在，只有有了else才能保证多选一的效果
}

在这里插入图片描述

2.2 switch分支

【1】基本语法：

switch 表达式 {
                        case 值1,值2,.….:
                                                        语句块1
                        case 值3,值4,...:
                                                        语句块2
                        ....
                        default:
                         语句块
}

【2】代码练习：

package main
import "fmt"
func main(){
	//实现功能：根据给出的学生分数，判断学生的等级；
	// >=90 ------A
	// >=80 ------B
	// >=70 ------C
	// >=60 ------D
	// <60  ------E
	
	//给出一个学生分数
	var score int = 98
	//根据分数判断等级：
	//switch后面是一个表达式，这个表达式的结果依次跟case进行比较，满足结果的话就执行冒号后面的代码
	//default是用来“兜底”的一个分支，其他case分支都不走的情况下就会走default分支
	//default分支可以放在任意位置上，不一定非要放在最后
	switch score/10 {
	case 10 :
		fmt.Println("您的等级为A级")
	case 9 :
		fmt.Println("您的等级为A级")
	case 8 :
		fmt.Println("您的等级为B级")
	case 7 :
		fmt.Println("您的等级为C级")
	case 6 :
		fmt.Println("您的等级为D级")
	case 5 :
		fmt.Println("您的等级为E级")
	case 4 :
		fmt.Println("您的等级为E级")
	case 3 :
		fmt.Println("您的等级为E级")
	case 2 :
		fmt.Println("您的等级为E级")
	case 1 :
		fmt.Println("您的等级为E级")
	case 0 :
		fmt.Println("您的等级为E级")
	default:
		fmt.Println("您的成绩有误")
	}
}

在这里插入图片描述

package main
import "fmt"
func main(){
	//实现功能：根据给出的学生分数，判断学生的等级；
	// >=90 ------A
	// >=80 ------B
	// >=70 ------C
	// >=60 ------D
	// <60  ------E
	
	//给出一个学生分数
	var score int = 198
	//根据分数判断等级：
	//switch后面是一个表达式，这个表达式的结果依次跟case进行比较，满足结果的话就执行冒号后面的代码
	//default是用来“兜底”的一个分支，其他case分支都不走的情况下就会走default分支
	//default分支可以放在任意位置上，不一定非要放在最后
	switch score/10 {
	case 10 :
		fmt.Println("您的等级为A级")
	case 9 :
		fmt.Println("您的等级为A级")
	case 8 :
		fmt.Println("您的等级为B级")
	case 7 :
		fmt.Println("您的等级为C级")
	case 6 :
		fmt.Println("您的等级为D级")
	case 5 :
		fmt.Println("您的等级为E级")
	case 4 :
		fmt.Println("您的等级为E级")
	case 3 :
		fmt.Println("您的等级为E级")
	case 2 :
		fmt.Println("您的等级为E级")
	case 1 :
		fmt.Println("您的等级为E级")
	case 0 :
		fmt.Println("您的等级为E级")
	default:
		fmt.Println("您的成绩有误")
	}
}

在这里插入图片描述

【3】注意事项：
（1）switch后是一个表达式(即:常量值、变量、一个有返回值的函数等都可以)

在这里插入图片描述

（2）case后面的值如果是常量值(字面量)，则要求不能重复

在这里插入图片描述

（3）case后的各个值的数据类型，必须和 switch 的表达式数据类型一致

在这里插入图片描述

（4）case后面可以带多个值，使用逗号间隔。比如 case 值1,值2…

在这里插入图片描述

（5）case后面不需要带break
（6）default语句不是必须的，位置也是随意的。
（7）switch后也可以不带表达式，当做if分支来使用

在这里插入图片描述

（8）switch后也可以直接声明/定义一个变量，分号结束，不推荐

在这里插入图片描述

（9）switch穿透，利用fallthrough关键字，如果在case语句块后增加fallthrough ,则会继续执行下一个case,也叫switch穿透。

在这里插入图片描述

2.循环结构

2.1 语法结构：

for 初始表达式; 布尔表达式; 迭代因子 {
          循环体;
}

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。

for循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。
初始化部分设置循环变量的初值
条件判断部分为任意布尔表达式
迭代因子控制循环变量的增减
for循环在执行条件判定后，先执行的循环体部分，再执行步进。
for循环结构的流程图如图所示：

在这里插入图片描述

2.2 代码展示：

步骤1

package main
import "fmt"

func main(){
	//实现一个功能：求和：1+2+3+4+5：
	//定义变量：
	var i1 int = 1
	var i2 int = 2
	var i3 int = 3
	var i4 int = 4
	var i5 int = 5

	//求和
	//定义一个变量，用来接收这个和
	var sum int = 0
	sum += i1
	sum += i2
	sum += i3
	sum += i4
	sum += i5

	//输出结果
	fmt.Println(sum)
}

在这里插入图片描述

缺点：变量的定义太多了

步骤2

package main
import "fmt"

func main(){
	//实现一个功能：求和：1+2+3+4+5：
	//定义变量：
	var i int = 1

	//求和
	//定义一个变量，用来接收这个和
	var sum int = 0
	sum += i
	i++
	sum += i
	i++
	sum += i
	i++
	sum += i
	i++
	sum += i
    i++
	//输出结果
	fmt.Println(sum)
}

在这里插入图片描述

缺点：重复的代码太多了

解决：利用for循环：

package main
import "fmt"

func main(){
	//实现一个功能：求和：1+2+3+4+5：
	//定义变量：
	//求和
	var sum int = 0
	for i := 1; i <= 5 ; i++ {
		sum += i
	}
	//输出结果：
	fmt.Println(sum)

	//for循环的语法格式：
	//for 初始表达式；布尔表达式（条件判断）；迭代因子 {
	//循环体；--》 反复重复执行的内容	

	//注意：for的初始表达式 不能用var定义变量的形式，要用:=
	//注意：for循环实际就是让程序员写代码的效率高了，但是底层该怎么执行还是怎么执行的，
	//底层效率没有提高，只是程序员写代码简洁了而已
}

在这里插入图片描述

2.3 for循环原理：

在这里插入图片描述

2.4 for循环细节

【1】格式灵活：

方式1

package main
import "fmt"

func main(){
     for i:= 1;i<=5;i++ {
		 fmt.Println("你好 Golang")
	 }
}

方式2

package main
import "fmt"

func main(){
	 i:= 1  //变量的初始化
     for i<=5 { //条件表达式，判断条件
		 fmt.Println("你好 Golang") //循环体
		 i++  //迭代
	 }
}

【2】死循环：

方式1

package main
import "fmt"

func main(){
	 //死循环：
	   for {
           fmt.Println("你好，Go lang")
	 }
}

在控制台中结束死循环：ctrl+c

方式2

package main
import "fmt"

func main(){
	 //死循环：
	   for ;; {
           fmt.Println("你好，Go lang")
	 }
}

2.5 for range

（键值循环） for range结构是Go语言特有的一种的迭代结构，在许多情况下都非常有用，for range 可以遍历数组、切片、字符串、map 及通道，for range 语法上类似于其它语言中的 foreach 语句，

一般形式为：

for key, val := range coll {
    ...
}

代码展示：

方式1：只用字符串，不用中文，用中文需要切片

package main
import "fmt"

func main(){
	 //定义一个字符串：
	 var str string = "hello golang"
	 //方式1：普通for循环：按照字节进行遍历输出的 (暂时先不使用中文)
	 for i := 0;i < len(str);i++ {//i:理解为字符串的下标
		fmt.Printf("%c \n",str[i])
	 }
}

方式2

package main
import "fmt"

func main(){
	 //定义一个字符串：
	 var str string = "hello golang你好"
	 //方式1：普通for循环：按照字节进行遍历输出的 (暂时先不使用中文)
	 //for i := 0;i < len(str);i++ {//i:理解为字符串的下标
	 //	fmt.Printf("%c \n",str[i])

	 //方式2
	 for i , value := range str {
		  fmt.Printf("索引为：%d,具体的值为：%c \n",i,value)
	 }
	 //对str进行遍历，遍历的每个结果的索引值被i接收，每个结果的具体数值被value接收
	 //遍历对字符进行遍历的
}

for-range的结果：

在这里插入图片描述

3.关键字

3.1 break

【1】感受break在循环中的作用：

package main
import "fmt"
func main(){
	//功能：求1-100的和，当和第一次超过300的时候，停止程序
	 var sum int = 0
	 for i := 1 ; i <= 100 ; i++ {
		 sum += i
		 fmt.Println(sum)
		 if sum >= 300 {
			//停止正在执行的这循环
			break
		 } 
	 }
	 fmt.Println("只是停止了for循环，后面代码该执行还是执行")
}

在这里插入图片描述

总结：
1.switch分支中，每个case分支后都用break结束当前分支，但是在go语言中break可以省略不写。
2.break可以结束正在执行的循环

【2】深入理解：

package main
import "fmt"
func main(){
	 //双重循环：
	 for i := 1 ; i < 5 ; i++ {
		 for j := 2 ; j < 4 ; j++ {
			 fmt.Printf("i: %v, j: %v \n",i,j)
			 if i == 2 && j == 2 {
				 break
			 }
		 }
	 }
}

总结：break的作用结束离它最近的循环
结果：

在这里插入图片描述

【3】标签的使用展示：

package main
import "fmt"
func main(){
	 //双重循环：
	 lable1:
	 for i := 1 ; i <= 5 ; i++ {
		 for j := 2 ; j <= 4 ; j++ {
			 fmt.Printf("i: %v, j: %v \n",i,j)
			 if i == 2 && j == 2 {
				 break lable1 //结束指定标签对应的循环
			 }
		 }
	 }
        fmt.Printf("-----------ok")
}

注意：如果那个标签没有使用到 的话，那么标签不用加，否则报错：定义未使用
结果：
在这里插入图片描述

3.2 continue

【1】continue的作用：结束本次循环，继续下一次的循环

方式1

package main
import "fmt"
func main(){
	 //功能：输出1-100中被6整除的数：
	 //方式1
	 for i := 1 ; i <= 100 ; i ++ {
		 if i % 6 == 0 {
			fmt.Println(i)
		 }
	 }
}

方式2

package main
import "fmt"
func main(){
	 //功能：输出1-100中被6整除的数：
	 //方式1
	 //for i := 1 ; i <= 100 ; i ++ {
	 //	 if i % 6 == 0 {
	 //		fmt.Println(i)
	 //	 }
	 //}

	 //方式2
	 for i := 1 ; i <= 100 ; i ++ {
		 if i % 6 != 0 {
			 continue //结束本次循环，继续下一次循环
		 }
		 fmt.Println(i)
	 }
}

【2】深入理解：

package main
import "fmt"
func main(){
	 //双重循环：
	 for i := 1 ; i <= 5 ; i++ {
		 for j := 2 ; j <= 4 ; j++ {
			 if i == 2 && j == 2 {
				continue
			 }
			 fmt.Printf("i: %v, j: %v \n",i,j)
		 }
	 }
	 fmt.Printf("-----------ok")
}

结果：
在这里插入图片描述

结论：continue的作用是结束离它近的那个循环，继续离它近的那个循环

【3】标签的作用：

package main
import "fmt"
func main(){
	 //双重循环：
	 lable:
	 for i := 1 ; i <= 5 ; i++ {
		 for j := 2 ; j <= 4 ; j++ {
			 if i == 2 && j == 2 {
				continue lable
			 }
			 fmt.Printf("i: %v, j: %v \n",i,j)
		 }
	 }
	 fmt.Printf("-----------ok")
}

在这里插入图片描述

3.3 goto(不建议使用)

【1】Golang的 goto 语句可以无条件地转移到程序中指定的行。
【2】goto语句通常与条件语句配合使用。可用来实现条件转移.
【3】在Go程序设计中一般不建议使用goto语句，以免造成程序流程的混乱。
【4】代码展示：

package main
import "fmt"
func main(){
	fmt.Println("hello golang1")
	fmt.Println("hello golang2")
	if 1 == 1 {
		goto lable1 //goto一般配合条件结构一起使用
	}
	fmt.Println("hello golang3")
	fmt.Println("hello golang4")
	fmt.Println("hello golang5")
	lable1:
	fmt.Println("hello golang6")
	fmt.Println("hello golang7")
	fmt.Println("hello golang8")
}

在这里插入图片描述

3.4 return

**代码展示：**先对return做一个了解，后面函数阶段重点学习

package main
import "fmt"
func main(){
	for i := 1 ; i <= 100 ; i ++ {
		fmt.Println(i)
		if i == 10 {
			return
		}
	}
	    fmt.Println("hello return后面的不会被执行")
}

在这里插入图片描述

一个不专业的码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
桫哥-GOlang基础-Go语言实战：成语查询
06-12
在本课程"桫哥-GOlang基础-Go语言实战：成语查询"中，你将学习到Go语言的基础知识以及如何将其应用到实际的成语查询项目中。Go语言，也称为Golang，是Google公司设计的一种静态类型、编译型、并发型且具有垃圾回收...
桫哥-GOlang基础-Go语言实战：文本大数据挖掘
06-12
2. 基本语法：介绍Go语言的变量、常量、数据类型、运算符、流程控制语句（如if、for、switch等）以及函数的使用。 3. 结构体与接口：讲解如何定义和使用结构体来组织数据，以及接口的概念和实现，这是Go语言实现多态...
Go之gorouting
weixin_30655219的博客
01-26 267
一：gorouting的必要性 假如设计一个程序1-10000000000000数字之间那些是偶数 ①:传统思路上设计一个循环，在循环中判断 ②：使用并发或者并行的方法，将判断那些书偶数的任务分配给多个grouting去完成，这样将大大提高速率。 二：进程与线程 ①：进程就是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位； ②：线程是进程的一个执行实例，是程序执行...
goroutine及调度器GMP模型
qqxhb 资源共享
02-28 298
协程是一种用户态轻量级线程，goroutine是go自己实现的协程，GMP则是goroutine的调度器模型。 1.什么是协程 进程是系统资源分配的最小单位, 进程的创建和销毁都是系统资源级别的，因此是一种比较昂贵的操作，进程是抢占式调度其有三个状态:等待态、就绪态、运行态。进程之间是相互隔离的，它们各自拥有自己的系统资源, 更加安全但是也存在进程间通信不便的问题。 线程是CPU调度的最小单位，进程是线程的载体容器，多个线程除了共享进程的资源还拥有自己的一少部分独立的资源，因此相比进程而言更加轻量，进程内的
GO特有-gorouting、通道
lishunxi0519的专栏
02-01 352
gorouting 只需在要让Goroutine执行的函数或方法前加上关键字go即可 启动一个新的协程时，会立即返回执行下一行代码，忽略该协程返回的任何值 channel go通过channel实现协程间的通信 channel 是有类型的管道，采用关键字chan 加上类型做声明。赋值取值采用符号”<-“ 和 map 与 slice 一样，channel 使用前必须创建： v...
Go goroutine调度
weixin_34295316的博客
09-29 173
为什么80%的码农都做不了架构师？>>> ...
Golang gorouting 并发控制 sync.WaitGroup 介绍与使用
fuyuande的博客
05-05 1249
WaitGroup简称同步组，用于等待goroutines结束的。 官方文档： type WaitGroup A WaitGroup waits for a collection of goroutines to finish. The main goroutine calls Add to set the number of goroutines to wait for. Then e...
2-golang基础-流程控制及数据类型
u013071014的博客
03-15 530
2-golang基础 1. 流程控制 1. 顺序控制 2. 分支控制 if-else func main() { // golang支持在if中直接定义一个变量 if age := 20; age > 18 { fmt.Println("aa") } } switch func main() { var age int = 18 switch age { // case 中可以使用多个表达式(常量、变量、有结果的函数)，用逗号隔开 // case 结束不需要break
Golang基础-13
TimerSea的博客
04-18 885
本文介绍Go语言中 channel、goroutine、互斥锁、读写锁、原子操作、select、超时处理、sync包、runtime包等相关知识。
桫哥-GOlang基础-Go语言实战：驾考系统
06-12
3. **控制流程**：讲解条件语句（if-else）、循环（for、while）、switch，以及函数的定义与调用，包括函数多返回值和接收者参数。 4. **指针**：理解指针的概念，学习如何声明、使用指针，以及指针在函数传递中的...
Golang基础之流程控制习题——李文周老师
01-08
编写代码打印9*9乘法表。 代码如下： package main import fmt func main() { i := 1 // 左乘数 j := 1 // 右乘数 for { if i9 { break ...附出处：李文周Go基础之流程控制 作者：Villero
桫哥-GOlang基础-Go语言实战：多人聊天室（上）
06-12
在本课程"桫哥-GOlang基础-Go语言实战：多人聊天室（上）"中，我们将深入学习Go语言的基础语法以及如何运用这些基础知识来构建一个多人聊天室的实战项目。Go语言，又称为Golang，是Google在2009年推出的一种静态类型...
深入解析 Golang debug/macho 包：解锁 Mach-O 文件的秘籍
最新发布
2401_85760095的博客
08-14 336
包提供了丰富的数据结构和函数，用于表示和处理 Mach-O 文件的不同部分。这包括文件头、加载命令、段、符号表等关键组件。使用此包，开发者可以获取有关 Mach-O 文件的详细信息，例如它的 CPU 类型、文件类型、加载命令和符号信息。
Ubuntu Linux安装Go语言
m0_73500130的博客
08-09 481
Golang是Google公司在2007年开始开发的一种静态强类型、编译型语言。Go语言被设计成一门简单、高效且可靠的编程语言，旨在解决大规模网络服务和分布式系统开发中的复杂性问题。Go语言结合了动态语言的开发速度和C/C++等编译型语言的性能与安全性，提供了强大的网络编程和并发编程支持。
zdpgo_gin_limit 为zdpgo_gin打造的接口限流框架，当API接口需要限制访问频率的时候可以使用此框架
Python私教
08-10 520
为zdpgo_gin打造的接口限流框架，当API接口需要限制访问频率的时候可以使用此框架。
Redis之golang编程实战
choice~的博客
08-08 812
Redis字符串存储字节序列，包括文本、序列化对象和二进制数组。因此，字符串是最基本的Redis数据类型。它们通常用于缓存，但它们支持额外的功能，允许您实现计数器并执行按位操作。默认情况下，string 的最大尺寸为：512MB。大多数的 string 操作时间复杂度为：O(1)。但 SUBSTR, GETRANGE， SETRANGE 命令的时间复杂度为O(n)。Redis位图是字符串数据类型的扩展，可以将字符串视为位向量。您还可以对一个或多个字符串执行按位操作。
Go 语言并发编程快速入门 20240814教学笔记及实战代码
Python私教
08-14 341
【代码】Go 语言并发编程快速入门 20240814教学笔记及实战代码。
Golang面试题四（并发编程）
qq_22321199的专栏
08-12 1134
L Locker // 互斥锁接口c chan struct{} // 用于信号的通道L是一个Locker接口类型的指针，它可以是任何实现了Lock()和Unlock()方法的对象，如Mutex或RWMutex。c是一个无缓冲的结构体通道，用于信号的传递。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值