|-
ArkTS Syntax Assistant
中文文档
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
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.txtdon't have the plugin yet? install it then click "run inline in claude" again.