GO语言学习之语句块的实现
更新时间：2025年06月30日 08:33:32 作者：唯独不开心
本文主要介绍了GO语言学习之语句块的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
顺序语句
顺序语句，顾名思义就是每条语句依次执行。
流程图：
示例：
package main
import "fmt"
func main() {
var a int = 10
var b int = 20
sum := a + b
fmt.Printf("a + b = %d", sum);
}在这个例子中，变量 a和 b依次被声明和初始化，然后执行加法运算并将结果赋值给 sum，最后打印输出结果。这些语句按照它们在代码中出现的顺序依次执行。
分支语句
if 分支语句
if - else语句：用于根据条件执行不同的代码块。
流程图：
示例：
package main
import "fmt"
func main() {
condition := []bool {true, false}
if condition[0] {
fmt.Println("condition[0] is true")
} else {
fmt.Println("condition[0] is false")
}
if condition[1] {
fmt.Println("condition[1] is true")
} else {
fmt.Println("condition[1] is false")
}
}if - else if - else链：用于处理多个互斥条件。
流程图：
示例：
package main
import "fmt"
func main() {
condition := []int {1, 2, 3}
fmt.Println("condition[3] = ", condition)
if condition[0] == 1 {
fmt.Println("condition[0] == 1")
} else if condition[0] == 2 {
fmt.Println("condition[0] == 2")
} else {
fmt.Println("condition[0] not equal 1 or 2")
}
if condition[1] == 1 {
fmt.Println("condition[1] == 1")
} else if condition[1] == 2 {
fmt.Println("condition[1] == 2")
} else {
fmt.Println("condition[1] not equal 1 or 2")
}
if condition[2] == 1 {
fmt.Println("condition[2] == 1")
} else if condition[2] == 2 {
fmt.Println("condition[2] == 2")
} else {
fmt.Println("condition[2] not equal 1 or 2")
}
}switch分支语句
switch - case 语句：是一种更简洁的多分支选择结构，根据表达式的值来选择执行哪个 case 分支。
1. switch 可以用在其他类型上，case 后的数值必须和switch作用的变量类型一致
2. case 是无序的
3. case后的数值是唯一的，
4. default语句是可选的
5. case分支默认不需要加 break直接退出
6. 如果想继续执行需要加上fallthrough
7. 可以省略switch 后面的变量，相当于每个分支是：true 则执行对应的语句块
8. break 可以用在switch 中， 也可以使用在for 循环语句中
9. break 用于强制结束case语句，从而结束switch分支
10. 遇到 fallthrough 无需匹配后续分支，继续执行
流程图：
示例：
package main
import "fmt"
const (
MONDAY = 1,
TUESDAY = 2,
WEDNESDAY = 3,
THURSDAY = 4,
FRIDAY = 5,
SATURDAY = 6,
SUNDAY = 7,
)
func check_week_days(day int)
{
switch day {
case MONDAY:
fmt.Println("Monday")
case TUESDAY:
fmt.Println("Tuesday")
case WEDNESDAY:
fmt.Println("Wednesday")
case THURSDAY:
fmt.Println("Thursday")
case FRIDAY:
fmt.Println("Friday")
case SATURDAY:
fmt.Println("Saturday")
case SUNDAY:
fmt.Println("Sunday")
default:
fmt.Printf("Error day value %d\n", day)
}
}
func main() {
days := []{ MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY, 100 }
for i := 0; i < len(days); i++ {
fmt.Println("input day is : ", days[i])
check_week_days(days[i])
}
}package main
import "fmt"
func check_month(year int, month int) {
day := 0
switch month {
case 1, 3, 5, 7, 8, 10, 12:
day = 31
case 4, 6, 9, 11:
day = 30
case 2:
if year%400 == 0 || year%4 == 0 && year%100 != 0 {
day = 29
} else {
day = 28
}
default:
fmt.Println("input month outof range, month is ", month)
return
}
fmt.Println(month, "月有 ", day, "天")
}
func main() {
year := 1998
month := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
for i := 0; i < len(month); i++ {
fmt.Println("判断的 month is ", month[i])
check_month(year, month[i])
}
}还有一种特殊的 switch case 语句，不带条件的使用方式，此时，判断分支的case 分支的 布尔值是否为 true，执行为 true的分支。但是，这里有一个有趣的地方就是，这里的每个分支检测的应该是同一个变量的布尔表达式，我用示例代码证明了，这个疑问。
正确的使用姿势：
package main
import "fmt"
func check_level(a int) {
switch {
case a > 100:
fmt.Println("more than scope")
case a > 90:
fmt.Println("A")
case a > 80:
fmt.Println("B")
case a > 70:
fmt.Println("C")
default:
fmt.Println("D")
}
}
func main() {
a := []int {70, 81,91, 101, 2}
for i := 0;i < len(a); i++ {
fmt.Println("input value : ", a[i])
check_level(a[i])
}
}多个变量的结果，结果不确定，你多执行几次，还不一样，这样的代码不可靠！！！！
package main
import "fmt"
func main() {
a := 2
b := 1
c := 1
switch {
case a == 1:
fmt.Println("case a")
case b == 1:
fmt.Println("case b")
case c == 1:
fmt.Println("case c")
default:
fmt.Println("a and b not equal 1")
}
}循环语句
for循环语句： Go 语言中只有 for 这一种循环结构，但它可以实现类似其他语言中 for、while 和 do - while 循环的功能。
经典for循环：
语法：for init; condition; post { 循环体 }
其中，init 是初始化语句，condition 是循环条件，post 是每次循环结束后执行的语句。
流程图：
示例 1：
package main
import "fmt"
func main() {
value := []int {1,2,3,4,5,6,7,8,9,10}
sum := 0
for i:=0;i < len(value);i++ {
sum += value[i]
}
fmt.Println("对数组 ", value, " 求和的结果是：", sum)
}示例 2：
package main
import "fmt"
func main() {
value := []int{1,2,3,4,5,6,7,8,9,10}
sum := 0
for i, v := range value {
fmt.Println("当前索引 ", i, " 当前值 ", v)
sum += v
}
fmt.Println("求数组 ", value, " 和的结果： ", sum)
}while风格的for循环：
省略 init 和 post 部分，只保留 condition，类似其他语言中的 while 循环。
流程图：
示例：
package main
import "fmt"
func main() {
value := []int {1,2,3,4,5,6,7,8,9,10}
sum := 0
i := 0
for i < len(value) {
sum += value[i]
i++
}
fmt.Println("对数组 ", value, " 求和的结果：", sum)
}无限循环：
省略所有部分，即 for { }，可以通过 break 语句跳出循环。
流程图：
示例 1：
package main
import "fmt"
func main() {
value := []int{1,2,3,4,5,6,7,8,9,10}
sum := 0
i := 0
for {
if i < len(value) {
sum += value[i]
fmt.Println("和 ", sum, "当前值 ", value[i])
i++
} else {
break;
}
}
fmt.Println("对数组 ", value, " 求和的结果：", sum)
}示例 2：（补充goto语句的使用）
package main
import "fmt"
func main() {
for i := 1;i < 10;i++ {
j := 1
start:
if (j <= i) {
fmt.Printf("%d * %d = %d ", i, j, i * j)
j++
goto start;
} else {
fmt.Println()
}
}
}到此这篇关于GO语言学习之语句块的实现的文章就介绍到这了,更多相关GO 语句块内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
这篇文章主要介绍了golang判断chan channel是否关闭的方法,结合实例形式对比分析了Go语言判断chan没有关闭的后果及关闭的方法,需要的朋友可以参考下2016-07-07
这篇文章主要介绍了golang 熔断器的实现过程，Go 项目中使用熔断技术提高系统容错性。接下俩就来给打家介绍 go 熔断器和其使用,需要的朋友可以参考一下2022-01-01
这篇文章主要介绍了golang中的单引号转义问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2023-02-02
这篇文章主要为大家介绍了Go Java算法之单词搜索示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-08-08
go mod可以使项目从GOPATH的强制依赖中独立出来，也就是说你的项目依赖不再需要放在在GOPATH下面了,下面这篇文章主要给大家介绍了关于Golang必知必会之Go Mod命令的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下2022-07-07
这篇文章主要为大家介绍了Go设计模式原型模式考查点及使用详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-12-12
GO excelize读取excel进行时间类型转换的示例代码(自动转换)
我们经常会遇到如何自动识别excel中的时间类型数据并转化成对应的 "Y-m-d H:i:s"类型数据,本文小编给大家介绍了GO excelize读取excel进行时间类型转换的示例代码(自动转换),需要的朋友可以参考下2024-10-10
这篇文章主要介绍了GO语言的数组array与切片slice,包括了GO语言数组定义赋值,GO语言多维数组,GO语言切片等知识点需要的朋友可以参考下2022-12-12
本文中，我们将解释Go语言中反射的运作机制。每个编程语言的反射模型不大相同，很多语言索性就不支持反射（C、C++）。由于本文是介绍Go语言的，所以当我们谈到“反射”时，默认为是Go语言中的反射。2016-08-08
这篇文章主要为大家学习介绍了如何利用Golang实现反向代理，文中的示例代码讲解详细，具有一定的学习价值，感兴趣的小伙伴可以跟随小编一起了解一下2023-07-07
最新评论