g共基础类库指南文档arkTs整改

Signed-off-by: Nbuzhuyu <buzhuyu@huawei.com>

zh-cn/application-dev/arkts-utils/async-concurrency-overview.md

@@ -16,7 +16,7 @@ Promise有三种状态：pending（进行中）、fulfilled（已完成）和rej
 最基本的用法是通过构造函数实例化一个Promise对象，同时传入一个带有两个参数的函数，通常称为executor函数。executor函数接收两个参数：resolve和reject，分别表示异步操作成功和失败时的回调函数。例如，以下代码创建了一个Promise对象并模拟了一个异步操作：
 
 
-```js
+```ts
 const promise: Promise<number> = new Promise((resolve: Function, reject: Function) => {
 setTimeout(() => {
   const randomNumber: number = Math.random();
@@ -26,7 +26,7 @@ setTimeout(() => {
     reject(new Error('Random number is too small'));
   }
 }, 1000);
-}
+})
 ```
 
 上述代码中，setTimeout函数模拟了一个异步操作，并在1秒钟后随机生成一个数字。如果随机数大于0.5，则执行resolve回调函数并将随机数作为参数传递；否则执行reject回调函数并传递一个错误对象作为参数。
@@ -34,10 +34,12 @@ setTimeout(() => {
 Promise对象创建后，可以使用then方法和catch方法指定fulfilled状态和rejected状态的回调函数。then方法可接受两个参数，一个处理fulfilled状态的函数，另一个处理rejected状态的函数。只传一个参数则表示状态改变就执行，不区分状态结果。使用catch方法注册一个回调函数，用于处理“失败”的结果，即捕获Promise的状态改变为rejected状态或操作失败抛出的异常。例如：
 
 
-```js
-promise.then(result => {
+```ts
+import { BusinessError } from '@ohos.base';
+
+promise.then((result: number) => {
  console.info(`Random number is ${result}`);
-}).catch(error => {
+}).catch((error: BusinessError) => {
  console.error(error.message);
 });
 ```
@@ -54,7 +56,7 @@ async函数是一个返回Promise对象的函数，用于表示一个异步操
 下面是一个使用async/await的例子，其中模拟了一个异步操作，该操作会在3秒钟后返回一个字符串。
 
 
-```js
+```ts
 async function myAsyncFunction(): Promise<void> {
   const result: string = await new Promise((resolve: Function) => {
     setTimeout(() => {
@@ -72,7 +74,7 @@ myAsyncFunction();
 需要注意的是，由于要等待异步操作完成，因此需要将整个操作包在async函数中。除了在async函数中使用await外，还可以使用try/catch块来捕获异步操作中的异常。
 
 
-```js
+```ts
 async function myAsyncFunction(): Promise<void> {
   try {
     const result: string = await new Promise((resolve: Function) => {

zh-cn/application-dev/arkts-utils/cpu-intensive-task-development.md

@@ -19,7 +19,6 @@ CPU密集型任务是指需要占用系统资源处理大量计算能力的任
 
 3. 结果数组汇总处理。
 
-
 ```ts
 import taskpool from '@ohos.taskpool';
 
@@ -58,8 +57,8 @@ struct Index {
           .fontSize(50)
           .fontWeight(FontWeight.Bold)
           .onClick(() => {
-            let data: ArrayBuffer;
-            histogramStatistic(data);
+            let buffer: ArrayBuffer = new ArrayBuffer(24);
+            histogramStatistic(buffer);
           })
       }
       .width('100%')
@@ -80,7 +79,7 @@ struct Index {
 
 2. 在主线程中通过调用ThreadWorker的[constructor()](../reference/apis/js-apis-worker.md#constructor9)方法创建Worker对象，当前线程为宿主线程。
 
-   ```js
+    ```ts
     import worker from '@ohos.worker';
 
     const workerInstance: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts');
@@ -89,17 +88,20 @@ struct Index {
 3. 在宿主线程中通过调用[onmessage()](../reference/apis/js-apis-worker.md#onmessage9)方法接收Worker线程发送过来的消息，并通过调用[postMessage()](../reference/apis/js-apis-worker.md#postmessage9)方法向Worker线程发送消息。
    例如向Worker线程发送训练和预测的消息，同时接收Worker线程发送回来的消息。
 
+    ```ts
+    import worker  from '@ohos.worker';
+    
+    const workerInstance: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts');
     
-   ```js
     // 接收Worker子线程的结果
-   workerInstance.onmessage = function(e) {
+    workerInstance.onmessage = (() => {
      console.info('MyWorker.ts onmessage');
      // 在Worker线程中进行耗时操作
-   }
+    })
     
-   workerInstance.onerror = function (d) {
+    workerInstance.onerror = (() => {
      // 接收Worker子线程的错误信息
-   }
+    })
     
     // 向Worker子线程发送训练消息
     workerInstance.postMessage({ 'type': 0 });
@@ -107,9 +109,10 @@ struct Index {
     workerInstance.postMessage({ 'type': 1, 'value': [90, 5] });
     ```
 
+
 4. 在MyWorker.ts文件中绑定Worker对象，当前线程为Worker线程。
 
-   ```js
+   ```ts
    import worker, { ThreadWorkerGlobalScope, MessageEvents, ErrorEvent } from '@ohos.worker';
 
    let workerPort: ThreadWorkerGlobalScope = worker.workerPort;
@@ -118,29 +121,23 @@ struct Index {
 5. 在Worker线程中通过调用[onmessage()](../reference/apis/js-apis-worker.md#onmessage9-1)方法接收宿主线程发送的消息内容，并通过调用[postMessage()](../reference/apis/js-apis-worker.md#postmessage9-2)方法向宿主线程发送消息。
     例如在Worker线程中定义预测模型及其训练过程，同时与主线程进行信息交互。
 
-
-   ```js
+    ```ts
     import worker, { ThreadWorkerGlobalScope, MessageEvents, ErrorEvent } from '@ohos.worker';
-
     let workerPort: ThreadWorkerGlobalScope = worker.workerPort;
-
     // 定义训练模型及结果
-   let result;
-
+    let result: Array<number>;
     // 定义预测函数
-   function predict(x) {
+    function predict(x: number): number {
      return result[x];
     }
-
     // 定义优化器训练过程
-   function optimize() {
-     result = {};
+    function optimize(): void {
+     result = [];
     }
-
     // Worker线程的onmessage逻辑
     workerPort.onmessage = (e: MessageEvents): void => {
      // 根据传输的数据的type选择进行操作
-     switch (e.data.type) {
+     switch (e.data.type as number) {
       case 0:
       // 进行训练
        optimize();
@@ -149,7 +146,7 @@ struct Index {
        break;
       case 1:
       // 执行预测
-         const output = predict(e.data.value);
+       const output: number = predict(e.data.value as number);
       // 发送主线程预测的结果
        workerPort.postMessage({ type: 'predict', value: output });
        break;
@@ -164,23 +161,23 @@ struct Index {
 
     在宿主线程中通过调用[onexit()](../reference/apis/js-apis-worker.md#onexit9)方法定义Worker线程销毁后的处理逻辑。
 
-   ```js
+    ```ts
     // Worker线程销毁后，执行onexit回调方法
-   workerInstance.onexit = function() {
+    workerInstance.onexit = (): void => {
      console.info("main thread terminate");
     }
     ```
 
-   方式一：在宿主线程中通过调用[terminate()](../reference/apis/js-apis-worker.md#terminate9)方法销毁Worker线程，并终止Worker接收消息。
+    方式一：在宿主线程中通过调用[terminate()](../reference/apis/js-apis-worker.md#terminate9)方法销毁Worker线程，并终止Worker接收息。
     
-   ```js
+    ```ts
     // 销毁Worker线程
     workerInstance.terminate();
     ```
     
     方式二：在Worker线程中通过调用[close()](../reference/apis/js-apis-worker.md#close9)方法主动销毁Worker线程，并终止Worker接收消息。
     
-   ```js
+    ```ts
     // 销毁线程
     workerPort.close();
     ```
\ No newline at end of file

zh-cn/application-dev/arkts-utils/io-intensive-task-development.md

@@ -8,18 +8,22 @@ I/O密集型任务的性能重点通常不在于CPU的处理能力，而在于I/
 
 
 1. 定义并发函数，内部密集调用I/O能力。
-
     ```ts
+    // a.ts
     import fs from '@ohos.file.fs';
-  import { BusinessError } from '@ohos.base';
     
     // 定义并发函数，内部密集调用I/O能力
     // 写入文件的实现
-  async function write(data: string, filePath: string): Promise<void> {
+    export async function write(data: string, filePath: string): Promise<void> {
       let file: fs.File = await fs.open(filePath, fs.OpenMode.READ_WRITE);
       await fs.write(file.fd, data);
       fs.close(file);
     }
+    ```
+
+	```ts
+    import { write } from './a'
+    import { BusinessError } from '@ohos.base';
     
     @Concurrent
     async function concurrentTest(fileList: string[]): Promise<boolean> {
@@ -41,13 +45,12 @@ I/O密集型任务的性能重点通常不在于CPU的处理能力，而在于I/
     ```ts
     import taskpool from '@ohos.taskpool';
     
-   let filePath1: string = ...; // 应用文件路径
-   let filePath2: string = ...;
+    let filePath1: string = "path1"; // 应用文件路径
+    let filePath2: string = "path2";
     
     // 使用TaskPool执行包含密集I/O的并发函数
     // 数组较大时，I/O密集型任务任务分发也会抢占主线程，需要使用多线程能力
     taskpool.execute(concurrentTest, [filePath1, filePath2]).then(() => {
       // 调度结果处理
-     console.info(`The result: ${ret}`);
     })
     ```

zh-cn/application-dev/arkts-utils/linear-container.md

@@ -198,7 +198,7 @@ Stack进行增、删、改、查操作的常用API如下：
 此处列举常用的线性容器ArrayList、Vector、Deque、Stack、List的使用示例，包括导入模块、增加元素、访问元素及修改等操作。示例代码如下所示：
 
 
-```js
+```ts
 // ArrayList
 import ArrayList from '@ohos.util.ArrayList'; // 导入ArrayList模块
 

zh-cn/application-dev/arkts-utils/multi-thread-concurrency-overview.md

@@ -27,7 +27,7 @@ Actor并发模型作为基于消息通信并发模型的典型代表，不需要
 可转移对象（Transferable object）传输采用地址转移进行序列化，不需要内容拷贝，会将ArrayBuffer的所有权转移给接收该ArrayBuffer的线程，转移后该ArrayBuffer在发送它的线程中变为不可用，不允许再访问。
 
 
-```js
+```ts
 // 定义可转移对象
 let buffer: ArrayBuffer = new ArrayBuffer(100);
 ```
@@ -42,7 +42,7 @@ let buffer: ArrayBuffer = new ArrayBuffer(100);
 SharedArrayBuffer对象存储的数据在同时被修改时，需要通过原子操作保证其同步性，即下个操作开始之前务必需要等到上个操作已经结束。
 
 
-```js
+```ts
 // 定义可共享对象，可以使用Atomics进行操作
 let sharedBuffer: SharedArrayBuffer = new SharedArrayBuffer(1024);
 ```

zh-cn/application-dev/arkts-utils/nonlinear-container.md

@@ -212,7 +212,7 @@ PlainArray进行增、删、改、查操作的常用API如下：
 此处列举常用的非线性容器HashMap、TreeMap、LightWeightMap、PlainArray的使用示例，包括导入模块、增加元素、访问元素及修改等操作，示例代码如下所示：
 
 
-```js
+```ts
 // HashMap
 import HashMap from '@ohos.util.HashMap'; // 导入HashMap模块
 

zh-cn/application-dev/arkts-utils/single-io-development.md

@@ -6,10 +6,9 @@ Promise和async/await提供异步并发能力，适用于单次I/O任务的场
 
 1. 实现单次I/O任务逻辑。
 
-   ```js
+    ```ts
     import fs from '@ohos.file.fs';
     import { BusinessError } from '@ohos.base';
-
     async function write(data: string, filePath: string): Promise<void> {
       let file: fs.File = await fs.open(filePath, fs.OpenMode.READ_WRITE);
       fs.write(file.fd, data).then((writeLen: number) => {
@@ -19,11 +18,10 @@ Promise和async/await提供异步并发能力，适用于单次I/O任务的场
       })
     }
     ```
-
 2. 采用异步能力调用单次I/O任务。示例中的filePath的获取方式请参见[获取应用文件路径](../application-models/application-context-stage.md#获取应用文件路径)。
 
-   ```js
-   let filePath: string = ...; // 应用文件路径
+    ```ts
+    let filePath: string = "path"; // 应用文件路径
     write('Hello World!', filePath).then(() => {
       console.info('Succeeded in writing data.');
     })

zh-cn/application-dev/arkts-utils/sync-task-development.md

@@ -39,6 +39,7 @@ export default class Handle {
 }
 ```
 
+
 业务使用TaskPool调用相关同步方法的代码。
 
 
@@ -52,8 +53,6 @@ import Handle from './Handle'; // 返回静态句柄
 function func(num: number): boolean {
   // 调用静态类对象中实现的同步等待调用
   Handle.syncSet(num);
-  // 或者调用单例对象中实现的同步等待调用
-  Handle.getInstance().syncGet();
   return true;
 }
 
@@ -95,7 +94,7 @@ struct Index {
 
 1. 在主线程中创建Worker对象，同时接收Worker线程发送回来的消息。
 
-   ```js
+    ```ts
     import worker from '@ohos.worker';
     
     @Entry
@@ -111,10 +110,10 @@ struct Index {
               .fontWeight(FontWeight.Bold)
               .onClick(() => {
                 let w: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts');
-               w.onmessage = function (d) {
+                w.onmessage = () => {
                   // 接收Worker子线程的结果
                 }
-               w.onerror = function (d) {
+                w.onerror = () => {
                   // 接收Worker子线程的错误信息
                 }
                 // 向Worker子线程发送Set消息
@@ -132,9 +131,10 @@ struct Index {
     }
     ```
 
+
 2. 在Worker线程中绑定Worker对象，同时处理同步任务逻辑。
 
-   ```js
+    ```ts
     // handle.ts代码
     export default class Handle {
       syncGet() {
@@ -156,8 +156,8 @@ struct Index {
     var handler = new Handle()
     
     // Worker线程的onmessage逻辑
-   workerPort.onmessage = function(e : MessageEvents) {
-     switch (e.data.type) {
+    workerPort.onmessage = (e : MessageEvents): void => {
+     switch (e.data.type as number) {
       case 0:
        handler.syncSet(e.data.data);
        workerPort.postMessage('success set');

zh-cn/application-dev/arkts-utils/taskpool-vs-worker.md

@@ -100,23 +100,21 @@ TaskPool支持开发者在主线程封装任务抛给任务队列，系统选择
 
   当使用Worker模块具体功能时，均需先构造Worker实例对象，其构造函数与API版本相关。
 
-```js
+```ts
 // API 9及之后版本使用：
-const worker1: worker.ThreadWorker = new worker.ThreadWorker(scriptURL);
+const worker1: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts');
 // API 8及之前版本使用：
-const worker1: worker.ThreadWorker = new worker.Worker(scriptURL);
+const worker2: worker.Worker = new worker.Worker('entry/ets/workers/MyWorker.ts');
 ```
 
 构造函数需要传入Worker的路径（scriptURL），Worker文件存放位置默认路径为Worker文件所在目录与pages目录属于同级。
 
 **Stage模型**
 
-
 构造函数中的scriptURL示例如下：
 
 
-
-```js
+```ts
 // 写法一
 // Stage模型-目录同级（entry模块下，workers目录与pages目录同级）
 const worker1: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts', {name:"first worker in Stage model"});
@@ -149,7 +147,7 @@ const worker4: worker.ThreadWorker = new worker.ThreadWorker('@bundle:com.exampl
 
   构造函数中的scriptURL示例如下：
 
-```js
+```ts
 // FA模型-目录同级（entry模块下，workers目录与pages目录同级）
 const worker1: worker.ThreadWorker = new worker.ThreadWorker('workers/worker.js', {name:'first worker in FA model'});
 // FA模型-目录不同级（entry模块下，workers目录与pages目录的父目录同级）

zh-cn/application-dev/arkts-utils/xml-conversion.md

@@ -18,13 +18,13 @@ XML解析及转换需要确保传入的XML数据符合标准格式。
 
 1. 引入模块。
 
-   ```js
+   ```ts
    import convertxml from '@ohos.convertxml';
    ```
 
 2. 输入待转换的XML，设置转换选项。
 
-   ```js
+   ```ts
    let xml: string =
     '<?xml version="1.0" encoding="utf-8"?>' +
     '<note importance="high" logged="true">' +
@@ -62,7 +62,7 @@ XML解析及转换需要确保传入的XML数据符合标准格式。
 
 3. 调用转换函数，打印结果。
 
-   ```js
+   ```ts
    let conv: convertxml.ConvertXML = new convertxml.ConvertXML();
    let result: object = conv.convertToJSObject(xml, options);
    let strRes: string = JSON.stringify(result); // 将js对象转换为json字符串，用于显式输出
@@ -71,7 +71,6 @@ XML解析及转换需要确保传入的XML数据符合标准格式。
 
    输出结果如下所示：
 
-
    ```js
    strRes:
    {"_declaration":{"_attributes":{"version":"1.0","encoding":"utf-8"}},"_elements":[{"_type":"element","_name":"note",

zh-cn/application-dev/arkts-utils/xml-generation.md

@@ -24,14 +24,14 @@ XML模块的API接口可以参考[@ohos.xml](../reference/apis/js-apis-xml.md)
 
 1. 引入模块。
 
-   ```js
+   ```ts
    import xml from '@ohos.xml';
    import util from '@ohos.util';
    ```
 
 2. 创建缓冲区，构造XmlSerializer对象（可以基于Arraybuffer构造XmlSerializer对象， 也可以基于DataView构造XmlSerializer对象）。
 
-   ```js
+   ```ts
    // 1.基于Arraybuffer构造XmlSerializer对象
    let arrayBuffer: ArrayBuffer = new ArrayBuffer(2048); // 创建一个2048字节的缓冲区
    let thatSer: xml.XmlSerializer = new xml.XmlSerializer(arrayBuffer); // 基于Arraybuffer构造XmlSerializer对象
@@ -44,7 +44,7 @@ XML模块的API接口可以参考[@ohos.xml](../reference/apis/js-apis-xml.md)
 
 3. 调用XML元素生成函数。
 
-   ```js
+   ```ts
    thatSer.setDeclaration(); // 写入xml的声明
    thatSer.startElement('bookstore'); // 写入元素开始标记
    thatSer.startElement('book'); // 嵌套元素开始标记
@@ -65,7 +65,7 @@ XML模块的API接口可以参考[@ohos.xml](../reference/apis/js-apis-xml.md)
 
 4. 使用Uint8Array操作Arraybuffer，调用TextDecoder对Uint8Array解码后输出。
 
-   ```js
+   ```ts
    let view: Uint8Array = new Uint8Array(arrayBuffer); // 使用Uint8Array读取arrayBuffer的数据
    let textDecoder: util.TextDecoder = util.TextDecoder.create(); // 调用util模块的TextDecoder类
    let res: string = textDecoder.decodeWithStream(view); // 对view解码
@@ -74,7 +74,6 @@ XML模块的API接口可以参考[@ohos.xml](../reference/apis/js-apis-xml.md)
 
    输出结果如下：
 
-
-   ```js
+   ```
    <?xml version=\"1.0\" encoding=\"utf-8\"?><bookstore>\r\n  <book category=\"COOKING\">\r\n    <title lang=\"en\">Everyday</title>\r\n    <author>Giada</author>\r\n    <year>2005</year>\r\n  </book>\r\n</bookstore>
    ```

zh-cn/application-dev/arkts-utils/xml-parsing.md

@@ -29,7 +29,7 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 
 1. 引入模块。
 
-   ```js
+    ```ts
     import xml from '@ohos.xml';
     import util from '@ohos.util'; // 需要使用util模块函数对文件编码
     ```
@@ -37,8 +37,7 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 2. 对XML文件编码后调用XmlPullParser。
    可以基于ArrayBuffer构造XmlPullParser对象， 也可以基于DataView构造XmlPullParser对象。
 
-
-   ```js
+    ```ts
     let strXml: string =
     '<?xml version="1.0" encoding="utf-8"?>' +
       '<note importance="high" logged="true">' +
@@ -57,7 +56,7 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 
 3. 自定义回调函数，本例直接打印出标签及标签值。
 
-   ```js
+    ```ts
     let str: string = '';
     function func(name: string, value: string): boolean {
       str = name + value;
@@ -68,15 +67,14 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 
 4. 设置解析选项，调用parse函数。
 
-   ```js
+    ```ts
     let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tagValueCallbackFunction:func};
     that.parse(options);
     ```
 
 	输出结果如下所示：
 
-
-   ```js
+	```
 	note
 	title
 	Play
@@ -88,18 +86,20 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 	```
 
 
+
+
 ## 解析XML属性和属性值
 
 1. 引入模块。
 
-   ```js
+    ```ts
     import xml from '@ohos.xml';
     import util from '@ohos.util'; // 需要使用util模块函数对文件编码
     ```
 
 2. 对XML文件编码后调用XmlPullParser。
 
-   ```js
+    ```ts
     let strXml: string =
       '<?xml version="1.0" encoding="utf-8"?>' +
         '<note importance="high" logged="true">' +
@@ -114,7 +114,7 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 
 3. 自定义回调函数，本例直接打印出属性及属性值。
 
-   ```js
+    ```ts
     let str: string = '';
     function func(name: string, value: string): boolean {
       str += name + ' ' + value + ' ';
@@ -124,16 +124,14 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 
 4. 设置解析选项，调用parse函数。
 
-   ```js
+    ```ts
     let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, attributeValueCallbackFunction:func};
     that.parse(options);
     console.info(str); // 一次打印出所有的属性及其值
     ```
 
    输出结果如下所示：
-
-
-   ```js
+   ```
    importance high logged true // note节点的属性及属性值
    ```
 
@@ -142,14 +140,14 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 
 1. 引入模块。
 
-   ```js
+    ```ts
     import xml from '@ohos.xml';
     import util from '@ohos.util'; // 需要使用util模块函数对文件编码
     ```
 
 2. 对XML文件编码后调用XmlPullParser。
 
-   ```js
+    ```ts
     let strXml: string =
       '<?xml version="1.0" encoding="utf-8"?>' +
       '<note importance="high" logged="true">' +
@@ -162,9 +160,9 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 
 3. 自定义回调函数，本例直接打印元素事件类型及元素深度。
 
-   ```js
+    ```ts
     let str: string  = '';
-   function func(name: string, value: xml.ParseInfo): boolean {
+    function func(name: xml.EventType, value: xml.ParseInfo): boolean {
       str = name + ' ' + value.getDepth(); // getDepth 获取元素的当前深度
       console.info(str)
       return true; //true:继续解析 false:停止解析
@@ -173,16 +171,15 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 
 4. 设置解析选项，调用parse函数。
 
-   ```js
+     ```ts
      let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func};
      that.parse(options);
      ```
 
    输出结果如下所示：
 
-
-   ```js
-   0 0 // 0：<?xml version="1.0" encoding="utf-8"?> 对应事件类型START_DOCUMENT值为0  0：起始深度为0
+	```
+	 0 0 // 0：<?xml version="1.0" encoding="utf-8"?> 对应事件类型		START_DOCUMENT值为0  0：起始深度为0
 	 2 1 // 2：<note importance="high" logged="true"> 对应事件类型START_TAG值为2       1：深度为1
 	 2 2 // 2：<title>对应事件类型START_TAG值为2                                       2：深度为2
 	 4 2 // 4：Play对应事件类型TEXT值为4                                               2：深度为2
@@ -192,12 +189,14 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
 	```
 
 
+
+
 ## 场景示例
 
 此处以调用所有解析选项为例，提供解析XML标签、属性和事件类型的开发示例。
 
 
-```js
+```ts
 import xml from '@ohos.xml';
 import util from '@ohos.util';
 
@@ -218,13 +217,13 @@ function tagFunc(name: string, value: string): boolean {
   return true;
 }
 
-function attFunc(name: string, value: string): boolean {
+function attFunc(name: xml.EventType, value: string): boolean {
   str = name + ' ' + value;
   console.info('attri-' + str);
   return true;
 }
 
-function tokenFunc(name: string, value: xml.ParseInfo): boolean {
+function tokenFunc(name: xml.EventType, value: xml.ParseInfo): boolean {
   str = name + ' ' + value.getDepth();
   console.info('token-' + str);
   return true;
@@ -238,33 +237,31 @@ let options: xml.ParseOptions = {
   tokenValueCallbackFunction: tokenFunc
 };
 that.parse(options);
-
 ```
 
 输出结果如下所示：
 
-
-```js
-tag-
-token-0 0
-tag-book
-attri-category COOKING
-token-2 1
-tag-title
-attri-lang en
-token-2 2
-tag-Everyday
-token-4 2
-tag-title
-token-3 2
-tag-author
-token-2 2
-tag-Giada
-token-4 2
-tag-author
-token-3 2
-tag-book
-token-3 1
-tag-
-token-1 0
-```
+   ```
+   tag-
+   token-0 0
+   tag-book
+   attri-category COOKING
+   token-2 1
+   tag-title
+   attri-lang en
+   token-2 2
+   tag-Everyday
+   token-4 2
+   tag-title
+   token-3 2
+   tag-author
+   token-2 2
+   tag-Giada
+   token-4 2
+   tag-author
+   token-3 2
+   tag-book
+   token-3 1
+   tag-
+   token-1 0
+   ```

zh-cn/application-dev/reference/apis/js-apis-taskpool.md

@@ -688,7 +688,7 @@ taskpoolExecute();
 
 ```ts
 // b.ets
-export let c: number = 2000;
+export let c: string = "hello";
 ```
 ```ts
 // 引用import变量
@@ -696,7 +696,7 @@ export let c: number = 2000;
 import { c } from "./b";
 
 @Concurrent
-function printArgs(a: number): number {
+function printArgs(a: string): string {
     console.log(a);
     console.log(c);
     return a;