[鸿蒙开发实战篇]HarmonyOS中ArkTS与dart语言在运算符和控制流程对比详解

大雷神
31 阅读3分钟

​

1. 运算符对比

算术运算符

Dart:

dart

// 基本算术运算
int a = 10, b = 3;
print(a + b);  // 13
print(a - b);  // 7
print(a * b);  // 30
print(a / b);  // 3.3333333333333335
print(a ~/ b); // 3 - 整除运算，Dart特有
print(a % b);  // 1

// 自增自减
int count = 5;
print(count++); // 5 - 后置递增
print(++count); // 7 - 前置递增

ArkTS:

typescript

// 基本算术运算
let a: number = 10, b: number = 3;
console.log(a + b);  // 13
console.log(a - b);  // 7
console.log(a * b);  // 30
console.log(a / b);  // 3.3333333333333335
console.log(Math.floor(a / b)); // 3 - 需要Math.floor模拟整除
console.log(a % b);  // 1

// 自增自减
let count: number = 5;
console.log(count++); // 5 - 后置递增
console.log(++count); // 7 - 前置递增

关键区别： Dart有专门的整除运算符~/，而ArkTS需要使用Math.floor()函数。

关系运算符

Dart:

dart

int x = 10, y = 20;
print(x == y);  // false
print(x != y);  // true
print(x > y);   // false
print(x < y);   // true
print(x >= y);  // false
print(x <= y);  // true

// 类型检查运算符
var value = "hello";
print(value is String);    // true
print(value is! int);      // true - 类型否定检查

ArkTS:

typescript

let x: number = 10, y: number = 20;
console.log(x == y);  // false
console.log(x != y);  // true
console.log(x > y);   // false
console.log(x < y);   // true
console.log(x >= y);  // false
console.log(x <= y);  // true

// 类型检查运算符
let value: any = "hello";
console.log(typeof value === 'string');    // true
console.log(value instanceof String);      // true
console.log(!(value instanceof Number));   // true

关键区别： Dart使用is和is!进行类型检查，ArkTS使用typeof和instanceof。

逻辑运算符

Dart:

dart

bool a = true, b = false;
print(a && b);  // false
print(a || b);  // true
print(!a);      // false

// 短路求值
String? name;
bool isValid = name != null && name.isNotEmpty;
print(isValid); // false - 不会执行name.isNotEmpty

ArkTS:

typescript

let a: boolean = true, b: boolean = false;
console.log(a && b);  // false
console.log(a || b);  // true
console.log(!a);      // false

// 短路求值
let name: string | null = null;
let isValid: boolean = name !== null && name.length > 0;
console.log(isValid); // false - 不会执行name.length > 0

相同点： 两者逻辑运算符语法和短路求值行为一致。

赋值运算符

Dart:

dart

// 基础赋值
int a = 10;
a += 5;   // a = 15
a -= 3;   // a = 12
a *= 2;   // a = 24
a ~/= 4;  // a = 6 - 整除赋值
a %= 4;   // a = 2

// 空感知赋值
String? name;
name ??= 'Unknown'; // 如果name为null则赋值
print(name); // 'Unknown'

ArkTS:

typescript

// 基础赋值
let a: number = 10;
a += 5;   // a = 15
a -= 3;   // a = 12
a *= 2;   // a = 24
a = Math.floor(a / 4);  // a = 6 - 需要显式整除
a %= 4;   // a = 2

// 空值合并赋值
let name: string | null = null;
name ??= 'Unknown'; // 如果name为null则赋值
console.log(name); // 'Unknown'

条件运算符

Dart:

dart

// 三目运算符
int age = 20;
String category = age >= 18 ? '成人' : '未成年';
print(category); // '成人'

// 级联运算符 - Dart特有
class Person {
  String? name;
  int? age;
}

var person = Person()
  ..name = 'Alice'
  ..age = 25;
print('${person.name}, ${person.age}'); // Alice, 25

// 空安全调用
String? text;
int? length = text?.length;
print(length); // null

ArkTS:

typescript

// 三目运算符
let age: number = 20;
let category: string = age >= 18 ? '成人' : '未成年';
console.log(category); // '成人'

// 可选链运算符 - ArkTS特有
interface Person {
  name?: string;
  age?: number;
  address?: {
    city?: string;
  };
}

let person: Person = { name: 'Alice', age: 25 };
let city = person.address?.city;
console.log(city); // undefined - 不会抛出错误

// 空值合并运算符
let text: string | null = null;
let displayText = text ?? '默认文本';
console.log(displayText); // '默认文本'

关键区别： Dart有级联运算符..，ArkTS有可选链运算符?.。

2. 控制流程对比

条件语句

Dart:

dart

// if-else语句
int score = 85;
if (score >= 90) {
  print('优秀');
} else if (score >= 60) {
  print('及格');
} else {
  print('不及格');
}

// switch语句
String grade = 'B';
switch (grade) {
  case 'A':
    print('优秀');
    break;
  case 'B':
    print('良好');
    continue alsoGood; // 继续到指定标签
  case 'C':
    print('及格');
    break;
  alsoGood:
  case 'D':
    print('也不错');
    break;
  default:
    print('未知等级');
}

ArkTS:

typescript

// if-else语句
let score: number = 85;
if (score >= 90) {
  console.log('优秀');
} else if (score >= 60) {
  console.log('及格');
} else {
  console.log('不及格');
}

// switch语句
let grade: string = 'B';
switch (grade) {
  case 'A':
    console.log('优秀');
    break;
  case 'B':
    console.log('良好');
    // 没有continue到标签的功能
    break;
  case 'C':
    console.log('及格');
    break;
  default:
    console.log('未知等级');
}

关键区别： Dart的switch支持continue到标签，ArkTS不支持。

循环语句

Dart:

dart

// for循环
for (int i = 0; i < 5; i++) {
  print('数字: $i');
}

// for-in循环
List<int> numbers = [1, 2, 3, 4, 5];
for (var number in numbers) {
  print(number);
}

// forEach方法
numbers.forEach((number) {
  print('值: $number');
});

// while循环
int count = 0;
while (count < 3) {
  print('计数: $count');
  count++;
}

// do-while循环
int i = 0;
do {
  print('i = $i');
  i++;
} while (i < 3);

ArkTS:

typescript

// for循环
for (let i = 0; i < 5; i++) {
  console.log(`数字: ${i}`);
}

// for-of循环（遍历值）
let numbers: number[] = [1, 2, 3, 4, 5];
for (let number of numbers) {
  console.log(number);
}

// for-in循环（遍历键/索引）
for (let index in numbers) {
  console.log(`索引: ${index}, 值: ${numbers[index]}`);
}

// forEach方法
numbers.forEach((number) => {
  console.log(`值: ${number}`);
});

// while循环
let count: number = 0;
while (count < 3) {
  console.log(`计数: ${count}`);
  count++;
}

// do-while循环
let i: number = 0;
do {
  console.log(`i = ${i}`);
  i++;
} while (i < 3);

关键区别： ArkTS区分for-in（遍历键）和for-of（遍历值），Dart只有for-in。

跳转语句

Dart:

dart

// break语句
for (int i = 0; i < 10; i++) {
  if (i == 5) {
    break; // 跳出整个循环
  }
  print(i); // 输出 0,1,2,3,4
}

// continue语句
for (int i = 0; i < 5; i++) {
  if (i == 2) {
    continue; // 跳过本次迭代
  }
  print(i); // 输出 0,1,3,4
}

// 标签与break/continue
outerLoop: for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
    if (i == 1 && j == 1) {
      break outerLoop; // 跳出外层循环
    }
    print('$i, $j');
  }
}

ArkTS:

typescript

// break语句
for (let i = 0; i < 10; i++) {
  if (i === 5) {
    break; // 跳出整个循环
  }
  console.log(i); // 输出 0,1,2,3,4
}

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

// 标签与break/continue
outerLoop: for (let i = 0; i < 3; i++) {
  for (let j = 0; j < 3; j++) {
    if (i === 1 && j === 1) {
      break outerLoop; // 跳出外层循环
    }
    console.log(`${i}, ${j}`);
  }
}

相同点： 跳转语句的语法和行为基本一致。

异常处理

Dart:

dart

// 抛出异常
void validateAge(int age) {
  if (age < 0) {
    throw ArgumentError('年龄不能为负数: $age');
  }
  if (age > 150) {
    throw FormatException('年龄不合理: $age');
  }
}

// 捕获异常
try {
  validateAge(-5);
} on ArgumentError catch (e) {
  print('参数错误: $e');
} on FormatException catch (e) {
  print('格式异常: $e');
} catch (e, s) {
  print('其他异常: $e');
  print('堆栈跟踪: $s');
} finally {
  print('清理工作');
}

// 重新抛出异常
try {
  validateAge(200);
} catch (e) {
  print('捕获到异常: $e');
  rethrow; // 重新抛出
}

ArkTS:

typescript

// 抛出异常
function validateAge(age: number): void {
  if (age < 0) {
    throw new Error(`年龄不能为负数: ${age}`);
  }
  if (age > 150) {
    throw new RangeError(`年龄不合理: ${age}`);
  }
}

// 捕获异常
try {
  validateAge(-5);
} catch (error) {
  if (error instanceof RangeError) {
    console.log('范围错误:', error.message);
  } else if (error instanceof Error) {
    console.log('一般错误:', error.message);
  }
} finally {
  console.log('清理工作');
}

// 自定义错误类型
class ValidationError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'ValidationError';
  }
}

关键区别： Dart支持按异常类型分别捕获（on Type catch），ArkTS需要在catch块内使用instanceof判断。

总结

特性

Dart

ArkTS

整除运算符

~/ 运算符

需使用 Math.floor()

类型检查

is 和 is!

typeof 和 instanceof

级联操作

.. 运算符

不支持

可选链

?. 运算符

?. 运算符

循环遍历

for-in 遍历值

for-in 遍历键，for-of 遍历值

Switch语句

支持 continue 到标签

不支持标签继续

异常处理

on Type catch 分别捕获

在catch内用instanceof判断

两种语言在控制流程上高度相似，都遵循C风格语法，主要区别在于：

  • Dart有一些特有的运算符（级联、整除）

  • ArkTS的类型系统更接近TypeScript

  • 异常处理机制有细微差异

  • 循环遍历方式不同

这些差异反映了Dart作为Flutter专用语言和ArkTS基于TypeScript的设计哲学差异。

developer.huawei.com/consumer/cn…

​

avatar
文章
阅读
粉丝