1# ets_utils组件
2ets_utils组件共提供四个子模块,分别是:js_api_module、js_util_module、js_sys_module和js_concurrent_module,以下内容将详细介绍各个子模块的简介、目录、说明和涉及仓等相关内容。
3
4# 子模块
5## 1. js_api_module子模块
6### 1.1. 简介
7
8URL接口用于解析,构造,规范化和编码 URLs。 URL的构造函数创建新的URL对象。 以便对URL的已解析组成部分或对URL进行更改。URLSearchParams 接口定义了一些实用的方法来处理 URL 的查询字符串。
9
10URI表示统一资源标识符引用。
11
12xml表示指可扩展标记语言。
13
14XmlSerializer接口用于生成一个xml文件。 XmlSerializer的构造函数创建新的XmlSerializer对象,调用XmlSerializer对象的方法生成一个xml文件。XmlPullParser 接口用于解析已有的xml文件,XmlPullParser的构造函数创建新的XmlPullParser对象,调用XmlPullParser对象的方法解析xml。
15
16### 1.2. 目录
17
18```
19commonlibrary/ets_utils/js_api_module/
20├── Class:URL                                                                     # URL类
21│   ├── new URL(input[, base])                                                    # 创建URL对象
22│   ├── hash                                                                      # hash属性
23│   ├── host                                                                      # host属性
24│   ├── hostname                                                                  # hostname属性
25│   ├── href                                                                      # href属性
26│   ├── origin                                                                    # origin属性
27│   ├── password                                                                  # password属性
28│   ├── pathname                                                                  # pathname属性
29│   ├── port                                                                      # port属性
30│   ├── protocol                                                                  # protocol属性
31│   ├── search                                                                    # search属性
32│   ├── searchParams                                                              # searchParams属性
33│   ├── username                                                                  # username属性
34│   ├── toString()                                                                # toString方法
35│   └── toJSON()                                                                  # toJSON方法
36├── Class: URLSearchParams                                                        # URLSearchParams类
37│   ├── new URLSearchParams()                                                     # 创建URLSearchParams对象
38│   ├── new URLSearchParams(string)                                               # 创建URLSearchParams对象
39│   ├── new URLSearchParams(obj)                                                  # 创建URLSearchParams对象
40│   ├── new URLSearchParams(iterable)                                             # 创建URLSearchParams对象
41│   ├── append(name, value)                                                       # append方法
42│   ├── delete(name)                                                              # delete方法
43│   ├── entries()                                                                 # entries方法
44│   ├── forEach(fn[, thisArg])                                                    # forEach方法
45│   ├── get(name)                                                                 # get方法
46│   ├── getAll(name)                                                              # getAll方法
47│   ├── has(name)                                                                 # has方法
48│   ├── keys()                                                                    # keys方法
49│   ├── set(name, value)                                                          # set方法
50│   ├── sort()                                                                    # sort方法
51│   ├── toString()                                                                # toString方法
52│   ├── values()                                                                  # values方法
53│   └── urlSearchParams[Symbol.iterator]()                                        # 创建URLSearchParams对象
54├── Class:URI                                                                     # URI类
55│   ├── URI(str: string)                                                          # 创建URI对象
56│   ├── scheme                                                                    # scheme属性
57│   ├── authority                                                                 # authority属性
58│   ├── ssp                                                                       # ssp属性
59│   ├── userinfo                                                                  # userinfo属性
60│   ├── host                                                                      # host属性
61│   ├── port                                                                      # port属性
62│   ├── query                                                                     # query属性
63│   ├── fragment                                                                  # fragment属性
64│   ├── path                                                                      # path属性
65│   ├── equals(ob: Object)                                                        # equals方法
66│   ├── normalize()                                                               # normalize方法
67│   ├── checkIsAbsolute()                                                         # checkIsAbsolute方法
68│   ├── normalize()                                                               # normalize方法
69│   └── toString()                                                                # toString方法
70├── Class:ConvertXml                                                              # ConvertXml类
71│   ├── ConvertXml()                                                              # 创建ConvertXml类对象
72│   └── convert(xml: string, options: Object)                                     # convert方法
73├── Class:XmlSerializer                                                           # XmlSerializer类
74│   ├── new XmlSerializer(buffer: ArrayBuffer | DataView, encoding?: string)      # 创建XmlSerializer类对象
75│   ├── setAttributes(name: string, value: string)                                # 设置Attributes方法
76│   ├── addEmptyElement(name: string)                                             # 添加一个空元素方法
77│   ├── setDeclaration()                                                          # 设置Declaration方法
78│   ├── startElement(name: string)                                                # 设置开始元素方法
79│   ├── endElement()                                                              # 设置结束元素方法
80│   ├── setNamespace(prefix: string, namespace: string)                           # 设置命名空间方法
81│   ├── setCommnet(text: string)                                                  # 设置Commnet方法
82│   ├── setCData(text: string)                                                    # 设置CData方法
83│   ├── setText(text: string)                                                     # 设置Text方法
84│   └── setDocType(text: string)                                                  # 设置DocType方法
85├── Class: XmlPullParser                                                          # XmlPullParser类
86│   ├── new (buffer: ArrayBuffer | DataView, encoding?: string)                   # 创建XmlPullParser对象
87│   └── parse(option: ParseOptions)                                               # parse方法
88├── alloc()                                                                       # 创建Buffer实例并初始化
89├── allocUninitializedFromPool()                                                  # 在池中创建Buffer实例
90├── allocUninitialized()                                                          # 创建Buffer实例
91├── byteLength()                                                                  # 按编码返回字节数
92├── compare()                                                                     # Buffer数据比较
93├── concat()                                                                      # 粘接Buffer数组
94├── from()                                                                        # 创建Buffer实例
95├── isBuffer()                                                                    # 判断是否为Buffer
96├── isEncoding()                                                                  # 创建Buffer实例
97├── transcode()                                                                   # 转码
98├── Class: Buffer                                                                 # Buffer类
99│   ├── length                                                                    # length属性
100│   ├── buffer                                                                    # buffer属性
101│   ├── byteOffset                                                                # byteOffset属性
102│   ├── fill()                                                                    # 填充数据
103│   ├── compare()                                                                 # Buffer数据比较
104│   ├── copy()                                                                    # 复制数据
105│   ├── equals()                                                                  # 比较实例是否相等
106│   ├── includes()                                                                # 检查对象是否包含值
107│   ├── indexOf()                                                                 # 查找索引
108│   ├── keys()                                                                    # 返回包含key值的迭代器
109│   ├── values()                                                                  # 返回包含value值的迭代器
110│   ├── entries()                                                                 # 返回包含key和value的迭代器
111│   ├── lastIndexOf()                                                             # 反向查找索引
112│   ├── readBigInt64BE()                                                          # 读取有符号的大端序64位整数
113│   ├── readBigInt64LE()                                                          # 读取有符号的小端序64位整数
114│   ├── readBigUInt64BE()                                                         # 读取无符号的大端序64位整数
115│   ├── readBigUInt64LE()                                                         # 读取无符号的小端序64位整数
116│   ├── readDoubleBE()                                                            # 读取64位大端序双精度值
117│   ├── readDoubleLE()                                                            # 读取64位小端序双精度值
118│   ├── readFloatBE()                                                             # 读取32位大端序浮点数
119│   ├── readFloatLE()                                                             # 读取32位小端序浮点数
120│   ├── readInt8()                                                                # 读取有符号的8位整数
121│   ├── readInt16BE()                                                             # 读取有符号的大端序16位整数
122│   ├── readInt16LE()                                                             # 读取有符号的小端序16位整数
123│   ├── readInt32BE()                                                             # 读取有符号的大端序32位整数
124│   ├── readInt32LE()                                                             # 读取有符号的小端序32位整数
125│   ├── readIntBE()                                                               # 读取有符号的大端序整数
126│   ├── readIntLE()                                                               # 读取有符号的小端序整数
127│   ├── readUInt8()                                                               # 读取8位无符号整数
128│   ├── readUInt16BE()                                                            # 读取无符号的大端序16位整数
129│   ├── readUInt16LE()                                                            # 读取无符号的小端序16位整数
130│   ├── readUInt32BE()                                                            # 读取无符号的大端序32位整数
131│   ├── readUInt32LE()                                                            # 读取无符号的小端序32位整数
132│   ├── readUIntBE()                                                              # 读取无符号的大端序整数
133│   ├── readUIntLE()                                                              # 读取无符号的小端序整数
134│   ├── subarray()                                                                # 子Buffer
135│   ├── swap16()                                                                  # 以16位为基础交换字节顺序
136│   ├── swap32()                                                                  # 以32位为基础交换字节顺序
137│   ├── swap64()                                                                  # 以64位为基础交换字节顺序
138│   ├── toJSON()                                                                  # 转为JSON格式对象
139│   ├── toString()                                                                # 转成字符串
140│   ├── write()                                                                   # 写入字符串
141│   ├── writeBigInt64BE()                                                         # 写入有符号的大端序64位整数
142│   ├── writeBigInt64LE()                                                         # 写入有符号的小端序64位整数
143│   ├── writeBigUInt64BE()                                                        # 写入无符号的大端序64位整数
144│   ├── writeBigUInt64LE()                                                        # 写入无符号的小端序64位整数
145│   ├── writeDoubleBE()                                                           # 写入64位大端序双浮点型数据
146│   ├── writeDoubleLE()                                                           # 写入64位小端序双浮点型数据
147│   ├── writeFloatBE()                                                            # 写入32位大端序浮点型数据
148│   ├── writeFloatLE()                                                            # 写入32位小端序浮点型数据
149│   ├── writeInt8()                                                               # 写入8位有符号整数
150│   ├── writeInt16BE()                                                            # 写入有符号的大端序16位整数
151│   ├── writeInt16LE()                                                            # 写入有符号的小端序16位整数
152│   ├── writeInt32BE()                                                            # 写入有符号的大端序32位整数
153│   ├── writeInt32LE()                                                            # 写入有符号的大端序16位整数
154│   ├── writeIntBE()                                                              # 写入有符号的大端序整数
155│   ├── writeIntLE()                                                              # 写入有符号的小端序整数
156│   ├── writeUInt8()                                                              # 写入8位无符号整数
157│   ├── writeUInt16BE()                                                           # 写入无符号的大端序16位整数
158│   ├── writeUInt16LE()                                                           # 写入无符号的小端序16位整数
159│   ├── writeUInt32BE()                                                           # 写入无符号的大端序32位整数
160│   ├── writeUInt32LE()                                                           # 写入无符号的小端序32位整数
161│   ├── writeUIntBE()                                                             # 写入无符号的大端序整数
162│   └── writeUIntLE()                                                             # 写入无符号的小端序整数
163└── Class: Blob                                                                   # Blob类
164    ├── constructor()                                                             # 构造函数
165    ├── size                                                                      # size属性
166    ├── type                                                                      # type属性
167    ├── arrayBuffer()                                                             # 获取ArrayBuffer对象
168    ├── slice()                                                                   # 返回切割后的对象
169    └── text()                                                                    # 返回文本
170```
171
172### 1.3. 说明
173
174#### 1.3.1. 接口说明
175
176
177| 接口名 | 说明 |
178| -------- | -------- |
179| URL(url: string,base?:string \| URL) | 创建并返回一个URL对象,该URL对象引用使用绝对URL字符串,相对URL字符串和基本URL字符串指定的URL。 |
180| tostring():string | 该字符串化方法返回一个包含完整 URL 的 USVString。它的作用等同于只读的 URL.href。 |
181| toJSON():string | 该方法返回一个USVString,其中包含一个序列化的URL版本。 |
182| new URLSearchParams() | URLSearchParams() 构造器无入参,该方法创建并返回一个新的URLSearchParams 对象。 开头的'?' 字符会被忽略。 |
183| new URLSearchParams(string) | URLSearchParams(string) 构造器的入参为string数据类型,该方法创建并返回一个新的URLSearchParams 对象。 开头的'?' 字符会被忽略。 |
184| new URLSearchParams(obj) | URLSearchParams(obj) 构造器的入参为obj数据类型,该方法创建并返回一个新的URLSearchParams 对象。 开头的'?' 字符会被忽略。 |
185| new URLSearchParams(iterable) | URLSearchParams(iterable) 构造器的入参为iterable数据类型,该方法创建并返回一个新的URLSearchParams 对象。 开头的'?' 字符会被忽略。 |
186| has(name: string): boolean | 检索searchParams对象中是否含有name。有则返回true,否则返回false。 |
187| set(name: string, value string): void |  检索searchParams对象中是否含有key为name的键值对。没有的话则添加该键值对,有的话则修改对象中第一个key所对应的value,并删除键为name的其余键值对。 |
188| sort(): void | 根据键的Unicode代码点,对包含在此对象中的所有键/值对进行排序,并返回undefined。 |
189| toString(): string | 根据searchParams对象,返回适用在URL中的查询字符串。 |
190| keys(): iterableIterator\<string> | 返回一个iterator,遍历器允许遍历对象中包含的所有key值。 |
191| values(): iterableIterator\<string> | 返回一个iterator,遍历器允许遍历对象中包含的所有value值。 |
192| append(name: string, value: string): void | 在searchParams对象中插入name, value键值对。 |
193| delete(name: string): void | 遍历searchParams对象,查找所有的name,删除对应的键值对。 |
194| get(name: string): string | 检索searchParams对象中第一个name,返回name键对应的值。 |
195| getAll(name: string): string[] | 检索searchParams对象中所有name,返回name键对应的所有值。 |
196| entries(): iterableIterator<[string, string]> | 返回一个iterator,允许遍历searchParams对象中包含的所有键/值对。 |
197| forEach(): void | 通过回调函数来遍历URLSearchParams实例对象上的键值对。 |
198| urlSearchParams\[Symbol.iterator]() | 返回查询字符串中每个名称-值对的ES6迭代器。迭代器的每个项都是一个JavaScript数组。 |
199| URI​(str: string) | 通过解析给定入参(String str)来构造URI。此构造函数严格按照RFC 2396附录A中的语法规定解析给定字符串。 |
200| scheme​ | 返回此 URI 的scheme部分,如果scheme未定义,则返回 null |
201| authority​ | 返回此 URI 的解码authority部分,如果authority未定义,则返回 null。 |
202| ssp​ |  返回此 URI 的解码scheme-specific部分。 |
203| userinfo​ | 返回此 URI 的解码userinfo部分。包含passworld和username。 |
204| host​ | 返回此 URI 的host部分,如果host未定义,则返回 null。 |
205| port​ | 返回此 URI 的port部分,如果port未定义,则返回 -1。URI 的port组件(如果已定义)是一个非负整数。 |
206| query​ | 返回此 URI 的query部分,如果query未定义,则返回 null。 |
207| fragment​ | 返回此 URI 的解码fragment组件,如果fragment未定义,则返回 null。|
208| path​ | 返回此 URI 的解码path组件,如果path未定义,则返回 null。 |
209| equals(ob: Object) | 测试此 URI 是否与另一个对象相等。如果给定的对象不是 URI,则此方法立即返回 false。 |
210| normalize​() | 规范化这个 URI 的路径。如果这个 URI 的path不规范,将规范后构造一个新 URI对象返回。 |
211| checkIsAbsolute​() | 判断这个 URI 是否是绝对的。当且仅当它具有scheme部分时,URI 是绝对的,返回值为true,否则返回值为false。 |
212| ConvertXml() | 用于构造ConvertXml类对象的构造函数。此构造函数无需传入参数。 |
213| convert(xml: string, options: Object)  | 返回按选项要求转化xml字符串的JavaScrip对象。 |
214| XmlSerializer(buffer: ArrayBuffer \| DataView, encoding?: string) | 创建并返回一个XmlSerializer对象,该XmlSerializer对象传参两个第一参数是ArrayBuffer或DataView一段内存,第二个参数为文件格式(默认为UTF-8)。 |
215| setAttributes(name: string, value: string): void | 给xml文件中写入属性Attributes属性。 |
216| addEmptyElement(name: string): void | 写入一个空元素。 |
217| setDeclaration(): void | 设置Declaration使用编码写入xml声明。例如:<?xml version=“1.0”encoding=“utf-8”> |
218| startElement(name: string): void | 写入具有给定名称的elemnet开始标记。|
219| endElement(): void | 写入元素的结束标记。 |
220| setNamespace(prefix: string, namespace: string): void | 写入当前元素标记的命名空间。 |
221| setCommnet(text: string): void | 写入comment属性。 |
222| setCData(text: string): void | 写入CData属性。 |
223| setText(text: string): void | 写入Text属性。 |
224| setDocType(text: string): void | 写入DocType属性。 |
225| XmlPullParser(buffer: ArrayBuffer \| DataView, encoding?: string) | 创建并返回一个XmlPullParser对象,该XmlPullParser对象传参两个第一参数是ArrayBuffer或DataView一段内存,第二个参数为文件格式(默认为UTF-8)。 |
226| parse(option: ParseOptions): void | 该接口用于解析xml,ParseOptions参数为一个接口包含五个可选参{supportDoctype?: boolea ignoreNameSpace?: boolean tagValueCallbackFunction?: (name: string, value: string) => boolean attributeValueCallbackFunction?: (name: string, value: string) => boolean) tokenValueCallbackFunction?: (eventType: EventType, value: ParseInfo) => boolean }。其中tokenValueCallbackFunction回调函数的入参1是事件类型,入参2是包含getColumnNumber、getDepth等get属性的info接口,用户可通过info.getDepth()等方法来获取当前解析过程中的depth等信息。 |
227| alloc(size: number, fill?: string \| Buffer \| number, encoding?: BufferEncoding): Buffer | 创建size个字节长度的Buffer实例,并初始化。 |
228| allocUninitializedFromPool(size: number): Buffer | 创建指定大小的未被初始化Buffer实例。内存从缓冲池分配。 创建的Buffer的内容未知,需要使用fill()函数来初始化Buffer实例。 |
229| allocUninitialized(size: number): Buffer | 创建指定大小的未被初始化Buffer实例。内存不从缓冲池分配。 |
230| byteLength(string: string \| Buffer \| TypedArray \| DataView \| ArrayBuffer \| SharedArrayBuffer, encoding?: BufferEncoding): number | 根据不同的编码方法,返回字符串的字节数。 |
231| compare(buf1: Buffer \| Uint8Array, buf2: Buffer \| Uint8Array): -1 \| 0 \| 1 | 返回比较buf1和buf2的结果, 通常用于对Buffer实例的数组进行排序。 |
232| concat(list: Buffer[] \| Uint8Array[], totalLength?: number): Buffer | 将list中的实例内容复制totalLength字节长度到新的Buffer实例中并返回。 |
233| from(array: number[]): Buffer | 根据指定数组创建新的Buffer实例。 |
234| from(arrayBuffer: ArrayBuffer \| SharedArrayBuffer, byteOffset?: number, length?: number): Buffer | 创建指定长度的与arrayBuffer共享内存的Buffer实例 |
235| from(buffer: Buffer \| Uint8Array): Buffer | 创建并复制buffer数据到新的Buffer实例并返回。 |
236| from(object: Object, offsetOrEncoding: number \| string, length: number): Buffer | 根据指定的object类型数据,创建新的Buffer实例。 |
237| from(string: String, encoding?: BufferEncoding): Buffer | 根据指定编码格式的字符串,创建新的Buffer实例。 |
238| isBuffer(obj: Object): boolean | 判断obj是否为Buffer。 |
239| isEncoding(encoding: string):boolean | 判断encoding是否为支持的编码格式。 |
240| transcode(source: Buffer \| Uint8Array, fromEnc: string, toEnc: string): Buffer | 将给定的Buffer或Uint8Array实例从一种字符编码重新编码为另一种。 |
241| length: number | buffer的字节长度。 |
242| buffer: ArrayBuffer | ArrayBuffer对象。 |
243| byteOffset: number | 当前buffer所在内存池的偏移量。 |
244| fill(value: string \| Buffer \| Uint8Array \| number, offset?: number, end?: number, encoding?: BufferEncoding): Buffer | 用value填充this实例指定位置的数据,默认为循环填充,并返回填充后的Buffer实例。 |
245| compare(target: Buffer \| Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 \| 0 \| 1 | this实例对象与target实例对象进行比较,返回buf在排序中的顺序,-1:前排序,0:与buf相同,1:后排序。 |
246| copy(target: Buffer \| Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number | 将this实例中指定位置的数据复制到target的指定位置上,并返回复制的字节总长度。 |
247| equals(otherBuffer: Uint8Array \| Buffer): boolean | 比较this实例和otherBuffer实例是否相等。 |
248| includes(value: string \| number \| Buffer \| Uint8Array, byteOffset?: number, encoding?: BufferEncoding): boolean | 检查Buffer对象是否包含value值。 |
249| indexOf(value: string \| number \| Buffer \| Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number | 查找this实例中第一次出现value的索引,如果不包含value,则为-1。 |
250| keys(): IterableIterator<number> | 返回一个包含key值的迭代器。 |
251| values(): IterableIterator<number> | 返回一个包含value的迭代器。 |
252| entries(): IterableIterator<[number, number]> | 返回一个包含key和value的迭代器。 |
253| lastIndexOf(value: string | number | Buffer | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number | 返回this实例中最后一次出现value的索引,如果对象不包含,则为-1。 |
254| readBigInt64BE(offset?: number): bigint | 从指定的offset处读取有符号的大端序64位整数。 |
255| readBigInt64LE(offset?: number): bigint | 从指定的offset处读取有符号的小端序64位整数。 |
256| readBigUInt64BE(offset?: number): bigint | 从指定的offset处读取无符号的大端序64位整数。 |
257| readBigUInt64LE(offset?: number): bigint | 从指定的offset处读取无符号的小端序64位整数。 |
258| readDoubleBE(offset?: number): number | 从指定offset处读取64位大端序双精度值。 |
259| readDoubleLE(offset?: number): number | 从指定offset处读取64位小端序双精度值。 |
260| readFloatBE(offset?: number): number | 从指定offset处读取32位大端序浮点数。 |
261| readFloatLE(offset?: number): number | 从指定offset处读取32位小端序浮点数。 |
262| readInt8(offset?: number): number | 从指定的offset处读取有符号的8位整数。 |
263| readInt16BE(offset?: number): number | 从指定的offset处读取有符号的大端序16位整数。 |
264| readInt16LE(offset?: number): number | 从指定的offset处读取有符号的小端序16位整数。 |
265| readInt32BE(offset?: number): number | 从指定的offset处读取有符号的大端序32位整数。 |
266| readInt32LE(offset?: number): number | 从指定的offset处读取有符号的小端序32位整数。 |
267| readIntBE(offset: number, byteLength: number): number | 从指定的offset处的buf读取byteLength个字节,并将结果解释为支持最高48位精度的大端序、二进制补码有符号值。 |
268| readIntLE(offset: number, byteLength: number): number | 从指定的offset处的buf读取byteLength个字节,并将结果解释为支持最高48位精度的小端序、二进制补码有符号值。 |
269| readUInt8(offset?: number): number | 从offset处读取8位无符号整型数。 |
270| readUInt16BE(offset?: number): number | 从指定的`offset`处的buf读取无符号的大端序16位整数。 |
271| readUInt16LE(offset?: number): number | 从指定的`offset`处的buf读取无符号的小端序16位整数。 |
272| readUInt32BE(offset?: number): number | 从指定的`offset`处的buf读取无符号的大端序32位整数。 |
273| readUInt32LE(offset?: number): number | 从指定的`offset`处的buf读取无符号的小端序32位整数。 |
274| readUIntBE(offset: number, byteLength: number): number | 从指定的`offset`处的buf读取`byteLength`个字节,并将结果解释为支持最高48位精度的无符号大端序整数。 |
275| readUIntLE(offset: number, byteLength: number): number | 从指定的`offset`处的buf读取`byteLength`个字节,并将结果解释为支持最高48位精度的无符号小端序整数。 |
276| subarray(start?: number, end?: number): Buffer | 截取指定位置的`this`实例并返回。 |
277| swap16(): Buffer | 将`this`实例解释为无符号的16位整数数组,并就地交换字节顺序。 |
278| swap32(): Buffer | 将`this`实例解释为无符号的32位整数数组,并就地交换字节顺序。 |
279| swap64(): Buffer | 将`this`实例解释为无符号的64位整数数组,并就地交换字节顺序。 |
280| toJSON(): Object | 将buf转为JSON并返回。 |
281| toString(encoding?: string, start?: number, end?: number): string | 将`this`实例中指定位置数据转成指定编码格式字符串并返回。 |
282| write(str: string, offset?: number, length?: number, encoding?: string): number | 从buf的offset偏移写入指定编码的字符串str,写入的字节长度为length。 |
283| writeBigInt64BE(value: bigint, offset?: number): number | 从buf的offset偏移写入有符号的大端序64位BigInt型数据value。 |
284| writeBigInt64LE(value: bigint, offset?: number): number | 从buf的offset偏移写入有符号的小端序64位BigInt型数据value。 |
285| writeBigUInt64BE(value: bigint, offset?: number): number | 从buf的offset偏移写入无符号的大端序64位BigUInt型数据value。 |
286| writeBigUInt64LE(value: bigint, offset?: number): number | 从buf的offset偏移写入无符号的小端序64位BigUInt型数据value。 |
287| writeDoubleBE(value: number, offset?: number): number | 从buf的offset偏移写入大端序的64位双浮点型数据value。 |
288| writeDoubleLE(value: number, offset?: number): number | 从buf的offset偏移写入小端序的64位双浮点型数据value。 |
289| writeFloatBE(value: number, offset?: number): number | 从buf的offset偏移写入大端序的32位浮点型数据value。 |
290| writeFloatLE(value: number, offset?: number): number | 从buf的offset偏移写入小端序的32位浮点型数据value。 |
291| writeInt8(value: number, offset?: number): number | 从buf的offset偏移写入8位有符号整型数据value。 |
292| writeInt16BE(value: number, offset?: number): number | 从buf的offset偏移写入大端序的16位有符号整型数据value。 |
293| writeInt16LE(value: number, offset?: number): number | 从buf的offset偏移写入小端序的16位有符号整型数据value。 |
294| writeInt32BE(value: number, offset?: number): number | 从buf的offset偏移写入大端序的32位有符号整型数据value。 |
295| writeInt32LE(value: number, offset?: number): number | 从buf的offset偏移写入小端序的32位有符号整型数据value。 |
296| writeIntBE(value: number, offset: number, byteLength: number): number | 从buf的offset偏移写入大端序的有符号value数据,value字节长度为byteLength。 |
297| writeIntLE(value: number, offset: number, byteLength: number): number | 从buf的offset偏移写入小端序的有符号value数据,value字节长度为byteLength。 |
298| writeUInt8(value: number, offset?: number): number | 从buf的offset偏移写入8位无符号整型数据value。 |
299| writeUInt16BE(value: number, offset?: number): number | 从buf的offset偏移写入大端序的16位无符号整型数据value。 |
300| writeUInt16LE(value: number, offset?: number): number | 从buf的offset偏移写入小端序的16位无符号整型数据value。 |
301| writeUInt32BE(value: number, offset?: number): number | 从buf的offset偏移写入大端序的32位无符号整型数据value。 |
302| writeUInt32LE(value: number, offset?: number): number | 从buf的offset偏移写入小端序的32位无符号整型数据value。 |
303| writeUIntBE(value: number, offset: number, byteLength: number): number | 从buf的offset偏移写入大端序的无符号value数据,value字节长度为byteLength。 |
304| writeUIntLE(value: number, offset: number, byteLength: number): number | 从buf的offset偏移写入小端序的无符号value数据,value字节长度为byteLength。 |
305| new Blob(sources: string[] \| ArrayBuffer[] \| TypedArray[] \| DataView[] \| Blob[] , options?: Object) | Blob的构造函数,返回一个Blob的实例对象。 |
306| size | Blob实例的总字节大小。 |
307| type | Blob实例的内容类型。 |
308| arrayBuffer(): Promise&lt;ArrayBuffer&gt; | 将Blob中的数据放入到ArrayBuffer中,并返回一个Promise。 |
309| slice(start?: number, end?: number, type?: string): Blob | 创建并返回一个复制原blob对象中start到end位置数据的新blob实例对象。 |
310| text(): Promise&lt;string&gt; | 返回一个Promise,该Promise中的值为UTF8编码类型的文本。 |
311#### 1.3.2. 使用说明 |
312
313各接口使用方法如下:
314
315
3161、new URL(url: string,base?:string|URL)
317```
318let b = new URL('https://developer.mozilla.org'); // => 'https://developer.mozilla.org/'
319
320let a = new URL( 'sca/./path/path/../scasa/text', 'http://www.example.com');
321// => 'http://www.example.com/sca/path/scasa/text'
322```
3232、tostring():string
324```
325const url = new URL('http://10.0xFF.O400.235:8080/directory/file?query#fragment');
326url.toString() // => 'http://10.0xff.o400.235:8080/directory/file?query#fragment'
327
328const url = new URL("http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html");
329url.toString() // => 'http://[fedc:ba98:7654:3210:fedc:ba98:7654:3210]/index.html'
330
331const url = new URL("http://username:password@host:8080/directory/file?query#fragment");
332url.toString() // => 'http://username:password@host:8080/directory/file?query#fragment'
333```
3343、toJSON():string
335```
336const url = new URL("https://developer.mozilla.org/en-US/docs/Web/API/URL/toString");
337url.toJSON(); // =>  'https://developer.mozilla.org/en-US/docs/Web/API/URL/toString'
338```
3394、new URLSearchParams()
340```
341let params = new URLSearchParams('foo=1&bar=2');
342```
3435、new URLSearchParams(string)
344```
345params = new URLSearchParams('user=abc&query=xyz');
346console.log(params.get('user'));
347// Prints 'abc'
348```
3496、new URLSearchParams(obj)
350```
351const params = new URLSearchParams({
352    user: 'abc',
353    query: ['first', 'second']
354});
355console.log(params.getAll('query'));
356// Prints [ 'first,second' ]
357```
3587、new URLSearchParams(iterable)
359```
360let params;
361
362// Using an array
363params = new URLSearchParams([
364    ['user', 'abc'],
365    ['query', 'first'],
366    ['query', 'second'],
367]);
368console.log(params.toString());
369// Prints 'user = abc & query = first&query = second'
370```
3718、has(name: string): boolean
372```
373console.log(params.has('bar')); // =>true
374```
3759、set(name: string, value string): void
376```
377params.set('baz', 3);
378```
37910、sort(): void
380```
381params .sort();
382```
38311、toString(): string
384```
385console.log(params .toString()); // =>bar=2&baz=3&foo=1'
386```
38712、keys(): iterableIterator\<string>
388```
389for(var key of params.keys()) {
390  console.log(key);
391} // =>bar  baz  foo
392```
39313、values(): iterableIterator\<string>
394```
395for(var value of params.values()) {
396  console.log(value);
397} // =>2  3  1
398```
39914、append(name: string, value: string): void
400```
401params.append('foo', 3); // =>bar=2&baz=3&foo=1&foo=3
402```
40315、delete(name: string): void
404```
405params.delete('baz'); // => bar=2&foo=1&foo=3
406```
40716、get(name: string): string
408```
409params.get('foo'); // => 1
410```
41117、getAll(name: string): string[]
412```
413params.getAll('foo'); // =>[ '1', '3' ]
414```
41518、entries(): iterableIterator<[string, string]>
416```
417for(var pair of searchParams.entries()) {
418   console.log(pair[0]+ ', '+ pair[1]);
419} // => bar, 2   foo, 1  foo, 3
420```
42119、forEach(): void
422```
423url.searchParams.forEach((value, name, searchParams) => {
424  console.log(name, value, url.searchParams === searchParams);
425});
426// => foo 1 true
427// => bar 2 true
428```
42920、urlSearchParams[Symbol.iterator] ()
430```
431const params = new URLSearchParams('foo=bar&xyz=baz');
432for (const [name, value] of params) {
433    console.log(name, value);
434}
435// Prints:
436// foo bar
437// xyz bar
438```
439
440
44121、URI​(str: string)
442```
443let gaogao = new Uri.URI('http://gg:gaogao@www.baidu.com:99/path/path?query#fagment');
444```
44522、scheme
446```
447let gaogao = new Uri.URI('http://gg:gaogao@www.baidu.com:99/path/path?query#fagment');
448gaogao.scheme        // => "http";
449```
45023、authority
451```
452let gaogao = new Uri.URI('http://gg:gaogao@www.baidu.com:99/path/path?query#fagment');
453gaogao.authority     // => "gg:gaogao@www.baidu.com:99";
454```
45524、ssp
456```
457let gaogao = new Uri.URI('http://gg:gaogao@www.baidu.com:99/path/path?query#fagment');
458gaogao.ssp "         // => gg:gaogao@www.baidu.com:99/path/path?query";
459```
46025、userinfo
461```
462let gaogao = new Uri.URI('http://gg:gaogao@www.baidu.com:99/path/path?query#fagment');
463gaogao.userinfo      // => "gg:gaogao";
464```
46526、host
466```
467let gaogao = new Uri.URI('http://gg:gaogao@www.baidu.com:99/path/path?query#fagment');
468gaogao.host          // => "www.baidu.com";
469```
47027、port
471```
472let gaogao = new Uri.URI('http://gg:gaogao@www.baidu.com:99/path/path?query#fagment');
473gaogao.port          // => "99";
474```
47528、query
476```
477let gaogao = new Uri.URI('http://gg:gaogao@www.baidu.com:99/path/path?query#fagment');
478gaogao.query         // => "query";
479```
48029、fragment
481```
482let gaogao = new Uri.URI('http://gg:gaogao@www.baidu.com:99/path/path?query#fagment');
483gaogao.fragment      // => "fagment";
484```
48530、path
486```
487let gaogao = new Uri.URI('http://gg:gaogao@www.baidu.com:99/path/path?query#fagment');
488gaogao.path          // => "/path/path";
489```
49031、equals(ob: Object)
491```
492let gaogao = new Uri.URI('http://gg:gaogao@[1:0:0:1:2:1:2:1]:99/path1?query#fagment');
493let gaogao1 = gaogao;
494let res = gaogao.equals(gaogao1);
495console.log(res);      // => true;
496```
49732、normalize​()
498```
499let gaogao = new Uri.URI('http://gg:gaogao@[1:0:0:1:2:1:2:1]:99/path/66./../././mm/.././path1?query#fagment');
500let res = gaogao.normalize();
501console.log(res.path);        // => "/path/path1"
502console.log(res.toString());  // => "http://gg:gaogao@[1:0:0:1:2:1:2:1]:99/path/path1?query#fagment"
503```
50433、checkIsAbsolute​()
505```
506let gaogao = new Uri.URI('f/tp://username:password@www.baidu.com:88/path?query#fagment');
507let res = gaogao.checkIsAbsolute();
508console.log(res);              //=> false;
509```
51034、toString()
511```
512let gaogao = new Uri.URI('http://gg:gaogao@[1:0:0:1:2:1:2:1]:99/../../path/.././../aa/bb/cc?query#fagment');
513let res = gaogao.toString();
514console.log(res.toString());     // => 'http://gg:gaogao@[1:0:0:1:2:1:2:1]:99/../../path/.././../aa/bb/cc?query#fagment';
515```
516
517
51835、ConvertXml()
519```
520var convertml = new convertXml.ConvertXml();
521```
52236、convert(xml: string, options: Object)
523```
524var result = convertml.convert(xml, {compact: false, spaces: 4});
525```
52637、new XmlSerializer(buffer: ArrayBuffer | DataView, encoding?: string)
527```
528
529var arrayBuffer = new ArrayBuffer(1024);
530var bufView = new DataView(arrayBuffer);
531var thatSer = new xml.XmlSerializer(bufView);
532```
53338、setDeclaration():void
534```
535var thatSer = new xml.XmlSerializer(bufView);
536thatSer.setDeclaration() // => <?xml version="1.0" encoding="utf-8"?>;
537```
53839、setCommnet(text: string):void
539```
540var thatSer = new xml.XmlSerializer(bufView);
541thatSer.setCommnet("Hello, World!"); // => <!--Hello, World!-->;
542```
54340、setCData(text: string) :void
544```
545var thatSer = new xml.XmlSerializer(bufView);
546thatSer.setDocType('root SYSTEM "http://www.test.org/test.dtd"'); // => <![CDATA[root SYSTEM \“http://www.test.org/test.dtd\”]]>
547```
54841、setDocType(text: string):void
549```
550var thatSer = new xml.XmlSerializer(bufView);
551thatSer.setDocType("foo"); // => <!DOCTYPE foo>
552```
55342、setNamespace(prefix: string, namespace: string): void
55443、startElement(name: string): void
55544、setAttributes(name: string, value: string): void
55645、endElement(): void
55746、setText(text: string): void
558```
559var thatSer = new xml.XmlSerializer(bufView);
560thatSer.setNamespace("h", "http://www.w3.org/TR/html4/");
561thatSer.startElement("table");
562thatSer.setAttributes("importance", "high");
563thatSer.setText("Happy");
564endElement(); // => <h:table importance="high" xmlns:h="http://www.w3.org/TR/html4/">Happy</h:table>
565```
56647、addEmptyElement(name: string): void
567```
568var thatSer = new xml.XmlSerializer(bufView);
569thatSer.addEmptyElement("b"); // => <b/>
570```
57148、new (buffer: ArrayBuffer | DataView, encoding?: string)
572```
573var strXml =
574            '<?xml version="1.0" encoding="utf-8"?>' +
575            '<note importance="high" logged="true">' +
576            '    <title>Happy</title>' +
577            '</note>';
578var arrayBuffer = new ArrayBuffer(strXml.length*2);
579var bufView = new Uint8Array(arrayBuffer);
580var strLen = strXml.length;
581for (var i = 0; i < strLen; ++i) {
582    bufView[i] = strXml.charCodeAt(i);//设置arraybuffer 方式
583}
584var that = new xml.XmlPullParser(arrayBuffer);
585
586```
58749、parse(option: ParseOptions): void
588```
589var strXml =
590            '<?xml version="1.0" encoding="utf-8"?>' +
591            '<note importance="high" logged="true">' +
592            '    <title>Happy</title>' +
593            '</note>';
594var arrayBuffer = new ArrayBuffer(strXml.length*2);
595var bufView = new Uint8Array(arrayBuffer);
596var strLen = strXml.length;
597for (var i = 0; i < strLen; ++i) {
598    bufView[i] = strXml.charCodeAt(i);
599}
600var that = new xml.XmlPullParser(arrayBuffer);
601var arrTag = {};
602arrTag[0] = '132';
603var i = 1;
604function func(key, value){
605    arrTag[i] = 'key:'+key+' value:'+ value.getDepth();
606    i++;
607    return true;
608}
609var options = {supportDoctype:true, ignoreNameSpace:true, tokenValueCallbackFunction:func}
610that.parse(options);
611```
61250、alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer
613```
614import buffer from '@ohos.buffer';
615
616let buf1 = buffer.alloc(5);
617let buf2 = buffer.alloc(5, 'a');
618let buf3 = buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
619```
62051、allocUninitializedFromPool(size: number): Buffer
621```
622import buffer from '@ohos.buffer';
623
624let buf = buffer.allocUninitializedFromPool(10);
625buf.fill(0);
626```
62752、allocUninitialized(size: number): Buffer
628```
629import buffer from '@ohos.buffer';
630
631let buf = buffer.allocUninitialized(10);
632buf.fill(0);
633```
63453、byteLength(string: string | Buffer | TypedArray | DataView | ArrayBuffer | SharedArrayBuffer, encoding?: BufferEncoding): number
635```
636import buffer from '@ohos.buffer';
637
638let str = '\u00bd + \u00bc = \u00be';
639console.log(`${str}: ${str.length} characters, ${buffer.byteLength(str, 'utf-8')} bytes`);
640// 打印: ½ + ¼ = ¾: 9 characters, 12 bytes
641```
64254、compare(buf1: Buffer | Uint8Array, buf2: Buffer | Uint8Array): -1 | 0 | 1
643```
644import buffer from '@ohos.buffer';
645
646let buf1 = buffer.from('1234');
647let buf2 = buffer.from('0123');
648let res = buf1.compare(buf2);
649
650console.log(Number(res).toString()); // 打印 1
651```
65255、concat(list: Buffer[] | Uint8Array[], totalLength?: number): Buffer
653```
654import buffer from '@ohos.buffer';
655
656let buf1 = buffer.from("1234");
657let buf2 = buffer.from("abcd");
658let buf = buffer.concat([buf1, buf2]);
659console.log(buf.toString('hex')); // 3132333461626364
660```
66156、from(array: number[]): Buffer
662```
663import buffer from '@ohos.buffer';
664
665let buf = buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
666console.log(buf.toString('hex')); // 627566666572
667```
66857、from(arrayBuffer: ArrayBuffer | SharedArrayBuffer, byteOffset?: number, length?: number): Buffer
669```
670let ab = new ArrayBuffer(10);
671let buf = buffer.from(ab, 0, 2);
672```
67358、from(buffer: Buffer | Uint8Array): Buffer
674```
675import buffer from '@ohos.buffer';
676
677let buf1 = buffer.from('buffer');
678let buf2 = buffer.from(buf1);
679```
68059、from(object: Object, offsetOrEncoding: number | string, length: number): Buffer
681```
682import buffer from '@ohos.buffer';
683
684let buf = buffer.from(new String('this is a test'));
685```
68660、from(string: String, encoding?: BufferEncoding): Buffer
687```
688import buffer from '@ohos.buffer';
689
690let buf1 = buffer.from('this is a test');
691let buf2 = buffer.from('7468697320697320612074c3a97374', 'hex');
692
693console.log(buf1.toString());	// 打印: this is a test
694console.log(buf2.toString());
695```
69661、isBuffer(obj: Object): boolean
697```
698import buffer from '@ohos.buffer';
699
700buffer.isBuffer(buffer.alloc(10)); // true
701buffer.isBuffer(buffer.from('foo')); // true
702buffer.isBuffer('a string'); // false
703buffer.isBuffer([]); // false
704buffer.isBuffer(new Uint8Array(1024)); // false
705```
70662、isEncoding(encoding: string):boolean
707```
708import buffer from '@ohos.buffer';
709
710console.log(buffer.isEncoding('utf-8').toString());	// 打印: true
711console.log(buffer.isEncoding('hex').toString());	// 打印: true
712console.log(buffer.isEncoding('utf/8').toString());	// 打印: false
713console.log(buffer.isEncoding('').toString());	// 打印: false
714```
71563、transcode(source: Buffer | Uint8Array, fromEnc: string, toEnc: string): Buffer
716```
717import buffer from '@ohos.buffer';
718
719let buf = buffer.alloc(50);
720let newBuf = buffer.transcode(buffer.from('€'), 'utf-8', 'ascii');
721console.log(newBuf.toString('ascii'));
722```
72364、length: number
724```
725import buffer from '@ohos.buffer';
726
727let buf = buffer.from("1236");
728console.log(JSON.stringify(buf.length));
729```
73065、buffer: ArrayBuffer
731```
732import buffer from '@ohos.buffer';
733
734let buf = buffer.from("1236");
735let arrayBuffer = buf.buffer;
736console.log(JSON.stringify(new Uint8Array(arrayBuffer)));
737```
73866、byteOffset: number
739```
740import buffer from '@ohos.buffer';
741
742let buf = buffer.from("1236");
743console.log(JSON.stringify(buf.byteOffset));
744```
74567、fill(value: string | Buffer | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): Buffer
746```
747import buffer from '@ohos.buffer';
748
749let b = buffer.allocUninitializedFromPool(50).fill('h');
750console.log(b.toString());
751```
75268、compare(target: Buffer | Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 | 0 | 1
753```
754import buffer from '@ohos.buffer';
755
756let buf1 = buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]);
757let buf2 = buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]);
758
759console.log(buf1.compare(buf2, 5, 9, 0, 4).toString());	// 打印: 0
760console.log(buf1.compare(buf2, 0, 6, 4).toString());	// 打印: -1
761console.log(buf1.compare(buf2, 5, 6, 5).toString());	// 打印: 1
762```
76369、copy(target: Buffer | Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number
764```
765import buffer from '@ohos.buffer';
766
767let buf1 = buffer.allocUninitializedFromPool(26);
768let buf2 = buffer.allocUninitializedFromPool(26).fill('!');
769
770for (let i = 0; i < 26; i++) {
771  buf1[i] = i + 97;
772}
773
774buf1.copy(buf2, 8, 16, 20);
775console.log(buf2.toString('ascii', 0, 25));
776// 打印: !!!!!!!!qrst!!!!!!!!!!!!!
777```
77870、equals(otherBuffer: Uint8Array | Buffer): boolean
779```
780import buffer from '@ohos.buffer';
781
782let buf1 = buffer.from('ABC');
783let buf2 = buffer.from('414243', 'hex');
784let buf3 = buffer.from('ABCD');
785
786console.log(buf1.equals(buf2).toString());	// 打印: true
787console.log(buf1.equals(buf3).toString());	// 打印: false
788```
78971、includes(value: string | number | Buffer | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): boolean
790```
791import buffer from '@ohos.buffer';
792
793let buf = buffer.from('this is a buffer');
794console.log(buf.includes('this').toString());	// 打印: true
795console.log(buf.includes('be').toString());	// 打印: false
796```
79772、indexOf(value: string | number | Buffer | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number
798```
799import buffer from '@ohos.buffer';
800
801let buf = buffer.from('this is a buffer');
802console.log(buf.indexOf('this').toString());	// 打印: 0
803console.log(buf.indexOf('is').toString());		// 打印: 2
804```
80573、keys(): IterableIterator\<number>
806```
807import buffer from '@ohos.buffer';
808
809let buf = buffer.from('buffer');
810for (const key of buf.keys()) {
811  console.log(key.toString());
812}
813```
81474、values(): IterableIterator\<number>
815```
816import buffer from '@ohos.buffer';
817
818let buf1 = buffer.from('buffer');
819for (let value of buf1.values()) {
820  console.log(value.toString());
821}
822```
82375、entries(): IterableIterator<[number, number]>
824```
825import buffer from '@ohos.buffer';
826
827let buf = buffer.from('buffer');
828for (let pair of buf.entries()) {
829  console.log(pair.toString());
830}
831```
83276、lastIndexOf(value: string | number | Buffer | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number
833```
834import buffer from '@ohos.buffer';
835
836let buf = buffer.from('this buffer is a buffer');
837console.log(buf.lastIndexOf('this').toString());	// 打印: 0
838console.log(buf.lastIndexOf('buffer').toString());	// 打印: 17
839```
84077、readBigInt64BE(offset?: number): bigint
841```
842import buffer from '@ohos.buffer';
843
844let buf = buffer.from([0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70,
845        0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78]);
846console.log(buf.readBigInt64BE(0).toString());
847
848let buf1 = buffer.allocUninitializedFromPool(8);
849buf1.writeBigInt64BE(0x0102030405060708n, 0);
850```
85178、readBigInt64LE(offset?: number): bigint
852```
853import buffer from '@ohos.buffer';
854
855let buf = buffer.from([0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70,
856        0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78]);
857console.log(buf.readBigInt64LE(0).toString());
858
859let buf1 = buffer.allocUninitializedFromPool(8);
860buf1.writeBigInt64BE(0x0102030405060708n, 0);
861```
86279、readBigUInt64BE(offset?: number): bigint
863```
864import buffer from '@ohos.buffer';
865
866let buf = buffer.from([0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70,
867        0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78]);
868console.log(buf.readBigUInt64BE(0).toString());
869
870let buf1 = buffer.allocUninitializedFromPool(8);
871buf1.writeBigUInt64BE(0xdecafafecacefaden, 0);
872```
87380、readBigUInt64LE(offset?: number): bigint
874```
875import buffer from '@ohos.buffer';
876
877let buf = buffer.from([0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70,
878        0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78]);
879console.log(buf.readBigUInt64LE(0).toString());
880
881let buf1 = buffer.allocUninitializedFromPool(8);
882buf1.writeBigUInt64BE(0xdecafafecacefaden, 0);
883```
88481、readDoubleBE(offset?: number): number
885```
886import buffer from '@ohos.buffer';
887
888let buf = buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
889console.log(buf.readDoubleBE(0).toString());
890
891let buf1 = buffer.allocUninitializedFromPool(8);
892buf1.writeDoubleBE(123.456, 0);
893```
89482、readDoubleLE(offset?: number): number
895```
896import buffer from '@ohos.buffer';
897
898let buf = buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
899console.log(buf.readDoubleLE(0).toString());
900
901let buf1 = buffer.allocUninitializedFromPool(8);
902buf1.writeDoubleLE(123.456, 0);
903```
90483、readFloatBE(offset?: number): number
905```
906import buffer from '@ohos.buffer';
907
908let buf = buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
909console.log(buf.readFloatBE(0).toString());
910
911let buf1 = buffer.allocUninitializedFromPool(4);
912buf1.writeFloatBE(0xcabcbcbc, 0);
913```
91484、readFloatLE(offset?: number): number
915```
916import buffer from '@ohos.buffer';
917
918let buf = buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
919console.log(buf.readFloatLE(0).toString());
920
921let buf1 = buffer.allocUninitializedFromPool(4);
922buf1.writeFloatLE(0xcabcbcbc, 0);
923```
92485、readInt8(offset?: number): number
925```
926import buffer from '@ohos.buffer';
927
928let buf = buffer.from([-1, 5]);
929console.log(buf.readInt8(0).toString());	// 打印: -1
930console.log(buf.readInt8(1).toString());	// 打印: 5
931
932let buf1 = buffer.allocUninitializedFromPool(2);
933buf1.writeInt8(0x12);
934```
93586、readInt16BE(offset?: number): number
936```
937import buffer from '@ohos.buffer';
938
939let buf = buffer.from([0, 5]);
940console.log(buf.readInt16BE(0).toString());	// 打印: 5
941
942let buf1 = buffer.alloc(2);
943buf1.writeInt16BE(0x1234, 0);
944```
94587、readInt16LE(offset?: number): number
946```
947import buffer from '@ohos.buffer';
948
949let buf = buffer.from([0, 5]);
950console.log(buf.readInt16LE(0).toString());	// 打印: 1280
951
952let buf1 = buffer.alloc(2);
953buf1.writeInt16BE(0x1234, 0);
954```
95588、readInt32BE(offset?: number): number
956```
957import buffer from '@ohos.buffer';
958
959let buf = buffer.from([0, 0, 0, 5]);
960console.log(buf.readInt32BE(0).toString());	// 打印: 5
961
962let buf1 = buffer.alloc(4);
963buf1.writeInt32BE(0x12345678, 0);
964```
96589、readInt32LE(offset?: number): number
966```
967import buffer from '@ohos.buffer';
968
969let buf = buffer.from([0, 0, 0, 5]);
970console.log(buf.readInt32LE(0).toString());	// 打印: 83886080
971
972let buf1 = buffer.alloc(4);
973buf1.writeInt32BE(0x12345678, 0);
974```
97590、readIntBE(offset: number, byteLength: number): number
976```
977import buffer from '@ohos.buffer';
978
979let buf = buffer.from("ab");
980let num = buf.readIntBE(0, 1);
981console.log(num.toString()); // 97
982
983let buf1 = buffer.allocUninitializedFromPool(6);
984buf1.writeIntBE(0x123456789011, 0, 6);
985```
98691、readIntLE(offset: number, byteLength: number): number
987```
988import buffer from '@ohos.buffer';
989
990let buf = buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
991console.log(buf.readIntLE(0, 6).toString(16));
992
993let buf1 = buffer.allocUninitializedFromPool(6);
994buf1.writeIntLE(0x123456789011, 0, 6);
995```
99692、readUInt8(offset?: number): number
997```
998import buffer from '@ohos.buffer';
999
1000let buf = buffer.from([1, -2]);
1001console.log(buf.readUInt8(0).toString());
1002console.log(buf.readUInt8(1).toString());
1003
1004let buf1 = buffer.allocUninitializedFromPool(4);
1005buf1.writeUInt8(0x42);
1006```
100793、readUInt16BE(offset?: number): number
1008```
1009import buffer from '@ohos.buffer';
1010let buf = buffer.from([0x12, 0x34, 0x56]);
1011console.log(buf.readUInt16BE(0).toString(16));
1012console.log(buf.readUInt16BE(1).toString(16));
1013```
101494、readUInt16LE(offset?: number): number
1015```
1016import buffer from '@ohos.buffer';
1017let buf = buffer.from([0x12, 0x34, 0x56]);
1018console.log(buf.readUInt16LE(0).toString(16));
1019console.log(buf.readUInt16LE(1).toString(16));
1020```
102195、readUInt32BE(offset?: number): number
1022```
1023import buffer from '@ohos.buffer';
1024let buf = buffer.from([0x12, 0x34, 0x56, 0x78]);
1025console.log(buf.readUInt32BE(0).toString(16));
1026```
102796、readUInt32LE(offset?: number): number
1028```
1029import buffer from '@ohos.buffer';
1030let buf = buffer.from([0x12, 0x34, 0x56, 0x78]);
1031console.log(buf.readUInt32LE(0).toString(16));
1032```
103397、readUIntBE(offset: number, byteLength: number): number
1034```
1035import buffer from '@ohos.buffer';
1036let buf = buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
1037console.log(buf.readUIntBE(0, 6).toString(16));
1038```
103998、readUIntLE(offset: number, byteLength: number): number
1040```
1041import buffer from '@ohos.buffer';
1042let buf = buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
1043console.log(buf.readUIntLE(0, 6).toString(16));
1044```
104599、subarray(start?: number, end?: number): Buffer
1046```
1047import buffer from '@ohos.buffer';
1048let buf1 = buffer.allocUninitializedFromPool(26);
1049for (let i = 0; i < 26; i++) {
1050  buf1[i] = i + 97;
1051}
1052const buf2 = buf1.subarray(0, 3);
1053console.log(buf2.toString('ascii', 0, buf2.length));
1054```
1055100、swap16(): Buffer
1056```
1057import buffer from '@ohos.buffer';
1058let buf1 = buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
1059console.log(buf1.toString('hex'));
1060buf1.swap16();
1061console.log(buf1.toString('hex'));
1062```
1063101、swap32(): Buffer
1064```
1065import buffer from '@ohos.buffer';
1066let buf1 = buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
1067console.log(buf1.toString('hex'));
1068buf1.swap32();
1069console.log(buf1.toString('hex'));
1070```
1071102、swap64(): Buffer
1072```
1073import buffer from '@ohos.buffer';
1074let buf1 = buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
1075console.log(buf1.toString('hex'));
1076buf1.swap64();
1077console.log(buf1.toString('hex'));
1078```
1079103、toJSON(): Object
1080```
1081import buffer from '@ohos.buffer';
1082let buf1 = buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
1083let obj = buf1.toJSON();
1084console.log(JSON.stringify(obj))
1085```
1086104、toString(encoding?: string, start?: number, end?: number): string
1087```
1088import buffer from '@ohos.buffer';
1089let buf1 = buffer.allocUninitializedFromPool(26);
1090for (let i = 0; i < 26; i++) {
1091  buf1[i] = i + 97;
1092}
1093console.log(buf1.toString('utf-8'));
1094```
1095105、write(str: string, offset?: number, length?: number, encoding?: string): number
1096```
1097import buffer from '@ohos.buffer';
1098let buf = buffer.alloc(256);
1099let len = buf.write('\u00bd + \u00bc = \u00be', 0);
1100console.log(`${len} bytes: ${buf.toString('utf-8', 0, len)}`);
1101let buffer1 = buffer.alloc(10);
1102let length = buffer1.write('abcd', 8);
1103```
1104106、writeBigInt64BE(value: bigint, offset?: number): number
1105```
1106import buffer from '@ohos.buffer';
1107let buf = buffer.allocUninitializedFromPool(8);
1108buf.writeBigInt64BE(0x0102030405060708n, 0);
1109```
1110107、writeBigInt64LE(value: bigint, offset?: number): number
1111```
1112import buffer from '@ohos.buffer';
1113let buf = buffer.allocUninitializedFromPool(8);
1114buf.writeBigInt64LE(0x0102030405060708n, 0);
1115```
1116108、writeBigUInt64BE(value: bigint, offset?: number): number
1117```
1118import buffer from '@ohos.buffer';
1119let buf = buffer.allocUninitializedFromPool(8);
1120buf.writeBigUInt64BE(0xdecafafecacefaden, 0);
1121```
1122109、writeBigUInt64LE(value: bigint, offset?: number): number
1123```
1124import buffer from '@ohos.buffer';
1125let buf = buffer.allocUninitializedFromPool(8);
1126buf.writeBigUInt64LE(0xdecafafecacefaden, 0);
1127```
1128110、writeDoubleBE(value: number, offset?: number): number
1129```
1130import buffer from '@ohos.buffer';
1131let buf = buffer.allocUninitializedFromPool(8);
1132buf.writeDoubleBE(123.456, 0);
1133```
1134111、writeDoubleLE(value: number, offset?: number): number
1135```
1136import buffer from '@ohos.buffer';
1137let buf = buffer.allocUninitializedFromPool(8);
1138buf.writeDoubleLE(123.456, 0);
1139```
1140112、writeFloatBE(value: number, offset?: number): number
1141```
1142import buffer from '@ohos.buffer';
1143let buf = buffer.allocUninitializedFromPool(8);
1144buf.writeFloatBE(0xcafebabe, 0);
1145```
1146113、writeFloatLE(value: number, offset?: number): number
1147```
1148import buffer from '@ohos.buffer';
1149let buf = buffer.allocUninitializedFromPool(8);
1150buf.writeFloatLE(0xcafebabe, 0);
1151```
1152114、writeInt8(value: number, offset?: number): number
1153```
1154import buffer from '@ohos.buffer';
1155let buf = buffer.allocUninitializedFromPool(2);
1156buf.writeInt8(2, 0);
1157buf.writeInt8(-2, 1);
1158```
1159115、writeInt16BE(value: number, offset?: number): number
1160```
1161import buffer from '@ohos.buffer';
1162let buf = buffer.allocUninitializedFromPool(2);
1163buf.writeInt16BE(0x0102, 0);
1164```
1165116、writeInt16LE(value: number, offset?: number): number
1166```
1167import buffer from '@ohos.buffer';
1168let buf = buffer.allocUninitializedFromPool(2);
1169buf.writeInt16LE(0x0304, 0);
1170```
1171117、writeInt32BE(value: number, offset?: number): number
1172```
1173import buffer from '@ohos.buffer';
1174let buf = buffer.allocUninitializedFromPool(4);
1175buf.writeInt32BE(0x01020304, 0);
1176```
1177118、writeInt32LE(value: number, offset?: number): number
1178```
1179import buffer from '@ohos.buffer';
1180let buf = buffer.allocUninitializedFromPool(4);
1181buf.writeInt32LE(0x05060708, 0);
1182```
1183119、writeIntBE(value: number, offset: number, byteLength: number): number
1184```
1185import buffer from '@ohos.buffer';
1186let buf = buffer.allocUninitializedFromPool(6);
1187buf.writeIntBE(0x1234567890ab, 0, 6);
1188```
1189120、writeIntLE(value: number, offset: number, byteLength: number): number
1190```
1191import buffer from '@ohos.buffer';
1192let buf = buffer.allocUninitializedFromPool(6);
1193buf.writeIntLE(0x1234567890ab, 0, 6);
1194```
1195121、writeUInt8(value: number, offset?: number): number
1196```
1197import buffer from '@ohos.buffer';
1198let buf = buffer.allocUninitializedFromPool(4);
1199buf.writeUInt8(0x3, 0);
1200buf.writeUInt8(0x4, 1);
1201buf.writeUInt8(0x23, 2);
1202buf.writeUInt8(0x42, 3);
1203```
1204122、writeUInt16BE(value: number, offset?: number): number
1205```
1206import buffer from '@ohos.buffer';
1207let buf = buffer.allocUninitializedFromPool(4);
1208buf.writeUInt16BE(0xdead, 0);
1209buf.writeUInt16BE(0xbeef, 2);
1210```
1211123、writeUInt16LE(value: number, offset?: number): number
1212```
1213import buffer from '@ohos.buffer';
1214let buf = buffer.allocUninitializedFromPool(4);
1215buf.writeUInt16LE(0xdead, 0);
1216buf.writeUInt16LE(0xbeef, 2);
1217```
1218124、writeUInt32BE(value: number, offset?: number): number
1219```
1220import buffer from '@ohos.buffer';
1221let buf = buffer.allocUninitializedFromPool(4);
1222buf.writeUInt32BE(0xfeedface, 0);
1223```
1224125、writeUInt32LE(value: number, offset?: number): number
1225```
1226import buffer from '@ohos.buffer';
1227let buf = buffer.allocUninitializedFromPool(4);
1228buf.writeUInt32LE(0xfeedface, 0);
1229```
1230126、writeUIntBE(value: number, offset: number, byteLength: number): number
1231```
1232import buffer from '@ohos.buffer';
1233let buf = buffer.allocUninitializedFromPool(6);
1234buf.writeUIntBE(0x1234567890ab, 0, 6);
1235```
1236127、writeUIntLE(value: number, offset: number, byteLength: number): number
1237```
1238import buffer from '@ohos.buffer';
1239let buf = buffer.allocUninitializedFromPool(6);
1240buf.writeUIntLE(0x1234567890ab, 0, 6);
1241```
1242128、new Blob(sources: string[] | ArrayBuffer[] | TypedArray[] | DataView[] | Blob[] , options?: Object)
1243```
1244import buffer from '@ohos.buffer';
1245let blob = new buffer.Blob(['a', 'b', 'c']);
1246let blob1 = new buffer.Blob(['a', 'b', 'c'], {endings:'native', type: 'MIME'});
1247```
1248129、size
1249```
1250import buffer from '@ohos.buffer';
1251let blob = new buffer.Blob(['a', 'b', 'c']);
1252blob.size
1253```
1254130、type
1255```
1256import buffer from '@ohos.buffer';
1257let blob = new buffer.Blob(['a', 'b', 'c'], {endings:'native', type: 'MIME'});
1258blob.type
1259```
1260131、arrayBuffer(): Promise&lt;ArrayBuffer&gt;
1261```
1262let blob = new buffer.Blob(['a', 'b', 'c']);
1263let pro = blob.arrayBuffer();
1264pro.then(val => {
1265  let uintarr = new Uint8Array(val);
1266  console.log(uintarr.toString());
1267});
1268```
1269132、slice(start?: number, end?: number, type?: string): Blob
1270```
1271let blob = new buffer.Blob(['a', 'b', 'c']);
1272let blob2 = blob.slice(0, 2);
1273let blob3 = blob.slice(0, 2, "MIME");
1274```
1275133、text(): Promise&lt;string&gt;
1276```
1277let blob = new buffer.Blob(['a', 'b', 'c']);
1278let pro = blob.text();
1279pro.then(val => {
1280    console.log(val)
1281});
1282```
1283
1284## 2. js_util_module子模块
1285### 2.1. 简介
1286
1287UTIL接口用于字符编码TextEncoder、解码TextDecoder、帮助函数HelpFunction、基于Base64的字节编码encode和解码decode、有理数RationalNumber。TextEncoder表示一个文本编码器,接受字符串作为输入,以UTF-8格式进行编码,输出UTF-8字节流。TextDecoder接口表示一个文本解码器,解码器将字节流作为输入,输出stirng字符串。HelpFunction主要是对函数做callback化、promise化以及对错误码进行编写输出,及类字符串的格式化输出。encode接口使用Base64编码方案将指定u8数组中的所有字节编码到新分配的u8数组中或者使用Base64编码方案将指定的字节数组编码为String。decode接口使用Base64编码方案将Base64编码的字符串或输入u8数组解码为新分配的u8数组。RationalNumber有理数主要是对有理数进行比较,获取分子分母等方法。LruBuffer该算法在缓存空间不够的时候,将近期最少使用的数据替换为新数据。该算法源自这样一种访问资源的需求:近期访问的数据,可能在不久的将来会再次访问。于是最少访问的数据就是价值最小的,是最应该踢出缓存空间的数据。Scope接口用于描述一个字段的有效范围。 Scope实例的构造函数用于创建具有指定下限和上限的对象,并要求这些对象必须具有可比性。
1288### 2.2. 目录
1289
1290```
1291commomlibrary/ets_utils/js_util_module/
1292├── Class:TextEncoder                   # TextEncoder类
1293│   ├──  new TextEncoder()              # 创建TextEncoder对象
1294│   ├──  encode()                       # encode方法
1295│   ├──  encoding                       # encoding属性
1296│   └──  encodeInto()                   # encodeInto方法
1297├── Class:TextDecoder                   # TextDecoder类
1298│   ├──  new TextDecoder()              # 创建TextDecoder对象
1299│   ├──  decode()                       # decode方法
1300|   ├──  decodeWithStream()             # decodeWithStream方法
1301│   ├──  encoding                       # encoding属性
1302│   ├──  fatal                          # fatal属性
1303│   └──  ignoreBOM                      # ignoreBOM属性
1304├── printf()                            # printf方法
1305├── getErrorString()                    # getErrorString方法
1306├── callbackWrapper()                   # callbackWrapper方法
1307├── promiseWrapper()                    # promiseWrapper方法
1308├── Class:Base64                        # Base64类
1309│   ├──  new Base64()                   # 创建Base64对象
1310│   ├──  encodeSync()                   # encodeSync方法
1311│   ├──  encodeToStringSync()           # encodeToStringSync方法
1312│   ├──  decodeSync()                   # decodeSync方法
1313│   ├──  encode()                       # encode方法
1314│   ├──  encodeToString()               # encodeToString方法
1315│   └──  decode()                       # decode方法
1316├── Class:RationalNumber                # RationalNumber类
1317│   ├──  new RationalNumber()           # 创建RationalNumber对象
1318│   ├──  createRationalFromString()     # createRationalFromString方法
1319│   ├──  compareTo()                    # compareTo方法
1320│   ├──  equals()                       # equals方法
1321│   ├──  valueOf()                      # valueOf方法
1322│   ├──  getCommonDivisor()             # getCommonDivisor方法
1323│   ├──  getDenominator()               # getDenominator方法
1324│   ├──  getNumerator()                 # getNumerator方法
1325│   ├──  isFinite()                     # isFinite方法
1326│   ├──  isNaN()                        # isNaN方法
1327│   ├──  isZero()                       # isZero方法
1328│   └──  toString()                     # toString方法
1329├── Class:LruBuffer                     # LruBuffer类
1330│   ├──  new LruBuffer()                # 创建LruBuffer对象
1331│   ├──  updateCapacity()               # updateCapacity方法
1332│   ├──  toString()                     # toString方法
1333│   ├──  values()                       # values方法
1334│   ├──  length                         # length属性
1335│   ├──  getCapacity()                  # getCapacity方法
1336│   ├──  clear()                        # clear方法
1337│   ├──  getCreateCount()               # getCreateCount方法
1338│   ├──  getMissCount()                 # getMissCount方法
1339│   ├──  getRemovalCount()              # getRemovalCount方法
1340│   ├──  getMatchCount()                # getMatchCount方法
1341│   ├──  getPutCount()                  # getPutCount方法
1342│   ├──  isEmpty()                      # isEmpty方法
1343│   ├──  get()                          # get方法
1344│   ├──  put()                          # put方法
1345│   ├──  keys()                         # keys方法
1346│   ├──  remove()                       # remove方法
1347│   ├──  afterRemoval()                 # afterRemoval方法
1348│   ├──  contains()                     # contains方法
1349│   ├──  createDefault()                # createDefault方法
1350│   ├──  entries()                      # entries方法
1351│   └──  [Symbol.iterator]()            # Symboliterator方法
1352|—— Class:Scope                         # Scope类
1353|   ├── constructor()                   # 创建Scope对象
1354|   ├── toString()                      # toString方法
1355|   ├── intersect()                     # intersect方法
1356|   ├── intersect()                     # intersect方法
1357|   ├── getUpper()                      # getUpper方法
1358|   ├── getLower()                      # getLower方法
1359|   ├── expand()                        # expand方法
1360|   ├── expand()                        # expand方法
1361|   ├── expand()                        # expand法
1362|   ├── contains()                      # contains方法
1363|   ├── contains()                      # contains方法
1364|   └── clamp()                         # clamp方法
1365|—— Class:Types                         # Types类
1366|   ├── isAnyArrayBuffer()              # isAnyArrayBuffer方法
1367|   ├── isArrayBufferView()             # isArrayBufferView方法
1368|   ├── isArgumentsObject()             # isArgumentsObject方法
1369|   ├── isArrayBuffer()                 # isArrayBuffer方法
1370|   ├── isAsyncFunction()               # isAsyncFunction方法
1371|   ├── isBigInt64Array()               # isBigInt64Array方法
1372|   ├── isBigUint64Array()              # isBigUint64Array方法
1373|   ├── isBooleanObject()               # isBooleanObject方法
1374|   ├── isBoxedPrimitive()              # isBoxedPrimitive方法
1375|   ├── isDataView()                    # isDataView方法
1376|   ├── isDate()                        # isDate方法
1377|   ├── isExternal()                    # isExternal方法
1378|   ├── isFloat32Array()                # isFloat32Array方法
1379|   ├── isFloat64Array()                # isFloat64Array方法
1380|   ├── isGeneratorFunction()           # isGeneratorFunction方法
1381|   ├── isGeneratorObject()             # isGeneratorObject方法
1382|   ├── isInt8Array()                   # isInt8Array方法
1383|   ├── isInt16Array()                  # isInt16Array方法
1384|   ├── isInt32Array()                  # isInt32Array方法
1385|   ├── isMap()                         # isMap方法
1386|   ├── isMapIterator()                 # isMapIterator方法
1387|   ├── isModuleNamespaceObject()       # isModuleNamespaceObject方法
1388|   ├── isNativeError()                 # isNativeError方法
1389|   ├── isNumberObject()                # isNumberObject方法
1390|   ├── isPromise()                     # isPromise方法
1391|   ├── isProxy()                       # isProxy方法
1392|   ├── isRegExp()                      # isRegExp方法
1393|   ├── isSet()                         # isSet方法
1394|   ├── isSetIterator()                 # isSetIterator方法
1395|   ├── isSharedArrayBuffer()           # isSharedArrayBuffer方法
1396|   ├── isStringObject()                # isStringObject方法
1397|   ├── isSymbolObject()                # isSymbolObject方法
1398|   ├── isTypedArray()                  # isTypedArray方法
1399|   ├── isUint8Array()                  # isUint8Array方法
1400|   ├── isUint8ClampedArray()           # isUint8ClampedArray方法
1401|   ├── isUint16Array()                 # isUint16Array方法
1402|   ├── isUint32Array()                 # isUint32Array方法
1403|   ├── isWeakMap()                     # isWeakMap方法
1404|   └── isWeakSet()                     # isWeakSet方法
1405|—— Class:ArrayList
1406|   ├── new ArrayList()                 # 创建ArrayList对象
1407|   ├── length                          # length属性
1408|   ├── add()                           # add方法
1409|   ├── insert()                        # insert方法
1410|   ├── has()                           # has方法
1411|   ├── getIndexOf()                    # getIndexOf方法
1412|   ├── removeByIndex()                 # removeByIndex方法
1413|   ├── remove()                        # remove方法
1414|   ├── getLastIndexOf()                # getLastIndexOf方法
1415|   ├── removeByRange()                 # removeByRange方法
1416|   ├── replaceAllElements()            # replaceAllElements方法
1417|   ├── forEach()                       # forEach方法
1418|   ├── sort()                          # sort方法
1419|   ├── subArrayList()                  # subArrayList方法
1420|   ├── clear()                         # clear方法
1421|   ├── clone()                         # clone方法
1422|   ├── getCapacity()                   # getCapacity方法
1423|   ├── convertToArray()                # convertToArray方法
1424|   ├── isEmpty()                       # isEmpty方法
1425|   ├── increaseCapacityTo()            # increaseCapacityTo方法
1426|   ├── trimToCurrentLength()           # trimToCurrentLength方法
1427|   └── isEmpty()                       # isEmpty方法
1428|—— Class:Deque
1429|   ├── new Deque()                     # 创建Deque对象
1430|   ├── length                          # length属性
1431|   ├── add()                           # add方法
1432|   ├── insertFront()                   # insertFront方法
1433|   ├── insertEnd()                     # insertEnd方法
1434|   ├── has()                           # has方法
1435|   ├── getFirst()                      # getFirst方法
1436|   ├── getLast()                       # getLast方法
1437|   ├── popFirst()                      # popFirst方法
1438|   ├── popLast()                       # popLast方法
1439|   └── forEach()                       # forEach方法
1440|—— Class:HashMap
1441|   ├── new HashMap()                   # 创建HashMap对象
1442|   ├── length                          # length属性
1443|   ├── isEmpty()                       # isEmpty方法
1444|   ├── hasKey()                        # hasKey方法
1445|   ├── hasValue()                      # hasValue方法
1446|   ├── setAll()                        # setAll方法
1447|   ├── set()                           # set方法
1448|   ├── remove()                        # remove方法
1449|   ├── clear()                         # clear方法
1450|   ├── keys()                          # keys方法
1451|   ├── values()                        # values方法
1452|   ├── replace()                       # replace方法
1453|   ├── forEach()                       # forEach方法
1454|   └── entries()                       # entries方法
1455|—— Class:HashSet
1456|   ├── new HashSet()                   # 创建HashSet对象
1457|   ├── length                          # length属性
1458|   ├── isEmpty()                       # isEmpty方法
1459|   ├── has()                           # has方法
1460|   ├── add()                           # add方法
1461|   ├── remove()                        # remove方法
1462|   ├── clear()                         # clear方法
1463|   ├── forEach()                       # forEach方法
1464|   ├── values()                        # values方法
1465|   └── entries()                       # entries方法
1466|—— Class:LightWeightMap
1467|   ├── new LightWeightMap()            # 创建LightWeightMap对象
1468|   ├── length                          # length属性
1469|   ├── hasAll()                        # hasAll方法
1470|   ├── hasKey()                        # hasKey方法
1471|   ├── hasValue()                      # hasValue方法
1472|   ├── increaseCapacityTo()            # increaseCapacityTo方法
1473|   ├── entries()                       # entries方法
1474|   ├── get()                           # get方法
1475|   ├── getIndexOfKey()                 # getIndexOfKey方法
1476|   ├── getIndexOfValue()               # getIndexOfValue方法
1477|   ├── isEmpty()                       # isEmpty方法
1478|   ├── getKeyAt()                      # getKeyAt方法
1479|   ├── keys()                          # keys方法
1480|   ├── setAll()                        # setAll方法
1481|   ├── set()                           # set方法
1482|   ├── remove()                        # remove方法
1483|   ├── removeAt()                      # removeAt方法
1484|   ├── clear()                         # clear方法
1485|   ├── setValueAt()                    # setValueAt方法
1486|   ├── forEach()                       # forEach方法
1487|   ├── toString()                      # toString方法
1488|   ├── getValueAt()                    # getValueAt方法
1489|   ├── values()                        # values方法
1490|   └── [Symbol.iterator]()             # [Symbol.iterator]方法
1491|—— Class:LightWeightSet
1492|   ├── new LightWeightSet()            # 创建LightWeightSet对象
1493|   ├── length                          # length属性
1494|   ├── add()                           # add方法
1495|   ├── addAll()                        # addAll方法
1496|   ├── hasAll()                        # hasAll方法
1497|   ├── has()                           # has方法
1498|   ├── equal()                         # equal方法
1499|   ├── increaseCapacityTo()            # increaseCapacityTo方法
1500|   ├── getIndexOf()                    # getIndexOf方法
1501|   ├── remove()                        # remove方法
1502|   ├── removeAt()                      # removeAt方法
1503|   ├── clear()                         # clear方法
1504|   ├── forEach()                       # forEach方法
1505|   ├── [Symbol.iterator]()             # [Symbol.iterator]方法
1506|   ├── toString()                      # toString方法
1507|   ├── toArray()                       # toArray方法
1508|   ├── getValueAt()                    # getValueAt方法
1509|   ├── values()                        # values方法
1510|   ├── entries()                       # entries方法
1511|   └── isEmpty()                       # isEmpty方法
1512|—— Class:LinkedList
1513|   ├── new LinkedList()                # 创建LinkedList对象
1514|   ├── length                          # length属性
1515|   ├── add()                           # add方法
1516|   ├── insert()                        # insert方法
1517|   ├── get()                           # get方法
1518|   ├── addFirst()                      # addFirst方法
1519|   ├── removeFirst()                   # removeFirst方法
1520|   ├── removeLast()                    # removeLast方法
1521|   ├── has()                           # has方法
1522|   ├── getIndexOf()                    # getIndexOf方法
1523|   ├── removeByIndex()                 # removeByIndex方法
1524|   ├── remove()                        # remove方法
1525|   ├── removeFirstFound()              # removeFirstFound方法
1526|   ├── removeLastFound()               # removeLastFound方法
1527|   ├── getLastIndexOf()                # getLastIndexOf方法
1528|   ├── getFirst()                      # getFirst方法
1529|   ├── getLast()                       # getLast方法
1530|   ├── set()                           # set方法
1531|   ├── forEach()                       # forEach方法
1532|   ├── clear()                         # clear方法
1533|   ├── clone()                         # clone方法
1534|   ├── convertToArray()                # convertToArray方法
1535|   └── [Symbol.iterator]()             # [Symbol.iterator]方法
1536|—— Class:List
1537|   ├── new List()                      # 创建List对象
1538|   ├── length                          # length属性
1539|   ├── add()                           # add方法
1540|   ├── insert()                        # insert方法
1541|   ├── get()                           # get方法
1542|   ├── has()                           # has方法
1543|   ├── getIndexOf()                    # getIndexOf方法
1544|   ├── removeByIndex()                 # removeByIndex方法
1545|   ├── remove()                        # remove方法
1546|   ├── getLastIndexOf()                # getLastIndexOf方法
1547|   ├── getFirst()                      # getFirst方法
1548|   ├── getLast()                       # getLast方法
1549|   ├── set()                           # set方法
1550|   ├── equal()                         # equal方法
1551|   ├── forEach()                       # forEach方法
1552|   ├── sort()                          # sort方法
1553|   ├── clear()                         # clear方法
1554|   ├── getSubList()                    # getSubList方法
1555|   ├── replaceAllElements()            # replaceAllElements方法
1556|   ├── convertToArray()                # convertToArray方法
1557|   ├── isEmpty()                       # isEmpty方法
1558|   └── [Symbol.iterator]()             # [Symbol.iterator]方法
1559|—— Class:PlainArray
1560|   ├── new PlainArray()                # 创建PlainArray对象
1561|   ├── length                          # length属性
1562|   ├── add()                           # add方法
1563|   ├── clear()                         # clear方法
1564|   ├── clone()                         # clone方法
1565|   ├── has()                           # has方法
1566|   ├── get()                           # get方法
1567|   ├── getIndexOfKey()                 # getIndexOfKey方法
1568|   ├── getIndexOfValue()               # getIndexOfValue方法
1569|   ├── isEmpty()                       # isEmpty方法
1570|   ├── getKeyAt()                      # getKeyAt方法
1571|   ├── remove()                        # remove方法
1572|   ├── removeAt()                      # removeAt方法
1573|   ├── removeRangeFrom()               # removeRangeFrom方法
1574|   ├── setValueAt()                    # setValueAt方法
1575|   ├── toString()                      # toString方法
1576|   ├── getValueAt()                    # getValueAt方法
1577|   ├── forEach()                       # forEach方法
1578|   └── [Symbol.iterator]()             # [Symbol.iterator]方法
1579|—— Class:Queue
1580|   ├── new Queue()                     # 创建Queue对象
1581|   ├── length                          # length属性
1582|   ├── add()                           # add方法
1583|   ├── getFirst()                      # getFirst方法
1584|   ├── pop()                           # pop方法
1585|   ├── forEach()                       # forEach方法
1586|   └── [Symbol.iterator]()             # [Symbol.iterator]方法
1587|—— Class:Stack
1588|   ├── new Stack()                     # 创建Stack对象
1589|   ├── length                          # length属性
1590|   ├── isEmpty()                       # isEmpty方法
1591|   ├── peek()                          # peek方法
1592|   ├── pop()                           # pop方法
1593|   ├── push()                          # push方法
1594|   ├── locate()                        # locate方法
1595|   ├── forEach()                       # forEach方法
1596|   └── [Symbol.iterator]()             # [Symbol.iterator]方法
1597|—— Class:TreeMap
1598|   ├── new TreeMap()                   # 创建TreeMap对象
1599|   ├── length                          # length属性
1600|   ├── isEmpty()                       # isEmpty方法
1601|   ├── hasKey()                        # hasKey方法
1602|   ├── hasValue()                      # hasValue方法
1603|   ├── get()                           # get方法
1604|   ├── getFirstKey()                   # getFirstKey方法
1605|   ├── getLastKey()                    # getLastKey方法
1606|   ├── setAll()                        # setAll方法
1607|   ├── set()                           # set方法
1608|   ├── remove()                        # remove方法
1609|   ├── clear()                         # clear方法
1610|   ├── getLowerKey()                   # getLowerKey方法
1611|   ├── getHigherKey()                  # getHigherKey方法
1612|   ├── keys()                          # keys方法
1613|   ├── values()                        # values方法
1614|   ├── replace()                       # replace方法
1615|   ├── forEach()                       # forEach方法
1616|   ├── entries()                       # entries方法
1617|   └── [Symbol.iterator]()             # [Symbol.iterator]方法
1618└── Class:TreeSet
1619    ├── new TreeSet()                   # 创建TreeSet对象
1620    ├── length                          # length属性
1621    ├── isEmpty()                       # isEmpty方法
1622    ├── has()                           # has方法
1623    ├── add()                           # add方法
1624    ├── remove()                        # remove方法
1625    ├── clear()                         # clear方法
1626    ├── getFirstValue()                 # getFirstValue方法
1627    ├── getLastValue()                  # getLastValue方法
1628    ├── getLowerValue()                 # getLowerValue方法
1629    ├── getHigherValue()                # getHigherValue方法
1630    ├── popFirst()                      # popFirst方法
1631    ├── popLast()                       # popLast方法
1632    ├── forEach()                       # forEach方法
1633    ├── values()                        # values方法
1634    ├── entries()                       # entries方法
1635    └── [Symbol.iterator]()             # [Symbol.iterator]方法
1636```
1637
1638### 2.3. 说明
1639
1640#### 2.3.1. 接口说明
1641
1642
1643| 接口名 | 说明 |
1644| -------- | -------- |
1645| constructor(encoding? : string) | 构造函数,参数encoding表示编码的格式。默认utf-8, 支持gb18030, gbk, gb2312. |
1646| readonly encoding : string | 在TextEncoder类中,获取编码的格式,只支持UTF-8。 |
1647| encode(input : string) : Uint8Array | 输入stirng字符串,根据encodeing编码并输出uint8字节流。 |
1648| encodeInto(input : string, dest : Uint8Array) : {read : number, written : number} | 输入stirng字符串,dest表示编码后存放位置,返回一个对象,read表示已经编码的字符的个数,written表示已编码字符所占字节的大小。 |
1649| constructor(encoding? : string, options? : {fatal? : boolean, ignoreBOM? : boolean}) | 构造函数,第一个参数encoding表示解码的格式。第二个参数表示一些属性。属性中fatal表示是否抛出异常,ignoreBOM表示是否忽略bom标志。 |
1650| readonly encoding : string | 在TextDecoder类中,获取设置的解码格式。 |
1651| readonly fatal : boolean | 获取抛出异常的设置。 |
1652| readonly ignoreBOM : boolean | 获取是否忽略bom标志的设置。 |
1653| decode(input : Uint8Array, options?: { stream?: false }) : string | 输入要解码的数据,解出对应的string字符串。第一个参数input表示要解码的数据,第二个参数options表示一个bool标志,表示将跟随附加数据,默认为false。 |
1654| decodeWithStream(input : Uint8Array, options?: { stream?: false }) : string | 输入要解码的数据,解出对应的string字符串。第一个参数input表示要解码的数据,第二个参数options表示一个bool标志,表示将跟随附加数据,默认为false。 |
1655| encodeSync(src: Uint8Array): Uint8Array; | 使用Base64编码方案将指定u8数组中的所有字节编码到新分配的u8数组中。 |
1656| encodeToStringSync(src: Uint8Array): string; | 使用Base64编码方案将指定的字节数组编码为String。 |
1657| decodeSync(src: Uint8Array \| string): Uint8Array; | 使用Base64编码方案将Base64编码的字符串或输入u8数组解码为新分配的u8数组。 |
1658| encode(src: Uint8Array): Promise\<Uint8Array\>; | 使用Base64编码方案将指定u8数组中的所有字节异步编码到新分配的u8数组中。 |
1659| encodeToString(src: Uint8Array): Promise\<string\>; | 使用Base64编码方案将指定的字节数组异步编码为String。 |
1660| decode(src: Uint8Array \| string): Promise\<Uint8Array\>; | 使用Base64编码方案将Base64编码的字符串或输入u8数组异步解码为新分配的u8数组。 |
1661| static createRationalFromString(rationalString: string): RationalNumber | 基于给定的字符串创建一个RationalNumber对象。 |
1662| compareTo(another: RationalNumber): number | 将当前的RationalNumber对象与给定的对象进行比较。 |
1663| equals(obj: object): number | 检查给定对象是否与当前 RationalNumber 对象相同。 |
1664| valueOf(): number | 将当前的RationalNumber对象进行取整数值或者浮点数值。 |
1665| static getCommonDivisor(number1: number, number2: number,): number | 获得两个指定数的最大公约数。 |
1666| getDenominator(): number | 获取当前的RationalNumber对象的分母。 |
1667| getNumerator(): number | 获取当前的RationalNumber对象的分子。 |
1668| isFinite(): boolean | 检查当前的RationalNumber对象是有限的。 |
1669| isNaN(): boolean | 检查当前RationalNumber对象是否表示非数字(NaN)值。 |
1670| isZero(): boolean | 检查当前RationalNumber对象是否表示零值。 |
1671| toString(): string | 获取当前RationalNumber对象的字符串表示形式。 |
1672| constructor(capacity?: number) | 创建默认构造函数用于创建一个新的LruBuffer实例,默认容量为64。 |
1673| updateCapacity(newCapacity: number): void | 将缓冲区容量更新为指定容量,如果 newCapacity 小于或等于 0,则抛出此异常。 |
1674| toString(): string | 返回对象的字符串表示形式,输出对象的字符串表示  |
1675| values(): V[] | 获取当前缓冲区中所有值的列表,输出按升序返回当前缓冲区中所有值的列表,从最近访问到最近最少访问。 |
1676| length: number | 代表当前缓冲区中值的总数,输出返回当前缓冲区中值的总数。 |
1677| getCapacity(): number | 获取当前缓冲区的容量,输出返回当前缓冲区的容量。 |
1678| clear(): void | 从当前缓冲区清除键值对,清除键值对后,调用afterRemoval()方法依次对其执行后续操作。 |
1679| getCreateCount(): number | 获取createDefault()返回值的次数,输出返回createDefault()返回值的次数。 |
1680| getMissCount(): number | 获取查询值不匹配的次数,输出返回查询值不匹配的次数。 |
1681| getRemovalCount(): number | 获取从缓冲区中逐出值的次数,输出从缓冲区中驱逐的次数。 |
1682| getMatchCount​(): number | 获取查询值匹配成功的次数,输出返回查询值匹配成功的次数。 |
1683| getPutCount(): number | 获取将值添加到缓冲区的次数,输出返回将值添加到缓冲区的次数。 |
1684| isEmpty(): boolean | 检查当前缓冲区是否为空,输出如果当前缓冲区不包含任何值,则返回 true 。 |
1685| get(key: K) : V \| undefined | 表示要查询的键,输出如果指定的键存在于缓冲区中,则返回与键关联的值;否则返回undefined。 |
1686| put(key: K , value: V): V | 将键值对添加到缓冲区,输出与添加的键关联的值;如果要添加的键已经存在,则返回原始值,如果键或值为空,则抛出此异常。 |
1687| keys(): K[ ] | 获取当前缓冲区中值的键列表,输出返回从最近访问到最近最少访问排序的键列表。 |
1688| remove​(key: K): V \| undefined |  从当前缓冲区中删除指定的键及其关联的值。 |
1689| afterRemoval(isEvict: boolean, key: K, value : V, newValue : V):void | 删除值后执行后续操作。 |
1690| contains(key: K): boolean | 检查当前缓冲区是否包含指定的键,输出如果缓冲区包含指定的键,则返回 true 。 |
1691| createDefault(key: K): V | 如果未计算特定键的值,则执行后续操作,参数表示丢失的键,输出返回与键关联的值。 |
1692| entries(): [K,V] | 允许迭代包含在这个对象中的所有键值对。每对的键和值都是对象。 |
1693| \[Symbol.iterator\](): [K,V] | 返回以键值对得形式得一个二维数组。 |
1694| constructor(lowerObj: ScopeType, upperObj : ScopeType) | 创建并返回一个Scope对象,用于创建指定下限和上限的作用域实例的构造函数。 |
1695| toString(): string | 该字符串化方法返回一个包含当前范围的字符串表示形式。 |
1696| intersect(range: Scope): Scope | 获取给定范围和当前范围的交集。 |
1697| intersect(lowerObj: ScopeType, upperObj: ScopeType): Scope | 获取当前范围与给定下限和上限范围的交集。 |
1698| getUpper(): ScopeType | 获取当前范围的上限。 |
1699| getLower(): ScopeType | 获取当前范围的下限。 |
1700| expand(lowerObj: ScopeType, upperObj:  ScopeType): Scope | 创建并返回包括当前范围和给定下限和上限的并集。 |
1701| expand(range: Scope): Scope | 创建并返回包括当前范围和给定范围的并集。 |
1702| expand(value: ScopeType): Scope | 创建并返回包括当前范围和给定值的并集。 |
1703| contains(value: ScopeType): boolean | 检查给定value是否包含在当前范围内。 |
1704| contains(range: Scope): boolean | 检查给定range是否在当前范围内。 |
1705| clamp(value: ScopeType): ScopeType | 将给定value限定到当前范围内。 |
1706| function printf(format: string, ...args: Object[]): string | printf()方法使用第一个参数作为格式字符串(其可以包含零个或多个格式说明符)来返回格式化的字符串。 |
1707| function getErrorString(errno: number): string | getErrorString()方法使用一个系统的错误数字作为参数,用来返回系统的错误信息。 |
1708| function callbackWrapper(original: Function): (err: Object, value: Object) => void | 参数为一个采用 async 函数(或返回 Promise 的函数)并返回遵循错误优先回调风格的函数,即将 (err, value) => ... 回调作为最后一个参数。 在回调中,第一个参数将是拒绝原因(如果 Promise 已解决,则为 null),第二个参数将是已解决的值。 |
1709| function promiseWrapper(original: (err: Object, value: Object) => void): Object | 参数为采用遵循常见的错误优先的回调风格的函数(也就是将 (err, value) => ... 回调作为最后一个参数),并返回一个返回 promise 的版本。 |
1710| isAnyArrayBuffer(value: Object): boolean | 检查输入的value是否是ArrayBuffer或SharedArrayBuffer类型。 |
1711| isArrayBufferView(value: Object): boolean | 检查输入的value是否是napi_int8_array或napi_uint8_array或napi_uint8_clamped_array或napi_int16_array或napi_uint16_array或napi_int32_array或napi_uint32_array或napi_float32_array或napi_float64_array数组或DataView类型。 |
1712| isArgumentsObject(value: Object): boolean | 检查输入的value是否是一个arguments对象类型。 |
1713| isArrayBuffer(value: Object): boolean | 检查输入的value是否是ArrayBuffer类型。 |
1714| isAsyncFunction(value: Object): boolean | 检查输入的value是否是异步函数类型。 |
1715| isBigInt64Array(value: Object): boolean | 检查输入的value是否是BigInt64Array数组类型。 |
1716| isBigUint64Array(value: Object): boolean | 检查输入的value是否是BigUint64Array数组类型。 |
1717| isBooleanObject(value: Object): boolean | 检查输入的value是否是一个布尔对象类型。 |
1718| isBoxedPrimitive(value: Object): boolean | 检查输入的value是否是Boolean或Number或String或Symbol对象类型。 |
1719| isDataView(value: Object): boolean | 检查输入的value是否是DataView类型。 |
1720| isDate(value: Object): boolean | 检查输入的value是否是Date类型。 |
1721| isExternal(value: Object): boolean | 检查输入的value是否是一个native External值类型。 |
1722| isFloat32Array(value: Object): boolean | 检查输入的value是否是Float32Array数组类型。 |
1723| isFloat64Array(value: Object): boolean | 检查输入的value是否是Float64Array数组类型。 |
1724| isGeneratorFunction(value: Object): boolean | 检查输入的value是否是一个generator函数类型。 |
1725| isGeneratorObject(value: Object): boolean | 检查输入的value是否是一个generator对象类型。 |
1726| isInt8Array(value: Object): boolean | 检查输入的value是否是Int8Array数组类型。 |
1727| isInt16Array(value: Object): boolean | 检查输入的value是否是Int16Array数组类型。 |
1728| isInt32Array(value: Object): boolean | 检查输入的value是否是Int32Array数组类型。 |
1729| isMap(value: Object): boolean | 检查输入的value是否是Map类型。 |
1730| isMapIterator(value: Object): boolean | 检查输入的value是否是Map的iterator类型。 |
1731| isModuleNamespaceObject(value: Object): boolean | 检查输入的value是否是Module Namespace Object对象类型。 |
1732| isNativeError(value: Object): boolean | 检查输入的value是否是Error类型。 |
1733| isNumberObject(value: Object): boolean | 检查输入的value是否是Number对象类型。 |
1734| isPromise(value: Object): boolean | 检查输入的value是否是Promise类型。 |
1735| isProxy(value: Object): boolean | 检查输入的value是否是Proxy类型。 |
1736| isRegExp(value: Object): boolean | 检查输入的value是否是RegExp类型。 |
1737| isSet(value: Object): boolean | 检查输入的value是否是Set类型。 |
1738| isSetIterator(value: Object): boolean | 检查输入的value是否是Set的iterator类型。 |
1739| isSharedArrayBuffer(value: Object): boolean | 检查输入的value是否是SharedArrayBuffer类型。 |
1740| isStringObject(value: Object): boolean | 检查输入的value是否是一个String对象类型。 |
1741| isSymbolObject(value: Object): boolean | 检查输入的value是否是一个Symbol对象类型。 |
1742| isTypedArray(value: Object): boolean | 检查输入的value是否是TypedArray包含的类型。 |
1743| isUint8Array(value: Object): boolean | 检查输入的value是否是Uint8Array数组类型。 |
1744| isUint8ClampedArray(value: Object): boolean | 检查输入的value是否是Uint8ClampedArray数组类型。 |
1745| isUint16Array(value: Object): boolean | 检查输入的value是否是Uint16Array数组类型。 |
1746| isUint32Array(value: Object): boolean | 检查输入的value是否是Uint32Array数组类型。 |
1747| isWeakMap(value: Object): boolean | 检查输入的value是否是WeakMap类型。 |
1748| isWeakSet(value: Object): boolean | 检查输入的value是否是WeakSet类型。 |
1749| add(element: T): boolean | 在ArrayList尾部插入元素。 |
1750| insert(element: T, index: number): void | 在长度范围内任意位置插入指定元素。 |
1751| has(element: T): boolean | 判断此ArrayList中是否含有该指定元素。 |
1752| getIndexOf(element: T): number | 返回指定元素第一次出现时的下标值,查找失败返回-1。 |
1753| removeByIndex(index: number): T | 根据元素的下标值查找元素,返回元素后将其删除。 |
1754| remove(element: T): boolean | 删除查找到的第一个指定的元素。 |
1755| getLastIndexOf(element: T): number | 返回指定元素最后一次出现时的下标值,查找失败返回-1。 |
1756| removeByRange(fromIndex: number, toIndex: number): void | 从一段范围内删除元素,包括起始值但不包括终止值。 |
1757| replaceAllElements(callbackFn: (value: T, index?: number, arrlist?: ArrayList<T>) => T,
1758thisArg?: Object): void | 用户操作ArrayList中的元素,用操作后的元素替换原元素并返回操作后的元素。 |
1759| forEach(callbackFn: (value: T, index?: number, arrlist?: ArrayList<T>) => void,
1760  thisArg?: Object): void | 通过回调函数来遍历ArrayList实例对象上的元素以及元素对应的下标。 |
1761| sort(comparator?: (firstValue: T, secondValue: T) => number): void | 对ArrayList中的元素排序。 |
1762| subArrayList(fromIndex: number, toIndex: number): ArrayList<T> | 根据下标截取ArrayList中的一段元素,并返回这一段ArrayList实例,包括起始值但不包括终止值。 |
1763| clear(): void | 清除ArrayList中的所有元素,并把length置为0。 |
1764| clone(): ArrayList<T> | 克隆一个与ArrayList相同的实例,并返回克隆后的实例。修改克隆后的实例并不会影响原实例。 |
1765| getCapacity(): number | 获取当前实例的容量大小。 |
1766| convertToArray(): Array<T> | 把当前ArrayList实例转换成数组,并返回转换后的数组。 |
1767| isEmpty(): boolean | 判断该ArrayList是否为空。 |
1768| increaseCapacityTo(newCapacity: number): void | 如果传入的新容量大于或等于ArrayList中的元素个数,将容量变更为新容量。 |
1769| trimToCurrentLength(): void | 把容量限制为当前的length大小。 |
1770| insertFront(element: T): void | 在deque头部插入元素。 |
1771| insertEnd(element: T): void | 在deque尾部插入元素。 |
1772| has(element: T): boolean | 判断此Deque中是否含有该指定元素。 |
1773| getFirst(): T | 获取Deque实例中的头元素。 |
1774| getLast(): T | 获取Deque实例中的尾元素。 |
1775| popFirst(): T | 删除并返回双端队列的首元素。 |
1776| popLast(): T | 删除并返回双端队列的尾元素。 |
1777| forEach(callbackFn: (value: T, index?: number, deque?: Deque<T>) => void,thisArg?: Object): void |
1778通过回调函数来遍历Deque实例对象上的元素以及元素对应的下标。 |
1779| isEmpty(): boolean | 判断该HashMap是否为空。 |
1780| hasKey(key: K): boolean | 判断此HashMap中是否含有该指定key。 |
1781| hasValue(value: V): boolean | 判断此HashMap中是否含有该指定value。 |
1782| get(key: K): V | 获取指定key所对应的value。 |
1783| setAll(map: HashMap<K, V>): void | 将一个HashMap中的所有元素组添加到另一个hashMap中。 |
1784| set(key: K, value: V): Object | 向HashMap中添加一组数据。 |
1785| remove(key: K): V | 删除指定key所对应元素。 |
1786| clear(): void | 清除HashMap中的所有元素,并把length置为0。 |
1787| keys(): IterableIterator<K> | 返回包含此映射中包含的键名的新迭代器对象。 |
1788| values(): IterableIterator<V> | 返回包含此映射中包含的键值的新迭代器对象。 |
1789| replace(key: K, newValue: V): boolean | 对HashMap中一组数据进行更新(替换)。 |
1790| forEach(callbackFn: (value?: V, key?: K, map?: HashMap<K, V>) => void,thisArg?: Object): void |
1791通过回调函数来遍历HashMap实例对象上的元素以及元素对应的下标。 |
1792| entries(): IterableIterator<[K, V]> | 返回包含此映射中包含的键值对的新迭代器对象。 |
1793| isEmpty(): boolean | 判断该HashSet是否为空。 |
1794| has(value: T): boolean | 判断此HashSet中是否含有该指定元素。 |
1795| add(value: T): boolean | 向HashSet中添加数据。 |
1796| remove(value: T): boolean | 删除指定的元素。 |
1797| clear(): void | 清除HashSet中的所有元素,并把length置为0。 |
1798| forEach(callbackFn: (value?: T, key?: T, set?: HashSet<T>) => void,thisArg?: Object): void |
1799通过回调函数来遍历实例对象上的元素以及元素对应的下标。 |
1800| values(): IterableIterator<T> | 返回包含此映射中包含的键值的新迭代器对象。 |
1801| entries(): IterableIterator<[T, T]> | 返回包含此映射中包含的键值对的新迭代器对象。 |
1802| hasAll(map: LightWeightMap<K, V>): boolean | 判断此LightWeightMap中是否含有该指定map中的所有元素。 |
1803| hasKey(key: K): boolean | 判断此LightWeightMap中是否含有该指定key。 |
1804| hasValue(value: V): boolean | 判断此LightWeightMap中是否含有该指定value。 |
1805| increaseCapacityTo(minimumCapacity: number): void | 将当前LightWeightMap扩容至可以容纳指定数量元素。 |
1806| entries(): IterableIterator<[K, V]> | 返回包含此映射中包含的键值对的新迭代器对象。 |
1807| get(key: K): V | 获取指定key所对应的value。 |
1808| getIndexOfKey(key: K): number | 查找key元素第一次出现的下标值,如果没有找到该元素返回-1。 |
1809| getIndexOfValue(value: V): number | 查找value元素第一次出现的下标值,如果没有找到该元素返回-1。 |
1810| isEmpty(): boolean | 判断该LightWeightMap是否为空。 |
1811| getKeyAt(index: number): K | 查找指定下标的元素键值对中key值,否则返回undefined。 |
1812| keys(): IterableIterator<K> | 返回包含此映射中包含的键的新迭代器对象。 |
1813| setAll(map: LightWeightMap<K, V>): void | 将一个LightWeightMap中的所有元素组添加到另一个lightWeightMap中。 |
1814| set(key: K, value: V): Object | 向LightWeightMap中添加一组数据。 |
1815| remove(key: K): V | 删除并返回指定key映射的元素。 |
1816| removeAt(index: number): boolean | 删除指定下标对应的元素。 |
1817| clear(): void | 清除LightWeightMap中的所有元素,并把length置为0。 |
1818| setValueAt(index: number, newValue: V): boolean | 替换指定下标对应键值对中的元素。 |
1819| forEach(callbackFn: (value?: V, key?: K, map?: LightWeightMap<K, V>) => void,thisArg?: Object): void |
1820通过回调函数来遍历实例对象上的元素以及元素对应的下标。 |
1821| [Symbol.iterator](): IterableIterator<[K, V]> | 返回一个迭代器,迭代器的每一项都是一个 JavaScript 对象,并返回该对象。 |
1822| toString(): String | 将此映射中包含的键值对拼接成字符串,并返回字符串类型。 |
1823| getValueAt(index: number): V | 获取指定下标对应键值对中的元素。 |
1824| values(): IterableIterator<V> | 返回包含此映射中包含的键值的新迭代器对象。 |
1825| add(obj: T): boolean | 向此容器中添加数据。 |
1826| addAll(set: LightWeightSet<T>): boolean | 将另一个容器中的所有元素组添加到当前容器中。 |
1827| hasAll(set: LightWeightSet<T>): boolean | 判断此容器中是否含有该指定set中的所有元素。 |
1828| has(key: T): boolean | 判断此容器中是否含有该指定key。 |
1829| equal(obj: Object): boolean | 判断此容器中是否含有该指定obj同类型的对象。 |
1830| increaseCapacityTo(minimumCapacity: number): void | 将当前容器扩容至可以容纳指定数量元素。 |
1831| getIndexOf(key: T): number | 获取指定key所对应的下标。 |
1832| remove(key: T): T | 删除并返回指定key对应的元素。 |
1833| removeAt(index: number): boolean | 删除指定下标所对应的元素。 |
1834| clear(): void | 清除容器中的所有元素,并把length置为0。 |
1835| forEach(callbackFn: (value?: T, key?: T, set?: LightWeightSet<T>) => void,thisArg?: Object): void |
1836通过回调函数来遍历LightWeightSet实例对象上的元素以及元素对应的下标。 |
1837| [Symbol.iterator](): IterableIterator<T> | 返回一个迭代器,迭代器的每一项都是一个 JavaScript 对象,并返回该对象。 |
1838| toString(): String | 获取包含容器中所有键和值的字符串。 |
1839| toArray(): Array<T> | 获取包含此容器中所有对象的数组。 |
1840| getValueAt(index: number): T | 获取此容器中指定下标对应的元素。 |
1841| values(): IterableIterator<T> | 返回包含此映射中包含的键值的新迭代器对象。 |
1842| entries(): IterableIterator<[T, T]> | 返回包含此映射中包含的键值对的新迭代器对象。 |
1843| isEmpty(): boolean | 判断该容器是否为空。 |
1844| add(element: T): boolean | 在LinkedList尾部插入元素。 |
1845| insert(index: number, element: T): void | 在长度范围内任意插入指定元素。 |
1846| get(index: number): T | 根据下标获取LinkedList中的元素。 |
1847| addFirst(element: T): void | 在LinkedList头部插入元素。 |
1848| removeFirst(): T | 删除并返回LinkedList的第一个元素。 |
1849| removeLast(): T | 删除并返回LinkedList的最后一个元素。 |
1850| has(element: T): boolean | 判断此LinkedList中是否含有该指定元素。 |
1851| getIndexOf(element: T): number | 返回指定元素第一次出现时的下标值,查找失败返回-1。 |
1852| removeByIndex(index: number): T | 根据元素的下标值查找元素,返回元素后将其删除。 |
1853| remove(element: T): boolean | 删除查找到的第一个指定的元素。 |
1854| removeFirstFound(element: T): boolean | 删除第一次出现的指定元素。 |
1855| removeLastFound(element: T): boolean | 删除最后一次出现的指定元素。 |
1856| getLastIndexOf(element: T): number | 返回指定元素最后一次出现时的下标值,查找失败返回-1。 |
1857| getFirst(): T | 获取LinkedList实例中的第一个元素。 |
1858| getLast(): T | 获取LinkedList实例中的最后一个元素。 |
1859| set(index: number, element: T): T | 将此LinkedList中指定位置的元素替换为指定元素。 |
1860| forEach(callbackFn: (value: T, index?: number, LinkedList?: LinkedList<T>) => void,thisArg?: Object): void |
1861通过回调函数来遍历LinkedList实例对象上的元素以及元素对应的下标。 |
1862| clear(): void | 清除LinkedList中的所有元素,并把length置为0。 |
1863| clone(): LinkedList<T> | 克隆一个与LinkedList相同的实例,并返回克隆后的实例。修改克隆后的实例并不会影响原实例。 |
1864| convertToArray(): Array<T> | 把当前LinkedList实例转换成数组,并返回转换后的数组。 |
1865| [Symbol.iterator](): IterableIterator<T> | 返回一个迭代器,迭代器的每一项都是一个 JavaScript 对象,并返回该对象。 |
1866| add(element: T): boolean | 在List尾部插入元素。 |
1867| insert(element: T, index: number): void | 在长度范围内任意位置插入指定元素。 |
1868| get(index: number): T | 根据下标获取List中的元素。 |
1869| has(element: T): boolean | 判断此List中是否含有该指定元素。 |
1870| getIndexOf(element: T): number | 查找指定元素第一次出现的下标值,查找失败返回-1。 |
1871| removeByIndex(index: number): T | 根据元素的下标值查找元素,返回元素后将其删除。 |
1872| remove(element: T): boolean | 删除查找到的第一个指定的元素。 |
1873| getLastIndexOf(element: T): number | 查找指定元素最后一次出现的下标值,查找失败返回-1。 |
1874| getFirst(): T | 获取List实例中的第一个元素。 |
1875| getLast(): T | 获取List实例中的最后一个元素。 |
1876| set(index: number, element: T): T | 将此 List 中指定位置的元素替换为指定元素。 |
1877| equal(obj: Object): boolean | 比较指定对象与此List是否相等。 |
1878| forEach(callbackFn: (value: T, index?: number, List?: List<T>) => void,thisArg?: Object): void |
1879通过回调函数来遍历List实例对象上的元素以及元素对应的下标。 |
1880| sort(comparator: (firstValue: T, secondValue: T) => number): void | 对List中的元素进行一个排序操作。 |
1881| clear(): void | 清除List中的所有元素,并把length置为0。 |
1882| getSubList(fromIndex: number, toIndex: number): List<T> |
1883根据下标截取List中的一段元素,并返回这一段List实例,包括起始值但不包括终止值。 |
1884| replaceAllElements(callbackFn: (value: T, index?: number, list?: List<T>) => T,thisArg?: Object): void;T |
1885用户操作List中的元素,用操作后的元素替换原元素并返回操作后的元素。 |
1886| convertToArray(): Array<T> | 把当前List实例转换成数组,并返回转换后的数组。 |
1887| isEmpty(): boolean | 判断该List是否为空。 |
1888| [Symbol.iterator](): IterableIterator<T> | 返回一个迭代器,迭代器的每一项都是一个 JavaScript 对象,并返回该对象。 |
1889| add(key: number, value: T): void | 向容器中添加一组数据。 |
1890| clear(): void | 清除容器中的所有元素,并把length置为0。 |
1891| clone(): PlainArray<T> | 克隆一个实例,并返回克隆后的实例。修改克隆后的实例并不会影响原实例。 |
1892| has(key: number): boolean | 判断此容器中是否含有该指定key。 |
1893| get(key: number): T | 获取指定key所对应的value。 |
1894| getIndexOfKey(key: number): number | 查找指定key第一次出现的下标值,如果没有找到该key返回-1。 |
1895| getIndexOfValue(value: T): number | 查找指定value元素第一次出现的下标值,如果没有找到该value元素返回-1。 |
1896| isEmpty(): boolean | 判断该容器是否为空。 |
1897| getKeyAt(index: number): number | 查找指定下标元素键值对中的key值。 |
1898| remove(key: number): T | 删除指定key对应元素。 |
1899| removeAt(index: number): T | 删除指定下标对应的元素。 |
1900| removeRangeFrom(index: number, size: number): number | 删除一定范围内的元素。 |
1901| setValueAt(index: number, value: T): void | 替换容器中指定下标对应键值对中的键值。 |
1902| toString(): String | 获取包含容器中所有键和值的字符串。 |
1903| getValueAt(index: number): T | 查找指定下标元素键值对中的Value值,失败返回undefined。 |
1904| forEach(callbackFn: (value: T, index?: number, PlainArray?: PlainArray<T>) => void,thisArg?: Object): void |
1905通过回调函数来遍历实例对象上的元素以及元素对应的下标。 |
1906| [Symbol.iterator](): IterableIterator<[number, T]> | 返回一个包含key-value键值对的迭代器对象,其中key是number类型。 |
1907| add(element: T): boolean | 在队列尾部插入元素。 |
1908| getFirst(): T | 获取队列的头元素。 |
1909| pop(): T | 删除头元素并返回该删除元素。 |
1910| forEach(callbackFn: (value: T, index?: number, Queue?: Queue<T>) => void, thisArg?: Object): void; |
1911通过回调函数来遍历Queue实例对象上的元素以及元素对应的下标。 |
1912| [Symbol.iterator](): IterableIterator<T> | 返回一个迭代器,迭代器的每一项都是一个 JavaScript 对象,并返回该对象。 |
1913| isEmpty(): boolean | 判断该栈是否为空。 |
1914| peek(): T | 获取并返回栈顶元素。 |
1915| pop(): T | 删除栈顶元素并返回该删除元素。 |
1916| push(item: T): T | 在栈顶插入元素,并返回该元素。 |
1917| locate(element: T): number | 返回指定元素第一次出现时的下标值,查找失败返回-1。 |
1918| forEach(callbackFn: (value: T, index?: number, stack?: Stack<T>) => void,thisArg?: Object): void |
1919通过回调函数来遍历Stack实例对象上的元素以及元素对应的下标。 |
1920| [Symbol.iterator](): IterableIterator<T> | 返回一个迭代器,迭代器的每一项都是一个 JavaScript 对象,并返回该对象。 |
1921| isEmpty(): boolean | 判断该容器是否为空。 |
1922| hasKey(key: K): boolean | 判断此容器中是否含有该指定key。 |
1923| hasValue(value: V): boolean | 判断此容器中是否含有该指定value。 |
1924| get(key: K): V | 获取指定key所对应的value。 |
1925| getFirstKey(): K | 获取容器中排序第一的key。 |
1926| getLastKey(): K | 获取容器中排序最后的key。 |
1927| setAll(map: TreeMap<K, V>): void | 将一个TreeMap中的所有元素组添加到另一个TreeMap中。 |
1928| set(key: K, value: V): Object | 向容器中添加一组数据。 |
1929| remove(key: K): V | 删除指定key对应的元素。 |
1930| clear(): void | 清除容器中的所有元素,并把length置为0。 |
1931| getLowerKey(key: K): K | 获取容器中比传入key排序靠前一位的key。 |
1932| getHigherKey(key: K): K | 获取容器中比传入key排序靠后一位的key。 |
1933| keys(): IterableIterator<K> | 返回包含此映射中包含的键的新迭代器对象。 |
1934| values(): IterableIterator<V> | 返回包含此映射中键值对的新迭代器对象。 |
1935| replace(key: K, newValue: V): boolean | 对容器中一组数据进行更新(替换)。 |
1936| forEach(callbackFn: (value?: V, key?: K, map?: TreeMap<K, V>) => void, thisArg?: Object): void; |
1937通过回调函数来遍历实例对象上的元素以及元素对应的下标。 |
1938| entries(): IterableIterator<[K, V]> | 返回包含此映射中键值对的新迭代器对象。 |
1939| [Symbol.iterator](): IterableIterator<[K, V]> | 返回一个迭代器,迭代器的每一项都是一个JavaScript对象,并返回该对象。 |
1940| isEmpty(): boolean | 判断该容器是否为空。 |
1941| has(value: T): boolean | 判断此容器中是否含有该指定元素。 |
1942| add(value: T): boolean | 向容器中添加一组数据。 |
1943| remove(value: T): boolean | 删除指定的元素。 |
1944| clear(): void | 清除容器中的所有元素,并把length置为0。 |
1945| getFirstValue(): T | 获取容器中排序第一的数据。 |
1946| getLastValue(): T | 获取容器中排序最后的数据。 |
1947| getLowerValue(key: T): T | 获取容器中比传入元素排序靠前一位的元素。 |
1948| getHigherValue(key: T): T | 获取容器中比传入元素排序靠后一位的元素。 |
1949| popFirst(): T | 删除容器中排序最前的数据。 |
1950| popLast(): T | 删除容器中排序最后的数据。 |
1951| forEach(callbackFn: (value?: T, key?: T, set?: TreeSet<T>) => void, thisArg?: Object): void; |
1952通过回调函数来遍历实例对象上的元素以及元素对应的下标。 |
1953| values(): IterableIterator<T> | 返回包含此映射中键值对的新迭代器对象。 |
1954| entries(): IterableIterator<[T, T]> | 返回包含此映射中键值对的新迭代器对象。 |
1955| [Symbol.iterator](): IterableIterator<T> | 返回一个迭代器,迭代器的每一项都是一个JavaScript对象,并返回该对象。 |
1956
1957printf中每个说明符都替换为来自相应参数的转换后的值。 支持的说明符有:
1958| 式样化字符 | 式样要求 |
1959| -------- | -------- |
1960|    %s:  | String 将用于转换除 BigInt、Object 和 -0 之外的所有值。|
1961|    %d:  | Number 将用于转换除 BigInt 和 Symbol 之外的所有值。|
1962|    %i:  | parseInt(value, 10) 用于除 BigInt 和 Symbol 之外的所有值。|
1963|    %f:  | parseFloat(value) 用于除 Symbol 之外的所有值。|
1964|    %j:  | JSON。 如果参数包含循环引用,则替换为字符串 '[Circular]'。|
1965|    %o:  | Object. 具有通用 JavaScript 对象格式的对象的字符串表示形式。类似于具有选项 { showHidden: true, showProxy: true } 的 util.inspect()。这将显示完整的对象,包括不可枚举的属性和代理。|
1966|    %O:  | Object. 具有通用 JavaScript 对象格式的对象的字符串表示形式。类似于没有选项的 util.inspect()。 这将显示完整的对象,但不包括不可枚举的属性和代理。|
1967|    %c:  | 此说明符被忽略,将跳过任何传入的 CSS 。|
1968|    %%:  | 单个百分号 ('%')。 这不消耗待式样化参数。|
1969
1970#### 2.3.2. 使用说明
1971各接口使用方法如下:
1972
19731.readonly encoding()
1974
1975```
1976import util from '@ohos.util'
1977var textEncoder = new util.TextEncoder();
1978var getEncoding = textEncoder.encoding();
1979```
19802.encode()
1981```
1982import util from '@ohos.util'
1983var textEncoder = new util.TextEncoder();
1984var result = textEncoder.encode('abc');
1985```
19863.encodeInto()
1987```
1988import util from '@ohos.util'
1989var textEncoder = new util.TextEncoder();
1990var obj = textEncoder.encodeInto('abc', dest);
1991```
19924.textDecoder()
1993```
1994import util from '@ohos.util'
1995var textDecoder = new util.textDecoder("utf-16be", {fatal : true, ignoreBOM : false});
1996```
19975.readonly encoding()
1998```
1999import util from '@ohos.util'
2000var textDecoder = new util.textDecoder("utf-16be", {fatal : true, ignoreBOM : false});
2001var getEncoding = textDecoder.encoding();
2002```
20036.readonly fatal()
2004```
2005import util from '@ohos.util'
2006var textDecoder = new util.textDecoder("utf-16be", {fatal : true, ignoreBOM : false});
2007var fatalStr = textDecoder.fatal();
2008```
20097.readonly ignoreBOM()
2010```
2011import util from '@ohos.util'
2012var textDecoder = new util.textDecoder("utf-16be", {fatal : true, ignoreBOM : false});
2013var ignoreBom = textDecoder.ignoreBOM();
2014```
20158.decode()
2016```
2017import util from '@ohos.util'
2018var textDecoder = new util.textDecoder("utf-16be", {fatal : true, ignoreBOM : false});
2019var result = textDecoder.decode(input, {stream : true});
2020```
20219.decodeWithStream()
2022```
2023import util from '@ohos.util'
2024var textDecoder = new util.textDecoder("utf-16be", {fatal : true, ignoreBOM : false});
2025var result = textDecoder.decodeWithStream(input, {stream : true});
2026```
202710.printf()
2028```
2029import util from '@ohos.util'
2030var format = "%%%o%%%i%s";
2031var value =  function aa(){};
2032var value1 = 1.5;
2033var value2 = "qwer";
2034var result = util.printf(format,value,value1,value2);
2035```
203611.getErrorString()
2037```
2038import util from '@ohos.util'
2039var errnum = 13;
2040var result = util.getErrorString(errnum);
2041```
204212.callbackWrapper()
2043```
2044import util from '@ohos.util'
2045async function promiseFn() {
2046    return Promise.resolve('value');
2047};
2048var cb = util.callbackWrapper(promiseFn);
2049cb((err, ret) => {
2050    expect(err).strictEqual(null);
2051    expect(ret).strictEqual('value');
2052})
2053```
205413.promiseWrapper()
2055```
2056import util from '@ohos.util'
2057function aysnFun(str1, str2, callback) {
2058    if (typeof str1 === 'string' && typeof str1 === 'string') {
2059        callback(null, str1 + str2);
2060    } else {
2061        callback('type err');
2062    }
2063}
2064let newPromiseObj = util.promiseWrapper(aysnFun)("Hello", 'World');
2065newPromiseObj.then(res => {
2066    expect(res).strictEqual('HelloWorld');
2067})
2068```
206914.encodeSync()
2070```
2071import util from '@ohos.util'
2072var that = new util.Base64();
2073var array = new Uint8Array([115,49,51]);
2074var result = that.encodeSync(array);
2075```
207615.encodeToStringSync()
2077```
2078import util from '@ohos.util'
2079var that = new util.Base64();
2080var array = new Uint8Array([115,49,51]);
2081var result = that.encodeToStringSync(array);
2082```
208316.decodeSync()
2084```
2085import util from '@ohos.util'
2086var that = new util.Base64()
2087var buff = 'czEz';
2088var result = that.decodeSync(buff);
2089
2090```
209117.encode()
2092```
2093import util from '@ohos.util'
2094var that = new util.Base64()
2095var array = new Uint8Array([115,49,51]);
2096await that.encode(array).then(val=>{
2097})
2098done()
2099```
210018.encodeToString()
2101```
2102import util from '@ohos.util'
2103var that = new util.Base64()
2104var array = new Uint8Array([115,49,51]);
2105await that.encodeToString(array).then(val=>{
2106})
2107done()
2108```
210919.decode()
2110```
2111import util from '@ohos.util'
2112var that = new util.Base64()
2113var buff = 'czEz';
2114await that.decode(buff).then(val=>{
2115})
2116done()
2117```
211820.createRationalFromString()
2119```
2120import util from '@ohos.util'
2121var pro = new util.RationalNumber(0, 0);
2122var res = pro.createRationalFromString("-1:2");
2123var result1 = res.valueOf();
2124```
212521.compareTo()
2126```
2127import util from '@ohos.util'
2128var pro = new util.RationalNumber(2, 1);
2129var proc = new util.RationalNumber(3, 4);
2130var res = pro.compareTo(proc);
2131```
213222.equals()
2133```
2134import util from '@ohos.util'
2135var pro = new util.RationalNumber(2, 1);
2136var proc = new util.RationalNumber(3, 4);
2137var res = pro.equals(proc);
2138```
213923.valueOf()
2140```
2141import util from '@ohos.util'
2142var pro = new util.RationalNumber(2, 1);
2143var res = pro.valueOf();
2144```
214524.getCommonDivisor()
2146```
2147import util from '@ohos.util'
2148var pro = new util.RationalNumber(0, 0);
2149var res = pro.getCommonDivisor(4, 8);
2150```
215125.getDenominator()
2152```
2153import util from '@ohos.util'
2154var pro = new util.RationalNumber(2, 1);
2155var res = pro.getDenominator();
2156```
215726.getNumerator()
2158```
2159import util from '@ohos.util'
2160var pro = new util.RationalNumber(-2, 1);
2161var res = pro.getNumerator();
2162```
216327.isFinite()
2164```
2165import util from '@ohos.util'
2166var pro = new util.RationalNumber(-2, 1);
2167var res = pro.isFinite();
2168```
216928.isNaN()
2170```
2171import util from '@ohos.util'
2172var pro = new util.RationalNumber(-2, 1);
2173var res = pro.isNaN();
2174```
217529.isZero()
2176```
2177import util from '@ohos.util'
2178var pro = new util.RationalNumber(-2, 1);
2179var res = pro.isZero();
2180```
218130.toString()
2182```
2183import util from '@ohos.util'
2184var pro = new util.RationalNumber(-2, 1);
2185var res = pro.toString();
2186```
218731.updateCapacity()
2188```
2189import util from '@ohos.util'
2190var pro = new util.LruBuffer();
2191var result = pro.updateCapacity(100);
2192```
219332.toString()
2194```
2195import util from '@ohos.util'
2196var pro = new util.LruBuffer();
2197pro.put(2,10);
2198pro.get(2);
2199pro.remove(20);
2200var result = pro.toString();
2201```
220233.values()
2203```
2204import util from '@ohos.util'
2205var pro = new util.LruBuffer();
2206pro.put(2,10);
2207pro.put(2,"anhu");
2208pro.put("afaf","grfb");
2209var result = pro.values();
2210```
221134.length
2212```
2213import util from '@ohos.util'
2214var pro = new util.LruBuffer();
2215pro.put(2,10);
2216pro.put(1,8);
2217var result = pro.length;
2218```
221935.getCapacity()
2220```
2221import util from '@ohos.util'
2222var pro = new util.LruBuffer();
2223var result = pro.getCapacity();
2224```
222536.clear()
2226```
2227import util from '@ohos.util'
2228var pro = new util.LruBuffer();
2229pro.put(2,10);
2230pro.clear();
2231```
223237.getCreateCount()
2233```
2234import util from '@ohos.util'
2235var pro = new util.LruBuffer();
2236pro.put(1,8);
2237var result = pro.getCreateCount();
2238```
223938.getMissCount()
2240```
2241import util from '@ohos.util'
2242var pro = new util.LruBuffer();
2243pro.put(2,10);
2244pro.get(2)
2245var result = pro.getMissCount();
2246```
224739.getRemovalCount()
2248```
2249
2250import util from '@ohos.util'
2251var pro = new util.LruBuffer();
2252pro.put(2,10);
2253pro.updateCapacity(2);
2254pro.put(50,22);
2255var result = pro.getRemovalCount();
2256
2257```
225840.getMatchCount()
2259```
2260import util from '@ohos.util'
2261var pro = new util.LruBuffer();
2262pro.put(2,10);
2263pro.get(2);
2264var result = pro.getMatchCount();
2265```
226641.getPutCount()
2267```
2268import util from '@ohos.util'
2269var pro = new util.LruBuffer();
2270pro.put(2,10);
2271var result = pro.getPutCount();
2272```
227342.isEmpty()
2274```
2275import util from '@ohos.util'
2276var pro = new util.LruBuffer();
2277pro.put(2,10);
2278var result = pro.isEmpty();
2279```
228043.get()
2281
2282```
2283import util from '@ohos.util'
2284var pro = new util.LruBuffer();
2285pro.put(2,10);
2286var result = pro.get(2);
2287```
228844.put()
2289```
2290import util from '@ohos.util'
2291var pro = new util.LruBuffer();
2292var result = pro.put(2,10);
2293```
229445.keys()
2295```
2296import util from '@ohos.util'
2297var pro = new util.LruBuffer();
2298pro.put(2,10);
2299var result = pro.keys();
2300```
230146.remove()
2302```
2303import util from '@ohos.util'
2304var pro = new util.LruBuffer();
2305pro.put(2,10);
2306var result = pro.remove(20);
2307```
230847.contains()
2309```
2310import util from '@ohos.util'
2311var pro = new util.LruBuffer();
2312pro.put(2,10);
2313var result = pro.contains(20);
2314```
231548.createDefault()
2316```
2317import util from '@ohos.util'
2318var pro = new util.LruBuffer();
2319var result = pro.createDefault(50);
2320```
232149.entries()
2322```
2323import util from '@ohos.util'
2324var pro = new util.LruBuffer();
2325pro.put(2,10);
2326var result = pro.entries();
2327```
232850.\[Symbol.iterator\]()
2329```
2330import util from '@ohos.util'
2331var pro = new util.LruBuffer();
2332pro .put(2,10);
2333var result = pro[symbol.iterator]();
2334```
233551.afterRemoval()
2336```
2337import util from '@ohos.util'
2338var arr = [ ];
2339class ChildLruBuffer extends util.LruBuffer
2340{
2341    constructor()
2342    {
2343        super();
2344    }
2345    static getInstance()
2346    {
2347        if(this.instance ==  null)
2348        {
2349            this.instance = new ChildLruBuffer();
2350        }
2351        return this.instance;
2352    }
2353    afterRemoval(isEvict, key, value, newValue)
2354    {
2355        if (isEvict === false)
2356        {
2357            arr = [key, value, newValue];
2358        }
2359    }
2360}
2361ChildLruBuffer.getInstance().afterRemoval(false,10,30,null)
2362```
2363Scope接口中构造新类,实现compareTo方法。
2364
2365```
2366class Temperature {
2367    constructor(value) {
2368        this._temp = value;
2369    }
2370    compareTo(value) {
2371        return this._temp >= value.getTemp();
2372    }
2373    getTemp() {
2374        return this._temp;
2375    }
2376    toString() {
2377        return this._temp.toString();
2378    }
2379}
2380```
2381
238252.constructor()
2383
2384```
2385var tempLower = new Temperature(30);
2386var tempUpper = new Temperature(40);
2387var range = new Scope(tempLower, tempUpper);
2388```
2389
239053.toString()
2391
2392```
2393var tempLower = new Temperature(30);
2394var tempUpper = new Temperature(40);
2395var range = new Scope(tempLower, tempUpper);
2396var result = range.toString() // => [30,40]
2397```
2398
239954.intersect()
2400
2401```
2402var tempLower = new Temperature(30);
2403var tempUpper = new Temperature(40);
2404var range = new Scope(tempLower, tempUpper);
2405var tempMiDF = new Temperature(35);
2406var tempMidS = new Temperature(39);
2407var rangeFir = new Scope(tempMiDF, tempMidS);
2408var result = range.intersect(rangeFir)  // => [35,39]
2409```
2410
241155.intersect()
2412
2413```
2414var tempLower = new Temperature(30);
2415var tempUpper = new Temperature(40);
2416var tempMiDF = new Temperature(35);
2417var tempMidS = new Temperature(39);
2418var range = new Scope(tempLower, tempUpper);
2419var result = range.intersect(tempMiDF, tempMidS)  // => [35,39]
2420```
2421
242256.getUpper()
2423
2424```
2425var tempLower = new Temperature(30);
2426var tempUpper = new Temperature(40);
2427var range = new Scope(tempLower, tempUpper);
2428var result = range.getUpper() // => 40
2429```
2430
243157.getLower()
2432
2433```
2434var tempLower = new Temperature(30);
2435var tempUpper = new Temperature(40);
2436var range = new Scope(tempLower, tempUpper);
2437var result = range.getLower() // => 30
2438```
2439
244058.expand()
2441
2442```
2443var tempLower = new Temperature(30);
2444var tempUpper = new Temperature(40);
2445var tempMiDF = new Temperature(35);
2446var tempMidS = new Temperature(39);
2447var range = new Scope(tempLower, tempUpper);
2448var result = range.expand(tempMiDF, tempMidS)  // => [30,40]
2449```
2450
245159.expand()
2452
2453```
2454var tempLower = new Temperature(30);
2455var tempUpper = new Temperature(40);
2456var tempMiDF = new Temperature(35);
2457var tempMidS = new Temperature(39);
2458var range = new Scope(tempLower, tempUpper);
2459var rangeFir = new Scope(tempMiDF, tempMidS);
2460var result = range.expand(rangeFir) // => [30,40]
2461```
2462
246360.expand()
2464
2465```
2466var tempLower = new Temperature(30);
2467var tempUpper = new Temperature(40);
2468var tempMiDF = new Temperature(35);
2469var range = new Scope(tempLower, tempUpper);
2470var result = range.expand(tempMiDF)  // => [30,40]
2471```
2472
247361.contains()
2474
2475```
2476var tempLower = new Temperature(30);
2477var tempUpper = new Temperature(40);
2478var tempMiDF = new Temperature(35);
2479var range = new Scope(tempLower, tempUpper);
2480var result = range.contains(tempMiDF) // => true
2481```
2482
248362.contains()
2484
2485```
2486var tempLower = new Temperature(30);
2487var tempUpper = new Temperature(40);
2488var range = new Scope(tempLower, tempUpper);
2489var tempLess = new Temperature(20);
2490var tempMore = new Temperature(45);
2491var rangeSec = new Scope(tempLess, tempMore);
2492var result = range.contains(rangeSec) // => true
2493```
2494
249563.clamp()
2496
2497```
2498var tempLower = new Temperature(30);
2499var tempUpper = new Temperature(40);
2500var tempMiDF = new Temperature(35);
2501var range = new Scope(tempLower, tempUpper);
2502var result = range.clamp(tempMiDF) // => 35
2503```
250464.isAnyArrayBuffer()
2505```
2506import util from '@ohos.util'
2507var proc = new util.Types();
2508var result = proc.isAnyArrayBuffer(new ArrayBuffer([]))
2509```
251065.isArrayBufferView()
2511```
2512import util from '@ohos.util'
2513var proc = new util.Types();
2514var result = proc.isArrayBufferView(new DataView(new ArrayBuffer(16)));
2515```
251666.isArgumentsObject()
2517```
2518import util from '@ohos.util'
2519function foo() {
2520        var result = proc.isArgumentsObject(arguments);
2521    }
2522var f = foo();
2523```
252467.isArrayBuffer()
2525```
2526import util from '@ohos.util'
2527var proc = new util.Types();
2528var result = proc.isArrayBuffer(new ArrayBuffer([]));
2529```
253068.isAsyncFunction()
2531```
2532import util from '@ohos.util'
2533var proc = new util.Types();
2534var result = proc.isAsyncFunction(async function foo() {});
2535```
253669.isBigInt64Array()
2537```
2538import util from '@ohos.util'
2539var proc = new util.Types();
2540var result = proc.isBigInt64Array(new Int16Array([]));
2541```
254270.isBigUint64Array()
2543```
2544import util from '@ohos.util'
2545var proc = new util.Types();
2546var result = proc.isBigUint64Array(new Int16Array([]));
2547```
254871.isBooleanObject()
2549```
2550import util from '@ohos.util'
2551var proc = new util.Types();
2552var result = proc.isBooleanObject(new Boolean(false));
2553```
255472.isBoxedPrimitive()
2555```
2556import util from '@ohos.util'
2557var proc = new util.Types();
2558var result = proc.isBoxedPrimitive(new Boolean(false));
2559```
256073.isDataView()
2561```
2562import util from '@ohos.util'
2563var proc = new util.Types();
2564const ab = new ArrayBuffer(20);
2565var result = proc.isDataView(new DataView(ab));
2566```
256774.isDate()
2568```
2569import util from '@ohos.util'
2570var proc = new util.Types();
2571var result = proc.isDate(new Date());
2572```
257375.isExternal()
2574```
2575import util from '@ohos.util'
2576const data = util.createExternalType();
2577var reult13 = proc.isExternal(data);
2578```
257976.isFloat32Array()
2580```
2581import util from '@ohos.util'
2582var proc = new util.Types();
2583var result = proc.isFloat32Array(new Float32Array([]));
2584```
258577.isFloat64Array()
2586```
2587import util from '@ohos.util'
2588var proc = new util.Types();
2589var result = proc.isFloat64Array(new Float64Array([]));
2590```
259178.isGeneratorFunction()
2592```
2593import util from '@ohos.util'
2594var proc = new util.Types();
2595var result = proc.isGeneratorFunction(function* foo() {});
2596```
259779.isGeneratorObject()
2598```
2599import util from '@ohos.util'
2600var proc = new util.Types();
2601function* foo() {}
2602const generator = foo();
2603var result = proc.isGeneratorObject(generator);
2604```
260580.isInt8Array()
2606```
2607import util from '@ohos.util'
2608var proc = new util.Types();
2609var result = proc.isInt8Array(new Int8Array([]));
2610```
261181.isInt16Array()
2612```
2613import util from '@ohos.util'
2614var proc = new util.Types();
2615var result = proc.isInt16Array(new Int16Array([]));
2616```
261782.isInt32Array()
2618```
2619import util from '@ohos.util'
2620var proc = new util.Types();
2621var result = proc.isInt32Array(new Int32Array([]));
2622```
262383.isMap()
2624```
2625import util from '@ohos.util'
2626var proc = new util.Types();
2627var result = proc.isMap(new Map());
2628```
262984.isMapIterator()
2630```
2631import util from '@ohos.util'
2632var proc = new util.Types();
2633var result = proc.isMapIterator(map.keys());
2634```
263585.isModuleNamespaceObject()
2636```
2637import util from '@ohos.util'
2638var proc = new util.Types();
2639var result = proc.isModuleNamespaceObject(util);
2640```
264186.isNativeError()
2642```
2643import util from '@ohos.util'
2644var proc = new util.Types();
2645var result = proc.isNativeError(new TypeError());
2646```
264787.isNumberObject()
2648```
2649import util from '@ohos.util'
2650var proc = new util.Types();
2651var result = proc.isNumberObject(new Number(0));
2652```
265388.isPromise()
2654```
2655import util from '@ohos.util'
2656var proc = new util.Types();
2657var result = proc.isPromise(Promise.resolve(42));
2658```
265989.isProxy()
2660```
2661import util from '@ohos.util'
2662var proc = new util.Types();
2663const target = {};
2664const proxy = new Proxy(target, {});
2665var result = proc.isProxy(proxy);
2666```
266790.isRegExp()
2668```
2669import util from '@ohos.util'
2670var proc = new util.Types();
2671var result = proc.isRegExp(new RegExp('abc'));
2672```
267391.isSet()
2674```
2675import util from '@ohos.util'
2676var proc = new util.Types();
2677var result = proc.isSet(new Set());
2678```
267992.isSetIterator()
2680```
2681import util from '@ohos.util'
2682var proc = new util.Types();
2683const set = new Set();
2684var result = proc.isSetIterator(set.keys());
2685```
268693.isSharedArrayBuffer()
2687```
2688import util from '@ohos.util'
2689var proc = new util.Types();
2690var result = proc.isSharedArrayBuffer(new ArrayBuffer([]));
2691```
269294.isStringObject()
2693```
2694import util from '@ohos.util'
2695var proc = new util.Types();
2696var result = proc.isStringObject(new String('foo'));
2697```
269895.isSymbolObject()
2699```
2700import util from '@ohos.util'
2701var proc = new util.Types();
2702const symbols = Symbol('foo');
2703var result = proc.isSymbolObject(Object(symbols));
2704```
270596.isTypedArray()
2706```
2707import util from '@ohos.util'
2708var proc = new util.Types();
2709var result = proc.isTypedArray(new Float64Array([]));
2710```
271197.isUint8Array()
2712```
2713import util from '@ohos.util'
2714var proc = new util.Types();
2715var result = proc.isUint8Array(new Uint8Array([]));
2716```
271798.isUint8ClampedArray()
2718```
2719import util from '@ohos.util'
2720var proc = new util.Types();
2721var result = proc.isUint8ClampedArray(new Uint8ClampedArray([]));
2722```
272399.isUint16Array()
2724```
2725import util from '@ohos.util'
2726var proc = new util.Types();
2727var result = proc.isUint16Array(new Uint16Array([]));
2728```
2729100.isUint32Array()
2730```
2731import util from '@ohos.util'
2732var proc = new util.Types();
2733var result = proc.isUint32Array(new Uint32Array([]));
2734```
2735101.isWeakMap()
2736```
2737import util from '@ohos.util'
2738var proc = new util.Types();
2739var result = proc.isWeakMap(new WeakMap());
2740```
2741102.isWeakSet()
2742```
2743import util from '@ohos.util'
2744var proc = new util.Types();
2745var result = proc.isWeakSet(new WeakSet());
2746```
2747103.add()
2748```
2749import ArrayList from "@ohos.util.ArrayList"
2750let arrayList = new ArrayList();
2751let result = arrayList.add(8);
2752```
2753104.insert()
2754```
2755import ArrayList from "@ohos.util.ArrayList"
2756let arrayList = new ArrayList();
2757arrayList.add("四");
2758arrayList.add("三");
2759arrayList.add(1);
2760arrayList.add("a");
2761arrayList.insert(8, 2);
2762```
2763105.add()
2764```
2765import ArrayList from "@ohos.util.ArrayList"
2766let arrayList = new ArrayList();
2767arrayList.add("四");
2768arrayList.add("三");
2769arrayList.add(1);
2770arrayList.add("a");
2771arrayList.insert(8, 2);
2772let result = arrayList.has(8);
2773```
2774106.getIndexOf()
2775```
2776import ArrayList from "@ohos.util.ArrayList"
2777let arrayList = new ArrayList();
2778arrayList.add(1);
2779arrayList.add("三");
2780arrayList.add(1);
2781arrayList.add("a");
2782arrayList.insert(1, 2);
2783let result = arrayList.getIndexOf(1);
2784```
2785107.removeByIndex()
2786```
2787import ArrayList from "@ohos.util.ArrayList"
2788let arrayList = new ArrayList();
2789arrayList.add(1);
2790arrayList.add("三");
2791arrayList.add(1);
2792arrayList.add("a");
2793let result = arrayList.removeByIndex(2);
2794```
2795108.remove()
2796```
2797import ArrayList from "@ohos.util.ArrayList"
2798let arrayList = new ArrayList();
2799arrayList.add("四");
2800arrayList.add("三");
2801arrayList.add(1);
2802arrayList.add("a");
2803let result = arrayList.remove("三");
2804```
2805109.getLastIndexOf()
2806```
2807import ArrayList from "@ohos.util.ArrayList"
2808let arrayList = new ArrayList();
2809arrayList.add("四");
2810arrayList.add("三");
2811arrayList.add(1);
2812arrayList.add("a");
2813arrayList.add(1);
2814arrayList.add("b");
2815let result = arrayList.getLastIndexOf(1);
2816```
2817110.removeByRange()
2818```
2819import ArrayList from "@ohos.util.ArrayList"
2820let arrayList = new ArrayList();
2821arrayList.add("四");
2822arrayList.add("三");
2823arrayList.add("a");
2824arrayList.add("b");
2825arrayList.add("c");
2826arrayList.removeByRange(1, 3);
2827```
2828111.replaceAllElements()
2829```
2830import ArrayList from "@ohos.util.ArrayList"
2831let arrayList = new ArrayList();
2832arrayList.add(4);
2833arrayList.add(3);
2834arrayList.add(1);
2835arrayList.add(2);
2836arrayList.add(14);
2837arrayList.replaceAllElements((item, index) => {
2838    return (item = 2 * item);
2839});
2840```
2841112.forEach()
2842```
2843import ArrayList from "@ohos.util.ArrayList"
2844let arrayList = new ArrayList();
2845arrayList.add(4);
2846arrayList.add(3);
2847arrayList.add(1);
2848arrayList.add(2);
2849arrayList.add(14);
2850let arr = [];
2851arrayList.forEach((item, index) => {
2852    arr.push(item);
2853});
2854```
2855113.sort()
2856```
2857import ArrayList from "@ohos.util.ArrayList"
2858let arrayList = new ArrayList();
2859arrayList.add(4);
2860arrayList.add(3);
2861arrayList.add(1);
2862arrayList.add(2);
2863arrayList.add(14);
2864arrayList.sort((a, b) => a - b);
2865```
2866114.subArrayList()
2867```
2868import ArrayList from "@ohos.util.ArrayList"
2869let arrayList = new ArrayList();
2870arrayList.add(4);
2871arrayList.add(3);
2872arrayList.add(1);
2873arrayList.add(2);
2874arrayList.add(14);
2875let result = arrayList.subArrayList(0, 5);
2876```
2877115.clear()
2878```
2879import ArrayList from "@ohos.util.ArrayList"
2880let arrayList = new ArrayList();
2881arrayList.add(4);
2882arrayList.add(3);
2883arrayList.add(1);
2884arrayList.add(2);
2885arrayList.add(14);
2886arrayList.clear();
2887```
2888116.clone()
2889```
2890import ArrayList from "@ohos.util.ArrayList"
2891let arrayList = new ArrayList();
2892arrayList.add(4);
2893arrayList.add(3);
2894arrayList.add(1);
2895arrayList.add(2);
2896arrayList.add(14);
2897let res = arrayList.clone();
2898```
2899117.getCapacity()
2900```
2901import ArrayList from "@ohos.util.ArrayList"
2902let arrayList = new ArrayList();
2903arrayList.add(4);
2904arrayList.add(3);
2905arrayList.add(1);
2906arrayList.add(2);
2907arrayList.add(14);
2908let result = arrayList.getCapacity();
2909```
2910118.convertToArray()
2911```
2912import ArrayList from "@ohos.util.ArrayList"
2913let arrayList = new ArrayList();
2914arrayList.add(4);
2915arrayList.add(3);
2916arrayList.add(1);
2917arrayList.add(2);
2918arrayList.add(14);
2919let arr = arrayList.convertToArray();
2920```
2921119.isEmpty()
2922```
2923import ArrayList from "@ohos.util.ArrayList"
2924let arrayList = new ArrayList();
2925arrayList.add(4);
2926arrayList.add(3);
2927arrayList.add(1);
2928arrayList.clear();
2929let result = arrayList.isEmpty();
2930```
2931120.increaseCapacityTo()
2932```
2933import ArrayList from "@ohos.util.ArrayList"
2934let arrayList = new ArrayList();
2935arrayList.add(4);
2936arrayList.add(3);
2937arrayList.add(1);
2938arrayList.add(2);
2939arrayList.add(14);
2940arrayList.increaseCapacityTo(-1);
2941```
2942121.trimToCurrentLength()
2943```
2944import ArrayList from "@ohos.util.ArrayList"
2945let arrayList = new ArrayList();
2946arrayList.add(4);
2947arrayList.add(3);
2948arrayList.add(1);
2949arrayList.add(2);
2950arrayList.add(14);
2951arrayList.trimToCurrentLength();
2952```
2953122.insertFront()
2954```
2955import Deque from "@ohos.util.Deque"
2956let deque = new Deque();
2957deque.insertFront("一");
2958```
2959123.insertEnd()
2960```
2961import Deque from "@ohos.util.Deque"
2962let deque = new Deque();
2963let a = ["a", "b", "c"];
2964deque.insertEnd(a);
2965```
2966124.has()
2967```
2968import Deque from "@ohos.util.Deque"
2969let deque = new Deque();
2970deque.insertEnd(6);
2971let result = deque.has(6);
2972```
2973125.getFirst()
2974```
2975import Deque from "@ohos.util.Deque"
2976let deque = new Deque();
2977deque.insertFront("$");
2978let result = deque.getFirst();
2979```
2980126.getLast()
2981```
2982import Deque from "@ohos.util.Deque"
2983let deque = new Deque();
2984deque.insertFront("$");
2985let result = deque.getLast();
2986```
2987127.popFirst()
2988```
2989import Deque from "@ohos.util.Deque"
2990let deque = new Deque();
2991deque.insertFront(6);
2992let result = deque.popFirst();
2993```
2994128.popLast()
2995```
2996import Deque from "@ohos.util.Deque"
2997let deque = new Deque();
2998deque.insertFront(11);
2999let result = deque.popLast();
3000```
3001129.forEach()
3002```
3003import Deque from "@ohos.util.Deque"
3004let deque = new Deque();
3005deque.insertEnd(1);
3006deque.insertEnd(2);
3007deque.insertEnd(3);
3008let arr = [];
3009deque.forEach((item, index) => {
3010    arr.push(item);
3011});
3012```
3013130.isEmpty()
3014```
3015import HashMap from "@ohos.util.HashMap"
3016let hashMap = new HashMap();
3017hashMap.set(1, "A");
3018hashMap.set(2, "B");
3019let result = hashMap.isEmpty();
3020```
3021131.hasKey()
3022```
3023import HashMap from "@ohos.util.HashMap"
3024let hashMap = new HashMap();
3025hashMap.set(1, "A");
3026hashMap.set(2, "B");
3027hashMap.set(3, "C");
3028let result = hashMap.hasKey(3);
3029```
3030132.hasValue()
3031```
3032import HashMap from "@ohos.util.HashMap"
3033let hashMap = new HashMap();
3034hashMap.set(1, "A");
3035hashMap.set(2, "B");
3036hashMap.set(3, "C");
3037let result = hashMap.hasValue("C");
3038```
3039133.get()
3040```
3041import HashMap from "@ohos.util.HashMap"
3042let hashMap = new HashMap();
3043hashMap.set(1, "A");
3044hashMap.set(2, "B");
3045hashMap.set(3, "C");
3046let result = hashMap.get(3);
3047```
3048134.setAll()
3049```
3050import HashMap from "@ohos.util.HashMap"
3051let hashMap = new HashMap();
3052hashMap.set(1, "A");
3053hashMap.set(2, "B");
3054hashMap.set(3, "C");
3055let hashMap1 = new HashMap();
3056hashMap1.set(1, 1);
3057hashMap1.set(2, 2);
3058hashMap.setAll(hashMap1);
3059```
3060135.set()
3061```
3062import HashMap from "@ohos.util.HashMap"
3063let hashMap = new HashMap();
3064hashMap.set(1, "A");
3065hashMap.set(2, "B");
3066hashMap.set(3, "C");
3067```
3068136.remove()
3069```
3070import HashMap from "@ohos.util.HashMap"
3071let hashMap = new HashMap();
3072hashMap.set(1, "A");
3073hashMap.set(2, "B");
3074hashMap.set(3, "C");
3075let result = hashMap.remove(3);
3076```
3077137.clear()
3078```
3079import HashMap from "@ohos.util.HashMap"
3080let hashMap = new HashMap();
3081hashMap.set(1, "A");
3082hashMap.set(2, "B");
3083hashMap.set(3, "C");
3084hashMap.clear();
3085```
3086138.keys()
3087```
3088import HashMap from "@ohos.util.HashMap"
3089let hashMap = new HashMap();
3090hashMap.set(1, "A");
3091hashMap.set(2, "B");
3092hashMap.set(3, "C");
3093hashMap.set(4, "D");
3094hashMap.set(5, "E");
3095let result = hashMap.keys();
3096```
3097139.values()
3098```
3099import HashMap from "@ohos.util.HashMap"
3100let hashMap = new HashMap();
3101hashMap.set(1, "A");
3102hashMap.set(2, "B");
3103hashMap.set(3, "C");
3104hashMap.set(4, "D");
3105hashMap.set(5, "E");
3106let result = hashMap.values();
3107```
3108140.replace()
3109```
3110import HashMap from "@ohos.util.HashMap"
3111let hashMap = new HashMap();
3112hashMap.set(1, "A");
3113hashMap.set(2, "B");
3114hashMap.set(3, "C");
3115hashMap.set(4, "D");
3116hashMap.set(5, "E");
3117let result = hashMap.replace(2, "G");
3118```
3119141.forEach()
3120```
3121import HashMap from "@ohos.util.HashMap"
3122let hashMap = new HashMap();
3123hashMap.set(1, "A");
3124hashMap.set(2, "B");
3125hashMap.set(3, "C");
3126hashMap.set(4, "D");
3127hashMap.set(5, "E");
3128let vals = [];
3129let keys = [];
3130hashMap.forEach((value, key) => {
3131    keys.push(key);
3132    vals.push(value);
3133});
3134```
3135142.entries()
3136```
3137import HashMap from "@ohos.util.HashMap"
3138let hashMap = new HashMap();
3139hashMap.set(1, "A");
3140hashMap.set(2, "B");
3141hashMap.set(3, "C");
3142hashMap.set(4, "D");
3143hashMap.set(5, "E");
3144let result = hashMap.entries();
3145```
3146143.isEmpty()
3147```
3148import HashSet from "@ohos.util.HashSet"
3149let hashSet = new HashSet();
3150hashSet.add(1);
3151hashSet.add(2);
3152let result = hashSet.isEmpty();
3153```
3154144.has()
3155```
3156import HashSet from "@ohos.util.HashSet"
3157let hashSet = new HashSet();
3158hashSet.add(1);
3159hashSet.add(2);
3160let result = hashSet.has(1);
3161```
3162145.add()
3163```
3164import HashSet from "@ohos.util.HashSet"
3165let hashSet = new HashSet();
3166hashSet.add(1);
3167hashSet.add(2);
3168```
3169146.remove()
3170```
3171import HashSet from "@ohos.util.HashSet"
3172let hashSet = new HashSet();
3173hashSet.add(1);
3174hashSet.add(2);
3175let hashSet = hashSet.remove(1);
3176```
3177147.clear()
3178```
3179import HashSet from "@ohos.util.HashSet"
3180let hashSet = new HashSet();
3181hashSet.add(1);
3182hashSet.add(2);
3183hashSet.clear();
3184```
3185148.forEach()
3186```
3187import HashSet from "@ohos.util.HashSet"
3188let hashSet = new HashSet();
3189hashSet.add(1);
3190hashSet.add(2);
3191hashSet.add(3);
3192hashSet.add(4);
3193hashSet.add(5);
3194let arr = [];
3195hashSet.forEach((value, index) => {
3196    arr.push(value);
3197});
3198```
3199149.values()
3200```
3201import HashSet from "@ohos.util.HashSet"
3202let hashSet = new HashSet();
3203hashSet.add("A");
3204hashSet.add("B");
3205hashSet.add("C");
3206hashSet.add("D");
3207hashSet.add("E");
3208let res = hashSet.values();
3209```
3210150.entries()
3211```
3212import HashSet from "@ohos.util.HashSet"
3213let hashSet = new HashSet();
3214hashSet.add(1);
3215hashSet.add(2);
3216hashSet.add(3);
3217let res = hashSet.entries();
3218```
3219151.hasAll()
3220```
3221import LightWeightMap from "@ohos.util.LightWeightMap"
3222let lightWeightMap = new LightWeightMap();
3223lightWeightMap.set("a", "A");
3224lightWeightMap.set("b", "B");
3225lightWeightMap.set("c", "C");
3226lightWeightMap.set("d", "D");
3227lightWeightMap.set("e", "E");
3228let lightWeightMap1 = new LightWeightMap();
3229lightWeightMap1.set("a", "A");
3230lightWeightMap1.set("d", "D");
3231let res = lightWeightMap.hasAll(lightWeightMap1);
3232```
3233152.hasKey()
3234```
3235import LightWeightMap from "@ohos.util.LightWeightMap"
3236let lightWeightMap = new LightWeightMap();
3237lightWeightMap.set("a", "A");
3238lightWeightMap.set("b", "B");
3239lightWeightMap.set("c", "C");
3240let res = lightWeightMap.hasKey("a");
3241```
3242153.hasValue()
3243```
3244import LightWeightMap from "@ohos.util.LightWeightMap"
3245let lightWeightMap = new LightWeightMap();
3246lightWeightMap.set("a", "A");
3247lightWeightMap.set("b", "B");
3248lightWeightMap.set("c", "C");
3249let res = lightWeightMap.hasValue("A");
3250```
3251154.increaseCapacityTo()
3252```
3253import LightWeightMap from "@ohos.util.LightWeightMap"
3254let lightWeightMap = new LightWeightMap();
3255lightWeightMap.set("a", "A");
3256lightWeightMap.set("b", "B");
3257lightWeightMap.set("c", "C");
3258lightWeightMap.increaseCapacityTo(3);
3259```
3260155.entries()
3261```
3262import LightWeightMap from "@ohos.util.LightWeightMap"
3263let lightWeightMap = new LightWeightMap();
3264lightWeightMap.set(1, "A");
3265lightWeightMap.set(2, "B");
3266lightWeightMap.set(3, "C");
3267let res = lightWeightMap.entries();
3268```
3269156.get()
3270```
3271import LightWeightMap from "@ohos.util.LightWeightMap"
3272let lightWeightMap = new LightWeightMap();
3273lightWeightMap.set(1, "A");
3274lightWeightMap.set(2, "B");
3275lightWeightMap.set(3, "C");
3276let res = lightWeightMap.get(1);
3277```
3278157.getIndexOfKey()
3279```
3280import LightWeightMap from "@ohos.util.LightWeightMap"
3281let lightWeightMap = new LightWeightMap();
3282lightWeightMap.set(1, "A");
3283lightWeightMap.set(2, "B");
3284lightWeightMap.set(3, "C");
3285let res = lightWeightMap.getIndexOfKey(2);
3286```
3287158.getIndexOfValue()
3288```
3289import LightWeightMap from "@ohos.util.LightWeightMap"
3290let lightWeightMap = new LightWeightMap();
3291lightWeightMap.set(1, "A");
3292lightWeightMap.set(2, "B");
3293lightWeightMap.set(3, "C");
3294lightWeightMap.set(4, "D");
3295lightWeightMap.set(5, "E");
3296lightWeightMap.setValueAt(4, "F");
3297let res = lightWeightMap.getIndexOfValue("F");
3298```
3299159.isEmpty()
3300```
3301import LightWeightMap from "@ohos.util.LightWeightMap"
3302let lightWeightMap = new LightWeightMap();
3303lightWeightMap.set(1, "A");
3304lightWeightMap.set(2, "B");
3305let res = lightWeightMap.isEmpty();
3306```
3307160.getKeyAt()
3308```
3309import LightWeightMap from "@ohos.util.LightWeightMap"
3310let lightWeightMap = new LightWeightMap();
3311lightWeightMap.set(1, "A");
3312lightWeightMap.set(2, "B");
3313lightWeightMap.set(3, "C");
3314let res = lightWeightMap.getKeyAt(1);
3315```
3316161.keys()
3317```
3318import LightWeightMap from "@ohos.util.LightWeightMap"
3319let lightWeightMap = new LightWeightMap();
3320lightWeightMap.set(1, "A");
3321lightWeightMap.set(2, "B");
3322lightWeightMap.set(3, "C");
3323let res = lightWeightMap.keys();
3324```
3325161.setAll()
3326```
3327import LightWeightMap from "@ohos.util.LightWeightMap"
3328let lightWeightMap = new LightWeightMap();
3329lightWeightMap.set(1, "A");
3330lightWeightMap.set(2, "B");
3331lightWeightMap.set(3, "C");
3332lightWeightMap.set(4, "D");
3333lightWeightMap.set(5, "E");
3334let lightWeightMap1 = new LightWeightMap();
3335lightWeightMap1.set(6, "A");
3336lightWeightMap1.set(7, "B");
3337lightWeightMap.setAll(lightWeightMap1);
3338```
3339162.set()
3340```
3341import LightWeightMap from "@ohos.util.LightWeightMap"
3342let lightWeightMap = new LightWeightMap();
3343lightWeightMap.set(1, "A");
3344lightWeightMap.set(2, "B");
3345```
3346163.remove()
3347```
3348import LightWeightMap from "@ohos.util.LightWeightMap"
3349let lightWeightMap = new LightWeightMap();
3350lightWeightMap.set(1, "A");
3351lightWeightMap.set(2, "B");
3352let res = lightWeightMap.remove(2);
3353```
3354164.removeAt()
3355```
3356import LightWeightMap from "@ohos.util.LightWeightMap"
3357let lightWeightMap = new LightWeightMap();
3358lightWeightMap.set(1, "A");
3359lightWeightMap.set(2, "B");
3360let res = lightWeightMap.removeAt(1);
3361```
3362165.clear()
3363```
3364import LightWeightMap from "@ohos.util.LightWeightMap"
3365let lightWeightMap = new LightWeightMap();
3366lightWeightMap.set(1, "A");
3367lightWeightMap.set(2, "B");
3368lightWeightMap.clear();
3369```
3370166.setValueAt()
3371```
3372import LightWeightMap from "@ohos.util.LightWeightMap"
3373let lightWeightMap = new LightWeightMap();
3374lightWeightMap.set(1, "A");
3375lightWeightMap.set(2, "B");
3376lightWeightMap.setValueAt(0, "a");
3377```
3378167.forEach()
3379```
3380import LightWeightMap from "@ohos.util.LightWeightMap"
3381let lightWeightMap = new LightWeightMap();
3382lightWeightMap.set(1, "A");
3383lightWeightMap.set(2, "B");
3384lightWeightMap.set(3, "C");
3385lightWeightMap.set(4, "D");
3386lightWeightMap.set(5, "E");
3387let arr = [];
3388lightWeightMap.forEach((value, index) => {
3389    arr.push(value);
3390});
3391```
3392168.[Symbol.iterator]()
3393```
3394import LightWeightMap from "@ohos.util.LightWeightMap"
3395let lightWeightMap = new LightWeightMap();
3396lightWeightMap.set(1, "A");
3397lightWeightMap.set(2, "B");
3398lightWeightMap.set(3, "C");
3399lightWeightMap.set(4, "D");
3400lightWeightMap.set(5, "E");
3401let iters = lightWeightMap[Symbol.iterator]();
3402```
3403169.toString()
3404```
3405import LightWeightMap from "@ohos.util.LightWeightMap"
3406let lightWeightMap = new LightWeightMap();
3407lightWeightMap.set(1, "A");
3408lightWeightMap.set(2, "B");
3409lightWeightMap.set(3, "C");
3410let res = lightWeightMap.toString();
3411```
3412170.getValueAt()
3413```
3414import LightWeightMap from "@ohos.util.LightWeightMap"
3415let lightWeightMap = new LightWeightMap();
3416lightWeightMap.set(1, "A");
3417lightWeightMap.set(2, "B");
3418lightWeightMap.set(3, "C");
3419let res = lightWeightMap.getValueAt(1);
3420```
3421171.values()
3422```
3423import LightWeightMap from "@ohos.util.LightWeightMap"
3424let lightWeightMap = new LightWeightMap();
3425lightWeightMap.set(1, "A");
3426lightWeightMap.set(2, "B");
3427lightWeightMap.set(3, "C");
3428let res = lightWeightMap.values();
3429```
3430172.add()
3431```
3432import LightWeightSet from "@ohos.util.LightWeightSet"
3433let lightWeightSet = new LightWeightSet();
3434lightWeightSet.add(1);
3435```
3436173.addAll()
3437```
3438import LightWeightSet from "@ohos.util.LightWeightSet"
3439let lightWeightSet = new LightWeightSet();
3440lightWeightSet.add(1);
3441lightWeightSet.add(2);
3442lightWeightSet.add(3);
3443lightWeightSet.add(4);
3444lightWeightSet.add(5);
3445let lightWeightSet1 = new LightWeightSet();
3446lightWeightSet1.add(6);
3447lightWeightSet1.add(7);
3448let res1 = lightWeightSet.addAll(lightWeightSet1);
3449```
3450174.hasAll()
3451```
3452import LightWeightSet from "@ohos.util.LightWeightSet"
3453let lightWeightSet = new LightWeightSet();
3454lightWeightSet.add("a");
3455lightWeightSet.add("b");
3456lightWeightSet.add("c");
3457lightWeightSet.add("e");
3458let lightWeightSet1 = new LightWeightSet();
3459lightWeightSet1.add("a");
3460lightWeightSet1.add("d");
3461let res = lightWeightSet.hasAll(lightWeightSet1);
3462```
3463175.has()
3464```
3465import LightWeightSet from "@ohos.util.LightWeightSet"
3466let lightWeightSet = new LightWeightSet();
3467lightWeightSet.add("a");
3468lightWeightSet.add("b");
3469lightWeightSet.add("c");
3470let res = lightWeightSet.has("a");
3471```
3472176.equal()
3473```
3474import LightWeightSet from "@ohos.util.LightWeightSet"
3475let lightWeightSet = new LightWeightSet();
3476lightWeightSet.add(1);
3477lightWeightSet.add(2);
3478lightWeightSet.add(3);
3479let obj = [1,2,3];
3480let res = lightWeightSet.equal(obj);
3481```
3482177.increaseCapacityTo()
3483```
3484import LightWeightSet from "@ohos.util.LightWeightSet"
3485let lightWeightSet = new LightWeightSet();
3486lightWeightSet.add(1);
3487lightWeightSet.add(2);
3488lightWeightSet.add(3);
3489let res = lightWeightSet.increaseCapacityTo(20);
3490```
3491178.getIndexOf()
3492```
3493import LightWeightSet from "@ohos.util.LightWeightSet"
3494let lightWeightSet = new LightWeightSet();
3495lightWeightSet.add(1);
3496lightWeightSet.add(2);
3497lightWeightSet.add(3);
3498let res = lightWeightSet.getIndexOf(2);
3499```
3500179.remove()
3501```
3502import LightWeightSet from "@ohos.util.LightWeightSet"
3503let lightWeightSet = new LightWeightSet();
3504lightWeightSet.add(1);
3505lightWeightSet.add(2);
3506lightWeightSet.add(3);
3507let res = lightWeightSet.remove(1);
3508```
3509180.removeAt()
3510```
3511import LightWeightSet from "@ohos.util.LightWeightSet"
3512let lightWeightSet = new LightWeightSet();
3513lightWeightSet.add(1);
3514lightWeightSet.add(2);
3515lightWeightSet.add(3);
3516let res = lightWeightSet.removeAt(1);
3517```
3518181.clear()
3519```
3520import LightWeightSet from "@ohos.util.LightWeightSet"
3521let lightWeightSet = new LightWeightSet();
3522lightWeightSet.add(1);
3523lightWeightSet.add(2);
3524lightWeightSet.add(3);
3525lightWeightSet.clear();
3526```
3527182.forEach()
3528```
3529import LightWeightSet from "@ohos.util.LightWeightSet"
3530let lightWeightSet = new LightWeightSet();
3531lightWeightSet.add(1);
3532lightWeightSet.add(2);
3533lightWeightSet.add(3);
3534lightWeightSet.add(4);
3535lightWeightSet.add(5);
3536let arr = [];
3537lightWeightSet.forEach((value, index) => {
3538    arr.push(value);
3539});
3540```
3541183.[Symbol.iterator]()
3542```
3543import LightWeightSet from "@ohos.util.LightWeightSet"
3544let lightWeightSet = new LightWeightSet();
3545lightWeightSet.add(1);
3546lightWeightSet.add(2);
3547lightWeightSet.add(3);
3548let res = lightWeightSet[Symbol.iterator]();
3549```
3550184.toString()
3551```
3552import LightWeightSet from "@ohos.util.LightWeightSet"
3553let lightWeightSet = new LightWeightSet();
3554lightWeightSet.add(1);
3555lightWeightSet.add(2);
3556lightWeightSet.add(3);
3557let res = lightWeightSet.toString();
3558```
3559185.toArray()
3560```
3561import LightWeightSet from "@ohos.util.LightWeightSet"
3562let lightWeightSet = new LightWeightSet();
3563lightWeightSet.add(1);
3564lightWeightSet.add(2);
3565lightWeightSet.add(3);
3566let res = lightWeightSet.toArray();
3567```
3568186.getValueAt()
3569```
3570import LightWeightSet from "@ohos.util.LightWeightSet"
3571let lightWeightSet = new LightWeightSet();
3572lightWeightSet.add(1);
3573lightWeightSet.add(2);
3574lightWeightSet.add(3);
3575let res = lightWeightSet.getValueAt(1);
3576```
3577187.values()
3578```
3579import LightWeightSet from "@ohos.util.LightWeightSet"
3580let lightWeightSet = new LightWeightSet();
3581lightWeightSet.add(1);
3582lightWeightSet.add(2);
3583lightWeightSet.add(3);
3584let res = lightWeightSet.values();
3585```
3586188.entries()
3587```
3588import LightWeightSet from "@ohos.util.LightWeightSet"
3589let lightWeightSet = new LightWeightSet();
3590lightWeightSet.add(1);
3591lightWeightSet.add(2);
3592lightWeightSet.add(3);
3593let res = lightWeightSet.entries();
3594```
3595189.isEmpty()
3596```
3597import LightWeightSet from "@ohos.util.LightWeightSet"
3598let lightWeightSet = new LightWeightSet();
3599lightWeightSet.add(1);
3600lightWeightSet.add(2);
3601lightWeightSet.add(3);
3602let res = lightWeightSet.isEmpty();
3603```
3604190.add()
3605```
3606import LinkedList from "@ohos.util.LinkedList"
3607let linkedList = new LinkedList();
3608linkedList.add("四");
3609```
3610191.insert()
3611```
3612import LinkedList from "@ohos.util.LinkedList"
3613let linkedList = new LinkedList();
3614linkedList.add("a");
3615linkedList.add("b");
3616linkedList.add("c");
3617linkedList.add("a");
3618linkedList.add("b");
3619let res = linkedList.insert(3, "d");
3620```
3621192.get()
3622```
3623import LinkedList from "@ohos.util.LinkedList"
3624let linkedList = new LinkedList();
3625linkedList.add("a");
3626linkedList.add("b");
3627linkedList.add("c");
3628let res1 = linkedList.get(2);
3629```
3630193.addFirst()
3631```
3632import LinkedList from "@ohos.util.LinkedList"
3633let linkedList = new LinkedList();
3634linkedList.add("a");
3635linkedList.add("b");
3636linkedList.add("c");
3637linkedList.addFirst("e");
3638```
3639194.removeFirst()
3640```
3641import LinkedList from "@ohos.util.LinkedList"
3642let linkedList = new LinkedList();
3643linkedList.add("a");
3644linkedList.add("b");
3645linkedList.add("c");
3646let res = linkedList.removeFirst();
3647```
3648195.removeLast()
3649```
3650import LinkedList from "@ohos.util.LinkedList"
3651let linkedList = new LinkedList();
3652linkedList.add("a");
3653linkedList.add("b");
3654linkedList.add("c");
3655let res = linkedList.removeLast();
3656```
3657196.has()
3658```
3659import LinkedList from "@ohos.util.LinkedList"
3660let linkedList = new LinkedList();
3661linkedList.add("a");
3662linkedList.add("b");
3663linkedList.add("c");
3664let res = linkedList.has(1);
3665```
3666197.getIndexOf()
3667```
3668import LinkedList from "@ohos.util.LinkedList"
3669let linkedList = new LinkedList();
3670linkedList.add("a");
3671linkedList.add("b");
3672linkedList.add("c");
3673let res = linkedList.getIndexOf("b");
3674```
3675198.removeByIndex()
3676```
3677import LinkedList from "@ohos.util.LinkedList"
3678let linkedList = new LinkedList();
3679linkedList.add("a");
3680linkedList.add("b");
3681linkedList.add("c");
3682let res = linkedList.removeByIndex(2);
3683```
3684199.remove()
3685```
3686import LinkedList from "@ohos.util.LinkedList"
3687let linkedList = new LinkedList();
3688linkedList.add("a");
3689linkedList.add("b");
3690linkedList.add("c");
3691let res = linkedList.remove("a");
3692```
3693200.removeFirstFound()
3694```
3695import LinkedList from "@ohos.util.LinkedList"
3696let linkedList = new LinkedList();
3697linkedList.add("a");
3698linkedList.add("b");
3699linkedList.add("c");
3700let res = linkedList.removeFirstFound("b");
3701```
3702201.removeLastFound()
3703```
3704import LinkedList from "@ohos.util.LinkedList"
3705let linkedList = new LinkedList();
3706linkedList.add("a");
3707linkedList.add("b");
3708linkedList.add("c");
3709let res = linkedList.removeLastFound("b");
3710```
3711202.getLastIndexOf()
3712```
3713import LinkedList from "@ohos.util.LinkedList"
3714let linkedList = new LinkedList();
3715linkedList.add("a");
3716linkedList.add("b");
3717linkedList.add("c");
3718linkedList.add("a");
3719linkedList.add("b");
3720linkedList.add("b");
3721let res = linkedList.getLastIndexOf("a");
3722```
3723203.getFirst()
3724```
3725import LinkedList from "@ohos.util.LinkedList"
3726let linkedList = new LinkedList();
3727linkedList.add("a");
3728linkedList.add("b");
3729linkedList.add("c");
3730linkedList.add("a");
3731linkedList.add("b");
3732linkedList.add("b");
3733let res = linkedList.getFirst();
3734```
3735204.getLast()
3736```
3737import LinkedList from "@ohos.util.LinkedList"
3738let linkedList = new LinkedList();
3739linkedList.add("a");
3740linkedList.add("b");
3741linkedList.add("c");
3742linkedList.add("a");
3743linkedList.add("b");
3744linkedList.add("b");
3745let res = linkedList.getLast();
3746```
3747205.set()
3748```
3749import LinkedList from "@ohos.util.LinkedList"
3750let linkedList = new LinkedList();
3751linkedList.add("a");
3752linkedList.add("b");
3753linkedList.add("c");
3754let res = linkedList.set(2, "d");
3755```
3756206.forEach()
3757```
3758import LinkedList from "@ohos.util.LinkedList"
3759let linkedList = new LinkedList();
3760linkedList.add(8);
3761linkedList.add("一");
3762linkedList.add("二");
3763linkedList.add(5);
3764let c = [1, 2, 3, 4];
3765linkedList.add(c);
3766linkedList.add(6);
3767linkedList.add("三");
3768linkedList.add("四");
3769let arr = [];
3770linkedList.forEach((item, index) => {
3771    arr.push(item);
3772});
3773```
3774207.clear()
3775```
3776import LinkedList from "@ohos.util.LinkedList"
3777let linkedList = new LinkedList();
3778linkedList.add("a");
3779linkedList.add("b");
3780linkedList.add("c");
3781let res = linkedList.clear();
3782```
3783208.clone()
3784```
3785import LinkedList from "@ohos.util.LinkedList"
3786let linkedList = new LinkedList();
3787linkedList.add("a");
3788linkedList.add("b");
3789linkedList.add("c");
3790let linkedList1 = linkedList.clone();
3791```
3792209.convertToArray()
3793```
3794import LinkedList from "@ohos.util.LinkedList"
3795let linkedList = new LinkedList();
3796linkedList.add(4);
3797linkedList.add(3);
3798linkedList.add(1);
3799linkedList.add(2);
3800linkedList.add(14);
3801let res = linkedList.convertToArray();
3802```
3803210.[Symbol.iterator]()
3804```
3805import LinkedList from "@ohos.util.LinkedList"
3806let linkedList = new LinkedList();
3807linkedList.add("a");
3808linkedList.add("b");
3809linkedList.add("c");
3810linkedList.addFirst("e");
3811let itr = linkedList[Symbol.iterator]();
3812```
3813211.add()
3814```
3815import List from "@ohos.util.List"
3816let list = new List();
3817list.add("四");
3818```
3819212.insert()
3820```
3821import List from "@ohos.util.List"
3822let list = new List();
3823list.add("a");
3824list.add("b");
3825list.add("c");
3826list.add("a");
3827list.add("b");
3828let res = list.insert("d", 3);
3829```
3830213.get()
3831```
3832import List from "@ohos.util.List"
3833let list = new List();
3834list.add("a");
3835list.add("b");
3836list.add("c");
3837list.add("a");
3838let res = list.set(2, "d");
3839let res1 = list.get(2);
3840```
3841214.has()
3842```
3843import List from "@ohos.util.List"
3844let list = new List();
3845list.add("a");
3846list.add("b");
3847let res = list.has(1);
3848```
3849215.getIndexOf()
3850```
3851import List from "@ohos.util.List"
3852let list = new List();
3853list.add("a");
3854list.add("b");
3855list.add("c");
3856list.add("b");
3857let res = list.getIndexOf("b");
3858```
3859216.removeByIndex()
3860```
3861import List from "@ohos.util.List"
3862let list = new List();
3863list.add("a");
3864list.add("b");
3865list.add("c");
3866list.add("b");
3867let res = list.removeByIndex(2);
3868```
3869217.remove()
3870```
3871import List from "@ohos.util.List"
3872let list = new List();
3873list.add("a");
3874list.add("b");
3875list.add("c");
3876list.add("b");
3877let res = list.remove("a");
3878```
3879218.getLastIndexOf()
3880```
3881import List from "@ohos.util.List"
3882let list = new List();
3883list.add("a");
3884list.add("b");
3885list.add("c");
3886list.add("b");
3887let res = list.getLastIndexOf("F");
3888```
3889219.getFirst()
3890```
3891import List from "@ohos.util.List"
3892let list = new List();
3893list.add("a");
3894list.add("b");
3895list.add("c");
3896list.add("b");
3897let res = list.getFirst();
3898```
3899220.getLast()
3900```
3901import List from "@ohos.util.List"
3902let list = new List();
3903list.add("a");
3904list.add("b");
3905list.add("c");
3906list.add("b");
3907let res = list.getLast();
3908```
3909221.set()
3910```
3911import List from "@ohos.util.List"
3912let list = new List();
3913list.add("a");
3914list.add("b");
3915list.add("c");
3916list.add("a");
3917let res = list.set(2, "d");
3918```
3919222.equal()
3920```
3921import List from "@ohos.util.List"
3922let list = new List();
3923let list1 = new List();
3924let res = list.equal(list1);
3925```
3926223.forEach()
3927```
3928import List from "@ohos.util.List"
3929let list = new List();
3930let num = 0;
3931list.forEach((item, index) => {
3932    num++;
3933});
3934```
3935224.sort()
3936```
3937import List from "@ohos.util.List"
3938let list = new List();
3939list.add(4);
3940list.add(3);
3941list.add(1);
3942list.sort((a, b) => a - b);
3943```
3944225.clear()
3945```
3946import List from "@ohos.util.List"
3947let list = new List();
3948list.add(4);
3949list.add(3);
3950list.add(1);
3951list.clear();
3952```
3953226.getSubList()
3954```
3955import List from "@ohos.util.List"
3956let list = new List();
3957list.add(4);
3958list.add(3);
3959list.add(1);
3960list.add(2);
3961list.add(14);
3962let res = list.getSubList(2, 4);
3963```
3964227.replaceAllElements()
3965```
3966import List from "@ohos.util.List"
3967let list = new List();
3968let num = 0;
3969list.replaceAllElements((item, index) => {
3970    num++;
3971});
3972```
3973228.convertToArray()
3974```
3975import List from "@ohos.util.List"
3976let list = new List();
3977const res = list.convertToArray();
3978```
3979229.isEmpty()
3980```
3981import List from "@ohos.util.List"
3982let list = new List();
3983let res = list.isEmpty();
3984```
3985230.[Symbol.iterator]()
3986```
3987import List from "@ohos.util.List"
3988let list = new List();
3989list.add("a");
3990list.add("b");
3991list.add("c");
3992let itr = list[Symbol.iterator]();
3993```
3994231.add()
3995```
3996import PlainArray from "@ohos.util.PlainArray"
3997let plainArray = new PlainArray();
3998plainArray.add(1, "A");
3999```
4000232.clear()
4001```
4002import PlainArray from "@ohos.util.PlainArray"
4003let plainArray = new PlainArray();
4004plainArray.add(1, "A");
4005plainArray.add(2, "B");
4006plainArray.add(3, "C");
4007plainArray.clear();
4008```
4009233.clone()
4010```
4011import PlainArray from "@ohos.util.PlainArray"
4012let plainArray = new PlainArray();
4013plainArray.add(1, "A");
4014plainArray.add(2, "B");
4015plainArray.add(3, "C");
4016let clonePlainarray = plainArray.clone();
4017```
4018234.has()
4019```
4020import PlainArray from "@ohos.util.PlainArray"
4021let plainArray = new PlainArray();
4022plainArray.add(1, "A");
4023plainArray.add(2, "B");
4024plainArray.add(3, "C");
4025let res = plainArray.has(6);
4026```
4027235.get()
4028```
4029import PlainArray from "@ohos.util.PlainArray"
4030let plainArray = new PlainArray();
4031plainArray.add(1, "A");
4032plainArray.add(2, "B");
4033plainArray.add(3, "C");
4034let value = plainArray.get(2);
4035```
4036236.getIndexOfKey()
4037```
4038import PlainArray from "@ohos.util.PlainArray"
4039let plainArray = new PlainArray();
4040plainArray.add(1, "A");
4041plainArray.add(2, "B");
4042plainArray.add(3, "C");
4043let res = plainArray.getIndexOfKey(9);
4044```
4045237.getIndexOfValue()
4046```
4047import PlainArray from "@ohos.util.PlainArray"
4048let plainArray = new PlainArray();
4049plainArray.add(1, "A");
4050plainArray.add(2, "B");
4051plainArray.add(3, "C");
4052let res = plainArray.getIndexOfValue("Asad");
4053```
4054238.isEmpty()
4055```
4056import PlainArray from "@ohos.util.PlainArray"
4057let plainArray = new PlainArray();
4058plainArray.add(1, "A");
4059plainArray.add(2, "B");
4060plainArray.add(3, "C");
4061let res = plainArray.isEmpty();
4062```
4063239.getKeyAt()
4064```
4065import PlainArray from "@ohos.util.PlainArray"
4066let plainArray = new PlainArray();
4067plainArray.add(1, "A");
4068plainArray.add(2, "B");
4069plainArray.add(3, "C");
4070let res = plainArray.getKeyAt(2);
4071```
4072240.remove()
4073```
4074import PlainArray from "@ohos.util.PlainArray"
4075let plainArray = new PlainArray();
4076plainArray.add(1, "A");
4077plainArray.add(2, "B");
4078plainArray.add(3, "C");
4079let res = plainArray.remove(2);
4080```
4081241.removeAt()
4082```
4083import PlainArray from "@ohos.util.PlainArray"
4084let plainArray = new PlainArray();
4085plainArray.add(1, "A");
4086plainArray.add(2, "B");
4087plainArray.add(3, "C");
4088let res = plainArray.removeAt(2);
4089```
4090242.removeRangeFrom()
4091```
4092import PlainArray from "@ohos.util.PlainArray"
4093let plainArray = new PlainArray();
4094plainArray.add(1, "A");
4095plainArray.add(2, "B");
4096plainArray.add(3, "C");
4097plainArray.removeRangeFrom(2, 2);
4098```
4099243.setValueAt()
4100```
4101import PlainArray from "@ohos.util.PlainArray"
4102let plainArray = new PlainArray();
4103plainArray.add(1, "A");
4104plainArray.add(2, "B");
4105plainArray.add(3, "C");
4106plainArray.setValueAt(2, "V");
4107```
4108244.toString()
4109```
4110import PlainArray from "@ohos.util.PlainArray"
4111let plainArray = new PlainArray();
4112plainArray.add(1, "A");
4113plainArray.add(2, "B");
4114plainArray.add(3, "C");
4115let res1 = plainArray.toString();
4116```
4117245.getValueAt()
4118```
4119import PlainArray from "@ohos.util.PlainArray"
4120let plainArray = new PlainArray();
4121plainArray.add(1, "A");
4122plainArray.add(2, "B");
4123plainArray.add(3, "C");
4124let res = plainArray.getValueAt(2);
4125```
4126246.forEach()
4127```
4128import PlainArray from "@ohos.util.PlainArray"
4129let plainArray = new PlainArray();
4130plainArray.add(1, "A");
4131plainArray.add(2, "B");
4132plainArray.add(3, "C");
4133let arr = [];
4134res.forEach((value, index) => {
4135    arr.push(value);
4136});
4137```
4138247.[Symbol.iterator]()
4139```
4140import PlainArray from "@ohos.util.PlainArray"
4141let plainArray = new PlainArray();
4142plainArray.add(1, "A");
4143plainArray.add(2, "B");
4144plainArray.add(3, "C");
4145let iters = plainArray[Symbol.iterator]();
4146```
4147248.add()
4148```
4149import Queue from "@ohos.util.Queue"
4150let queue = new Queue();
4151queue.add("四");
4152```
4153249.getFirst()
4154```
4155import Queue from "@ohos.util.Queue"
4156let queue = new Queue();
4157queue.add("四");
4158let res = queue.getFirst();
4159```
4160250.pop()
4161```
4162import Queue from "@ohos.util.Queue"
4163let queue = new Queue();
4164queue.add("四");
4165let res = queue.pop();
4166```
4167251.forEach()
4168```
4169import Queue from "@ohos.util.Queue"
4170let queue = new Queue();
4171queue.add(1);
4172queue.add(2);
4173queue.add(3);
4174queue.add(4);
4175queue.forEach((item, index) => {
4176    arr.push(item);
4177});
4178```
4179252.[Symbol.iterator]()
4180```
4181import Queue from "@ohos.util.Queue"
4182let queue = new Queue();
4183queue.add("四");
4184let itr = queue[Symbol.iterator]();
4185```
4186253.isEmpty()
4187```
4188import Stack from "@ohos.util.Stack"
4189let stack = new Stack();
4190stack.push(8);
4191stack.push(5);
4192let res = stack.isEmpty();
4193```
4194254.peek()
4195```
4196import Stack from "@ohos.util.Stack"
4197let stack = new Stack();
4198stack.push(1234);
4199let res = stack.peek();
4200```
4201255.pop()
4202```
4203import Stack from "@ohos.util.Stack"
4204let stack = new Stack();
4205stack.push(1234);
4206let res = stack.pop();
4207```
4208256.push()
4209```
4210import Stack from "@ohos.util.Stack"
4211let stack = new Stack();
4212stack.push(12);
4213```
4214257.locate()
4215```
4216import Stack from "@ohos.util.Stack"
4217let stack = new Stack();
4218stack.push("A");
4219stack.push("B");
4220stack.push(1);
4221let res = stack.locate("A");
4222```
4223258.forEach()
4224```
4225import Stack from "@ohos.util.Stack"
4226let stack = new Stack();
4227stack.push(8);
4228stack.push(5);
4229stack.push(c);
4230stack.push(6);
4231stack.forEach((item, index) => {
4232    arr.push(item);
4233});
4234```
4235259.[Symbol.iterator]()
4236```
4237import Stack from "@ohos.util.Stack"
4238let stack = new Stack();
4239stack.push("A");
4240stack.push("B");
4241stack.push(1);
4242let itr = stack[Symbol.iterator]();
4243```
4244260.isEmpty()
4245```
4246import TreeMap from "@ohos.util.TreeMap"
4247let treeMap = new TreeMap();
4248treeMap.set(0, "a");
4249treeMap.set(1, "b");
4250let res = treeMap.isEmpty();
4251```
4252261.hasKey()
4253```
4254import TreeMap from "@ohos.util.TreeMap"
4255let treeMap = new TreeMap();
4256treeMap.set(0, "a");
4257treeMap.set(1, "b");
4258let res = treeMap.hasKey(1);
4259```
4260262.hasValue()
4261```
4262import TreeMap from "@ohos.util.TreeMap"
4263let treeMap = new TreeMap();
4264treeMap.set(0, "a");
4265treeMap.set(1, "b");
4266let res = treeMap.hasValue("a");
4267```
4268263.get()
4269```
4270import TreeMap from "@ohos.util.TreeMap"
4271let treeMap = new TreeMap();
4272treeMap.set(0, "a");
4273treeMap.set(1, "b");
4274let res = treeMap.get(1);
4275```
4276264.getFirstKey()
4277```
4278import TreeMap from "@ohos.util.TreeMap"
4279let treeMap = new TreeMap();
4280treeMap.set(0, "a");
4281treeMap.set(1, "b");
4282let res = treeMap.getFirstKey();
4283```
4284265.getLastKey()
4285```
4286import TreeMap from "@ohos.util.TreeMap"
4287let treeMap = new TreeMap();
4288treeMap.set(0, "a");
4289treeMap.set(1, "b");
4290let res = treeMap.getLastKey();
4291```
4292266.setAll()
4293```
4294import TreeMap from "@ohos.util.TreeMap"
4295let treeMap = new TreeMap();
4296treeMap.set(0, "a");
4297treeMap.set(1, "b");
4298let treeMap1 = new TreeMap();
4299treeMap1.set(0, "a");
4300treeMap1.set(1, "b");
4301treeMap1.set(2, "c");
4302treeMap.setAll(treeMap1);
4303```
4304267.set()
4305```
4306import TreeMap from "@ohos.util.TreeMap"
4307let treeMap = new TreeMap();
4308treeMap.set(0, "a");
4309treeMap.set(1, "b");
4310```
4311268.remove()
4312```
4313import TreeMap from "@ohos.util.TreeMap"
4314let treeMap = new TreeMap();
4315treeMap.set(0, "a");
4316treeMap.set(1, "b");
4317let res = treeMap.remove(1);
4318```
4319269.clear()
4320```
4321import TreeMap from "@ohos.util.TreeMap"
4322let treeMap = new TreeMap();
4323treeMap.set(0, "a");
4324treeMap.set(1, "b");
4325treeMap.clear();
4326```
4327270.getLowerKey()
4328```
4329import TreeMap from "@ohos.util.TreeMap"
4330let treeMap = new TreeMap();
4331treeMap.set(0, "a");
4332treeMap.set(1, "b");
4333let res = treeMap.getLowerKey(1);
4334```
4335271.getHigherKey()
4336```
4337import TreeMap from "@ohos.util.TreeMap"
4338let treeMap = new TreeMap();
4339treeMap.set(0, "a");
4340treeMap.set(1, "b");
4341let res = treeMap.getHigherKey(1);
4342```
4343272.keys()
4344```
4345import TreeMap from "@ohos.util.TreeMap"
4346let treeMap = new TreeMap();
4347treeMap.set(0, "a");
4348treeMap.set(1, "b");
4349let res = treeMap.keys();
4350```
4351273.values()
4352```
4353import TreeMap from "@ohos.util.TreeMap"
4354let treeMap = new TreeMap();
4355treeMap.set(0, "a");
4356treeMap.set(1, "b");
4357let res = treeMap.values();
4358```
4359274.replace()
4360```
4361import TreeMap from "@ohos.util.TreeMap"
4362let treeMap = new TreeMap();
4363treeMap.set(0, "a");
4364treeMap.set(1, "b");
4365let res = treeMap.replace(1, "B");
4366```
4367275.forEach()
4368```
4369import TreeMap from "@ohos.util.TreeMap"
4370let treeMap = new TreeMap();
4371treeMap.set(0, "a");
4372treeMap.set(1, "b");
4373treeMap.set(2, "c");
4374treeMap.set(3, "d");
4375treeMap.set(4, "g");
4376let arr1 = [];
4377treeMap.forEach((value, key) => {
4378    arr1.push(value);
4379});
4380```
4381276.entries()
4382```
4383import TreeMap from "@ohos.util.TreeMap"
4384let treeMap = new TreeMap();
4385treeMap.set(0, "a");
4386treeMap.set(1, "b");
4387treeMap.set(2, "c");
4388let entries = treeMap.entries();
4389```
4390277.[Symbol.iterator]()
4391```
4392import TreeMap from "@ohos.util.TreeMap"
4393let treeMap = new TreeMap();
4394treeMap.set(0, "a");
4395treeMap.set(1, "b");
4396treeMap.set(2, "c");
4397let iters = treeMap[Symbol.iterator]();
4398```
4399278.isEmpty()
4400```
4401import TreeSet from "@ohos.util.TreeSet"
4402let treeSet = new TreeSet();
4403treeSet.add("a");
4404let res = treeSet.isEmpty();
4405```
4406279.has()
4407```
4408import TreeSet from "@ohos.util.TreeSet"
4409let treeSet = new TreeSet();
4410treeSet.add("a");
4411treeSet.add("b");
4412treeSet.add("c");
4413let res = treeSet.has("c");
4414```
4415280.add()
4416```
4417import TreeSet from "@ohos.util.TreeSet"
4418let treeSet = new TreeSet();
4419treeSet.add("a");
4420treeSet.add("b");
4421treeSet.add("c");
4422```
4423281.remove()
4424```
4425import TreeSet from "@ohos.util.TreeSet"
4426let treeSet = new TreeSet();
4427treeSet.add("a");
4428treeSet.add("b");
4429treeSet.add("c");
4430let res = treeSet.remove("c");
4431```
4432282.clear()
4433```
4434import TreeSet from "@ohos.util.TreeSet"
4435let treeSet = new TreeSet();
4436treeSet.add("a");
4437treeSet.add("b");
4438treeSet.add("c");
4439treeSet.clear();
4440```
4441283.getFirstValue()
4442```
4443import TreeSet from "@ohos.util.TreeSet"
4444let treeSet = new TreeSet();
4445treeSet.add("a");
4446treeSet.add("b");
4447treeSet.add("c");
4448let res = treeSet.getFirstValue();
4449```
4450284.getLastValue()
4451```
4452import TreeSet from "@ohos.util.TreeSet"
4453let treeSet = new TreeSet();
4454treeSet.add("a");
4455treeSet.add("b");
4456treeSet.add("c");
4457let res = treeSet.getLastValue();
4458```
4459285.getLowerValue()
4460```
4461import TreeSet from "@ohos.util.TreeSet"
4462let treeSet = new TreeSet();
4463treeSet.add(0);
4464treeSet.add(1);
4465treeSet.add(2);
4466treeSet.add(3);
4467let res = treeSet.getLowerValue(2);
4468```
4469286.getHigherValue()
4470```
4471import TreeSet from "@ohos.util.TreeSet"
4472let treeSet = new TreeSet();
4473treeSet.add(0);
4474treeSet.add(1);
4475treeSet.add(2);
4476treeSet.add(3);
4477let res = treeSet.getHigherValue(3);
4478```
4479287.popFirst()
4480```
4481import TreeSet from "@ohos.util.TreeSet"
4482let treeSet = new TreeSet();
4483treeSet.add(0);
4484treeSet.add(1);
4485treeSet.add(2);
4486treeSet.add(3);
4487let res = treeSet.popFirst();
4488```
4489288.popLast()
4490```
4491import TreeSet from "@ohos.util.TreeSet"
4492let treeSet = new TreeSet();
4493treeSet.add(0);
4494treeSet.add(1);
4495treeSet.add(2);
4496treeSet.add(3);
4497let res = treeSet.popLast();
4498```
4499289.forEach()
4500```
4501import TreeSet from "@ohos.util.TreeSet"
4502let treeSet = new TreeSet();
4503treeSet.add(0);
4504treeSet.add(1);
4505treeSet.add(2);
4506treeSet.add(3);
4507treeSet.add(4);
4508let arr1 = [];
4509treeSet.forEach((value, key) => {
4510    arr1.push(value);
4511});
4512```
4513290.values()
4514```
4515import TreeSet from "@ohos.util.TreeSet"
4516let treeSet = new TreeSet();
4517treeSet.add("a");
4518treeSet.add("b");
4519treeSet.add("c");
4520let res = treeSet.values();
4521```
4522291.entries()
4523```
4524import TreeSet from "@ohos.util.TreeSet"
4525let treeSet = new TreeSet();
4526treeSet.add("a");
4527treeSet.add("b");
4528treeSet.add("c");
4529let res = treeSet.entries();
4530```
4531292.[Symbol.iterator]()
4532```
4533import TreeSet from "@ohos.util.TreeSet"
4534let treeSet = new TreeSet();
4535treeSet.add("a");
4536treeSet.add("b");
4537treeSet.add("c");
4538let res = treeSet[Symbol.iterator]();
4539```
4540
4541## 3. js_sys_module子模块
4542### 3.1. 简介
4543进程主要用于获取进程的相关ID,获取和修改进程的工作目录,退出和关闭进程。 childprocess 对象可用于创建新进程。 主进程可以获取子进程的标准输入输出,发送信号,关闭子进程。
4544### 3.2. 目录
4545
4546```
4547commomlibrary/ets_utils/js_sys_module/
4548├── Class:PROCESS                   # PROCESS类
4549├── Uid                             # Uid属性
4550├── Gid                             # Gid属性
4551├── EUid                            # EUid属性
4552├── EGid                            # EGid属性
4553├── Groups                          # Groups属性
4554├── Pid                             # Pid属性
4555├── Ppid                            # Ppid属性
4556├── chdir()                         # chdir方法
4557├── uptime()                        # uptime方法
4558├── kill()                          # kill方法
4559├── abort()                         # abort方法
4560├── on()                            # on方法
4561├── tid                             # tid方法
4562├── getStartRealtime()              # getStartRealtime方法
4563├── getAvailableCores()             # getAvailableCores方法
4564├── getPastCputime()                # getPastCputime方法
4565├── isIsolatedProcess()             # isIsolatedProcess方法
4566├── is64Bit()                       # is64Bit方法
4567├── isAppUid()                      # isAppUid方法
4568├── getUidForName()                 # getUidForName方法
4569├── getThreadPriority()             # getThreadPriority方法
4570├── getSystemConfig()               # getSystemConfig方法
4571├── getEnvironmentVar()             # getEnvironmentVar方法
4572├── exit()                          # exit方法
4573├── cwd()                           # cwd方法
4574├── off()                           # off方法
4575├── runCmd()                        # runCmd方法
4576└─── Class:CHILDPROCESS             # class of CHILDPROCESS类
4577    ├── close()                     # close方法
4578    ├── kill()                      # kill方法
4579    ├── getOutput()                 # getOutput方法
4580    ├── getErrorOutput()            # getErrorOutput方法
4581    ├── wait()                      # wait方法
4582    ├── killed                      # killed属性
4583    ├── pid                         # pid属性
4584    ├── ppid                        # ppid属性
4585    └── exitCode                    # exitCode属性
4586|—— Class:CONSOLE
4587    ├── debug()                     # debug方法
4588    ├── log()                       # log方法
4589    ├── info()                      # info方法
4590    ├── warn()                      # warn方法
4591    ├── error()                     # error方法
4592    ├── assert()                    # assert方法
4593    ├── count()                     # count方法
4594    ├── countReset()                # countReset方法
4595    ├── dir()                       # dir方法
4596    ├── dirxml()                    # dirxml方法
4597    ├── group()                     # group方法
4598    ├── groupCollapsed()            # groupCollapsed方法
4599    ├── groupEnd()                  # groupEnd方法
4600    ├── table()                     # table方法
4601    ├── time()                      # time方法
4602    ├── timeEnd()                   # timeEnd方法
4603    ├── timeLog()                   # timeLog方法
4604    ├── trace()                     # trace方法
4605|—— Class:TIMER
4606    ├── setInterval()               # setInterval方法
4607    ├── setTimeout()                # setTimeout方法
4608    ├── clearInterval()             # clearInterval方法
4609    ├── clearTimeout()              # clearTimeout方法
4610```
4611
4612### 3.3. 说明
4613
4614#### 3.3.1. 接口说明
4615| 接口名 | 说明 |
4616| -------- | -------- |
4617| const uid :number | 返回进程的数字用户 ID。 |
4618| const gid :number | 返回进程的数字组 ID。 |
4619| const euid :number | 返回进程的数字有效用户身份。 |
4620| const egid :number | 返回 node.js 进程的数字有效组 ID。 |
4621| const groups :number[] |  返回具有补充组 ID 的数组。 |
4622| const pid :number | 返回进程的PID。 |
4623| const ppid :number |  返回当前进程的父进程的PID。 |
4624| chdir(dir:string) :void | 更改 node.js 进程的当前工作目录。 |
4625| uptime() :number |  返回当前系统已经运行的秒数。 |
4626| Kill(pid:number, signal:number) :boolean | 将信号发送到识别的进程PID,true表示发送成功。 |
4627| abort() :void | 导致 node.js 进程立即退出并生成核心文件。 |
4628| on(type:string ,listener:EventListener) :void | 用于存储用户触发的事件。 |
4629| exit(code:number):void | 导致 node.js 进程立即退出。 |
4630| cwd():string |  返回 node.js 进程的当前工作目录。 |
4631| off(type: string): boolean | 清除用户存储的事件。 True 表示清算成功。 |
4632| runCmd(command: string, options?: { timeout : number, killSignal : number \| string, maxBuffer : number }): ChildProcess |通过runcmd,你可以fork一个新进程来运行一个shell并返回childprocess对象。 第一个参数command指的是要运行的shell,第二个参数options指的是子进程的一些运行参数。 这些参数主要是指 timeout、killsignal 和 maxbuffer。 如果设置了timeout,则子进程会在超时后发送killsignal信号。 Maxbuffer 用于限制可以接收的最大 stdout 和 stderr 大小。 |
4633| wait(): Promise\<number> | 用于等待子进程运行并返回promise对象,其值为子进程的退出码。 |
4634| getOutput(): Promise\<Uint8Array> |  用于获取子进程的标准输出。 |
4635| getErrorOutput(): Promise\<Uint8Array> | 用于获取子进程的标准错误输出。 |
4636| const tid:number | 返回进程的 TID。 |
4637| getStartRealtime() :number | 获取从系统启动到进程启动所经过的实时时间(以毫秒为单位)。 |
4638| getAvailableCores() :number[] | 获取多核设备上当前进程可用的 CPU 内核。 |
4639| getPastCputime() :number | 获取从进程开始到当前时间的 CPU 时间(以毫秒为单位)。 |
4640| isIsolatedProcess(): boolean | 检查进程是否被隔离。 |
4641| is64Bit(): boolean | 检查进程是否在 64 位环境中运行。 |
4642| isAppUid(v:number): boolean | 检查指定的 uid 是否属于特定应用程序。 |
4643| getUidForName(v:string): number | 根据用户名获取用户所属的用户组ID |
4644| getThreadPriority(v:number): number | 根据指定的 TID 获取线程优先级。 |
4645| getSystemConfig(name:number): number | 根据指定的系统配置名称获取系统的配置。 |
4646| getEnvironmentVar(name:string): string | 根据环境变量的名称获取对应的值。 |
4647| close(): void | 用于关闭正在运行的子进程。 |
4648| kill(signal: number \| string): void |  用于向子进程发送信号。 |
4649| readonly killed: boolean | 表示信号是否发送成功,true表示信号发送成功。 |
4650| readonly exitCode: number | 表示子进程的退出代码。 |
4651| readonly pid: number | 表示子进程ID。 |
4652| readonly ppid: number | 代表主进程ID。 |
4653| debug(message: string, ...arguments: any[]): void | 打印debug信息。 |
4654| log(message: string, ...arguments: any[]): void | 打印log信息。 |
4655| info(message: string, ...arguments: any[]): void | 打印info信息。 |
4656| warn(message: string, ...arguments: any[]): void | 打印warn信息。 |
4657| error(message: string, ...arguments: any[]): void | 打印error信息。 |
4658| assert(value?: Object, ...arguments: Object[]): void | 若value为假,打印后续内容。 |
4659| count(label?: string): void | 对label名计数。 |
4660| countReset(label?: string): void | 清除label名的计数。 |
4661| dir(dir?: Object): void | 打印对象内容。 |
4662| dirxml(...arguments: Object[]): void | 打印日志。 |
4663| group(...arguments: Object[]): void | 缩进一组。 |
4664| groupCollapsed(...arguments: Object[]): void | 缩进一组。 |
4665| groupEnd(): void | 取消缩进一组。 |
4666| table(tableData?: Object): void | 以表格形式打印数据。 |
4667| time(label?: string): void | 开始计时。 |
4668| timeEnd(label?: string): void | 结束计时。 |
4669| timeLog(label?: string, ...arguments: Object[]): void | 打印当前计时。 |
4670| trace(...arguments: Object[]): void | 打印当前栈。 |
4671|  setInterval(handler: Function \| string, delay: number, ...arguments: any[]): number | 定时调用回调函数。 |
4672|  setTimeout(handler: Function \| string, delay?: number, ...arguments: any[]): number | 计时结束调用回调函数。 |
4673|  clearInterval(intervalID?: number): void | 清除定时回调。 |
4674|  clearTimeout(timeoutID?: number): void | 清除计时回调。 |
4675
4676#### 3.3.2. 使用说明
4677
4678各接口使用方法如下:
46791.uid()
4680```
4681uid(){
4682    var res =  Process.uid;
4683}
4684```
46852.gid()
4686```
4687gid(){
4688    var result = Process.gid;
4689}
4690```
46913.euid()
4692```
4693euid(){
4694    var and = Process.euid;
4695}
4696```
46974.egid()
4698```
4699egid(){
4700    var resb = Process.egid;
4701}
4702```
47035.groups()
4704```
4705groups(){
4706    var answer = Process.groups;
4707}
4708```
47096.pid()
4710```
4711pid(){
4712    var result = Process.pid;
4713}
4714```
47157.ppid()
4716```
4717ppid(){
4718    var result = Process.ppid;
4719}
4720```
47218.chdir()
4722```
4723chdir(){
4724    Process.chdir("123456");
4725}
4726```
47279.uptime()
4728```
4729uptime(){
4730    var num = Process.uptime();
4731}
4732```
473310.kill()
4734```
4735kill(){
4736    var ansu = Process.kill(5,23);
4737}
4738```
473911.abort()
4740```
4741abort(){
4742    Process.abort();
4743}
4744```
474512.on()
4746```
4747on(){
4748    function add(num){
4749        var value = num + 5;
4750        return value;
4751    }
4752    Process.on("add",add);
4753}
4754```
475513.exit()
4756```
4757exit(){
4758    Process.exit(15);
4759}
4760```
476114.Cwd()
4762```
4763Cwd(){
4764    var result = Process.cwd();
4765}
4766```
476715.off()
4768
4769```
4770off(){
4771    var result =  Process.off("add");
4772}
4773```
477416.runCmd()
4775```
4776runCmd(){
4777    var child = process.runCmd('echo abc')
4778    // killSignal can be a number or a string
4779    var child = process.runCmd('echo abc;', {killSignal : 'SIGKILL'});
4780    var child = process.runCmd('sleep 5; echo abc;', {timeout : 1, killSignal : 9, maxBuffer : 2})
4781}
4782```
478317.wait()
4784```
4785wait()
4786{
4787    var child = process.runCmd('ls')
4788    var status = child.wait();
4789    status.then(val => {
4790        console.log(val);
4791    })
4792}
4793```
479418.getOutput()
4795```
4796getOutput(){
4797    var child = process.runCmd('echo bcd;');
4798    var res = child.getOutput();
4799    child.wait();
4800    res.then(val => {
4801        console.log(val);
4802    })
4803}
4804```
480519.getErrorOutput()
4806```
4807getErrorOutput(){
4808    var child = process.runCmd('makdir 1.txt'); // execute an error command
4809    var res = child.getErrorOutput();
4810    child.wait();
4811    res.then(val => {
4812        console.log(val);
4813    })
4814}
4815```
481620.close()
4817```
4818close(){
4819    var child =  process.runCmd('ls; sleep 5s;')
4820    var result = child.close()
4821}
4822```
482321.kill()
4824```
4825kill(){
4826    var child =  process.runCmd('ls; sleep 5s;')
4827    var result = child.kill('SIGHUP');
4828    child.wait();
4829    var temp = child.killed;
4830}
4831```
483222.killed
4833```
4834{
4835    var child = process.runCmd('ls; sleep 5;')
4836    child.kill(3);
4837    var killed_ = child.killed;
4838    child.wait();
4839}
4840```
484123.exitCode
4842```
4843{
4844    var child = process.runCmd('ls; sleep 5;')
4845    child.kill(9);
4846    child.wait();
4847    var exitCode_ = child.exitCode;
4848}
4849```
485024.pid
4851```
4852pid
4853{
4854    var child = process.runCmd('ls; sleep 5;')
4855    var pid_ = child.pid;
4856    child.wait();
4857}
4858```
485925.ppid
4860```
4861ppid
4862{
4863    var child = process.runCmd('ls; sleep 5;')
4864    var ppid_ = child.ppid;
4865    child.wait();
4866}
4867```
486826.tid
4869```
4870tid(){
4871    var ansu = Process.tid;
4872}
4873```
487427.isIsolatedProcess()
4875```
4876isIsolatedProcess(){
4877    var ansu = Process.isIsolatedProcess()();
4878}
4879```
488028.isAppUid()
4881```
4882isAppUid(){
4883    var ansu = Process.isAppUid(10000);
4884}
4885```
488629.is64Bit()
4887```
4888is64Bit(){
4889    var ansu = Process.is64Bit();
4890}
4891```
489230.getUidForName()
4893```
4894getUidForName(){
4895    var buf = "root";
4896    var ansu = Process.getUidForName(buf);
4897}
4898```
489931.getEnvironmentVar()
4900```
4901getEnvironmentVar(){
4902    var ansu = Process.getEnvironmentVar('USER');
4903}
4904```
490532.getAvailableCores()
4906```
4907getAvailableCores(){
4908    var ansu = Process.getAvailableCores();
4909}
4910```
491133.getThreadPriority()
4912```
4913getThreadPriority(){
4914    var result = Process.getTid();
4915    var ansu = getThreadPriority(result);
4916}
4917```
491834.getStartRealtime()
4919```
4920getStartRealtime(){
4921    var ansu = Process.getStartRealtime();
4922}
4923```
492435.getPastCputime()
4925```
4926getPastCputime(){
4927    var ansu = Process.getPastCputime();
4928}
4929```
493036.getSystemConfig()
4931```
4932getSystemConfig(){
4933    var _SC_ARG_MAX = 0;
4934    var ansu = Process.getSystemConfig(_SC_ARG_MAX)
4935}
4936```
493737.console.debug()
4938```
4939console.debug("print debug log");
4940}
4941```
494238.console.log()
4943```
4944console.debug("print log");
4945}
4946```
494739.console.info()
4948```
4949console.debug("print info log");
4950}
4951```
495240.console.warn()
4953```
4954console.debug("print warn log");
4955}
4956```
495741.console.error()
4958```
4959console.debug("print error log");
4960}
4961```
496242.console.assert()
4963```
4964for (let number = 2; number <= 5; number++) {
4965    console.assert(number % 2 === 0, "error");
4966}
4967```
496843.console.count()
4969```
4970console.count("myObj");
4971```
497244.console.countReset()
4973```
4974console.count("myObj");
4975console.countReset("myObj");
4976```
497745.console.dir()
4978```
4979function cat(name, age, score){
4980  this.name = name;
4981  this.age = age;
4982  this.score = score;
4983}
4984var c = new cat("ohos", 2, [6,8,7]);
4985console.dir(c);
4986```
498746.console.dirxml()
4988```
4989console.xml("print log");
4990```
499147.console.group()
4992```
4993console.group();
4994```
499548.console.groupCollapsed()
4996```
4997console.groupCollapsed();
4998```
499949.console.groupEnd()
5000```
5001console.groupEnd();
5002```
500350.console.table()
5004```
5005var languages = {
5006  csharp: { name: "C#", paradigm: "undefined" },
5007  fsharp: { name: "F#", paradigm: "functional" }
5008};
5009console.table(languages);
5010```
501151.console.time()
5012```
5013console.time("timer1");
5014```
501552.console.timeEnd()
5016```
5017console.time("timer1");
5018console.timeEnd("timer1");
5019```
502053.console.timeLog()
5021```
5022console.time("timer1");
5023console.timeLog("timer1");
5024```
502554.console.trace()
5026```
5027console.trace();
5028```
502955.setInterval()
5030```
5031function callback() {
5032  console.log("setInterval");
5033};
5034setInterval(callback, 100);
5035```
503655.setTimeout()
5037```
5038function callback() {
5039  console.log("setTimeout");
5040};
5041setTimeout(callback, 100);
5042```
504355.clearInterval()
5044```
5045function callback() {
5046  console.log("clearInterval");
5047};
5048var myVar = setInterval(callback, 1000);
5049clearInterval(myVar);
5050```
505156.clearTimeout()
5052```
5053function callback() {
5054  console.log("clearTimeout");
5055};
5056var myVar = setTimeout(callback, 1000);
5057clearTimeout(myVar);
5058```
5059
5060## 4. js_concurrent_module子模块
5061
5062### 4.1. 简介
5063
5064worker能够让js拥有多线程的能力,通过postMessage完成worker线程与宿主线程通信。
5065
5066### 4.2. 接口说明
5067接口实现详见:js_concurrent_module/worker
5068
5069#### 4.2.1. Worker对象描述
5070
5071宿主线程用于与worker线程通信的Object对象。
5072
5073##### 4.2.1.1. 接口
5074
50751.
5076
5077- 接口名
5078
5079|constructor(scriptURL:string, options?:WorkerOptions) | 构造函数 |
5080|---|---|
5081
5082- 使用示例
5083
5084通过判断存放worker.ts的workers目录是否与pages目录同级(以下简称目录同级)和创建项目的模型类别,共有以下四种新建Worker的方式:
5085
5086(1) FA模型: 目录同级
5087```
5088import worker from "@ohos.worker";
5089const workerInstance = new worker.Worker("workers/worker.js", {name:"first worker"});
5090```
5091(2) FA模型: 目录不同级(以workers目录放置pages目录前一级为例)
5092```
5093import worker from "@ohos.worker";
5094const workerInstance = new worker.Worker("../workers/worker.js", {name:"first worker"});
5095```
5096(3)  Stage模型: 目录同级
5097```
5098import worker from "@ohos.worker";
5099const workerInstance = new worker.Worker('entry/ets/workers/worker.ts');
5100```
5101(4) Stage模型: 目录不同级(以workers目录放置pages目录后一级为例)
5102```
5103import worker from "@ohos.worker";
5104const workerInstance = new worker.Worker('entry/ets/pages/workers/worker.ts');
5105```
5106对于Stage模型中scriptURL——"entry/ets/workers/worker.ts"的解释:
5107- entry: 为module.json5中module中name属性的值;
5108- ets: 表明当前工程使用的语言;
5109- worker.ts: 创建worker.ts文件或者worker.js文件都可以。
5110
5111另外,需在工程的模块级build-profile.json5文件的buildOption属性中添加配置信息,主要分为下面两种情况:
5112
5113(1) 目录同级(**此情况不添加亦可**)
5114
5115FA模型:
5116```
5117  "buildOption": {
5118    "sourceOption": {
5119      "workers": [
5120        "./src/main/ets/MainAbility/workers/worker.js"
5121      ]
5122    }
5123  }
5124```
5125Stage模型:
5126```
5127  "buildOption": {
5128    "sourceOption": {
5129      "workers": [
5130        "./src/main/ets/workers/worker.ts"
5131      ]
5132    }
5133  }
5134```
5135(2) 目录不同级(**此情况必须添加**)
5136
5137FA模型:
5138```
5139  "buildOption": {
5140    "sourceOption": {
5141      "workers": [
5142        "./src/main/ets/workers/worker.js"
5143      ]
5144    }
5145  }
5146```
5147Stage模型(workers目录放在pages目录里为例):
5148```
5149  "buildOption": {
5150    "sourceOption": {
5151      "workers": [
5152        "./src/main/ets/pages/workers/worker.ts"
5153      ]
5154    }
5155  }
5156```
51572.
5158
5159- 接口名
5160
5161| postMessage(message:Object, options?:PostMessageOptions)  | 向worker线程发送消息  |
5162|---|---|
5163| postMessage(message:Object, transfer:ArrayBuffer[])  | 向worker线程发送消息  |
5164
5165- 使用示例
5166
5167```
5168// 示例一
5169import worker from "@ohos.worker"
5170const worker = new worker.Worker("workers/worker.js");
5171worker.postMessage("hello world");
5172
5173// 示例二
5174import worker from "@ohos.worker"
5175const worker = new worker.Worker("workers/worker.js");
5176var buffer = new ArrayBuffer(8);
5177worker.postMessage(buffer, [buffer]);
5178```
5179
51803.
5181
5182- 接口名
5183
5184| on(type:string, listener:EventListener)  | 向worker添加一个事件监听  |
5185|---|---|
5186
5187- 使用示例
5188
5189```
5190import worker from "@ohos.worker"
5191const worker = new worker.Worker("workers/worker.js");
5192worker.on("alert", (e)=>{
5193     console.log("worker on...");
5194});
5195```
5196
51974.
5198
5199- 接口名
5200
5201| once(type:string, listener:EventListener)  | 向worker添加一个事件监听, 事件监听只执行一次便自动删除  |
5202|---|---|
5203
5204- 使用示例
5205
5206```
5207import worker from "@ohos.worker"
5208const worker = new worker.Worker("workers/worker.js");
5209worker.once("alert", (e)=>{
5210    console.log("worker once...");
5211});
5212```
5213
52145.
5215
5216- 接口名
5217
5218| off(type:string, listener?:EventListener)  | 删除worker的事件监听  |
5219|---|---|
5220
5221- 使用示例
5222
5223```
5224import worker from "@ohos.worker"
5225const worker = new worker.Worker("workers/worker.js");
5226worker.off("alert");
5227```
5228
52296.
5230
5231- 接口名
5232
5233| terminate()  | 关闭worker线程,终止worker发送消息  |
5234|---|---|
5235
5236- 使用示例
5237
5238```
5239import worker from "@ohos.worker"
5240const worker = new worker.Worker("workers/worker.js");
5241worker.terminate();
5242```
5243
52447.
5245
5246- 接口名
5247
5248| removeEventListener(type:string, listener?:EventListener)  | 删除worker的事件监听  |
5249|---|---|
5250
5251- 使用示例
5252
5253```
5254import worker from "@ohos.worker"
5255const worker = new worker.Worker("workers/worker.js");
5256worker.removeEventListener("alert", (e)=>{
5257    console.log("worker removeEventListener...");
5258});
5259```
5260
52618.
5262
5263- 接口名
5264
5265| dispatchEvent(event: Event)  | 分发定义在worker的事件  |
5266|---|---|
5267
5268- 使用示例
5269
5270```
5271import worker from "@ohos.worker"
5272const worker = new worker.Worker("workers/worker.js");
5273worker.dispatchEvent({type:"alert"});
5274```
5275
52769.
5277
5278- 接口名
5279
5280| removeAllListener()  | 删除worker的所有事件监听  |
5281|---|---|
5282
5283- 使用示例
5284
5285```
5286import worker from "@ohos.worker"
5287const worker = new worker.Worker("workers/worker.js");
5288worker.removeAllListener();
5289```
5290
5291##### 4.2.1.2. 属性
5292
52931.
5294
5295- 属性名
5296
5297| onexit?:(code:number)=>void  | worker退出时被调用的事件处理程序,处理程序在宿主线程中执行  |
5298|---|---|
5299
5300- 使用示例
5301
5302```
5303import worker from "@ohos.worker"
5304const worker = new worker.Worker("workers/worker.js");
5305worker.onexit = function(e) {
5306    console.log("onexit...");
5307}
5308```
5309
53102.
5311
5312- 属性名
5313
5314| onerror?:(ev:ErrorEvent)=>void  | worker在执行过程中发生异常被调用的事件处理程序,处理程序在宿主线程中执行  |
5315|---|---|
5316
5317- 使用示例
5318
5319```
5320import worker from "@ohos.worker"
5321const worker = new worker.Worker("workers/worker.js");
5322worker.onerror = function(e) {
5323    console.log("onerror...");
5324}
5325```
5326
53273.
5328
5329- 属性名
5330
5331| onmessage?:(ev:MessageEvent)=>void  | 宿主线程收到来自其创建的worker通过parentPort.postMessage接口发送的消息时被调用的事件处理程序, 处理程序在宿主线程中执行 |
5332|---|---|
5333
5334- 使用示例
5335
5336```
5337import worker from "@ohos.worker"
5338const worker = new worker.Worker("workers/worker.js");
5339worker.onmessage = function(e) {
5340    console.log("onmessage...");
5341}
5342```
5343
53444.
5345
5346- 属性名
5347
5348| onmessageerror?:(event:MessageEvent)=>void  | worker对象接收到一条无法序列化的消息时被调用的事件处理程序, 处理程序在宿主线程中执行 |
5349|---|---|
5350
5351- 使用示例
5352
5353```
5354import worker from "@ohos.worker"
5355const worker = new worker.Worker("workers/worker.js");
5356worker.onmessageerror = function(e) {
5357    console.log("onmessageerror...");
5358}
5359```
5360
5361#### 4.2.2. parentPort对象描述
5362
5363worker线程用于与宿主线程通信的Object对象。
5364
5365##### 4.2.2.1. 接口
5366
53671.
5368
5369- 接口名
5370
5371| postMessage(message:Object, options?:PostMessageOptions)  | 向宿主线程发送消息 |
5372|---|---|
5373| postMessage(message:Object, transfer:ArrayBuffer[])  | 向宿主线程发送消息  |
5374
5375- 使用示例
5376
5377```
5378// main.js
5379import worker from "@ohos.worker"
5380const worker = new worker.Worker("workers/worker.js");
5381worker.postMessage("hello world");
5382
5383// worker.js
5384import worker from "@ohos.worker"
5385const parentPort = worker.parentPort;
5386parentPort.onmessage = function(e) {
5387    parentPort.postMessage("hello world from worker.js");
5388}
5389```
5390
53912.
5392
5393- 接口名
5394
5395| close()  | 关闭worker线程,终止worker接收消息  |
5396|---|---|
5397
5398- 使用示例
5399
5400```
5401// main.js
5402import worker from "@ohos.worker"
5403const worker = new worker.Worker("workers/worker.js");
5404worker.postMessage("hello world");
5405
5406// worker.js
5407import worker from "@ohos.worker"
5408const parentPort = worker.parentPort;
5409parentPort.onmessage = function(e) {
5410    parentPort.close();
5411}
5412```
5413
5414##### 4.2.2.2. 属性
5415
54161.
5417
5418- 属性名
5419
5420| onmessage?:(event:MessageEvent)=>void  | 宿主线程收到来自其创建的worker通过worker.postMessage接口发送的消息时被调用的事件处理程序,处理程序在worker线程中执行  |
5421|---|---|
5422
5423- 使用示例
5424
5425```
5426// main.js
5427import worker from "@ohos.worker"
5428const worker = new worker.Worker("workers/worker.js");
5429worker.postMessage("hello world");
5430
5431// worker.js
5432import worker from "@ohos.worker"
5433const parentPort = worker.parentPort;
5434parentPort.onmessage = function(e) {
5435    console.log("receive main.js message");
5436}
5437```
5438
54392.
5440
5441- 属性名
5442
5443| onerror?:(ev: ErrorEvent)=>void  | worker在执行过程中发生异常被调用的事件处理程序,处理程序在worker线程中执行  |
5444|---|---|
5445
5446- 使用示例
5447
5448```
5449// main.js
5450import worker from "@ohos.worker"
5451const worker = new worker.Worker("workers/worker.js");
5452worker.postMessage("hello world");
5453
5454// worker.js
5455import worker from "@ohos.worker"
5456const parentPort = worker.parentPort;
5457parentPort.onerror = function(e) {
5458    console.log("onerror...");
5459}
5460
5461```
5462
54633.
5464
5465- 属性名
5466
5467| onmessageerror?:(event: MessageEvent)=>void  | worker对象接收到一条无法被反序列化的消息时被调用的事件处理程序, 处理程序在worker线程中执行  |
5468|---|---|
5469
5470- 使用示例
5471
5472```
5473// main.js
5474import worker from "@ohos.worker"
5475const worker = new worker.Worker("workers/worker.js");
5476worker.postMessage("hello world");
5477
5478// worker.js
5479import worker from "@ohos.worker"
5480const parentPort = worker.parentPort;
5481parentPort.onmessageerror = function(e) {
5482    console.log("onmessageerror...");
5483}
5484```
5485
5486### 4.3. 涉及仓
5487
5488[arkcompiler_ets_runtime](https://gitee.com/openharmony/arkcompiler_ets_runtime/blob/master/README_zh.md)
5489[arkui_ace_engine](https://gitee.com/openharmony/arkui_ace_engine/blob/master/README_zh.md)
5490[arkui_napi](https://gitee.com/openharmony/arkui_napi/blob/master/README_zh.md)
5491
5492
5493# 相关仓
5494
5495[ets_utils子系统](https://gitee.com/openharmony/commonlibrary_ets_utils/blob/master/README.md)
5496