Static Typing: All types determined at compile time, reducing runtime checks
No Dynamic Object Layout: Object structure fixed at compile time, cannot be modified at runtime
Restricted Operators: Some operator behaviors are restricted to encourage clearer code semantics
No Structural Typing: Structural typing is currently not supported

Reference Documentation

Scenario	Document
Syntax Learning	references/en/introduction-to-arkts.md
Quick Overview	references/en/arkts-get-started.md
TS Migration	references/en/typescript-to-arkts-migration-guide.md
Migration Background	references/en/arkts-migration-background.md
Performance	references/en/arkts-high-performance-programming.md
More Cases	references/en/arkts-more-cases.md

Workflows

1. Syntax Questions

User Question -> Identify Question Type -> Consult Documentation -> Provide Code Example

Common Syntax Questions:

Variable declaration -> Use let/const with explicit type or inference
Function definition -> Supports optional parameters, defaults, rest parameters, arrow functions
Classes and interfaces -> Must initialize fields, supports inheritance and implementation
Generics -> Supports constraints and default values
Null safety -> Nullable types ((T | null)), non-null assertion ((!)), optional chaining ((?.))

2. TypeScript Migration

Identify TS Code -> Check Incompatible Features -> Consult Migration Rules -> Provide ArkTS Alternative

Key Migration Rules Quick Reference:

TypeScript	ArkTS Alternative
`var x`	`let x`
`any`/`unknown`	Specific types
`{n: 42}` object literal	Define class/interface first
`[index: T]: U` index signature	`Record<T, U>`
`A & B` intersection type	`interface C extends A, B`
`function(){}` function expression	`() => {}` arrow function
`<Type>value` type assertion	`value as Type`
Destructuring `[a, b] = arr`	Individual access `arr[0]`, `arr[1]`
`for..in`	`for` loop or `for..of`
Constructor parameter properties	Explicit field declaration

3. Performance Optimization

Analyze Code -> Identify Performance Issues -> Consult Optimization Guide -> Provide Solutions

High-Performance Programming Key Points:

Declarations: Use const for invariants; avoid mixing integer and float
Loops: Extract loop invariants; avoid numeric overflow
Functions: Parameter passing preferred over closures; avoid optional parameters
Arrays: Use TypedArray for numeric values; avoid sparse arrays and union type arrays
Exceptions: Avoid throwing in loops; use return values instead

4. Compile Error Resolution

Get Error Message -> Search Migration Rules -> Find Related Case -> Provide Fix

Common Questions

Q: How to handle JSON.parse return value?

// Error
let data = JSON.parse(str);

// Correct
let data: Record<string, Object> = JSON.parse(str);

Q: How to define object types?

// TypeScript syntax (not supported in ArkTS)
type Person = { name: string, age: number }

// ArkTS syntax
interface Person {
  name: string;
  age: number;
}

// Using object literal
let p: Person = { name: 'John', age: 25 };

Q: How to replace globalThis?

// Error
globalThis.value = 'xxx';

// Use singleton pattern
export class GlobalContext {
  private constructor() {}
  private static instance: GlobalContext;
  private _objects = new Map<string, Object>();

  public static getContext(): GlobalContext {
    if (!GlobalContext.instance) {
      GlobalContext.instance = new GlobalContext();
    }
    return GlobalContext.instance;
  }

  getObject(key: string): Object | undefined {
    return this._objects.get(key);
  }

  setObject(key: string, value: Object): void {
    this._objects.set(key, value);
  }
}

Q: How to handle error types in catch?

// Error
try {} catch (e: BusinessError) {}

// Correct
try {} catch (error) {
  let e: BusinessError = error as BusinessError;
}

Q: How to use Record type?

// TypeScript index signature
function foo(data: { [key: string]: string }) {}

// ArkTS Record
function foo(data: Record<string, string>) {}

// Usage example
let map: Record<string, number> = {
  'John': 25,
  'Mary': 21,
};

Q: How to replace constructor signatures with factory functions?

// TypeScript constructor signature
type ControllerCtor = {
  new (value: string): Controller;
}

// ArkTS factory function
type ControllerFactory = () => Controller;

class Menu {
  createController: ControllerFactory = () => {
    return new Controller('default');
  }
}

Prohibited Standard Library APIs

The following are prohibited in ArkTS:

Global: eval
Object: __proto__, defineProperty, freeze, getPrototypeOf, etc.
Reflect: apply, construct, defineProperty, etc.
Proxy: All handler methods

Build Scripts

The scripts directory provides quick compilation scripts for ArkTS projects (including dependency installation):

Platform	Script	Purpose
macOS/Linux	`scripts/run.sh`	Execute `ohpm install` + `hvigorw assembleApp`
Windows	`scripts/run.ps1`	Execute `ohpm install` + `hvigorw assembleApp`

Usage:

# macOS/Linux
bash scripts/run.sh

# Windows PowerShell
.\scripts\run.ps1

Script execution steps:

Install dependencies (ohpm install --all)
Build project (hvigorw assembleApp)

Mandatory Requirements

CRITICAL: When this skill generates ArkTS code, the following workflow MUST be followed:

Compilation Verification: After generating code, you MUST compile the project using the build scripts:
- macOS/Linux: bash scripts/run.sh
- Windows: .\scripts\run.ps1
Retry Strategy: If compilation fails:
- Analyze the error output
- Fix the issue and retry compilation
- Maximum of 3 compilation attempts

User Intervention: After 3 failed compilation attempts, use AskUserQuestion:

Question: Compilation failed after 3 attempts. How would you like to proceed?
Options:
- Continue retrying (attempt another fix)
- Manual intervention (I'll wait for your guidance)
- Skip compilation (proceed without verification)

Error Reporting: Always show the full compilation error output when failures occur.

Answer Guidelines

Prioritize code examples: Show correct vs incorrect syntax comparison
Reference official documentation: For detailed explanations, guide users to consult corresponding documents in references/
Explain reasons: Explain why ArkTS has this restriction (performance, stability)
Provide alternatives: For unsupported features, provide feasible alternatives

License

MIT License - see LICENSE.txt

arkts-syntax-assistant

ArkTS Syntax Assistant

Overview

Core Features