Go学习第四章——程序流程控制

这篇具有很好参考价值的文章主要介绍了Go学习第四章——程序流程控制。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

  1. 流程控制的作用:
    流程控制语句是用来控制程序中各语句执行顺序的语句,可以把语句组合成能完成一定功能的小逻辑模块。

  2. 控制语句的分类:
    控制语句分为三类:顺序、选择和循环。
    “顺序结构”代表“先执行a,再执行b”的逻辑。
    “条件判断结构”代表“如果…,则…”的逻辑。
    “循环结构”代表“如果…,则再继续…”的逻辑。
    三种流程控制语句就能表示所有的事情!不信,你可以试试拆分你遇到的各种事情。这三种基本逻辑结构是相互支撑的,它们共同构成了算法的基本结构,无论怎样复杂的逻辑结构,都可以通过它们来表达。所以任何一种高级语言都具备上述两种结构。
    本章是大家真正进入编程界的“门票”。

  3. 流程控制的流程:

Go学习第四章——程序流程控制,golang,学习,开发语言,笔记,后端

1 分支结构

1.1 单分支

基本语法

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

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

案例讲解

func main() {
    // 实现功能:如果口罩的库存小于30个,提示:库存不足:

    /*var count int = 100
    // 单分支:
    if count < 30 {
       fmt.Println("对不起,口罩存量不足")
    }*/

    //在golang里,if后面可以并列的加入变量的定义:
    if count := 20; count < 30 {
       fmt.Println("对不起,口罩存量不足")
    }
}

输出:

对不起,口罩存量不足
1.2 双分支

基本语法

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

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

案例讲解

func main() {
    var age byte
    fmt.Println("请问你的年龄多少?")
    fmt.Scanln(&age)
    if age < 18 {
       fmt.Println("你还没有成年!")
    } else {
       fmt.Println("你已经成年了!!")
    }
}

输出:

请问你的年龄多少?
18
你已经成年了!!
1.3 多分支

基本语法

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

案例讲解

略。。。。。只是多了几个else,略了。。

1.4 switch分支

基本语法

switch 表达式 {
	case1,2,..:
		语句块1
	case3,4,...:
		语句块2
	....
	default:
		语句块
}

ps:case后是一个表达式(即:常量值、变量、一个有返回值的函数都可以)

ps:case后面可以有多个表达式

ps:case后面的表达式如果是常量值,则不能重复

补充:穿透-fallthrough,如果在case语句块后增加fallthrough,则会继续执行下一个case,也叫switch穿透

案例讲解

func main() {
	// a,b,c,d,e,f,g
	var week byte
	fmt.Println("请输入一个字符,在a,b,c,d,e,f,g里:")
	fmt.Scanf("%c", &week)
	switch week {
	case 'a':
		fmt.Println("星期一")
	case 'b':
		fmt.Println("星期二")
	case 'c':
		fmt.Println("星期三")
	case 'd':
		fmt.Println("星期四")
	case 'e':
		fmt.Println("星期五")
	case 'f', 'g':
		fmt.Println("周末休息日")
	default:
		fmt.Println("您的输入有误,请重新输入")
	}
}

输出:

请输入一个字符,在a,b,c,d,e,f,g里:
f
周末休息日

2 循环结构

2.1 for循环

for循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化,即执行初始表达式;随后,对布尔表达式进行判定,若判定结果为true,则执行循环体,否则,终止循环;最后在每一次反复的时候,进行某种形式的“步进”,即执行迭代因子。

语法结构:

for 初始表达式; 布尔表达式; 迭代因子 {
	循环体;
}
  1. 初始化部分设置循环变量的初值
  2. 条件判断部分为任意布尔表达式
  3. 迭代因子控制循环变量的增减

简单使用:

func main() {
    for a := 1; a <= 10; a++ {
       fmt.Println("打印", a, "次")
    }
}

输出:

打印 1 次
打印 2 次
打印 3 次
打印 4 次
打印 5 次
打印 6 次
打印 7 次
打印 8 次
打印 9 次
打印 10

注意事项:

  1. 循环条件是返回一个布尔值的表达式

  2. for循环的第二种使用方式

    for 循环判断条件 {
    	// 循环执行语句
    }
    
  3. for循环的第三种使用方式

    for {
        // 循环执行语句
    }
    

    这种方式等价for ; ; {} 是一个无限循环,通常需要配合break语句使用。

  4. Golang提供for-range的方式,可以方便遍历字符串、数组、切片、字典等(注:数组的遍历,我们放到讲数组的时候再讲解),案例说明如何遍历字符串。

    func main() {
        // 字符串遍历方式1-传统方式
        var str string = "hello,world!"
        for i := 0; i < len(str); i++ {
           fmt.Printf("i的值为:%d ,str[i]的值为:%c \n", i, str[i])
        }
    
        fmt.Println()
    
        // 字符串遍历方式2-for-range
        str = "abc~ok!"
        for index, val := range str {
           fmt.Printf("index=%d, val=%c \n", index, val)
        }
    }
    

    **注意:**在使用 for-range 遍历字符串时,返回的 val 类型为 rune 类型,而不是 byte 类型。因为字符串在 Go 语言中是采用 UTF-8 编码,每个 rune 类型表示一个 Unicode 码点,可以正确地表示任何 Unicode 字符。因此,在处理和打印中文字符时,一定要注意字符编码的正确性。

2.2 while和dowhile的实现

while的实现:

for {
    if 循环条件表达式 {
       break // 跳出for循环..
    }
    循环操作(语句)
    循环变量迭代
}

// 例子
func main() {
	var i int = 1
	for {
		if i > 10 {
			break // 跳出for循环..
		}
		fmt.Println("hello world") // 循环操作(语句)
		i++                        // 循环变量迭代
	}
}

do while的实现

for {
    循环操作(语句)
    循环变量迭代
    if 循环条件表达式 {
       break // 跳出for循环..
    }
}

// 例子 
func main() {
	var i int = 1
	for {
		fmt.Println("hello world")
		i++
		if i > 0 { // 故意的
			break // 跳出for循环..
		}
	}
}
// 输出:hello world
2.3 经典案例——打印金字塔
func main() {
    var n int
    fmt.Println("请输入你想要显示的金字塔层数:")
    fmt.Scanf("%d", &n)
    for i := 1; i <= n; i++ {
       // 打印空格
       for j := 1; j <= n-i; j++ {
          fmt.Print(" ")
       }

       // 打印星号
       for k := 1; k <= 2*i-1; k++ {
          fmt.Print("*")
       }

       fmt.Println() // 换行
    }
}

输出:

请输入你想要显示的金字塔层数:
5
    *    
   ***   
  *****  
 ******* 
*********
2.4 经典案例——打印九九乘法表
func main() {
    for i := 1; i <= 9; i++ {
       for j := 1; j <= i; j++ {
          fmt.Printf("%d*%d=%-2d ", j, i, i*j)
       }
       fmt.Println()
    }
}

输出:

1*1=1
1*2=2  2*2=4
1*3=3  2*3=6  3*3=9
1*4=4  2*4=8  3*4=12 4*4=16
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

3 跳转控制语句

3.1 break

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("-----ok")
}

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

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的作用结束离它最近的循环
结果:

i: 1, j: 2
i: 1, j: 3
i: 1, j: 4
i: 2, j: 2
i: 3, j: 2
i: 3, j: 3
i: 3, j: 4
i: 4, j: 2
i: 4, j: 3
i: 4, j: 4
i: 5, j: 2
i: 5, j: 3
i: 5, j: 4
3.2 continue
func main() {
	for i := 1; i <= 100; i++ {
		if i%6 != 0 {
			continue //结束本次循环,继续下一次循环
		}
		fmt.Println(i)
	}
}

结论:continue的作用是结束离它近的那个循环当前循环,开始下一次循环

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

import "fmt"

func main() {
	var (
		input string
		count int
	)

start:
	fmt.Println("请输入一个合法的字符串:")
	fmt.Scan(&input)
	if input == "" {
		goto start
	}

	for i := 0; i < len(input); i++ {
		if input[i] == 'a' || input[i] == 'A' {
			count++
		}
	}

	fmt.Printf("字符串 \"%s\" 中包含 %d 个字母 \"a\"。\n", input, count)
}

以上代码实现了一个简单的统计字符串中字母 “a” 出现次数的程序。程序通过使用无限循环和 goto 语句,让用户输入一个字符串,如果输入的字符串为空,则返回 start 标签,继续要求用户输入。

当用户输入一个非空字符串时,程序开始统计其中字母 “a” 的个数,结束后输出结果。在这个过程中,goto 语句用于实现 “输入不为空时跳转到计算代码块” 的功能。这种方式在少数情况下可能比较有用,但要谨慎使用。

需要注意,过多的使用 goto 语句可能会导致程序阅读性和可维护性降低。因此,在实际编写代码时,应该尽可能避免使用 goto 语句,用更加结构化的语言特性来代替。

3.4 return

return 是 Go 语言中的一个关键字,用于结束当前函数或方法的执行,并返回结果(可选)。return 语句可以带有一个或多个返回值。同时,和其他语言不同的是,在 Go 语言中,return 语句可以被放在函数或方法中的任意位置。

return 语句的使用场景包括但不限于:

  • 在函数或方法执行过程中,需要提前跳出函数或方法;
  • 在函数或方法返回结果之前,需要对某些资源进行清理或释放;
  • 函数或方法执行成功或失败后,需要返回相应结果给调用方;
  • 函数或方法需要直接返回某个值,而不需要继续执行下去。

这里只讲解,提前跳出循环的案例:

func main() {
    for i := 1; i <= 100; i++ {
       fmt.Println(i)
       if i == 4 {
          return //结束当前的函数
       }
    }
    fmt.Println("hello golang")
}

输出:

1
2
3
4

Over~~~

第四章结束啦!!!下一步结构体,冲冲冲!!!文章来源地址https://www.toymoban.com/news/detail-721986.html

到了这里,关于Go学习第四章——程序流程控制的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • GO语言圣经 第四章习题

    编写一个函数,计算两个SHA256哈希码中不同bit的数目。(参考2.6.2节的PopCount函数。) 编写一个程序,默认情况下打印标准输入的SHA256编码,并支持通过命令行flag定制,输出SHA384或SHA512哈希算法。 重写reverse函数,使用数组指针代替slice。 编写一个rotate函数,通过一次循环完成

    2024年02月11日
    浏览(33)
  • 第四章——软件测试流程和规范

    第四章 软件测试流程和规范 学完本章应该明白要做测试或者验证应该分几步,每一步应该干什么,明确一个流程。这个流程是比较标准化的。 本章将从软件过程模型出发,讨论传统的测试过程和敏捷测试过程,进而扩展到基于脚本的测试和探索式测试,然后讨论测试过程改

    2024年02月09日
    浏览(49)
  • 信息安全系统导论第四章访问控制

    1)基本目标:依据授权对提出的资源访问请求进行控制,防止对任何资源进行未授权的访问。 2)访问控制模型基本组成: 3)三要素: 主体(subject):访问的发起者,通常为进程或用户。 客体(object):可供访问的各种软硬件资源。 策略(policy):定义了主体对客体的权

    2024年02月13日
    浏览(46)
  • 《计算机网络》第四章 数据链路控制

    为什么要设计数据链路层 在原始的物理传输线路上传输数据信号是有差错的, 存在一定的误码率 。 在设计数据链路层的目的就是如何在有差错的线路上, 进行无差错传输 。向网络层提供高质量的服务。 从网络参考来看,物理层之上各层都有改善 数据传输质量 的要求,数

    2024年02月01日
    浏览(48)
  • 算法详解+代码(无人驾驶车辆模型预测控制第四章)

    首先对汽车运动学模型进行建模: ​ 设后轴速度为,前轴行速度为考虑后轴轴心的速度约束,得到和后轴速度的关系如下:                                             考虑到前后轴速度约束的运动学方程为:       设后轴行驶中心为,前轴行驶中心为,根据前后轴之

    2024年02月03日
    浏览(39)
  • 小黑子—spring:第四章 事务控制与整合web环境

    事务是开发中必不可少的东西,使用JDBC开发时,我们使用connnection对事务进行控制,使用MyBatis时,我们使用SqlSession对事务进行控制,缺点显而易见,当我们切换数据库访问技术时,事务控制的方式总会变化,Spring 就将这些技术基础上,提供了统一的控制事务的接口。Spring的

    2024年02月06日
    浏览(40)
  • 微信小程序第四章(页面组件)

    了解小程序组件 掌握视图容器组件 掌握基础内容组件 掌握表单组件 掌握多媒体组件 掌握其他高级组件 组件是页面视图层(WXML)的基本组成单元,组件组合可以构建功能强大的页面结构。小程序框架为开发者提供了器视图、基础内容、表单、导航、多媒体、地图、画布、开放

    2024年04月25日
    浏览(52)
  • 西瓜书学习笔记---第四章 决策树

    目录 一、题目要求 二、数据集介绍  三、决策树模型 3.1 决策树模型介绍 3.2 决策树算法原理 3.2.1 决策树的建立 3.2.2 决策树的划分(1)—信息增益ID3 3.2.3 决策树的划分(2)—Gini指数CART 3.2.4 预剪枝pre-pruning 3.2.5 后剪枝post-pruning 3.3 决策树算法核心代码解释 四、运行结果

    2024年02月04日
    浏览(45)
  • 第四章 微信小程序页面组件作业

    步骤: 在index.js中输入代码: 在index.json中输入代码: 在index.wmxl中输入代码: 运行结果如下: 步骤: 插入所需要的图片在images中 在index.wxss中输入代码: 在index.json中输入代码: 在index.wxml中输入代码: 运行效果: 在index.wxml中输入代码: 在index.js中输入代码: 运行效果:

    2024年04月08日
    浏览(44)
  • MySQL学习记录:第四章 TCL语言

    /* TCL语言 :transaction control language 事务控制语言 事务 : 一个或一组语句组成的一个执行单元,该执行单元要么全执行,要么全不执行 事务由单独单元的一个或多个SQL语句组成,在这个单元中,每个MySQL语句是相互依赖的。而整个单独单元作为一个不可分割的整体,如果单元

    2024年02月14日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包