Golang--流程控制

🕗 发布于 2024-11-05 02:47 golang

1、分支结构

1.1 if分支

单分支

语法：
if 条件表达式 {

逻辑代码

}

当条件表达式为true时，就会执行代码块的代码。
条件表达式左右的()可以不写，也建议不写
if和表达式中间，一定要有空格
在Golang中，{}是必须有的,就算你只写一行代码。
在golang里，if后面可以并列的加入变量的定义
package main  

import (  
"fmt"
)  

func main() {  
if true {
fmt.Println("hello")
}
}
package main  

import (  
"fmt"
)  

func main() {  
if a,b := 1,2; a < b {
fmt.Println("hello")
}
}

双分支

正确语法：

if 条件表达式 {

逻辑代码1

} else {

逻辑代码2

}

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

错误语法：

if 条件表达式 {

逻辑代码1

}

else {

逻辑代码2

}


package main  

import (  
"fmt"
)  

func main() {  
if a,b := 10,20; a > b{
fmt.Println("a > b")
}else{
fmt.Println("a < b")
}
}

多分支

语法：

if 条件表达式1 {

逻辑代码1

} else if 条件表达式2 {

逻辑代码2

}

.......

else {

逻辑代码n

}
package main  

import (  
"fmt"
)  

func main() {  
if a,b := 10,10; a > b{
fmt.Println("a > b")
}else if c := 100; a < c{
fmt.Println("a < c")
}else
{
fmt.Println("a == b")
}
}

1.2 switch分支

语法：

switch 表达式 {

case 值1,值2,.….:

语句块1

case 值3,值4,...:

语句块2

....

default:

语句块

}

注意：

switch后的表达式可以是常量值、变量、一个有返回值的函数调用等*
case后面的值如果是常量值(字面量)，则要求不能重复
case后的各个值的数据类型，必须和 switch 的表达式数据类型一致
case后面可以带多个值，使用逗号间隔。比如 case 值1,值2...*
case后面不需要带break* （C语言如果没有break，就会执行后面的case）
default语句不是必须的，位置也是随意的
switch后也可以不带表达式，当做if分支来使用*
switch后也可以直接声明/定义一个变量，分号结束，不推荐*
switch穿透，利用fallthrough关键字，如果在case语句块后增加fallthrough ,则会继续执行下一个case,也叫switch穿透。
package main
import "fmt"
func main(){
        //实现功能：根据给出的学生分数，判断学生的等级：
        // >=90  -----A
        // >=80  -----B
        // >=70  -----C
        // >=60  -----D
        // <60   -----E
        //给出一个学生分数：
        var score int = 187
        //根据分数判断等级：
        //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("您的成绩有误")
        }
        
}

2、循环结构

2.1 for循环

for循环语法：
for 初始表达式; 布尔表达式; 迭代因子 { //注意：这里迭代因子只能有一个
循环体;
}

注意：

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

import (  
"fmt"
)  

func main() {  
for i,j := 1,2; i < 10 && j < 10; i++{
fmt.Println(i * j)
j++
}
}

for循环类似while的用法：

package main  

import "fmt"  

func main() {  
    i := 0  
    for i < 5 {  
        fmt.Println(i)  
        i++  
    }  
}

for实现无线循环：

package main  

import "fmt"  

func main() {  
    i := 0  
    for {  
        if i >= 5 {  
            break  
        }  
        fmt.Println(i)  
        i++  
    }  
}

2.2 for range

for range结构是Go语言特有的一种的迭代结构，for range 可以遍历数组、切片、字符串、map 及通道，for range 语法上类似于其它语言中的 foreach 语句，一般形式为：
for key, val := range coll {
...
}
package main  

import "fmt"  

func main() {  
    // 遍历数组  
    arr := []int{1, 2, 3, 4, 5}  
    for i, v := range arr {  
        fmt.Printf("Index: %d, Value: %d\n", i, v)  
    }  

    // 遍历字符串  
    str := "hello"  
    for i, v := range str {  
        fmt.Printf("Index: %d, Character: %c\n", i, v)  
    }  
}

2.3 关键字

2.3.1 break

break可以结束正在执行的循环（break的作用结束离它最近的循环）
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
                        }
                }
        }
        fmt.Println("-----ok")
}

使用标签（可以做到一次break跳出多层循环）：

package main
import "fmt"
func main(){
        //双重循环：
        label2:
        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 label2   //结束指定标签对应的循环
                        }
                }
        }
        fmt.Println("-----ok")
}

2.3.2 continue

continue结束本次循环，继续下一次循环（continue的作用是结束离它近的那个循环，继续离它近的那个循环，即在同一层循环中）
continue 标签，结束指定标签对应的本次循环，可以做到一次跳过指定标签对应的一次循环，并继续下一次循环（注意：如果那个标签没有使用到的话，那么标签不用加，否则报错：定义未使用）

没有使用标签：

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

使用标签：

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

2.3.3 goto

Golang的 goto 语句可以无条件地转移到程序中指定的行。
goto语句通常与条件语句配合使用。可用来实现条件转移.
在Go程序设计中一般不建议使用goto语句，以免造成程序流程的混乱。
package main
import "fmt"
func main(){
        fmt.Println("hello golang1")
        fmt.Println("hello golang2")
        if 1 == 1 {
                goto label1 //goto一般配合条件结构一起使用
        }
        fmt.Println("hello golang3")
        fmt.Println("hello golang4")
        fmt.Println("hello golang5")
        fmt.Println("hello golang6")
        label1:
        fmt.Println("hello golang7")
        fmt.Println("hello golang8")
        fmt.Println("hello golang9")
}

2.3.4 return

直接结束当前函数：

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

原文地址：https://blog.csdn.net/cookies_s_/article/details/143458480

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：快速学会C 语言基本概念和语法结构
下一篇：Java实现图片转pdf

量化交易系统开发-实时行情自动化交易-3.4.3.3.期货市场深度数据
市场深度数据（Order Book Data）是了解市场供需力量的重要工具，显示了不同价位上买卖挂单的数量。通过分析市场深度数据，交易者可以识别支撑位和阻力位，了解流动性情况，为交易策略提供决策依据。
阅读更多2024-11-17
出现“ERR_CONNECTION_REFUSED”的原因及解决方法
通过尝试上述方法，您可能能够解决“ERR_CONNECTION_REFUSED”错误并成功访问该网站。如果问题仍然存在，可能需要进一步深入调查或与技术支持团队联系以解决问题。出现“ERR_CONNEC
阅读更多2024-11-17
聚类分析 | MSADBO优化Spectral谱聚类优化算法
聚类分析 | MSADBO优化Spectral谱聚类优化算法
阅读更多2024-11-17
应用层协议之WebSocket
WebSocket是一种强大的实时通信协议，它的双向通信和持久连接特性使得它在许多实时应用场景中发挥着重要作用。然而，在使用WebSocket时也需要注意其兼容性和安全性问题，并合理评估其对服务器资源
阅读更多2024-11-17
Python的秘密基地--Python基础知识
Python是一种高级、解释型、动态和多范式的编程语言，由Guido van Rossum于1989年底首次发布，1991年正式发布第一个版本。Python以简洁、易读和高效著称，非常适合初学者和专业
阅读更多2024-11-17
泛型11.16
①泛型是Java5的新特性，属于编译阶段的功能。②泛型可以让开发者在编写代码时指定集合中存储的数据类型③泛型作用：1.类型安全：指定了集合中元素的类型之后，编译器会在编译时进行类型检查，如果尝试将错误
阅读更多2024-11-17
Go语言24小时极速学习教程（三）常见标准库用法
常见标准库即Go语言自带的库，这里的所有包都可以通过import直接引入，如果你觉得实在是不好用，那么请先保证你学会了标准库的基础上，再学一下`Gookit`，特别是其中的`GoUtil`，千万不要轻
阅读更多2024-11-17
长连接配置以及断线重连
长连接配置以及断线重连
阅读更多2024-11-17
IDEA2024：右下角显示内存
实时知晓idea内存使用情况。
阅读更多2024-11-17
【Python】如何设置VSCode中的Pylint，消除各种没有必要的警告
最近打开VSCode，编辑之前创建的Python项目，突然发现多了一堆报错和警告，如下图所示。就非常吓人，因为之前这个项目是没有任何报错的，我赶紧试着运行了一下，还好，可以正常运行，那就说明是检测出了
阅读更多2024-11-17