1# @ohos.xml (XML解析与生成) 2<!--Kit: ArkTS--> 3<!--Subsystem: CommonLibrary--> 4<!--Owner: @xliu-huanwei; @shilei123; @huanghello--> 5<!--Designer: @yuanyao14--> 6<!--Tester: @kirl75; @zsw_zhushiwei--> 7<!--Adviser: @ge-yafang--> 8 9本模块提供XML生成和解析的接口。 10 11本模块提供了两种生成XML文件的方式: 12* [XmlSerializer](#xmlserializer)：适用于已知XML文本大小的情况 13* [XmlDynamicSerializer<sup>20+</sup>](#xmldynamicserializer20)：适用于未知XML文本大小的情况。 14 15> **说明：** 16> 17> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 18 19 20## 导入模块 21 22``` 23import { xml } from '@kit.ArkTS'; 24``` 25 26## XmlSerializer 27 28XmlSerializer接口用于生成XML文件。 29 30### constructor 31 32constructor(buffer: ArrayBuffer | DataView, encoding?: string) 33 34XmlSerializer的构造函数。 35 36> **说明：** 37> 38> buffer是开发者根据需要自定义大小的缓存区域，用于临时存储生成的XML文本。在使用过程中必须确保缓存区域足以容纳生成的文本内容。 39 40**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 41 42**系统能力：** SystemCapability.Utils.Lang 43 44**参数：** 45 46| 参数名 | 类型 | 必填 | 说明 | 47| -------- | --------------------------------- | ---- | ------------------------------------------------ | 48| buffer | ArrayBuffer \| DataView | 是 | 用于接收写入XML信息的ArrayBuffer或DataView内存。 | 49| encoding | string | 否 | 编码格式，默认'utf-8'（目前仅支持'utf-8'）。 | 50 51**错误码：** 52 53以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 54 55| 错误码ID | 错误信息 | 56| -------- | -------- | 57| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 58 59**示例：** 60 61```ts 62let arrayBuffer = new ArrayBuffer(2048); 63let thatSer = new xml.XmlSerializer(arrayBuffer, "utf-8"); 64``` 65 66### setAttributes 67 68setAttributes(name: string, value: string): void 69 70添加元素的属性和属性值。 71 72> **说明：** 73> 74> 该接口对所添加数据不做标准XML校验处理，确保所添加的数据符合标准XML规范。例如不允许添加数字开头的属性名称以及添加多个同名的属性名称。 75 76**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 77 78**系统能力：** SystemCapability.Utils.Lang 79 80**参数：** 81 82| 参数名 | 类型 | 必填 | 说明 | 83| ------ | ------ | ---- | --------------- | 84| name | string | 是 | 属性。 | 85| value | string | 是 | 属性值。 | 86 87**错误码：** 88 89以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 90 91| 错误码ID | 错误信息 | 92| -------- | -------- | 93| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 94 95**示例：** 96 97```ts 98import { util } from '@kit.ArkTS'; 99 100let arrayBuffer = new ArrayBuffer(2048); 101let thatSer = new xml.XmlSerializer(arrayBuffer); 102thatSer.startElement("note"); 103thatSer.setAttributes("importance", "high"); 104thatSer.endElement(); 105let uint8 = new Uint8Array(arrayBuffer); 106let result = util.TextDecoder.create().decodeToString(uint8); 107console.info(result); // <note importance="high"/> 108``` 109 110### addEmptyElement 111 112addEmptyElement(name: string): void 113 114添加一个空元素。 115 116> **说明：** 117> 118> 该接口对所添加数据不做标准XML校验处理，确保所添加的数据符合标准XML规范。例如不允许添加数字开头的元素名称。 119 120**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 121 122**系统能力：** SystemCapability.Utils.Lang 123 124**参数：** 125 126| 参数名 | 类型 | 必填 | 说明 | 127| ------ | ------ | ---- | ------------------ | 128| name | string | 是 | 元素的名称。 | 129 130**错误码：** 131 132以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 133 134| 错误码ID | 错误信息 | 135| -------- | -------- | 136| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 137 138**示例：** 139 140```ts 141import { util } from '@kit.ArkTS'; 142 143let arrayBuffer = new ArrayBuffer(2048); 144let thatSer = new xml.XmlSerializer(arrayBuffer); 145thatSer.addEmptyElement("d"); 146let uint8 = new Uint8Array(arrayBuffer); 147let result = util.TextDecoder.create().decodeToString(uint8); 148console.info(result); // <d/> 149``` 150 151### setDeclaration 152 153setDeclaration(): void 154 155添加文件声明。 156 157**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 158 159**系统能力：** SystemCapability.Utils.Lang 160 161**示例：** 162 163```ts 164import { util } from '@kit.ArkTS'; 165 166let arrayBuffer = new ArrayBuffer(2048); 167let thatSer = new xml.XmlSerializer(arrayBuffer); 168thatSer.setDeclaration(); 169let uint8 = new Uint8Array(arrayBuffer); 170let result = util.TextDecoder.create().decodeToString(uint8); 171console.info(result); 172// <?xml version="1.0" encoding="utf-8"?> 173``` 174 175### startElement 176 177startElement(name: string): void 178 179根据给定名称添加元素开始标记。 180 181> **说明：** 182> 183>- 调用该接口后须调用[endElement](#endelement)写入元素结束标记，以确保节点正确闭合。 184> 185>- 该接口对所添加数据不做标准XML校验处理，请确保所添加的数据符合标准XML规范。比如不允许添加数字开头的元素名称。 186 187**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 188 189**系统能力：** SystemCapability.Utils.Lang 190 191**参数：** 192 193| 参数名 | 类型 | 必填 | 说明 | 194| ------ | ------ | ---- | ------------------ | 195| name | string | 是 | 当前元素的元素名。 | 196 197**错误码：** 198 199以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 200 201| 错误码ID | 错误信息 | 202| -------- | -------- | 203| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 204 205**示例：** 206 207```ts 208import { util } from '@kit.ArkTS'; 209 210let arrayBuffer = new ArrayBuffer(2048); 211let thatSer = new xml.XmlSerializer(arrayBuffer); 212thatSer.startElement("note"); 213thatSer.setText("Happy"); 214thatSer.endElement(); 215let uint8 = new Uint8Array(arrayBuffer); 216let result = util.TextDecoder.create().decodeToString(uint8); 217console.info(result); 218// <note>Happy</note> 219``` 220 221### endElement 222 223endElement(): void 224 225添加元素结束标记。 226 227> **说明：** 228> 229> 调用该接口前必须先调用[startElement](#startelement)接口写入元素开始标记。 230 231**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 232 233**系统能力：** SystemCapability.Utils.Lang 234 235**示例：** 236 237```ts 238import { util } from '@kit.ArkTS'; 239 240let arrayBuffer = new ArrayBuffer(2048); 241let thatSer = new xml.XmlSerializer(arrayBuffer); 242thatSer.startElement("note"); 243thatSer.setText("Happy"); 244thatSer.endElement(); 245let uint8 = new Uint8Array(arrayBuffer); 246let result = util.TextDecoder.create().decodeToString(uint8); 247console.info(result); 248// <note>Happy</note> 249``` 250 251### setNamespace 252 253setNamespace(prefix: string, namespace: string): void 254 255添加当前元素标记的命名空间。 256 257> **说明：** 258> 259> 该接口对所添加数据不做标准XML校验处理，请确保所添加的数据符合标准XML规范。例如禁止添加数字开头的前缀以及为同一个元素设置多个命名空间。 260 261**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 262 263**系统能力：** SystemCapability.Utils.Lang 264 265**参数：** 266 267| 参数名 | 类型 | 必填 | 说明 | 268| --------- | ------ | ---- | ------------------------------ | 269| prefix | string | 是 | 当前元素及其子元素的前缀。 | 270| namespace | string | 是 | 当前元素及其子元素的命名空间。 | 271 272**错误码：** 273 274以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 275 276| 错误码ID | 错误信息 | 277| -------- | -------- | 278| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 279 280**示例：** 281 282```ts 283import { util } from '@kit.ArkTS'; 284 285let arrayBuffer = new ArrayBuffer(2048); 286let thatSer = new xml.XmlSerializer(arrayBuffer); 287thatSer.setNamespace("h", "http://www.w3.org/TR/html4/"); 288thatSer.startElement("note"); 289thatSer.endElement(); 290let uint8 = new Uint8Array(arrayBuffer); 291let result = util.TextDecoder.create().decodeToString(uint8); 292console.info(result); 293// <h:note xmlns:h="http://www.w3.org/TR/html4/"/> 294``` 295 296### setComment 297 298setComment(text: string): void 299 300添加注释内容。 301 302**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 303 304**系统能力：** SystemCapability.Utils.Lang 305 306**参数：** 307 308| 参数名 | 类型 | 必填 | 说明 | 309| ------ | ------ | ---- | -------------------- | 310| text | string | 是 | 当前元素的注释内容。 | 311 312**错误码：** 313 314以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 315 316| 错误码ID | 错误信息 | 317| -------- | -------- | 318| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 319 320**示例：** 321 322```ts 323import { util } from '@kit.ArkTS'; 324 325let arrayBuffer = new ArrayBuffer(2048); 326let thatSer = new xml.XmlSerializer(arrayBuffer); 327thatSer.setComment("Hello, World!"); 328let uint8 = new Uint8Array(arrayBuffer); 329let result = util.TextDecoder.create().decodeToString(uint8); 330console.info(result); // <!--Hello, World!--> 331``` 332 333### setCDATA 334 335setCDATA(text: string): void 336 337提供在CDATA标签中添加数据的能力，所生成的CDATA标签结构为："\<!\[CDATA\[" + 所添加的数据 + "\]\]\>"。 338 339> **说明：** 340> 341> 该接口对所添加数据不做标准XML校验处理，请确保所添加的数据符合标准XML规范。比如不允许在CDATA标签中添加包含"\]\]\>"字符串的数据。 342 343**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 344 345**系统能力：** SystemCapability.Utils.Lang 346 347**参数：** 348 349| 参数名 | 类型 | 必填 | 说明 | 350| ------ | ------ | ---- | ----------------- | 351| text | string | 是 | CDATA属性的内容。 | 352 353**错误码：** 354 355以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 356 357| 错误码ID | 错误信息 | 358| -------- | -------- | 359| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 360 361**示例：** 362 363```ts 364import { util } from '@kit.ArkTS'; 365 366let arrayBuffer = new ArrayBuffer(2048); 367let thatSer = new xml.XmlSerializer(arrayBuffer); 368thatSer.setCDATA('root SYSTEM') 369let uint8 = new Uint8Array(arrayBuffer); 370let result = util.TextDecoder.create().decodeToString(uint8); 371console.info(result); // <![CDATA[root SYSTEM]]> 372``` 373 374### setText 375 376setText(text: string): void 377 378添加标签值。 379 380**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 381 382**系统能力：** SystemCapability.Utils.Lang 383 384**参数：** 385 386| 参数名 | 类型 | 必填 | 说明 | 387| ------ | ------ | ---- | ---------------- | 388| text | string | 是 | text属性的内容。 | 389 390**错误码：** 391 392以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 393 394| 错误码ID | 错误信息 | 395| -------- | -------- | 396| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 397 398**示例：** 399 400```ts 401import { util } from '@kit.ArkTS'; 402 403let arrayBuffer = new ArrayBuffer(2048); 404let thatSer = new xml.XmlSerializer(arrayBuffer); 405thatSer.startElement("note"); 406thatSer.setAttributes("importance", "high"); 407thatSer.setText("Happy"); 408thatSer.endElement(); 409let uint8 = new Uint8Array(arrayBuffer); 410let result = util.TextDecoder.create().decodeToString(uint8); 411console.info(result); // <note importance="high">Happy</note> 412``` 413 414### setDocType 415 416setDocType(text: string): void 417 418添加文档类型。 419 420**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 421 422**系统能力：** SystemCapability.Utils.Lang 423 424**参数：** 425 426| 参数名 | 类型 | 必填 | 说明 | 427| ------ | ------ | ---- | ------------------- | 428| text | string | 是 | DocType属性的内容。 | 429 430**错误码：** 431 432以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 433 434| 错误码ID | 错误信息 | 435| -------- | -------- | 436| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 437 438**示例：** 439 440```ts 441import { util } from '@kit.ArkTS'; 442 443let arrayBuffer = new ArrayBuffer(2048); 444let thatSer = new xml.XmlSerializer(arrayBuffer); 445thatSer.setDocType('root SYSTEM "http://www.test.org/test.dtd"'); 446let uint8 = new Uint8Array(arrayBuffer); 447let result = util.TextDecoder.create().decodeToString(uint8); 448console.info(result); // <!DOCTYPE root SYSTEM "http://www.test.org/test.dtd"> 449``` 450 451## XmlDynamicSerializer<sup>20+</sup> 452 453XmlDynamicSerializer类用于动态生成XML字符串。当无法确定XML内容长度时，推荐使用该类。 454 455> **说明：** 456> 457> 使用该类构造的对象无需自行创建ArrayBuffer，程序动态扩容，可以不断添加XML元素，最终序列化结果字符串长度上限为100000。 458 459### constructor<sup>20+</sup> 460 461constructor(encoding?: string) 462 463XmlDynamicSerializer的构造函数。 464 465**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 466 467**系统能力：** SystemCapability.Utils.Lang 468 469**参数：** 470 471| 参数名 | 类型 | 必填 | 说明 | 472| -------- | --------------------------------- | ---- | ------------------------------------------------ | 473| encoding | string | 否 | 编码格式，默认'utf-8'(目前仅支持'utf-8')。 | 474 475**错误码：** 476 477以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 478 479| 错误码ID | 错误信息 | 480| -------- | -------- | 481| 10200066 | Incorrect encoding format, only support utf-8. | 482 483**示例：** 484 485```ts 486let serializer = new xml.XmlDynamicSerializer('utf-8'); 487``` 488 489### getOutput<sup>20+</sup> 490 491getOutput(): ArrayBuffer 492 493返回XML字符串的ArrayBuffer。 494 495**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 496 497**系统能力：** SystemCapability.Utils.Lang 498 499**返回值：** 500 501| 类型 | 说明 | 502| ------ | -------------------- | 503| ArrayBuffer | 用于接收写入XML信息的ArrayBuffer内存。 | 504 505**示例：** 506 507```ts 508import { util } from '@kit.ArkTS'; 509 510let serializer = new xml.XmlDynamicSerializer('utf-8'); 511serializer.startElement("note"); 512serializer.setText("Happy"); 513serializer.endElement(); 514let arr = serializer.getOutput(); 515let uint8 = new Uint8Array(arr); 516let result = util.TextDecoder.create().decodeToString(uint8); 517console.info(result); // <note>Happy</note> 518``` 519 520### setAttributes<sup>20+</sup> 521 522setAttributes(name: string, value: string): void 523 524写入元素的属性和属性值。 525 526> **说明：** 527> 528> 该接口对所添加数据不做标准XML校验处理，请确保所添加的数据符合标准XML规范。比如不允许添加数字开头的属性名称以及添加多个同名的属性名称。 529 530**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 531 532**系统能力：** SystemCapability.Utils.Lang 533 534**参数：** 535 536| 参数名 | 类型 | 必填 | 说明 | 537| ------ | ------ | ---- | --------------- | 538| name | string | 是 | 属性。所组成的XML长度不能超过100000。| 539| value | string | 是 | 属性值。所组成的XML长度不能超过100000。| 540 541**错误码：** 542 543以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 544 545| 错误码ID | 错误信息 | 546| -------- | -------- | 547| 10200062 | The cumulative length of xml has exceeded the upper limit 100000. | 548| 10200063 | Illegal position for xml. | 549| 10200064 | Cannot be an empty string. | 550 551**示例：** 552 553```ts 554import { util } from '@kit.ArkTS'; 555 556let serializer = new xml.XmlDynamicSerializer('utf-8'); 557serializer.startElement("note"); 558serializer.setAttributes("importance", "high"); 559serializer.endElement(); 560let arrayBuffer = serializer.getOutput(); 561let uint8 = new Uint8Array(arrayBuffer); 562let result = util.TextDecoder.create().decodeToString(uint8); 563console.info(result); // <note importance="high"/> 564``` 565 566### addEmptyElement<sup>20+</sup> 567 568addEmptyElement(name: string): void 569 570写入一个空元素。 571 572> **说明：** 573> 574> 该接口对所添加数据不做标准XML校验处理，请确保所添加的数据符合标准XML规范。比如不允许添加数字开头的元素名称。 575 576**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 577 578**系统能力：** SystemCapability.Utils.Lang 579 580**参数：** 581 582| 参数名 | 类型 | 必填 | 说明 | 583| ------ | ------ | ---- | ------------------ | 584| name | string | 是 | 该空元素的元素名。所组成的XML长度不能超过100000。| 585 586**错误码：** 587 588以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 589 590| 错误码ID | 错误信息 | 591| -------- | -------- | 592| 10200062 | The cumulative length of xml has exceeded the upper limit 100000. | 593| 10200064 | Cannot be an empty string. | 594 595**示例：** 596 597```ts 598import { util } from '@kit.ArkTS'; 599 600let serializer = new xml.XmlDynamicSerializer('utf-8'); 601serializer.addEmptyElement("d"); 602let arrayBuffer = serializer.getOutput(); 603let uint8 = new Uint8Array(arrayBuffer); 604let result = util.TextDecoder.create().decodeToString(uint8); 605console.info(result); // <d/> 606``` 607 608### setDeclaration<sup>20+</sup> 609 610setDeclaration(): void 611 612编写带有编码的文件声明。 613 614**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 615 616**系统能力：** SystemCapability.Utils.Lang 617 618**错误码：** 619 620以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 621 622| 错误码ID | 错误信息 | 623| -------- | -------- | 624| 10200062 | The cumulative length of xml has exceeded the upper limit 100000. | 625| 10200063 | Illegal position for xml. | 626 627**示例：** 628 629```ts 630import { util } from '@kit.ArkTS'; 631 632let serializer = new xml.XmlDynamicSerializer('utf-8'); 633serializer.setDeclaration(); 634let arrayBuffer = serializer.getOutput(); 635let uint8 = new Uint8Array(arrayBuffer); 636let result = util.TextDecoder.create().decodeToString(uint8); 637console.info(result); // <?xml version="1.0" encoding="utf-8"?> 638``` 639 640### startElement<sup>20+</sup> 641 642startElement(name: string): void 643 644写入元素开始标记。 645 646> **说明：** 647> 648>- 调用该接口后须调用[endElement](#endelement)写入元素结束标记，以确保节点正确闭合。 649> 650>- 该接口对所添加数据不做标准XML校验处理，请确保所添加的数据符合标准XML规范。比如不允许添加数字开头的元素名称。 651 652**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 653 654**系统能力：** SystemCapability.Utils.Lang 655 656**参数：** 657 658| 参数名 | 类型 | 必填 | 说明 | 659| ------ | ------ | ---- | ------------------ | 660| name | string | 是 | 当前元素的元素名。所组成的XML长度不能超过100000。| 661 662**错误码：** 663 664以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 665 666| 错误码ID | 错误信息 | 667| -------- | -------- | 668| 10200062 | The cumulative length of xml has exceeded the upper limit 100000. | 669| 10200064 | Cannot be an empty string. | 670 671**示例：** 672 673```ts 674import { util } from '@kit.ArkTS'; 675 676let serializer = new xml.XmlDynamicSerializer('utf-8'); 677serializer.startElement("note"); 678serializer.setText("Happy"); 679serializer.endElement(); 680let arrayBuffer = serializer.getOutput(); 681let uint8 = new Uint8Array(arrayBuffer); 682let result = util.TextDecoder.create().decodeToString(uint8); 683console.info(result); // <note>Happy</note> 684``` 685 686### endElement<sup>20+</sup> 687 688endElement(): void 689 690写入元素结束标记。 691 692> **说明：** 693> 694> 调用该接口前必须先调用[startElement](#startelement)接口写入元素开始标记。 695 696**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 697 698**系统能力：** SystemCapability.Utils.Lang 699 700**错误码：** 701 702以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 703 704| 错误码ID | 错误信息 | 705| -------- | -------- | 706| 10200062 | The cumulative length of xml has exceeded the upper limit 100000. | 707| 10200065 | There is no match between the startElement and the endElement. | 708 709**示例：** 710 711```ts 712import { util } from '@kit.ArkTS'; 713 714let serializer = new xml.XmlDynamicSerializer('utf-8'); 715serializer.startElement("note"); 716serializer.setText("Happy"); 717serializer.endElement(); 718let arrayBuffer = serializer.getOutput(); 719let uint8 = new Uint8Array(arrayBuffer); 720let result = util.TextDecoder.create().decodeToString(uint8); 721console.info(result); // <note>Happy</note> 722``` 723 724### setNamespace<sup>20+</sup> 725 726setNamespace(prefix: string, namespace: string): void 727 728写入当前元素标记的命名空间。 729 730> **说明：** 731> 732> 该接口对所添加数据不做标准XML校验处理，请确保所添加的数据符合标准XML规范。比如不允许添加数字开头的前缀以及对同一个元素设置多个命名空间。 733 734**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 735 736**系统能力：** SystemCapability.Utils.Lang 737 738**参数：** 739 740| 参数名 | 类型 | 必填 | 说明 | 741| --------- | ------ | ---- | ------------------------------ | 742| prefix | string | 是 | 当前元素及其子元素的前缀。所组成的XML长度不能超过100000。| 743| namespace | string | 是 | 当前元素及其子元素的命名空间。所组成的XML长度不能超过100000。| 744 745**错误码：** 746 747以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 748 749| 错误码ID | 错误信息 | 750| -------- | -------- | 751| 10200062 | The cumulative length of xml has exceeded the upper limit 100000. | 752| 10200064 | Cannot be an empty string. | 753 754**示例：** 755 756```ts 757import { util } from '@kit.ArkTS'; 758 759let serializer = new xml.XmlDynamicSerializer('utf-8'); 760serializer.setNamespace("h", "http://www.w3.org/TR/html4/"); 761serializer.startElement("note"); 762serializer.endElement(); 763let arrayBuffer = serializer.getOutput(); 764let uint8 = new Uint8Array(arrayBuffer); 765let result = util.TextDecoder.create().decodeToString(uint8); 766console.info(result); // <h:note xmlns:h="http://www.w3.org/TR/html4/"/> 767``` 768 769### setComment<sup>20+</sup> 770 771setComment(text: string): void 772 773写入注释内容。 774 775**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 776 777**系统能力：** SystemCapability.Utils.Lang 778 779**参数：** 780 781| 参数名 | 类型 | 必填 | 说明 | 782| ------ | ------ | ---- | -------------------- | 783| text | string | 是 | 当前元素的注释内容。所组成的XML长度不能超过100000。| 784 785**错误码：** 786 787以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 788 789| 错误码ID | 错误信息 | 790| -------- | -------- | 791| 10200062 | The cumulative length of xml has exceeded the upper limit 100000. | 792| 10200064 | Cannot be an empty string. | 793 794**示例：** 795 796```ts 797import { util } from '@kit.ArkTS'; 798 799let serializer = new xml.XmlDynamicSerializer('utf-8'); 800serializer.setComment("Hello, World!"); 801let arrayBuffer = serializer.getOutput(); 802let uint8 = new Uint8Array(arrayBuffer); 803let result = util.TextDecoder.create().decodeToString(uint8); 804console.info(result); // <!--Hello, World!--> 805``` 806 807### setCdata<sup>20+</sup> 808 809setCdata(text: string): void 810 811提供在CDATA标签中添加数据的能力，所生成的CDATA标签结构为："\<!\[CDATA\[" + 所添加的数据 + "\]\]\>"。 812 813> **说明：** 814> 815> 该接口对所添加数据不做标准XML校验处理，请确保所添加的数据符合标准XML规范。比如不允许在CDATA标签中添加包含"\]\]\>"字符串的数据。 816 817**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 818 819**系统能力：** SystemCapability.Utils.Lang 820 821**参数：** 822 823| 参数名 | 类型 | 必填 | 说明 | 824| ------ | ------ | ---- | ----------------- | 825| text | string | 是 | CDATA属性的内容。所组成的XML长度不能超过100000。| 826 827**错误码：** 828 829以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 830 831| 错误码ID | 错误信息 | 832| -------- | -------- | 833| 10200062 | The cumulative length of xml has exceeded the upper limit 100000. | 834| 10200064 | Cannot be an empty string. | 835 836**示例：** 837 838```ts 839import { util } from '@kit.ArkTS'; 840 841let serializer = new xml.XmlDynamicSerializer('utf-8'); 842serializer.setCdata('root SYSTEM') 843let arrayBuffer = serializer.getOutput(); 844let uint8 = new Uint8Array(arrayBuffer); 845let result = util.TextDecoder.create().decodeToString(uint8); 846console.info(result); // <![CDATA[root SYSTEM]]> 847``` 848 849### setText<sup>20+</sup> 850 851setText(text: string): void 852 853写入标签值。 854 855**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 856 857**系统能力：** SystemCapability.Utils.Lang 858 859**参数：** 860 861| 参数名 | 类型 | 必填 | 说明 | 862| ------ | ------ | ---- | ---------------- | 863| text | string | 是 | 标签值。所组成的XML长度不能超过100000。| 864 865**错误码：** 866 867以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 868 869| 错误码ID | 错误信息 | 870| -------- | -------- | 871| 10200062 | The cumulative length of xml has exceeded the upper limit 100000. | 872| 10200064 | Cannot be an empty string. | 873 874**示例：** 875 876```ts 877import { util } from '@kit.ArkTS'; 878 879let serializer = new xml.XmlDynamicSerializer('utf-8'); 880serializer.startElement("note"); 881serializer.setAttributes("importance", "high"); 882serializer.setText("Happy"); 883serializer.endElement(); 884let arrayBuffer = serializer.getOutput(); 885let uint8 = new Uint8Array(arrayBuffer); 886let result = util.TextDecoder.create().decodeToString(uint8); 887console.info(result); // <note importance="high">Happy</note> 888``` 889 890### setDocType<sup>20+</sup> 891 892setDocType(text: string): void 893 894写入文档类型。 895 896**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。 897 898**系统能力：** SystemCapability.Utils.Lang 899 900**参数：** 901 902| 参数名 | 类型 | 必填 | 说明 | 903| ------ | ------ | ---- | ------------------- | 904| text | string | 是 | DocType属性的内容。所组成的XML长度不能超过100000。 | 905 906**错误码：** 907 908以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 909 910| 错误码ID | 错误信息 | 911| -------- | -------- | 912| 10200062 | The cumulative length of xml has exceeded the upper limit 100000. | 913| 10200064 | Cannot be an empty string. | 914 915**示例：** 916 917```ts 918import { util } from '@kit.ArkTS'; 919 920let serializer = new xml.XmlDynamicSerializer('utf-8'); 921serializer.setDocType('root SYSTEM "http://www.test.org/test.dtd"'); 922let arrayBuffer = serializer.getOutput(); 923let uint8 = new Uint8Array(arrayBuffer); 924let result = util.TextDecoder.create().decodeToString(uint8); 925console.info(result); // <!DOCTYPE root SYSTEM "http://www.test.org/test.dtd"> 926``` 927 928## XmlPullParser 929 930XmlPullParser接口用于解析现有的XML文件。 931 932### constructor 933 934constructor(buffer: ArrayBuffer | DataView, encoding?: string) 935 936构造并返回一个XmlPullParser对象。 937 938**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 939 940**系统能力：** SystemCapability.Utils.Lang 941 942**参数：** 943 944| 参数名 | 类型 | 必填 | 说明 | 945| -------- | --------------------------------- | ---- | ------------------------------------------ | 946| buffer | ArrayBuffer \| DataView | 是 | 用于解析的XML文本信息。| 947| encoding | string | 否 | 编码格式，默认'utf-8'（目前仅支持'utf-8'）。 | 948 949**错误码：** 950 951以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 952 953| 错误码ID | 错误信息 | 954| -------- | -------- | 955| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 956 957**示例：** 958 959```ts 960import { util } from '@kit.ArkTS'; 961 962let strXml = '<title>Happy</title>' 963let textEncoder = new util.TextEncoder(); 964let uint8Array = textEncoder.encodeInto(strXml); 965let that = new xml.XmlPullParser(uint8Array.buffer as object as ArrayBuffer, 'UTF-8'); 966``` 967 968### parseXml<sup>14+</sup> 969 970parseXml(option: ParseOptions): void 971 972解析XML。 973 974**原子化服务API**：从API version 14 开始，该接口支持在原子化服务中使用。 975 976**系统能力：** SystemCapability.Utils.Lang 977 978**参数：** 979 980| 参数名 | 类型 | 必填 | 说明 | 981| ------ | ----------------------------- | ---- | ------------- | 982| option | [ParseOptions](#parseoptions) | 是 | XML解析选项。 | 983 984**错误码：** 985 986以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 987 988| 错误码ID | 错误信息 | 989| -------- | -------- | 990| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 991 992**示例：** 993具体使用场景可参照[解析XML标签和标签值](../../arkts-utils/xml-parsing.md#解析xml标签和标签值)和[解析XML属性和属性值](../../arkts-utils/xml-parsing.md#解析xml属性和属性值) 994 995```ts 996import { xml, util } from '@kit.ArkTS'; 997 998let strxml = 999 '<?xml version="1.0" encoding="utf-8"?>' + 1000 '<note importance="high" logged="true">' + 1001 ' <title><![CDATA[测试\n测试]]></title>' + 1002 '</note>'; 1003let textEncoder = new util.TextEncoder(); 1004let uint8 = textEncoder.encodeInto(strxml); 1005 1006function func(key: xml.EventType, value: xml.ParseInfo) { 1007 if (key == xml.EventType.CDSECT) { 1008 console.info(JSON.stringify(value.getText())); 1009 } 1010 return true; 1011} 1012let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func} 1013let pullParser = new xml.XmlPullParser(uint8.buffer as object as ArrayBuffer); 1014pullParser.parseXml(options); 1015// "测试\n测试" 1016``` 1017 1018### parse<sup>(deprecated)</sup> 1019 1020parse(option: ParseOptions): void 1021 1022该接口用于解析XML。 1023 1024> **说明：** 1025> 1026> 从API version 8开始支持，从API version 14开始废弃，建议使用[parseXml<sup>14+</sup>](#parsexml14)替代。 1027 1028**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1029 1030**系统能力：** SystemCapability.Utils.Lang 1031 1032**参数：** 1033 1034| 参数名 | 类型 | 必填 | 说明 | 1035| ------ | ----------------------------- | ---- | -------------------------------- | 1036| option | [ParseOptions](#parseoptions) | 是 | XML解析选项。 | 1037 1038**错误码：** 1039 1040以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1041 1042| 错误码ID | 错误信息 | 1043| -------- | -------- | 1044| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 1045 1046**示例：** 1047 1048```ts 1049import { util } from '@kit.ArkTS'; 1050 1051let strXml = 1052 '<?xml version="1.0" encoding="utf-8"?>' + 1053 '<note importance="high" logged="true">' + 1054 '<company>John & Hans</company>' + 1055 '<title>Happy</title>' + 1056 '</note>'; 1057let textEncoder = new util.TextEncoder(); 1058let arrBuffer = textEncoder.encodeInto(strXml); 1059let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer, 'UTF-8'); 1060let str = ''; 1061function func(name: string, value: string) { 1062 str = name + value; 1063 console.info(str); 1064 return true; 1065} 1066let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tagValueCallbackFunction:func} 1067that.parse(options); 1068// note 1069// company 1070// John & Hans 1071// company 1072// title 1073// Happy 1074// title 1075// note 1076``` 1077 1078## AttributeWithTagCb<sup>20+</sup> 1079 1080type AttributeWithTagCb = (tagName: string, key: string, value: string) => boolean 1081 1082**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。 1083 1084**系统能力：** SystemCapability.Utils.Lang 1085 1086**参数：** 1087 1088| 参数名 | 类型 | 必填 | 说明 | 1089| ------- | -------| ---- | ------ | 1090| tagName | string | 是 | 标签名称。| 1091| key | string | 是 | 属性名称。| 1092| value | string | 是 | 属性的值。| 1093 1094**返回值：** 1095 1096| 类型 | 说明 | 1097| ------- | ------------------------------------------------------------------------- | 1098| boolean | 是否继续解析标签名称、属性名称及属性的值。true表示继续解析，false表示停止解析。 | 1099 1100## ParseOptions 1101 1102XML解析选项。 1103 1104 1105**系统能力：** SystemCapability.Utils.Lang。 1106 1107 1108| 名称 | 类型 | 必填 | 说明 | 1109| ------------------------------ | ------------------------------------------------------------ | ---- | --------------------------------------- | 1110| supportDoctype | boolean | 否 | 是否解析文档类型，false表示不解析文档类型，true表示解析文档类型，默认值false。 <br/>**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。| 1111| ignoreNameSpace | boolean | 否 | 是否忽略命名空间，忽略命名空间后，将不会对其进行解析。true表示忽略命名空间，false表示不忽略命名空间，默认值false。 <br/>**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。| 1112| tagValueCallbackFunction | (name: string, value: string) => boolean | 否 | 解析开始标签、标签值和结束标签，默认值undefined，表示不解析。 <br/>**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。| 1113| attributeValueCallbackFunction | (name: string, value: string) => boolean | 否 | 解析属性和属性值，默认值undefined，表示不解析。 <br/>**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。| 1114| tokenValueCallbackFunction | (eventType: [EventType](#eventtype), value: [ParseInfo](#parseinfo)) => boolean | 否 | 解析元素事件类型([EventType](#eventtype))和[ParseInfo](#parseinfo)属性，默认值undefined，表示不解析。 <br/>**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。| 1115| attributeWithTagCallbackFunction<sup>20+</sup> | [AttributeWithTagCb](#attributewithtagcb20) | 否 | 解析标签名称、属性名称及属性的值，默认值为undefined，表示不执行解析。 <br/>**原子化服务API**：从API version 20开始，该接口支持在原子化服务中使用。| 1116 1117## ParseInfo 1118 1119当前XML解析信息。 1120 1121 1122### getColumnNumber 1123 1124getColumnNumber(): number 1125 1126获取当前列号，从1开始计数。 1127 1128**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1129 1130**系统能力：** SystemCapability.Utils.Lang 1131 1132**返回值：** 1133 1134| 类型 | 说明 | 1135| ------ | -------------- | 1136| number | 返回当前列号。 | 1137 1138**示例：** 1139 1140```ts 1141import { util } from '@kit.ArkTS'; 1142 1143let strXml = '<?xml version="1.0" encoding="utf-8"?><note>Happy</note>'; 1144let textEncoder = new util.TextEncoder(); 1145let arrBuffer = textEncoder.encodeInto(strXml); 1146let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer); 1147let str = ""; 1148function func(key: xml.EventType, value: xml.ParseInfo) { 1149 str += 'key:' + key + ' value:' + value.getColumnNumber() + ' '; 1150 return true; // Determines whether to continually parse, which is used to continue or terminate parsing. 1151} 1152let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func} 1153that.parseXml(options); 1154console.info(str); 1155// key:0 value:1 key:2 value:45 key:4 value:50 key:3 value:57 key:1 value:57 1156``` 1157 1158### getDepth 1159 1160getDepth(): number 1161 1162获取元素的当前深度。 1163 1164> **说明：** 1165> 1166> 标签内的空白事件深度与标签的深度保持一致。 1167 1168**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1169 1170**系统能力：** SystemCapability.Utils.Lang 1171 1172**返回值：** 1173 1174| 类型 | 说明 | 1175| ------ | -------------------- | 1176| number | 返回元素的当前深度。 | 1177 1178**示例：** 1179 1180```ts 1181import { util } from '@kit.ArkTS'; 1182 1183let strXml = 1184 '<?xml version="1.0" encoding="utf-8"?>' + 1185 '<note importance="high">' + 1186 '<title>Happy</title>' + 1187 '</note>'; 1188let textEncoder = new util.TextEncoder(); 1189let arrBuffer = textEncoder.encodeInto(strXml); 1190let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer); 1191let str = ""; 1192function func(key: xml.EventType, value: xml.ParseInfo) { 1193 str += 'key:' + key + ' value:' + value.getDepth() + ' '; 1194 return true; // Determines whether to continually parse, which is used to continue or terminate parsing. 1195} 1196let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func} 1197that.parseXml(options); 1198console.info(str); 1199// key:0 value:0 key:2 value:1 key:2 value:2 key:4 value:2 key:3 value:2 key:3 value:1 key:1 value:0 1200``` 1201 1202### getLineNumber 1203 1204getLineNumber(): number 1205 1206获取当前行号，从1开始。 1207 1208**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1209 1210**系统能力：** SystemCapability.Utils.Lang 1211 1212**返回值：** 1213 1214| 类型 | 说明 | 1215| ------ | -------------- | 1216| number | 返回当前行号。 | 1217 1218**示例：** 1219 1220```ts 1221import { util } from '@kit.ArkTS'; 1222 1223let strXml = '<?xml version="1.0" encoding="utf-8"?><note>Work</note>'; 1224let textEncoder = new util.TextEncoder(); 1225let arrBuffer = textEncoder.encodeInto(strXml); 1226let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer); 1227let str = ""; 1228function func(key: xml.EventType, value: xml.ParseInfo) { 1229 str += 'key:' + key + ' value:' + value.getLineNumber() + ' '; 1230 return true; // Determines whether to continually parse, which is used to continue or terminate parsing. 1231} 1232let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func} 1233that.parseXml(options); 1234console.info(str); 1235// key:0 value:1 key:2 value:1 key:4 value:1 key:3 value:1 key:1 value:1 1236``` 1237 1238### getName 1239 1240getName(): string 1241 1242获取当前元素名称。 1243 1244**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1245 1246**系统能力：** SystemCapability.Utils.Lang 1247 1248**返回值：** 1249 1250| 类型 | 说明 | 1251| ------ | ------------------ | 1252| string | 返回当前元素名称。 | 1253 1254**示例：** 1255 1256```ts 1257import { util } from '@kit.ArkTS'; 1258 1259let strXml = '<?xml version="1.0" encoding="utf-8"?><note>Happy</note>'; 1260let textEncoder = new util.TextEncoder(); 1261let arrBuffer = textEncoder.encodeInto(strXml); 1262let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer); 1263let str = ""; 1264function func(key: xml.EventType, value: xml.ParseInfo) { 1265 str += 'key:' + key + ' value:' + value.getName() + ' '; 1266 return true; // Determines whether to continually parse, which is used to continue or terminate parsing. 1267} 1268let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func} 1269that.parseXml(options); 1270console.info(str); 1271// key:0 value: key:2 value:note key:4 value: key:3 value:note key:1 value: 1272``` 1273### getNamespace 1274 1275getNamespace(): string 1276 1277获取当前元素的命名空间。 1278 1279**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1280 1281**系统能力：** SystemCapability.Utils.Lang 1282 1283**返回值：** 1284 1285| 类型 | 说明 | 1286| ------ | ------------------------ | 1287| string | 返回当前元素的命名空间。 | 1288 1289**示例：** 1290 1291```ts 1292import { util } from '@kit.ArkTS'; 1293 1294let strXml = 1295 '<?xml version="1.0" encoding="utf-8"?>' + 1296 '<note xmlns:h="http://www.w3.org">' + 1297 '<h:title>Happy</h:title>' + 1298 '</note>'; 1299let textEncoder = new util.TextEncoder(); 1300let arrBuffer = textEncoder.encodeInto(strXml); 1301let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer); 1302let str = ""; 1303function func(key: xml.EventType, value: xml.ParseInfo) { 1304 str += 'key:' + key + ' value:' + value.getNamespace() + ' '; 1305 return true; // Determines whether to continually parse, which is used to continue or terminate parsing. 1306} 1307let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:false, tokenValueCallbackFunction:func} 1308that.parseXml(options); 1309console.info(str); 1310// key:0 value: key:2 value: key:2 value:http://www.w3.org key:4 value: key:3 value:http://www.w3.org key:3 value: key:1 value: 1311``` 1312### getPrefix 1313 1314getPrefix(): string 1315 1316获取当前元素前缀。 1317 1318**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1319 1320**系统能力：** SystemCapability.Utils.Lang 1321 1322**返回值：** 1323 1324| 类型 | 说明 | 1325| ------ | ------------------ | 1326| string | 返回当前元素前缀。 | 1327 1328**示例：** 1329 1330```ts 1331import { util } from '@kit.ArkTS'; 1332 1333let strXml = 1334 '<?xml version="1.0" encoding="utf-8"?>' + 1335 '<note xmlns:h="http://www.w3.org/TR/html4">' + 1336 '<h:title>Happy</h:title>' + 1337 '</note>'; 1338let textEncoder = new util.TextEncoder(); 1339let arrBuffer = textEncoder.encodeInto(strXml); 1340let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer); 1341let str = ""; 1342function func(key: xml.EventType, value: xml.ParseInfo) { 1343 str += 'key:' + key + ' value:' + value.getPrefix() + ' '; 1344 return true; // Determines whether to continually parse, which is used to continue or terminate parsing. 1345} 1346let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:false, tokenValueCallbackFunction:func} 1347that.parseXml(options); 1348console.info(str); 1349// key:0 value: key:2 value: key:2 value:h key:4 value: key:3 value:h key:3 value: key:1 value: 1350``` 1351 1352### getText 1353 1354getText(): string 1355 1356获取当前事件的文本内容。 1357 1358**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1359 1360**系统能力：** SystemCapability.Utils.Lang 1361 1362**返回值：** 1363 1364| 类型 | 说明 | 1365| ------ | ------------------------ | 1366| string | 返回当前事件的文本内容。 | 1367 1368**示例：** 1369 1370```ts 1371import { util } from '@kit.ArkTS'; 1372 1373let strXml = '<?xml version="1.0" encoding="utf-8"?><note>Happy</note>'; 1374let textEncoder = new util.TextEncoder(); 1375let arrBuffer = textEncoder.encodeInto(strXml); 1376let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer); 1377let str = ""; 1378function func(key: xml.EventType, value: xml.ParseInfo) { 1379 str += 'key:' + key + ' value:' + value.getText() + ' '; 1380 return true; // Determines whether to continually parse, which is used to continue or terminate parsing. 1381} 1382let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func} 1383that.parseXml(options); 1384console.info(str); 1385// key:0 value: key:2 value: key:4 value:Happy key:3 value: key:1 value: 1386``` 1387### isEmptyElementTag 1388 1389isEmptyElementTag(): boolean 1390 1391判断当前元素是否为空元素。 1392 1393**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1394 1395**系统能力：** SystemCapability.Utils.Lang 1396 1397**返回值：** 1398 1399| 类型 | 说明 | 1400| ------- | ---------------------------- | 1401| boolean | 返回true，表示当前元素为空元素。返回false，表示当前元素为非空元素。 | 1402 1403**示例：** 1404 1405```ts 1406import { util } from '@kit.ArkTS'; 1407 1408let strXml = 1409 '<?xml version="1.0" encoding="utf-8"?>' + 1410 '<note importance="high" logged="true">' + 1411 '<title/>' + 1412 '</note>'; 1413let textEncoder = new util.TextEncoder(); 1414let arrBuffer = textEncoder.encodeInto(strXml); 1415let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer); 1416let str = ""; 1417function func(key: xml.EventType, value: xml.ParseInfo) { 1418 str += 'key:' + key + ' value:' + value.isEmptyElementTag() + ' '; 1419 return true; // Determines whether to continually parse, which is used to continue or terminate parsing. 1420} 1421let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func} 1422that.parseXml(options); 1423console.info(str); 1424// key:0 value:false key:2 value:false key:2 value:true key:3 value:false key:3 value:false key:1 value:false 1425``` 1426### isWhitespace 1427 1428isWhitespace(): boolean 1429 1430判断当前事件是否仅包含空格字符。 1431 1432**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1433 1434**系统能力：** SystemCapability.Utils.Lang 1435 1436**返回值：** 1437 1438| 类型 | 说明 | 1439| ------- | -------------------------------------- | 1440| boolean | 返回true，表示当前文本事件仅包含空格字符。 返回false，表示当前文本事件包含非空格字符。 | 1441 1442**示例：** 1443 1444```ts 1445import { util } from '@kit.ArkTS'; 1446 1447let strXml = 1448 '<?xml version="1.0" encoding="utf-8"?>' + 1449 '<note importance="high" logged="true">' + 1450 '<title> </title>' + 1451 '</note>'; 1452let textEncoder = new util.TextEncoder(); 1453let arrBuffer = textEncoder.encodeInto(strXml); 1454let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer); 1455let str = ""; 1456function func(key: xml.EventType, value: xml.ParseInfo) { 1457 str += 'key:' + key + ' value:' + value.isWhitespace() + ' '; 1458 return true; // Determines whether to continually parse, which is used to continue or terminate parsing. 1459} 1460let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func} 1461that.parseXml(options); 1462console.info(str); 1463// key:0 value:true key:2 value:false key:2 value:true key:10 value:true key:3 value:true key:3 value:true key:1 value:true 1464``` 1465### getAttributeCount 1466 1467getAttributeCount(): number 1468 1469获取当前开始标记的属性数。 1470 1471**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1472 1473**系统能力：** SystemCapability.Utils.Lang 1474 1475**返回值：** 1476| 类型 | 说明 | 1477| ------ | ---------------------- | 1478| number | 当前开始标记的属性数。 | 1479 1480**示例：** 1481 1482```ts 1483import { util } from '@kit.ArkTS'; 1484 1485let strXml = '<?xml version="1.0" encoding="utf-8"?><note importance="high" logged="true"/>'; 1486let textEncoder = new util.TextEncoder(); 1487let arrBuffer = textEncoder.encodeInto(strXml); 1488let that = new xml.XmlPullParser(arrBuffer.buffer as object as ArrayBuffer); 1489let str = ""; 1490function func(key: xml.EventType, value: xml.ParseInfo) { 1491 str += 'key:' + key + ' value:' + value.getAttributeCount() + ' '; 1492 return true; // Determines whether to continually parse, which is used to continue or terminate parsing. 1493} 1494let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func} 1495that.parseXml(options); 1496console.info(str); 1497// key:0 value:0 key:2 value:2 key:3 value:2 key:1 value:0 1498``` 1499 1500## EventType 1501 1502事件类型枚举。 1503 1504**原子化服务API**：从API version 11开始，该接口支持在原子化服务中使用。 1505 1506**系统能力：** SystemCapability.Utils.Lang 1507 1508| 名称 | 值 | 说明 | 1509| ---------------- | ---- | --------------------- | 1510| START_DOCUMENT | 0 | 启动文件事件。 | 1511| END_DOCUMENT | 1 | 结束文件事件。 | 1512| START_TAG | 2 | 启动标签事件。 | 1513| END_TAG | 3 | 结束标签事件。 | 1514| TEXT | 4 | 文本事件。 | 1515| CDSECT | 5 | CDATA事件。 | 1516| COMMENT | 6 | XML注释事件。 | 1517| DOCDECL | 7 | XML文档类型声明事件。 | 1518| INSTRUCTION | 8 | XML处理指令声明事件。 | 1519| ENTITY_REFERENCE | 9 | 实体引用事件。 | 1520| WHITESPACE | 10 | 空白事件。 |