控制流

Fluxon 的控制结构也是表达式：分支与循环可以产生值，并参与更大表达式的求值。本章覆盖 if、when、循环、break/continue 与 try。

条件分支

基本语法

if 用于按条件选择不同的表达式结果：

if &n <= 1 then 1 else &n - 1

要点：

if 后跟条件表达式。
then 后跟条件为 true 时计算的表达式。
else 后跟条件为 false 时计算的表达式。
整个 if ... then ... else ... 是一个表达式，可以直接作为函数返回值或赋值右侧：

def fib(n) = if &n <= 1 then 1 else fib(&n - 1) + fib(&n - 2)

多行与嵌套写法

当分支逻辑较复杂时，可以用代码块书写，并在 if 中嵌套使用：

result = if &score >= 90 {
	"A"
} else if &score >= 60 {
	"B"
} else {
	"C"
}

花括号 { ... } 表示一个代码块。
块内可以包含多条语句，块的结果是最后一个表达式的值，或者显式 return 的值。
if 是表达式，可以作为更大表达式的一部分，也可以嵌套出现在 else 分支中。

多分支选择

when 提供了更灵活的多分支选择语法，支持按条件测试和按值匹配两种用法。

条件模式

在条件模式下，when 按顺序测试每个条件：

when {
	&num % 2 == 0 -> "even"
	&num < 0      -> "negative odd"
	else          -> "positive odd"
}

花括号内部每一行是一个“条件 -> 结果表达式”。
会自上而下依次计算条件表达式，返回第一个为 true 的分支右侧结果。
else 分支是可选分支，用于兜底情况。
如果省略 else 且没有任何条件命中，则结果为 null：

label = when {
	&status == "ok"    -> "OK"
	&status == "error" -> "ERROR"
}

值匹配

在值匹配模式下，when 先对一个表达式求值，然后与各个分支左侧的值做相等比较：

when &value {
	1    -> "one"
	2    -> "two"
	3    -> "three"
	else -> "other"
}

when expr { ... } 会先计算 expr，再依次与每个分支左侧的值比较。
适合枚举值、常量分支、简单状态码等场景。
同样支持 else 作为兜底分支。

集合匹配

when 支持使用 in 和 !in 检查值是否在集合、映射或区间内：

when &score {
	in 0..59    -> "不及格"
	in 60..79   -> "及格"
	in 80..100  -> "优秀"
	else        -> "无效分数"
}

in <collection> 检查主题值是否在集合中
!in <collection> 检查主题值是否不在集合中
支持列表、映射、区间等可迭代值

类型匹配

when 支持使用 is 运算符进行类型检查：

when &obj {
	is string -> "这是文本"
	is int    -> "这是整数"
	is list   -> "这是列表"
	else      -> "未知类型"
}

类型匹配特性：

使用 is <TypeName> 进行运行时类型检查
支持类型别名（不区分大小写）：string、int、list、map 等
支持完全限定类名：is java.util.ArrayList
null 值不匹配任何类型，会进入 else 分支
可与其他匹配类型混合使用：

when &value {
	null       -> "空值"
	is string  -> "文本类型"
	42         -> "答案"
	in 0..100  -> "数字范围"
	else       -> "其他"
}

详见运算符与优先级 - 类型检查。

与其他表达式组合

when 是表达式，可以绑定为变量、作为函数返回值，或嵌入到更大的表达式中：

label = when &status {
	"ok"      -> "OK"
	"failed"  -> "FAILED"
	else      -> "UNKNOWN"
}

async def handleStatus(status) = {
	message = when &status {
		"ok"     -> "success"
		"queued" -> "pending"
		else     -> "error"
	}
	print(&message)
}

循环

Fluxon 提供 for 和 while 两种循环形式，它们都可以在循环体中使用 break 和 continue。

for-in 循环

for 用于遍历列表、区间或映射等可迭代值。

遍历列表

sum = 0

for x in [1, 2, 3] {
	sum += &x
}

语法为 for 标识符 in 可迭代表达式 { ... }。
在循环体中通过 &标识符 访问当前元素。

你也可以在循环中调用函数：

async def printAll(xs) = {
	for x in &xs {
		print(&x)
	}
}

遍历映射（键值对）

当可迭代值是键值对集合时，你可以直接解构当前项：

pairs = []

for (key, value) in &map {
	pairs += [&key + ":" + &value]
}

使用解构 (key, value) 遍历键值对。
具体迭代顺序由底层集合类型决定，例如字典或环境变量。

遍历区间

区间由 a..b（闭区间）或 a..<b（左闭右开）创建：

total = 0

for i in 1..5 {
	total += &i      # i = 1, 2, 3, 4, 5
}

for j in 0..<3 {
	print(&j)          # j = 0, 1, 2
}

区间表达式本身是一个值，也可以先赋给变量再用于循环：

range = 1..10

for i in &range {
	print(&i)
}

while 循环

while 在条件为 true 时重复执行循环体：

count = 0
output = ""

while &count < 10 {
	count = &count + 1
	output = &output + &count + ","
}

每次进入循环体之前都会计算条件表达式。
条件结果为 false 或 null 时循环结束。
条件表达式可以引用外层变量，也可以调用函数：

def done(count) = &count >= 3

c = 0

while !done(&c) {
	c = &c + 1
}

终止与跳过

终止：break

break 用于提前结束当前循环：

status = "not-found"

for i in 1..10 {
	if &i == 5 {
		status = "found"
		break
	}
}

立即结束最内层的 for 或 while。
循环之后的语句会继续执行。

break 也可以配合 when 或函数调用使用，只要位置在循环体内即可。

result = ""

for item in [1, 2, 3, "stop", 4, 5] {
	when &item {
		is string -> {
			result = "stopped at: " + &item
			break
		}
		else -> result = &result + &item + ","
	}
}
# result = "stopped at: stop"

跳过：continue

continue 用于跳过当前迭代剩余的语句，直接进入下一轮：

odds = []

for i in 1..10 {
	if &i % 2 == 0 {
		continue
	}
	odds += [&i]
}

当前迭代中，continue 之后的语句不会执行。
下一轮迭代从条件检查开始。
在多重嵌套循环中，continue 只作用于最内层循环。

异常处理

Fluxon 提供 throw 与 try / catch / finally 结构来处理运行时错误。和其他控制结构一样，try 是一个表达式，可以产生值。

抛出异常

使用 throw(expr) 可以在任意位置显式抛出异常：

throw("error")

在没有被 try 包裹时，throw 会中断当前脚本的执行，向外抛出一个运行时异常。 expr 的值会作为异常的消息或原因被传递到底层运行时：

def failIfNegative(n) = {
	if &n < 0 {
		throw("negative not allowed")
	}
	&n
}

作为表达式

try 是一个完整的表达式，用来包裹可能出错的代码，并在出错时给出替代值：

result = try {
	1 / 0
} catch (e) {
	"failed: " + &e.message
}

示例中的 &e.message 使用成员访问 .（反射）。嵌入式集成默认关闭反射访问，如需使用请参阅成员访问（.）。

求值规则概括如下：

正常情况：
- 先执行 try { ... } 块。
- 如果没有抛出异常，try 表达式的结果就是 try 块最后一个表达式的值。
- 如果存在 finally，仍然会在返回前执行 finally（见下文）。
出错情况：
- 如果 try 块中抛出了异常，会跳转到后续的 catch。
- 没有匹配的 catch 时，异常会继续向外传播。仅写 try { ... } 而不写 catch / finally 时，常用于“保证 finally 执行”或调试。

由于 try 是表达式，它可以出现在赋值、函数调用参数、甚至其他表达式内部：

status = try {
	parseConfig(&text)
} catch (e) {
	"invalid config: "
}

print("status = " + &status)

处理异常

catch 用于捕获异常并返回一个替代值。Fluxon 支持两种常见写法：

省略异常变量：只关心出错时的兜底结果，不关心异常对象本身：
result = try { throw("error") } catch { "ok" }

带异常变量：需要访问异常对象的详细信息，例如类型或消息：

result = try {
	throw("error")
} catch (e) {
	"java.lang.RuntimeException: " + &e::message()
}

在这两种形式中：

catch 块本身是一个代码块，最后一个表达式的值（或显式 return 的值）会成为整条 try 表达式在出错时的结果。
如果 try 块没有抛出异常，对应的 catch 块不会执行。

最终执行

finally 用于那些不关心结果，只关心“必须执行”的逻辑，例如日志、资源释放或计时：

value = try {
	parseInt(&text)
} catch (e) {
	0
} finally {
	print("parse done")
}

执行顺序为：

执行 try 块。
若发生异常，执行 catch 块；catch 的返回值作为候选结果。
不论是否发生异常，都执行 finally 块。
如果 finally 正常结束，则 try 表达式的结果为：
- 正常情况下：try 块的结果。
- 出错且被捕获的情况下：catch 块的结果。

只有在 finally 内部再次抛出异常时，才会覆盖原本的结果，改为向外抛出新的异常。否则，finally 不会改变 try / catch 已经决定好的值。

链式用法与简写形式

在 Fluxon 中，可以把多个异常处理片段写成一条链，形成紧凑的错误恢复逻辑：

result = try throw("error") catch "ok" finally print("done")

这与块体写法是等价的，只是把 try、catch、finally 部分写在一行上：

result = try {
	throw("error")
} catch {
	"ok"
} finally {
	print("done")
}

你可以根据脚本复杂度选择简写或块体形式：

对于一两行的简单逻辑，简写更紧凑。
涉及多步操作或需要访问异常对象时，推荐使用块体形式并显式写出 (e)。

核心语法

内置函数

扩展函数

条件分支

基本语法

多行与嵌套写法

多分支选择

条件模式

值匹配

集合匹配

类型匹配

与其他表达式组合

循环

for-in 循环

遍历列表

遍历映射（键值对）

遍历区间

while 循环

终止与跳过

终止：break

跳过：continue

异常处理

抛出异常

作为表达式

处理异常

最终执行

链式用法与简写形式

相关链接

​条件分支

​基本语法

​多行与嵌套写法

​多分支选择

​条件模式

​值匹配

​集合匹配

​类型匹配

​与其他表达式组合

​循环

​for-in 循环

​遍历列表

​遍历映射（键值对）

​遍历区间

​while 循环

​终止与跳过

​终止：break

​跳过：continue

​异常处理

​抛出异常

​作为表达式

​处理异常

​最终执行

​链式用法与简写形式

​相关链接

条件分支

基本语法

多行与嵌套写法

多分支选择

条件模式

值匹配

集合匹配

类型匹配

与其他表达式组合

循环

for-in 循环

遍历列表

遍历映射（键值对）

遍历区间

while 循环

终止与跳过

终止：break

跳过：continue

异常处理

抛出异常

作为表达式

处理异常

最终执行

链式用法与简写形式

相关链接