update zh-cn/application-dev/reference/apis/js-apis-util.md.

Signed-off-by: N葛亚芳 <geyafang@huawei.com>

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

 # util工具函数
 
+该模块主要提供常用的工具函数，实现字符串编解码（TextEncoder，TextDecoder）、有理数运算（RationalNumber）、缓冲区管理（LruBuffer）、范围判断（Scope）、Base64编解码（Base64）、内置对象类型检查（Types）等功能。
 
-> ![icon-note.gif](public_sys-resources/icon-note.gif) **说明：**
+> **说明：**
+>
 > 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
 
 
-该模块主要提供常用的工具函数，实现字符串编解码（TextEncoder，TextDecoder）、有理数运算（RationalNumber）、缓冲区管理（LruBuffer）、范围判断（Scope）、Base64编解码（Base64）、内置对象类型检查（Types）等功能。
-
-
 ## 导入模块
 
-```
+```js
 import util from '@ohos.util';
 ```
 
@@ -44,13 +43,14 @@ console.log(res);
 
 ## util.printf<sup>(deprecated)</sup>
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[util.format9+](#utilformat9)替代。
-
 printf(format: string,  ...args: Object[]): string
 
 通过式样化字符串对输入的内容按特定格式输出。
 
+> **说明：**
+>
+> 从API Version 7开始支持，从API Version 9开始废弃，建议使用[util.format<sup>9+</sup>](#utilformat9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -67,6 +67,7 @@ printf(format: string,  ...args: Object[]): string
 | string | 按特定格式式样化后的字符串。 |
 
 **示例：**
+
   ```js
   let res = util.printf("%s", "hello world!");
   console.log(res);
@@ -94,21 +95,22 @@ errnoToString(errno: number): string
 
 **示例：**
 
-  ```js
+```js
 let errnum = 10; // 10 : a system error number
 let result = util.errnoToString(errnum);
 console.log("result = " + result);
-  ```
+```
 
 ## util.getErrorString<sup>(deprecated)</sup>
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[util.errnoToString9+](#utilerrnotostring9)替代。
-
 getErrorString(errno: number): string
 
 获取系统错误码对应的详细信息。
 
+> **说明：**
+>
+> 从API Version 7开始支持，从API Version 9开始废弃，建议使用[util.errnoToString<sup>9+</sup>](#utilerrnotostring9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -124,6 +126,7 @@ getErrorString(errno: number): string
 | string | 错误码对应的详细信息。 |
 
 **示例：**
+
   ```js
   let errnum = 10; // 10 : a system error number
   let result = util.getErrorString(errnum);
@@ -151,6 +154,7 @@ callbackWrapper(original: Function): (err: Object, value: Object )=&gt;void
 | Function | 返回一个第一个参数是拒绝原因（如果&nbsp;Promise&nbsp;已解决，则为&nbsp;null），第二个参数是已解决的回调函数。 |
 
 **示例：**
+
   ```js
   async function promiseFn() {
       return Promise.reject('value');
@@ -184,6 +188,7 @@ promisify(original: (err: Object, value: Object) =&gt; void): Function
 | Function | 采用遵循常见的错误优先的回调风格的函数（也就是将&nbsp;(err,&nbsp;value)&nbsp;=&gt;&nbsp;...&nbsp;回调作为最后一个参数），并返回一个返回&nbsp;promise&nbsp;的函数。 |
 
 **示例：**
+
   ```js
   function aysnFun(str1, str2) {
     if (typeof str1 === 'object' && typeof str2 === 'object') {
@@ -202,11 +207,12 @@ promisify(original: (err: Object, value: Object) =&gt; void): Function
 
 promiseWrapper(original: (err: Object, value: Object) =&gt; void): Object
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[util.promisify9+](#utilpromisify9)替代。
-
 对异步函数处理并返回一个promise的版本。
 
+> **说明：**
+>
+> 此接口不可用，建议使用[util.promisify<sup>9+</sup>](#utilpromisify9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -242,6 +248,7 @@ randomUUID(entropyCache?: boolean): string
 | string | 表示此UUID的字符串。 |
 
 **示例：**
+
   ```js
   let uuid = util.randomUUID(true);
   console.log("RFC 4122 Version 4 UUID:" + uuid);
@@ -270,6 +277,7 @@ randomBinaryUUID(entropyCache?: boolean): Uint8Array
 | Uint8Array | 表示此UUID的Uint8Array值。 |
 
 **示例：**
+
   ```js
   let uuid = util.randomBinaryUUID(true);
   console.log(JSON.stringify(uuid));
@@ -298,6 +306,7 @@ parseUUID(uuid: string): Uint8Array
 | Uint8Array | 返回表示此UUID的Uint8Array，如果解析失败，则抛出SyntaxError。 |
 
 **示例：**
+
   ```js
   let uuid = util.parseUUID("84bdf796-66cc-4655-9b89-d6218d100f9c");
   console.log(JSON.stringify(uuid));
@@ -311,7 +320,7 @@ parseUUID(uuid: string): Uint8Array
 
 **系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。
 
-| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| 名称 | 类型 | 可读 | 可写 | 说明 |
 | -------- | -------- | -------- | -------- | -------- |
 | encoding | string | 是 | 否 | 编码格式。<br/>-&nbsp;支持格式：utf-8、ibm866、iso-8859-2、iso-8859-3、iso-8859-4、iso-8859-5、iso-8859-6、iso-8859-7、iso-8859-8、iso-8859-8-i、iso-8859-10、iso-8859-13、iso-8859-14、iso-8859-15、koi8-r、koi8-u、macintosh、windows-874、windows-1250、windows-1251、windows-1252、windows-1253、windows-1254、windows-1255、windows-1256、windows-1257、windows-1258、x-mac-cyrilli、gbk、gb18030、big5、euc-jp、iso-2022-jp、shift_jis、euc-kr、utf-16be、utf-16le。 |
 | fatal | boolean | 是 | 否 | 是否显示致命错误。 |
@@ -331,6 +340,8 @@ create(encoding?: string,options?: { fatal?: boolean; ignoreBOM?: boolean },): T
 
 替代有参构造功能。
 
+**系统能力：** SystemCapability.Utils.Lang
+
 **参数：**
 
 | 参数名   | 类型   | 必填 | 说明                                             |
@@ -338,7 +349,7 @@ create(encoding?: string,options?: { fatal?: boolean; ignoreBOM?: boolean },): T
 | encoding | string | 否   | 编码格式。                                       |
 | options  | Object | 否   | 编码相关选项参数，存在两个属性fatal和ignoreBOM。 |
 
-  **表1.1**options
+**表1.1**options
 
 | 名称      | 参数类型 | 必填 | 说明               |
 | --------- | -------- | ---- | ------------------ |
@@ -347,20 +358,21 @@ create(encoding?: string,options?: { fatal?: boolean; ignoreBOM?: boolean },): T
 
 **示例：**
 
-  ```js
+```js
 let textDecoder = new util.TextDecoder()
 textDecoder.create('utf-8', { ignoreBOM : true });
-  ```
+```
 
 ### constructor<sup>(deprecated)</sup>
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[constructor9+](#constructor9)替代。
-
 constructor(encoding?: string, options?: { fatal?: boolean; ignoreBOM?: boolean },)
 
 TextDecoder的构造函数。
 
+> **说明：**
+>
+> 从API Version 7开始支持，从API Version 9开始废弃，建议使用[constructor<sup>9+</sup>](#constructor9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -378,6 +390,7 @@ TextDecoder的构造函数。
 | ignoreBOM | boolean | 否 | 是否忽略BOM标记。 |
 
 **示例：**
+
   ```js
   let textDecoder = new util.TextDecoder("utf-8",{ignoreBOM: true});
   ```
@@ -397,7 +410,7 @@ decode(input: Uint8Array, options?: { stream?: false }): string
 | input | Uint8Array | 是 | 符合格式需要解码的数组。 |
 | options | Object | 否 | 解码相关选项参数。 |
 
-  **表2** options
+**表2** options
 
 | 名称 | 参数类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
@@ -410,6 +423,7 @@ decode(input: Uint8Array, options?: { stream?: false }): string
 | string | 解码后的数据。 |
 
 **示例：**
+
   ```js
   let textDecoder = new util.TextDecoder("utf-8",{ignoreBOM: true});
   let result = new Uint8Array(6);
@@ -440,7 +454,7 @@ decodeWithStream(input: Uint8Array, options?: { stream?: boolean }): string
 | input | Uint8Array | 是 | 符合格式需要解码的数组。 |
 | options | Object | 否 | 解码相关选项参数。 |
 
-  **表2** options
+**表2** options
 
 | 名称 | 参数类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
@@ -453,6 +467,7 @@ decodeWithStream(input: Uint8Array, options?: { stream?: boolean }): string
 | string | 解码后的数据。 |
 
 **示例：**
+
   ```js
   let textDecoder = new util.TextDecoder("utf-8",{ignoreBOM: true});
   let result = new Uint8Array(6);
@@ -474,7 +489,7 @@ decodeWithStream(input: Uint8Array, options?: { stream?: boolean }): string
 
 **系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。
 
-| 名称 | 参数类型 | 可读 | 可写 | 说明 |
+| 名称 | 类型 | 可读 | 可写 | 说明 |
 | -------- | -------- | -------- | -------- | -------- |
 | encoding | string | 是 | 否 | 编码格式，默认值是utf-8。 |
 
@@ -488,6 +503,7 @@ TextEncoder的构造函数。
 **系统能力：** SystemCapability.Utils.Lang
 
 **示例：**
+
   ```js
   let textEncoder = new util.TextEncoder();
   ```
@@ -504,7 +520,7 @@ encodeInto(input?: string): Uint8Array
 
 | 参数名 | 类型   | 必填 | 说明               |
 | ------ | ------ | ---- | ------------------ |
-| input  | string | 是   | 需要编码的字符串。 |
+| input  | string | 否   | 需要编码的字符串。 |
 
 **返回值：**
 
@@ -523,20 +539,21 @@ result = textEncoder.encodeInto("\uD800¥¥");
 
 ### encode<sup>(deprecated)</sup>
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[encodeInto9+](#encodeinto9)替代。
-
 encode(input?: string): Uint8Array
 
 通过输入参数编码后输出对应文本。
 
+> **说明：**
+>
+> 从API Version 7开始支持，从API Version 9开始废弃，建议使用[encodeInto<sup>9+</sup>](#encodeinto9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
 
 | 参数名 | 类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
-| input | string | 是 | 需要编码的字符串。 |
+| input | string | 否 | 需要编码的字符串。 |
 
 **返回值：**
 
@@ -585,13 +602,14 @@ result = that.encodeInto('abcd', dest)
 
 ### encodeInto<sup>(deprecated)</sup>
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[encodeIntoUint8Array9+](#encodeintouint8array9)替代。
-
 encodeInto(input: string, dest: Uint8Array, ): { read: number; written: number }
 
 放置生成的UTF-8编码文本。
 
+> **说明：**
+>
+> 从API Version 7开始支持，从API Version 9开始废弃，建议使用[encodeIntoUint8Array<sup>9+</sup>](#encodeintouint8array9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -628,13 +646,13 @@ RationalNumber的构造函数。
 
 **示例：**
 
-  ```js
+```js
 let rationalNumber = new util.RationalNumber();
-  ```
+```
 
 ### parseRationalNumber<sup>9+</sup>
 
-parseRationalNumber(numerator: number,denominator: number)
+parseRationalNumber(numerator: number,denominator: number): RationalNumber
 
 替代原有参构造的参数处理。
 
@@ -649,20 +667,21 @@ parseRationalNumber(numerator: number,denominator: number)
 
 **示例：**
 
-  ```js
+```js
 let rationalNumber = new util.RationalNumber();
 rationalNumber.parseRationalNumber(1,2)
-  ```
-
-### constructor<sup>8+(deprecated)</sup>
+```
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[constructor9+](#constructor9)替代。
+### constructor<sup>(deprecated)</sup>
 
 constructor(numerator: number,denominator: number)
 
 RationalNumber的构造函数。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[constructor<sup>9+</sup>](#constructor9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -674,9 +693,9 @@ RationalNumber的构造函数。
 
 **示例：**
 
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  ```
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+```
 
 ### createRationalFromString<sup>8+</sup>
 
@@ -699,10 +718,11 @@ static createRationalFromString​(rationalString: string): RationalNumber​
 | object | 返回有理数类的对象。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let rational = util.RationalNumber.createRationalFromString("3/4");
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+let rational = util.RationalNumber.createRationalFromString("3/4");
+```
 
 ### compare<sup>9+</sup>
 
@@ -732,15 +752,16 @@ let rational = util.RationalNumber.createRationalFromString("3/4");
 let result = rationalNumber.compare(rational);
   ```
 
-### compareTo<sup>8+</sup><sup>(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[compare9+](#compare9)替代。
+### compareTo<sup>(deprecated)</sup>
 
 compareTo​(another: RationalNumber): number​
 
 将当前的RationalNumber对象与给定的对象进行比较。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[compare<sup>9+</sup>](#compare9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -756,11 +777,12 @@ compareTo​(another: RationalNumber): number​
 | number | 如果两个对象相等，则返回0；如果给定对象小于当前对象，则返回1；如果给定对象大于当前对象，则返回-1。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let rational = util.RationalNumber.createRationalFromString("3/4");
-  let result = rationalNumber.compareTo(rational);
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+let rational = util.RationalNumber.createRationalFromString("3/4");
+let result = rationalNumber.compareTo(rational);
+```
 
 ### valueOf<sup>8+</sup>
 
@@ -777,10 +799,11 @@ valueOf(): number
 | number | 返回整数或者浮点数的值。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let result = rationalNumber.valueOf();
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+let result = rationalNumber.valueOf();
+```
 
 ### equals<sup>8+</sup>
 
@@ -803,11 +826,12 @@ equals​(obj: Object): boolean
 | boolean | 如果给定对象与当前对象相同，则返回true；否则返回false。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let rational = util.RationalNumber.createRationalFromString("3/4");
-  let result = rationalNumber.equals(rational);
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+let rational = util.RationalNumber.createRationalFromString("3/4");
+let result = rationalNumber.equals(rational);
+```
 
 ### getCommonFactor<sup>9+</sup>
 
@@ -832,19 +856,21 @@ getCommonFactor(number1: number,number2: number): number
 
 **示例：**
 
-  ```js
+```js
 let rationalNumber = new util.RationalNumber(1,2);
 let result = util.RationalNumber.getCommonFactor(4,6);
-  ```
+```
 
-### getCommonDivisor<sup>8+(deprecated)</sup>
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[getCommonFactor9+](#getcommonfactor9)替代。
+### getCommonDivisor<sup>(deprecated)</sup>
 
 static getCommonDivisor​(number1: number,number2: number): number
 
 获取两个指定整数的最大公约数。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[getCommonFactor<sup>9+</sup>](#getcommonfactor9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -861,10 +887,11 @@ static getCommonDivisor​(number1: number,number2: number): number
 | number | 返回两个给定数字的最大公约数。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let result = util.RationalNumber.getCommonDivisor(4,6);
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+let result = util.RationalNumber.getCommonDivisor(4,6);
+```
 
 ### getNumerator<sup>8+</sup>
 
@@ -881,10 +908,11 @@ getNumerator​(): number
 | number | 返回RationalNumber对象的分子的值。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let result = rationalNumber.getNumerator();
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+let result = rationalNumber.getNumerator();
+```
 
 ### getDenominator<sup>8+</sup>
 
@@ -901,10 +929,11 @@ getDenominator​(): number
 | number | 返回RationalNumber对象的分母的值。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let result = rationalNumber.getDenominator();
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+lett result = rationalNumber.getDenominator();
+```
 
 ### isZero<sup>8+</sup>
 
@@ -921,10 +950,11 @@ isZero​():boolean
 | boolean | 如果当前对象表示的值为0，则返回true；否则返回false。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let result = rationalNumber.isZero();
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+let result = rationalNumber.isZero();
+```
 
 ### isNaN<sup>8+</sup>
 
@@ -941,10 +971,11 @@ isNaN​(): boolean
 | boolean | 如果分母和分子都为0，则返回true；否则返回false。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let result = rationalNumber.isNaN();
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+let result = rationalNumber.isNaN();
+```
 
 ### isFinite<sup>8+</sup>
 
@@ -961,10 +992,11 @@ isFinite​():boolean
 | boolean | 如果分母不为0，则返回true；否则返回false。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let result = rationalNumber.isFinite();
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+let result = rationalNumber.isFinite();
+```
 
 ### toString<sup>8+</sup>
 
@@ -981,10 +1013,11 @@ toString​(): string
 | string | 返回Numerator/Denominator格式的字符串，例如3/5，如果当前对象的分子和分母都为0，则返回NaN。 |
 
 **示例：**
-  ```js
-  let rationalNumber = new util.RationalNumber(1,2);
-  let result = rationalNumber.toString();
-  ```
+
+```js
+let rationalNumber = new util.RationalNumber(1,2);
+let result = rationalNumber.toString();
+```
 
 
 ## LRUCache<sup>9+</sup>
@@ -999,12 +1032,12 @@ toString​(): string
 
 **示例：**
 
-  ```js
+```js
 let pro = new util.LRUCache();
 pro.put(2,10);
 pro.put(1,8);
 let result = pro.length;
-  ```
+```
 
 ### constructor<sup>9+</sup>
 
@@ -1022,9 +1055,9 @@ constructor(capacity?: number)
 
 **示例：**
 
-  ```js
+```js
 let lrubuffer= new util.LRUCache();
-  ```
+```
 
 
 ### updateCapacity<sup>9+</sup>
@@ -1043,10 +1076,10 @@ updateCapacity(newCapacity: number): void
 
 **示例：**
 
-  ```js
+```js
 let pro = new util.LRUCache();
 let result = pro.updateCapacity(100);
-  ```
+```
 
 
 ### toString<sup>9+</sup>
@@ -1065,13 +1098,13 @@ toString(): string
 
 **示例：**
 
-  ```js
+```js
 let pro = new util.LRUCache();
 pro.put(2,10);
 pro.get(2);
 pro.remove(20);
 let result = pro.toString();
-  ```
+```
 
 
 ### getCapacity<sup>9+</sup>
@@ -1274,7 +1307,7 @@ get(key: K): V | undefined
 
 | 类型                     | 说明                                                         |
 | ------------------------ | ------------------------------------------------------------ |
-| V&nbsp;\|&nbsp;undefined | 如果指定的键存在于缓冲区中，则返回与键关联的值；否则返回undefined。 |
+| V \| undefined | 如果指定的键存在于缓冲区中，则返回与键关联的值；否则返回undefined。 |
 
 **示例：**
 
@@ -1402,10 +1435,10 @@ afterRemoval(isEvict: boolean,key: K,value: V,newValue: V): void
 
 | 参数名   | 类型    | 必填 | 说明                                                         |
 | -------- | ------- | ---- | ------------------------------------------------------------ |
-| isEvict  | boolean | 否   | 因容量不足而调用该方法时，参数值为true，其他情况为false。    |
+| isEvict  | boolean | 是   | 因容量不足而调用该方法时，参数值为true，其他情况为false。    |
 | key      | K       | 是   | 表示删除的键。                                               |
 | value    | V       | 是   | 表示删除的值。                                               |
-| newValue | V       | 否   | 如果已调用put方法并且要添加的键已经存在，则参数值是关联的新值。其他情况下参数值为空。 |
+| newValue | V       | 是   | 如果已调用put方法并且要添加的键已经存在，则参数值是关联的新值。其他情况下参数值为空。 |
 
 **示例：**
 
@@ -1432,7 +1465,7 @@ lru.afterRemoval(false,10,30,null);
 
 ### contains<sup>9+</sup>
 
-contains(key: K): boolean
+contains(key: object): boolean
 
 检查当前缓冲区是否包含指定的键。
 
@@ -1440,9 +1473,9 @@ contains(key: K): boolean
 
 **参数：**
 
-| 参数名 | 类型 | 必填 | 说明             |
-| ------ | ---- | ---- | ---------------- |
-| key    | K    | 是   | 表示要检查的键。 |
+| 参数名 | 类型   | 必填 | 说明             |
+| ------ | ------ | ---- | ---------------- |
+| key    | object | 是   | 表示要检查的键。 |
 
 **返回值：**
 
@@ -1531,10 +1564,11 @@ pro.put(2,10);
 let result = pro[Symbol.iterator]();
   ```
 
-## LruBuffer<sup>8+(deprecated)</sup>
+## LruBuffer<sup>(deprecated)</sup>
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[LRUCache9+](#lrucache9)替代。
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[LRUCache<sup>9+</sup>](#lrucache9)替代。
 
 ### 属性
 
@@ -1545,6 +1579,7 @@ let result = pro[Symbol.iterator]();
 | length | number | 是 | 否 | 当前缓冲区中值的总数。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
@@ -1552,15 +1587,16 @@ let result = pro[Symbol.iterator]();
   let result = pro.length;
   ```
 
-### constructor<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[constructor9+](#constructor9)替代。
+### constructor<sup>(deprecated)</sup>
 
 constructor(capacity?: number)
 
 默认构造函数用于创建一个新的LruBuffer实例，默认容量为64。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[constructor<sup>9+</sup>](#constructor9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -1570,19 +1606,21 @@ constructor(capacity?: number)
 | capacity | number | 否 | 指示要为缓冲区自定义的容量。 |
 
 **示例：**
+
   ```js
   let lrubuffer= new util.LruBuffer();
   ```
 
-### updateCapacity<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[updateCapacity9+](#updatecapacity9)替代。
+### updateCapacity<sup>(deprecated)</sup>
 
 updateCapacity(newCapacity: number): void
 
 将缓冲区容量更新为指定容量，如果newCapacity小于或等于0，则抛出异常。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[updateCapacity<sup>9+</sup>](#updatecapacity9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -1592,20 +1630,22 @@ updateCapacity(newCapacity: number): void
 | newCapacity | number | 是 | 指示要为缓冲区自定义的容量。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   let result = pro.updateCapacity(100);
   ```
 
-### toString<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[toString9+](#tostring9)替代。
+### toString<sup>(deprecated)</sup>
 
 toString(): string
 
 返回对象的字符串表示形式。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[toString<sup>9+</sup>](#tostring9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -1615,6 +1655,7 @@ toString(): string
 | string | 返回对象的字符串表示形式。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
@@ -1623,15 +1664,16 @@ toString(): string
   let result = pro.toString();
   ```
 
-### getCapacity<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[getCapacity9+](#getcapacity9)替代。
+### getCapacity<sup>(deprecated)</sup>
 
 getCapacity(): number
 
 获取当前缓冲区的容量。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[getCapacity<sup>9+</sup>](#getcapacity9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -1646,18 +1688,20 @@ getCapacity(): number
   let result = pro.getCapacity();
   ```
 
-### clear<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[clear9+](#clear9)替代。
+### clear<sup>(deprecated)</sup>
 
 clear(): void
 
 从当前缓冲区清除键值对。后续会调用afterRemoval()方法执行后续操作。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[clear<sup>9+</sup>](#clear9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
@@ -1665,15 +1709,16 @@ clear(): void
   pro.clear();
   ```
 
-### getCreateCount<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[getCreateCount9+](#getcreatecount9)替代。
+### getCreateCount<sup>(deprecated)</sup>
 
 getCreateCount(): number
 
 获取createDefault()返回值的次数。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[getCreateCount<sup>9+</sup>](#getcreatecount9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -1683,21 +1728,23 @@ getCreateCount(): number
 | number | 返回createDefault()返回值的次数。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(1,8);
   let result = pro.getCreateCount();
   ```
 
-### getMissCount<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[getMissCount9+](#getmisscount9)替代。
+### getMissCount<sup>(deprecated)</sup>
 
 getMissCount(): number
 
 获取查询值不匹配的次数。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[getMissCount<sup>9+</sup>](#getmisscount9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -1707,6 +1754,7 @@ getMissCount(): number
 | number | 返回查询值不匹配的次数。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
@@ -1714,15 +1762,16 @@ getMissCount(): number
   let result = pro.getMissCount();
   ```
 
-### getRemovalCount<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[getRemovalCount9+](#getremovalcount9)替代。
+### getRemovalCount<sup>(deprecated)</sup>
 
 getRemovalCount(): number
 
 获取从缓冲区中逐出值的次数。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[getRemovalCount<sup>9+</sup>](#getremovalcount9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -1732,6 +1781,7 @@ getRemovalCount(): number
 | number | 返回从缓冲区中驱逐的次数。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
@@ -1740,15 +1790,16 @@ getRemovalCount(): number
   let result = pro.getRemovalCount();
   ```
 
-### getMatchCount<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[getMatchCount9+](#getmatchcount9)替代。
+### getMatchCount<sup>(deprecated)</sup>
 
 getMatchCount(): number
 
 获取查询值匹配成功的次数。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[getMatchCount<sup>9+</sup>](#getmatchcount9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -1758,6 +1809,7 @@ getMatchCount(): number
 | number | 返回查询值匹配成功的次数。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
@@ -1765,15 +1817,16 @@ getMatchCount(): number
   let result = pro.getMatchCount();
   ```
 
-### getPutCount<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[getPutCount9+](#getputcount9)替代。
+### getPutCount<sup>(deprecated)</sup>
 
 getPutCount(): number
 
 获取将值添加到缓冲区的次数。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[getPutCount<sup>9+</sup>](#getputcount9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -1783,21 +1836,23 @@ getPutCount(): number
 | number | 返回将值添加到缓冲区的次数。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
   let result = pro.getPutCount();
   ```
 
-### isEmpty<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[isEmpty9+](#isempty9)替代。
+### isEmpty<sup>(deprecated)</sup>
 
 isEmpty(): boolean
 
 检查当前缓冲区是否为空。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[isEmpty<sup>9+</sup>](#isempty9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -1807,21 +1862,23 @@ isEmpty(): boolean
 | boolean | 如果当前缓冲区不包含任何值，则返回true。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
   let result = pro.isEmpty();
   ```
 
-### get<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[get9+](#get9)替代。
+### get<sup>(deprecated)</sup>
 
 get(key: K): V | undefined
 
 表示要查询的键。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[get<sup>9+</sup>](#get9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -1837,21 +1894,23 @@ get(key: K): V | undefined
 | V&nbsp;\|&nbsp;undefined | 如果指定的键存在于缓冲区中，则返回与键关联的值；否则返回undefined。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
   let result  = pro.get(2);
   ```
 
-### put<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[put9+](#put9)替代。
+### put<sup>(deprecated)</sup>
 
 put(key: K,value: V): V
 
 将键值对添加到缓冲区。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[put<sup>9+</sup>](#put9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -1868,19 +1927,21 @@ put(key: K,value: V): V
 | V | 返回与添加的键关联的值；如果要添加的键已经存在，则返回原始值，如果键或值为空，则抛出此异常。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   let result = pro.put(2,10);
   ```
 
-### values<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[values9+](#values9)替代。
+### values<sup>(deprecated)</sup>
 
 values(): V[]
 
-获取当前缓冲区中所有值从最近访问到最近最少访问的顺序列表 。
+获取当前缓冲区中所有值从最近访问到最近最少访问的顺序列表。
+
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[values<sup>9+</sup>](#values9)替代。
 
 **系统能力：** SystemCapability.Utils.Lang
 
@@ -1891,6 +1952,7 @@ values(): V[]
 | V&nbsp;[] | 按从最近访问到最近最少访问的顺序返回当前缓冲区中所有值的列表。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
@@ -1899,15 +1961,16 @@ values(): V[]
   let result = pro.values();
   ```
 
-### keys<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[keys9+](#keys9)替代。
+### keys<sup>(deprecated)</sup>
 
 keys(): K[]
 
 获取当前缓冲区中所有键从最近访问到最近最少访问的升序列表。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[keys<sup>9+</sup>](#keys9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -1923,15 +1986,16 @@ keys(): K[]
   let result = pro.keys();
   ```
 
-### remove<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[remove9+](#remove9)替代。
+### remove<sup>(deprecated)</sup>
 
 remove(key: K): V | undefined
 
 从当前缓冲区中删除指定的键及其关联的值。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[remove<sup>9+</sup>](#remove9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -1953,27 +2017,29 @@ remove(key: K): V | undefined
   let result = pro.remove(20);
   ```
 
-### afterRemoval<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[afterRemoval9+](#afterremoval9)替代。
+### afterRemoval<sup>(deprecated)</sup>
 
 afterRemoval(isEvict: boolean,key: K,value: V,newValue: V): void
 
 删除值后执行后续操作。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[afterRemoval<sup>9+</sup>](#afterremoval9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
 
 | 参数名 | 类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
-| isEvict | boolean | 否 | 因容量不足而调用该方法时，参数值为true，其他情况为false。 |
+| isEvict | boolean | 是 | 因容量不足而调用该方法时，参数值为true，其他情况为false。 |
 | key | K | 是 | 表示删除的键。 |
 | value | V | 是 | 表示删除的值。 |
-| newValue | V | 否 | 如果已调用put方法并且要添加的键已经存在，则参数值是关联的新值。其他情况下参数值为空。 |
+| newValue | V | 是 | 如果已调用put方法并且要添加的键已经存在，则参数值是关联的新值。其他情况下参数值为空。 |
 
 **示例：**
+
   ```js
   let arr = [];
   class ChildLruBuffer<K, V> extends util.LruBuffer<K, V>
@@ -1994,15 +2060,17 @@ afterRemoval(isEvict: boolean,key: K,value: V,newValue: V): void
   lru.afterRemoval(false,10,30,null);
   ```
 
-### contains<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[contains9+](#contains9)替代。
+### contains<sup>(deprecated)</sup>
 
 contains(key: K): boolean
 
 检查当前缓冲区是否包含指定的键。
 
+
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[contains<sup>9+</sup>](#contains9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2018,21 +2086,23 @@ contains(key: K): boolean
 | boolean | 如果缓冲区包含指定的键，则返回&nbsp;true。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
   let result = pro.contains(20);
   ```
 
-### createDefault<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[createDefault9+](#createdefault9)替代。
+### createDefault<sup>(deprecated)</sup>
 
 createDefault(key: K): V
 
 如果未计算特定键的值，则执行后续操作，参数表示丢失的键，返回与键关联的值。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[createDefault<sup>9+</sup>](#createdefault9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2048,20 +2118,22 @@ createDefault(key: K): V
 | V | 返回与键关联的值。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   let result = pro.createDefault(50);
   ```
 
-### entries<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[entries9+](#entries9)替代。
+### entries<sup>(deprecated)</sup>
 
 entries(): IterableIterator&lt;[K,V]&gt;
 
 允许迭代包含在这个对象中的所有键值对。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[entries<sup>9+</sup>](#entries9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -2071,21 +2143,23 @@ entries(): IterableIterator&lt;[K,V]&gt;
 | [K,&nbsp;V] | 返回一个可迭代数组。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
   let result = pro.entries();
   ```
 
-### [Symbol.iterator]<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[Symbol.iterator9+](#symboliterator9)替代。
+### [Symbol.iterator]<sup>(deprecated)</sup>
 
 [Symbol.iterator]\(): IterableIterator&lt;[K, V]&gt;
 
 返回一个键值对形式的二维数组。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[Symbol.iterator<sup>9+</sup>](#symboliterator9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -2095,6 +2169,7 @@ entries(): IterableIterator&lt;[K,V]&gt;
 | [K,&nbsp;V] | 返回一个键值对形式的二维数组。 |
 
 **示例：**
+
   ```js
   let pro = new util.LruBuffer();
   pro.put(2,10);
@@ -2106,6 +2181,7 @@ entries(): IterableIterator&lt;[K,V]&gt;
 用于表示范围中的值的类型。该类型的值，类型可以为ScopeComparable或number。
 
 ScopeComparable类型的值需要实现compareTo方法，确保传入的数据具有可比性。
+
 ```js
 interface ScopeComparable{
     compareTo(other: ScopeComparable): boolean;
@@ -2197,9 +2273,9 @@ intersect(range: ScopeHelper): ScopeHelper
 
 **参数：**
 
-| 参数名 | 类型                           | 必填 | 说明               |
-| ------ | ------------------------------ | ---- | ------------------ |
-| range  | [ScopeHelper9+](#scopehelper9) | 是   | 传入一个给定范围。 |
+| 参数名 | 类型                         | 必填 | 说明               |
+| ------ | ---------------------------- | ---- | ------------------ |
+| range  | [ScopeHelper](#scopehelper9) | 是   | 传入一个给定范围。 |
 
 **返回值：**
 
@@ -2237,9 +2313,9 @@ intersect(lowerObj:ScopeType,upperObj:ScopeType):ScopeHelper
 
 **返回值：**
 
-| 类型                           | 说明                                     |
-| ------------------------------ | ---------------------------------------- |
-| [ScopeHelper9+](#scopehelper9) | 返回当前范围与给定下限和上限范围的交集。 |
+| 类型                         | 说明                                     |
+| ---------------------------- | ---------------------------------------- |
+| [ScopeHelper](#scopehelper9) | 返回当前范围与给定下限和上限范围的交集。 |
 
 **示例：**
 
@@ -2318,9 +2394,9 @@ expand(lowerObj: ScopeType,upperObj: ScopeType): ScopeHelper
 
 **返回值：**
 
-| 类型                           | 说明                                 |
-| ------------------------------ | ------------------------------------ |
-| [ScopeHelper9+](#scopehelper9) | 返回当前范围和给定下限和上限的并集。 |
+| 类型                         | 说明                                 |
+| ---------------------------- | ------------------------------------ |
+| [ScopeHelper](#scopehelper9) | 返回当前范围和给定下限和上限的并集。 |
 
 **示例：**
 
@@ -2344,15 +2420,15 @@ expand(range: ScopeHelper): ScopeHelper
 
 **参数：**
 
-| 参数名 | 类型                           | 必填 | 说明               |
-| ------ | ------------------------------ | ---- | ------------------ |
-| range  | [ScopeHelper9+](#scopehelper9) | 是   | 传入一个给定范围。 |
+| 参数名 | 类型                         | 必填 | 说明               |
+| ------ | ---------------------------- | ---- | ------------------ |
+| range  | [ScopeHelper](#scopehelper9) | 是   | 传入一个给定范围。 |
 
 **返回值：**
 
-| 类型                           | 说明                               |
-| ------------------------------ | ---------------------------------- |
-| [ScopeHelper9+](#scopehelper9) | 返回包括当前范围和给定范围的并集。 |
+| 类型                         | 说明                               |
+| ---------------------------- | ---------------------------------- |
+| [ScopeHelper](#scopehelper9) | 返回包括当前范围和给定范围的并集。 |
 
 **示例：**
 
@@ -2383,9 +2459,9 @@ expand(value: ScopeType): ScopeHelper
 
 **返回值：**
 
-| 类型                           | 说明                             |
-| ------------------------------ | -------------------------------- |
-| [ScopeHelper9+](#scopehelper9) | 返回包括当前范围和给定值的并集。 |
+| 类型                         | 说明                             |
+| ---------------------------- | -------------------------------- |
+| [ScopeHelper](#scopehelper9) | 返回包括当前范围和给定值的并集。 |
 
 **示例：**
 
@@ -2439,9 +2515,9 @@ contains(range: ScopeHelper): boolean
 
 **参数：**
 
-| 参数名 | 类型                           | 必填 | 说明               |
-| ------ | ------------------------------ | ---- | ------------------ |
-| range  | [ScopeHelper9+](#scopehelper9) | 是   | 传入一个给定范围。 |
+| 参数名 | 类型                         | 必填 | 说明               |
+| ------ | ---------------------------- | ---- | ------------------ |
+| range  | [ScopeHelper](#scopehelper9) | 是   | 传入一个给定范围。 |
 
 **返回值：**
 
@@ -2492,20 +2568,23 @@ let range = new util.ScopeHelper(tempLower, tempUpper);
 let result = range.clamp(tempMiDF);
   ```
 
-## Scope<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[ScopeHelper9+](#scopehelper9)替代。
+## Scope<sup>(deprecated)</sup>
 
-### constructor<sup>8+(deprecated)</sup>
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[ScopeHelper<sup>9+</sup>](#scopehelper9)替代。
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[constructor9+](#constructor9)替代。
+### constructor<sup>(deprecated)</sup>
 
 constructor(lowerObj: ScopeType, upperObj: ScopeType)
 
 用于创建指定下限和上限的作用域实例的构造函数，返回一个Scope对象。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[constructor<sup>9+</sup>](#constructor9)替代。
+
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2522,15 +2601,16 @@ constructor(lowerObj: ScopeType, upperObj: ScopeType)
   let range = new util.Scope(tempLower, tempUpper);
   ```
 
-### toString<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[toString9+](#tostring9)替代。
+### toString<sup>(deprecated)</sup>
 
 toString(): string
 
 该字符串化方法返回一个包含当前范围的字符串表示形式。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[toString<sup>9+</sup>](#tostring9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -2540,6 +2620,7 @@ toString(): string
 | string | 返回包含当前范围对象的字符串表示形式。 |
 
 **示例：**
+
   ```js
   let tempLower = new Temperature(30);
   let tempUpper = new Temperature(40);
@@ -2547,15 +2628,16 @@ toString(): string
   let result = range.toString();
   ```
 
-### intersect<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[intersect9+](#intersect9)替代。
+### intersect<sup>(deprecated)</sup>
 
 intersect(range: Scope): Scope
 
 获取给定范围和当前范围的交集。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[intersect<sup>9+</sup>](#intersect9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2582,15 +2664,16 @@ intersect(range: Scope): Scope
   range.intersect(rangeFir );
   ```
 
-### intersect<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[intersect9+](#intersect9)替代。
+### intersect<sup>(deprecated)</sup>
 
 intersect(lowerObj:ScopeType,upperObj:ScopeType):Scope
 
 获取当前范围与给定下限和上限范围的交集。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[intersect<sup>9+</sup>](#intersect9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2607,6 +2690,7 @@ intersect(lowerObj:ScopeType,upperObj:ScopeType):Scope
 | [Scope](#scope8) | 返回当前范围与给定下限和上限范围的交集。 |
 
 **示例：**
+
   ```js
   let tempLower = new Temperature(30);
   let tempUpper = new Temperature(40);
@@ -2616,15 +2700,16 @@ intersect(lowerObj:ScopeType,upperObj:ScopeType):Scope
   let result = range.intersect(tempMiDF, tempMidS);
   ```
 
-### getUpper<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[getUpper9+](#getupper9)替代。
+### getUpper<sup>(deprecated)</sup>
 
 getUpper(): ScopeType
 
 获取当前范围的上限。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[getUpper<sup>9+</sup>](#getupper9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -2634,6 +2719,7 @@ getUpper(): ScopeType
 | [ScopeType](#scopetype8) | 返回当前范围的上限值。 |
 
 **示例：**
+
   ```js
   let tempLower = new Temperature(30);
   let tempUpper = new Temperature(40);
@@ -2641,15 +2727,16 @@ getUpper(): ScopeType
   let result = range.getUpper();
   ```
 
-### getLower<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[getLower9+](#getlower9)替代。
+### getLower<sup>(deprecated)</sup>
 
 getLower(): ScopeType
 
 获取当前范围的下限。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[getLower<sup>9+</sup>](#getlower9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **返回值：**
@@ -2659,6 +2746,7 @@ getLower(): ScopeType
 | [ScopeType](#scopetype8) | 返回当前范围的下限值。 |
 
 **示例：**
+
   ```js
   let tempLower = new Temperature(30);
   let tempUpper = new Temperature(40);
@@ -2666,15 +2754,16 @@ getLower(): ScopeType
   let result = range.getLower();
   ```
 
-### expand<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[expand9+](#expand9)替代。
+### expand<sup>(deprecated)</sup>
 
 expand(lowerObj: ScopeType,upperObj: ScopeType): Scope
 
 创建并返回包括当前范围和给定下限和上限的并集。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[expand<sup>9+</sup>](#expand9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2701,15 +2790,16 @@ expand(lowerObj: ScopeType,upperObj: ScopeType): Scope
   let result = range.expand(tempMiDF, tempMidS);
   ```
 
-### expand<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[expand9+](#expand9)替代。
+### expand<sup>(deprecated)</sup>
 
 expand(range: Scope): Scope
 
 创建并返回包括当前范围和给定范围的并集。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[expand<sup>9+</sup>](#expand9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2725,6 +2815,7 @@ expand(range: Scope): Scope
 | [Scope](#scope8) | 返回包括当前范围和给定范围的并集。 |
 
 **示例：**
+
   ```js
   let tempLower = new Temperature(30);
   let tempUpper = new Temperature(40);
@@ -2735,15 +2826,16 @@ expand(range: Scope): Scope
   let result = range.expand(rangeFir);
   ```
 
-### expand<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[expand9+](#expand9)替代。
+### expand<sup>(deprecated)</sup>
 
 expand(value: ScopeType): Scope
 
 创建并返回包括当前范围和给定值的并集。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[expand<sup>9+</sup>](#expand9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2759,6 +2851,7 @@ expand(value: ScopeType): Scope
 | [Scope](#scope8) | 返回包括当前范围和给定值的并集。 |
 
 **示例：**
+
   ```js
   let tempLower = new Temperature(30);
   let tempUpper = new Temperature(40);
@@ -2767,15 +2860,16 @@ expand(value: ScopeType): Scope
   let result = range.expand(tempMiDF);
   ```
 
-### contains<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[contains9+](#contains9)替代。
+### contains<sup>(deprecated)</sup>
 
 contains(value: ScopeType): boolean
 
 检查给定value是否包含在当前范围内。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[contains<sup>9+</sup>](#contains9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2791,6 +2885,7 @@ contains(value: ScopeType): boolean
 | boolean | 如果给定值包含在当前范围内返回true，否则返回false。 |
 
 **示例：**
+
   ```js
   let tempLower = new Temperature(30);
   let tempUpper = new Temperature(40);
@@ -2799,15 +2894,16 @@ contains(value: ScopeType): boolean
   range.contains(tempMiDF);
   ```
 
-### contains<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[contains9+](#contains9)替代。
+### contains<sup>(deprecated)</sup>
 
 contains(range: Scope): boolean
 
 检查给定range是否在当前范围内。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[contains<sup>9+</sup>](#contains9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2834,15 +2930,17 @@ contains(range: Scope): boolean
   let result = range.contains(rangeSec);
   ```
 
-### clamp<sup>8+(deprecated)</sup>
+### clamp<sup>(deprecated)</sup>
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[clamp9+](#clamp9)替代。
 
 clamp(value: ScopeType): ScopeType
 
 将给定值限定到当前范围内。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[clamp<sup>9+</sup>](#clamp9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -2858,6 +2956,7 @@ clamp(value: ScopeType): ScopeType
 | [ScopeType](#scopetype8) | 如果传入的value小于下限，则返回lowerObj；如果大于上限值则返回upperObj；如果在当前范围内，则返回value。 |
 
 **示例：**
+
   ```js
   let tempLower = new Temperature(30);
   let tempUpper = new Temperature(40);
@@ -3068,36 +3167,40 @@ that.decode(array).then(val=>{
   ```
 
 
-## Base64<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[Base64Helper9+](#base64helper9)替代。
+## Base64<sup>(deprecated)</sup>
 
-### constructor<sup>8+(deprecated)</sup>
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[Base64Helper<sup>9+</sup>](#base64helper9)替代。
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[constructor9+](#constructor9)替代。
+### constructor<sup>(deprecated)</sup>
 
 constructor()
 
 Base64的构造函数。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[constructor<sup>9+</sup>](#constructor9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **示例：**
+
   ```js
   let base64 = new  util.Base64();
   ```
 
-### encodeSync<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[encodeSync9+](#encodesync9)替代。
+### encodeSync<sup>(deprecated)</sup>
 
 encodeSync(src: Uint8Array): Uint8Array
 
 通过输入参数编码后输出对应文本。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[encodeSync<sup>9+</sup>](#encodesync9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -3120,15 +3223,16 @@ encodeSync(src: Uint8Array): Uint8Array
   let result = that.encodeSync(array);
   ```
 
-### encodeToStringSync<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[encodeToStringSync9+](#encodetostringsync9)替代。
+### encodeToStringSync<sup>(deprecated)</sup>
 
 encodeToStringSync(src: Uint8Array): string
 
 通过输入参数编码后输出对应文本。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[encodeToStringSync<sup>9+</sup>](#encodetostringsync9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -3144,21 +3248,23 @@ encodeToStringSync(src: Uint8Array): string
 | string | 返回编码后的字符串。 |
 
 **示例：**
+
   ```js
   let that = new util.Base64();
   let array = new Uint8Array([115,49,51]);
   let result = that.encodeToStringSync(array);
   ```
 
-### decodeSync<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[decodeSync9+](#decodesync9)替代。
+### decodeSync<sup>(deprecated)</sup>
 
 decodeSync(src: Uint8Array | string): Uint8Array
 
 通过输入参数解码后输出对应文本。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[decodeSync<sup>9+</sup>](#decodesync9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -3174,21 +3280,23 @@ decodeSync(src: Uint8Array | string): Uint8Array
 | Uint8Array | 返回解码后新分配的Uint8数组。 |
 
 **示例：**
+
   ```js
   let that = new util.Base64();
   let buff = 'czEz';
   let result = that.decodeSync(buff);
   ```
 
-### encode<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[encode9+](#encode9)替代。
+### encode<sup>(deprecated)</sup>
 
 encode(src: Uint8Array): Promise&lt;Uint8Array&gt;
 
 通过输入参数异步编码后输出对应文本。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[encode<sup>9+</sup>](#encode9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -3204,6 +3312,7 @@ encode(src: Uint8Array): Promise&lt;Uint8Array&gt;
 | Promise&lt;Uint8Array&gt; | 返回异步编码后新分配的Uint8数组。 |
 
 **示例：**
+
   ```js
   let that = new util.Base64();
   let array = new Uint8Array([115,49,51]);
@@ -3215,15 +3324,16 @@ encode(src: Uint8Array): Promise&lt;Uint8Array&gt;
   })
   ```
 
-### encodeToString<sup>8+(deprecated)</sup>
-
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[encodeToString9+](#encodetostring9)替代。
+### encodeToString<sup>(deprecated)</sup>
 
 encodeToString(src: Uint8Array): Promise&lt;string&gt;
 
 通过输入参数异步编码后输出对应文本。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[encodeToString<sup>9+</sup>](#encodetostring9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -3239,6 +3349,7 @@ encodeToString(src: Uint8Array): Promise&lt;string&gt;
 | Promise&lt;string&gt; | 返回异步编码后的字符串。 |
 
 **示例：**
+
   ```js
   let that = new util.Base64();
   let array = new Uint8Array([115,49,51]);
@@ -3247,15 +3358,17 @@ encodeToString(src: Uint8Array): Promise&lt;string&gt;
   })
   ```
 
-### decode<sup>8+(deprecated)</sup>
+### decode<sup>(deprecated)</sup>
 
-> **说明：**<br/>
-> 从API Version 9开始废弃，建议使用[decode9+](#decode9)替代。
 
 decode(src: Uint8Array | string): Promise&lt;Uint8Array&gt;
 
 通过输入参数异步解码后输出对应文本。
 
+> **说明：**
+>
+> 从API Version 8开始支持，从API Version 9开始废弃，建议使用[decode<sup>9+</sup>](#decode9)替代。
+
 **系统能力：** SystemCapability.Utils.Lang
 
 **参数：**
@@ -3271,6 +3384,7 @@ decode(src: Uint8Array | string): Promise&lt;Uint8Array&gt;
 | Promise&lt;Uint8Array&gt; | 返回异步解码后新分配的Uint8数组。 |
 
 **示例：**
+
   ```js
   let that = new util.Base64();
   let array = new Uint8Array([99,122,69,122]);
@@ -3294,6 +3408,7 @@ Types的构造函数。
 **系统能力：** SystemCapability.Utils.Lang
 
 **示例：**
+
   ```js
   let type = new util.types();
   ```
@@ -3320,6 +3435,7 @@ isAnyArrayBuffer(value: Object): boolean
 | boolean | 判断的结果，如果是ArrayBuffer类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isAnyArrayBuffer(new ArrayBuffer(0));
@@ -3349,6 +3465,7 @@ ArrayBufferView辅助类型包括：Int8Array、Int16Array、Int32Array、Uint8A
 | boolean | 判断的结果，如果是内置包含的ArrayBufferView辅助类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isArrayBufferView(new Int8Array([]));
@@ -3376,6 +3493,7 @@ isArgumentsObject(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的arguments类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   function foo() {
@@ -3406,6 +3524,7 @@ isArrayBuffer(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的ArrayBuffer类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isArrayBuffer(new ArrayBuffer(0));
@@ -3433,6 +3552,7 @@ isAsyncFunction(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的异步函数类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isAsyncFunction(async function foo() {});
@@ -3460,6 +3580,7 @@ isBooleanObject(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Boolean对象类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isBooleanObject(new Boolean(true));
@@ -3487,6 +3608,7 @@ isBoxedPrimitive(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Boolean或Number或String或Symbol对象类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isBoxedPrimitive(new Boolean(false));
@@ -3514,6 +3636,7 @@ isDataView(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的DataView对象类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   const ab = new ArrayBuffer(20);
@@ -3542,6 +3665,7 @@ isDate(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Date对象类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isDate(new Date());
@@ -3569,6 +3693,7 @@ isExternal(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含native&nbsp;External类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isExternal(true);
@@ -3596,6 +3721,7 @@ isFloat32Array(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Float32Array数组类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isFloat32Array(new Float32Array());
@@ -3623,6 +3749,7 @@ isFloat64Array(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Float64Array数组类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isFloat64Array(new Float64Array());
@@ -3650,6 +3777,7 @@ isGeneratorFunction(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的generator函数类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isGeneratorFunction(function* foo() {});
@@ -3677,6 +3805,7 @@ isGeneratorObject(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的generator对象类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   function* foo() {}
@@ -3706,6 +3835,7 @@ isInt8Array(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Int8Array数组类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isInt8Array(new Int8Array([]));
@@ -3733,6 +3863,7 @@ isInt16Array(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Int16Array数组类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isInt16Array(new Int16Array([]));
@@ -3760,6 +3891,7 @@ isInt32Array(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Int32Array数组类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isInt32Array(new Int32Array([]));
@@ -3787,6 +3919,7 @@ isMap(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Map类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isMap(new Map());
@@ -3803,6 +3936,7 @@ isMapIterator(value: Object): boolean
 
 **参数：**
 
+
 | 参数名 | 类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
 | value | Object | 是 | 待检测对象。 |
@@ -3814,6 +3948,7 @@ isMapIterator(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Map的Iterator类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   const map = new Map();
@@ -3842,6 +3977,7 @@ isNativeError(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Error类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isNativeError(new TypeError());
@@ -3869,6 +4005,7 @@ isNumberObject(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Number对象类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isNumberObject(new Number(0));
@@ -3896,6 +4033,7 @@ isPromise(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Promise类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isPromise(Promise.resolve(1));
@@ -3923,6 +4061,7 @@ isProxy(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Proxy类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   const target = {};
@@ -3952,6 +4091,7 @@ isRegExp(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的RegExp类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isRegExp(new RegExp('abc'));
@@ -3979,6 +4119,7 @@ isSet(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Set类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isSet(new Set());
@@ -4006,6 +4147,7 @@ isSetIterator(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Set的Iterator类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   const set = new Set();
@@ -4034,6 +4176,7 @@ isStringObject(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的String对象类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isStringObject(new String('foo'));
@@ -4061,6 +4204,7 @@ isSymbolObject(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Symbol对象类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   const symbols = Symbol('foo');
@@ -4091,6 +4235,7 @@ TypedArray类型的辅助类型，包括Int8Array、Int16Array、Int32Array、Ui
 | boolean | 判断的结果，如果是内置包含的TypedArray包含的类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isTypedArray(new Float64Array([]));
@@ -4118,6 +4263,7 @@ isUint8Array(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Uint8Array数组类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isUint8Array(new Uint8Array([]));
@@ -4145,6 +4291,7 @@ isUint8ClampedArray(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Uint8ClampedArray数组类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isUint8ClampedArray(new Uint8ClampedArray([]));
@@ -4172,6 +4319,7 @@ isUint16Array(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Uint16Array数组类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isUint16Array(new Uint16Array([]));
@@ -4199,6 +4347,7 @@ isUint32Array(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Uint32Array数组类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isUint32Array(new Uint32Array([]));
@@ -4226,6 +4375,7 @@ isWeakMap(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的WeakMap类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isWeakMap(new WeakMap());
@@ -4253,6 +4403,7 @@ isWeakSet(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的WeakSet类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isWeakSet(new WeakSet());
@@ -4280,6 +4431,7 @@ isBigInt64Array(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的BigInt64Array类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isBigInt64Array(new BigInt64Array([]));
@@ -4307,6 +4459,7 @@ isBigUint64Array(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的BigUint64Array类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isBigUint64Array(new BigUint64Array([]));
@@ -4334,6 +4487,7 @@ isModuleNamespaceObject(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的Module Namespace Object类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   import url from '@ohos.url'
   let that = new util.types();
@@ -4362,6 +4516,7 @@ isSharedArrayBuffer(value: Object): boolean
 | boolean | 判断的结果，如果是内置包含的SharedArrayBuffer类型为true，反之为false。 |
 
 **示例：**
+
   ```js
   let that = new util.types();
   let result = that.isSharedArrayBuffer(new SharedArrayBuffer(0));