Go语言学习五 go的循环结构 chan range

2023-10-23 23:58
文章标签 语言 go 学习 range 结构 循环 chan

本文主要是介绍Go语言学习五 go的循环结构 chan range，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Go 语言循环语句


Go 语言循环语句

在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。

以下为大多编程语言循环程序的流程图： 

Go 语言提供了以下几种类型循环处理语句：

循环类型描述
for 循环重复执行语句块
循环嵌套在 for 循环中嵌套一个或多个 for 循环

循环控制语句

循环控制语句可以控制循环体内语句的执行过程。

GO 语言支持以下几种循环控制语句：

控制语句描述
break 语句经常用于中断当前 for 循环或跳出 switch 语句
continue 语句跳过当前循环的剩余语句，然后继续进行下一轮循环。
goto 语句将控制转移到被标记的语句。

无限循环

如过循环中条件语句永远不为 false 则会进行无限循环，我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环：

package mainimport "fmt"func main() {for true  {fmt.Printf("这是无限循环。\n");}
}

Go 语言 for 循环

由  youj 创建， 最后一次修改  2016-07-22

Go 语言 for 循环

Go 语言循环语句Go 语言循环语句

for循环是一个循环控制结构，可以执行指定次数的循环。

语法

Go语言的For循环有3中形式，只有其中的一种使用分号。

和 C 语言的 for 一样：

for init; condition; post { }

和 C 的 while 一样：

for condition { }

和 C 的 for(;;) 一样：

for { }
  • init： 一般为赋值表达式，给控制变量赋初值；
  • condition： 关系表达式或逻辑表达式，循环控制条件；
  • post： 一般为赋值表达式，给控制变量增量或减量。

for语句执行过程如下：

  • ①先对表达式1赋初值；
  • ②判别赋值表达式 init 是否满足给定条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

for key, value := range oldMap {newMap[key] = value
}

for语句语法流程如下图所示：

实例

package mainimport "fmt"func main() {var b int = 15var a intnumbers := [6]int{1, 2, 3, 5} /* for 循环 */for a := 0; a < 10; a++ {fmt.Printf("a 的值为: %d\n", a)}for a < b {a++fmt.Printf("a 的值为: %d\n", a)}for i,x:= range numbers {fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)}   
}

以上实例运行输出结果为:

a 的值为: 0
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 10
a 的值为: 11
a 的值为: 12
a 的值为: 13
a 的值为: 14
a 的值为: 15
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0

第 5 位 x 的值 = 0

Go 语言循环嵌套

由  youj 创建， 最后一次修改  2016-07-22

Go 语言循环嵌套

Go 语言循环语句Go 语言循环语句

Go 语言允许用户在循环内使用循环。接下来我们将为大家介绍嵌套循环的使用。

语法

以下为 Go 语言嵌套循环的格式：

for [condition |  ( init; condition; increment ) | Range]
{for [condition |  ( init; condition; increment ) | Range]{statement(s);}statement(s);
}

实例

以下实例使用循环嵌套来输出 2 到 100 间的素数：

package mainimport "fmt"func main() {/* 定义局部变量 */var i, j intfor i=2; i < 100; i++ {for j=2; j <= (i/j); j++ {if(i%j==0) {break; // 如果发现因子，则不是素数}}if(j > (i/j)) {fmt.Printf("%d  是素数\n", i);}}  
}

以上实例运行输出结果为:

2  是素数
3  是素数
5  是素数
7  是素数
11  是素数
13  是素数
17  是素数
19  是素数
23  是素数
29  是素数
31  是素数
37  是素数
41  是素数
43  是素数
47  是素数
53  是素数
59  是素数
61  是素数
67  是素数
71  是素数
73  是素数
79  是素数
83  是素数
89  是素数
97  是素数

Go 语言 break 语句

由  youj 创建， 最后一次修改  2016-07-22

Go 语言 break 语句

Go 语言循环语句 Go语言循环语句

Go 语言中 break 语句用于以下两方面：

  1. 用于循环语句中跳出循环，并开始执行循环之后的语句。
  2. break在switch（开关语句）中在执行一条case后跳出语句的作用。

语法

break 语法格式如下：

break;

break 语句流程图如下：

实例

package mainimport "fmt"func main() {/* 定义局部变量 */var a int = 10/* for 循环 */for a < 20 {fmt.Printf("a 的值为 : %d\n", a);a++;if a > 15 {/* 使用 break 语句跳出循环 */break;}}
}

以上实例执行结果为：

a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 15

Go 语言 continue 语句

由  youj 创建， 最后一次修改  2016-07-22

Go 语言 continue 语句

Go 语言循环语句Go 语言循环语句

Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。

for 循环中，执行 continue 语句会触发for增量语句的执行。

语法

continue 语法格式如下：

continue;

continue 语句流程图如下：

实例

package mainimport "fmt"func main() {/* 定义局部变量 */var a int = 10/* for 循环 */for a < 20 {if a == 15 {/* 跳过此次循环 */a = a + 1;continue;}fmt.Printf("a 的值为 : %d\n", a);a++;     }  
}

以上实例执行结果为：

a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19

Go 语言 goto 语句

由  youj 创建， 最后一次修改  2016-07-22

Go 语言 goto 语句

Go 语言循环语句Go 语言循环语句

Go 语言的 goto 语句可以无条件地转移到过程中指定的行。

goto语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。

但是，在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。

语法

goto 语法格式如下：

goto label;
..
.
label: statement;

break 语句流程图如下：

实例

package mainimport "fmt"func main() {/* 定义局部变量 */var a int = 10/* 循环 */LOOP: for a < 20 {if a == 15 {/* 跳过迭代 */a = a + 1goto LOOP}fmt.Printf("a的值为 : %d\n", a)a++     }  
}

以上实例执行结果为：

a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19

go:chan分为阻塞和非阻塞


chan是一个FIFO队列，chan分成两种类型同步和异步
同步的chan完成发送者和接受者之间手递手传递元素的过程，必须要求对方的存在才能完成一次发送或接受
异步的chan发送和接受都是基于chan的缓存，但当缓存队列填满后，发送者就会进入发送队列, 当缓存队列为空时，接受者就会接入等待队列。

一句话总结：ch := make(chan int) 由于没有缓冲发送和接收需要同步，ch := make(chan int, 2) 有缓冲不要求发送和接收操作同步。

1、无缓冲时，发送阻塞直到数据被接收，接收阻塞直到读到数据


package main
 
import (
 
	"fmt"
 
	"time"
 
)
 
 
func main() {
 
	ch := make(chan int)
 
 
	go func() {
 
		var sum int = 6
 
		fmt.Println("first send")
 
		ch <- sum
 
		fmt.Println("second send start")
 
		fmt.Println("second send")
 
		ch <- sum
 
	}()
 
	time.Sleep(1e9)
 
	fmt.Println("first recv")
 
	fmt.Println(<-ch)
 
	fmt.Println("second recv")
 
	fmt.Println(<-ch)
 
 
}
 
 
 
 
first send
 
first recv
 
6
 
second recv
 
second send start
 
second send
 
6
 
 

 
2、有缓冲时，当缓冲满时发送阻塞，当缓冲空时接收阻塞
 

 
 
package main
 
 
import (
 
	"fmt"
 
	"time"
 
)
 
 
func main() {
 
	ch := make(chan int, 2)
 
 
	go func() {
 
		var sum int = 6
 
		fmt.Println("first send")
 
		ch <- sum
 
		fmt.Println("second send start")
 
		time.Sleep(1e9)
 
		fmt.Println("second send")
 
		ch <- sum
 
		fmt.Println("third send start")
 
		time.Sleep(1e9)
 
		fmt.Println("third send")
 
		ch <- sum
 
		time.Sleep(1e9)
 
		fmt.Println("forth send")
 
		ch <- sum
 
	}()
 
	time.Sleep(6e9)
 
	fmt.Println("first recv")
 
	fmt.Println(<-ch)
 
	fmt.Println("second recv")
 
	fmt.Println(<-ch)
 
	fmt.Println("third recv")
 
	fmt.Println(<-ch)
 
	fmt.Println("forth recv")
 
	fmt.Println(<-ch)
 
}
 
 
 
 
first send
 
second send start
 
second send
 
third send start
 
third send
 
first recv
 
6
 
second recv
 
6
 
third recv
 
6
 
forth recv
 
forth send
 
6
 
 
 
 
 

 

 
Go学习笔记之：range函数
 
 

 

 
 
range函数是个神奇而有趣的内置函数，你可以使用它来遍历数组，切片和字典。
 
当用于遍历数组和切片的时候，range函数返回索引和元素；
 
当用于遍历字典的时候，range函数返回字典的键和值。
 
package mainimport "fmt"func main() {// 这里我们使用range来计算一个切片的所有元素和// 这种方法对数组也适用nums := []int{2, 3, 4}sum := 0for _, num := range nums {sum += num}fmt.Println("sum:", sum)// range 用来遍历数组和切片的时候返回索引和元素值// 如果我们不要关心索引可以使用一个下划线(_)来忽略这个返回值// 当然我们有的时候也需要这个索引for i, num := range nums {if num == 3 {fmt.Println("index:", i)}}// 使用range来遍历字典的时候，返回键值对。kvs := map[string]string{"a": "apple", "b": "banana"}for k, v := range kvs {fmt.Printf("%s -> %s\n", k, v)}// range函数用来遍历字符串时，返回Unicode代码点。// 第一个返回值是每个字符的起始字节的索引，第二个是字符代码点，// 因为Go的字符串是由字节组成的，多个字节组成一个rune类型字符。for i, c := range "go" {fmt.Println(i, c)}
}
 
 
输出结果为
 
sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111
 
 

 


                                    

                                        这篇关于Go语言学习五    go的循环结构  chan  range的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
                                    

                                    

                                

                            

                            

                        

                    

                    

                        

                            

                            http://www.chinasem.cn/article/271310。
                            
                        

                    

                    
                    

                        
                            
                        
                    

                

                

                    相关文章
                

                    

                        

                            

                                

                                    
                                        Java中switch-case结构的使用方法举例详解
                                    
                                

                            

                            

                                

                                    Java中switch-case结构的使用方法举例详解
                                

                                

                                    《Java中switch-case结构的使用方法举例详解》：本文主要介绍Java中switch-case结构使用的相关资料,switch-case结构是Java中处理多个分支条件的一种有效方式,它...																									目录前言一、switch-case结构的基本语法二、使用示例三、注意事项四、总结前言对于Java初学者
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        结构体和联合体的区别及说明
                                    
                                

                            

                            

                                

                                    结构体和联合体的区别及说明
                                

                                

                                    《结构体和联合体的区别及说明》文章主要介绍了C语言中的结构体和联合体,结构体是一种自定义的复合数据类型,可以包含多个成员,每个成员可以是不同的数据类型,联合体是一种特殊的数据结构,可以在内存中共享同一...																									目录结构体和联合体的区别1. 结构体(Struct)2. 联合体(Union)3. 联合体与结构体的
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        C语言线程池的常见实现方式详解
                                    
                                

                            

                            

                                

                                    C语言线程池的常见实现方式详解
                                

                                

                                    《C语言线程池的常见实现方式详解》本文介绍了如何使用C语言实现一个基本的线程池,线程池的实现包括工作线程、任务队列、任务调度、线程池的初始化、任务添加、销毁等步骤,感兴趣的朋友跟随小编一起看看吧...																									目录1. 线程池的基本结构2. 线程池的实现步骤3. 线程池的核心数据结构4. 线程池的详细实现4.1 初
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        JAVA中while循环的使用与注意事项
                                    
                                

                            

                            

                                

                                    JAVA中while循环的使用与注意事项
                                

                                

                                    《JAVA中while循环的使用与注意事项》：本文主要介绍while循环在编程中的应用,包括其基本结构、语句示例、适用场景以及注意事项,文中通过代码介绍的非常详细,需要的朋友可以参考下...																									目录while循环1. 什么是while循环2. while循环的语句3.while循环的适用场景以及优势4. 注意
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        Go信号处理如何优雅地关闭你的应用
                                    
                                

                            

                            

                                

                                    Go信号处理如何优雅地关闭你的应用
                                

                                

                                    《Go信号处理如何优雅地关闭你的应用》Go中的优雅关闭机制使得在应用程序接收到终止信号时,能够进行平滑的资源清理,通过使用context来管理goroutine的生命周期,结合signal...																									目录1. 什么是信号处理？2. 如何优雅地关闭 Go 应用？3. 代码实现3.1 基本的信号捕获和优雅关闭3.2
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        Python中的异步:async 和 await以及操作中的事件循环、回调和异常
                                    
                                

                            

                            

                                

                                    Python中的异步:async 和 await以及操作中的事件循环、回调和异常
                                

                                

                                    《Python中的异步:async和await以及操作中的事件循环、回调和异常》在现代编程中,异步操作在处理I/O密集型任务时,可以显著提高程序的性能和响应速度,Python提供了asyn...																									目录引言什么是异步操作？python 中的异步编程基础async 和 await 关键字asyncio 模块理论
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        PostgreSQL如何查询表结构和索引信息
                                    
                                

                            

                            

                                

                                    PostgreSQL如何查询表结构和索引信息
                                

                                

                                    《PostgreSQL如何查询表结构和索引信息》文章介绍了在PostgreSQL中查询表结构和索引信息的几种方法,包括使用`d`元命令、系统数据字典查询以及使用可视化工具DBeaver...																									目录前言使用\d元命令查看表字段信息和索引信息通过系统数据字典查询表结构通过系统数据字典查询索引信息查询所有的表名可
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        HarmonyOS学习(七)——UI（五）常用布局总结
                                    
                                

                            

                            

                                

                                    HarmonyOS学习(七)——UI（五）常用布局总结
                                

                                

                                    自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧
                                    
                                

                            

                            

                                

                                    Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧
                                

                                

                                    Ilya（不是本人，claude AI）在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。  以下是详细的内容：   提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。  快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）
                                    
                                

                            

                            

                                

                                    【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）
                                

                                

                                    【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili  本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解）    <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
                                

                                

                                    阅读更多...
                                

                            

                        

                    

            

        

    


    


    

        

            Copyright China编程   23002807@qq.com
        

        

            沪ICP备2023033072号-2