ArkTS 语言基础与 TypeScript 的差异

interface UserProfile {
  id: number;
  name: string;
  vip: boolean;
  tags: string[];
  joinedAt: Date;
  extra?: Record<string, string>;
}

let count: number = 0;
let list: number[] = [1, 2, 3];
let maybe: string | null = null;

interface Serializable {
  serialize(): string;
}

// 显式 implements，且必须实现全部成员
class Device implements Serializable {
  readonly name: string;
  private sn: string;

  constructor(name: string, sn: string) {
    this.name = name;
    this.sn = sn;
  }

  serialize(): string {
    return JSON.stringify({ name: this.name, sn: this.sn });
  }
}

enum NetState {
  IDLE = 0,
  CONNECTED = 2,
  FAILED = 3
}

// 字符串枚举同样支持，可读性更好
enum LogLevel {
  DEBUG = 'DEBUG',
  ERROR = 'ERROR'
}

interface Repository<T extends object> {
  getById(id: string): Promise<T | null>;
  save(item: T): Promise<void>;
}

class MemoryRepo<T extends object> implements Repository<T> {
  private store: Map<string, T> = new Map();

  async getById(id: string): Promise<T | null> {
    return this.store.get(id) ?? null;
  }

  async save(item: T): Promise<void> {
    this.store.set(JSON.stringify(item), item);
  }
}

// 重载签名在前，实现签名在最后
function format(value: number): string;
function format(value: string): string;
function format(value: number | string): string {
  if (typeof value === 'number') {
    return value.toFixed(2);
  }
  return value.trim();
}

interface Config {
  network?: {
    timeout?: number;
  };
}

const cfg: Config = {};
// 可选链 + 空值合并，是 ArkTS 里处理可空值的首选写法
const timeout: number = cfg.network?.timeout ?? 5000;

// 非空断言 ! 允许使用，但要谨慎
const arr: string[] | null = null;
const len: number = arr?.length ?? 0;

// 反例：报错 Use explicit types instead of "any"
// function parse(input: any): any { return JSON.parse(input); }

// 正例：用明确的接口
interface ApiResp {
  code: number;
  msg: string;
}

function parseResp(raw: string): ApiResp {
  return JSON.parse(raw) as ApiResp;
}

interface Point {
  x: number;
  y: number;
}

// 反例：Point2 字段与 Point 一致，但没有 implements 关系，以下两行编译失败
// class Point2 { x: number = 0; y: number = 0; }
// const p: Point = new Point2();

// 正例：显式 implements
class PointImpl implements Point {
  x: number = 0;
  y: number = 0;
}
const q: Point = new PointImpl();    // 通过

interface Person {
  name: string;
  age?: number;      // 需要扩展的字段必须提前声明
}

const p: Person = { name: 'Tom' };
p.age = 18;            // 合法
// p['weight'] = 60;   // 编译报错：属性不存在
// delete p.name;      // 编译报错：不支持 delete 对象属性

// 反例：报错 Object literal must correspond to some explicitly declared class or interface
// const obj = { name: 'a', value: 1 };

interface Item {
  name: string;
  value: number;
}

// 正例一：显式标注类型
const item: Item = { name: 'a', value: 1 };

// 正例二：作为实参时由形参提供上下文类型
function send(it: Item): void { console.info(it.name); }
send({ name: 'b', value: 2 });

// 反例：ArkTS 不支持同名 interface 合并，报重复标识符
// interface Box { a: number; }
// interface Box { b: number; }

// 正例：一次写全，或用 extends 继承
interface BoxBase {
  a: number;
}
interface Box extends BoxBase {
  b: number;
}

// 反例：TS 允许的双重断言绕过检查，ArkTS 禁止
// const n = ('abc' as unknown) as number;

// 正例：断言目标必须是相关类型，或用类型守卫
function isApiResp(v: Object): v is ApiResp {
  return typeof (v as ApiResp).code === 'number';
}
const raw: Object = JSON.parse('{"code":0,"msg":"ok"}');
// 类型守卫收窄后可安全赋值
if (isApiResp(raw)) { const r: ApiResp = raw; }

// 反例：以下写法全部禁止
// const s = Symbol('k');
// Object.setPrototypeOf(obj, proto);
// obj.__proto__ = proto;
// SomeClass.prototype.newMethod = () => {};

// 正例：用类继承或组合表达扩展
class Base {
  hello(): string { return 'base'; }
}
class Derived extends Base {
  hello(): string { return 'derived'; }
}

// 反例：报错 Property 'count' has no initializer
// class Bad { count: number; }

// 正例：声明时给初值，或在构造函数中赋值
class Counter {
  count: number = 0;
  name?: string;          // 可选属性可以不初始化
  private step: number;

  constructor(step: number) {
    this.step = step;     // 构造函数内赋值也算初始化
  }
}

// 反例：ArkTS 不支持 Function 类型
// let fn: Function = () => {};

// 正例：用明确的函数签名类型
type Handler = (code: number, msg: string) => void;

const onDone: Handler = (code, msg) => { console.info(`${code}: ${msg}`); };
onDone(0, 'ok');      // 直接调用，避免 apply 的动态参数数组

// 反例：ArkTS 不支持任意索引签名
// interface Dict { [key: string]: number; }

// 正例：用 Record 或 Map
type Dict = Record<string, number>;
const d: Dict = { a: 1, b: 2 };
const m: Map<string, number> = new Map();
m.set('a', 1);