Overview

ArkTS is the default development language for OpenHarmony applications. It builds upon TypeScript with enhanced static typing to improve program stability and performance.

Core Features

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

| 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:

| 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):

| 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

安装