谁能告知一下ArkTS相关知识点总结，

let hi: string = 'hello'

Const hello: string= 'hello'

for (variable of iterable)  
 statement

function add(x: string, y: string): string { 
  let z: string = `${x} ${y}` 
  return z 
}

function hello(name?: string) { 
  if (name == undefined) { 
    console.log('Hello!') 
  } else { 
    console.log('Hello, ${name}!') 
  } 
}

function multiply(n: number, coeff: number = 2): number { 
  return n * coeff 
} 
multiply(2)  // 返回2*2 
multiply(2, 3) // 返回2*3

function sum(...numbers: number[]): number { 
  let res = 0 
  for (let n of numbers) 
    res += n 
  return res 
} 
sum() // 返回0 
sum(1, 2, 3) // 返回6

// 显式指定返回类型 
function foo(): string { return 'foo' } 
// 推断返回类型为string 
function goo() { return 'goo' }

type trigFunc = (x: number) => number // 这是一个函数类型 
function do_action(f: trigFunc) { 
   f(3.141592653589) // 调用函数 
} 
do_action(Math.sin) // 将函数作为参数传入

let sum = (x: number, y: number): number => { 
  return x + y 
}

let sum1 = (x: number, y: number) => { return x + y } 
let sum2 = (x: number, y: number) => x + y

function f(): () => number { 
  let count = 0 
  return (): number => { count++; return count } 
} 
let z = f() 
console.log(z()) // 输出：1 
console.log(z()) // 输出：2

class Person { 
  name: string = '' 
  age: number = 0 
  constructor(n: string, a: number) { 
    this.name = n 
    this.age = a 
  } 
  GetName(): string { 
    return this.name 
  } 
} 
let p1 = new Person('Alice', 25) 
console.log(p1.name) 
let p2 = new Person('Bob', 28) 
console.log(p2.GetName())

class Person { 
  static numberOfPersons = 0 
  constructor() { 
     // ... 
     Person.numberOfPersons++ 
     // ... 
  } 
} 
console.log(Person.numberOfPersons)

class Person { 
  name ?: string // 可能为`undefined` 
  
  setName(n:string): void { 
    this.name = n 
  } 
  // 编译时错误：name可以是"undefined"，所以将这个API的返回值类型标记为string 
  getNameWrong(): string { 
    return this.name 
  } 
  getName(): string | undefined { // 返回类型匹配name的类型 
    return this.name 
  } 
} 
let jack = new Person() 
// 假设代码中没有对name赋值，例如调用"jack.setName('Jack')" 
  
// 编译时错误：编译器认为下一行代码有可能会访问undefined的属性，报错 
console.log(jack.getName().length);  // 编译失败 
console.log(jack.getName()?.length); // 编译成功，没有运行时错误

class Cl { 
  static staticMethod(): string { 
    return 'this is a static method.' 
  } 
} 
console.log(Cl.staticMethod())

class Rectangle { 
  constructor(width: number, height: number) { 
    // ... 
  } 
} 
class Square extends Rectangle { 
  constructor(side: number) { 
    super(side, side) 
  } 
}

class C { 
  constructor()             /* 第一个签名 */ 
  constructor(x: string)    /* 第二个签名 */ 
  constructor(x?: string) { /* 实现签名 */ 
    console.log(x) 
  } 
} 
let c1 = new C()      // OK，使用第一个签名 
let c2 = new C('abc') // OK，使用第二个签名

class C { 
  n: number = 0 
  s: string = '' 
} 
let c: C = {n: 42, s: 'foo'}

let map: Record<string, number> = { 
  'John': 25, 
  'Mary': 21, 
} 
console.log(map['John']) // prints 25

const promise: Promise<number> = new Promise((resolve: Function, reject: Function) => { 
setTimeout(() => { 
  const randomNumber: number = Math.random(); 
  if (randomNumber > 0.5) { 
    resolve(randomNumber); 
  } else { 
    reject(new Error('Random number is too small')); 
  } 
}, 1000); 
})

import { BusinessError } from '@ohos.base'; 
  
promise.then((result: number) => { 
 console.info(`Random number is ${result}`); 
}).catch((error: BusinessError) => { 
 console.error(error.message); 
});

async function myAsyncFunction(): Promise<void> { 
  try { 
    const result: string = await new Promise((resolve: Function) => { 
      resolve('Hello, world!'); 
    }); 
  } catch (e) { 
    console.error(`Get exception: ${e}`); 
  } 
} 
myAsyncFunction();

import taskpool from '@ohos.taskpool';

@Concurrent 
function printArgs(args: number): number { 
    console.log("printArgs: " + args); 
    return args; 
} 
taskpool.execute(printArgs, 100).then((value: number) => { // 100: test number 
  console.log("taskpool result: " + value); 
});

// 导入模块 
import worker form '@ohos.worker';

// 写法一 
// Stage模型-目录同级（entry模块下，workers目录与pages目录同级） 
const worker1: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts', {name:"first worker in Stage model"}); 
// Stage模型-目录不同级（entry模块下，workers目录是pages目录的子目录） 
const worker2: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/pages/workers/MyWorker.ts'); 
// 写法二 
// Stage模型-目录同级（entry模块下，workers目录与pages目录同级），假设bundlename是com.example.workerdemo 
const worker3: worker.ThreadWorker = new worker.ThreadWorker('@bundle:com.example.workerdemo/entry/ets/workers/worker'); 
// Stage模型-目录不同级（entry模块下，workers目录是pages目录的子目录），假设bundlename是com.example.workerdemo 
const worker4: worker.ThreadWorker = new worker.ThreadWorker('@bundle:com.example.workerdemo/entry/ets/pages/workers/worker');