目录
[4.1 Golang 中的流程控制](#4.1 Golang 中的流程控制)
[4.2 条件语句详解](#4.2 条件语句详解)
[4.2.1 if 条件判断基本写法](#4.2.1 if 条件判断基本写法)
[4.2.2 if 条件判断特殊写法](#4.2.2 if 条件判断特殊写法)
[4.2.3 switch语句](#4.2.3 switch语句)
[4.3 循环语句详解](#4.3 循环语句详解)
[4.3.1 for(循环结构)](#4.3.1 for(循环结构))
[4.3.2 for 无限循环](#4.3.2 for 无限循环)
[4.3.3 for range(键值循环)](#4.3.3 for range(键值循环))
[4.4 跳出循环](#4.4 跳出循环)
[4.4.1 break](#4.4.1 break)
[4.4.2 continue(继续下次循环)](#4.4.2 continue(继续下次循环))
[4.4.3 goto(跳转到指定标签)](#4.4.3 goto(跳转到指定标签))
[4.5 练习题：Web3.0智能合约控制流](#4.5 练习题：Web3.0智能合约控制流)
4.1 Golang 中的流程控制
流程控制是每种编程语言控制逻辑走向和执行次序的重要部分，流程控制可以说是一门语言的"经脉"。 Go 语言中最常用的流程控制有if 和 for ，而switch 和 goto主要是为了简化代码、降低重复代码而生的结构，属于扩展类的流程控制。
4.2 条件语句详解
生活案例：智能家居 决策系统
条件语句就像智能家居中的自动化决策系统：
- **if 语句：**如果温度高于28度，则打开空调。
- **if-else 语句：**如果有人在家则开灯，否则关灯。
- switch **语句：**根据天气模式选择不同的家居场景。
4.2.1 if 条件判断基本写法
Go
if 表达式1 {
分支1
} else if 表达式2 {
分支2
} else{
分支3
}当表达式 1 的结果为 true 时，执行分支 1，否则判断表达式 2，如果满足则执行分支 2，都不满足时，则执行分支 3。 if 判断中的 else if 和 else 都是可选的，可以根据实际需要进行选择。
**注意：**Go 语言规定与 if 匹配的左括号{必须与 if 和表达式放在同一行，{放在其他位置会触发编译错误。 同理，与 else 匹配的{也必须与 else 写在同一行，else 也必须与上一个 if 或 else if 右边的大括号在同一行。
举个例子：
Go
package main
import "fmt"
func main() {
score := 65
if score >= 90 {
fmt.Println("A")
} else if score > 75 {
fmt.Println("B")
} else {
fmt.Println("C")
}
}4.2.2 if 条件判断特殊写法
if 条件判断还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断，举个例子：
Go
package main
import "fmt"
func main() {
// 先赋值 score := 56，再去做条件判断
if score := 56; score >= 90 {
fmt.Println("A")
} else if score > 75 {
fmt.Println("B")
} else {
fmt.Println("C")
}
}**思考题：**上下两种写法的区别在哪里？
Go
package main
import "fmt"
func main() {
// score 是一个局部的变量
if score := 56; score >= 90 {
fmt.Println("A")
} else if score > 75 {
fmt.Println("B")
} else {
fmt.Println("C")
}
fmt.Println(score) // undefined: score
}练习： 求两个数的最大值 (注意 go 语言中没有三目运算)
Go
package main
import "fmt"
func main() {
a := 99
b := 100
max := 0
if a > b {
max = a
} else {
max = b
}
fmt.Println(max)
}**练习：**判断一个人的成绩 小于 60 分不及格 大于等于 60 小于 80 及格，大于 80 优秀
Go
package main
import "fmt"
func main() {
score := 78
if score >= 80 {
fmt.Println("分数大于80分，真优秀！！")
} else if score > 60 && score < 80 {
fmt.Println("分数大于60小于80分，及格")
} else {
fmt.Println("分数小于60分，得努力！！")
}
}4.2.3 switch 语句
使用 switch 语句可方便地对大量的值进行条件判断。
**练习：**判断文件类型,如果后缀名是 .html 输入 text/html, 如果后缀名.css 输出 text/css ,如果后缀名是.js 输出 text/javascript
Go 语言规定每个 switch 只能有一个 default 分支。
Go
package main
import "fmt"
func main() {
extname := ".html"
switch extname {
case ".html":
fmt.Println("text/html")
break
case ".css":
fmt.Println("text/css")
break
case ".js":
fmt.Println("text/javascript")
break
default:
fmt.Println("格式错误")
break
}
}Go 语言中每个 case 语句中可以不写 break，不加 break 也不会出现穿透的现象。
穿透现象（Fall-through）是指 ：当某个
case匹配成功后，如果没有break语句，程序会继续执行后续所有case的代码块，直到遇到break或整个switch结束。
如下例子：
Go
package main
import "fmt"
func main() {
extname := ".html"
switch extname {
case ".html":
fmt.Println("text/html")
case ".css":
fmt.Println("text/css")
case ".js":
fmt.Println("text/javascript")
default:
fmt.Println("格式错误")
}
}一个分支可以有多个值，多个 case 值中间使用英文逗号分隔。
Go
package main
import "fmt"
func main() {
n := 2
switch n {
case 1, 3, 5, 7, 9:
fmt.Println("奇数")
case 2, 4, 6, 8:
fmt.Println("偶数")
default:
fmt.Println(n)
}
}另一种写法：
Go
package main
import "fmt"
func main() {
switch n := 7; n {
case 1, 3, 5, 7, 9:
fmt.Println("奇数")
case 2, 4, 6, 8:
fmt.Println("偶数")
default:
fmt.Println(n)
}
}**注意：**上面两种写法的作用域
分支还可以使用表达式，这时候 switch 语句后面不需要再跟判断变量。例如：
Go
package main
import "fmt"
func main() {
age := 56
switch {
case age < 25:
fmt.Println("好好学习吧！！")
case age > 25 && age <= 60:
fmt.Println("好好工作吧！！")
case age > 60:
fmt.Println("好好享受吧！！")
default:
fmt.Println("活着真好！！")
}
}switch 的穿透 fallthrought
fallthrough`语法可以执行满足条件的 case 的下一个 case，是为了兼容 C 语言中的 case 设计的。
Go
package main
import "fmt"
func main() {
s := "a"
switch {
case s == "a":
fmt.Println("a")
fallthrough fallthrough // 继续往下走，**不再判断** case s == "b" 的条件
case s == "b":
fmt.Println("b")
case s == "c":
fmt.Println("c")
default:
fmt.Println("...")
}
}
Go
package main
import "fmt"
func main() {
var num int = 10
switch num {
case 10:
fmt.Println("ok1")
fallthrough
case 20:
fmt.Println("ok2")
fallthrough
case 30:
fmt.Println("ok3")
default:
fmt.Println("没有匹配到..")
}
}案例1：
Go
package main
import "fmt"
func main() {
fmt.Println("🏠 智能家居控制系统")
fmt.Println("========================")
// 当前家居状态
currentTemperature := 26.0
isHome := true
weather := "晴天"
hour := 14 // 24小时制
fmt.Println("📊 当前状态:")
fmt.Printf("温度: %.1f°C\n", currentTemperature)
fmt.Printf("有人在家: %t\n", isHome)
fmt.Printf("天气: %s\n", weather)
fmt.Printf("时间: %d:00\n", hour)
// 基本的 if 语句
fmt.Println("\n🌡️ 温度控制:")
if currentTemperature > 28 {
fmt.Println(" 打开空调")
}
if currentTemperature < 18 {
fmt.Println(" 打开暖气")
}
// if-else 语句
fmt.Println("\n💡 灯光控制:")
if isHome {
fmt.Println(" 打开客厅灯光")
} else {
fmt.Println(" 关闭所有灯光")
}
// if-else if-else 语句
fmt.Println("\n🎵 音乐控制:")
if hour >= 6 && hour < 12 {
fmt.Println(" 播放清晨音乐")
} else if hour >= 12 && hour < 18 {
fmt.Println(" 播放午后音乐")
} else if hour >= 18 && hour < 22 {
fmt.Println(" 播放晚间音乐")
} else {
fmt.Println(" 静音模式")
}
// 在条件中声明变量
fmt.Println("\n💧 湿度控制:")
if humidity := getCurrentHumidity(); humidity > 80 {
fmt.Printf(" 当前湿度 %d%%，开启除湿模式\n", humidity)
} else if humidity < 30 {
fmt.Printf(" 当前湿度 %d%%，开启加湿模式\n", humidity)
} else {
fmt.Printf(" 当前湿度 %d%%，舒适范围\n", humidity)
}
// switch 语句
fmt.Println("\n🌤️ 天气模式:")
switch weather {
case "晴天":
fmt.Println(" 打开窗帘，调节室内亮度")
case "阴天":
fmt.Println(" 适度补光，调节色温")
case "雨天":
fmt.Println(" 关闭窗户，增加室内照明")
case "雪天":
fmt.Println(" 开启地暖，增加室内亮度")
default:
fmt.Println(" 保持当前状态")
}
// 表达式 switch
fmt.Println("\n⏰ 时间段判断:")
switch {
case hour >= 5 && hour < 12:
fmt.Println(" 早晨模式：轻柔唤醒")
case hour >= 12 && hour < 14:
fmt.Println(" 午间模式：休息时光")
case hour >= 14 && hour < 18:
fmt.Println(" 下午模式：工作学习")
case hour >= 18 && hour < 22:
fmt.Println(" 晚间模式：休闲娱乐")
default:
fmt.Println(" 夜间模式：安静节能")
}
// 复杂条件组合
fmt.Println("\n🎯 综合决策:")
if isHome && currentTemperature > 28 && weather == "晴天" {
fmt.Println(" 家中有人的高温晴天：")
fmt.Println(" - 打开空调")
fmt.Println(" - 关闭窗帘")
fmt.Println(" - 开启风扇")
}
if !isHome || weather == "暴雨" {
fmt.Println(" 无人在家或暴雨天气：")
fmt.Println(" - 关闭所有窗户")
fmt.Println(" - 关闭不必要的电器")
fmt.Println(" - 启用安防模式")
}
// fallthrough 示例
fmt.Println("\n📈 温度等级:")
temperatureLevel := ""
switch {
case currentTemperature >= 35:
temperatureLevel = "酷热"
fallthrough
case currentTemperature >= 30:
fmt.Println(" 高温警告")
case currentTemperature <= 0:
temperatureLevel = "严寒"
fallthrough
case currentTemperature <= 5:
fmt.Println(" 低温警告")
default:
temperatureLevel = "舒适"
}
fmt.Printf(" 当前温度等级: %s\n", temperatureLevel)
}
// 模拟获取湿度的函数
func getCurrentHumidity() int {
return 65
}4.3 循环语句详解
生活案例：智能家居 巡检系统
循环语句就像智能家居的自动化巡检：
- for循环：定期检查所有设备状态
- range循环：遍历所有房间和设备
- 无限循环：持续监控安全状态
- break/continue：处理异常情况和跳过检查
4.3.1 for(循环结构)
Go 语言中的所有循环类型均可以使用 for 关键字来完成。
Go
for 初始语句;条件表达式;结束语句{
循环体语句
}条件表达式返回 true 时循环体不停地进行循环，直到条件表达式返回 false 时自动退出循环。
Go
package main
import "fmt"
func main() {
count := 10
for i := 0; i < count; i++ {
fmt.Println("第%v次输出", i)
}
}for 循环的初始语句可以被忽略，但是初始语句后的分号必须要写，例如：
Go
package main
import "fmt"
func main() {
count := 10
i := 0
for ; i < count; i++ {
fmt.Printf("第%v次输出\n", i)
}
}for 循环的初始语句和结束语句都可以省略，例如：
Go
package main
import "fmt"
func main() {
count := 10
i := 0
for i < count {
fmt.Printf("第%v次输出\n", i)
i++
}
}这种写法类似于其他编程语言中的 while，在 while 后添加一个条件表达式，满足条件表达式时持续循环，否则结束循环。
注意：Go 语言中是没有 while 语句的，我们可以通过 for 代替
4.3.2 for 无限循环
Go
for {
循环体语句
}for 循环可以通过 break、goto、return、panic 语句强制退出循环。
Go
package main
import "fmt"
func main() {
k := 1
for { // 这里也等价与 for ; ;
if k <= 10 {
fmt.Println("ok~~", k)
} else {
break // break就是跳出这个for循环
}
k++
}
}**练习：**打印 0-50 所有的偶数
Go
package main
import "fmt"
func main() {
for k := 0; k < 50; k++ {
if k != 0 && k%2 == 0 {
fmt.Println("0-50的偶数有：", k)
}
}
}练习：打印 1~100 之间所有是 9 的倍数的整数的个数及总和
Go
package main
import "fmt"
func main() {
i := 0
sum := 0
for k := 0; k <= 100; k++ {
if k%9 == 0 {
sum += k
i++
}
}
fmt.Printf("9的倍数的个数为：%v\n", i)
fmt.Printf("总和为：%v", sum)
}**练习：**求 1+2+3+4 +...100 的和
Go
package main
import "fmt"
func main() {
sum := 0
for k := 0; k <= 100; k++ {
sum += k
}
fmt.Printf("总和为：%v", sum)
}练习 ：计算 5 的阶乘 (12 34 5 n 的阶乘 1*2......*n)
Go
package main
import "fmt"
func main() {
jieceng := 1
for k := 2; k <= 5; k++ {
jieceng *= k
}
fmt.Printf("总和为：%v", jieceng)
}**练习：**打印一个矩形。
Go
package main
import "fmt"
func main() {
for i := 1; i <= 12; i++ {
fmt.Print("*")
if i%4 == 0 { // 表示换行
fmt.Println()
}
}
}嵌套循环解决这个问题
Go
package main
import "fmt"
func main() {
kuan := 4
chang := 8
for i := 1; i <= kuan; i++ {
for j := 1; j <= chang; j++ {
fmt.Print("*")
}
fmt.Println()
}
}**练习：**打印一个等边三角形。
Go
package main
import "fmt"
func main() {
const n = 10 // 想打印多少行
tri := make([][]int, n)
for i := 0; i < n; i++ {
tri[i] = make([]int, i+1)
tri[i][0], tri[i][i] = 1, 1
for j := 1; j < i; j++ {
tri[i][j] = tri[i-1][j-1] + tri[i-1][j]
}
}
// 控制台三角形
for i := 0; i < n; i++ {
// 前面留白
for k := 0; k < n-i; k++ {
fmt.Print(" ")
}
for j := 0; j <= i; j++ {
fmt.Printf("%-4d", tri[i][j])
}
fmt.Println()
}
}**练习：**打印出九九乘法表
1x1=1
2x1=2 2x2=4
3x1=3 3x2=6 3x3=9
4x1=4 4x2=8 4x3=12 4x4=16
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
Go
package main
import "fmt"
func main() {
for i := 1; i <= 9; i++ {
for j := 1; j <= i; j++ {
fmt.Print(i, "*", j, "=", i*j, " ")
}
fmt.Println()
}
}4.3.3 for range(键值循环)
Go 语言中可以使用 for range 遍历数组、切片、字符串、map 及通道（channel）。 通过 for range 遍历的返回值有以下规律：
（1）数组、切片、字符串返回索引和值。
（2）map 返回键和值。
（3）通道（channel）只返回通道内的值。
Go
package main
import "fmt"
func main() {
str := "abc 上海"
// 输出索引和值的内容
for index, val := range str {
fmt.Printf("index = %d,val=%c\n", index, val)
}
// 输出值的内容
for _, val := range str {
fmt.Printf("val = %c\n", val)
}
// 输出键的内容
for index, _ := range str {
fmt.Printf("val = %d\n", index)
}
}项目案例1：
Go
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("🔄 循环语句 - 智能家居巡检系统")
fmt.Println("========================")
// 设备列表
deviceList := []string{"主卧灯光", "客厅空调", "厨房烟雾报警器", "卫生间排风扇", "大门门锁"}
// 房间列表
roomList := []string{"客厅", "主卧", "次卧", "厨房", "卫生间"}
// 基本的 for 循环
fmt.Println("🔧 设备状态检查:")
for i := 0; i < len(deviceList); i++ {
fmt.Printf("检查设备: %s", deviceList[i])
time.Sleep(300 * time.Millisecond) // 模拟检查耗时
fmt.Printf(" - ✅ 正常\n")
}
// range 循环遍历切片
fmt.Println("\n🏠 房间巡检:")
for index, room := range roomList {
fmt.Printf("%d. 检查%s: ", index+1, room)
time.Sleep(500 * time.Millisecond)
// 模拟不同房间的检查结果
switch room {
case "厨房":
fmt.Printf("发现窗户未关")
case "卫生间":
fmt.Printf("排风扇需要清洁")
default:
fmt.Printf("正常")
}
fmt.Println()
}
// while 风格的循环（Go 中用 for 实现）
fmt.Println("\n📊 持续监控模式:")
monitorCount := 0
for monitorCount < 3 {
monitorCount++
fmt.Printf("第 %d 次全屋监控 - ", monitorCount)
// 模拟监控结果
if monitorCount == 2 {
fmt.Printf("发现异常: 客厅温度过高\n")
} else {
fmt.Printf("一切正常\n")
}
time.Sleep(1 * time.Second)
}
// 无限循环配合 break
fmt.Println("\n🚨 安防监控系统:")
anomalyCount := 0
for {
// 模拟安全检测
if detectAnomaly() {
anomalyCount++
fmt.Printf("⚠️ 检测到异常 (#%d)\n", anomalyCount)
if anomalyCount >= 3 {
fmt.Println("🔒 触发安全协议：锁定所有门窗")
break
}
} else {
fmt.Printf("监控中... 一切正常\n")
}
time.Sleep(2 * time.Second)
}
// continue 示例 - 跳过某些设备的检查
fmt.Println("\n⚡ 快速设备检查（跳过正常设备）:")
for _, device := range deviceList {
// 假设这些设备总是正常，跳过检查
if device == "主卧灯光" || device == "大门门锁" {
continue
}
fmt.Printf("详细检查: %s", device)
time.Sleep(400 * time.Millisecond)
// 模拟检查结果
if device == "厨房烟雾报警器" {
fmt.Printf(" - ⚠️ 需要更换电池\n")
} else {
fmt.Printf(" - ✅ 正常\n")
}
}
// 嵌套循环 - 检查每个房间的每个设备类型
fmt.Println("\n📋 详细巡检报告:")
deviceTypes := []string{"灯光", "空调", "传感器"}
for _, room := range roomList {
fmt.Printf("\n=== %s ===\n", room)
for _, deviceType := range deviceTypes {
fmt.Printf(" %s: ", deviceType)
time.Sleep(200 * time.Millisecond)
// 模拟检查结果
switch {
case room == "厨房" && deviceType == "传感器":
fmt.Printf("需要校准\n")
case room == "客厅" && deviceType == "空调":
fmt.Printf("运行良好\n")
default:
fmt.Printf("正常\n")
}
}
}
// 带标签的循环控制
fmt.Println("\n🎯 智能终止检查:")
outerLoop:
for _, room := range roomList {
fmt.Printf("检查%s: ", room)
for _, deviceType := range deviceTypes {
// 模拟发现严重问题
if room == "厨房" && deviceType == "传感器" {
fmt.Printf("发现严重安全隐患，终止检查\n")
break outerLoop
}
fmt.Printf("%s ", deviceType)
}
fmt.Println()
}
// 循环中的条件判断
fmt.Println("\n🔍 智能分析模式:")
for i := 1; i <= 5; i++ {
fmt.Printf("分析周期 %d: ", i)
if i == 1 {
fmt.Printf("基础设备状态分析\n")
} else if i == 3 {
fmt.Printf("能效优化分析\n")
} else if i == 5 {
fmt.Printf("安全漏洞扫描\n")
} else {
fmt.Printf("例行检查\n")
}
}
}
// 模拟异常检测
func detectAnomaly() bool {
// 模拟 30% 的概率检测到异常
return time.Now().Unix()%10 < 3
}4.4 跳出循环
4.4.1 break
Go 语言中 break 语句用于以下几个方面：
• 用于循环语句中跳出循环，并开始执行循环之后的语句。
• break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
• 在多重循环中，可以用标号 label 标出想 break 的循环。
1、 switch （开关语句）中在执行一条 case 后跳出语句的作用。
Go
package main
import "fmt"
func main() {
extname := ".html"
switch extname {
case ".html":
fmt.Println("text/html")
break
case ".css":
fmt.Println("text/css")
break
case ".js":
fmt.Println("text/javascript")
break
default:
fmt.Println("格式错误")
}
}2、 for 循环中默认 break 只能跳出一层循环
Go
package main
import "fmt"
func main() {
for i := 0; i < 25; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
break
}
fmt.Println("i j的值：", i, "-", j)
}
fmt.Println("i的值为：", i)
}
}
Go
package main
import "fmt"
func main() {
k := 1
for { // 这里也等价 for ; ; {}
if k <= 10 {
fmt.Println("ok~~~", k)
k++
} else {
break // break 就是跳出这个for循环。
}
}
}3、 在多重循环中，可以用标号 label 标出想要 break 的循环。
Go
package main
import "fmt"
func main() {
label2:
for i := 0; i < 2; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
break label2
}
fmt.Println("i j的值：", i, "-", j)
}
}
}4.4.2 continue(继续下次循环)
continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限在 for 循环内使用。
Go
package main
import "fmt"
func main() {
for i := 0; i < 2; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
continue // 跳出本次循环
}
fmt.Println("i j的值：", i, "-", j)
}
}
}在 continue 语句后添加标签时，表示开始标签对应的循环。例如：
Go
package main
import "fmt"
func main() {
here:
for i := 0; i < 2; i++ {
for j := 0; j < 4; j++ {
if j == 2 {
continue here
}
fmt.Println("i j 的值", i, "-", j)
}
}
}4.4.3 goto(跳转到指定标签)
goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go 语言中使用 goto 语句能简化一些代码的实现过程。
Go
package main
import "fmt"
func main() {
var n int = 30
fmt.Println("ok1")
if n > 20 {
goto label1 // 跳到执行这个位置的代码
}
fmt.Println("ok2")
fmt.Println("ok3")
fmt.Println("ok4")
label1:
fmt.Println("ok5")
fmt.Println("ok6")
fmt.Println("ok7")
}使用 goto 语句能简化代码：
Go
package main
import "fmt"
func main() {
for i := 0; i < 10; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
// 设置退出标签
goto breakTag
}
fmt.Println("%v-%v\n", i, j)
}
}
return
// 标签
breakTag:
fmt.Println("结束for循环")
}4.5 练习题：Web3.0智能合约控制流
练习4.1： 智能合约 状态机验证器
Go
package main
import "fmt"
func main() {
fmt.Println("📝 智能合约状态机验证器")
fmt.Println("========================")
// 模拟智能合约的状态流转
currentState := "Created" // 当前状态
transactionList := []string{ // 交易列表
"initialize",
"fund",
"activate",
"complete",
"refund",
}
fmt.Printf("初始状态: %s\n", currentState)
fmt.Println("\n🔄 状态流转验证:")
for _, transaction := range transactionList { // 交易
fmt.Printf("\n处理交易: %s\n", transaction)
fmt.Printf("当前状态: %s → ", currentState)
// 状态机逻辑
switch currentState {
case "Created":
if transaction == "initialize" {
currentState = "Initialized"
fmt.Printf("Initialized ✅\n")
} else {
fmt.Printf("无效交易 ❌\n")
}
case "Initialized":
switch transaction {
case "fund":
currentState = "Funded"
fmt.Printf("Funded ✅\n")
case "cancel":
currentState = "Cancelled"
fmt.Printf("Cancelled ✅\n")
default:
fmt.Printf("无效交易 ❌\n")
}
case "Funded":
switch transaction {
case "activate":
currentState = "Active"
fmt.Printf("Active ✅\n")
case "refund":
currentState = "Refunded"
fmt.Printf("Refunded ✅\n")
default:
fmt.Printf("无效交易 ❌\n")
}
case "Active":
if transaction == "complete" {
currentState = "Completed"
fmt.Printf("Completed ✅\n")
} else {
fmt.Printf("无效交易 ❌\n")
}
case "Completed", "Cancelled", "Refunded":
fmt.Printf("合约已终止，无法处理交易 ❌\n")
default:
fmt.Printf("未知状态 ❌\n")
}
// 状态验证
if !validateStateLegality(currentState) { // 验证状态合法性
fmt.Printf("⚠️ 状态异常: %s\n", currentState)
break
}
}
// 最终状态报告
fmt.Println("\n📊 最终状态报告:")
fmt.Printf("最终状态: %s\n", currentState)
switch currentState {
case "Completed":
fmt.Println("✅ 合约成功完成")
case "Cancelled":
fmt.Println("ℹ️ 合约已取消")
case "Refunded":
fmt.Println("💰 资金已退还")
case "Active":
fmt.Println("🔄 合约进行中")
default:
fmt.Println("❓ 未知状态")
}
// 状态转移图验证
fmt.Println("\n🔍 状态转移验证:")
validateStateTransition(currentState) // 验证状态转移
}
func validateStateLegality(state string) bool { // 验证状态合法性
legalStates := []string{ // 合法状态
"Created", "Initialized", "Funded",
"Active", "Completed", "Cancelled", "Refunded",
}
for _, legalState := range legalStates { // 合法
if state == legalState {
return true
}
}
return false
}
func validateStateTransition(currentState string) { // 验证状态转移
// 验证从当前状态可以转移到哪些状态
fmt.Printf("从 %s 可以转移到: ", currentState)
switch currentState {
case "Created":
fmt.Println("Initialized")
case "Initialized":
fmt.Println("Funded, Cancelled")
case "Funded":
fmt.Println("Active, Refunded")
case "Active":
fmt.Println("Completed")
case "Completed", "Cancelled", "Refunded":
fmt.Println("无（终止状态）")
default:
fmt.Println("未知")
}
}练习4.2：交易验证和风险控制系统
Go
package main
import "fmt"
func main() {
fmt.Println("🔐 交易验证和风险控制系统")
fmt.Println("========================")
// 模拟交易数据
transactionQueue := []map[string]interface{}{ // 交易队列
{
"from": "0x1234...5678",
"to": "0x8765...4321",
"value": 1.5,
"gas": 21000.0,
"nonce": 5,
},
{
"from": "0x1111...2222",
"to": "0x3333...4444",
"value": 100.0,
"gas": 50000.0,
"nonce": 1,
},
{
"from": "0x5555...6666",
"to": "0x7777...8888",
"value": 0.001,
"gas": 21000.0,
"nonce": 0, // 无效nonce
},
}
fmt.Println("📄 交易验证处理:")
fmt.Println("----------------")
successCount := 0 // 成功交易数
failureCount := 0 // 失败交易数
for i, transaction := range transactionQueue { // 交易
fmt.Printf("\n🔹 交易 %d:\n", i+1)
fmt.Printf(" 从: %s\n", transaction["from"])
fmt.Printf(" 到: %s\n", transaction["to"])
fmt.Printf(" 金额: %.4f ETH\n", transaction["value"])
// 执行验证检查
if !validateTransaction(transaction) { // 验证交易
failureCount++
continue
}
// 风险评估
riskLevel := assessTransactionRisk(transaction) // 评估交易风险
// 根据风险等级处理
switch riskLevel {
case "低风险":
fmt.Printf(" ✅ 低风险交易，立即执行\n")
executeTransaction(transaction) // 执行交易
successCount++
case "中风险":
fmt.Printf(" ⚠️ 中风险交易，需要确认\n")
if getUserConfirmation() { // 获取用户确认
executeTransaction(transaction)
successCount++
} else {
fmt.Printf(" ❌ 用户取消交易\n")
failureCount++
}
case "高风险":
fmt.Printf(" 🚨 高风险交易，拒绝执行\n")
failureCount++
default:
fmt.Printf(" ❓ 未知风险等级\n")
failureCount++
}
}
// 统计报告
fmt.Println("\n📊 处理结果:")
fmt.Printf("总交易数: %d\n", len(transactionQueue))
fmt.Printf("成功交易: %d\n", successCount)
fmt.Printf("失败交易: %d\n", failureCount)
fmt.Printf("成功率: %.1f%%\n", float64(successCount)/float64(len(transactionQueue))*100)
// 风险分析
fmt.Println("\n📈 风险分析:")
if failureCount > successCount {
fmt.Println("⚠️ 高风险环境，建议谨慎操作")
} else {
fmt.Println("✅ 交易环境正常")
}
}
func validateTransaction(transaction map[string]interface{}) bool { // 验证交易
fmt.Printf(" 验证: ")
// 检查必要字段
required := []string{"from", "to", "value", "gas", "nonce"}
for _, field := range required {
if _, exists := transaction[field]; !exists {
fmt.Printf("缺少字段 %s ❌\n", field)
return false
}
}
// 检查金额
if transaction["value"].(float64) <= 0 {
fmt.Printf("无效金额 ❌\n")
return false
}
// 检查nonce
if transaction["nonce"].(int) < 0 {
fmt.Printf("无效nonce ❌\n")
return false
}
// 检查Gas限制
if transaction["gas"].(float64) < 21000 {
fmt.Printf("Gas不足 ❌\n")
return false
}
fmt.Printf("基本验证通过 ✅\n")
return true
}
func assessTransactionRisk(transaction map[string]interface{}) string { // 评估交易风险
amount := transaction["value"].(float64) // 金额
gasCost := transaction["gas"].(float64) // Gas费用
// 风险评估逻辑
switch {
case amount > 10.0:
return "高风险"
case amount > 1.0:
return "中风险"
case gasCost > 50000:
return "中风险"
default:
return "低风险"
}
}
func executeTransaction(transaction map[string]interface{}) { // 执行交易
fmt.Printf(" 🚀 执行交易...\n")
// 模拟交易执行
fmt.Printf(" 📨 交易已广播到网络\n")
}
func getUserConfirmation() bool { // 获取用户确认
// 模拟用户确认（实际中会等待用户输入）
return true
}练习4.3：Gas价格优化策略选择器
Go
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("⛽ Gas价格优化策略选择器")
fmt.Println("========================")
// 当前网络状态
networkStatus := "拥堵" // 网络状态
currentGasPrice := 45.0 // Gwei // 当前Gas价格
userUrgency := "中等" // 用户紧急程度
transactionAmount := 2.5 // ETH // 交易金额
fmt.Println("📊 当前环境:")
fmt.Printf("网络状态: %s\n", networkStatus)
fmt.Printf("当前Gas价格: %.1f Gwei\n", currentGasPrice)
fmt.Printf("用户紧急程度: %s\n", userUrgency)
fmt.Printf("交易金额: %.2f ETH\n", transactionAmount)
// 选择Gas策略
fmt.Println("\n🎯 Gas策略选择:")
var recommendedStrategy string // 推荐策略
var recommendedGasPrice float64 // 推荐Gas价格
switch {
case userUrgency == "紧急" || transactionAmount > 10:
recommendedStrategy = "快速确认"
recommendedGasPrice = currentGasPrice * 1.2
case networkStatus == "拥堵" && userUrgency == "高":
recommendedStrategy = "标准加速"
recommendedGasPrice = currentGasPrice * 1.1
case networkStatus == "拥堵" && userUrgency == "中等":
recommendedStrategy = "经济加速"
recommendedGasPrice = currentGasPrice * 1.05
case networkStatus == "正常" && userUrgency == "低":
recommendedStrategy = "经济模式"
recommendedGasPrice = currentGasPrice * 0.9
case networkStatus == "空闲":
recommendedStrategy = "低成本模式"
recommendedGasPrice = currentGasPrice * 0.8
default:
recommendedStrategy = "标准模式"
recommendedGasPrice = currentGasPrice
}
fmt.Printf("推荐策略: %s\n", recommendedStrategy)
fmt.Printf("推荐Gas价格: %.1f Gwei\n", recommendedGasPrice)
// 预估确认时间
fmt.Println("\n⏱️ 预估确认时间:")
var estimatedTime string // 预估时间
switch recommendedStrategy {
case "快速确认":
estimatedTime = "15-30秒"
case "标准加速":
estimatedTime = "1-2分钟"
case "经济加速":
estimatedTime = "2-5分钟"
case "标准模式":
estimatedTime = "3-8分钟"
case "经济模式":
estimatedTime = "5-15分钟"
case "低成本模式":
estimatedTime = "10-30分钟"
default:
estimatedTime = "不确定"
}
fmt.Printf("预计确认: %s\n", estimatedTime)
// 成本计算
fmt.Println("\n💰 成本分析:")
gasCostETH := 21000.0 * recommendedGasPrice / 1e9 // Gas费用ETH
gasCostUSD := gasCostETH * 3200 // 假设ETH价格$3200 // Gas费用美元
transactionCostPercentage := (gasCostUSD / (transactionAmount * 3200)) * 100 // 交易成本占比
fmt.Printf("Gas费用: %.6f ETH ($%.2f)\n", gasCostETH, gasCostUSD)
fmt.Printf("交易成本占比: %.2f%%\n", transactionCostPercentage)
// 成本建议
if transactionCostPercentage > 5 {
fmt.Println("⚠️ Gas成本占比较高，建议等待网络改善")
} else if transactionCostPercentage < 1 {
fmt.Println("✅ Gas成本合理")
} else {
fmt.Println("📊 Gas成本适中")
}
// 多策略比较
fmt.Println("\n📈 多策略比较:")
strategyList := []string{"快速确认", "标准加速", "经济加速", "标准模式", "经济模式"} // 策略列表
for _, strategy := range strategyList { // 策略
strategyGasPrice := calculateStrategyGasPrice(strategy, currentGasPrice) // Gas价格
strategyGasCost := 21000.0 * strategyGasPrice / 1e9 // Gas费用
cost := strategyGasCost * 3200 // 成本
fmt.Printf("%s: %.1f Gwei ($%.2f)\n", strategy, strategyGasPrice, cost)
}
// 自动优化循环
fmt.Println("\n🔄 自动优化监控:")
for i := 1; i <= 3; i++ {
fmt.Printf("监控周期 %d: ", i)
currentGasPrice = getRealTimeGasPrice() // 获取实时Gas价格
if currentGasPrice < recommendedGasPrice*0.9 {
fmt.Printf("Gas价格下降 %.1f Gwei，建议立即交易\n", currentGasPrice)
break
} else {
fmt.Printf("Gas价格 %.1f Gwei，继续等待\n", currentGasPrice)
}
time.Sleep(1 * time.Second)
}
}
func calculateStrategyGasPrice(strategy string, basePrice float64) float64 { // 计算策略Gas价格
switch strategy {
case "快速确认":
return basePrice * 1.2
case "标准加速":
return basePrice * 1.1
case "经济加速":
return basePrice * 1.05
case "标准模式":
return basePrice
case "经济模式":
return basePrice * 0.9
default:
return basePrice
}
}
func getRealTimeGasPrice() float64 { // 获取实时Gas价格
// 模拟实时Gas价格变化
return 40.0 + float64(time.Now().Second()%10)
}练习4.4：DeFi协议安全检查器
Go
package main
import "fmt"
func main() {
fmt.Println("🛡️ DeFi协议安全检查器")
fmt.Println("========================")
// 协议检查列表
protocolList := []string{ // 协议列表
"Uniswap V3",
"Compound V2",
"Aave V3",
"Curve Finance",
"SushiSwap",
}
fmt.Println("🔍 协议安全检查:")
fmt.Println("----------------")
safeProtocolCount := 0 // 安全协议数
warningProtocolCount := 0 // 警告协议数
dangerousProtocolCount := 0 // 危险协议数
for _, protocol := range protocolList { // 协议
fmt.Printf("\n📋 检查协议: %s\n", protocol)
// 执行安全检查
checkResult := performSecurityCheck(protocol) // 检查结果
// 根据检查结果分类
switch checkResult.RiskLevel { // 风险等级
case "安全":
fmt.Printf(" ✅ 安全\n")
safeProtocolCount++
case "警告":
fmt.Printf(" ⚠️ 警告: %s\n", checkResult.IssueDescription) // 问题描述
warningProtocolCount++
case "危险":
fmt.Printf(" 🚨 危险: %s\n", checkResult.IssueDescription)
dangerousProtocolCount++
default:
fmt.Printf(" ❓ 未知风险\n")
}
// 显示详细检查项
fmt.Printf(" 审计状态: %s\n", checkResult.AuditStatus) // 审计状态
fmt.Printf(" 漏洞数量: %d\n", checkResult.VulnerabilityCount) // 漏洞数量
fmt.Printf(" TVL: $%.0f\n", checkResult.TVL)
// 提供建议
if checkResult.RiskLevel == "安全" {
fmt.Printf(" 💡 建议: 可以安全使用\n")
} else if checkResult.RiskLevel == "警告" {
fmt.Printf(" 💡 建议: 谨慎使用，注意风险\n")
} else {
fmt.Printf(" 💡 建议: 避免使用\n")
}
}
// 总体安全报告
fmt.Println("\n📊 总体安全报告:")
fmt.Printf("检查协议总数: %d\n", len(protocolList))
fmt.Printf("安全协议: %d\n", safeProtocolCount)
fmt.Printf("警告协议: %d\n", warningProtocolCount)
fmt.Printf("危险协议: %d\n", dangerousProtocolCount)
safetyPercentage := float64(safeProtocolCount) / float64(len(protocolList)) * 100 // 安全比例
fmt.Printf("安全比例: %.1f%%\n", safetyPercentage)
// 风险评估
fmt.Println("\n📈 风险评估:")
switch {
case safetyPercentage >= 80:
fmt.Println("✅ 整体环境安全")
case safetyPercentage >= 60:
fmt.Println("⚠️ 存在一定风险，需谨慎选择")
case safetyPercentage >= 40:
fmt.Println("🚨 风险较高，建议严格筛选")
default:
fmt.Println("💀 风险极高，强烈建议避免")
}
// 推荐协议
fmt.Println("\n🏆 推荐协议:")
for _, protocol := range protocolList {
checkResult := performSecurityCheck(protocol)
if checkResult.RiskLevel == "安全" && checkResult.TVL > 1000000000 {
fmt.Printf("✅ %s (TVL: $%.0f)\n", protocol, checkResult.TVL)
}
}
}
type SecurityCheckResult struct { // 安全检查结果
RiskLevel string // 风险等级
IssueDescription string // 问题描述
AuditStatus string // 审计状态
VulnerabilityCount int // 漏洞数量
TVL float64 // TVL
}
func performSecurityCheck(protocol string) SecurityCheckResult { // 执行安全检查
// 模拟不同协议的安全检查结果
switch protocol {
case "Uniswap V3":
return SecurityCheckResult{
RiskLevel: "安全",
IssueDescription: "",
AuditStatus: "多重审计通过",
VulnerabilityCount: 0,
TVL: 3500000000,
}
case "Compound V2":
return SecurityCheckResult{
RiskLevel: "安全",
IssueDescription: "",
AuditStatus: "知名机构审计",
VulnerabilityCount: 1,
TVL: 1500000000,
}
case "Aave V3":
return SecurityCheckResult{
RiskLevel: "安全",
IssueDescription: "",
AuditStatus: "全面审计",
VulnerabilityCount: 0,
TVL: 1200000000,
}
case "Curve Finance":
return SecurityCheckResult{
RiskLevel: "警告",
IssueDescription: "近期有漏洞报告",
AuditStatus: "部分审计",
VulnerabilityCount: 3,
TVL: 800000000,
}
case "SushiSwap":
return SecurityCheckResult{
RiskLevel: "危险",
IssueDescription: "多次安全事件",
AuditStatus: "审计不完整",
VulnerabilityCount: 5,
TVL: 500000000,
}
default:
return SecurityCheckResult{
RiskLevel: "未知",
IssueDescription: "协议信息不足",
AuditStatus: "未审计",
VulnerabilityCount: 0,
TVL: 0,
}
}
}练习4.5： 跨链 交易状态追踪器
Go
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("🌉 跨链交易状态追踪器")
fmt.Println("========================")
// 模拟跨链交易
transactionID := "0xabc123def456" // 交易ID
sourceChain := "Ethereum" // 源链
targetChain := "Polygon" // 目标链
transferAmount := 2.5 // 转移金额
startTime := time.Now() // 开始时间
fmt.Printf("交易ID: %s\n", transactionID)
fmt.Printf("从 %s 到 %s\n", sourceChain, targetChain)
fmt.Printf("金额: %.2f ETH\n", transferAmount)
fmt.Printf("开始时间: %s\n", startTime.Format("15:04:05"))
// 状态追踪循环
fmt.Println("\n🔄 交易状态追踪:")
statusList := []string{ // 状态列表
"提交到源链",
"源链确认",
"跨链桥处理",
"目标链确认",
"完成",
}
currentStatusIndex := 0 // 当前状态索引
maxWaitTime := 30 // 最大等待时间（秒）
waitStartTime := time.Now() // 开始等待时间
for currentStatusIndex < len(statusList) {
currentStatus := statusList[currentStatusIndex] // 当前状态
elapsedTime := int(time.Since(waitStartTime).Seconds()) // 经过时间
// 检查是否超时
if elapsedTime > maxWaitTime {
fmt.Printf("❌ 交易超时，当前状态: %s\n", currentStatus)
break
}
// 模拟状态推进
if shouldAdvanceStatus(elapsedTime, currentStatusIndex) { // 应该推进状态
fmt.Printf("✅ %s", currentStatus)
// 显示状态特定信息
switch currentStatus {
case "源链确认":
fmt.Printf(" (区块确认数: 12/12)")
case "跨链桥处理":
fmt.Printf(" (验证中...)")
case "目标链确认":
fmt.Printf(" (区块确认数: 8/8)")
case "完成":
fmt.Printf(" 🎉")
}
fmt.Println()
currentStatusIndex++
} else {
fmt.Printf("⏳ %s... 已等待 %d秒\n", currentStatus, elapsedTime)
}
time.Sleep(2 * time.Second)
}
// 最终结果
fmt.Println("\n📊 交易结果:")
if currentStatusIndex == len(statusList) {
fmt.Println("✅ 跨链交易成功完成")
totalDuration := time.Since(startTime) // 总耗时
fmt.Printf("总耗时: %.0f秒\n", totalDuration.Seconds())
} else {
fmt.Println("❌ 跨链交易失败或超时")
}
// 费用报告
fmt.Println("\n💰 费用报告:")
baseFee := 0.001 // 基础费用
crossChainFee := 0.0005 // 跨链费用
totalFee := baseFee + crossChainFee // 总费用
receivedAmount := transferAmount - totalFee // 到账金额
fmt.Printf("转移金额: %.4f ETH\n", transferAmount)
fmt.Printf("基础费用: %.4f ETH\n", baseFee)
fmt.Printf("跨链费用: %.4f ETH\n", crossChainFee)
fmt.Printf("总费用: %.4f ETH\n", totalFee)
fmt.Printf("到账金额: %.4f ETH\n", receivedAmount)
// 费用占比分析
feePercentage := (totalFee / transferAmount) * 100 // 费用占比
fmt.Printf("费用占比: %.2f%%\n", feePercentage)
if feePercentage > 5 {
fmt.Println("⚠️ 费用占比较高，建议大额转移")
} else {
fmt.Println("✅ 费用比例合理")
}
// 历史记录分析
fmt.Println("\n📈 历史性能分析:")
historicalTransactionCount := 15 // 历史交易次数
successCount := 12 // 成功次数
averageDuration := 45.5 // 平均耗时
fmt.Printf("历史交易次数: %d\n", historicalTransactionCount)
fmt.Printf("成功次数: %d\n", successCount)
fmt.Printf("成功率: %.1f%%\n", float64(successCount)/float64(historicalTransactionCount)*100)
fmt.Printf("平均耗时: %.1f秒\n", averageDuration)
// 推荐改进
if averageDuration > 60 {
fmt.Println("💡 建议: 跨链耗时较长，考虑使用其他桥接方案")
}
}
func shouldAdvanceStatus(elapsedTime int, currentStatusIndex int) bool { // 应该推进状态
// 模拟状态推进条件
switch currentStatusIndex {
case 0: // 提交到源链
return elapsedTime >= 2
case 1: // 源链确认
return elapsedTime >= 8
case 2: // 跨链桥处理
return elapsedTime >= 15
case 3: // 目标链确认
return elapsedTime >= 22
case 4: // 完成
return elapsedTime >= 25
default:
return false
}
}