1. 基础数据类型对比
数字类型 (Numbers)
Dart:
dart
// 整数类型
int age = 25;
int hexValue = 0xDEADBEEF;
// 浮点数类型
double price = 19.99;
double exponent = 1.42e5;
// 数值类型自动推断
var number = 42; // 编译时为 int
var decimal = 3.14; // 编译时为 doubleArkTS:
typescript
// 数字类型 (不区分整数和浮点数)
let age: number = 25;
let price: number = 19.99;
let hexValue: number = 0xDEADBEEF;
let exponent: number = 1.42e5;
// 类型推断
let number = 42; // 推断为 number
let decimal = 3.14; // 推断为 number关键区别： Dart严格区分int和double，而ArkTS统一使用number类型。
字符串类型 (Strings)
Dart:
dart
// 字符串定义
String name = 'Alice';
String greeting = "Hello, World!";
// 多行字符串
String multiLine = '''
这是多行
字符串
''';
// 字符串插值
String message = 'Hello, $name! You are ${age + 1} years old next year.';ArkTS:
typescript
// 字符串定义
let name: string = 'Alice';
let greeting: string = "Hello, World!";
// 多行字符串 (使用模板字符串)
let multiLine: string = `
这是多行
字符串
`;
// 字符串插值
let message: string = `Hello, ${name}! You are ${age + 1} years old next year.`;关键区别： 两者都支持字符串插值，但语法不同：Dart使用$variable，ArkTS使用${expression}。
布尔类型 (Booleans)
Dart:
dart
bool isActive = true;
bool isEmpty = false;
// 类型检查
var result = 10 > 5; // 自动推断为 boolArkTS:
typescript
let isActive: boolean = true;
let isEmpty: boolean = false;
// 类型检查
let result: boolean = 10 > 5;相同点： 两者布尔类型基本一致。
2. 集合数据类型对比
列表/数组 (List/Array)
Dart:
dart
// 列表定义
List<int> numbers = [1, 2, 3, 4, 5];
List<String> names = ['Alice', 'Bob', 'Charlie'];
// 动态类型列表
List dynamicList = [1, 'hello', true];
// 列表操作
numbers.add(6);
names.removeAt(0);
print(numbers.length); // 获取长度ArkTS:
typescript
// 数组定义
let numbers: number[] = [1, 2, 3, 4, 5];
let names: Array<string> = ['Alice', 'Bob', 'Charlie'];
// 元组类型 (ArkTS特有)
let tuple: [string, number, boolean] = ['Alice', 25, true];
// 数组操作
numbers.push(6);
names.splice(0, 1);
console.log(numbers.length); // 获取长度关键区别： ArkTS支持**元组(Tuple)**类型，可以定义固定类型和长度的数组。
映射/对象 (Map/Object)
Dart:
dart
// Map定义
Map<String, dynamic> person = {
'name': 'Alice',
'age': 25,
'isStudent': true
};
// 类型化Map
Map<String, int> scores = {
'math': 95,
'english': 88
};
// Map操作
person['city'] = 'Beijing';
print(person['name']);ArkTS:
typescript
// 对象定义
interface Person {
name: string;
age: number;
isStudent: boolean;
}
let person: Person = {
name: 'Alice',
age: 25,
isStudent: true
};
// 索引签名对象
let dynamicObject: { [key: string]: any } = {
'name': 'Alice',
'age': 25
};
// 对象操作
dynamicObject['city'] = 'Beijing';
console.log(person.name);关键区别： ArkTS强调**接口(Interface)**定义对象结构，提供更好的类型安全。
3. 特殊数据类型对比
空安全处理
Dart:
dart
// 可空类型
String? nullableString = null;
int? nullableInt;
// 空断言操作符
String name = nullableString!; // 运行时如果为null会抛出异常
// 空安全调用
int? length = nullableString?.length;
// 空值合并操作符
String displayName = nullableString ?? 'Unknown';ArkTS:
typescript
// 可空类型
let nullableString: string | null = null;
let nullableString2: string | undefined = undefined;
// 非空断言操作符
let name: string = nullableString!;
// 可选链操作符
let length: number | undefined = nullableString?.length;
// 空值合并操作符
let displayName: string = nullableString ?? 'Unknown';枚举类型 (Enums)
Dart:
dart
enum Color { red, green, blue }
// 增强枚举 (Dart 2.17+)
enum Status {
pending('等待中'),
approved('已批准'),
rejected('已拒绝');
final String description;
const Status(this.description);
}
var favoriteColor = Color.blue;
print(favoriteColor.index); // 2ArkTS:
typescript
enum Color {
Red,
Green,
Blue
}
// 字符串枚举
enum Direction {
Up = "UP",
Down = "DOWN",
Left = "LEFT",
Right = "RIGHT"
}
let favoriteColor: Color = Color.Blue;
console.log(favoriteColor); // 2动态类型与类型推断
Dart:
dart
// dynamic类型
dynamic anything = 'hello';
anything = 42; // 可以重新赋值为不同类型
anything = [1, 2, 3]; // 再次改变类型
// var类型推断
var name = 'Alice'; // 推断为 String
var count = 42; // 推断为 int
// final和const
final username = 'Alice'; // 运行时常量
const maxCount = 100; // 编译时常量ArkTS:
typescript
// any类型
let anything: any = 'hello';
anything = 42; // 可以重新赋值为不同类型
anything = [1, 2, 3]; // 再次改变类型
// unknown类型 (比any更安全)
let uncertain: unknown = 'hello';
// uncertain.toUpperCase(); // 错误：需要类型检查
if (typeof uncertain === 'string') {
console.log(uncertain.toUpperCase()); // 正确
}
// 类型推断
let name = 'Alice'; // 推断为 string
let count = 42; // 推断为 number
// const和readonly
const maxCount = 100; // 常量
let readonlyArray: readonly number[] = [1, 2, 3];
// readonlyArray.push(4); // 错误：只读数组关键区别： ArkTS引入unknown类型，比any更安全，需要显式类型检查。
4. 高级类型特性
联合类型与类型别名
Dart:
dart
// 联合类型 (通过继承或mixin实现)
abstract class Shape {}
class Circle implements Shape {}
class Rectangle implements Shape {}
// 类型定义别名
typedef IntList = List<int>;
typedef StringMapper = String Function(String);
IntList numbers = [1, 2, 3];
StringMapper toUpper = (s) => s.toUpperCase();ArkTS:
typescript
// 联合类型
type ID = number | string;
type Status = 'pending' | 'approved' | 'rejected';
let userId: ID = 123;
userId = 'abc123'; // 允许
let currentStatus: Status = 'pending';
// 类型别名
type Point = {
x: number;
y: number;
};
type StringMapper = (s: string) => string;
let position: Point = { x: 10, y: 20 };
let toUpper: StringMapper = (s) => s.toUpperCase();泛型 (Generics)
Dart:
dart
// 泛型类
class Box<T> {
T value;
Box(this.value);
T getValue() => value;
}
// 泛型函数
T first<T>(List<T> items) {
return items[0];
}
var stringBox = Box<String>('hello');
var numberBox = Box<int>(42);ArkTS:
typescript
// 泛型接口
interface Box<T> {
value: T;
getValue(): T;
}
// 泛型函数
function first<T>(items: T[]): T {
return items[0];
}
// 泛型约束
interface HasLength {
length: number;
}
function logLength<T extends HasLength>(arg: T): void {
console.log(arg.length);
}
let stringBox: Box<string> = { value: 'hello', getValue: () => 'hello' };
let numberBox: Box<number> = { value: 42, getValue: () => 42 };总结
| 特性 | Dart | ArkTS |
|---|---|---|
| 数字类型 | 区分int和double |
统一number类型 |
| 字符串插值 | $variable |
${expression} |
| 数组/列表 | List<T> |
T[] 或 Array<T> |
| 元组支持 | 不支持 | 支持[T1, T2, T3] |
| 对象结构 | Map或类定义 |
接口interface定义 |
| 空安全 | T?和!操作符 |
`T |
| 动态类型 | dynamic |
any和更安全的unknown |
| 类型别名 | typedef |
type关键字 |
| 枚举增强 | 支持带字段的枚举 | 支持字符串枚举 |
两种语言在数据类型设计上都体现了现代语言的特性，但ArkTS基于TypeScript，更强调静态类型安全和与JavaScript生态的兼容性，而Dart作为Flutter的专属语言，更注重开发效率和运行时性能的平衡