跳到主要内容

控制流

Alia 语言提供了多种控制流结构，用于控制代码的执行流程。

1. 条件语句​

if 语句​

alias if <Boolean condition> <Stack thenStack>
alias if <Boolean condition> <Stack thenStack> else <Stack elseStack>

示例​

const age = 18
if age >= 18 {
  print '成年人'
} else {
  print '未成年人'
}
const score = 85
if score >= 90 {
  print '优秀'
} else {
  if score >= 80 {
    print '良好'
  } else {
    if score >= 60 {
      print '及格'
    } else {
      print '不及格'
    }
  }
}

switch 语句​

switch 根据一个值匹配多个分支，case/multicase 子句按声明顺序匹配，首个匹配的子句执行其体，后续子句跳过；default 在所有子句均未匹配时执行。switch 表达式的值为首个匹配子句的返回值；若无任何子句匹配且无 default，则为 switch 体最后一条语句的值。

alias switch <Value switchVal> <Stack switchBody>
alias case <Value caseVal> <Stack caseBody>
alias multicase <Array caseVals> <Stack caseBody>
alias default <Stack defaultBody>

基本 case​

const fruit = 'apple'
switch fruit {
  case 'apple' {
    print '苹果'
  }
  case 'banana' {
    print '香蕉'
  }
}

作为表达式的 switch​

switch 会返回首个匹配子句的值，可直接作为表达式使用：

const score = 2
const level = switch score {
  case 1 { 'low' }
  case 2 { 'medium' }
  case 3 { 'high' }
  default { 'unknown' }
}
print level

multicase 复合条件​

multicase 接受一个值数组，任一值相等即命中，用于将多个值归入同一分支：

const day = 6
switch day {
  multicase [1, 2, 3, 4, 5] {
    print '工作日'
  }
  multicase [6, 7] {
    print '周末'
  }
}

default 默认分支​

所有 case/multicase 均未命中时执行 default：

const code = 404
switch code {
  case 200 {
    print 'OK'
  }
  case 404 {
    print 'Not Found'
  }
  default {
    print '未知状态码'
  }
}

首个匹配优先​

一旦某个子句命中，其后的子句全部跳过：

let count = 0
switch 2 {
  case 2 { count = count + 1 }
  case 2 { count = count + 100 }
  default { count = count + 1000 }
}
print count

类型区分​

case 按值且区分类型匹配：case 42 不会匹配字符串 '42'。

const hit = switch '42' {
  case 42 { 'number' }
  case '42' { 'string' }
  default { 'other' }
}
print hit

2. 循环语句​

for 循环​

alias for <Stack init> <Boolean condition> <Stack update> <Stack body>

示例​

for { let i = 0 } i < 10 { i ++ } {
  print i
}
const arr = [1, 2, 3, 4, 5]
for { let i = 0 } i < arr.length { i ++ } {
  print '元素 ' .. i .. ': ' .. arr[i]
}

while 循环​

alias while <Boolean condition> <Stack body>

示例​

let i = 1
while i <= 5 {
  print i
  i ++
}
let count = 0
while count < 3 {
  print '循环次数: ' .. count
  count ++
}

each 循环​

用于遍历数组的每个元素。

alias each <Variable arrayItem> in <Array target> <Stack body>
alias each <Variable arrayItem> with <Variable updateCount> in <Array target> <Stack body>

基本语法​

基本形式遍历数组的每个元素，元素绑定至给定变量。

带计数器的 each​

带计数器形式在遍历的同时维护计数值，计数值从 1 开始。

示例​

const fruits = ['苹果', '香蕉', '橙子']
each fruit in fruits {
  print fruit
}
const nums = [10, 20, 30]
let total = 0
each num in nums {
  total += num
}
print total
const data = [1, 2, 3, 4, 5]
each item in data {
  if item > 3 {
    break
  }
  print item
}

repeat 循环​

alias repeat <Stack body>

示例​

let i = 0
try {
  repeat {
    print i
    i ++
    if i >= 5 {
      throw 'done'
    }
  }
} catch e {
  print e
}

3. 跳转语句​

break 语句​

用于跳出循环或栈。

alias break
alias break <Value returnVal>

示例​

for { let i = 0 } i < 10 { i ++ } {
  if i == 5 {
    break
  }
  print i
}
const stack = {
  print 'start'
  break '找到 5 了'
  print 'end'
}
const result = call stack.run
print result

return 语句​

用于从函数或栈中返回值。

alias return
alias return <Value returnVal>

示例​

const add = alias <Number a> <Number b> -> {
  return a + b
}
const sum = call add [1, 2]
print sum

Has 关键字​

用于检查可变栈内是否存在指定变量，检查结果为 Boolean 类型。

alias Has <Variable name>
alias Has <String name>

示例​

const stack = mut *{
  if Has 'count' {
    count
  } else {
    let count = 1
    count
  }
}
const first = call stack.run
print first
const second = call stack.run
print second

enter 关键字​

用于进入栈的语境，类似 JavaScript 的 with 但更安全。

alias enter <Stack stack>
alias enter <Value stackVal> <Stack body>

示例​

const stack = mut *{
  let val = 100
  val
}
call stack.run
enter (stack) {
  print val
}

4. 错误处理​

try-catch 语句​

alias try <Stack tryStack> catch <Variable e> <Stack catchStack>

示例​

try {
  print '尝试执行'
  throw '发生错误'
} catch e {
  print '捕获到错误: ' .. e
}

5. 示例代码​

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let sum = 0
let evenCount = 0
let oddCount = 0
for { let i = 0 } i < numbers.length { i ++ } {
  const num = numbers[i]
  if num % 2 == 0 {
    evenCount ++
    print num .. ' 是偶数'
  } else {
    oddCount ++
    print num .. ' 是奇数'
  }
  sum += num
  if sum > 20 {
    print '和超过 20，跳出循环'
    break
  }
}
print '偶数个数: ' .. evenCount
print '奇数个数: ' .. oddCount
print '总和: ' .. sum

下一步​