索取营销诊断书
021-80394720QQ
    您的位置：上海毫米网络优化公司 > 网站优化分享 >
    相关推荐recommended
    Golang流程控制语句
    作者：mmseoamin日期：2024-04-30

    文章目录

    • 顺序控制
    • 分支控制
      • if语句
      • switch语句
      • 循环控制
        • for循环语句
        • 跳转控制
          • break语句
          • continue语句
          • goto语句
          • return语句

            顺序控制

            顺序控制

            默认情况下，Go代码执行顺序是按照从上到下依次执行的，这种按照顺序执行的代码就叫做顺序语句。如下：

            package main
import "fmt"
func main() {
	// 顺序控制
	fmt.Println("statement 1...")
	fmt.Println("statement 2...")
	fmt.Println("statement 3...")
}

            分支控制

            if语句

            if语句

            Go中if语句的基本语法如下：

            Golang流程控制语句,在这里插入图片描述,第1张

            使用案例如下：

            package main
import "fmt"
func main() {
	// if语句
	var num1, num2 int = 10, 20
	if num1 > num2 {
		fmt.Println("num1 > num2")
	} else if num1 < num2 {
		fmt.Println("num1 < num2")
	} else {
		fmt.Println("num1 = num2")
	}
}

            说明一下：

            • 执行if语句时，会依次判断各个条件表达式，找到第一个结果为true的if分支并执行对应的代码块，如果所有条件表达式都不成立，则执行最后的else代码块。
            • if语句中的else if分支可以有一个或多个，最后的else分支是可选的，if语句支持嵌套。
            • 每一个if分支的{}都是必须的，就算代码块中只有一行代码也不能省略，否则会产生报错。
            • if语句中的条件表达式不需要用()包裹，虽然加上也不会报错，但是不建议这样做。
            • if语句的条件表达式不能是赋值语句，比如if flag = false，否则会产生报错。

              if后声明变量

              if语句支持在if后声明一个变量，并以分号结束，然后在分号后面再给出条件表达式。如下：

              package main
import "fmt"
func main() {
	// if后声明变量
	var num = 10
	if base := 20; num < base {
		fmt.Println("num < base")
	}
}

              注意： 在if后声明的变量仅在if语句中有效。

              switch语句

              switch语句

              Go中switch语句的基本语法如下：

              Golang流程控制语句,在这里插入图片描述,第2张

              使用案例如下：

              package main
import "fmt"
func main() {
	// switch语句
	var year, month int = 2024, 4
	switch month {
	case 1, 3, 5, 7, 8, 10, 12:
		fmt.Println("这个月有31天")
	case 4, 6, 9, 11:
		fmt.Println("这个月有30天")
	case 2:
		day := 28
		if (year%4 == 0 && year%100 != 0) || (year%400 == 0) {
			day++
		}
		fmt.Printf("这个月有%d天\n", day)
	default:
		fmt.Println("无效月份!")
	}
}

              说明一下：

              • 执行switch语句时，会将表达式依次与各个case后的表达式进行比较，如果匹配成功，则执行对应case的代码块，如果所有case后的表达式都不匹配，则执行最后的default代码块，最后的default是可选的。
              • switch语句中的case可以有多个，并且每个case后可以带多个表达式，表达式之间使用逗号分隔。程序执行完case语句的代码块后会直接退出switch控制，不需要在代码块最后加break语句。
              • switch和case后面的表达式可以是常量值、变量、有返回值的函数调用等，case后的表达式如果是常量值（字面量），则要求不能重复。case后的各个表达式的值的数据类型，必须和switch后的表达式的数据类型一致。

                switch后声明变量

                switch语句支持在switch后声明一个变量，并以分号结束，然后在分号后面再给出表达式。如下：

                package main
import "fmt"
func main() {
	// switch后声明变量
	switch year, month := 2024, 4; month {
	case 1, 3, 5, 7, 8, 10, 12:
		fmt.Println("这个月有31天")
	case 4, 6, 9, 11:
		fmt.Println("这个月有30天")
	case 2:
		day := 28
		if (year%4 == 0 && year%100 != 0) || (year%400 == 0) {
			day++
		}
		fmt.Printf("这个月有%d天\n", day)
	default:
		fmt.Println("无效月份!")
	}
}

                注意： 在switch后声明的变量仅在switch语句中有效。

                switch穿透

                在执行完对应的case语句的代码块后，程序会直接退出switch控制，如果希望程序继续执行下一个case语句的代码块，可以在代码块的最后通过fallthough关键字实现switch穿透。如下：

                package main
import "fmt"
func main() {
	// switch穿透
	var num int = 2
	switch num {
	case 1:
		fmt.Println("case 1 block...")
	case 2:
		fmt.Println("case 2 block...")
		fallthrough // 继续执行下一个case的代码块
	case 3:
		fmt.Println("case 3 block...")
	default:
		fmt.Println("default block...")
	}
}

                注意： switch穿透默认只会穿透一层，如果希望执行下面更多case的代码块，需要再次穿透。

                Type Switch

                switch语句可以用于判断某个interface变量实际指向的变量类型，然后根据不同的类型执行相应的代码逻辑。如下：

                package main
import "fmt"
func main() {
	// Type Switch
	var num int = 10
	var x interface{} = num
	switch t := x.(type) {
	case int:
		fmt.Println("int类型")
	case float64:
		fmt.Println("float64类型")
	case string:
		fmt.Println("string类型")
	default:
		fmt.Printf("未处理类型: %T\n", t)
	}
}

                说明一下：

                • interface{}叫做空接口类型，其可以接收任意类型的变量值，在必要时需要通过类型断言的方式获取到变量原本的类型，而Type Switch就是一种类型断言的方式。

                  无表达式的switch

                  switch语句后可以不带表达式，这时在case后放条件表达式可以达到if语句的效果。如下：

                  package main
import "fmt"
func main() {
	// 无表达式的switch
	var num1, num2 int = 10, 20
	switch {
	case num1 > num2:
		fmt.Println("num1 > num2")
	case num1 < num2:
		fmt.Println("num1 < num2")
	default:
		fmt.Println("num1 = num2")
	}
}

                  说明一下：

                  • 这里每个case后也可以带多个条件表达式，表达式之间使用逗号分隔。

                    循环控制

                    for循环语句

                    for循环语句

                    Go中for循环语句的基本语法如下：

                    Golang流程控制语句,在这里插入图片描述,第3张

                    使用案例如下：

                    package main
import (
	"fmt"
)
func main() {
	// for循环语句
	for i := 1; i <= 10; i++ {
		fmt.Printf("%d ", i)
	}
	fmt.Println()
}

                    说明一下：

                    • 在执行for循环语句时，会先执行循环遍历初始化的语句，然后不断根据循环条件判断是否执行循环体操作，如果循环条件为真则执行一次循环体操作并进行一次循环变量迭代，如果循环条件为假则退出for循环。

                      for循环的其他用法

                      在使用for循环语句时，可以只在for后指明循环条件，而将循环变量的初始化和循环变量的迭代放在其他位置。如下：

                      Golang流程控制语句,在这里插入图片描述,第4张

                      使用案例如下：

                      package main
import (
	"fmt"
)
func main() {
	// for循环语句
	i := 1
	for i <= 10 {
		fmt.Printf("%d ", i)
		i++
	}
	fmt.Println()
}

                      在使用for循环语句时，以for{}或for ; ; {}表示无限循环，通常需要配合break语句使用。如下：

                      Golang流程控制语句,在这里插入图片描述,第5张

                      使用案例如下：

                      package main
import (
	"fmt"
)
func main() {
	// for循环语句
	for {
		fmt.Println("这是一个死循环...")
		time.Sleep(time.Second)
	}
}

                      说明一下：

                      • Sleep是time包中的一个函数，用于阻塞当前goroutine指定时间，其参数的类型是Duration。
                      • Second是time包中的一个Duration类型的常量，表示1秒。

                        for range循环

                        Go中的for range循环，可以方便的对string、数组、切片、map等数据类型中的元素进行遍历。如下：

                        package main
import (
	"fmt"
)
func main() {
	// for range循环
	var s string = "Hello 世界"
	for index, value := range s {
		fmt.Printf("s[%d] = %c\n", index, value)
	}
}

                        在使用for range遍历string时，它会按照UTF-8编码格式解析字符串，并以Unicode字符作为迭代的单位，每次迭代都会返回字符串中的一个Unicode字符（rune）和对应的索引，无论是单字节的ASCII字符还是多字节的汉字，都会被正确地解析并返回。上述程序的运行结果如下：

                        Golang流程控制语句,在这里插入图片描述,第6张

                        说明一下：

                        • 在for range循环中遍历字符串时，每次迭代会返回两个值，第一个是字符的索引，第二个是字符的值，当遍历结束后会自动退出for循环。

                          跳转控制

                          break语句

                          break语句

                          Go中break语句可以用于跳出for循环语句或switch语句。如下：

                          package main
import "fmt"
func main() {
	// break语句
	for i := 0; i < 10; i++ {
		if i == 6 {
			break
		}
		fmt.Printf("%d ", i)
	}
	fmt.Println()
}

                          在多层循环嵌套语句中，break默认只会跳出最近的for循环，如果希望跳出更外层的for循环，可以通过标签进行指明。如下：

                          package main
import "fmt"
func main() {
	// break标签
label:
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			for k := 0; k < 10; k++ {
				if i == 2 && j == 3 && k == 4 {
					break label
				}
				fmt.Printf("i = %d, j = %d, k = %d\n", i, j, k)
			}
		}
	}
}

                          说明一下：

                          • 当使用break语句指定标签时，该标签必须用于标记循环语句或switch语句的起始位置。
                          • 标签的命名应该符合标识符命名规则，标签名由用户自定义。

                            continue语句

                            continue语句

                            Go中continue语句用于for循环中，可以停止当前的迭代并进入下一次迭代。如下：

                            package main
import "fmt"
func main() {
	// continue语句
	for i := 0; i < 10; i++ {
		if i == 6 {
			continue
		}
		fmt.Printf("%d ", i)
	}
	fmt.Println()
}

                            在多层循环嵌套语句中，continue默认只会作用到最近的for循环，如果希望作用到更外层的for循环，可以通过标签进行指明。如下：

                            package main
import "fmt"
func main() {
	// continue标签
label:
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			for k := 0; k < 10; k++ {
				if i == 2 && j == 3 && k == 4 {
					continue label
				}
				fmt.Printf("i = %d, j = %d, k = %d\n", i, j, k)
			}
		}
	}
}

                            说明一下：

                            • 当使用continue语句指定标签时，该标签必须用于标记循环语句的起始位置。

                              goto语句

                              goto语句

                              Go中的goto语句用于无条件地跳转到程序中指定标签的位置。如下：

                              package main
import "fmt"
func main() {
	// goto语句
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			for k := 0; k < 10; k++ {
				if i == 2 && j == 3 && k == 4 {
					goto label
				}
				fmt.Printf("i = %d, j = %d, k = %d\n", i, j, k)
			}
		}
	}
label:
	fmt.Println("other code...")
}

                              说明一下：

                              • goto语句通常与条件语句配合使用，用于实现条件转移，跳出循环体等功能。
                              • Go程序中一般不主张使用goto语句，以免造成程序流程混乱。

                                return语句

                                return语句

                                Go中的return语句在方法或函数中使用，表示跳出所在的方法或函数。如下：

                                package main
import "fmt"
func main() {
	// return语句
	for i := 0; i < 10; i++ {
		if i == 6 {
			return
		}
		fmt.Printf("%d ", i)
	}
}

                                说明一下：

                                • 在普通函数中使用return语句，表示跳出当前函数，可以理解成终止函数。
                                • 在main函数中使用return语句，表示终止main函数，即终止整个程序。
                                 

    上一篇：Rust｜60个新手常犯的错误

    下一篇：Django中的实时通信：WebSockets与异步视图的结合

    网站优化运营
    整站seo优化
    网络营销运营
    成功案例
    品牌创意网站
    营销型网站
    小程序
    微信小程序
    微信公众号
    百度熊掌号
    网站优化分享
    关于我们
    公司概况
    公司新闻
    公司文化
    结构体系
    企业资质
    加入我们
    关注我们
    扫描二维码
    获取更多信息
    精彩一手掌握
    Copyright © 2014-2019 seo,上海网站优化_网络制作_网站seo排名_网站建设推广_上海网络公司 版权所有 沪ICP备19022315号