1# @ohos.xml (XML解析与生成)
2
3本模块提供了将XML文本转换为JavaScript对象、以及XML文件生成和解析的一系列接口。
4
5> **说明:**
6>
7> 本模块首批接口从API version 8开始支持。后续版本的新增接口,采用上角标单独标记接口的起始版本。
8
9
10## 导入模块
11
12```
13import { xml } from '@kit.ArkTS';
14```
15
16## XmlSerializer
17
18XmlSerializer接口用于生成XML文件。
19
20### constructor
21
22constructor(buffer: ArrayBuffer | DataView, encoding?: string)
23
24XmlSerializer的构造函数。
25
26> **说明:**
27>
28> buffer是一个用户根据需要自定义大小的缓存区域,用于临时存储生成的XML文本。在使用过程中务必确保所设置的缓存区足够大,使其可以容纳生成文本的所有内容。
29
30**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
31
32**系统能力:** SystemCapability.Utils.Lang
33
34**参数:**
35
36| 参数名   | 类型                              | 必填 | 说明                                             |
37| -------- | --------------------------------- | ---- | ------------------------------------------------ |
38| buffer   | ArrayBuffer \| DataView | 是   | 用于接收写入XML信息的ArrayBuffer或DataView内存。 |
39| encoding | string                            | 否   | 编码格式 , 默认'utf-8'(目前仅支持'utf-8')。               |
40
41**错误码:**
42
43以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
44
45| 错误码ID | 错误信息 |
46| -------- | -------- |
47| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. |
48
49**示例:**
50
51```ts
52let arrayBuffer = new ArrayBuffer(2048);
53let thatSer = new xml.XmlSerializer(arrayBuffer, "utf-8");
54```
55
56### setAttributes
57
58setAttributes(name: string, value: string): void
59
60写入元素的属性和属性值。
61
62> **说明:**
63>
64> 该接口对所添加数据不做标准XML校验处理,请确保所添加的数据符合标准XML规范。比如不允许添加数字开头的属性名称以及添加多个同名的属性名称。
65
66**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
67
68**系统能力:** SystemCapability.Utils.Lang
69
70**参数:**
71
72| 参数名 | 类型   | 必填 | 说明            |
73| ------ | ------ | ---- | --------------- |
74| name   | string | 是   | 属性。   |
75| value  | string | 是   | 属性值。 |
76
77**错误码:**
78
79以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
80
81| 错误码ID | 错误信息 |
82| -------- | -------- |
83| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. |
84
85**示例:**
86
87```ts
88import { util } from '@kit.ArkTS';
89
90let arrayBuffer = new ArrayBuffer(2048);
91let thatSer = new xml.XmlSerializer(arrayBuffer);
92thatSer.startElement("note");
93thatSer.setAttributes("importance", "high");
94thatSer.endElement();
95let uint8 = new Uint8Array(arrayBuffer);
96let result = util.TextDecoder.create().decodeToString(uint8);
97console.log(result); // <note importance="high"/>
98```
99
100### addEmptyElement
101
102addEmptyElement(name: string): void
103
104写入一个空元素。
105
106> **说明:**
107>
108> 该接口对所添加数据不做标准XML校验处理,请确保所添加的数据符合标准XML规范。比如不允许添加数字开头的元素名称。
109
110**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
111
112**系统能力:** SystemCapability.Utils.Lang
113
114**参数:**
115
116| 参数名 | 类型   | 必填 | 说明               |
117| ------ | ------ | ---- | ------------------ |
118| name   | string | 是   | 该空元素的元素名。 |
119
120**错误码:**
121
122以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
123
124| 错误码ID | 错误信息 |
125| -------- | -------- |
126| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. |
127
128**示例:**
129
130```ts
131import { util } from '@kit.ArkTS';
132
133let arrayBuffer = new ArrayBuffer(2048);
134let thatSer = new xml.XmlSerializer(arrayBuffer);
135thatSer.addEmptyElement("d");
136let uint8 = new Uint8Array(arrayBuffer);
137let result = util.TextDecoder.create().decodeToString(uint8);
138console.log(result); // <d/>
139```
140
141### setDeclaration
142
143setDeclaration(): void
144
145编写带有编码的文件声明。
146
147**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
148
149**系统能力:** SystemCapability.Utils.Lang
150
151**示例:**
152
153```ts
154import { util } from '@kit.ArkTS';
155
156let arrayBuffer = new ArrayBuffer(2048);
157let thatSer = new xml.XmlSerializer(arrayBuffer);
158thatSer.setDeclaration();
159let uint8 = new Uint8Array(arrayBuffer);
160let result = util.TextDecoder.create().decodeToString(uint8);
161console.log(result);
162// <?xml version="1.0" encoding="utf-8"?>
163```
164
165### startElement
166
167startElement(name: string): void
168
169根据给定名称写入元素开始标记。
170
171> **说明:**
172>
173>- 调用该接口后须调用[endElement](#endelement)写入元素结束标记,以确保节点正确闭合。
174>
175>- 该接口对所添加数据不做标准XML校验处理,请确保所添加的数据符合标准XML规范。比如不允许添加数字开头的元素名称。
176
177**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
178
179**系统能力:** SystemCapability.Utils.Lang
180
181**参数:**
182
183| 参数名 | 类型   | 必填 | 说明               |
184| ------ | ------ | ---- | ------------------ |
185| name   | string | 是   | 当前元素的元素名。 |
186
187**错误码:**
188
189以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
190
191| 错误码ID | 错误信息 |
192| -------- | -------- |
193| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. |
194
195**示例:**
196
197```ts
198import { util } from '@kit.ArkTS';
199
200let arrayBuffer = new ArrayBuffer(2048);
201let thatSer = new xml.XmlSerializer(arrayBuffer);
202thatSer.startElement("note");
203thatSer.setText("Happy");
204thatSer.endElement();
205let uint8 = new Uint8Array(arrayBuffer);
206let result = util.TextDecoder.create().decodeToString(uint8);
207console.log(result);
208// <note>Happy</note>
209```
210
211### endElement
212
213endElement(): void
214
215写入元素结束标记。
216
217> **说明:**
218>
219> 调用该接口前必须先调用[startElement](#startelement)接口写入元素开始标记。
220
221**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
222
223**系统能力:** SystemCapability.Utils.Lang
224
225**示例:**
226
227```ts
228import { util } from '@kit.ArkTS';
229
230let arrayBuffer = new ArrayBuffer(2048);
231let thatSer = new xml.XmlSerializer(arrayBuffer);
232thatSer.startElement("note");
233thatSer.setText("Happy");
234thatSer.endElement();
235let uint8 = new Uint8Array(arrayBuffer);
236let result = util.TextDecoder.create().decodeToString(uint8);
237console.log(result);
238// <note>Happy</note>
239```
240
241### setNamespace
242
243setNamespace(prefix: string, namespace: string): void
244
245写入当前元素标记的命名空间。
246
247> **说明:**
248>
249> 该接口对所添加数据不做标准XML校验处理,请确保所添加的数据符合标准XML规范。比如不允许添加数字开头的前缀以及对同一个元素设置多个命名空间。
250
251**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
252
253**系统能力:** SystemCapability.Utils.Lang
254
255**参数:**
256
257| 参数名    | 类型   | 必填 | 说明                           |
258| --------- | ------ | ---- | ------------------------------ |
259| prefix    | string | 是   | 当前元素及其子元素的前缀。     |
260| namespace | string | 是   | 当前元素及其子元素的命名空间。 |
261
262**错误码:**
263
264以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
265
266| 错误码ID | 错误信息 |
267| -------- | -------- |
268| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. |
269
270**示例:**
271
272```ts
273import { util } from '@kit.ArkTS';
274
275let arrayBuffer = new ArrayBuffer(2048);
276let thatSer = new xml.XmlSerializer(arrayBuffer);
277thatSer.setNamespace("h", "http://www.w3.org/TR/html4/");
278thatSer.startElement("note");
279thatSer.endElement();
280let uint8 = new Uint8Array(arrayBuffer);
281let result = util.TextDecoder.create().decodeToString(uint8);
282console.log(result);
283// <h:note xmlns:h="http://www.w3.org/TR/html4/"/>
284```
285
286### setComment
287
288setComment(text: string): void
289
290写入注释内容。
291
292**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
293
294**系统能力:** SystemCapability.Utils.Lang
295
296**参数:**
297
298| 参数名 | 类型   | 必填 | 说明                 |
299| ------ | ------ | ---- | -------------------- |
300| text   | string | 是   | 当前元素的注释内容。 |
301
302**错误码:**
303
304以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
305
306| 错误码ID | 错误信息 |
307| -------- | -------- |
308| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. |
309
310**示例:**
311
312```ts
313import { util } from '@kit.ArkTS';
314
315let arrayBuffer = new ArrayBuffer(2048);
316let thatSer = new xml.XmlSerializer(arrayBuffer);
317thatSer.setComment("Hello, World!");
318let uint8 = new Uint8Array(arrayBuffer);
319let result = util.TextDecoder.create().decodeToString(uint8);
320console.log(result); // <!--Hello, World!-->
321```
322
323### setCDATA
324
325setCDATA(text: string): void
326
327提供在CDATA标签中添加数据的能力,所生成的CDATA标签结构为:"\<!\[CDATA\[" + 所添加的数据 + "\]\]\>"。
328
329> **说明:**
330>
331> 该接口对所添加数据不做标准XML校验处理,请确保所添加的数据符合标准XML规范。比如不允许在CDATA标签中添加包含"\]\]\>"字符串的数据。
332
333**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
334
335**系统能力:** SystemCapability.Utils.Lang
336
337**参数:**
338
339| 参数名 | 类型   | 必填 | 说明              |
340| ------ | ------ | ---- | ----------------- |
341| text   | string | 是   | CDATA属性的内容。 |
342
343**错误码:**
344
345以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
346
347| 错误码ID | 错误信息 |
348| -------- | -------- |
349| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. |
350
351**示例:**
352
353```ts
354import { util } from '@kit.ArkTS';
355
356let arrayBuffer = new ArrayBuffer(2048);
357let thatSer = new xml.XmlSerializer(arrayBuffer);
358thatSer.setCDATA('root SYSTEM')
359let uint8 = new Uint8Array(arrayBuffer);
360let result = util.TextDecoder.create().decodeToString(uint8);
361console.log(result); // <![CDATA[root SYSTEM]]>
362```
363
364### setText
365
366setText(text: string): void
367
368写入标签值。
369
370**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
371
372**系统能力:** SystemCapability.Utils.Lang
373
374**参数:**
375
376| 参数名 | 类型   | 必填 | 说明             |
377| ------ | ------ | ---- | ---------------- |
378| text   | string | 是   | text属性的内容。 |
379
380**错误码:**
381
382以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
383
384| 错误码ID | 错误信息 |
385| -------- | -------- |
386| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. |
387
388**示例:**
389
390```ts
391import { util } from '@kit.ArkTS';
392
393let arrayBuffer = new ArrayBuffer(2048);
394let thatSer = new xml.XmlSerializer(arrayBuffer);
395thatSer.startElement("note");
396thatSer.setAttributes("importance", "high");
397thatSer.setText("Happy");
398thatSer.endElement();
399let uint8 = new Uint8Array(arrayBuffer);
400let result = util.TextDecoder.create().decodeToString(uint8);
401console.log(result); // <note importance="high">Happy</note>
402```
403
404### setDocType
405
406setDocType(text: string): void
407
408写入文档类型。
409
410**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
411
412**系统能力:** SystemCapability.Utils.Lang
413
414**参数:**
415
416| 参数名 | 类型   | 必填 | 说明                |
417| ------ | ------ | ---- | ------------------- |
418| text   | string | 是   | DocType属性的内容。 |
419
420**错误码:**
421
422以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
423
424| 错误码ID | 错误信息 |
425| -------- | -------- |
426| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. |
427
428**示例:**
429
430```ts
431import { util } from '@kit.ArkTS';
432
433let arrayBuffer = new ArrayBuffer(2048);
434let thatSer = new xml.XmlSerializer(arrayBuffer);
435thatSer.setDocType('root SYSTEM "http://www.test.org/test.dtd"');
436let uint8 = new Uint8Array(arrayBuffer);
437let result = util.TextDecoder.create().decodeToString(uint8);
438console.log(result); // <!DOCTYPE root SYSTEM "http://www.test.org/test.dtd">
439```
440
441## XmlPullParser
442
443XmlPullParser接口用于解析现有的XML文件。
444
445### constructor
446
447constructor(buffer: ArrayBuffer | DataView, encoding?: string)
448
449构造并返回一个XmlPullParser对象。
450
451**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
452
453**系统能力:** SystemCapability.Utils.Lang
454
455**参数:**
456
457| 参数名   | 类型                              | 必填 | 说明                                       |
458| -------- | --------------------------------- | ---- | ------------------------------------------ |
459| buffer   | ArrayBuffer \| DataView | 是   | 需要解析的XML文本信息。 |
460| encoding | string                            | 否   | 编码格式 , 默认'utf-8'(目前仅支持'utf-8')。         |
461
462**错误码:**
463
464以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
465
466| 错误码ID | 错误信息 |
467| -------- | -------- |
468| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. |
469
470**示例:**
471
472```ts
473import { util } from '@kit.ArkTS';
474
475let strXml = '<title>Happy</title>'
476let textEncoder = new util.TextEncoder();
477let uint8Array = textEncoder.encodeInto(strXml);
478let that = new xml.XmlPullParser(uint8Array.buffer as object as ArrayBuffer, 'UTF-8');
479```
480
481### parseXml<sup>14+</sup>
482
483parseXml(option: ParseOptions): void
484
485解析XML。
486
487**原子化服务API**:从API version 14 开始,该接口支持在原子化服务中使用。
488
489**系统能力:** SystemCapability.Utils.Lang
490
491**参数:**
492
493| 参数名 | 类型                          | 必填 | 说明          |
494| ------ | ----------------------------- | ---- | ------------- |
495| option | [ParseOptions](#parseoptions) | 是   | XML解析选项。 |
496
497**错误码:**
498
499以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
500
501| 错误码ID | 错误信息 |
502| -------- | -------- |
503| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. |
504
505**示例:**
506
507```ts
508import { xml, util } from '@kit.ArkTS';
509
510let strxml =
511  '<?xml version="1.0" encoding="utf-8"?>' +
512    '<note importance="high" logged="true">' +
513    '    <title><![CDATA[测试\n测试]]></title>' +
514    '</note>';
515let textEncoder = new util.TextEncoder();
516let uint8 = textEncoder.encodeInto(strxml);
517
518function func(key: xml.EventType, value: xml.ParseInfo) {
519  if (key == xml.EventType.CDSECT) {
520    console.log(JSON.stringify(value.getText()));
521  }
522  return true;
523}
524let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func}
525let pullParser = new xml.XmlPullParser(uint8.buffer as object as ArrayBuffer);
526pullParser.parseXml(options);
527// "测试\n测试"
528```
529
530### parse<sup>(deprecated)</sup>
531
532parse(option: ParseOptions): void
533
534该接口用于解析xml。
535
536> **说明:**
537>
538> 从API version 8开始支持,从API version 14开始废弃,建议使用[parseXml<sup>14+</sup>](#parsexml14)替代。
539
540**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
541
542**系统能力:** SystemCapability.Utils.Lang
543
544**参数:**
545
546| 参数名 | 类型                          | 必填 | 说明                             |
547| ------ | ----------------------------- | ---- | -------------------------------- |
548| option | [ParseOptions](#parseoptions) | 是   | 用户控制以及获取解析信息的选项。 |
549
550**错误码:**
551
552以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。
553
554| 错误码ID | 错误信息 |
555| -------- | -------- |
556| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. |
557
558**示例:**
559
560```ts
561import { util } from '@kit.ArkTS';
562
563let strXml =
564  '<?xml version="1.0" encoding="utf-8"?>' +
565  '<note importance="high" logged="true">' +
566    '<company>John &amp; Hans</company>' +
567    '<title>Happy</title>' +
568  '</note>';
569let textEncoder = new util.TextEncoder();
570let arrbuffer = textEncoder.encodeInto(strXml);
571let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer, 'UTF-8');
572let str = '';
573function func(name: string, value: string) {
574  str = name + value;
575  console.log(str);
576  return true;
577}
578let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tagValueCallbackFunction:func}
579that.parse(options);
580// note
581// company
582// John & Hans
583// company
584// title
585// Happy
586// title
587// note
588```
589
590## ParseOptions
591
592XML解析选项。
593
594**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
595
596**系统能力:** 以下各项对应的系统能力均为SystemCapability.Utils.Lang
597
598
599| 名称                           | 类型                                                         | 必填 | 说明                                    |
600| ------------------------------ | ------------------------------------------------------------ | ---- | --------------------------------------- |
601| supportDoctype                 | boolean                                                      | 否   | 是否解析文档类型,默认false,表示不解析。 |
602| ignoreNameSpace                | boolean                                                      | 否   | 是否忽略命名空间,默认false,表示不忽略。 |
603| tagValueCallbackFunction       | (name: string, value: string) =&gt; boolean | 否   | 解析开始标签、标签值和结束标签,默认undefined,表示不解析。 |
604| attributeValueCallbackFunction | (name: string, value: string) =&gt; boolean | 否   | 解析属性和属性值,默认undefined,表示不解析。 |
605| tokenValueCallbackFunction     | (eventType: [EventType](#eventtype), value: [ParseInfo](#parseinfo)) =&gt; boolean | 否   | 解析元素事件类型([EventType](#eventtype))和[ParseInfo](#parseinfo)属性,默认undefined,表示不解析。 |
606
607## ParseInfo
608
609当前XML解析信息。
610
611
612### getColumnNumber
613
614getColumnNumber(): number
615
616获取当前列号,从1开始。
617
618**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
619
620**系统能力:** SystemCapability.Utils.Lang
621
622**返回值:**
623
624| 类型   | 说明           |
625| ------ | -------------- |
626| number | 返回当前列号。 |
627
628**示例:**
629
630```ts
631import { util } from '@kit.ArkTS';
632
633let strXml = '<?xml version="1.0" encoding="utf-8"?><note>Happy</note>';
634let textEncoder = new util.TextEncoder();
635let arrbuffer = textEncoder.encodeInto(strXml);
636let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer);
637let str = "";
638function func(key: xml.EventType, value: xml.ParseInfo) {
639  str += 'key:' + key + ' value:' + value.getColumnNumber() + ' ';
640  return true; // Determines whether to continually parse, which is used to continue or terminate parsing.
641}
642let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func}
643that.parse(options);
644console.log(str);
645// key:0 value:1 key:2 value:45 key:4 value:50 key:3 value:57 key:1 value:57
646```
647
648### getDepth
649
650getDepth(): number
651
652获取元素的当前深度。
653
654> **说明:**
655>
656> 标签内的空白事件深度与标签的深度保持一致。
657
658**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
659
660**系统能力:** SystemCapability.Utils.Lang
661
662**返回值:**
663
664| 类型   | 说明                 |
665| ------ | -------------------- |
666| number | 返回元素的当前深度。 |
667
668**示例:**
669
670```ts
671import { util } from '@kit.ArkTS';
672
673let strXml =
674  '<?xml version="1.0" encoding="utf-8"?>' +
675  '<note importance="high">' +
676    '<title>Happy</title>' +
677  '</note>';
678let textEncoder = new util.TextEncoder();
679let arrbuffer = textEncoder.encodeInto(strXml);
680let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer);
681let str = "";
682function func(key: xml.EventType, value: xml.ParseInfo) {
683  str += 'key:' + key + ' value:' + value.getDepth() + ' ';
684  return true; // Determines whether to continually parse, which is used to continue or terminate parsing.
685}
686let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func}
687that.parse(options);
688console.log(str);
689// 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
690```
691
692### getLineNumber
693
694getLineNumber(): number
695
696获取当前行号,从1开始。
697
698**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
699
700**系统能力:** SystemCapability.Utils.Lang
701
702**返回值:**
703
704| 类型   | 说明           |
705| ------ | -------------- |
706| number | 返回当前行号。 |
707
708**示例:**
709
710```ts
711import { util } from '@kit.ArkTS';
712
713let strXml = '<?xml version="1.0" encoding="utf-8"?><note>Work</note>';
714let textEncoder = new util.TextEncoder();
715let arrbuffer = textEncoder.encodeInto(strXml);
716let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer);
717let str = "";
718function func(key: xml.EventType, value: xml.ParseInfo) {
719  str += 'key:' + key + ' value:' + value.getLineNumber() + ' ';
720  return true; // Determines whether to continually parse, which is used to continue or terminate parsing.
721}
722let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func}
723that.parse(options);
724console.log(str);
725// key:0 value:1 key:2 value:1 key:4 value:1 key:3 value:1 key:1 value:1
726```
727
728### getName
729
730getName(): string
731
732获取当前元素名称。
733
734**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
735
736**系统能力:** SystemCapability.Utils.Lang
737
738**返回值:**
739
740| 类型   | 说明               |
741| ------ | ------------------ |
742| string | 返回当前元素名称。 |
743
744**示例:**
745
746```ts
747import { util } from '@kit.ArkTS';
748
749let strXml = '<?xml version="1.0" encoding="utf-8"?><note>Happy</note>';
750let textEncoder = new util.TextEncoder();
751let arrbuffer = textEncoder.encodeInto(strXml);
752let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer);
753let str = "";
754function func(key: xml.EventType, value: xml.ParseInfo) {
755  str += 'key:' + key + ' value:' + value.getName() + ' ';
756  return true; // Determines whether to continually parse, which is used to continue or terminate parsing.
757}
758let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func}
759that.parse(options);
760console.log(str);
761// key:0 value: key:2 value:note key:4 value: key:3 value:note key:1 value:
762```
763### getNamespace
764
765getNamespace(): string
766
767获取当前元素的命名空间。
768
769**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
770
771**系统能力:** SystemCapability.Utils.Lang
772
773**返回值:**
774
775| 类型   | 说明                     |
776| ------ | ------------------------ |
777| string | 返回当前元素的命名空间。 |
778
779**示例:**
780
781```ts
782import { util } from '@kit.ArkTS';
783
784let strXml =
785  '<?xml version="1.0" encoding="utf-8"?>' +
786  '<note xmlns:h="http://www.w3.org">' +
787    '<h:title>Happy</h:title>' +
788  '</note>';
789let textEncoder = new util.TextEncoder();
790let arrbuffer = textEncoder.encodeInto(strXml);
791let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer);
792let str = "";
793function func(key: xml.EventType, value: xml.ParseInfo) {
794  str += 'key:' + key + ' value:' + value.getNamespace() + ' ';
795  return true; // Determines whether to continually parse, which is used to continue or terminate parsing.
796}
797let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:false, tokenValueCallbackFunction:func}
798that.parse(options);
799console.log(str);
800// 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:
801```
802### getPrefix
803
804getPrefix(): string
805
806获取当前元素前缀。
807
808**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
809
810**系统能力:** SystemCapability.Utils.Lang
811
812**返回值:**
813
814| 类型   | 说明               |
815| ------ | ------------------ |
816| string | 返回当前元素前缀。 |
817
818**示例:**
819
820```ts
821import { util } from '@kit.ArkTS';
822
823let strXml =
824  '<?xml version="1.0" encoding="utf-8"?>' +
825  '<note xmlns:h="http://www.w3.org/TR/html4">' +
826    '<h:title>Happy</h:title>' +
827  '</note>';
828let textEncoder = new util.TextEncoder();
829let arrbuffer = textEncoder.encodeInto(strXml);
830let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer);
831let str = "";
832function func(key: xml.EventType, value: xml.ParseInfo) {
833  str += 'key:' + key + ' value:' + value.getPrefix() + ' ';
834  return true; // Determines whether to continually parse, which is used to continue or terminate parsing.
835}
836let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:false, tokenValueCallbackFunction:func}
837that.parse(options);
838console.log(str);
839// key:0 value: key:2 value: key:2 value:h key:4 value: key:3 value:h key:3 value: key:1 value:
840```
841
842### getText
843
844getText(): string
845
846获取当前事件的文本内容。
847
848**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
849
850**系统能力:** SystemCapability.Utils.Lang
851
852**返回值:**
853
854| 类型   | 说明                     |
855| ------ | ------------------------ |
856| string | 返回当前事件的文本内容。 |
857
858**示例:**
859
860```ts
861import { util } from '@kit.ArkTS';
862
863let strXml = '<?xml version="1.0" encoding="utf-8"?><note>Happy</note>';
864let textEncoder = new util.TextEncoder();
865let arrbuffer = textEncoder.encodeInto(strXml);
866let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer);
867let str = "";
868function func(key: xml.EventType, value: xml.ParseInfo) {
869  str += 'key:' + key + ' value:' + value.getText() + ' ';
870  return true; // Determines whether to continually parse, which is used to continue or terminate parsing.
871}
872let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func}
873that.parse(options);
874console.log(str);
875// key:0 value: key:2 value: key:4 value:Happy key:3 value: key:1 value:
876```
877### isEmptyElementTag
878
879isEmptyElementTag(): boolean
880
881判断当前元素是否为空元素。
882
883**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
884
885**系统能力:** SystemCapability.Utils.Lang
886
887**返回值:**
888
889| 类型    | 说明                         |
890| ------- | ---------------------------- |
891| boolean | 返回true,当前元素为空元素。 |
892
893**示例:**
894
895```ts
896import { util } from '@kit.ArkTS';
897
898let strXml =
899  '<?xml version="1.0" encoding="utf-8"?>' +
900  '<note importance="high" logged="true">' +
901    '<title/>' +
902  '</note>';
903let textEncoder = new util.TextEncoder();
904let arrbuffer = textEncoder.encodeInto(strXml);
905let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer);
906let str = "";
907function func(key: xml.EventType, value: xml.ParseInfo) {
908  str += 'key:' + key + ' value:' + value.isEmptyElementTag() + ' ';
909  return true; // Determines whether to continually parse, which is used to continue or terminate parsing.
910}
911let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func}
912that.parse(options);
913console.log(str);
914// key:0 value:false key:2 value:false key:2 value:true key:3 value:false key:3 value:false key:1 value:false
915```
916### isWhitespace
917
918isWhitespace(): boolean
919
920判断当前事件是否仅包含空格字符。
921
922**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
923
924**系统能力:** SystemCapability.Utils.Lang
925
926**返回值:**
927
928| 类型    | 说明                                   |
929| ------- | -------------------------------------- |
930| boolean | 返回true,当前文本事件仅包含空格字符。 |
931
932**示例:**
933
934```ts
935import { util } from '@kit.ArkTS';
936
937let strXml =
938  '<?xml version="1.0" encoding="utf-8"?>' +
939  '<note importance="high" logged="true">' +
940    '<title> </title>' +
941  '</note>';
942let textEncoder = new util.TextEncoder();
943let arrbuffer = textEncoder.encodeInto(strXml);
944let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer);
945let str = "";
946function func(key: xml.EventType, value: xml.ParseInfo) {
947  str += 'key:' + key + ' value:' + value.isWhitespace() + ' ';
948  return true; // Determines whether to continually parse, which is used to continue or terminate parsing.
949}
950let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func}
951that.parse(options);
952console.log(str);
953// 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
954```
955### getAttributeCount
956
957getAttributeCount(): number
958
959获取当前开始标记的属性数。
960
961**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
962
963**系统能力:** SystemCapability.Utils.Lang
964
965**返回值:**
966| 类型   | 说明                   |
967| ------ | ---------------------- |
968| number | 当前开始标记的属性数。 |
969
970**示例:**
971
972```ts
973import { util } from '@kit.ArkTS';
974
975let strXml = '<?xml version="1.0" encoding="utf-8"?><note importance="high" logged="true"/>';
976let textEncoder = new util.TextEncoder();
977let arrbuffer = textEncoder.encodeInto(strXml);
978let that = new xml.XmlPullParser(arrbuffer.buffer as object as ArrayBuffer);
979let str = "";
980function func(key: xml.EventType, value: xml.ParseInfo) {
981  str += 'key:' + key + ' value:' + value.getAttributeCount() + ' ';
982  return true; // Determines whether to continually parse, which is used to continue or terminate parsing.
983}
984let options: xml.ParseOptions = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func}
985that.parse(options);
986console.log(str);
987// key:0 value:0 key:2 value:2 key:3 value:2 key:1 value:0
988```
989
990## EventType
991
992事件类型枚举。
993
994**原子化服务API**:从API version 11 开始,该接口支持在原子化服务中使用。
995
996**系统能力:** 以下各项对应的系统能力均为SystemCapability.Utils.Lang
997
998| 名称             | 值   | 说明                  |
999| ---------------- | ---- | --------------------- |
1000| START_DOCUMENT   | 0    | 启动文件事件。        |
1001| END_DOCUMENT     | 1    | 结束文件事件。        |
1002| START_TAG        | 2    | 启动标签事件。        |
1003| END_TAG          | 3    | 结束标签事件。        |
1004| TEXT             | 4    | 文本事件。            |
1005| CDSECT           | 5    | CDATA事件。           |
1006| COMMENT          | 6    | XML注释事件。         |
1007| DOCDECL          | 7    | XML文档类型声明事件。 |
1008| INSTRUCTION      | 8    | XML处理指令声明事件。 |
1009| ENTITY_REFERENCE | 9    | 实体引用事件。        |
1010| WHITESPACE       | 10   | 空白事件。            |