运算符、空安全机制和流程控制语句是 ArkTS 里的核心内容，是写出高效、稳定的鸿蒙应用的关键基础。运算符决定了数据怎么运算，空安全能避免程序因为空值而崩溃，流程控制语句能让代码根据不同情况灵活执行。

运算符

ArkTS 中的运算符总共可以分为五大类：赋值运算符、比较运算符、算术运算符、逻辑运算符、位运算符。这些运算符是编写 ArkTS 逻辑、处理数据计算的基础。

赋值运算符

基础赋值：=

复合赋值：+=、-=、*=、/=、%=、<<=、>>=、>>>=、&=、|=、^=

let a = 10;
a += 5; // 等价于 a = a + 5;
a -= 5; // 等价于 a = a - 5;
a *= 3; // 等价于 a = a * 3;
a /= 3; // 等价于 a = a / 3;
a %= 2; // 等价于 a = a % 2;

比较运算符

严格比较：===（值与类型均相等）、!==（值与类型均不等）

宽松比较：==、!=、>、<、>=、<=

function compareStrict(a: string | number, b: string | number) : boolean{
  return a === b;
}
let a: string | number = 10;
let b: string | number = '10';
compareStrict(a, b); // false 类型不同

function compareLoose(a: string | number, b: string | number): boolean{
  return a == b;
}
let a: string | number = 10;
let b: string | number = '10';
compareLoose(a, b); // true 字符串转为数字

算术运算符

一元运算符：+（正号）、-（负号）、++（自增）、–（自减）

二元运算符：+、-、*、/、%（取余）

let c = 10 + 5;       // 15
let d = 10 - 5;       // 5
let e = 3 * 4;        // 12
let f = 10 / 4;       // 2.5
let g = 10 % 3;       // 1（余数）

运算符	形式	核心逻辑	执行代码（假定 count = 5）	等价的语句	执行后 count 的值	返回值（result 的值）
自增运算符（++）	后置自增	先取值后加一	result = count++;	result = count;count = count + 1;	6	5
自增运算符（++）	前置自增	先加一后取值	result = ++count;	count = count + 1;result = count;	6	6
自减运算符（–）	后置自减	先取值后减一	result = count–;	result = count;count = count - 1;	4	5
自减运算符（–）	前置自减	先减一后取值	result = --count;	count = count - 1;result = count;	4	4

逻辑运算符

&&（逻辑与）：所有条件为真时返回 true

|（逻辑或）: 任一条件为真时返回 true

!（逻辑非）: 布尔值取反

let a = false && true;         // false（首个条件为 false 直接短路）
let b = true || false;         // true（首个条件为 true 直接短路）
let c = !false;                // true

逻辑与短路特性：若第一个条件为 false，直接跳过后续条件。

逻辑或短路特性：若第一个条件为 true，直接跳过后续条件。

位运算符

位运算是直接对整数的二进制位进行操作的运算方式。

基础运算符：&、|、^、~

位移运算符： <<、>>、>>>

按位与 &：两个操作数的对应二进制位均为 1 时结果为 1，否则为 0。

let a = 5; // 二进制 0101
let b = 3; // 二进制 0011
let c = a & b; // 二进制 0001

空安全

在实际开发中，当运算符操作的变量为空，即值为 null 或者 undefind 时极易引发运行时异常，影响应用的稳定性。为了避免这些程序因为空值而崩溃，ArkTS 专门引入了空安全机制，通过这个机制可以在编译阶段就可以发现潜在的空值问题并提前解决，让代码更靠谱、更稳定。

一般来说，有时会存在声明变量时不确定初始值。在这类情况下，通常使用联合类型包含 null 值或 undefined null 表示显式赋值的空值，常用于主动清空对象引用，undefined 表示变量未初始化或属性不存在。

let name: string | null = null;
console.log(name.length.toString()); // 名称可能是空值

使用时，不对可为 null 值的变量进行非空校验，那么在编译或者运行时就会发生错误，无法正确运行。

if/else

使用 if/else 进行判空。

if (name !== null) { /* do something */ }

?. 可选链

使用 ?. 可选链，如果是 null，运算符会返回 undefined。

function nullSafetyWithOptionalChaining(obj: Object | null): string | undefined {
  return obj?.toString();
}

非空断言运算符

使用非空断言运算符，! 断言左边的值非空。

function nullSafetyWithAssertion(obj: Object | null): string {
  // return obj.toString(); // obj可能为空.
  // 编译通过，如果运行时obj的值非空，可以访问到obj的方法；如果运行时obj的值为空，则发生运行时异常
  return obj!.toString();
}

空值合并运算符

使用空值合并运算符，?? 左边的值为 null 时会返回表达式右边的值。

let name: string | null = null;
const res = name ?? ' ';

语句

语句可以控制程序的执行逻辑，保障程序稳定运行。具体包括 if、switch、循环、break、continue、throw、try 等语句。

条件语句

if 语句

if 语句基于不同的条件执行不同的动作，根据判断条件的执行结果（true 或者 false）来决定执行的代码块。

// 场景：进园前要检查有没有买票
let hasTicket: boolean = true;
if (hasTicket) {
  console.log('检票通过！');
} else {
  console.log('禁止入园！');
}

let hasTicket = true;
let result = hasTicket ? '检票通过！' : '禁止入园！';

条件表达式

除了 if-else 这种完整的条件语句，还可以使用更加简洁的条件表达式。

语法： condition ? expression1 : expression2

行为：如果 condition 为 true 就返回 expression1 的值，否则返回 expression2 的值。

let hasTicket = true;
let result = hasTicket ? '检票通过' : '禁止入园';

### switch 语句

switch 语句根据一个表达式的不同值执行对应的代码块，特别适合多离散值匹配的场景。

```ArkTS
switch (day) {
  case 1:
    console.log('星期一');
    break;
  case 2:
    console.log('星期二');
    break;
  case 3:
    console.log('星期三');
    break;
  case 4:
    console.log('星期四');
    break;
  case 5:
    console.log('星期五');
    break;
  case 6:
  case 7:
    console.log('周末');
    break;
  default:
    console.log('输入错误，请输入1-7之间的数字');
}

这里有一个重要的规则，每一个 case 语句的代码块结尾都要加上 break 关键字用于跳出 switch 结构。如果不加 break 就会出现穿透现象，代码会继续执行后面所有 case 的语句，直到遇到 break 或者 switch 语句结束。

循环语句

循环语句用于重复执行相同的一组语句，提高效率、简化代码。

let students: string[] = ['XiaoMing', 'XiaoZhang', 'XiaoWang', 'XiaoLi'];

for 语句

for 语句会被重复执行，直到循环条件结果为 false。

for (let i = 0; i < students.length; i++) {
  console.log(students[i]);
}

for-of 语句

for-of 语句可以遍历数组等可以迭代的类型。

for (let student of students) {
  console.log(student);
}

while 语句

while 语句中的循环表达式是在执行循环体之前判断的。

let index = 0;
while (index < students.length) {
  console.log(students[index]);
  index++;
}

do-while 语句

do-while 语句中的循环控制表达式是在执行循环体之后判断的。

let index = 0;
do {
  console.log(students[index]);
  index++;
} while (index < students.length)

break 语句

用于立即终止当前循环（如 for、while、do-while），跳出循环体并执行后续代码。

// 输出 0 1 2
for (let i = 0; i < 5; i++) {
  if (i === 3) {
    break; // 当 i = 3 时退出循环
  }
  console.log(i + ' ');
}

continue 语句

用于跳出当前循环迭代的剩余代码，直接进入下一次循环条件判断。

// 输出 0 1 2 4
for (let i = 0; i < 5; i++) {
  if (i === 3) {
    continue; // 跳过 i = 3 的迭代
  }
  console.log(i + ' ');
}

异常处理语句

throw 语句

异常处理是保障应用稳定运行的核心机制之一。当代码执行遇到错误时，可以通过 throw 关键字主动抛出异常，把错误信息明确地告诉程序。

function checkAge(age: number) {
  if (age < 0) {
    throw new Error('年龄不能为负数');
  }
}

try 语句

抛出异常后，一定要处理异常，不然程序会因为未处理的异常而崩溃。处理异常用的是 try-catch-finally 这三个关键字：try 里面包裹可能抛出异常的代码块，如果 try 里面的代码真的出错了，就执行 catch 里面的代码来处理异常，finally 里面的代码不管有没有异常都会执行，通常用来释放资源。

捕获并处理异常。

try {
  let result = checkAge(-5); // 可能抛出异常的操作
} catch (error) {
  console.error('捕获到异常：', error.message); // 处理异常
} finally {
  console.log('清理操作'); // 无论是否异常都会执行
}