Skip to content

D
Docs

OpenHarmony / Docs
10 个月 前同步成功

通知 158
Star 292
Fork 28
D
Docs

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

未验证 提交 c63c08a1 编写于 作者: O openharmony_ci 提交者： Gitee
浏览文件
操作

!23859 公共基础类库指南文档arkTs整改 

Merge pull request !23859 from buzhuyu/master
上级 967d0b1a 8e259595
展开全部 隐藏空白更改
内联 并排
Showing with 513 addition and 524 deletion
zh-cn/application-dev/arkts-utils/async-concurrency-overview.md
浏览文件 @ c63c08a1
......@@ -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,11 +34,13 @@ setTimeout(() => {
Promise对象创建后，可以使用then方法和catch方法指定fulfilled状态和rejected状态的回调函数。then方法可接受两个参数，一个处理fulfilled状态的函数，另一个处理rejected状态的函数。只传一个参数则表示状态改变就执行，不区分状态结果。使用catch方法注册一个回调函数，用于处理“失败”的结果，即捕获Promise的状态改变为rejected状态或操作失败抛出的异常。例如：
```js
promise.then(result => {
console.info(`Random number is ${result}`);
}).catch(error => {
console.error(error.message);
```ts
import { BusinessError } from '@ohos.base';
promise.then((result: number) => {
console.info(`Random number is ${result}`);
}).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
浏览文件 @ c63c08a1
......@@ -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,107 +79,105 @@ struct Index {
2. 在主线程中通过调用ThreadWorker的[constructor()](../reference/apis/js-apis-worker.md#constructor9)方法创建Worker对象，当前线程为宿主线程。
```js
import worker from '@ohos.worker';
```ts
import worker from '@ohos.worker';
const workerInstance: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts');
```
const workerInstance: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts');
```
3. 在宿主线程中通过调用[onmessage()](../reference/apis/js-apis-worker.md#onmessage9)方法接收Worker线程发送过来的消息，并通过调用[postMessage()](../reference/apis/js-apis-worker.md#postmessage9)方法向Worker线程发送消息。
例如向Worker线程发送训练和预测的消息，同时接收Worker线程发送回来的消息。
```js
// 接收Worker子线程的结果
workerInstance.onmessage = function(e) {
```ts
import worker from '@ohos.worker';
const workerInstance: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts');
// 接收Worker子线程的结果
workerInstance.onmessage = (() => {
console.info('MyWorker.ts onmessage');
// 在Worker线程中进行耗时操作
}
workerInstance.onerror = function (d) {
})
workerInstance.onerror = (() => {
// 接收Worker子线程的错误信息
}
})
// 向Worker子线程发送训练消息
workerInstance.postMessage({ 'type': 0 });
// 向Worker子线程发送预测消息
workerInstance.postMessage({ 'type': 1, 'value': [90, 5] });
```
// 向Worker子线程发送训练消息
workerInstance.postMessage({ 'type': 0 });
// 向Worker子线程发送预测消息
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;
```
5. 在Worker线程中通过调用[onmessage()](../reference/apis/js-apis-worker.md#onmessage9-1)方法接收宿主线程发送的消息内容，并通过调用[postMessage()](../reference/apis/js-apis-worker.md#postmessage9-2)方法向宿主线程发送消息。
例如在Worker线程中定义预测模型及其训练过程，同时与主线程进行信息交互。
```js
import worker, { ThreadWorkerGlobalScope, MessageEvents, ErrorEvent } from '@ohos.worker';
let workerPort: ThreadWorkerGlobalScope = worker.workerPort;
// 定义训练模型及结果
let result;
// 定义预测函数
function predict(x) {
例如在Worker线程中定义预测模型及其训练过程，同时与主线程进行信息交互。
```ts
import worker, { ThreadWorkerGlobalScope, MessageEvents, ErrorEvent } from '@ohos.worker';
let workerPort: ThreadWorkerGlobalScope = worker.workerPort;
// 定义训练模型及结果
let result: Array<number>;
// 定义预测函数
function predict(x: number): number {
return result[x];
}
// 定义优化器训练过程
function optimize() {
result = {};
}
// Worker线程的onmessage逻辑
workerPort.onmessage = (e: MessageEvents): void => {
}
// 定义优化器训练过程
function optimize(): void {
result = [];
}
// Worker线程的onmessage逻辑
workerPort.onmessage = (e: MessageEvents): void => {
// 根据传输的数据的type选择进行操作
switch (e.data.type) {
case 0:
// 进行训练
optimize();
// 训练之后发送主线程训练成功的消息
workerPort.postMessage({ type: 'message', value: 'train success.' });
break;
case 1:
// 执行预测
const output = predict(e.data.value);
// 发送主线程预测的结果
workerPort.postMessage({ type: 'predict', value: output });
break;
default:
workerPort.postMessage({ type: 'message', value: 'send message is invalid' });
break;
switch (e.data.type as number) {
case 0:
// 进行训练
optimize();
// 训练之后发送主线程训练成功的消息
workerPort.postMessage({ type: 'message', value: 'train success.' });
break;
case 1:
// 执行预测
const output: number = predict(e.data.value as number);
// 发送主线程预测的结果
workerPort.postMessage({ type: 'predict', value: output });
break;
default:
workerPort.postMessage({ type: 'message', value: 'send message is invalid' });
break;
}
}
```
}
```
6. 在Worker线程中完成任务之后，执行Worker线程销毁操作。销毁线程的方式主要有两种：根据需要可以在宿主线程中对Worker线程进行销毁；也可以在Worker线程中主动销毁Worker线程。
在宿主线程中通过调用[onexit()](../reference/apis/js-apis-worker.md#onexit9)方法定义Worker线程销毁后的处理逻辑。
在宿主线程中通过调用[onexit()](../reference/apis/js-apis-worker.md#onexit9)方法定义Worker线程销毁后的处理逻辑。
```js
// Worker线程销毁后，执行onexit回调方法
workerInstance.onexit = function() {
```ts
// Worker线程销毁后，执行onexit回调方法
workerInstance.onexit = (): void => {
console.info("main thread terminate");
}
```
方式一：在宿主线程中通过调用[terminate()](../reference/apis/js-apis-worker.md#terminate9)方法销毁Worker线程，并终止Worker接收消息。
```js
// 销毁Worker线程
workerInstance.terminate();
```
方式二：在Worker线程中通过调用[close()](../reference/apis/js-apis-worker.md#close9)方法主动销毁Worker线程，并终止Worker接收消息。
```js
// 销毁线程
workerPort.close();
```
}
```
方式一：在宿主线程中通过调用[terminate()](../reference/apis/js-apis-worker.md#terminate9)方法销毁Worker线程，并终止Worker接收息。
```ts
// 销毁Worker线程
workerInstance.terminate();
```
方式二：在Worker线程中通过调用[close()](../reference/apis/js-apis-worker.md#close9)方法主动销毁Worker线程，并终止Worker接收消息。
```ts
// 销毁线程
workerPort.close();
```
\ No newline at end of file
zh-cn/application-dev/arkts-utils/io-intensive-task-development.md
浏览文件 @ c63c08a1
......@@ -8,46 +8,49 @@ I/O密集型任务的性能重点通常不在于CPU的处理能力，而在于I/
1. 定义并发函数，内部密集调用I/O能力。
```ts
import fs from '@ohos.file.fs';
import { BusinessError } from '@ohos.base';
// 定义并发函数，内部密集调用I/O能力
// 写入文件的实现
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);
}
@Concurrent
async function concurrentTest(fileList: string[]): Promise<boolean> {
// 循环写文件操作
for (let i: number = 0; i < fileList.length; i++) {
write('Hello World!', fileList[i]).then(() => {
console.info(`Succeeded in writing the file. FileList: ${fileList[i]}`);
}).catch((err: BusinessError) => {
console.error(`Failed to write the file. Code is ${err.code}, message is ${err.message}`)
return false;
})
```ts
// a.ts
import fs from '@ohos.file.fs';
// 定义并发函数，内部密集调用I/O能力
// 写入文件的实现
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> {
// 循环写文件操作
for (let i: number = 0; i < fileList.length; i++) {
write('Hello World!', fileList[i]).then(() => {
console.info(`Succeeded in writing the file. FileList: ${fileList[i]}`);
}).catch((err: BusinessError) => {
console.error(`Failed to write the file. Code is ${err.code}, message is ${err.message}`)
return false;
})
}
return true;
}
return true;
}
```
```
2. 使用TaskPool执行包含密集I/O的并发函数：通过调用[execute()](../reference/apis/js-apis-taskpool.md#taskpoolexecute)方法执行任务，并在回调中进行调度结果处理。示例中的filePath1和filePath2的获取方式请参见[获取应用文件路径](../application-models/application-context-stage.md#获取应用文件路径)。
```ts
import taskpool from '@ohos.taskpool';
let filePath1: string = ...; // 应用文件路径
let filePath2: string = ...;
// 使用TaskPool执行包含密集I/O的并发函数
// 数组较大时，I/O密集型任务任务分发也会抢占主线程，需要使用多线程能力
taskpool.execute(concurrentTest, [filePath1, filePath2]).then(() => {
// 调度结果处理
console.info(`The result: ${ret}`);
})
```
```ts
import taskpool from '@ohos.taskpool';
let filePath1: string = "path1"; // 应用文件路径
let filePath2: string = "path2";
// 使用TaskPool执行包含密集I/O的并发函数
// 数组较大时，I/O密集型任务任务分发也会抢占主线程，需要使用多线程能力
taskpool.execute(concurrentTest, [filePath1, filePath2]).then(() => {
// 调度结果处理
})
```
zh-cn/application-dev/arkts-utils/linear-container.md
浏览文件 @ c63c08a1
......@@ -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
浏览文件 @ c63c08a1
......@@ -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
浏览文件 @ c63c08a1
......@@ -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
浏览文件 @ c63c08a1
......@@ -6,25 +6,23 @@ Promise和async/await提供异步并发能力，适用于单次I/O任务的场
1. 实现单次I/O任务逻辑。
```js
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) => {
fs.close(file);
}).catch((err: BusinessError) => {
console.error(`Failed to write data. Code is ${err.code}, message is ${err.message}`);
})
}
```
```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) => {
fs.close(file);
}).catch((err: BusinessError) => {
console.error(`Failed to write data. Code is ${err.code}, message is ${err.message}`);
})
}
```
2. 采用异步能力调用单次I/O任务。示例中的filePath的获取方式请参见[获取应用文件路径](../application-models/application-context-stage.md#获取应用文件路径)。
```js
let filePath: string = ...; // 应用文件路径
write('Hello World!', filePath).then(() => {
console.info('Succeeded in writing data.');
})
```
```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
浏览文件 @ c63c08a1
......@@ -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,75 +94,76 @@ struct Index {
1. 在主线程中创建Worker对象，同时接收Worker线程发送回来的消息。
```js
import worker from '@ohos.worker';
@Entry
@Component
struct Index {
@State message: string = 'Hello World';
build() {
Row() {
Column() {
Text(this.message)
.fontSize(50)
.fontWeight(FontWeight.Bold)
.onClick(() => {
let w: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts');
w.onmessage = function (d) {
// 接收Worker子线程的结果
}
w.onerror = function (d) {
// 接收Worker子线程的错误信息
}
// 向Worker子线程发送Set消息
w.postMessage({'type': 0, 'data': 'data'})
// 向Worker子线程发送Get消息
w.postMessage({'type': 1})
// 销毁线程
w.terminate()
})
}
.width('100%')
}
.height('100%')
}
}
```
```ts
import worker from '@ohos.worker';
@Entry
@Component
struct Index {
@State message: string = 'Hello World';
build() {
Row() {
Column() {
Text(this.message)
.fontSize(50)
.fontWeight(FontWeight.Bold)
.onClick(() => {
let w: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts');
w.onmessage = () => {
// 接收Worker子线程的结果
}
w.onerror = () => {
// 接收Worker子线程的错误信息
}
// 向Worker子线程发送Set消息
w.postMessage({'type': 0, 'data': 'data'})
// 向Worker子线程发送Get消息
w.postMessage({'type': 1})
// 销毁线程
w.terminate()
})
}
.width('100%')
}
.height('100%')
}
}
```
2. 在Worker线程中绑定Worker对象，同时处理同步任务逻辑。
```js
// handle.ts代码
export default class Handle {
syncGet() {
return;
}
2. 在Worker线程中绑定Worker对象，同时处理同步任务逻辑。
syncSet(num: number) {
return;
}
}
// Worker.ts代码
import worker, { ThreadWorkerGlobalScope, MessageEvents } from '@ohos.worker';
import Handle from './handle.ts' // 返回句柄
var workerPort : ThreadWorkerGlobalScope = worker.workerPort;
// 无法传输的句柄，所有操作依赖此句柄
var handler = new Handle()
// Worker线程的onmessage逻辑
workerPort.onmessage = function(e : MessageEvents) {
switch (e.data.type) {
case 0:
handler.syncSet(e.data.data);
workerPort.postMessage('success set');
case 1:
handler.syncGet();
workerPort.postMessage('success get');
```ts
// handle.ts代码
export default class Handle {
syncGet() {
return;
}
syncSet(num: number) {
return;
}
}
// Worker.ts代码
import worker, { ThreadWorkerGlobalScope, MessageEvents } from '@ohos.worker';
import Handle from './handle.ts' // 返回句柄
var workerPort : ThreadWorkerGlobalScope = worker.workerPort;
// 无法传输的句柄，所有操作依赖此句柄
var handler = new Handle()
// Worker线程的onmessage逻辑
workerPort.onmessage = (e : MessageEvents): void => {
switch (e.data.type as number) {
case 0:
handler.syncSet(e.data.data);
workerPort.postMessage('success set');
case 1:
handler.syncGet();
workerPort.postMessage('success get');
}
}
```
}
```
zh-cn/application-dev/arkts-utils/taskpool-vs-worker.md
浏览文件 @ c63c08a1
......@@ -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
浏览文件 @ c63c08a1
......@@ -18,15 +18,15 @@ XML解析及转换需要确保传入的XML数据符合标准格式。
1. 引入模块。
```js
```ts
import convertxml from '@ohos.convertxml';
```
2. 输入待转换的XML，设置转换选项。
```js
```ts
let xml: string =
'<?xml version="1.0" encoding="utf-8"?>' +
'<?xml version="1.0" encoding="utf-8"?>' +
'<note importance="high" logged="true">' +
' <title>Happy</title>' +
' <todo>Work</todo>' +
......@@ -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
浏览文件 @ c63c08a1
......@@ -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
浏览文件 @ c63c08a1
......@@ -29,111 +29,109 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
1. 引入模块。
```js
import xml from '@ohos.xml';
import util from '@ohos.util'; // 需要使用util模块函数对文件编码
```
```ts
import xml from '@ohos.xml';
import util from '@ohos.util'; // 需要使用util模块函数对文件编码
```
2. 对XML文件编码后调用XmlPullParser。
可以基于ArrayBuffer构造XmlPullParser对象， 也可以基于DataView构造XmlPullParser对象。
```js
let strXml: string =
'<?xml version="1.0" encoding="utf-8"?>' +
'<note importance="high" logged="true">' +
'<title>Play</title>' +
'<lens>Work</lens>' +
'</note>';
let textEncoder: util.TextEncoder = new util.TextEncoder();
let arrBuffer: Uint8Array = textEncoder.encodeInto(strXml); // 对数据编码，防止包含中文字符乱码
// 1.基于ArrayBuffer构造XmlPullParser对象
let that: xml.XmlPullParser = new xml.XmlPullParser(arrBuffer.buffer, 'UTF-8');
// 2.基于DataView构造XmlPullParser对象
let dataView: DataView = new DataView(arrBuffer.buffer);
let that: xml.XmlPullParser = new xml.XmlPullParser(dataView, 'UTF-8');
```
```ts
let strXml: string =
'<?xml version="1.0" encoding="utf-8"?>' +
'<note importance="high" logged="true">' +
'<title>Play</title>' +
'<lens>Work</lens>' +
'</note>';
let textEncoder: util.TextEncoder = new util.TextEncoder();
let arrBuffer: Uint8Array = textEncoder.encodeInto(strXml); // 对数据编码，防止包含中文字符乱码
// 1.基于ArrayBuffer构造XmlPullParser对象
let that: xml.XmlPullParser = new xml.XmlPullParser(arrBuffer.buffer, 'UTF-8');
// 2.基于DataView构造XmlPullParser对象
let dataView: DataView = new DataView(arrBuffer.buffer);
let that: xml.XmlPullParser = new xml.XmlPullParser(dataView, 'UTF-8');
```
3. 自定义回调函数，本例直接打印出标签及标签值。
```js
let str: string = '';
function func(name: string, value: string): boolean {
str = name + value;
console.info(str);
return true; //true:继续解析 false:停止解析
}
```
```ts
let str: string = '';
function func(name: string, value: string): boolean {
str = name + value;
console.info(str);
return true; //true:继续解析 false:停止解析
}
```
4. 设置解析选项，调用parse函数。
```js
let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tagValueCallbackFunction:func};
that.parse(options);
```
```ts
let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tagValueCallbackFunction:func};
that.parse(options);
```
输出结果如下所示：
输出结果如下所示：
```
note
title
Play
title
lens
Work
lens
note
```
```js
note
title
Play
title
lens
Work
lens
note
```
## 解析XML属性和属性值
1. 引入模块。
```js
import xml from '@ohos.xml';
import util from '@ohos.util'; // 需要使用util模块函数对文件编码
```
```ts
import xml from '@ohos.xml';
import util from '@ohos.util'; // 需要使用util模块函数对文件编码
```
2. 对XML文件编码后调用XmlPullParser。
```js
let strXml: string =
'<?xml version="1.0" encoding="utf-8"?>' +
'<note importance="high" logged="true">' +
' <title>Play</title>' +
' <title>Happy</title>' +
' <lens>Work</lens>' +
'</note>';
let textEncoder: util.TextEncoder = new util.TextEncoder();
let arrBuffer: Uint8Array = textEncoder.encodeInto(strXml); // 对数据编码，防止包含中文字符乱码
let that: xml.XmlPullParser = new xml.XmlPullParser(arrBuffer.buffer, 'UTF-8');
```
```ts
let strXml: string =
'<?xml version="1.0" encoding="utf-8"?>' +
'<note importance="high" logged="true">' +
' <title>Play</title>' +
' <title>Happy</title>' +
' <lens>Work</lens>' +
'</note>';
let textEncoder: util.TextEncoder = new util.TextEncoder();
let arrBuffer: Uint8Array = textEncoder.encodeInto(strXml); // 对数据编码，防止包含中文字符乱码
let that: xml.XmlPullParser = new xml.XmlPullParser(arrBuffer.buffer, 'UTF-8');
```
3. 自定义回调函数，本例直接打印出属性及属性值。
```js
let str: string = '';
function func(name: string, value: string): boolean {
str += name + ' ' + value + ' ';
return true; // true:继续解析 false:停止解析
}
```
```ts
let str: string = '';
function func(name: string, value: string): boolean {
str += name + ' ' + value + ' ';
return true; // true:继续解析 false:停止解析
}
```
4. 设置解析选项，调用parse函数。
```js
let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, attributeValueCallbackFunction:func};
that.parse(options);
console.info(str); // 一次打印出所有的属性及其值
```
```ts
let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, attributeValueCallbackFunction:func};
that.parse(options);
console.info(str); // 一次打印出所有的属性及其值
```
输出结果如下所示：
```js
```
importance high logged true // note节点的属性及属性值
```
......@@ -142,54 +140,55 @@ XML模块提供XmlPullParser类对XML文件解析，输入为含有XML文本的A
1. 引入模块。
```js
import xml from '@ohos.xml';
import util from '@ohos.util'; // 需要使用util模块函数对文件编码
```
```ts
import xml from '@ohos.xml';
import util from '@ohos.util'; // 需要使用util模块函数对文件编码
```
2. 对XML文件编码后调用XmlPullParser。
```js
let strXml: string =
'<?xml version="1.0" encoding="utf-8"?>' +
'<note importance="high" logged="true">' +
'<title>Play</title>' +
'</note>';
let textEncoder: util.TextEncoder = new util.TextEncoder();
let arrBuffer: Uint8Array = textEncoder.encodeInto(strXml); // 对数据编码，防止包含中文字符乱码
let that: xml.XmlPullParser = new xml.XmlPullParser(arrBuffer.buffer, 'UTF-8');
```
```ts
let strXml: string =
'<?xml version="1.0" encoding="utf-8"?>' +
'<note importance="high" logged="true">' +
'<title>Play</title>' +
'</note>';
let textEncoder: util.TextEncoder = new util.TextEncoder();
let arrBuffer: Uint8Array = textEncoder.encodeInto(strXml); // 对数据编码，防止包含中文字符乱码
let that: xml.XmlPullParser = new xml.XmlPullParser(arrBuffer.buffer, 'UTF-8');
```
3. 自定义回调函数，本例直接打印元素事件类型及元素深度。
```js
let str: string = '';
function func(name: string, value: xml.ParseInfo): boolean {
str = name + ' ' + value.getDepth(); // getDepth 获取元素的当前深度
console.info(str)
return true; //true:继续解析 false:停止解析
}
```
```ts
let str: string = '';
function func(name: xml.EventType, value: xml.ParseInfo): boolean {
str = name + ' ' + value.getDepth(); // getDepth 获取元素的当前深度
console.info(str)
return true; //true:继续解析 false:停止解析
}
```
4. 设置解析选项，调用parse函数。
```js
let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func};
that.parse(options);
```
```ts
let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func};
that.parse(options);
```
输出结果如下所示：
```
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
3 2 // 3：</title>对应事件类型END_TAG值为3 2：深度为2
3 1 // 3：</note>对应事件类型END_TAG值为3 1：深度为1（与<note对应>）
1 0 // 1：对应事件类型END_DOCUMENT值为1 0：深度为0
```
```js
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
3 2 // 3：</title>对应事件类型END_TAG值为3 2：深度为2
3 1 // 3：</note>对应事件类型END_TAG值为3 1：深度为1（与<note对应>）
1 0 // 1：对应事件类型END_DOCUMENT值为1 0：深度为0
```
## 场景示例
......@@ -197,7 +196,7 @@ 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
浏览文件 @ c63c08a1
......@@ -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;
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或