1# @ohos.util (util工具函数) 2 3该模块主要提供常用的工具函数，实现字符串编解码（[TextEncoder](#textencoder)，[TextDecoder](#textdecoder)）、有理数运算（[RationalNumber<sup>8+</sup>](#rationalnumber8)）、缓冲区管理（[LRUCache<sup>9+</sup>](#lrucache9)）、范围判断（[ScopeHelper<sup>9+</sup>](#scopehelper9)）、Base64编解码（[Base64Helper<sup>9+</sup>](#base64helper9)）、内置对象类型检查（[types<sup>8+</sup>](#types8)、对方法进行插桩和替换（[Aspect<sup>11+</sup>](#aspect11)）等功能。 4 5> **说明：** 6> 7> 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 8 9 10## 导入模块 11 12```ts 13import { util } from '@kit.ArkTS'; 14``` 15## util.format<sup>9+</sup> 16 17format(format: string, ...args: Object[]): string 18 19通过式样化字符串对输入的内容按特定格式输出。 20 21**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 22 23**系统能力：** SystemCapability.Utils.Lang 24 25**参数：** 26 27| 参数名 | 类型 | 必填 | 说明 | 28| ------- | -------- | ---- | -------------- | 29| format | string | 是 | 格式化字符串，可以包含零个或多个占位符，用于指定要插入的参数的位置和格式。 | 30| ...args | Object[] | 否 | 替换format参数中占位符的数据，此参数缺失时，默认返回第一个参数。| 31 32**返回值：** 33 34| 类型 | 说明 | 35| ------ | -----------------| 36| string | 格式化后的字符串。 | 37 38**错误码：** 39 40以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 41 42| 错误码ID | 错误信息 | 43| -------- | -------- | 44| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 45 46**格式说明符：** 47 48| 格式说明符 | 说明 | 49| ------ | -------------------------------- | 50| %s | 将参数转换为字符串，用于除Object，BigInt和-0之外的所有值。| 51| %d | 将参数作为十进制整数进行格式化输出，用于除Symbol和BigInt之外的所有值。| 52| %i | 将字符串转换为十进制整数，用于除BigInt和Symbol之外的所有值。| 53| %f | 将字符串转换为浮点数，用于除Bigint和Symbol之外的所有值。| 54| %j | 将JavaScript对象转换为JSON字符串进行格式化输出。| 55| %o | 用于将JavaScript对象进行格式化输出，将对象转换为字符串表示，但不包含对象的原型链信息。| 56| %O | 用于将JavaScript对象进行格式化输出，将对象转换为字符串表示。| 57| %c | 只在浏览器环境中有效。其余环境不会产生样式效果。| 58| %% | 转义百分号的特殊格式化占位符。| 59 60**示例：** 61 62```ts 63import { util } from '@kit.ArkTS'; 64 65interface utilAddresstype { 66 city: string; 67 country: string; 68} 69interface utilPersontype { 70 name: string; 71 age: number; 72 address: utilAddresstype; 73} 74 75let name = 'John'; 76let age = 20; 77let formattedString = util.format('My name is %s and I am %s years old', name, age); 78console.info(formattedString); 79// 输出结果：My name is John and I am 20 years old 80let num = 10.5; 81formattedString = util.format('The number is %d', num); 82console.info(formattedString); 83// 输出结果：The number is 10.5 84num = 100.5; 85formattedString = util.format('The number is %i', num); 86console.info(formattedString); 87// 输出结果：The number is 100 88const pi = 3.141592653; 89formattedString = util.format('The value of pi is %f', pi); 90console.info(formattedString); 91// 输出结果：The value of pi is 3.141592653 92const obj: Record<string,number | string> = { "name": 'John', "age": 20 }; 93formattedString = util.format('The object is %j', obj); 94console.info(formattedString); 95// 输出结果：The object is {"name":"John","age":20} 96const person: utilPersontype = { 97 name: 'John', 98 age: 20, 99 address: { 100 city: 'New York', 101 country: 'USA' 102 } 103}; 104console.info(util.format('Formatted object using %%O: %O', person)); 105console.info(util.format('Formatted object using %%o: %o', person)); 106/* 107输出结果： 108Formatted object using %O: { name: 'John', 109 age: 20, 110 address: 111 { city: 'New York', 112 country: 'USA' } } 113Formatted object using %o: { name: 'John', 114 age: 20, 115 address: 116 { city: 'New York', 117 country: 'USA' } } 118*/ 119const percentage = 80; 120let arg = 'homework'; 121formattedString = util.format('John finished %d%% of the %s', percentage, arg); 122console.info(formattedString); 123// 输出结果：John finished 80% of the homework 124``` 125 126## util.errnoToString<sup>9+</sup> 127 128errnoToString(errno: number): string 129 130获取系统错误码对应的详细信息。 131 132**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 133 134**系统能力：** SystemCapability.Utils.Lang 135 136**参数：** 137 138| 参数名 | 类型 | 必填 | 说明 | 139| ------ | ------ | ---- | -------------------------- | 140| errno | number | 是 | 系统发生错误产生的错误码。 | 141 142**返回值：** 143 144| 类型 | 说明 | 145| ------ | ---------------------- | 146| string | 错误码对应的详细信息。 | 147 148**错误码：** 149 150以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 151 152| 错误码ID | 错误信息 | 153| -------- | -------- | 154| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 155 156**示例：** 157 158```ts 159let errnum = -1; // -1 : a system error number 160let result = util.errnoToString(errnum); 161console.info("result = " + result); 162``` 163 164**部分错误码及信息示例：** 165 166| 错误码 | 信息 | 167| ------ | -------------------------------- | 168| -1 | operation not permitted | 169| -2 | no such file or directory | 170| -3 | no such process | 171| -4 | interrupted system call | 172| -5 | i/o error | 173| -11 | resource temporarily unavailable | 174| -12 | not enough memory | 175| -13 | permission denied | 176| -100 | network is down | 177 178## util.callbackWrapper 179 180callbackWrapper(original: Function): (err: Object, value: Object )=>void 181 182对异步函数进行回调化处理，回调中第一个参数将是拒绝原因（如果 Promise 已解决，则为 null），第二个参数将是已解决的值。 183 184> **说明：** 185> 186> 该接口要求参数original必须是异步函数类型。如果传入的参数不是异步函数，不会进行拦截，但是会输出错误信息："callbackWrapper: The type of Parameter must be AsyncFunction"。 187 188**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 189 190**系统能力：** SystemCapability.Utils.Lang 191 192**参数：** 193 194| 参数名 | 类型 | 必填 | 说明 | 195| -------- | -------- | -------- | -------- | 196| original | Function | 是 | 异步函数。 | 197 198**返回值：** 199 200| 类型 | 说明 | 201| -------- | -------- | 202| Function | 返回一个回调函数，该函数第一个参数err是拒绝原因（如果 Promise 已解决，则为 null），第二个参数value是已解决的值。 | 203 204**错误码：** 205 206以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 207 208| 错误码ID | 错误信息 | 209| -------- | -------- | 210| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 211 212**示例：** 213 214```ts 215async function fn() { 216 return 'hello world'; 217} 218let cb = util.callbackWrapper(fn); 219cb(1, (err : Object, ret : string) => { 220 if (err) throw new Error; 221 console.info(ret); 222}); 223``` 224 225## util.promisify<sup>9+</sup> 226 227promisify(original: (err: Object, value: Object) => void): Function 228 229对异步函数处理并返回一个promise的函数。 230 231**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 232 233**系统能力：** SystemCapability.Utils.Lang 234 235**参数：** 236 237| 参数名 | 类型 | 必填 | 说明 | 238| -------- | -------- | -------- | -------- | 239| original | Function | 是 | 回调函数中第一个参数err是拒绝原因（如果 Promise 已解决，则为 null），第二个参数value是已解决的值。 | 240 241**返回值：** 242 243| 类型 | 说明 | 244| -------- | -------- | 245| Function | 返回一个 Promise 的函数。 | 246 247**错误码：** 248 249以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 250 251| 错误码ID | 错误信息 | 252| -------- | -------- | 253| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 254 255**示例：** 256 257```ts 258async function fn() { 259 return 'hello world'; 260} 261const addCall = util.promisify(util.callbackWrapper(fn)); 262(async () => { 263 try { 264 let res: string = await addCall(); 265 console.info(res); 266 } catch (err) { 267 console.info(err); 268 } 269})(); 270``` 271 272## util.generateRandomUUID<sup>9+</sup> 273 274generateRandomUUID(entropyCache?: boolean): string 275 276使用加密安全随机数生成器生成随机的RFC 4122版本4的string类型UUID。调用此函数会生成两个UUID，其中一个UUID进行缓存，一个UUID用于输出，首次调用时，参数是true或false无区别；下次调用时，如果参数是true，依旧缓存上次UUID，并生成新的UUID；如果参数是false，将生成两个UUID，其中一个UUID进行缓存，一个UUID进行输出。 277 278**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 279 280**系统能力：** SystemCapability.Utils.Lang 281 282**参数：** 283 284| 参数名 | 类型 | 必填 | 说明 | 285| -------- | -------- | -------- | -------- | 286| entropyCache | boolean | 否 | 是否使用已缓存的UUID， 默认true。 | 287 288**返回值：** 289 290| 类型 | 说明 | 291| -------- | -------- | 292| string | 表示此UUID的字符串。 | 293 294**错误码：** 295 296以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 297 298| 错误码ID | 错误信息 | 299| -------- | -------- | 300| 401 | Parameter error. Possible causes: 1. Incorrect parameter types. | 301 302**示例：** 303 304```ts 305let uuid = util.generateRandomUUID(true); 306console.info("RFC 4122 Version 4 UUID:" + uuid); 307// 输出随机生成的UUID 308``` 309 310## util.generateRandomBinaryUUID<sup>9+</sup> 311 312generateRandomBinaryUUID(entropyCache?: boolean): Uint8Array 313 314使用加密安全随机数生成器生成随机的RFC 4122版本4的Uint8Array类型UUID。 315 316**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 317 318**系统能力：** SystemCapability.Utils.Lang 319 320**参数：** 321 322| 参数名 | 类型 | 必填 | 说明 | 323| -------- | -------- | -------- | -------- | 324| entropyCache | boolean | 否 | 是否使用已缓存的UUID， 默认true。 | 325 326**返回值：** 327 328| 类型 | 说明 | 329| -------- | -------- | 330| Uint8Array | 表示此UUID的Uint8Array值。 | 331 332**错误码：** 333 334以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 335 336| 错误码ID | 错误信息 | 337| -------- | -------- | 338| 401 | Parameter error. Possible causes: 1. Incorrect parameter types. | 339 340**示例：** 341 342```ts 343let uuid = util.generateRandomBinaryUUID(true); 344console.info(JSON.stringify(uuid)); 345// 输出随机生成的UUID 346``` 347 348## util.parseUUID<sup>9+</sup> 349 350parseUUID(uuid: string): Uint8Array 351 352将generateRandomUUID生成的string类型UUID转换为generateRandomBinaryUUID生成的Uint8Array类型UUID，如RFC 4122版本4中所述。 353 354**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 355 356**系统能力：** SystemCapability.Utils.Lang 357 358**参数：** 359 360| 参数名 | 类型 | 必填 | 说明 | 361| -------- | -------- | -------- | -------- | 362| uuid | string | 是 | UUID字符串。 | 363 364**返回值：** 365 366| 类型 | 说明 | 367| -------- | -------- | 368| Uint8Array | 返回表示此UUID的Uint8Array，如果解析失败，则抛出SyntaxError。 | 369 370**错误码：** 371 372以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 373 374| 错误码ID | 错误信息 | 375| -------- | -------- | 376| 401 | Parameter error. Possible causes: 1. Incorrect parameter types. | 377| 10200002 | Invalid uuid string. | 378 379**示例：** 380 381```ts 382let uuid = util.parseUUID("84bdf796-66cc-4655-9b89-d6218d100f9c"); 383console.info(JSON.stringify(uuid)); 384// 输出： 385// 132,189,247,150,102,204,70,85,155,137,214,33,141,16,15,156 386``` 387 388## util.printf<sup>(deprecated)</sup> 389 390printf(format: string, ...args: Object[]): string 391 392通过式样化字符串对输入的内容按特定格式输出。 393 394> **说明：** 395> 396> 从API version 7开始支持，从API version 9开始废弃，建议使用[util.format<sup>9+</sup>](#utilformat9)替代。 397 398**系统能力：** SystemCapability.Utils.Lang 399 400**参数：** 401 402| 参数名 | 类型 | 必填 | 说明 | 403| -------- | -------- | -------- | -------- | 404| format | string | 是 | 式样化字符串。 | 405| ...args | Object[] | 否 | 替换式样化字符串通配符的数据，此参数缺失时，默认返回第一个参数。 | 406 407**返回值：** 408 409| 类型 | 说明 | 410| -------- | -------- | 411| string | 按特定格式式样化后的字符串。 | 412 413**示例：** 414 415```ts 416let res = util.printf("%s", "hello world!"); 417console.info(res); 418``` 419 420 421## util.getErrorString<sup>(deprecated)</sup> 422 423getErrorString(errno: number): string 424 425获取系统错误码对应的详细信息。 426 427> **说明：** 428> 429> 从API version 7开始支持，从API version 9开始废弃，建议使用[util.errnoToString<sup>9+</sup>](#utilerrnotostring9)替代。 430 431**系统能力：** SystemCapability.Utils.Lang 432 433**参数：** 434 435| 参数名 | 类型 | 必填 | 说明 | 436| -------- | -------- | -------- | -------- | 437| errno | number | 是 | 系统发生错误产生的错误码。 | 438 439**返回值：** 440 441| 类型 | 说明 | 442| -------- | -------- | 443| string | 错误码对应的详细信息。 | 444 445**示例：** 446 447```ts 448let errnum = -1; // -1 : a system error number 449let result = util.getErrorString(errnum); 450console.info("result = " + result); 451``` 452 453## util.promiseWrapper<sup>(deprecated)</sup> 454 455promiseWrapper(original: (err: Object, value: Object) => void): Object 456 457对异步函数处理并返回一个promise的版本。 458 459> **说明：** 460> 461> 此接口不可用，建议使用[util.promisify<sup>9+</sup>](#utilpromisify9)替代。 462 463**系统能力：** SystemCapability.Utils.Lang 464 465**参数：** 466 467| 参数名 | 类型 | 必填 | 说明 | 468| -------- | -------- | -------- | -------- | 469| original | Function | 是 | 异步函数。 | 470 471**返回值：** 472 473| 类型 | 说明 | 474| -------- | -------- | 475| Function | 采用遵循常见的错误优先的回调风格的函数（也就是将 (err, value) => ... 回调作为最后一个参数），并返回一个返回 promise 的版本。 | 476 477 478## util.getHash<sup>12+</sup> 479 480getHash(object: object): number 481 482获取对象的Hash值。如果是第一次获取，则计算Hash值并保存到对象的Hash域（返回随机的Hash值）；如果不是第一次获取，则从Hash域中获取并返回Hash值（同一对象多次返回值保持不变）。 483 484**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 485 486**系统能力：** SystemCapability.Utils.Lang 487 488**参数：** 489 490| 参数名 | 类型 | 必填 | 说明 | 491| -------- | -------- | -------- | -------- | 492| object | object | 是 | 希望获取Hash值的对象。 | 493 494**返回值：** 495 496| 类型 | 说明 | 497| -------- | -------- | 498| number | Hash值。 | 499 500**错误码：** 501 502以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 503 504| 错误码ID | 错误信息 | 505| -------- | -------- | 506| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 507 508**示例：** 509 510```ts 511interface Person { 512 name: string, 513 age: number 514} 515let obj: Person = { name: 'Jack', age: 20 }; 516let result1 = util.getHash(obj); 517console.info('result1 is ' + result1); 518let result2 = util.getHash(obj); 519console.info('result2 is ' + result2); 520// 输出：result1 与 result2 的值相等，且为随机的Hash值。 521``` 522 523 524## TextDecoderOptions<sup>11+</sup> 525 526解码相关选项参数，存在两个属性fatal和ignoreBOM。 527 528**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 529 530**系统能力：** SystemCapability.Utils.Lang 531 532| 名称 | 类型 | 必填 | 说明 | 533| --------- | -------- | ---- | ------------------ | 534| fatal | boolean | 否 | 是否显示致命错误，默认值是false。 | 535| ignoreBOM | boolean | 否 | 是否忽略BOM标记，默认值是false。 | 536 537## DecodeToStringOptions<sup>12+</sup> 538 539解码是否使用流处理方式。 540 541**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 542 543**系统能力：** SystemCapability.Utils.Lang 544 545| 名称 | 类型 | 必填 | 说明 | 546| -------- | -------- | -------- | -------- | 547| stream | boolean | 否 | 输入末尾出现的不完整字节序列是否需要追加在下次调用decodeToString的参数中处理。设置为true，则不完整的字节序列会存储在内部缓存区直到下次调用该函数，false则会在当前调用时直接解码。默认为false。 | 548 549## DecodeWithStreamOptions<sup>11+</sup> 550 551解码是否跟随附加数据块相关选项参数。 552 553**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 554 555**系统能力：** SystemCapability.Utils.Lang 556 557| 名称 | 类型 | 必填 | 说明 | 558| -------- | -------- | -------- | -------- | 559| stream | boolean | 否 | 在随后的decodeWithStream()调用中是否跟随附加数据块。如果以块的形式处理数据，则设置为true；如果处理最后的数据块或数据未分块，则设置为false。默认为false。 | 560 561## Aspect<sup>11+</sup> 562 563Aspect类用于封装提供切面能力（Aspect Oriented Programming，简写AOP）的接口，这些接口可以用来对类方法进行前后插桩或者替换实现。 564 565### addBefore<sup>11+</sup> 566 567static addBefore(targetClass: Object, methodName: string, isStatic: boolean, before: Function): void 568 569在指定的类对象的原方法执行前插入一个函数。addBefore接口执行完成后，都会先执行插入的函数逻辑，再执行指定类对象的原方法。 570 571**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 572 573**系统能力：** SystemCapability.Utils.Lang 574 575**参数：** 576 577| 参数名 | 类型 | 必填 | 说明 | 578| -------- | ------- | ---- | -------------------------------------| 579| targetClass | Object | 是 | 指定的类对象。 | 580| methodName | string | 是 | 指定的方法名，不支持read-only方法。 | 581| isStatic | boolean | 是 | 指定的原方法是否为静态方法，true表示静态方法，false表示实例方法。 | 582| before | Function | 是 | 要插入的函数对象。函数有参数，则第一个参数是this对象（若isStatic为true，则为类对象即targetClass；若isStatic为false，则为调用方法的实例对象），其余参数是原方法的参数。函数也可以无参数，无参时不做处理。 | 583 584**错误码：** 585 586以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 587 588| 错误码ID | 错误信息 | 589| -------- | -------- | 590| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 591 592**示例：** 593 594```ts 595class MyClass { 596 msg: string = 'msg000'; 597 foo(arg: string): string { 598 console.info('foo arg is ' + arg); 599 return this.msg; 600 } 601 602 static data: string = 'data000'; 603 static bar(arg: string): string { 604 console.info('bar arg is ' + arg); 605 return MyClass.data; 606 } 607} 608 609let asp = new MyClass(); 610let result = asp.foo('123'); 611// 输出结果：foo arg is 123 612console.info('result is ' + result); 613// 输出结果：result is msg000 614console.info('asp.msg is ' + asp.msg); 615// 输出结果：asp.msg is msg000 616 617util.Aspect.addBefore(MyClass, 'foo', false, (instance: MyClass, arg: string) => { 618 console.info('arg is ' + arg); 619 instance.msg = 'msg111'; 620 console.info('msg is changed to ' + instance.msg) 621}); 622 623result = asp.foo('123'); 624// 输出结果：arg is 123 625// 输出结果：msg is changed to msg111 626// 输出结果：foo arg is 123 627console.info('result is ' + result); 628// 输出结果：result is msg111 629console.info('asp.msg is ' + asp.msg); 630// 输出结果：asp.msg is msg111 631 632 633let res = MyClass.bar('456'); 634// 输出结果：bar arg is 456 635console.info('res is ' + res); 636// 输出结果：res is data000 637console.info('MyClass.data is ' + MyClass.data); 638// 输出结果：MyClass.data is data000 639 640util.Aspect.addBefore(MyClass, 'bar', true, (target: Object, arg: string) => { 641 console.info('arg is ' + arg); 642 let newVal = 'data111'; 643 Reflect.set(target, 'data', newVal); 644 console.info('data is changed to ' + newVal); 645}); 646 647res = MyClass.bar('456'); 648// 输出结果：arg is 456 649// 输出结果：data is changed to data111 650// 输出结果：bar arg is 456 651console.info('res is ' + res); 652// 输出结果：res is data111 653console.info('MyClass.data is ' + MyClass.data); 654// 输出结果：MyClass.data is data111 655``` 656 657### addAfter<sup>11+</sup> 658 659static addAfter(targetClass: Object, methodName: string, isStatic: boolean, after: Function): void 660 661在指定的类方法执行后插入一段逻辑。最终返回值是插入函数执行后的返回值。 662 663**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 664 665**系统能力：** SystemCapability.Utils.Lang 666 667**参数：** 668 669| 参数名 | 类型 | 必填 | 说明 | 670| -------- | ------- | ---- | -------------------------------------| 671| targetClass | Object | 是 | 指定的类对象。 | 672| methodName | string | 是 | 指定的原方法名，不支持read-only方法。 | 673| isStatic | boolean | 是 | 指定的原方法是否为静态方法，true表示静态方法，false表示实例方法。 | 674| after | Function | 是 | 要插入的函数。函数有参数时，则第一个参数是this对象（若isStatic为true，则为类对象即targetClass；若isStatic为false，则为调用方法的实例对象），第二个参数是原方法的返回值（如果原方法没有返回值，则为undefined），其余参数是原方法的参数。函数也可以无参，无参时不做处理。 | 675 676**错误码：** 677 678以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 679 680| 错误码ID | 错误信息 | 681| -------- | -------- | 682| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 683 684**示例：** 685 686```ts 687class MyClass { 688 msg: string = 'msg000'; 689 foo(arg: string): string { 690 console.info('foo arg is ' + arg); 691 return this.msg; 692 } 693} 694 695let asp = new MyClass(); 696let result = asp.foo('123'); 697// 输出结果：foo arg is 123 698console.info('result is ' + result); 699// 输出结果：result is msg000 700console.info('asp.msg is ' + asp.msg); 701// 输出结果：asp.msg is msg000 702 703util.Aspect.addAfter(MyClass, 'foo', false, (instance: MyClass, ret: string, arg: string): string => { 704 console.info('arg is ' + arg); 705 console.info('ret is ' + ret); 706 instance.msg = 'msg111'; 707 console.info('msg is changed to ' + instance.msg); 708 return 'msg222'; 709}); 710 711result = asp.foo('123'); 712// 输出结果：foo arg is 123 713// 输出结果：arg is 123 714// 输出结果：ret is msg000 715// 输出结果：msg is changed to msg111 716console.info('result is ' + result); 717// 输出结果：result is msg222 718console.info('asp.msg is ' + asp.msg); 719// 输出结果：asp.msg is msg111 720 721// 前后插桩的例子 722class AroundTest { 723 foo(arg: string) { 724 console.info('execute foo with arg ' + arg); 725 } 726} 727util.Aspect.addBefore(AroundTest, 'foo', false, () => { 728 console.info('execute before'); 729}); 730util.Aspect.addAfter(AroundTest, 'foo', false, () => { 731 console.info('execute after'); 732}); 733 734(new AroundTest()).foo('hello'); 735// 输出结果：execute before 736// 输出结果：execute foo with arg hello 737// 输出结果：execute after 738``` 739 740### replace<sup>11+</sup> 741 742static replace(targetClass: Object, methodName: string, isStatic: boolean, instead: Function) : void 743 744将指定的类方法的原方法替换为另一个函数。replace接口执行完成后，调用指定的类方法时，只会执行替换后的逻辑。最终返回值为替换函数执行完毕的返回值。 745 746**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 747 748**系统能力：** SystemCapability.Utils.Lang 749 750**参数：** 751 752| 参数名 | 类型 | 必填 | 说明 | 753| -------- | ------- | ---- | -------------------------------------| 754| targetClass | Object | 是 | 指定的类对象。 | 755| methodName | string | 是 | 指定的原方法名，不支持read-only方法。 | 756| isStatic | boolean | 是 | 指定的原方法是否为静态方法，true表示静态方法，false表示实例方法。 | 757| instead | Function | 是 | 要用来替换原方法的函数。函数有参数时，则第一个参数是this对象（若isStatic为true，则为类对象即targetClass；若isStatic为false，则为调用方法的实例对象），其余参数是原方法的参数。函数也可以无参，无参时不做处理。 | 758 759**错误码：** 760 761以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 762 763| 错误码ID | 错误信息 | 764| -------- | -------- | 765| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 766 767**示例：** 768 769```ts 770class MyClass { 771 msg: string = 'msg000'; 772 foo(arg: string): string { 773 console.info('foo arg is ' + arg); 774 return this.msg; 775 } 776} 777 778let asp = new MyClass(); 779let result = asp.foo('123'); 780// 输出结果：foo arg is 123 781console.info('result is ' + result); 782// 输出结果：result is msg000 783console.info('asp.msg is ' + asp.msg); 784// 输出结果：asp.msg is msg000 785 786util.Aspect.replace(MyClass, 'foo', false, (instance: MyClass, arg: string): string => { 787 console.info('execute instead') 788 console.info('arg is ' + arg); 789 instance.msg = 'msg111'; 790 console.info('msg is changed to ' + instance.msg); 791 return 'msg222'; 792}); 793 794result = asp.foo('123'); 795// 输出结果：execute instead 796// 输出结果：arg is 123 797// 输出结果：msg is changed to msg111 798console.info('result is ' + result); 799// 输出结果：result is msg222 800console.info('asp.msg is ' + asp.msg); 801// 输出结果：asp.msg is msg111 802``` 803 804## TextDecoder 805 806TextDecoder用于将字节数组解码为字符串，可以处理多种编码格式，包括utf-8、utf-16le/be、iso-8859和windows-1251等不同的编码格式。 807 808### 属性 809 810**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 811 812**系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。 813 814| 名称 | 类型 | 可读 | 可写 | 说明 | 815| -------- | -------- | -------- | -------- | -------- | 816| encoding | string | 是 | 否 | 编码格式。<br/>- 支持格式：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-cyrillic、gbk、gb18030、big5、euc-jp、iso-2022-jp、shift_jis、euc-kr、utf-16be、utf-16le、UTF-8、GBK、GB2312、gb2312、GB18030、iso-8859-1。 | 817| fatal | boolean | 是 | 否 | 是否显示致命错误。 | 818| ignoreBOM | boolean | 是 | 否 | 是否忽略BOM（byte order marker）标记，默认值为false ，表示解码结果包含BOM标记。 | 819 820### constructor<sup>9+</sup> 821 822constructor() 823 824TextDecoder的构造函数。 825 826**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 827 828**系统能力：** SystemCapability.Utils.Lang 829 830**示例：** 831 832```ts 833let textDecoder = new util.TextDecoder(); 834let retStr = textDecoder.encoding; 835``` 836### create<sup>9+</sup> 837 838static create(encoding?: string, options?: TextDecoderOptions): TextDecoder 839 840替代有参构造功能。 841 842**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 843 844**系统能力：** SystemCapability.Utils.Lang 845 846**参数：** 847 848| 参数名 | 类型 | 必填 | 说明 | 849| -------- | ------ | ---- | ------------------------------------------------ | 850| encoding | string | 否 | 编码格式，默认值是'utf-8'。 | 851| options | [TextDecoderOptions](#textdecoderoptions11) | 否 | 解码相关选项参数，存在两个属性fatal和ignoreBOM。| 852 853**错误码：** 854 855以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 856 857| 错误码ID | 错误信息 | 858| -------- | -------- | 859| 401 | Parameter error. Possible causes: 1. Incorrect parameter types. | 860 861**示例：** 862 863```ts 864let textDecoderOptions: util.TextDecoderOptions = { 865 fatal: false, 866 ignoreBOM : true 867} 868let textDecoder = util.TextDecoder.create('utf-8', textDecoderOptions); 869let retStr = textDecoder.encoding; 870``` 871 872### decodeToString<sup>12+</sup> 873 874decodeToString(input: Uint8Array, options?: DecodeToStringOptions): string 875 876通过输入参数解码后输出对应文本。 877 878**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 879 880**系统能力：** SystemCapability.Utils.Lang 881 882**参数：** 883 884| 参数名 | 类型 | 必填 | 说明 | 885| -------- | -------- | -------- | -------- | 886| input | Uint8Array | 是 | 符合格式需要解码的数组。 | 887| options | [DecodeToStringOptions](#decodetostringoptions12) | 否 | 解码相关选项参数。默认undefined。| 888 889**返回值：** 890 891| 类型 | 说明 | 892| -------- | -------- | 893| string | 解码后的数据。 | 894 895**错误码：** 896 897以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 898 899| 错误码ID | 错误信息 | 900| -------- | -------- | 901| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 902 903**示例：** 904 905```ts 906let textDecoderOptions: util.TextDecoderOptions = { 907 fatal: false, 908 ignoreBOM : true 909} 910let decodeToStringOptions: util.DecodeToStringOptions = { 911 stream: false 912} 913let textDecoder = util.TextDecoder.create('utf-8', textDecoderOptions); 914let uint8 = new Uint8Array([0xEF, 0xBB, 0xBF, 0x61, 0x62, 0x63]); 915let retStr = textDecoder.decodeToString(uint8, decodeToStringOptions); 916console.info("retStr = " + retStr); 917``` 918 919### decodeWithStream<sup>(deprecated)</sup> 920 921decodeWithStream(input: Uint8Array, options?: DecodeWithStreamOptions): string 922 923通过输入参数解码后输出对应文本。当input是一个空数组时，返回值为undefined。 924 925> **说明：** 926> 927> 从API version 9开始支持，从API version 12开始废弃，建议使用[decodeToString<sup>12+</sup>](#decodetostring12)替代。 928 929**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 930 931**系统能力：** SystemCapability.Utils.Lang 932 933**参数：** 934 935| 参数名 | 类型 | 必填 | 说明 | 936| -------- | -------- | -------- | -------- | 937| input | Uint8Array | 是 | 符合格式需要解码的数组。 | 938| options | [DecodeWithStreamOptions](#decodewithstreamoptions11) | 否 | 解码相关选项参数。 | 939 940**返回值：** 941 942| 类型 | 说明 | 943| -------- | -------- | 944| string | 解码后的数据。 | 945 946**错误码：** 947 948以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 949 950| 错误码ID | 错误信息 | 951| -------- | -------- | 952| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 953 954**示例：** 955 956```ts 957let textDecoderOptions: util.TextDecoderOptions = { 958 fatal: false, 959 ignoreBOM : true 960} 961let decodeWithStreamOptions: util.DecodeWithStreamOptions = { 962 stream: false 963} 964let textDecoder = util.TextDecoder.create('utf-8', textDecoderOptions); 965let uint8 = new Uint8Array(6); 966uint8[0] = 0xEF; 967uint8[1] = 0xBB; 968uint8[2] = 0xBF; 969uint8[3] = 0x61; 970uint8[4] = 0x62; 971uint8[5] = 0x63; 972console.info("input num:"); 973let retStr = textDecoder.decodeWithStream(uint8, decodeWithStreamOptions); 974console.info("retStr = " + retStr); 975``` 976 977### constructor<sup>(deprecated)</sup> 978 979constructor(encoding?: string, options?: { fatal?: boolean; ignoreBOM?: boolean }) 980 981TextDecoder的构造函数。 982 983> **说明：** 984> 985> 从API version 7开始支持，从API version 9开始废弃，建议使用[create<sup>9+</sup>](#create9)替代。 986 987**系统能力：** SystemCapability.Utils.Lang 988 989**参数：** 990 991| 参数名 | 类型 | 必填 | 说明 | 992| -------- | -------- | -------- | -------- | 993| encoding | string | 否 | 编码格式，默认值是'utf-8'。 | 994| options | object | 否 | 解码相关选项参数，存在两个属性fatal和ignoreBOM。 | 995 996 **表1** options 997 998| 名称 | 参数类型 | 必填 | 说明 | 999| -------- | -------- | -------- | -------- | 1000| fatal | boolean | 否 | 是否显示致命错误，默认值是false。 | 1001| ignoreBOM | boolean | 否 | 是否忽略BOM标记，默认值是false。 | 1002 1003**示例：** 1004 1005```ts 1006let textDecoder = new util.TextDecoder("utf-8",{ignoreBOM: true}); 1007``` 1008 1009### decode<sup>(deprecated)</sup> 1010 1011decode(input: Uint8Array, options?: { stream?: false }): string 1012 1013通过输入参数解码后输出对应文本。 1014 1015> **说明：** 1016> 1017> 从API version 7开始支持，从API version 9开始废弃，建议使用[decodeToString<sup>12+</sup>](#decodetostring12)替代。 1018 1019**系统能力：** SystemCapability.Utils.Lang 1020 1021**参数：** 1022 1023| 参数名 | 类型 | 必填 | 说明 | 1024| -------- | -------- | -------- | -------- | 1025| input | Uint8Array | 是 | 符合格式需要解码的数组。 | 1026| options | object | 否 | 解码相关选项参数。 | 1027 1028**表2** options 1029 1030| 名称 | 参数类型 | 必填 | 说明 | 1031| -------- | -------- | -------- | -------- | 1032| stream | boolean | 否 | 在随后的decode()调用中是否跟随附加数据块。如果以块的形式处理数据，则设置为true；如果处理最后的数据块或数据未分块，则设置为false。默认为false。 | 1033 1034**返回值：** 1035 1036| 类型 | 说明 | 1037| -------- | -------- | 1038| string | 解码后的数据。 | 1039 1040**示例：** 1041 1042```ts 1043let textDecoder = new util.TextDecoder("utf-8",{ignoreBOM: true}); 1044let uint8 = new Uint8Array(6); 1045uint8[0] = 0xEF; 1046uint8[1] = 0xBB; 1047uint8[2] = 0xBF; 1048uint8[3] = 0x61; 1049uint8[4] = 0x62; 1050uint8[5] = 0x63; 1051console.info("input num:"); 1052let retStr = textDecoder.decode(uint8, {stream: false}); 1053console.info("retStr = " + retStr); 1054``` 1055 1056## EncodeIntoUint8ArrayInfo<sup>11+</sup> 1057 1058**系统能力：** SystemCapability.Utils.Lang 1059 1060编码后的文本。 1061 1062**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1063 1064| 名称 | 类型 | 可读 |可写 | 说明 | 1065| --------- | -------- | -------- |-------- |------------------ | 1066| read | number | 是 | 否 |表示已读取的字符数。 | 1067| written | number | 是 |否 |表示已写入的字节数。 | 1068 1069 1070## TextEncoder 1071 1072TextEncoder用于将字符串编码为字节数组，支持多种编码格式。 1073需要注意的是，在使用TextEncoder进行编码时，不同编码格式下字符所占的字节数是不同的，在使用TextEncoder时需要明确指定要使用的编码格式，以确保编码结果正确。 1074 1075### 属性 1076 1077**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1078 1079**系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。 1080 1081| 名称 | 类型 | 可读 | 可写 | 说明 | 1082| -------- | -------- | -------- | -------- | -------- | 1083| encoding | string | 是 | 否 | 编码格式。<br/>- 支持格式：utf-8、UTF-8、GBK、GB2312、gb2312、GB18030、gb18030、ibm866、iso-8859-1、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、gbk、big5、euc-jp、iso-2022-jp、shift_jis、euc-kr、x-mac-cyrillic、utf-16be、utf-16le。 <br/>- 默认值是：'utf-8'。 | 1084 1085 1086### constructor 1087 1088constructor() 1089 1090TextEncoder的构造函数。 1091 1092**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1093 1094**系统能力：** SystemCapability.Utils.Lang 1095 1096**示例：** 1097 1098```ts 1099let textEncoder = new util.TextEncoder(); 1100``` 1101 1102### constructor<sup>9+</sup> 1103 1104constructor(encoding?: string) 1105 1106TextEncoder的构造函数。 1107 1108**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1109 1110**系统能力：** SystemCapability.Utils.Lang 1111 1112**参数：** 1113 1114| 参数名 | 类型 | 必填 | 说明 | 1115| ----- | ---- | ---- | ---- | 1116| encoding | string | 否 | 编码格式，默认值为'utf-8'。 | 1117 1118**错误码：** 1119 1120以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1121 1122| 错误码ID | 错误信息 | 1123| -------- | -------- | 1124| 401 | Parameter error. Possible causes: 1. Incorrect parameter types. | 1125 1126**示例：** 1127 1128```ts 1129let textEncoder = new util.TextEncoder("utf-8"); 1130``` 1131 1132### create<sup>12+</sup> 1133 1134static create(encoding?: string): TextEncoder 1135 1136创建TextEncoder对象的方法。 1137 1138**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 1139 1140**系统能力：** SystemCapability.Utils.Lang 1141 1142**参数：** 1143 1144| 参数名 | 类型 | 必填 | 说明 | 1145| ----- | ---- | ---- | ---- | 1146| encoding | string | 否 | 编码格式，默认值为'utf-8'。 | 1147 1148**错误码：** 1149 1150以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1151 1152| 错误码ID | 错误信息 | 1153| -------- | -------- | 1154| 401 | Parameter error. Possible causes: 1. Incorrect parameter types. | 1155 1156**示例：** 1157 1158```ts 1159let textEncoder = util.TextEncoder.create("utf-8"); 1160``` 1161 1162### encodeInto<sup>9+</sup> 1163 1164encodeInto(input?: string): Uint8Array 1165 1166通过输入参数编码后输出Uint8Array对象。 1167 1168**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1169 1170**系统能力：** SystemCapability.Utils.Lang 1171 1172**参数：** 1173 1174| 参数名 | 类型 | 必填 | 说明 | 1175| ------ | ------ | ---- | ------------------ | 1176| input | string | 否 | 需要编码的字符串，默认值是空字符串。 | 1177 1178**返回值：** 1179 1180| 类型 | 说明 | 1181| ---------- | ------------------ | 1182| Uint8Array | 返回编码后的Uint8Array对象。 | 1183 1184**错误码：** 1185 1186以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1187 1188| 错误码ID | 错误信息 | 1189| -------- | -------- | 1190| 401 | Parameter error. Possible causes: 1. Incorrect parameter types. | 1191 1192**示例：** 1193 1194```ts 1195let textEncoder = new util.TextEncoder(); 1196let result = textEncoder.encodeInto("\uD800¥¥"); 1197console.info("result = " + result); 1198// 输出结果: result = 237,160,128,194,165,194,165 1199``` 1200 1201### encodeIntoUint8Array<sup>9+</sup> 1202 1203encodeIntoUint8Array(input: string, dest: Uint8Array): EncodeIntoUint8ArrayInfo 1204 1205对字符串进行编码，将结果写入dest数组。 1206 1207**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1208 1209**系统能力：** SystemCapability.Utils.Lang 1210 1211**参数：** 1212 1213| 参数名 | 类型 | 必填 | 说明 | 1214| ------ | ---------- | ---- | ------------------------------------------------------- | 1215| input | string | 是 | 需要编码的字符串。 | 1216| dest | Uint8Array | 是 | Uint8Array对象实例，用于将生成的UTF-8编码文本放入其中。 | 1217 1218**返回值：** 1219 1220| 类型 | 说明 | 1221| ---------- | ------------------ | 1222| [EncodeIntoUint8ArrayInfo](#encodeintouint8arrayinfo11) | 返回一个对象，read表示已编码的字符数，write表示编码字符所占用的字节数。 | 1223 1224**错误码：** 1225 1226以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1227 1228| 错误码ID | 错误信息 | 1229| -------- | -------- | 1230| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 1231 1232**示例：** 1233 1234```ts 1235let textEncoder = new util.TextEncoder(); 1236let buffer = new ArrayBuffer(4); 1237let uint8 = new Uint8Array(buffer); 1238let result = textEncoder.encodeIntoUint8Array('abcd', uint8); 1239console.info("uint8 = " + uint8); 1240// 输出结果: uint8 = 97,98,99,100 1241``` 1242 1243### encodeInto<sup>(deprecated)</sup> 1244 1245encodeInto(input: string, dest: Uint8Array): { read: number; written: number } 1246 1247放置生成的UTF-8编码文本。 1248 1249> **说明：** 1250> 1251> 从API version 7开始支持，从API version 9开始废弃，建议使用[encodeIntoUint8Array<sup>9+</sup>](#encodeintouint8array9)替代。 1252 1253**系统能力：** SystemCapability.Utils.Lang 1254 1255**参数：** 1256 1257| 参数名 | 类型 | 必填 | 说明 | 1258| -------- | -------- | -------- | -------- | 1259| input | string | 是 | 需要编码的字符串。 | 1260| dest | Uint8Array | 是 | Uint8Array对象实例，用于将生成的UTF-8编码文本放入其中。 | 1261 1262**返回值：** 1263 1264| 类型 | 说明 | 1265| -------- | -------- | 1266| Uint8Array | 返回编码后的文本。 | 1267 1268**示例：** 1269 1270```ts 1271let textEncoder = new util.TextEncoder(); 1272let buffer = new ArrayBuffer(4); 1273let uint8 = new Uint8Array(buffer); 1274let result = textEncoder.encodeInto('abcd', uint8); 1275console.info("uint8 = " + uint8); 1276// 输出结果: uint8 = 97,98,99,100 1277``` 1278 1279### encode<sup>(deprecated)</sup> 1280 1281encode(input?: string): Uint8Array 1282 1283通过输入参数编码后输出对应文本。 1284 1285> **说明：** 1286> 1287> 从API version 7开始支持，从API version 9开始废弃，建议使用[encodeInto<sup>9+</sup>](#encodeinto9)替代。 1288 1289**系统能力：** SystemCapability.Utils.Lang 1290 1291**参数：** 1292 1293| 参数名 | 类型 | 必填 | 说明 | 1294| -------- | -------- | -------- | -------- | 1295| input | string | 否 | 需要编码的字符串，默认值是空字符串。 | 1296 1297**返回值：** 1298 1299| 类型 | 说明 | 1300| -------- | -------- | 1301| Uint8Array | 返回编码后的文本。 | 1302 1303**示例：** 1304 1305```ts 1306let textEncoder = new util.TextEncoder(); 1307let result = textEncoder.encode("\uD800¥¥"); 1308console.info("result = " + result); 1309// 输出结果: result = 237,160,128,194,165,194,165 1310``` 1311 1312## RationalNumber<sup>8+</sup> 1313 1314RationalNumber主要是对有理数进行比较，获取分子分母等方法。例如使用toString()方法可以将有理数转换为字符串形式，使用该类可以方便地进行有理数的各种操作。 1315 1316### constructor<sup>9+</sup> 1317 1318constructor() 1319 1320RationalNumber的构造函数。 1321 1322**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1323 1324**系统能力：** SystemCapability.Utils.Lang 1325 1326**示例：** 1327 1328```ts 1329let rationalNumber = new util.RationalNumber(); 1330``` 1331 1332### parseRationalNumber<sup>9+</sup> 1333 1334static parseRationalNumber(numerator: number,denominator: number): RationalNumber 1335 1336用于创建具有给定分子和分母的RationalNumber实例。 1337 1338> **说明：** 1339> 1340> 该接口要求参数numerator和denominator必须是整数类型。如果传入的参数是小数类型，不会进行拦截，但是会输出错误信息："parseRationalNumber: The type of Parameter must be integer"。 1341 1342**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1343 1344**系统能力：** SystemCapability.Utils.Lang 1345 1346**参数：** 1347 1348| 参数名 | 类型 | 必填 | 说明 | 1349| ----------- | ------ | ---- | ---------------- | 1350| numerator | number | 是 | 分子，整数类型。取值范围：-Number.MAX_VALUE <= numerator <= Number.MAX_VALUE。| 1351| denominator | number | 是 | 分母，整数类型。取值范围：-Number.MAX_VALUE <= denominator <= Number.MAX_VALUE。| 1352 1353**错误码：** 1354 1355以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1356 1357| 错误码ID | 错误信息 | 1358| -------- | -------- | 1359| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 1360 1361**示例：** 1362 1363```ts 1364let rationalNumber = util.RationalNumber.parseRationalNumber(1,2); 1365``` 1366 1367### createRationalFromString<sup>8+</sup> 1368 1369static createRationalFromString(rationalString: string): RationalNumber 1370 1371基于给定的字符串创建一个RationalNumber对象。 1372 1373> **说明：** 1374> 1375> 该接口要求参数rationalString是字符串格式。如果传入的参数是小数类型字符串格式，不会进行拦截，但是会输出错误信息："createRationalFromString: The type of Parameter must be integer string"。 1376 1377**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1378 1379**系统能力：** SystemCapability.Utils.Lang 1380 1381**参数：** 1382 1383| 参数名 | 类型 | 必填 | 说明 | 1384| -------- | -------- | -------- | -------- | 1385| rationalString | string | 是 | 字符串格式。 | 1386 1387**返回值：** 1388 1389| 类型 | 说明 | 1390| -------- | -------- | 1391| Object | 返回RationalNumber对象。 | 1392 1393**错误码：** 1394 1395以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1396 1397| 错误码ID | 错误信息 | 1398| -------- | -------- | 1399| 401 | The type of rationalString must be string. | 1400 1401**示例：** 1402 1403```ts 1404let rational = util.RationalNumber.createRationalFromString("3/4"); 1405``` 1406 1407### compare<sup>9+</sup> 1408 1409compare(another: RationalNumber): number 1410 1411将当前RationalNumber对象与目标RationalNumber对象进行比较，并返回比较结果。 1412 1413**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1414 1415**系统能力：** SystemCapability.Utils.Lang 1416 1417**参数：** 1418 1419| 参数名 | 类型 | 必填 | 说明 | 1420| ------- | -------------- | ---- | ------------------ | 1421| another | [RationalNumber](#rationalnumber8) | 是 | 其他的有理数对象。 | 1422 1423**返回值：** 1424 1425| 类型 | 说明 | 1426| ------ | ------------------------------------------------------------ | 1427| number | 如果两个对象相等，则返回0；如果给定对象小于当前对象，则返回1；如果给定对象大于当前对象，则返回-1。 | 1428 1429**错误码：** 1430 1431以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1432 1433| 错误码ID | 错误信息 | 1434| -------- | -------- | 1435| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 1436 1437**示例：** 1438 1439```ts 1440let rationalNumber = util.RationalNumber.parseRationalNumber(1,2); 1441let rational = util.RationalNumber.createRationalFromString("3/4"); 1442let result = rationalNumber.compare(rational); 1443console.info("result = " + result); 1444// 输出结果：result = -1 1445``` 1446 1447### valueOf<sup>8+</sup> 1448 1449valueOf(): number 1450 1451以整数形式或者浮点数的形式获取当前RationalNumber对象的值。 1452 1453**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1454 1455**系统能力：** SystemCapability.Utils.Lang 1456 1457**返回值：** 1458 1459| 类型 | 说明 | 1460| -------- | -------- | 1461| number | 返回整数或者浮点数的值。 | 1462 1463**示例：** 1464 1465```ts 1466let rationalNumber = new util.RationalNumber(1,2); 1467let result = rationalNumber.valueOf(); 1468console.info("result = " + result); 1469// 输出结果：result = 0.5 1470``` 1471API 9及以上建议使用以下写法： 1472```ts 1473let rationalNumber = util.RationalNumber.parseRationalNumber(1,2); 1474let result = rationalNumber.valueOf(); 1475console.info("result = " + result); 1476// 输出结果：result = 0.5 1477``` 1478 1479### equals<sup>8+</sup> 1480 1481equals(obj: Object): boolean 1482 1483将当前的RationalNumber对象与给定的对象进行比较是否相等。 1484 1485**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1486 1487**系统能力：** SystemCapability.Utils.Lang 1488 1489**参数：** 1490 1491| 参数名 | 类型 | 必填 | 说明 | 1492| -------- | -------- | -------- | -------- | 1493| obj | Object | 是 | 其他类型对象。 | 1494 1495**返回值：** 1496 1497| 类型 | 说明 | 1498| -------- | -------- | 1499| boolean | 如果给定对象与当前对象相同，则返回true；否则返回false。 | 1500 1501**示例：** 1502 1503```ts 1504let rationalNumber = new util.RationalNumber(1,2); 1505let rational = util.RationalNumber.createRationalFromString("3/4"); 1506let result = rationalNumber.equals(rational); 1507console.info("result = " + result); 1508// 输出结果：result = false 1509``` 1510API 9及以上建议使用以下写法： 1511```ts 1512let rationalNumber = util.RationalNumber.parseRationalNumber(1,2); 1513let rational = util.RationalNumber.createRationalFromString("3/4"); 1514let result = rationalNumber.equals(rational); 1515console.info("result = " + result); 1516// 输出结果：result = false 1517``` 1518 1519### getCommonFactor<sup>9+</sup> 1520 1521static getCommonFactor(number1: number,number2: number): number 1522 1523获取两个指定整数的最大公约数。 1524 1525> **说明：** 1526> 1527> 该接口要求参数number1和number2必须是整数类型。如果传入的参数是小数类型，不会进行拦截，但是会输出错误信息："getCommonFactor: The type of Parameter must be integer"。 1528 1529**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1530 1531**系统能力：** SystemCapability.Utils.Lang 1532 1533**参数：** 1534 1535| 参数名 | 类型 | 必填 | 说明 | 1536| ------- | ------ | ---- | ---------- | 1537| number1 | number | 是 | 整数类型。-Number.MAX_VALUE <= number1 <= Number.MAX_VALUE。| 1538| number2 | number | 是 | 整数类型。-Number.MAX_VALUE <= number2 <= Number.MAX_VALUE。| 1539 1540**返回值：** 1541 1542| 类型 | 说明 | 1543| ------ | ------------------------------ | 1544| number | 返回两个给定数字的最大公约数。 | 1545 1546**错误码：** 1547 1548以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1549 1550| 错误码ID | 错误信息 | 1551| -------- | -------- | 1552| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 1553 1554**示例：** 1555 1556```ts 1557let result = util.RationalNumber.getCommonFactor(4,6); 1558console.info("result = " + result); 1559// 输出结果：result = 2 1560``` 1561 1562### getNumerator<sup>8+</sup> 1563 1564getNumerator(): number 1565 1566获取当前RationalNumber对象的分子。 1567 1568**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1569 1570**系统能力：** SystemCapability.Utils.Lang 1571 1572**返回值：** 1573 1574| 类型 | 说明 | 1575| -------- | -------- | 1576| number | 返回RationalNumber对象的分子的值。 | 1577 1578**示例：** 1579 1580```ts 1581let rationalNumber = new util.RationalNumber(1,2); 1582let result = rationalNumber.getNumerator(); 1583console.info("result = " + result); 1584// 输出结果：result = 1 1585``` 1586API 9及以上建议使用以下写法： 1587```ts 1588let rationalNumber = util.RationalNumber.parseRationalNumber(1,2); 1589let result = rationalNumber.getNumerator(); 1590console.info("result = " + result); 1591// 输出结果：result = 1 1592``` 1593 1594### getDenominator<sup>8+</sup> 1595 1596getDenominator(): number 1597 1598获取当前RationalNumber对象的分母。 1599 1600**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1601 1602**系统能力：** SystemCapability.Utils.Lang 1603 1604**返回值：** 1605 1606| 类型 | 说明 | 1607| -------- | -------- | 1608| number | 返回RationalNumber对象的分母的值。 | 1609 1610**示例：** 1611 1612```ts 1613let rationalNumber = new util.RationalNumber(1,2); 1614let result = rationalNumber.getDenominator(); 1615console.info("result = " + result); 1616// 输出结果：result = 2 1617``` 1618API 9及以上建议使用以下写法： 1619```ts 1620let rationalNumber = util.RationalNumber.parseRationalNumber(1,2) 1621let result = rationalNumber.getDenominator(); 1622console.info("result = " + result); 1623// 输出结果：result = 2 1624``` 1625 1626### isZero<sup>8+</sup> 1627 1628isZero():boolean 1629 1630检查当前RationalNumber对象是否为0。 1631 1632**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1633 1634**系统能力：** SystemCapability.Utils.Lang 1635 1636**返回值：** 1637 1638| 类型 | 说明 | 1639| -------- | -------- | 1640| boolean | 如果当前对象表示的值为0，则返回true；否则返回false。 | 1641 1642**示例：** 1643 1644```ts 1645let rationalNumber = new util.RationalNumber(1,2); 1646let result = rationalNumber.isZero(); 1647console.info("result = " + result); 1648// 输出结果：result = false 1649``` 1650API 9及以上建议使用以下写法： 1651```ts 1652let rationalNumber = util.RationalNumber.parseRationalNumber(1,2); 1653let result = rationalNumber.isZero(); 1654console.info("result = " + result); 1655// 输出结果：result = false 1656``` 1657 1658### isNaN<sup>8+</sup> 1659 1660isNaN(): boolean 1661 1662检查当前RationalNumber对象是否表示非数字(NaN)值。 1663 1664**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1665 1666**系统能力：** SystemCapability.Utils.Lang 1667 1668**返回值：** 1669 1670| 类型 | 说明 | 1671| -------- | -------- | 1672| boolean | 如果分母和分子都为0，则返回true；否则返回false。 | 1673 1674**示例：** 1675 1676```ts 1677let rationalNumber = new util.RationalNumber(1,2); 1678let result = rationalNumber.isNaN(); 1679console.info("result = " + result); 1680// 输出结果：result = false 1681``` 1682API 9及以上建议使用以下写法： 1683```ts 1684let rationalNumber = util.RationalNumber.parseRationalNumber(1,2); 1685let result = rationalNumber.isNaN(); 1686console.info("result = " + result); 1687// 输出结果：result = false 1688``` 1689 1690### isFinite<sup>8+</sup> 1691 1692isFinite():boolean 1693 1694检查当前RationalNumber对象是否表示一个有限值。 1695 1696**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1697 1698**系统能力：** SystemCapability.Utils.Lang 1699 1700**返回值：** 1701 1702| 类型 | 说明 | 1703| -------- | -------- | 1704| boolean | 如果分母不为0，则返回true；否则返回false。 | 1705 1706**示例：** 1707 1708```ts 1709let rationalNumber = new util.RationalNumber(1,2); 1710let result = rationalNumber.isFinite(); 1711console.info("result = " + result); 1712// 输出结果：result = true 1713``` 1714API 9及以上建议使用以下写法： 1715```ts 1716let rationalNumber = util.RationalNumber.parseRationalNumber(1,2); 1717let result = rationalNumber.isFinite(); 1718console.info("result = " + result); 1719// 输出结果：result = true 1720``` 1721 1722### toString<sup>8+</sup> 1723 1724toString(): string 1725 1726获取当前RationalNumber对象的字符串表示形式。 1727 1728**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1729 1730**系统能力：** SystemCapability.Utils.Lang 1731 1732**返回值：** 1733 1734| 类型 | 说明 | 1735| -------- | -------- | 1736| string | 返回Numerator/Denominator格式的字符串，例如3/5，如果当前对象的分子为0，则返回0/1。如果当前对象的分母为0，则返回Infinity。如果当前对象的分子和分母都为0，则返回NaN。| 1737 1738**示例：** 1739 1740```ts 1741let rationalNumber = new util.RationalNumber(1,2); 1742let result = rationalNumber.toString(); 1743console.info("result = " + result); 1744// 输出结果：result = 1/2 1745``` 1746API 9及以上建议使用以下写法： 1747```ts 1748let rationalNumber = util.RationalNumber.parseRationalNumber(1,2); 1749let result = rationalNumber.toString(); 1750console.info("result = " + result); 1751// 输出结果：result = 1/2 1752``` 1753 1754### constructor<sup>(deprecated)</sup> 1755 1756constructor(numerator: number,denominator: number) 1757 1758RationalNumber的构造函数。 1759 1760> **说明：** 1761> 1762> 从API version 8开始支持，从API version 9开始废弃，建议使用[parserationalnumber<sup>9+</sup>](#parserationalnumber9)替代。 1763 1764**系统能力：** SystemCapability.Utils.Lang 1765 1766**参数：** 1767 1768| 参数名 | 类型 | 必填 | 说明 | 1769| -------- | -------- | -------- | -------- | 1770| numerator | number | 是 | 分子，整数类型。 | 1771| denominator | number | 是 | 分母，整数类型。 | 1772 1773**示例：** 1774 1775```ts 1776let rationalNumber = new util.RationalNumber(1,2); 1777``` 1778 1779### compareTo<sup>(deprecated)</sup> 1780 1781compareTo(another: RationalNumber): number 1782 1783将当前的RationalNumber对象与给定的对象进行比较。 1784 1785> **说明：** 1786> 1787> 从API version 8开始支持，从API version 9开始废弃，建议使用[compare<sup>9+</sup>](#compare9)替代。 1788 1789**系统能力：** SystemCapability.Utils.Lang 1790 1791**参数：** 1792 1793| 参数名 | 类型 | 必填 | 说明 | 1794| -------- | -------- | -------- | -------- | 1795| another | RationalNumber | 是 | 其他的有理数对象。 | 1796 1797**返回值：** 1798 1799| 类型 | 说明 | 1800| -------- | -------- | 1801| number | 如果两个对象相等，则返回0；如果给定对象小于当前对象，则返回1；如果给定对象大于当前对象，则返回-1。 | 1802 1803**示例：** 1804 1805```ts 1806let rationalNumber = new util.RationalNumber(1,2); 1807let rational = util.RationalNumber.createRationalFromString("3/4"); 1808let result = rationalNumber.compareTo(rational); 1809``` 1810 1811### getCommonDivisor<sup>(deprecated)</sup> 1812 1813static getCommonDivisor(number1: number,number2: number): number 1814 1815获取两个指定整数的最大公约数。 1816 1817> **说明：** 1818> 1819> 从API version 8开始支持，从API version 9开始废弃，建议使用[getCommonFactor<sup>9+</sup>](#getcommonfactor9)替代。 1820 1821**系统能力：** SystemCapability.Utils.Lang 1822 1823**参数：** 1824 1825| 参数名 | 类型 | 必填 | 说明 | 1826| -------- | -------- | -------- | -------- | 1827| number1 | number | 是 | 整数类型。 | 1828| number2 | number | 是 | 整数类型。 | 1829 1830**返回值：** 1831 1832| 类型 | 说明 | 1833| -------- | -------- | 1834| number | 返回两个给定数字的最大公约数。 | 1835 1836**示例：** 1837 1838```ts 1839let rationalNumber = new util.RationalNumber(1,2); 1840let result = util.RationalNumber.getCommonDivisor(4,6); 1841``` 1842 1843## LRUCache<sup>9+</sup> 1844 1845LRUCache用于在缓存空间不够的时候，将近期最少使用的数据替换为新数据。此设计基于资源访问的考虑：近期访问的数据，可能在不久的将来会再次访问。于是最少访问的数据就是价值最小的数据，是最应该踢出缓存空间的数据。 1846 1847### 属性 1848 1849**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1850 1851**系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。 1852 1853| 名称 | 类型 | 可读 | 可写 | 说明 | 1854| ------ | ------ | ---- | ---- | ---------------------- | 1855| length | number | 是 | 否 | 当前缓冲区中值的总数。 | 1856 1857**示例：** 1858 1859```ts 1860let pro = new util.LRUCache<number, number>(); 1861pro.put(2, 10); 1862pro.put(1, 8); 1863let result = pro.length; 1864console.info('result = ' + result); 1865// 输出结果：result = 2 1866``` 1867 1868### constructor<sup>9+</sup> 1869 1870constructor(capacity?: number) 1871 1872默认构造函数用于创建一个新的LRUCache实例，默认容量为64。 1873 1874**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1875 1876**系统能力：** SystemCapability.Utils.Lang 1877 1878**参数：** 1879 1880| 参数名 | 类型 | 必填 | 说明 | 1881| -------- | ------ | ---- | ---------------------------- | 1882| capacity | number | 否 | 指示要为缓冲区自定义的容量，不传默认值为64，最大值不能超过2147483647。 | 1883 1884**错误码：** 1885 1886以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1887 1888| 错误码ID | 错误信息 | 1889| -------- | -------- | 1890| 401 | Parameter error. Possible causes: 1.Incorrect parameter types. | 1891 1892**示例：** 1893 1894```ts 1895let pro = new util.LRUCache<number, number>(); 1896``` 1897 1898 1899### updateCapacity<sup>9+</sup> 1900 1901updateCapacity(newCapacity: number): void 1902 1903将缓冲区容量更新为指定容量，如果newCapacity小于或等于0，则抛出异常。当缓冲区中值的总数大于指定容量时，会执行删除操作。 1904 1905**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1906 1907**系统能力：** SystemCapability.Utils.Lang 1908 1909**参数：** 1910 1911| 参数名 | 类型 | 必填 | 说明 | 1912| ----------- | ------ | ---- | ---------------------------- | 1913| newCapacity | number | 是 | 指示要为缓冲区自定义的容量，最大值不能超过2147483647。 | 1914 1915**错误码：** 1916 1917以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1918 1919| 错误码ID | 错误信息 | 1920| -------- | -------- | 1921| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. | 1922 1923**示例：** 1924 1925```ts 1926let pro = new util.LRUCache<number, number>(); 1927pro.updateCapacity(100); 1928``` 1929 1930### toString<sup>9+</sup> 1931 1932toString(): string 1933 1934返回对象的字符串表示形式。 1935 1936**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1937 1938**系统能力：** SystemCapability.Utils.Lang 1939 1940**返回值：** 1941 1942| 类型 | 说明 | 1943| ------ | -------------------------- | 1944| string | 返回对象的字符串表示形式。 | 1945 1946**示例：** 1947 1948```ts 1949let pro = new util.LRUCache<number, number>(); 1950pro.put(2, 10); 1951pro.get(2); 1952pro.get(3); 1953console.info(pro.toString()); 1954// 输出结果：LRUCache[ maxSize = 64, hits = 1, misses = 1, hitRate = 50% ] 1955// maxSize: 缓存区最大值 hits: 查询值匹配成功的次数 misses: 查询值匹配失败的次数 hitRate: 查询值匹配率 1956``` 1957 1958### getCapacity<sup>9+</sup> 1959 1960getCapacity(): number 1961 1962获取当前缓冲区的容量。 1963 1964**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1965 1966**系统能力：** SystemCapability.Utils.Lang 1967 1968**返回值：** 1969 1970| 类型 | 说明 | 1971| ------ | ---------------------- | 1972| number | 返回当前缓冲区的容量。 | 1973 1974**示例：** 1975 1976```ts 1977let pro = new util.LRUCache<number, number>(); 1978let result = pro.getCapacity(); 1979console.info('result = ' + result); 1980// 输出结果：result = 64 1981``` 1982 1983### clear<sup>9+</sup> 1984 1985clear(): void 1986 1987从当前缓冲区清除键值对。 1988 1989**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1990 1991**系统能力：** SystemCapability.Utils.Lang 1992 1993**示例：** 1994 1995```ts 1996let pro = new util.LRUCache<number, number>(); 1997pro.put(2, 10); 1998let result = pro.length; 1999pro.clear(); 2000let res = pro.length; 2001console.info('result = ' + result); 2002console.info('res = ' + res); 2003// 输出结果：result = 1 2004// 输出结果：res = 0 2005``` 2006 2007### getCreateCount<sup>9+</sup> 2008 2009getCreateCount(): number 2010 2011获取创建对象的次数。 2012 2013**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2014 2015**系统能力：** SystemCapability.Utils.Lang 2016 2017**返回值：** 2018 2019| 类型 | 说明 | 2020| ------ | -------------------| 2021| number | 返回创建对象的次数。 | 2022 2023**示例：** 2024 2025```ts 2026// 创建新类ChildLRUCache继承LRUCache，重写createDefault方法，返回一个非undefined的值。 2027class ChildLRUCache extends util.LRUCache<number, number> { 2028 constructor() { 2029 super(); 2030 } 2031 2032 createDefault(key: number): number { 2033 return key; 2034 } 2035} 2036let lru = new ChildLRUCache(); 2037lru.put(2, 10); 2038lru.get(3); 2039lru.get(5); 2040let res = lru.getCreateCount(); 2041console.info('res = ' + res); 2042// 输出结果：res = 2 2043``` 2044 2045### getMissCount<sup>9+</sup> 2046 2047getMissCount(): number 2048 2049获取查询值不匹配的次数。 2050 2051**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2052 2053**系统能力：** SystemCapability.Utils.Lang 2054 2055**返回值：** 2056 2057| 类型 | 说明 | 2058| ------ | ------------------------ | 2059| number | 返回查询值不匹配的次数。 | 2060 2061**示例：** 2062 2063```ts 2064let pro = new util.LRUCache<number, number>(); 2065pro.put(2, 10); 2066pro.get(2); 2067let result = pro.getMissCount(); 2068console.info('result = ' + result); 2069// 输出结果：result = 0 2070``` 2071 2072### getRemovalCount<sup>9+</sup> 2073 2074getRemovalCount(): number 2075 2076获取缓冲区键值对回收的次数。 2077 2078**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2079 2080**系统能力：** SystemCapability.Utils.Lang 2081 2082**返回值：** 2083 2084| 类型 | 说明 | 2085| ------ | -------------------------- | 2086| number | 返回缓冲区键值对回收的次数。 | 2087 2088**示例：** 2089 2090```ts 2091let pro = new util.LRUCache<number, number>(); 2092pro.put(2, 10); 2093pro.updateCapacity(2); 2094pro.put(50, 22); 2095let result = pro.getRemovalCount(); 2096console.info('result = ' + result); 2097// 输出结果：result = 0 2098``` 2099 2100### getMatchCount<sup>9+</sup> 2101 2102getMatchCount(): number 2103 2104获取查询值匹配成功的次数。 2105 2106**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2107 2108**系统能力：** SystemCapability.Utils.Lang 2109 2110**返回值：** 2111 2112| 类型 | 说明 | 2113| ------ | -------------------------- | 2114| number | 返回查询值匹配成功的次数。 | 2115 2116**示例：** 2117 2118 ```ts 2119 let pro = new util.LRUCache<number, number>(); 2120 pro.put(2, 10); 2121 pro.get(2); 2122 let result = pro.getMatchCount(); 2123 console.info('result = ' + result); 2124 // 输出结果：result = 1 2125 ``` 2126 2127### getPutCount<sup>9+</sup> 2128 2129getPutCount(): number 2130 2131获取将值添加到缓冲区的次数。 2132 2133**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2134 2135**系统能力：** SystemCapability.Utils.Lang 2136 2137**返回值：** 2138 2139| 类型 | 说明 | 2140| ------ | ---------------------------- | 2141| number | 返回将值添加到缓冲区的次数。 | 2142 2143**示例：** 2144 2145```ts 2146let pro = new util.LRUCache<number, number>(); 2147pro.put(2, 10); 2148let result = pro.getPutCount(); 2149console.info('result = ' + result); 2150// 输出结果：result = 1 2151``` 2152 2153### isEmpty<sup>9+</sup> 2154 2155isEmpty(): boolean 2156 2157检查当前缓冲区是否为空。 2158 2159**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2160 2161**系统能力：** SystemCapability.Utils.Lang 2162 2163**返回值：** 2164 2165| 类型 | 说明 | 2166| ------- | ---------------------------------------- | 2167| boolean | 如果当前缓冲区不包含任何值，则返回true。 | 2168 2169**示例：** 2170 2171```ts 2172let pro = new util.LRUCache<number, number>(); 2173pro.put(2, 10); 2174let result = pro.isEmpty(); 2175console.info('result = ' + result); 2176// 输出结果：result = false 2177``` 2178 2179### get<sup>9+</sup> 2180 2181get(key: K): V | undefined 2182 2183返回键对应的值。当键不在缓冲区中时，通过[createDefault<sup>9+</sup>](#createdefault9)接口创建，若createDefault创建的值不为undefined时，此时会调用[afterRemoval<sup>9+</sup>](#afterremoval9)接口，返回createDefault创建的值。 2184 2185**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2186 2187**系统能力：** SystemCapability.Utils.Lang 2188 2189**参数：** 2190 2191| 参数名 | 类型 | 必填 | 说明 | 2192| ------ | ---- | ---- | ------------ | 2193| key | K | 是 | 要查询的键。 | 2194 2195**返回值：** 2196 2197| 类型 | 说明 | 2198| ------------------------ | ------------------------------------------------------------ | 2199| V \| undefined | 如果指定的键存在于缓冲区中，则返回与键关联的值；否则返回createDefault创建的值。 | 2200 2201**错误码：** 2202 2203以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2204 2205| 错误码ID | 错误信息 | 2206| -------- | -------- | 2207| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2208 2209**示例：** 2210 2211```ts 2212let pro = new util.LRUCache<number, number>(); 2213pro.put(2, 10); 2214let result = pro.get(2); 2215console.info('result = ' + result); 2216// 输出结果：result = 10 2217``` 2218 2219### put<sup>9+</sup> 2220 2221put(key: K,value: V): V 2222 2223将键值对添加到缓冲区中，返回与添加的键关联的值。当缓冲区中值的总数大于容量时，会执行删除操作。 2224 2225**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2226 2227**系统能力：** SystemCapability.Utils.Lang 2228 2229**参数：** 2230 2231| 参数名 | 类型 | 必填 | 说明 | 2232| ------ | ---- | ---- | -------------------------- | 2233| key | K | 是 | 要添加的键。 | 2234| value | V | 是 | 指示与要添加的键关联的值。 | 2235 2236**返回值：** 2237 2238| 类型 | 说明 | 2239| ---- | ------------------------------------------------------------ | 2240| V | 返回与添加的键关联的值。如果键或值为空，则抛出此异常。 | 2241 2242**错误码：** 2243 2244以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2245 2246| 错误码ID | 错误信息 | 2247| -------- | -------- | 2248| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2249 2250**示例：** 2251 2252```ts 2253let pro = new util.LRUCache<number, number>(); 2254let result = pro.put(2, 10); 2255console.info('result = ' + result); 2256// 输出结果：result = 10 2257``` 2258 2259### values<sup>9+</sup> 2260 2261values(): V[] 2262 2263获取当前缓冲区中所有值从最近访问到最近最少访问的顺序列表 。 2264 2265**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2266 2267**系统能力：** SystemCapability.Utils.Lang 2268 2269**返回值：** 2270 2271| 类型 | 说明 | 2272| --------- | ------------------------------------------------------------ | 2273| V [] | 按从最近访问到最近最少访问的顺序返回当前缓冲区中所有值的列表。 | 2274 2275**示例：** 2276 2277```ts 2278let pro = new util.LRUCache<number|string,number|string>(); 2279pro.put(2, 10); 2280pro.put(2, "anhu"); 2281pro.put("afaf", "grfb"); 2282let result = pro.values(); 2283console.info('result = ' + result); 2284// 输出结果：result = anhu,grfb 2285``` 2286 2287### keys<sup>9+</sup> 2288 2289keys(): K[] 2290 2291获取当前缓冲区中所有键从最近访问到最近最少访问的升序列表。 2292 2293**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2294 2295**系统能力：** SystemCapability.Utils.Lang 2296 2297**返回值：** 2298 2299| 类型 | 说明 | 2300| --------- | ------------------------------------------------------------ | 2301| K [] | 按升序返回当前缓冲区中所有键的列表，从最近访问到最近最少访问。 | 2302 2303**示例：** 2304 2305```ts 2306let pro = new util.LRUCache<number, number>(); 2307pro.put(2, 10); 2308pro.put(3, 1); 2309let result = pro.keys(); 2310console.info('result = ' + result); 2311// 输出结果：result = 2,3 2312``` 2313 2314### remove<sup>9+</sup> 2315 2316remove(key: K): V | undefined 2317 2318从当前缓冲区中删除指定的键及其关联的值，返回键关联的值。如果键不存在时，则返回undefined。 2319 2320**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2321 2322**系统能力：** SystemCapability.Utils.Lang 2323 2324**参数：** 2325 2326| 参数名 | 类型 | 必填 | 说明 | 2327| ------ | ---- | ---- | -------------- | 2328| key | K | 是 | 要删除的键值。 | 2329 2330**返回值：** 2331 2332| 类型 | 说明 | 2333| ------------------------ | ------------------------------------------------------------ | 2334| V \| undefined | 返回一个包含已删除键值对的Optional对象；如果key不存在，则返回undefined，如果key为null，则抛出异常。 | 2335 2336**错误码：** 2337 2338以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2339 2340| 错误码ID | 错误信息 | 2341| -------- | -------- | 2342| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2343 2344**示例：** 2345 2346```ts 2347let pro = new util.LRUCache<number, number>(); 2348pro.put(2, 10); 2349let result = pro.remove(20); 2350console.info('result = ' + result); 2351// 输出结果：result = undefined 2352``` 2353 2354### afterRemoval<sup>9+</sup> 2355 2356afterRemoval(isEvict: boolean,key: K,value: V,newValue: V): void 2357 2358删除值后执行后续操作，后续操作由开发者自行实现。本接口会在删除操作时被调用，如[get<sup>9+</sup>](#get9)、[put<sup>9+</sup>](#put9)、[remove<sup>9+</sup>](#remove9)、[clear<sup>9+</sup>](#clear9)、[updateCapacity<sup>9+</sup>](#updatecapacity9)接口。 2359 2360**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2361 2362**系统能力：** SystemCapability.Utils.Lang 2363 2364**参数：** 2365 2366| 参数名 | 类型 | 必填 | 说明 | 2367| -------- | ------- | ---- | ------------------------------------------------------------ | 2368| isEvict | boolean | 是 | 因容量不足而调用该方法时，参数值为true，其他情况为false。 | 2369| key | K | 是 | 表示删除的键。 | 2370| value | V | 是 | 表示删除的值。 | 2371| newValue | V | 是 | 如果已调用put方法并且要添加的键已经存在，则参数值是关联的新值。其他情况下参数值为空。 | 2372 2373**错误码：** 2374 2375以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2376 2377| 错误码ID | 错误信息 | 2378| -------- | -------- | 2379| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2380 2381**示例：** 2382 2383```ts 2384class ChildLRUCache<K, V> extends util.LRUCache<K, V> { 2385 constructor(capacity?: number) { 2386 super(capacity); 2387 } 2388 2389 afterRemoval(isEvict: boolean, key: K, value: V, newValue: V): void { 2390 if (isEvict === true) { 2391 console.info('key = ' + key); 2392 // 输出结果：key = 1 2393 console.info('value = ' + value); 2394 // 输出结果：value = 1 2395 console.info('newValue = ' + newValue); 2396 // 输出结果：newValue = null 2397 } 2398 } 2399} 2400let lru = new ChildLRUCache<number, number>(2); 2401lru.put(1, 1); 2402lru.put(2, 2); 2403lru.put(3, 3); 2404``` 2405 2406### contains<sup>9+</sup> 2407 2408contains(key: K): boolean 2409 2410检查当前缓冲区是否包含指定的键。 2411 2412**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2413 2414**系统能力：** SystemCapability.Utils.Lang 2415 2416**参数：** 2417 2418| 参数名 | 类型 | 必填 | 说明 | 2419| ------ | ------ | ---- | ---------------- | 2420| key | K | 是 | 表示要检查的键。 | 2421 2422**返回值：** 2423 2424| 类型 | 说明 | 2425| ------- | ------------------------------------------ | 2426| boolean | 如果缓冲区包含指定的键，则返回 true。 | 2427 2428**错误码：** 2429 2430以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2431 2432| 错误码ID | 错误信息 | 2433| -------- | -------- | 2434| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2435 2436**示例：** 2437 2438```ts 2439let pro = new util.LRUCache<number, number>(); 2440pro.put(2, 10); 2441let result = pro.contains(2); 2442console.info('result = ' + result); 2443// 输出结果：result = true 2444``` 2445 2446### createDefault<sup>9+</sup> 2447 2448createDefault(key: K): V 2449 2450如果在缓冲区未匹配到键，则执行后续操作，参数表示未匹配的键，返回与键关联的值，默认返回undefined。 2451 2452**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2453 2454**系统能力：** SystemCapability.Utils.Lang 2455 2456**参数：** 2457 2458| 参数名 | 类型 | 必填 | 说明 | 2459| ------ | ---- | ---- | -------------- | 2460| key | K | 是 | 表示未匹配的键。 | 2461 2462**返回值：** 2463 2464| 类型 | 说明 | 2465| ---- | ------------------ | 2466| V | 返回与键关联的值。 | 2467 2468**错误码：** 2469 2470以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2471 2472| 错误码ID | 错误信息 | 2473| -------- | -------- | 2474| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2475 2476**示例：** 2477 2478```ts 2479let pro = new util.LRUCache<number, number>(); 2480let result = pro.createDefault(50); 2481console.info('result = ' + result); 2482// 输出结果：result = undefined 2483``` 2484 2485### entries<sup>9+</sup> 2486 2487entries(): IterableIterator<[K,V]> 2488 2489允许迭代包含在这个对象中的所有键值对。 2490 2491**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2492 2493**系统能力：** SystemCapability.Utils.Lang 2494 2495**返回值：** 2496 2497| 类型 | 说明 | 2498| ----------- | -------------------- | 2499| [K, V] | 返回一个可迭代数组。 | 2500 2501**示例：** 2502 2503```ts 2504let pro = new util.LRUCache<number, number>(); 2505pro.put(2, 10); 2506pro.put(3, 15); 2507let pair:Iterable<Object[]> = pro.entries(); 2508let arrayValue = Array.from(pair); 2509for (let value of arrayValue) { 2510 console.info(value[0]+ ', '+ value[1]); 2511 // 输出结果： 2512 // 2, 10 2513 // 3, 15 2514} 2515``` 2516 2517### [Symbol.iterator]<sup>9+</sup> 2518 2519[Symbol.iterator]\(): IterableIterator<[K, V]> 2520 2521返回一个键值对形式的二维数组。 2522 2523**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2524 2525**系统能力：** SystemCapability.Utils.Lang 2526 2527**返回值：** 2528 2529| 类型 | 说明 | 2530| ----------- | ------------------------------ | 2531| [K, V] | 返回一个键值对形式的二维数组。 | 2532 2533**示例：** 2534 2535```ts 2536let pro = new util.LRUCache<number, number>(); 2537pro.put(2, 10); 2538pro.put(3, 15); 2539let pair:Iterable<Object[]> = pro[Symbol.iterator](); 2540let arrayValue = Array.from(pair); 2541for (let value of arrayValue) { 2542 console.info(value[0]+ ', '+ value[1]); 2543 // 输出结果： 2544 // 2, 10 2545 // 3, 15 2546} 2547``` 2548 2549## ScopeComparable<sup>8+</sup> 2550 2551ScopeComparable类型的值需要实现compareTo方法，确保传入的数据具有可比性。 2552 2553**系统能力：** SystemCapability.Utils.Lang 2554 2555### compareTo<sup>8+</sup> 2556 2557compareTo(other: ScopeComparable): boolean 2558 2559比较两个值的大小，返回一个布尔值。 2560 2561**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2562 2563**系统能力：** SystemCapability.Utils.Lang 2564 2565**参数：** 2566 2567| 参数名 | 类型 | 必填 | 说明 | 2568| ------ | ---- | ---- | -------------- | 2569| other | [ScopeComparable](#scopecomparable8) | 是 | 表示要比较的值。 | 2570 2571**返回值：** 2572 2573| 类型 | 说明 | 2574| ---- | ------------------ | 2575| boolean | 调用compareTo的值大于等于传入的值返回true，否则返回false。| 2576 2577**示例：** 2578 2579构造新类，实现compareTo方法。后续示例代码中，均以此Temperature类为例。 2580 2581```ts 2582class Temperature{ 2583 private readonly _temp: number; 2584 constructor(value : number) { 2585 this._temp = value; 2586 } 2587 compareTo(value : Temperature ) { 2588 return this._temp >= value.getTemp(); 2589 } 2590 getTemp() { 2591 return this._temp; 2592 } 2593 toString() : string { 2594 return this._temp.toString(); 2595 } 2596} 2597``` 2598 2599## ScopeType<sup>8+</sup> 2600 2601type ScopeType = ScopeComparable | number 2602 2603用于表示范围中的值的类型。 2604 2605**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2606 2607**系统能力：** SystemCapability.Utils.Lang 2608 2609| 类型 | 说明 | 2610| -------- | -------- | 2611| number | 表示值的类型为数字。 | 2612| [ScopeComparable](#scopecomparable8) | 表示值的类型为ScopeComparable。| 2613 2614## ScopeHelper<sup>9+</sup> 2615 2616ScopeHelper接口用于描述一个字段的有效范围。ScopeHelper实例的构造函数用于创建具有指定下限和上限的对象，并要求这些对象必须具有可比性。 2617 2618### constructor<sup>9+</sup> 2619 2620constructor(lowerObj: ScopeType, upperObj: ScopeType) 2621 2622用于创建指定下限和上限的作用域实例的构造函数，返回一个ScopeHelper对象。 2623 2624**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2625 2626**系统能力：** SystemCapability.Utils.Lang 2627 2628**参数：** 2629 2630| 参数名 | 类型 | 必填 | 说明 | 2631| -------- | ------------------------ | ---- | ---------------------- | 2632| lowerObj | [ScopeType](#scopetype8) | 是 | 指定作用域实例的下限。 | 2633| upperObj | [ScopeType](#scopetype8) | 是 | 指定作用域实例的上限。 | 2634 2635**错误码：** 2636 2637以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2638 2639| 错误码ID | 错误信息 | 2640| -------- | -------- | 2641| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2642 2643**示例：** 2644 2645```ts 2646class Temperature{ 2647 private readonly _temp: number; 2648 constructor(value : number) { 2649 this._temp = value; 2650 } 2651 compareTo(value : Temperature ) { 2652 return this._temp >= value.getTemp(); 2653 } 2654 getTemp() { 2655 return this._temp; 2656 } 2657 toString() : string { 2658 return this._temp.toString(); 2659 } 2660} 2661let tempLower = new Temperature(30); 2662let tempUpper = new Temperature(40); 2663let range = new util.ScopeHelper(tempLower, tempUpper); 2664``` 2665 2666### toString<sup>9+</sup> 2667 2668toString(): string 2669 2670该字符串化方法返回一个包含当前范围的字符串表示形式。 2671 2672**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2673 2674**系统能力：** SystemCapability.Utils.Lang 2675 2676**返回值：** 2677 2678| 类型 | 说明 | 2679| ------ | -------------------------------------- | 2680| string | 返回包含当前范围对象的字符串表示形式。 | 2681 2682**示例：** 2683 2684```ts 2685class Temperature{ 2686 private readonly _temp: number; 2687 constructor(value : number) { 2688 this._temp = value; 2689 } 2690 compareTo(value : Temperature ) { 2691 return this._temp >= value.getTemp(); 2692 } 2693 getTemp() { 2694 return this._temp; 2695 } 2696 toString() : string { 2697 return this._temp.toString(); 2698 } 2699} 2700 2701let tempLower = new Temperature(30); 2702let tempUpper = new Temperature(40); 2703let range = new util.ScopeHelper(tempLower, tempUpper); 2704let result = range.toString(); 2705``` 2706 2707### intersect<sup>9+</sup> 2708 2709intersect(range: ScopeHelper): ScopeHelper 2710 2711获取给定范围和当前范围的交集。 2712 2713**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2714 2715**系统能力：** SystemCapability.Utils.Lang 2716 2717**参数：** 2718 2719| 参数名 | 类型 | 必填 | 说明 | 2720| ------ | ---------------------------- | ---- | ------------------ | 2721| range | [ScopeHelper](#scopehelper9) | 是 | 传入一个给定范围。 | 2722 2723**返回值：** 2724 2725| 类型 | 说明 | 2726| ------------------------------ | ------------------------------ | 2727| [ScopeHelper](#scopehelper9) | 返回给定范围和当前范围的交集。 | 2728 2729**错误码：** 2730 2731以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2732 2733| 错误码ID | 错误信息 | 2734| -------- | -------- | 2735| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2736 2737**示例：** 2738 2739```ts 2740class Temperature{ 2741 private readonly _temp: number; 2742 constructor(value : number) { 2743 this._temp = value; 2744 } 2745 compareTo(value : Temperature ) { 2746 return this._temp >= value.getTemp(); 2747 } 2748 getTemp() { 2749 return this._temp; 2750 } 2751 toString() : string { 2752 return this._temp.toString(); 2753 } 2754} 2755 2756let tempLower = new Temperature(30); 2757let tempUpper = new Temperature(40); 2758let range = new util.ScopeHelper(tempLower, tempUpper); 2759let tempMiDF = new Temperature(35); 2760let tempMidS = new Temperature(39); 2761let rangeFir = new util.ScopeHelper(tempMiDF, tempMidS); 2762range.intersect(rangeFir); 2763``` 2764 2765### intersect<sup>9+</sup> 2766 2767intersect(lowerObj:ScopeType,upperObj:ScopeType):ScopeHelper 2768 2769获取当前范围与给定下限和上限范围的交集。 2770 2771**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2772 2773**系统能力：** SystemCapability.Utils.Lang 2774 2775**参数：** 2776 2777| 参数名 | 类型 | 必填 | 说明 | 2778| -------- | ------------------------ | ---- | ---------------- | 2779| lowerObj | [ScopeType](#scopetype8) | 是 | 给定范围的下限。 | 2780| upperObj | [ScopeType](#scopetype8) | 是 | 给定范围的上限。 | 2781 2782**返回值：** 2783 2784| 类型 | 说明 | 2785| ---------------------------- | ---------------------------------------- | 2786| [ScopeHelper](#scopehelper9) | 返回当前范围与给定下限和上限范围的交集。 | 2787 2788**错误码：** 2789 2790以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2791 2792| 错误码ID | 错误信息 | 2793| -------- | -------- | 2794| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2795 2796**示例：** 2797 2798```ts 2799class Temperature{ 2800 private readonly _temp: number; 2801 constructor(value : number) { 2802 this._temp = value; 2803 } 2804 compareTo(value : Temperature ) { 2805 return this._temp >= value.getTemp(); 2806 } 2807 getTemp() { 2808 return this._temp; 2809 } 2810 toString() : string { 2811 return this._temp.toString(); 2812 } 2813} 2814 2815let tempLower = new Temperature(30); 2816let tempUpper = new Temperature(40); 2817let tempMiDF = new Temperature(35); 2818let tempMidS = new Temperature(39); 2819let range = new util.ScopeHelper(tempLower, tempUpper); 2820let result = range.intersect(tempMiDF, tempMidS); 2821``` 2822 2823### getUpper<sup>9+</sup> 2824 2825getUpper(): ScopeType 2826 2827获取当前范围的上限。 2828 2829**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2830 2831**系统能力：** SystemCapability.Utils.Lang 2832 2833**返回值：** 2834 2835| 类型 | 说明 | 2836| ------------------------ | ---------------------- | 2837| [ScopeType](#scopetype8) | 返回当前范围的上限值。 | 2838 2839**示例：** 2840 2841```ts 2842class Temperature{ 2843 private readonly _temp: number; 2844 constructor(value : number) { 2845 this._temp = value; 2846 } 2847 compareTo(value : Temperature ) { 2848 return this._temp >= value.getTemp(); 2849 } 2850 getTemp() { 2851 return this._temp; 2852 } 2853 toString() : string { 2854 return this._temp.toString(); 2855 } 2856} 2857 2858let tempLower = new Temperature(30); 2859let tempUpper = new Temperature(40); 2860let range = new util.ScopeHelper(tempLower, tempUpper); 2861let result = range.getUpper(); 2862``` 2863 2864### getLower<sup>9+</sup> 2865 2866getLower(): ScopeType 2867 2868获取当前范围的下限。 2869 2870**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2871 2872**系统能力：** SystemCapability.Utils.Lang 2873 2874**返回值：** 2875 2876| 类型 | 说明 | 2877| ------------------------ | ---------------------- | 2878| [ScopeType](#scopetype8) | 返回当前范围的下限值。 | 2879 2880**示例：** 2881 2882```ts 2883class Temperature{ 2884 private readonly _temp: number; 2885 constructor(value : number) { 2886 this._temp = value; 2887 } 2888 compareTo(value : Temperature ) { 2889 return this._temp >= value.getTemp(); 2890 } 2891 getTemp() { 2892 return this._temp; 2893 } 2894 toString() : string { 2895 return this._temp.toString(); 2896 } 2897} 2898 2899let tempLower = new Temperature(30); 2900let tempUpper = new Temperature(40); 2901let range = new util.ScopeHelper(tempLower, tempUpper); 2902let result = range.getLower(); 2903``` 2904 2905### expand<sup>9+</sup> 2906 2907expand(lowerObj: ScopeType,upperObj: ScopeType): ScopeHelper 2908 2909创建并返回包括当前范围和给定下限和上限的并集。 2910 2911**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2912 2913**系统能力：** SystemCapability.Utils.Lang 2914 2915**参数：** 2916 2917| 参数名 | 类型 | 必填 | 说明 | 2918| -------- | ------------------------ | ---- | ---------------- | 2919| lowerObj | [ScopeType](#scopetype8) | 是 | 给定范围的下限。 | 2920| upperObj | [ScopeType](#scopetype8) | 是 | 给定范围的上限。 | 2921 2922**返回值：** 2923 2924| 类型 | 说明 | 2925| ---------------------------- | ------------------------------------ | 2926| [ScopeHelper](#scopehelper9) | 返回当前范围和给定下限和上限的并集。 | 2927 2928**错误码：** 2929 2930以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2931 2932| 错误码ID | 错误信息 | 2933| -------- | -------- | 2934| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2935 2936**示例：** 2937 2938```ts 2939class Temperature{ 2940 private readonly _temp: number; 2941 constructor(value : number) { 2942 this._temp = value; 2943 } 2944 compareTo(value : Temperature ) { 2945 return this._temp >= value.getTemp(); 2946 } 2947 getTemp() { 2948 return this._temp; 2949 } 2950 toString() : string { 2951 return this._temp.toString(); 2952 } 2953} 2954 2955let tempLower = new Temperature(30); 2956let tempUpper = new Temperature(40); 2957let tempMiDF = new Temperature(35); 2958let tempMidS = new Temperature(39); 2959let range = new util.ScopeHelper(tempLower, tempUpper); 2960let result = range.expand(tempMiDF, tempMidS); 2961``` 2962 2963### expand<sup>9+</sup> 2964 2965expand(range: ScopeHelper): ScopeHelper 2966 2967创建并返回包括当前范围和给定范围的并集。 2968 2969**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2970 2971**系统能力：** SystemCapability.Utils.Lang 2972 2973**参数：** 2974 2975| 参数名 | 类型 | 必填 | 说明 | 2976| ------ | ---------------------------- | ---- | ------------------ | 2977| range | [ScopeHelper](#scopehelper9) | 是 | 传入一个给定范围。 | 2978 2979**返回值：** 2980 2981| 类型 | 说明 | 2982| ---------------------------- | ---------------------------------- | 2983| [ScopeHelper](#scopehelper9) | 返回包括当前范围和给定范围的并集。 | 2984 2985**错误码：** 2986 2987以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2988 2989| 错误码ID | 错误信息 | 2990| -------- | -------- | 2991| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2992 2993**示例：** 2994 2995```ts 2996class Temperature{ 2997 private readonly _temp: number; 2998 constructor(value : number) { 2999 this._temp = value; 3000 } 3001 compareTo(value : Temperature ) { 3002 return this._temp >= value.getTemp(); 3003 } 3004 getTemp() { 3005 return this._temp; 3006 } 3007 toString() : string { 3008 return this._temp.toString(); 3009 } 3010} 3011 3012let tempLower = new Temperature(30); 3013let tempUpper = new Temperature(40); 3014let tempMiDF = new Temperature(35); 3015let tempMidS = new Temperature(39); 3016let range = new util.ScopeHelper(tempLower, tempUpper); 3017let rangeFir = new util.ScopeHelper(tempMiDF, tempMidS); 3018let result = range.expand(rangeFir); 3019``` 3020 3021### expand<sup>9+</sup> 3022 3023expand(value: ScopeType): ScopeHelper 3024 3025创建并返回包括当前范围和给定值的并集。 3026 3027**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3028 3029**系统能力：** SystemCapability.Utils.Lang 3030 3031**参数：** 3032 3033| 参数名 | 类型 | 必填 | 说明 | 3034| ------ | ------------------------ | ---- | ---------------- | 3035| value | [ScopeType](#scopetype8) | 是 | 传入一个给定值。 | 3036 3037**返回值：** 3038 3039| 类型 | 说明 | 3040| ---------------------------- | -------------------------------- | 3041| [ScopeHelper](#scopehelper9) | 返回包括当前范围和给定值的并集。 | 3042 3043**错误码：** 3044 3045以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3046 3047| 错误码ID | 错误信息 | 3048| -------- | -------- | 3049| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3050 3051**示例：** 3052 3053```ts 3054class Temperature{ 3055 private readonly _temp: number; 3056 constructor(value : number) { 3057 this._temp = value; 3058 } 3059 compareTo(value : Temperature ) { 3060 return this._temp >= value.getTemp(); 3061 } 3062 getTemp() { 3063 return this._temp; 3064 } 3065 toString() : string { 3066 return this._temp.toString(); 3067 } 3068} 3069 3070let tempLower = new Temperature(30); 3071let tempUpper = new Temperature(40); 3072let tempMiDF = new Temperature(35); 3073let range = new util.ScopeHelper(tempLower, tempUpper); 3074let result = range.expand(tempMiDF); 3075``` 3076 3077### contains<sup>9+</sup> 3078 3079contains(value: ScopeType): boolean 3080 3081检查给定value是否包含在当前范围内。 3082 3083**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3084 3085**系统能力：** SystemCapability.Utils.Lang 3086 3087**参数：** 3088 3089| 参数名 | 类型 | 必填 | 说明 | 3090| ------ | ------------------------ | ---- | ---------------- | 3091| value | [ScopeType](#scopetype8) | 是 | 传入一个给定值。 | 3092 3093**返回值：** 3094 3095| 类型 | 说明 | 3096| ------- | --------------------------------------------------- | 3097| boolean | 如果给定值包含在当前范围内返回true，否则返回false。 | 3098 3099**错误码：** 3100 3101以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3102 3103| 错误码ID | 错误信息 | 3104| -------- | -------- | 3105| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3106 3107**示例：** 3108 3109```ts 3110class Temperature{ 3111 private readonly _temp: number; 3112 constructor(value : number) { 3113 this._temp = value; 3114 } 3115 compareTo(value : Temperature ) { 3116 return this._temp >= value.getTemp(); 3117 } 3118 getTemp() { 3119 return this._temp; 3120 } 3121 toString() : string { 3122 return this._temp.toString(); 3123 } 3124} 3125 3126let tempLower = new Temperature(30); 3127let tempUpper = new Temperature(40); 3128let tempMiDF = new Temperature(35); 3129let range = new util.ScopeHelper(tempLower, tempUpper); 3130let result = range.contains(tempMiDF); 3131``` 3132 3133### contains<sup>9+</sup> 3134 3135contains(range: ScopeHelper): boolean 3136 3137检查给定range是否在当前范围内。 3138 3139**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3140 3141**系统能力：** SystemCapability.Utils.Lang 3142 3143**参数：** 3144 3145| 参数名 | 类型 | 必填 | 说明 | 3146| ------ | ---------------------------- | ---- | ------------------ | 3147| range | [ScopeHelper](#scopehelper9) | 是 | 传入一个给定范围。 | 3148 3149**返回值：** 3150 3151| 类型 | 说明 | 3152| ------- | ----------------------------------------------------- | 3153| boolean | 如果给定范围包含在当前范围内返回true，否则返回false。 | 3154 3155**错误码：** 3156 3157以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3158 3159| 错误码ID | 错误信息 | 3160| -------- | -------- | 3161| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3162 3163**示例：** 3164 3165```ts 3166class Temperature{ 3167 private readonly _temp: number; 3168 constructor(value : number) { 3169 this._temp = value; 3170 } 3171 compareTo(value : Temperature ) { 3172 return this._temp >= value.getTemp(); 3173 } 3174 getTemp() { 3175 return this._temp; 3176 } 3177 toString() : string { 3178 return this._temp.toString(); 3179 } 3180} 3181 3182let tempLower = new Temperature(30); 3183let tempUpper = new Temperature(40); 3184let range = new util.ScopeHelper(tempLower, tempUpper); 3185let tempLess = new Temperature(20); 3186let tempMore = new Temperature(45); 3187let rangeSec = new util.ScopeHelper(tempLess, tempMore); 3188let result = range.contains(rangeSec); 3189``` 3190 3191### clamp<sup>9+</sup> 3192 3193clamp(value: ScopeType): ScopeType 3194 3195将给定值限定到当前范围内。 3196 3197**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3198 3199**系统能力：** SystemCapability.Utils.Lang 3200 3201**参数：** 3202 3203| 参数名 | 类型 | 必填 | 说明 | 3204| ------ | ------------------------ | ---- | -------------- | 3205| value | [ScopeType](#scopetype8) | 是 | 传入的给定值。 | 3206 3207**返回值：** 3208 3209| 类型 | 说明 | 3210| ------------------------ | ------------------------------------------------------------ | 3211| [ScopeType](#scopetype8) | 如果传入的value小于下限，则返回lowerObj；如果大于上限值则返回upperObj；如果在当前范围内，则返回value。 | 3212 3213**错误码：** 3214 3215以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3216 3217| 错误码ID | 错误信息 | 3218| -------- | -------- | 3219| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3220 3221**示例：** 3222 3223```ts 3224class Temperature{ 3225 private readonly _temp: number; 3226 constructor(value : number) { 3227 this._temp = value; 3228 } 3229 compareTo(value : Temperature ) { 3230 return this._temp >= value.getTemp(); 3231 } 3232 getTemp() { 3233 return this._temp; 3234 } 3235 toString() : string { 3236 return this._temp.toString(); 3237 } 3238} 3239 3240let tempLower = new Temperature(30); 3241let tempUpper = new Temperature(40); 3242let tempMiDF = new Temperature(35); 3243let range = new util.ScopeHelper(tempLower, tempUpper); 3244let result = range.clamp(tempMiDF); 3245``` 3246 3247## Base64Helper<sup>9+</sup> 3248 3249Base64Helper类提供Base64编解码和Base64URL编解码功能。Base64编码表包含A-Z、a-z、0-9这62个字符，以及"+"和"/"这两个特殊字符。在编码时，将原始数据按3个字节一组进行划分，得到若干个6位的数字，然后使用Base64编码表中对应的字符来表示这些数字。如果最后剩余1或2个字节，则需要使用"="字符进行补齐。Base64URL编码表包含A-Z、a-z、0-9以及"-"和"_"64个字符，Base64URL编码结果不含"="。 3250 3251### constructor<sup>9+</sup> 3252 3253constructor() 3254 3255Base64Helper的构造函数。 3256 3257**系统能力：** SystemCapability.Utils.Lang 3258 3259**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 3260 3261**示例：** 3262 3263 ```ts 3264 let base64 = new util.Base64Helper(); 3265 ``` 3266 3267### encodeSync<sup>9+</sup> 3268 3269encodeSync(src: Uint8Array, options?: Type): Uint8Array 3270 3271通过输入参数编码后输出Uint8Array对象。 3272 3273**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 3274 3275**系统能力：** SystemCapability.Utils.Lang 3276 3277**参数：** 3278 3279| 参数名 | 类型 | 必填 | 说明 | 3280| ------ | ---------- | ---- | ------------------- | 3281| src | Uint8Array | 是 | 待编码Uint8Array对象。 | 3282| options<sup>12+</sup> | [Type](#type10) | 否 | 从API version 12开始支持该参数，表示对应的编码格式。<br/>此参数可选，可选值为：util.Type.BASIC和util.Type.BASIC_URL_SAFE，默认值为：util.Type.BASIC。<br/>util.Type.BASIC 表示 Base64编码。<br/>util.Type.BASIC_URL_SAFE 表示 Base64URL编码。 | 3283 3284**返回值：** 3285 3286| 类型 | 说明 | 3287| ---------- | ----------------------------- | 3288| Uint8Array | 返回编码后的Uint8Array对象。 | 3289 3290**错误码：** 3291 3292以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3293 3294| 错误码ID | 错误信息 | 3295| -------- | -------- | 3296| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3297 3298**示例：** 3299 3300 ```ts 3301 let base64Helper = new util.Base64Helper(); 3302 let array = new Uint8Array([115,49,51]); 3303 let result = base64Helper.encodeSync(array); 3304 ``` 3305 3306 3307### encodeToStringSync<sup>9+</sup> 3308 3309encodeToStringSync(src: Uint8Array, options?: Type): string 3310 3311通过输入参数编码后输出对应文本。 3312 3313**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 3314 3315**系统能力：** SystemCapability.Utils.Lang 3316 3317**参数：** 3318 3319| 参数名 | 类型 | 必填 | 说明 | 3320| ------ | ---------- | ---- | ------------------- | 3321| src | Uint8Array | 是 | 待编码Uint8Array对象。 | 3322| options<sup>10+</sup> | [Type](#type10) | 否 | 从API version 10开始支持该参数，表示对应的编码格式。<br/>此参数可选，可选值为：util.Type.BASIC，util.Type.MIME，util.Type.BASIC_URL_SAFE 和util.Type.MIME_URL_SAFE，默认值为：util.Type.BASIC。<br/>- 当参数取值为util.Type.BASIC，表示Base64编码，返回值没有回车符、换行符。<br/>- 当参数取值为util.Type.MIME，表示Base64编码，返回值每一行不超过76个字符，而且每行以'\r\n'符结束。<br/>- 当参数取值为util.Type.BASIC_URL_SAFE，表示Base64URL编码，返回值没有回车符、换行符。<br/>- 当参数取值为util.Type.MIME_URL_SAFE，表示Base64URL编码，返回值每一行不超过76个字符，而且每行以'\r\n'符结束。 | 3323 3324**返回值：** 3325 3326| 类型 | 说明 | 3327| ------ | -------------------- | 3328| string | 返回编码后的字符串。 | 3329 3330**错误码：** 3331 3332以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3333 3334| 错误码ID | 错误信息 | 3335| -------- | -------- | 3336| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3337 3338**示例：** 3339 3340 ```ts 3341 let base64Helper = new util.Base64Helper(); 3342 let array = new Uint8Array([77,97,110,105,115,100,105,115,116,105,110,103,117,105,115,104,101,100,110,111,116,111,110,108,121,98,121,104,105,115,114,101,97,115,111,110,98,117,116,98,121,116,104,105,115,115,105,110,103,117,108,97,114,112,97,115,115,105,111,110,102,114,111,109,111,116,104,101,114,97,110,105,109,97,108,115,119,104,105,99,104,105,115,97,108,117,115,116,111,102,116,104,101,109,105,110,100,101,120,99,101,101,100,115,116,104,101,115,104,111,114,116,118,101,104,101,109,101,110,99,101,111,102,97,110,121,99,97,114,110,97,108,112,108,101,97,115,117,114,101]); 3343 let result = base64Helper.encodeToStringSync(array, util.Type.MIME); 3344 ``` 3345 3346 3347### decodeSync<sup>9+</sup> 3348 3349decodeSync(src: Uint8Array | string, options?: Type): Uint8Array 3350 3351通过输入参数解码后输出对应Uint8Array对象。 3352 3353**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 3354 3355**系统能力：** SystemCapability.Utils.Lang 3356 3357**参数：** 3358 3359| 参数名 | 类型 | 必填 | 说明 | 3360| ------ | ------------------------------ | ---- | ----------------------------- | 3361| src | Uint8Array \| string | 是 | 待解码Uint8Array对象或者字符串。 | 3362| options<sup>10+</sup> | [Type](#type10) | 否 | 从API version 10开始支持该参数，表示对应的解码格式。<br/>此参数可选，可选值为：util.Type.BASIC，util.Type.MIME，util.Type.BASIC_URL_SAFE 和util.Type.MIME_URL_SAFE，默认值为：util.Type.BASIC。<br/>- 当参数取值为util.Type.BASIC，表示Base64解码。<br/>- 当参数取值为util.Type.MIME，表示Base64解码，src入参包含回车符、换行符。<br/>- 当参数取值为util.Type.BASIC_URL_SAFE，表示Base64URL解码。<br/>- 当参数取值为util.Type.MIME_URL_SAFE，表示Base64URL解码，src入参包含回车符、换行符。 | 3363 3364**返回值：** 3365 3366| 类型 | 说明 | 3367| ---------- | ----------------------------- | 3368| Uint8Array | 返回解码后新分配的Uint8Array对象。 | 3369 3370**错误码：** 3371 3372以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3373 3374| 错误码ID | 错误信息 | 3375| -------- | -------- | 3376| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3377 3378**示例：** 3379 3380 ```ts 3381 let base64Helper = new util.Base64Helper(); 3382 let buff = 'TWFuaXNkaXN0aW5ndWlzaGVkbm90b25seWJ5aGlzcmVhc29uYnV0Ynl0aGlzc2luZ3VsYXJwYXNz\r\naW9uZnJvbW90aGVyYW5pbWFsc3doaWNoaXNhbHVzdG9mdGhlbWluZGV4Y2VlZHN0aGVzaG9ydHZl\r\naGVtZW5jZW9mYW55Y2FybmFscGxlYXN1cmU=\r\n'; 3383 let result = base64Helper.decodeSync(buff, util.Type.MIME); 3384 ``` 3385 3386 3387### encode<sup>9+</sup> 3388 3389encode(src: Uint8Array, options?: Type): Promise<Uint8Array> 3390 3391通过输入参数异步编码后输出对应Uint8Array对象。 3392 3393**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 3394 3395**系统能力：** SystemCapability.Utils.Lang 3396 3397**参数：** 3398 3399| 参数名 | 类型 | 必填 | 说明 | 3400| ------ | ---------- | ---- | ----------------------- | 3401| src | Uint8Array | 是 | 异步编码输入Uint8Array对象。 | 3402| options<sup>12+</sup> | [Type](#type10) | 否 | 从API version 12开始支持该参数，表示对应的编码格式。<br/>此参数可选，可选值为：util.Type.BASIC和util.Type.BASIC_URL_SAFE，默认值为：util.Type.BASIC。<br/>util.Type.BASIC 表示 Base64编码。<br/>util.Type.BASIC_URL_SAFE表示 Base64URL编码。 | 3403 3404**返回值：** 3405 3406| 类型 | 说明 | 3407| ------------------------- | --------------------------------- | 3408| Promise<Uint8Array> | 返回异步编码后新分配的Uint8Array对象。 | 3409 3410**错误码：** 3411 3412以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3413 3414| 错误码ID | 错误信息 | 3415| -------- | -------- | 3416| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3417 3418**示例：** 3419 3420 ```ts 3421 let base64Helper = new util.Base64Helper(); 3422 let array = new Uint8Array([115,49,51]); 3423 base64Helper.encode(array).then((val) => { 3424 console.info(val.toString()); 3425 }) 3426 ``` 3427 3428 3429### encodeToString<sup>9+</sup> 3430 3431encodeToString(src: Uint8Array, options?: Type): Promise<string> 3432 3433通过输入参数异步编码后输出对应文本。 3434 3435**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3436 3437**系统能力：** SystemCapability.Utils.Lang 3438 3439**参数：** 3440 3441| 参数名 | 类型 | 必填 | 说明 | 3442| ------ | ---------- | ---- | ----------------------- | 3443| src | Uint8Array | 是 | 异步编码输入Uint8Array对象。 | 3444| options<sup>10+</sup> | [Type](#type10) | 否 | 从API version 10开始支持该参数，表示对应的编码格式。<br/>此参数可选，可选值为：util.Type.BASIC，util.Type.MIME，util.Type.BASIC_URL_SAFE 和util.Type.MIME_URL_SAFE，默认值为：util.Type.BASIC。<br/>- 当参数取值为util.Type.BASIC，表示Base64编码，返回值没有回车符、换行符。<br/>- 当参数取值为util.Type.MIME，表示Base64编码，返回值每一行不超过76个字符，而且每行以'\r\n'符结束。<br/>- 当参数取值为util.Type.BASIC_URL_SAFE，表示Base64URL编码，返回值没有回车符、换行符。<br/>- 当参数取值为util.Type.MIME_URL_SAFE，表示Base64URL编码，返回值每一行不超过76个字符，而且每行以'\r\n'符结束。 | 3445 3446**返回值：** 3447 3448| 类型 | 说明 | 3449| --------------------- | ------------------------ | 3450| Promise<string> | 返回异步编码后的字符串。 | 3451 3452**错误码：** 3453 3454以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3455 3456| 错误码ID | 错误信息 | 3457| -------- | -------- | 3458| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3459 3460**示例：** 3461 3462 ```ts 3463 let base64Helper = new util.Base64Helper(); 3464 let array = new Uint8Array([77,97,110,105,115,100,105,115,116,105,110,103,117,105,115,104,101,100,110,111,116,111,110,108,121,98,121,104,105,115,114,101,97,115,111,110,98,117,116,98,121,116,104,105,115,115,105,110,103,117,108,97,114,112,97,115,115,105,111,110,102,114,111,109,111,116,104,101,114,97,110,105,109,97,108,115,119,104,105,99,104,105,115,97,108,117,115,116,111,102,116,104,101,109,105,110,100,101,120,99,101,101,100,115,116,104,101,115,104,111,114,116,118,101,104,101,109,101,110,99,101,111,102,97,110,121,99,97,114,110,97,108,112,108,101,97,115,117,114,101]); 3465 base64Helper.encodeToString(array, util.Type.MIME).then((val) => { 3466 console.info(val); 3467 }) 3468 ``` 3469 3470 3471### decode<sup>9+</sup> 3472 3473decode(src: Uint8Array | string, options?: Type): Promise<Uint8Array> 3474 3475通过输入参数异步解码后输出对应Uint8Array对象。 3476 3477**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3478 3479**系统能力：** SystemCapability.Utils.Lang 3480 3481**参数：** 3482 3483| 参数名 | 类型 | 必填 | 说明 | 3484| ------ | ------------------------------ | ---- | --------------------------------- | 3485| src | Uint8Array \| string | 是 | 异步解码输入Uint8Array对象或者字符串。 | 3486| options<sup>10+</sup> | [Type](#type10) | 否 | 从API version 10开始支持该参数，表示对应的解码格式。<br/>此参数可选，可选值为：util.Type.BASIC，util.Type.MIME，util.Type.BASIC_URL_SAFE 和util.Type.MIME_URL_SAFE，默认值为：util.Type.BASIC。<br/>- 当参数取值为util.Type.BASIC时，表示Base64解码。<br/>- 当参数取值为util.Type.MIME时，表示Base64解码，src入参包含回车符、换行符。<br/>- 当参数取值为util.Type.BASIC_URL_SAFE，表示Base64URL解码。<br/>- 当参数取值为util.Type.MIME_URL_SAFE，表示Base64URL解码，src入参包含回车符、换行符。 | 3487 3488**返回值：** 3489 3490| 类型 | 说明 | 3491| ------------------------- | --------------------------------- | 3492| Promise<Uint8Array> | 返回异步解码后新分配的Uint8Array对象。 | 3493 3494**错误码：** 3495 3496以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3497 3498| 错误码ID | 错误信息 | 3499| -------- | -------- | 3500| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3501 3502**示例：** 3503 3504 ```ts 3505 let base64Helper = new util.Base64Helper(); 3506 let array = 'TWFuaXNkaXN0aW5ndWlzaGVkbm90b25seWJ5aGlzcmVhc29uYnV0Ynl0aGlzc2luZ3VsYXJwYXNz\r\naW9uZnJvbW90aGVyYW5pbWFsc3doaWNoaXNhbHVzdG9mdGhlbWluZGV4Y2VlZHN0aGVzaG9ydHZl\r\naGVtZW5jZW9mYW55Y2FybmFscGxlYXN1cmU=\r\n'; 3507 base64Helper.decode(array, util.Type.MIME).then((val) => { 3508 console.info(val.toString()); 3509 }) 3510 ``` 3511 3512## StringDecoder<sup>12+</sup> 3513 3514提供将二进制流解码为字符串的能力。支持的编码类型包括：utf-8、iso-8859-2、koi8-r、macintosh、windows-1250、windows-1251、gbk、gb18030、big5、utf-16be、utf-16le等。 3515 3516### constructor<sup>12+</sup> 3517 3518constructor(encoding?: string) 3519 3520StringDecoder的构造函数。 3521 3522**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 3523 3524**系统能力：** SystemCapability.Utils.Lang 3525 3526**参数：** 3527 3528| 参数名 | 类型 | 必填 | 说明 | 3529| ------ | ------------------------------ | ---- | --------------------------------- | 3530| encoding | string | 否 | 输入数据的编码类型。默认值：'utf-8'。 | 3531 3532**错误码：** 3533 3534以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3535 3536| 错误码ID | 错误信息 | 3537| -------- | -------- | 3538| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3539 3540**示例：** 3541 3542 ```ts 3543 let decoder = new util.StringDecoder(); 3544 ``` 3545 3546### write<sup>12+</sup> 3547 3548write(chunk: string | Uint8Array): string 3549 3550返回一个解码后的字符串，确保Uint8Array末尾的任何不完整的多字节字符从返回的字符串中被过滤，并保存在一个内部的buffer中用于下次调用。 3551 3552**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 3553 3554**系统能力：** SystemCapability.Utils.Lang 3555 3556**参数：** 3557 3558| 参数名 | 类型 | 必填 | 说明 | 3559| ------ | ---------- | ---- | ------------------- | 3560| chunk | string \| Uint8Array | 是 | 需要解码的字符串。会根据输入的编码类型进行解码，参数为Uint8Array时会正常解码，参数为string类型时会原路返回。 | 3561 3562**返回值：** 3563 3564| 类型 | 说明 | 3565| ---------- | ----------------------------- | 3566| string | 返回解码后的字符串。 | 3567 3568**错误码：** 3569 3570以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3571 3572| 错误码ID | 错误信息 | 3573| -------- | -------- | 3574| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3575 3576**示例：** 3577 3578 ```ts 3579 let decoder = new util.StringDecoder('utf-8'); 3580 let input = new Uint8Array([0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD]); 3581 const decoded = decoder.write(input); 3582 console.info("decoder:", decoded);// 你好 3583 ``` 3584 3585### end<sup>12+</sup> 3586 3587end(chunk?: string | Uint8Array): string 3588 3589结束解码过程，以字符串形式返回存储在内部缓冲区中的任何剩余输入。 3590 3591**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 3592 3593**系统能力：** SystemCapability.Utils.Lang 3594 3595**参数：** 3596 3597| 参数名 | 类型 | 必填 | 说明 | 3598| ------ | ---------- | ---- | ------------------- | 3599| chunk | string \| Uint8Array | 否 | 需要解码的字符串。默认为undefined。 | 3600 3601**返回值：** 3602 3603| 类型 | 说明 | 3604| ---------- | ----------------------------- | 3605| string | 返回解码后的字符串。 | 3606 3607**错误码：** 3608 3609以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 3610 3611| 错误码ID | 错误信息 | 3612| -------- | -------- | 3613| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 3614 3615**示例：** 3616 3617 ```ts 3618 let decoder = new util.StringDecoder('utf-8'); 3619 let input = new Uint8Array([0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD]); 3620 const decoded = decoder.write(input.slice(0, 5)); 3621 const decodedend = decoder.end(input.slice(5)); 3622 console.info("decoded:", decoded);// 你 3623 console.info("decodedend:", decodedend);// 好 3624 ``` 3625 3626## Type<sup>10+</sup> 3627 3628Base64编码格式枚举。 3629 3630**系统能力：** SystemCapability.Utils.Lang 3631 3632 3633| 名称 |值| 说明 | 3634| ----- |---| ----------------- | 3635| BASIC | 0 | 表示BASIC编码格式。**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。| 3636| MIME | 1 | 表示MIME编码格式。**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。| 3637| BASIC_URL_SAFE<sup>12+</sup> | 2 | 表示BASIC_URL_SAFE编码格式。<br/>从API version 12开始支持此枚举。**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。| 3638| MIME_URL_SAFE<sup>12+</sup> | 3 | 表示MIME_URL_SAFE编码格式。<br/>从API version 12开始支持此枚举。**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 | 3639 3640 3641## types<sup>8+</sup> 3642 3643types为不同类型的内置对象提供类型检查，可以避免由于类型错误导致的异常或崩溃。该模块包含了多个工具函数，用于判断JS对象是否属于各种类型例如：ArrayBuffer、Map、Set等。 3644 3645### constructor<sup>8+</sup> 3646 3647constructor() 3648 3649Types的构造函数。 3650 3651**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3652 3653**系统能力：** SystemCapability.Utils.Lang 3654 3655**示例：** 3656 3657 ```ts 3658 let type = new util.types(); 3659 ``` 3660 3661 3662### isAnyArrayBuffer<sup>8+</sup> 3663 3664isAnyArrayBuffer(value: Object): boolean 3665 3666检查输入的value是否是ArrayBuffer或SharedArrayBuffer类型。 3667 3668**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3669 3670**系统能力：** SystemCapability.Utils.Lang 3671 3672**参数：** 3673 3674| 参数名 | 类型 | 必填 | 说明 | 3675| -------- | -------- | -------- | -------- | 3676| value | Object | 是 | 待检测对象。 | 3677 3678**返回值：** 3679 3680| 类型 | 说明 | 3681| -------- | -------- | 3682| boolean | 判断的结果，如果是ArrayBuffer或SharedArrayBuffer类型为true，反之为false。 | 3683 3684**示例：** 3685 3686 ```ts 3687 let type = new util.types(); 3688 let result = type.isAnyArrayBuffer(new ArrayBuffer(0)); 3689 console.info("result = " + result); 3690 // 输出结果：result = true 3691 ``` 3692 3693 3694### isArrayBufferView<sup>8+</sup> 3695 3696isArrayBufferView(value: Object): boolean 3697 3698检查输入的value是否是内置ArrayBufferView辅助类型。 3699 3700ArrayBufferView辅助类型包括：Int8Array、Int16Array、Int32Array、Uint8Array、Uint8ClampedArray、Uint32Array、Float32Array、Float64Array、DataView。 3701 3702**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3703 3704**系统能力：** SystemCapability.Utils.Lang 3705 3706**参数：** 3707 3708| 参数名 | 类型 | 必填 | 说明 | 3709| -------- | -------- | -------- | -------- | 3710| value | Object | 是 | 待检测对象。 | 3711 3712**返回值：** 3713 3714| 类型 | 说明 | 3715| -------- | -------- | 3716| boolean | 判断的结果，如果是内置包含的ArrayBufferView辅助类型为true，反之为false。 | 3717 3718**示例：** 3719 3720 ```ts 3721 let type = new util.types(); 3722 let result = type.isArrayBufferView(new Int8Array([])); 3723 console.info("result = " + result); 3724 // 输出结果：result = true 3725 ``` 3726 3727 3728### isArgumentsObject<sup>8+</sup> 3729 3730isArgumentsObject(value: Object): boolean 3731 3732检查输入的value是否是一个arguments对象。 3733 3734**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3735 3736**系统能力：** SystemCapability.Utils.Lang 3737 3738**参数：** 3739 3740| 参数名 | 类型 | 必填 | 说明 | 3741| -------- | -------- | -------- | -------- | 3742| value | Object | 是 | 待检测对象。 | 3743 3744**返回值：** 3745 3746| 类型 | 说明 | 3747| -------- | -------- | 3748| boolean | 判断的结果，如果是一个arguments对象为true，反之为false。 | 3749 3750**示例：** 3751 3752 ```ts 3753 let type = new util.types(); 3754 function foo() { 3755 let result = type.isArgumentsObject(arguments); 3756 console.info("result = " + result); 3757 } 3758 let f = foo(); 3759 // 输出结果：result = true 3760 ``` 3761 3762 3763### isArrayBuffer<sup>8+</sup> 3764 3765isArrayBuffer(value: Object): boolean 3766 3767检查输入的value是否是ArrayBuffer类型。 3768 3769**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3770 3771**系统能力：** SystemCapability.Utils.Lang 3772 3773**参数：** 3774 3775| 参数名 | 类型 | 必填 | 说明 | 3776| -------- | -------- | -------- | -------- | 3777| value | Object | 是 | 待检测对象。 | 3778 3779**返回值：** 3780 3781| 类型 | 说明 | 3782| -------- | -------- | 3783| boolean | 判断的结果，如果是内置包含的ArrayBuffer类型为true，反之为false。 | 3784 3785**示例：** 3786 3787 ```ts 3788 let type = new util.types(); 3789 let result = type.isArrayBuffer(new ArrayBuffer(0)); 3790 console.info("result = " + result); 3791 // 输出结果：result = true 3792 ``` 3793 3794 3795### isAsyncFunction<sup>8+</sup> 3796 3797isAsyncFunction(value: Object): boolean 3798 3799检查输入的value是否是一个异步函数类型。 3800 3801**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3802 3803**系统能力：** SystemCapability.Utils.Lang 3804 3805**参数：** 3806 3807| 参数名 | 类型 | 必填 | 说明 | 3808| -------- | -------- | -------- | -------- | 3809| value | Object | 是 | 待检测对象。 | 3810 3811**返回值：** 3812 3813| 类型 | 说明 | 3814| -------- | -------- | 3815| boolean | 判断的结果，如果是内置包含的异步函数类型为true，反之为false。 | 3816 3817**示例：** 3818 3819 ```ts 3820 let type = new util.types(); 3821 let result = type.isAsyncFunction(async () => {}); 3822 console.info("result = " + result); 3823 // 输出结果：result = true 3824 ``` 3825 3826 3827### isBooleanObject<sup>8+</sup> 3828 3829isBooleanObject(value: Object): boolean 3830 3831检查输入的value是否是一个Boolean对象类型。 3832 3833**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3834 3835**系统能力：** SystemCapability.Utils.Lang 3836 3837**参数：** 3838 3839| 参数名 | 类型 | 必填 | 说明 | 3840| -------- | -------- | -------- | -------- | 3841| value | Object | 是 | 待检测对象。 | 3842 3843**返回值：** 3844 3845| 类型 | 说明 | 3846| -------- | -------- | 3847| boolean | 判断的结果，如果是内置包含的Boolean对象类型为true，反之为false。 | 3848 3849**示例：** 3850 3851 ```ts 3852 let type = new util.types(); 3853 let result = type.isBooleanObject(new Boolean(true)); 3854 console.info("result = " + result); 3855 // 输出结果：result = true 3856 ``` 3857 3858 3859### isBoxedPrimitive<sup>8+</sup> 3860 3861isBoxedPrimitive(value: Object): boolean 3862 3863检查输入的value是否是Boolean或Number或String或Symbol对象类型。 3864 3865**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3866 3867**系统能力：** SystemCapability.Utils.Lang 3868 3869**参数：** 3870 3871| 参数名 | 类型 | 必填 | 说明 | 3872| -------- | -------- | -------- | -------- | 3873| value | Object | 是 | 待检测对象。 | 3874 3875**返回值：** 3876 3877| 类型 | 说明 | 3878| -------- | -------- | 3879| boolean | 判断的结果，如果是内置包含的Boolean或Number或String或Symbol对象类型为true，反之为false。 | 3880 3881**示例：** 3882 3883 ```ts 3884 let type = new util.types(); 3885 let result = type.isBoxedPrimitive(new Boolean(false)); 3886 console.info("result = " + result); 3887 // 输出结果：result = true 3888 ``` 3889 3890 3891### isDataView<sup>8+</sup> 3892 3893isDataView(value: Object): boolean 3894 3895检查输入的value是否是DataView类型。 3896 3897**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3898 3899**系统能力：** SystemCapability.Utils.Lang 3900 3901**参数：** 3902 3903| 参数名 | 类型 | 必填 | 说明 | 3904| -------- | -------- | -------- | -------- | 3905| value | Object | 是 | 待检测对象。 | 3906 3907**返回值：** 3908 3909| 类型 | 说明 | 3910| -------- | -------- | 3911| boolean | 判断的结果，如果是内置包含的DataView对象类型为true，反之为false。 | 3912 3913**示例：** 3914 3915 ```ts 3916 let type = new util.types(); 3917 const ab = new ArrayBuffer(20); 3918 let result = type.isDataView(new DataView(ab)); 3919 console.info("result = " + result); 3920 // 输出结果：result = true 3921 ``` 3922 3923 3924### isDate<sup>8+</sup> 3925 3926isDate(value: Object): boolean 3927 3928检查输入的value是否是Date类型。 3929 3930**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3931 3932**系统能力：** SystemCapability.Utils.Lang 3933 3934**参数：** 3935 3936| 参数名 | 类型 | 必填 | 说明 | 3937| -------- | -------- | -------- | -------- | 3938| value | Object | 是 | 待检测对象。 | 3939 3940**返回值：** 3941 3942| 类型 | 说明 | 3943| -------- | -------- | 3944| boolean | 判断的结果，如果是内置包含的Date对象类型为true，反之为false。 | 3945 3946**示例：** 3947 3948 ```ts 3949 let type = new util.types(); 3950 let result = type.isDate(new Date()); 3951 console.info("result = " + result); 3952 // 输出结果：result = true 3953 ``` 3954 3955 3956### isExternal<sup>8+</sup> 3957 3958isExternal(value: Object): boolean 3959 3960检查输入的value是否是native External类型。 3961 3962**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 3963 3964**系统能力：** SystemCapability.Utils.Lang 3965 3966**参数：** 3967 3968| 参数名 | 类型 | 必填 | 说明 | 3969| -------- | -------- | -------- | -------- | 3970| value | Object | 是 | 待检测对象。 | 3971 3972**返回值：** 3973 3974| 类型 | 说明 | 3975| -------- | -------- | 3976| boolean | 判断的结果，如果是内置包含native External类型为true，反之为false。 | 3977 3978**示例：** 3979 3980 ```cpp 3981 // /entry/src/main/cpp/napi_init.cpp 3982 #include "napi/native_api.h" 3983 #include <js_native_api.h> 3984 #include <stdlib.h> 3985 3986 napi_value result; 3987 static napi_value Testexternal(napi_env env, napi_callback_info info) { 3988 int* raw = (int*) malloc(1024); 3989 napi_status status = napi_create_external(env, (void*) raw, NULL, NULL, &result); 3990 if (status != napi_ok) { 3991 napi_throw_error(env, NULL, "create external failed"); 3992 return NULL; 3993 } 3994 return result; 3995 } 3996 3997 EXTERN_C_START 3998 static napi_value Init(napi_env env, napi_value exports) 3999 { 4000 napi_property_descriptor desc[] = { 4001 {"testexternal", nullptr, Testexternal, nullptr, nullptr, nullptr, napi_default, nullptr}, 4002 }; 4003 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); 4004 return exports; 4005 } 4006 EXTERN_C_END 4007 // 此处已省略模块注册的代码, 你可能需要自行注册Testexternal方法 4008 ... 4009 4010 ``` 4011 4012 <!--code_no_check--> 4013 ```ts 4014 import testNapi from 'libentry.so'; 4015 4016 let type = new util.types(); 4017 const data = testNapi.testexternal(); 4018 let result = type.isExternal(data); 4019 4020 let result01 = type.isExternal(true); 4021 console.info("result = " + result); 4022 console.info("result01 = " + result01); 4023 // 输出结果：result = true 4024 // 输出结果：result01 = false 4025 ``` 4026 4027 4028### isFloat32Array<sup>8+</sup> 4029 4030isFloat32Array(value: Object): boolean 4031 4032检查输入的value是否是Float32Array数组类型。 4033 4034**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4035 4036**系统能力：** SystemCapability.Utils.Lang 4037 4038**参数：** 4039 4040| 参数名 | 类型 | 必填 | 说明 | 4041| -------- | -------- | -------- | -------- | 4042| value | Object | 是 | 待检测对象。 | 4043 4044**返回值：** 4045 4046| 类型 | 说明 | 4047| -------- | -------- | 4048| boolean | 判断的结果，如果是内置包含的Float32Array数组类型为true，反之为false。 | 4049 4050**示例：** 4051 4052 ```ts 4053 let type = new util.types(); 4054 let result = type.isFloat32Array(new Float32Array()); 4055 console.info("result = " + result); 4056 // 输出结果：result = true 4057 ``` 4058 4059 4060### isFloat64Array<sup>8+</sup> 4061 4062isFloat64Array(value: Object): boolean 4063 4064检查输入的value是否是Float64Array数组类型。 4065 4066**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4067 4068**系统能力：** SystemCapability.Utils.Lang 4069 4070**参数：** 4071 4072| 参数名 | 类型 | 必填 | 说明 | 4073| -------- | -------- | -------- | -------- | 4074| value | Object | 是 | 待检测对象。 | 4075 4076**返回值：** 4077 4078| 类型 | 说明 | 4079| -------- | -------- | 4080| boolean | 判断的结果，如果是内置包含的Float64Array数组类型为true，反之为false。 | 4081 4082**示例：** 4083 4084 ```ts 4085 let type = new util.types(); 4086 let result = type.isFloat64Array(new Float64Array()); 4087 console.info("result = " + result); 4088 // 输出结果：result = true 4089 ``` 4090 4091 4092### isGeneratorFunction<sup>8+</sup> 4093 4094isGeneratorFunction(value: Object): boolean 4095 4096检查输入的value是否是generator函数类型。 4097 4098**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4099 4100**系统能力：** SystemCapability.Utils.Lang 4101 4102**参数：** 4103 4104| 参数名 | 类型 | 必填 | 说明 | 4105| -------- | -------- | -------- | -------- | 4106| value | Object | 是 | 待检测对象。 | 4107 4108**返回值：** 4109 4110| 类型 | 说明 | 4111| -------- | -------- | 4112| boolean | 判断的结果，如果是内置包含的generator函数类型为true，反之为false。 | 4113 4114**示例：** 4115 4116 ```ts 4117 // /entry/src/main/ets/pages/test.ts 4118 export function* foo() {} 4119 ``` 4120 4121 <!--code_no_check--> 4122 ```ts 4123 import { foo } from './test' 4124 4125 let type = new util.types(); 4126 let result = type.isGeneratorFunction(foo); 4127 console.info("result = " + result); 4128 // 输出结果：result = true 4129 ``` 4130 4131 4132### isGeneratorObject<sup>8+</sup> 4133 4134isGeneratorObject(value: Object): boolean 4135 4136检查输入的value是否是generator对象类型。 4137 4138**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4139 4140**系统能力：** SystemCapability.Utils.Lang 4141 4142**参数：** 4143 4144| 参数名 | 类型 | 必填 | 说明 | 4145| -------- | -------- | -------- | -------- | 4146| value | Object | 是 | 待检测对象。 | 4147 4148**返回值：** 4149 4150| 类型 | 说明 | 4151| -------- | -------- | 4152| boolean | 判断的结果，如果是内置包含的generator对象类型为true，反之为false。 | 4153 4154**示例：** 4155 4156 ```ts 4157 // /entry/src/main/ets/pages/test.ts 4158 function* foo() {} 4159 export const generator = foo(); 4160 ``` 4161 4162 <!--code_no_check--> 4163 ```ts 4164 import { generator } from './test' 4165 4166 let type = new util.types(); 4167 let result = type.isGeneratorObject(generator); 4168 console.info("result = " + result); 4169 // 输出结果：result = true 4170 ``` 4171 4172 4173### isInt8Array<sup>8+</sup> 4174 4175isInt8Array(value: Object): boolean 4176 4177检查输入的value是否是Int8Array数组类型。 4178 4179**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4180 4181**系统能力：** SystemCapability.Utils.Lang 4182 4183**参数：** 4184 4185| 参数名 | 类型 | 必填 | 说明 | 4186| -------- | -------- | -------- | -------- | 4187| value | Object | 是 | 待检测对象。 | 4188 4189**返回值：** 4190 4191| 类型 | 说明 | 4192| -------- | -------- | 4193| boolean | 判断的结果，如果是内置包含的Int8Array数组类型为true，反之为false。 | 4194 4195**示例：** 4196 4197 ```ts 4198 let type = new util.types(); 4199 let result = type.isInt8Array(new Int8Array([])); 4200 console.info("result = " + result); 4201 // 输出结果：result = true 4202 ``` 4203 4204 4205### isInt16Array<sup>8+</sup> 4206 4207isInt16Array(value: Object): boolean 4208 4209检查输入的value是否是Int16Array数组类型。 4210 4211**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4212 4213**系统能力：** SystemCapability.Utils.Lang 4214 4215**参数：** 4216 4217| 参数名 | 类型 | 必填 | 说明 | 4218| -------- | -------- | -------- | -------- | 4219| value | Object | 是 | 待检测对象。 | 4220 4221**返回值：** 4222 4223| 类型 | 说明 | 4224| -------- | -------- | 4225| boolean | 判断的结果，如果是内置包含的Int16Array数组类型为true，反之为false。 | 4226 4227**示例：** 4228 4229 ```ts 4230 let type = new util.types(); 4231 let result = type.isInt16Array(new Int16Array([])); 4232 console.info("result = " + result); 4233 // 输出结果：result = true 4234 ``` 4235 4236 4237### isInt32Array<sup>8+</sup> 4238 4239isInt32Array(value: Object): boolean 4240 4241检查输入的value是否是Int32Array数组类型。 4242 4243**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4244 4245**系统能力：** SystemCapability.Utils.Lang 4246 4247**参数：** 4248 4249| 参数名 | 类型 | 必填 | 说明 | 4250| -------- | -------- | -------- | -------- | 4251| value | Object | 是 | 待检测对象。 | 4252 4253**返回值：** 4254 4255| 类型 | 说明 | 4256| -------- | -------- | 4257| boolean | 判断的结果，如果是内置包含的Int32Array数组类型为true，反之为false。 | 4258 4259**示例：** 4260 4261 ```ts 4262 let type = new util.types(); 4263 let result = type.isInt32Array(new Int32Array([])); 4264 console.info("result = " + result); 4265 // 输出结果：result = true 4266 ``` 4267 4268 4269### isMap<sup>8+</sup> 4270 4271isMap(value: Object): boolean 4272 4273检查输入的value是否是Map类型。 4274 4275**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4276 4277**系统能力：** SystemCapability.Utils.Lang 4278 4279**参数：** 4280 4281| 参数名 | 类型 | 必填 | 说明 | 4282| -------- | -------- | -------- | -------- | 4283| value | Object | 是 | 待检测对象。 | 4284 4285**返回值：** 4286 4287| 类型 | 说明 | 4288| -------- | -------- | 4289| boolean | 判断的结果，如果是内置包含的Map类型为true，反之为false。 | 4290 4291**示例：** 4292 4293 ```ts 4294 let type = new util.types(); 4295 let result = type.isMap(new Map()); 4296 console.info("result = " + result); 4297 // 输出结果：result = true 4298 ``` 4299 4300 4301### isMapIterator<sup>8+</sup> 4302 4303isMapIterator(value: Object): boolean 4304 4305检查输入的value是否是Map的Iterator类型。 4306 4307**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4308 4309**系统能力：** SystemCapability.Utils.Lang 4310 4311**参数：** 4312 4313 4314| 参数名 | 类型 | 必填 | 说明 | 4315| -------- | -------- | -------- | -------- | 4316| value | Object | 是 | 待检测对象。 | 4317 4318**返回值：** 4319 4320| 类型 | 说明 | 4321| -------- | -------- | 4322| boolean | 判断的结果，如果是内置包含的Map的Iterator类型为true，反之为false。 | 4323 4324**示例：** 4325 4326 ```ts 4327 let type = new util.types(); 4328 const map : Map<number,number> = new Map(); 4329 let result = type.isMapIterator(map.keys()); 4330 console.info("result = " + result); 4331 // 输出结果：result = true 4332 ``` 4333 4334 4335### isNativeError<sup>8+</sup> 4336 4337isNativeError(value: Object): boolean 4338 4339检查输入的value是否是Error类型。 4340 4341**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4342 4343**系统能力：** SystemCapability.Utils.Lang 4344 4345**参数：** 4346 4347| 参数名 | 类型 | 必填 | 说明 | 4348| -------- | -------- | -------- | -------- | 4349| value | Object | 是 | 待检测对象。 | 4350 4351**返回值：** 4352 4353| 类型 | 说明 | 4354| -------- | -------- | 4355| boolean | 判断的结果，如果是内置包含的Error类型为true，反之为false。 | 4356 4357**示例：** 4358 4359 ```ts 4360 let type = new util.types(); 4361 let result = type.isNativeError(new TypeError()); 4362 console.info("result = " + result); 4363 // 输出结果：result = true 4364 ``` 4365 4366 4367### isNumberObject<sup>8+</sup> 4368 4369isNumberObject(value: Object): boolean 4370 4371检查输入的value是否是Number对象类型。 4372 4373**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4374 4375**系统能力：** SystemCapability.Utils.Lang 4376 4377**参数：** 4378 4379| 参数名 | 类型 | 必填 | 说明 | 4380| -------- | -------- | -------- | -------- | 4381| value | Object | 是 | 待检测对象。 | 4382 4383**返回值：** 4384 4385| 类型 | 说明 | 4386| -------- | -------- | 4387| boolean | 判断的结果，如果是内置包含的Number对象类型为true，反之为false。 | 4388 4389**示例：** 4390 4391 ```ts 4392 let type = new util.types(); 4393 let result = type.isNumberObject(new Number(0)); 4394 console.info("result = " + result); 4395 // 输出结果：result = true 4396 ``` 4397 4398 4399### isPromise<sup>8+</sup> 4400 4401isPromise(value: Object): boolean 4402 4403检查输入的value是否是Promise类型。 4404 4405**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4406 4407**系统能力：** SystemCapability.Utils.Lang 4408 4409**参数：** 4410 4411| 参数名 | 类型 | 必填 | 说明 | 4412| -------- | -------- | -------- | -------- | 4413| value | Object | 是 | 待检测对象。 | 4414 4415**返回值：** 4416 4417| 类型 | 说明 | 4418| -------- | -------- | 4419| boolean | 判断的结果，如果是内置包含的Promise类型为true，反之为false。 | 4420 4421**示例：** 4422 4423 ```ts 4424 let type = new util.types(); 4425 let result = type.isPromise(Promise.resolve(1)); 4426 console.info("result = " + result); 4427 // 输出结果：result = true 4428 ``` 4429 4430 4431### isProxy<sup>8+</sup> 4432 4433isProxy(value: Object): boolean 4434 4435检查输入的value是否是Proxy类型。 4436 4437**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4438 4439**系统能力：** SystemCapability.Utils.Lang 4440 4441**参数：** 4442 4443| 参数名 | 类型 | 必填 | 说明 | 4444| -------- | -------- | -------- | -------- | 4445| value | Object | 是 | 待检测对象。 | 4446 4447**返回值：** 4448 4449| 类型 | 说明 | 4450| -------- | -------- | 4451| boolean | 判断的结果，如果是内置包含的Proxy类型为true，反之为false。 | 4452 4453**示例：** 4454 4455 ```ts 4456 class Target{ 4457 } 4458 let type = new util.types(); 4459 const target : Target = {}; 4460 const proxy = new Proxy(target, target); 4461 let result = type.isProxy(proxy); 4462 console.info("result = " + result); 4463 // 输出结果：result = true 4464 ``` 4465 4466 4467### isRegExp<sup>8+</sup> 4468 4469isRegExp(value: Object): boolean 4470 4471检查输入的value是否是RegExp类型。 4472 4473**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4474 4475**系统能力：** SystemCapability.Utils.Lang 4476 4477**参数：** 4478 4479| 参数名 | 类型 | 必填 | 说明 | 4480| -------- | -------- | -------- | -------- | 4481| value | Object | 是 | 待检测对象。 | 4482 4483**返回值：** 4484 4485| 类型 | 说明 | 4486| -------- | -------- | 4487| boolean | 判断的结果，如果是内置包含的RegExp类型为true，反之为false。 | 4488 4489**示例：** 4490 4491 ```ts 4492 let type = new util.types(); 4493 let result = type.isRegExp(new RegExp('abc')); 4494 console.info("result = " + result); 4495 // 输出结果：result = true 4496 ``` 4497 4498 4499### isSet<sup>8+</sup> 4500 4501isSet(value: Object): boolean 4502 4503检查输入的value是否是Set类型。 4504 4505**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4506 4507**系统能力：** SystemCapability.Utils.Lang 4508 4509**参数：** 4510 4511| 参数名 | 类型 | 必填 | 说明 | 4512| -------- | -------- | -------- | -------- | 4513| value | Object | 是 | 待检测对象。 | 4514 4515**返回值：** 4516 4517| 类型 | 说明 | 4518| -------- | -------- | 4519| boolean | 判断的结果，如果是内置包含的Set类型为true，反之为false。 | 4520 4521**示例：** 4522 4523 ```ts 4524 let type = new util.types(); 4525 let set : Set<number> = new Set(); 4526 let result = type.isSet(set); 4527 console.info("result = " + result); 4528 // 输出结果：result = true 4529 ``` 4530 4531 4532### isSetIterator<sup>8+</sup> 4533 4534isSetIterator(value: Object): boolean 4535 4536检查输入的value是否是Set的Iterator类型。 4537 4538**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4539 4540**系统能力：** SystemCapability.Utils.Lang 4541 4542**参数：** 4543 4544| 参数名 | 类型 | 必填 | 说明 | 4545| -------- | -------- | -------- | -------- | 4546| value | Object | 是 | 待检测对象。 | 4547 4548**返回值：** 4549 4550| 类型 | 说明 | 4551| -------- | -------- | 4552| boolean | 判断的结果，如果是内置包含的Set的Iterator类型为true，反之为false。 | 4553 4554**示例：** 4555 4556 ```ts 4557 let type = new util.types(); 4558 const set : Set<number> = new Set(); 4559 let result = type.isSetIterator(set.keys()); 4560 console.info("result = " + result); 4561 // 输出结果：result = true 4562 ``` 4563 4564 4565### isStringObject<sup>8+</sup> 4566 4567isStringObject(value: Object): boolean 4568 4569检查输入的value是否是String对象类型。 4570 4571**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4572 4573**系统能力：** SystemCapability.Utils.Lang 4574 4575**参数：** 4576 4577| 参数名 | 类型 | 必填 | 说明 | 4578| -------- | -------- | -------- | -------- | 4579| value | Object | 是 | 待检测对象。 | 4580 4581**返回值：** 4582 4583| 类型 | 说明 | 4584| -------- | -------- | 4585| boolean | 判断的结果，如果是内置包含的String对象类型为true，反之为false。 | 4586 4587**示例：** 4588 4589 ```ts 4590 let type = new util.types(); 4591 let result = type.isStringObject(new String('foo')); 4592 console.info("result = " + result); 4593 // 输出结果：result = true 4594 ``` 4595 4596 4597### isSymbolObject<sup>8+</sup> 4598 4599isSymbolObject(value: Object): boolean 4600 4601检查输入的value是否是Symbol对象类型。 4602 4603**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4604 4605**系统能力：** SystemCapability.Utils.Lang 4606 4607**参数：** 4608 4609| 参数名 | 类型 | 必填 | 说明 | 4610| -------- | -------- | -------- | -------- | 4611| value | Object | 是 | 待检测对象。 | 4612 4613**返回值：** 4614 4615| 类型 | 说明 | 4616| -------- | -------- | 4617| boolean | 判断的结果，如果是内置包含的Symbol对象类型为true，反之为false。 | 4618 4619**示例：** 4620 4621 ```ts 4622 // /entry/src/main/ets/pages/test.ts 4623 export const symbols = Symbol('foo'); 4624 ``` 4625 4626 <!--code_no_check--> 4627 ```ts 4628 import { symbols } from './test' 4629 4630 let type = new util.types(); 4631 let result = type.isSymbolObject(Object(symbols)); 4632 console.info("result = " + result); 4633 // 输出结果：result = true 4634 ``` 4635 4636 4637### isTypedArray<sup>8+</sup> 4638 4639isTypedArray(value: Object): boolean 4640 4641检查输入的value是否是TypedArray类型的辅助类型。 4642 4643TypedArray类型的辅助类型，包括Int8Array、Int16Array、Int32Array、Uint8Array、Uint8ClampedArray、Uint16Array、Uint32Array、Float32Array、Float64Array、BigInt64Array、BigUint64Array。 4644 4645**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4646 4647**系统能力：** SystemCapability.Utils.Lang 4648 4649**参数：** 4650 4651| 参数名 | 类型 | 必填 | 说明 | 4652| -------- | -------- | -------- | -------- | 4653| value | Object | 是 | 待检测对象。 | 4654 4655**返回值：** 4656 4657| 类型 | 说明 | 4658| -------- | -------- | 4659| boolean | 判断的结果，如果是内置包含的TypedArray包含的类型为true，反之为false。 | 4660 4661**示例：** 4662 4663 ```ts 4664 let type = new util.types(); 4665 let result = type.isTypedArray(new Float64Array([])); 4666 console.info("result = " + result); 4667 // 输出结果：result = true 4668 ``` 4669 4670 4671### isUint8Array<sup>8+</sup> 4672 4673isUint8Array(value: Object): boolean 4674 4675检查输入的value是否是Uint8Array数组类型。 4676 4677**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4678 4679**系统能力：** SystemCapability.Utils.Lang 4680 4681**参数：** 4682 4683| 参数名 | 类型 | 必填 | 说明 | 4684| -------- | -------- | -------- | -------- | 4685| value | Object | 是 | 待检测对象。 | 4686 4687**返回值：** 4688 4689| 类型 | 说明 | 4690| -------- | -------- | 4691| boolean | 判断的结果，如果是内置包含的Uint8Array数组类型为true，反之为false。 | 4692 4693**示例：** 4694 4695 ```ts 4696 let type = new util.types(); 4697 let result = type.isUint8Array(new Uint8Array([])); 4698 console.info("result = " + result); 4699 // 输出结果：result = true 4700 ``` 4701 4702 4703### isUint8ClampedArray<sup>8+</sup> 4704 4705isUint8ClampedArray(value: Object): boolean 4706 4707检查输入的value是否是Uint8ClampedArray数组类型。 4708 4709**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4710 4711**系统能力：** SystemCapability.Utils.Lang 4712 4713**参数：** 4714 4715| 参数名 | 类型 | 必填 | 说明 | 4716| -------- | -------- | -------- | -------- | 4717| value | Object | 是 | 待检测对象。 | 4718 4719**返回值：** 4720 4721| 类型 | 说明 | 4722| -------- | -------- | 4723| boolean | 判断的结果，如果是内置包含的Uint8ClampedArray数组类型为true，反之为false。 | 4724 4725**示例：** 4726 4727 ```ts 4728 let type = new util.types(); 4729 let result = type.isUint8ClampedArray(new Uint8ClampedArray([])); 4730 console.info("result = " + result); 4731 // 输出结果：result = true 4732 ``` 4733 4734 4735### isUint16Array<sup>8+</sup> 4736 4737isUint16Array(value: Object): boolean 4738 4739检查输入的value是否是Uint16Array数组类型。 4740 4741**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4742 4743**系统能力：** SystemCapability.Utils.Lang 4744 4745**参数：** 4746 4747| 参数名 | 类型 | 必填 | 说明 | 4748| -------- | -------- | -------- | -------- | 4749| value | Object | 是 | 待检测对象。 | 4750 4751**返回值：** 4752 4753| 类型 | 说明 | 4754| -------- | -------- | 4755| boolean | 判断的结果，如果是内置包含的Uint16Array数组类型为true，反之为false。 | 4756 4757**示例：** 4758 4759 ```ts 4760 let type = new util.types(); 4761 let result = type.isUint16Array(new Uint16Array([])); 4762 console.info("result = " + result); 4763 // 输出结果：result = true 4764 ``` 4765 4766 4767### isUint32Array<sup>8+</sup> 4768 4769isUint32Array(value: Object): boolean 4770 4771检查输入的value是否是Uint32Array数组类型。 4772 4773**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4774 4775**系统能力：** SystemCapability.Utils.Lang 4776 4777**参数：** 4778 4779| 参数名 | 类型 | 必填 | 说明 | 4780| -------- | -------- | -------- | -------- | 4781| value | Object | 是 | 待检测对象。 | 4782 4783**返回值：** 4784 4785| 类型 | 说明 | 4786| -------- | -------- | 4787| boolean | 判断的结果，如果是内置包含的Uint32Array数组类型为true，反之为false。 | 4788 4789**示例：** 4790 4791 ```ts 4792 let type = new util.types(); 4793 let result = type.isUint32Array(new Uint32Array([])); 4794 console.info("result = " + result); 4795 // 输出结果：result = true 4796 ``` 4797 4798 4799### isWeakMap<sup>8+</sup> 4800 4801isWeakMap(value: Object): boolean 4802 4803检查输入的value是否是WeakMap类型。 4804 4805**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4806 4807**系统能力：** SystemCapability.Utils.Lang 4808 4809**参数：** 4810 4811| 参数名 | 类型 | 必填 | 说明 | 4812| -------- | -------- | -------- | -------- | 4813| value | Object | 是 | 待检测对象。 | 4814 4815**返回值：** 4816 4817| 类型 | 说明 | 4818| -------- | -------- | 4819| boolean | 判断的结果，如果是内置包含的WeakMap类型为true，反之为false。 | 4820 4821**示例：** 4822 4823 ```ts 4824 let type = new util.types(); 4825 let value : WeakMap<object, number> = new WeakMap(); 4826 let result = type.isWeakMap(value); 4827 console.info("result = " + result); 4828 // 输出结果：result = true 4829 ``` 4830 4831 4832### isWeakSet<sup>8+</sup> 4833 4834isWeakSet(value: Object): boolean 4835 4836检查输入的value是否是WeakSet类型。 4837 4838**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4839 4840**系统能力：** SystemCapability.Utils.Lang 4841 4842**参数：** 4843 4844| 参数名 | 类型 | 必填 | 说明 | 4845| -------- | -------- | -------- | -------- | 4846| value | Object | 是 | 待检测对象。 | 4847 4848**返回值：** 4849 4850| 类型 | 说明 | 4851| -------- | -------- | 4852| boolean | 判断的结果，如果是内置包含的WeakSet类型为true，反之为false。 | 4853 4854**示例：** 4855 4856 ```ts 4857 let type = new util.types(); 4858 let result = type.isWeakSet(new WeakSet()); 4859 console.info("result = " + result); 4860 // 输出结果：result = true 4861 ``` 4862 4863 4864### isBigInt64Array<sup>8+</sup> 4865 4866isBigInt64Array(value: Object): boolean 4867 4868检查输入的value是否是BigInt64Array类型。 4869 4870**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4871 4872**系统能力：** SystemCapability.Utils.Lang 4873 4874**参数：** 4875 4876| 参数名 | 类型 | 必填 | 说明 | 4877| -------- | -------- | -------- | -------- | 4878| value | Object | 是 | 待检测对象。 | 4879 4880**返回值：** 4881 4882| 类型 | 说明 | 4883| -------- | -------- | 4884| boolean | 判断的结果，如果是内置包含的BigInt64Array类型为true，反之为false。 | 4885 4886**示例：** 4887 4888 ```ts 4889 let type = new util.types(); 4890 let result = type.isBigInt64Array(new BigInt64Array([])); 4891 console.info("result = " + result); 4892 // 输出结果：result = true 4893 ``` 4894 4895 4896### isBigUint64Array<sup>8+</sup> 4897 4898isBigUint64Array(value: Object): boolean 4899 4900检查输入的value是否是BigUint64Array类型。 4901 4902**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4903 4904**系统能力：** SystemCapability.Utils.Lang 4905 4906**参数：** 4907 4908| 参数名 | 类型 | 必填 | 说明 | 4909| -------- | -------- | -------- | -------- | 4910| value | Object | 是 | 待检测对象。 | 4911 4912**返回值：** 4913 4914| 类型 | 说明 | 4915| -------- | -------- | 4916| boolean | 判断的结果，如果是内置包含的BigUint64Array类型为true，反之为false。 | 4917 4918**示例：** 4919 4920 ```ts 4921 let type = new util.types(); 4922 let result = type.isBigUint64Array(new BigUint64Array([])); 4923 console.info("result = " + result); 4924 // 输出结果：result = true 4925 ``` 4926 4927 4928### isModuleNamespaceObject<sup>8+</sup> 4929 4930isModuleNamespaceObject(value: Object): boolean 4931 4932检查输入的value是否是Module Namespace Object类型。 4933 4934**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4935 4936**系统能力：** SystemCapability.Utils.Lang 4937 4938**参数：** 4939 4940| 参数名 | 类型 | 必填 | 说明 | 4941| -------- | -------- | -------- | -------- | 4942| value | Object | 是 | 待检测对象。 | 4943 4944**返回值：** 4945 4946| 类型 | 说明 | 4947| -------- | -------- | 4948| boolean | 判断的结果，如果是内置包含的Module Namespace Object类型为true，反之为false。 | 4949 4950**示例：** 4951 4952 ```ts 4953 // /entry/src/main/ets/pages/test.ts 4954 export function func() { 4955 console.info("hello world"); 4956 } 4957 ``` 4958 4959 <!--code_no_check--> 4960 ```ts 4961 import * as nameSpace from './test'; 4962 4963 let type = new util.types(); 4964 let result = type.isModuleNamespaceObject(nameSpace); 4965 console.info("result = " + result); 4966 // 输出结果：result = true 4967 ``` 4968 4969 4970### isSharedArrayBuffer<sup>8+</sup> 4971 4972isSharedArrayBuffer(value: Object): boolean 4973 4974检查输入的value是否是SharedArrayBuffer类型。 4975 4976**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4977 4978**系统能力：** SystemCapability.Utils.Lang 4979 4980**参数：** 4981 4982| 参数名 | 类型 | 必填 | 说明 | 4983| -------- | -------- | -------- | -------- | 4984| value | Object | 是 | 待检测对象。 | 4985 4986**返回值：** 4987 4988| 类型 | 说明 | 4989| -------- | -------- | 4990| boolean | 判断的结果，如果是内置包含的SharedArrayBuffer类型为true，反之为false。 | 4991 4992**示例：** 4993 4994 ```ts 4995 let type = new util.types(); 4996 let result = type.isSharedArrayBuffer(new SharedArrayBuffer(0)); 4997 console.info("result = " + result); 4998 // 输出结果：result = true 4999 ``` 5000 5001## LruBuffer<sup>(deprecated)</sup> 5002 5003> **说明：** 5004> 5005> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache<sup>9+</sup>](#lrucache9)替代。 5006 5007### 属性 5008 5009**系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。 5010 5011| 名称 | 类型 | 可读 | 可写 | 说明 | 5012| -------- | -------- | -------- | -------- | -------- | 5013| length | number | 是 | 否 | 当前缓冲区中值的总数。 | 5014 5015**示例：** 5016 5017 ```ts 5018 let pro : util.LruBuffer<number,number>= new util.LruBuffer(); 5019 pro.put(2,10); 5020 pro.put(1,8); 5021 let result = pro.length; 5022 ``` 5023 5024### constructor<sup>(deprecated)</sup> 5025 5026constructor(capacity?: number) 5027 5028默认构造函数用于创建一个新的LruBuffer实例，默认容量为64。 5029 5030> **说明：** 5031> 5032> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.constructor<sup>9+</sup>](#constructor9-3)替代。 5033 5034**系统能力：** SystemCapability.Utils.Lang 5035 5036**参数：** 5037 5038| 参数名 | 类型 | 必填 | 说明 | 5039| -------- | -------- | -------- | -------- | 5040| capacity | number | 否 | 指示要为缓冲区自定义的容量，默认值为64。 | 5041 5042**示例：** 5043 5044 ```ts 5045 let lrubuffer : util.LruBuffer<number,number> = new util.LruBuffer(); 5046 ``` 5047 5048### updateCapacity<sup>(deprecated)</sup> 5049 5050updateCapacity(newCapacity: number): void 5051 5052将缓冲区容量更新为指定容量，如果newCapacity小于或等于0，则抛出异常。 5053 5054> **说明：** 5055> 5056> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.updateCapacity<sup>9+</sup>](#updatecapacity9)替代。 5057 5058**系统能力：** SystemCapability.Utils.Lang 5059 5060**参数：** 5061 5062| 参数名 | 类型 | 必填 | 说明 | 5063| -------- | -------- | -------- | -------- | 5064| newCapacity | number | 是 | 指示要为缓冲区自定义的容量。 | 5065 5066**示例：** 5067 5068 ```ts 5069 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5070 pro.updateCapacity(100); 5071 ``` 5072 5073### toString<sup>(deprecated)</sup> 5074 5075toString(): string 5076 5077返回对象的字符串表示形式。 5078 5079> **说明：** 5080> 5081> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.toString<sup>9+</sup>](#tostring9)替代。 5082 5083**系统能力：** SystemCapability.Utils.Lang 5084 5085**返回值：** 5086 5087| 类型 | 说明 | 5088| -------- | -------- | 5089| string | 返回对象的字符串表示形式。 | 5090 5091**示例：** 5092 5093 ```ts 5094 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5095 pro.put(2,10); 5096 pro.get(2); 5097 pro.remove(20); 5098 let result = pro.toString(); 5099 ``` 5100 5101### getCapacity<sup>(deprecated)</sup> 5102 5103getCapacity(): number 5104 5105获取当前缓冲区的容量。 5106 5107> **说明：** 5108> 5109> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getCapacity<sup>9+</sup>](#getcapacity9)替代。 5110 5111**系统能力：** SystemCapability.Utils.Lang 5112 5113**返回值：** 5114 5115| 类型 | 说明 | 5116| -------- | -------- | 5117| number | 返回当前缓冲区的容量。 | 5118 5119**示例：** 5120 5121 ```ts 5122 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5123 let result = pro.getCapacity(); 5124 ``` 5125 5126### clear<sup>(deprecated)</sup> 5127 5128clear(): void 5129 5130从当前缓冲区清除键值对。后续会调用afterRemoval()方法执行后续操作。 5131 5132> **说明：** 5133> 5134> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.clear<sup>9+</sup>](#clear9)替代。 5135 5136**系统能力：** SystemCapability.Utils.Lang 5137 5138**示例：** 5139 5140 ```ts 5141 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5142 pro.put(2,10); 5143 let result = pro.length; 5144 pro.clear(); 5145 ``` 5146 5147### getCreateCount<sup>(deprecated)</sup> 5148 5149getCreateCount(): number 5150 5151获取createDefault()返回值的次数。 5152 5153> **说明：** 5154> 5155> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getCreateCount<sup>9+</sup>](#getcreatecount9)替代。 5156 5157**系统能力：** SystemCapability.Utils.Lang 5158 5159**返回值：** 5160 5161| 类型 | 说明 | 5162| -------- | -------- | 5163| number | 返回createDefault()返回值的次数。 | 5164 5165**示例：** 5166 5167 ```ts 5168 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5169 pro.put(1,8); 5170 let result = pro.getCreateCount(); 5171 ``` 5172 5173### getMissCount<sup>(deprecated)</sup> 5174 5175getMissCount(): number 5176 5177获取查询值不匹配的次数。 5178 5179> **说明：** 5180> 5181> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getMissCount<sup>9+</sup>](#getmisscount9)替代。 5182 5183**系统能力：** SystemCapability.Utils.Lang 5184 5185**返回值：** 5186 5187| 类型 | 说明 | 5188| -------- | -------- | 5189| number | 返回查询值不匹配的次数。 | 5190 5191**示例：** 5192 5193 ```ts 5194 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5195 pro.put(2,10); 5196 pro.get(2); 5197 let result = pro.getMissCount(); 5198 ``` 5199 5200### getRemovalCount<sup>(deprecated)</sup> 5201 5202getRemovalCount(): number 5203 5204获取从缓冲区中逐出值的次数。 5205 5206> **说明：** 5207> 5208> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getRemovalCount<sup>9+</sup>](#getremovalcount9)替代。 5209 5210**系统能力：** SystemCapability.Utils.Lang 5211 5212**返回值：** 5213 5214| 类型 | 说明 | 5215| -------- | -------- | 5216| number | 返回从缓冲区中驱逐的次数。 | 5217 5218**示例：** 5219 5220 ```ts 5221 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5222 pro.put(2,10); 5223 pro.updateCapacity(2); 5224 pro.put(50,22); 5225 let result = pro.getRemovalCount(); 5226 ``` 5227 5228### getMatchCount<sup>(deprecated)</sup> 5229 5230getMatchCount(): number 5231 5232获取查询值匹配成功的次数。 5233 5234> **说明：** 5235> 5236> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getMatchCount<sup>9+</sup>](#getmatchcount9)替代。 5237 5238**系统能力：** SystemCapability.Utils.Lang 5239 5240**返回值：** 5241 5242| 类型 | 说明 | 5243| -------- | -------- | 5244| number | 返回查询值匹配成功的次数。 | 5245 5246**示例：** 5247 5248 ```ts 5249 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5250 pro.put(2,10); 5251 pro.get(2); 5252 let result = pro.getMatchCount(); 5253 ``` 5254 5255### getPutCount<sup>(deprecated)</sup> 5256 5257getPutCount(): number 5258 5259获取将值添加到缓冲区的次数。 5260 5261> **说明：** 5262> 5263> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getPutCount<sup>9+</sup>](#getputcount9)替代。 5264 5265**系统能力：** SystemCapability.Utils.Lang 5266 5267**返回值：** 5268 5269| 类型 | 说明 | 5270| -------- | -------- | 5271| number | 返回将值添加到缓冲区的次数。 | 5272 5273**示例：** 5274 5275 ```ts 5276 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5277 pro.put(2,10); 5278 let result = pro.getPutCount(); 5279 ``` 5280 5281### isEmpty<sup>(deprecated)</sup> 5282 5283isEmpty(): boolean 5284 5285检查当前缓冲区是否为空。 5286 5287> **说明：** 5288> 5289> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.isEmpty<sup>9+</sup>](#isempty9)替代。 5290 5291**系统能力：** SystemCapability.Utils.Lang 5292 5293**返回值：** 5294 5295| 类型 | 说明 | 5296| -------- | -------- | 5297| boolean | 如果当前缓冲区不包含任何值，则返回true。 | 5298 5299**示例：** 5300 5301 ```ts 5302 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5303 pro.put(2,10); 5304 let result = pro.isEmpty(); 5305 ``` 5306 5307### get<sup>(deprecated)</sup> 5308 5309get(key: K): V | undefined 5310 5311表示要查询的键。 5312 5313> **说明：** 5314> 5315> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.get<sup>9+</sup>](#get9)替代。 5316 5317**系统能力：** SystemCapability.Utils.Lang 5318 5319**参数：** 5320 5321| 参数名 | 类型 | 必填 | 说明 | 5322| -------- | -------- | -------- | -------- | 5323| key | K | 是 | 要查询的键。 | 5324 5325**返回值：** 5326 5327| 类型 | 说明 | 5328| -------- | -------- | 5329| V \| undefined | 如果指定的键存在于缓冲区中，则返回与键关联的值；否则返回undefined。 | 5330 5331**示例：** 5332 5333 ```ts 5334 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5335 pro.put(2,10); 5336 let result = pro.get(2); 5337 ``` 5338 5339### put<sup>(deprecated)</sup> 5340 5341put(key: K,value: V): V 5342 5343将键值对添加到缓冲区。 5344 5345> **说明：** 5346> 5347> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.put<sup>9+</sup>](#put9)替代。 5348 5349**系统能力：** SystemCapability.Utils.Lang 5350 5351**参数：** 5352 5353| 参数名 | 类型 | 必填 | 说明 | 5354| -------- | -------- | -------- | -------- | 5355| key | K | 是 | 要添加的密钥。 | 5356| value | V | 是 | 指示与要添加的键关联的值。 | 5357 5358**返回值：** 5359 5360| 类型 | 说明 | 5361| -------- | -------- | 5362| V | 返回与添加的键关联的值；如果要添加的键已经存在，则返回原始值，如果键或值为空，则抛出此异常。 | 5363 5364**示例：** 5365 5366 ```ts 5367 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5368 let result = pro.put(2,10); 5369 ``` 5370 5371### values<sup>(deprecated)</sup> 5372 5373values(): V[] 5374 5375获取当前缓冲区中所有值从最近访问到最近最少访问的顺序列表。 5376 5377> **说明：** 5378> 5379> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.values<sup>9+</sup>](#values9)替代。 5380 5381**系统能力：** SystemCapability.Utils.Lang 5382 5383**返回值：** 5384 5385| 类型 | 说明 | 5386| -------- | -------- | 5387| V [] | 按从最近访问到最近最少访问的顺序返回当前缓冲区中所有值的列表。 | 5388 5389**示例：** 5390 5391 ```ts 5392 let pro : util.LruBuffer<number|string,number|string> = new util.LruBuffer(); 5393 pro.put(2,10); 5394 pro.put(2,"anhu"); 5395 pro.put("afaf","grfb"); 5396 let result = pro.values(); 5397 ``` 5398 5399### keys<sup>(deprecated)</sup> 5400 5401keys(): K[] 5402 5403获取当前缓冲区中所有键从最近访问到最近最少访问的升序列表。 5404 5405> **说明：** 5406> 5407> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.keys<sup>9+</sup>](#keys9)替代。 5408 5409**系统能力：** SystemCapability.Utils.Lang 5410 5411**返回值：** 5412 5413| 类型 | 说明 | 5414| -------- | -------- | 5415| K [] | 按升序返回当前缓冲区中所有键的列表，从最近访问到最近最少访问。 | 5416 5417**示例：** 5418 5419 ```ts 5420 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5421 pro.put(2,10); 5422 let result = pro.keys(); 5423 ``` 5424 5425### remove<sup>(deprecated)</sup> 5426 5427remove(key: K): V | undefined 5428 5429从当前缓冲区中删除指定的键及其关联的值。 5430 5431> **说明：** 5432> 5433> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.remove<sup>9+</sup>](#remove9)替代。 5434 5435**系统能力：** SystemCapability.Utils.Lang 5436 5437**参数：** 5438 5439| 参数名 | 类型 | 必填 | 说明 | 5440| -------- | -------- | -------- | -------- | 5441| key | K | 是 | 要删除的密钥。 | 5442 5443**返回值：** 5444 5445| 类型 | 说明 | 5446| -------- | -------- | 5447| V \| undefined | 返回一个包含已删除键值对的Optional对象；如果key不存在，则返回一个空的Optional对象，如果key为null，则抛出异常。 | 5448 5449**示例：** 5450 5451 ```ts 5452 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5453 pro.put(2,10); 5454 let result = pro.remove(20); 5455 ``` 5456 5457### afterRemoval<sup>(deprecated)</sup> 5458 5459afterRemoval(isEvict: boolean,key: K,value: V,newValue: V): void 5460 5461删除值后执行后续操作。 5462 5463> **说明：** 5464> 5465> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.afterRemoval<sup>9+</sup>](#afterremoval9)替代。 5466 5467**系统能力：** SystemCapability.Utils.Lang 5468 5469**参数：** 5470 5471| 参数名 | 类型 | 必填 | 说明 | 5472| -------- | -------- | -------- | -------- | 5473| isEvict | boolean | 是 | 因容量不足而调用该方法时，参数值为true，其他情况为false。 | 5474| key | K | 是 | 表示删除的键。 | 5475| value | V | 是 | 表示删除的值。 | 5476| newValue | V | 是 | 如果已调用put方法并且要添加的键已经存在，则参数值是关联的新值。其他情况下参数值为空。 | 5477 5478**示例：** 5479 5480```ts 5481class ChildLruBuffer<K, V> extends util.LruBuffer<K, V> { 5482 constructor(capacity?: number) { 5483 super(capacity); 5484 } 5485 5486 afterRemoval(isEvict: boolean, key: K, value: V, newValue: V): void { 5487 if (isEvict === true) { 5488 console.info('key: ' + key); 5489 console.info('value: ' + value); 5490 console.info('newValue: ' + newValue); 5491 } 5492 } 5493} 5494let lru: ChildLruBuffer<number, number> = new ChildLruBuffer(2); 5495lru.put(11, 1); 5496lru.put(22, 2); 5497lru.put(33, 3); 5498``` 5499 5500### contains<sup>(deprecated)</sup> 5501 5502contains(key: K): boolean 5503 5504检查当前缓冲区是否包含指定的键。 5505 5506 5507> **说明：** 5508> 5509> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.contains<sup>9+</sup>](#contains9)替代。 5510 5511**系统能力：** SystemCapability.Utils.Lang 5512 5513**参数：** 5514 5515| 参数名 | 类型 | 必填 | 说明 | 5516| -------- | -------- | -------- | -------- | 5517| key | K | 是 | 表示要检查的键。 | 5518 5519**返回值：** 5520 5521| 类型 | 说明 | 5522| -------- | -------- | 5523| boolean | 如果缓冲区包含指定的键，则返回 true。 | 5524 5525**示例：** 5526 5527 ```ts 5528 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5529 pro.put(2,10); 5530 let result = pro.contains(20); 5531 ``` 5532 5533### createDefault<sup>(deprecated)</sup> 5534 5535createDefault(key: K): V 5536 5537如果未计算特定键的值，则执行后续操作，参数表示丢失的键，返回与键关联的值。 5538 5539> **说明：** 5540> 5541> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.createDefault<sup>9+</sup>](#createdefault9)替代。 5542 5543**系统能力：** SystemCapability.Utils.Lang 5544 5545**参数：** 5546 5547| 参数名 | 类型 | 必填 | 说明 | 5548| -------- | -------- | -------- | -------- | 5549| key | K | 是 | 表示丢失的键。 | 5550 5551**返回值：** 5552 5553| 类型 | 说明 | 5554| -------- | -------- | 5555| V | 返回与键关联的值。 | 5556 5557**示例：** 5558 5559 ```ts 5560 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5561 let result = pro.createDefault(50); 5562 ``` 5563 5564### entries<sup>(deprecated)</sup> 5565 5566entries(): IterableIterator<[K,V]> 5567 5568允许迭代包含在这个对象中的所有键值对。 5569 5570> **说明：** 5571> 5572> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.entries<sup>9+</sup>](#entries9)替代。 5573 5574**系统能力：** SystemCapability.Utils.Lang 5575 5576**返回值：** 5577 5578| 类型 | 说明 | 5579| -------- | -------- | 5580| [K, V] | 返回一个可迭代数组。 | 5581 5582**示例：** 5583 5584 ```ts 5585 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5586 pro.put(2,10); 5587 let result = pro.entries(); 5588 ``` 5589 5590### [Symbol.iterator]<sup>(deprecated)</sup> 5591 5592[Symbol.iterator]\(): IterableIterator<[K, V]> 5593 5594返回一个键值对形式的二维数组。 5595 5596> **说明：** 5597> 5598> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.Symbol.iterator<sup>9+</sup>](#symboliterator9)替代。 5599 5600**系统能力：** SystemCapability.Utils.Lang 5601 5602**返回值：** 5603 5604| 类型 | 说明 | 5605| -------- | -------- | 5606| [K, V] | 返回一个键值对形式的二维数组。 | 5607 5608**示例：** 5609 5610 ```ts 5611 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5612 pro.put(2,10); 5613 let result = pro[Symbol.iterator](); 5614 ``` 5615 5616## Scope<sup>(deprecated)</sup> 5617 5618> **说明：** 5619> 5620> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper<sup>9+</sup>](#scopehelper9)替代。 5621 5622### constructor<sup>(deprecated)</sup> 5623 5624constructor(lowerObj: ScopeType, upperObj: ScopeType) 5625 5626用于创建指定下限和上限的作用域实例的构造函数，返回一个Scope对象。 5627 5628> **说明：** 5629> 5630> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.constructor<sup>9+</sup>](#constructor9-4)替代。 5631 5632 5633**系统能力：** SystemCapability.Utils.Lang 5634 5635**参数：** 5636 5637| 参数名 | 类型 | 必填 | 说明 | 5638| -------- | -------- | -------- | -------- | 5639| lowerObj | [ScopeType](#scopetype8) | 是 | 指定作用域实例的下限。 | 5640| upperObj | [ScopeType](#scopetype8) | 是 | 指定作用域实例的上限。 | 5641 5642**示例：** 5643 ```ts 5644 class Temperature{ 5645 private readonly _temp: number; 5646 constructor(value : number) { 5647 this._temp = value; 5648 } 5649 compareTo(value : Temperature ) { 5650 return this._temp >= value.getTemp(); 5651 } 5652 getTemp() { 5653 return this._temp; 5654 } 5655 toString() : string { 5656 return this._temp.toString(); 5657 } 5658 } 5659 let tempLower = new Temperature(30); 5660 let tempUpper = new Temperature(40); 5661 let range = new util.Scope(tempLower, tempUpper); 5662 ``` 5663 5664### toString<sup>(deprecated)</sup> 5665 5666toString(): string 5667 5668该字符串化方法返回一个包含当前范围的字符串表示形式。 5669 5670> **说明：** 5671> 5672> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.toString<sup>9+</sup>](#tostring9-1)替代。 5673 5674**系统能力：** SystemCapability.Utils.Lang 5675 5676**返回值：** 5677 5678| 类型 | 说明 | 5679| -------- | -------- | 5680| string | 返回包含当前范围对象的字符串表示形式。 | 5681 5682**示例：** 5683 5684 ```ts 5685 class Temperature{ 5686 private readonly _temp: number; 5687 constructor(value : number) { 5688 this._temp = value; 5689 } 5690 compareTo(value : Temperature ) { 5691 return this._temp >= value.getTemp(); 5692 } 5693 getTemp() { 5694 return this._temp; 5695 } 5696 toString() : string { 5697 return this._temp.toString(); 5698 } 5699 } 5700 5701 let tempLower = new Temperature(30); 5702 let tempUpper = new Temperature(40); 5703 let range = new util.Scope(tempLower, tempUpper); 5704 let result = range.toString(); 5705 ``` 5706 5707### intersect<sup>(deprecated)</sup> 5708 5709intersect(range: Scope): Scope 5710 5711获取给定范围和当前范围的交集。 5712 5713> **说明：** 5714> 5715> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.intersect<sup>9+</sup>](#intersect9)替代。 5716 5717**系统能力：** SystemCapability.Utils.Lang 5718 5719**参数：** 5720 5721| 参数名 | 类型 | 必填 | 说明 | 5722| -------- | -------- | -------- | -------- | 5723| range | [Scope](#scopedeprecated) | 是 | 传入一个给定范围。 | 5724 5725**返回值：** 5726 5727| 类型 | 说明 | 5728| -------- | -------- | 5729| [Scope](#scopedeprecated) | 返回给定范围和当前范围的交集。 | 5730 5731**示例：** 5732 5733 ```ts 5734 class Temperature{ 5735 private readonly _temp: number; 5736 constructor(value : number) { 5737 this._temp = value; 5738 } 5739 compareTo(value : Temperature ) { 5740 return this._temp >= value.getTemp(); 5741 } 5742 getTemp() { 5743 return this._temp; 5744 } 5745 toString() : string { 5746 return this._temp.toString(); 5747 } 5748 } 5749 5750 let tempLower = new Temperature(30); 5751 let tempUpper = new Temperature(40); 5752 let range = new util.Scope(tempLower, tempUpper); 5753 let tempMiDF = new Temperature(35); 5754 let tempMidS = new Temperature(39); 5755 let rangeFir = new util.Scope(tempMiDF, tempMidS); 5756 let result = range.intersect(rangeFir ); 5757 ``` 5758 5759### intersect<sup>(deprecated)</sup> 5760 5761intersect(lowerObj:ScopeType,upperObj:ScopeType):Scope 5762 5763获取当前范围与给定下限和上限范围的交集。 5764 5765> **说明：** 5766> 5767> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.intersect<sup>9+</sup>](#intersect9-1)替代。 5768 5769**系统能力：** SystemCapability.Utils.Lang 5770 5771**参数：** 5772 5773| 参数名 | 类型 | 必填 | 说明 | 5774| -------- | -------- | -------- | -------- | 5775| lowerObj | [ScopeType](#scopetype8) | 是 | 给定范围的下限。 | 5776| upperObj | [ScopeType](#scopetype8) | 是 | 给定范围的上限。 | 5777 5778**返回值：** 5779 5780| 类型 | 说明 | 5781| -------- | -------- | 5782| [Scope](#scopedeprecated) | 返回当前范围与给定下限和上限范围的交集。 | 5783 5784**示例：** 5785 5786 ```ts 5787 class Temperature{ 5788 private readonly _temp: number; 5789 constructor(value : number) { 5790 this._temp = value; 5791 } 5792 compareTo(value : Temperature ) { 5793 return this._temp >= value.getTemp(); 5794 } 5795 getTemp() { 5796 return this._temp; 5797 } 5798 toString() : string { 5799 return this._temp.toString(); 5800 } 5801 } 5802 5803 let tempLower = new Temperature(30); 5804 let tempUpper = new Temperature(40); 5805 let tempMiDF = new Temperature(35); 5806 let tempMidS = new Temperature(39); 5807 let range = new util.Scope(tempLower, tempUpper); 5808 let result = range.intersect(tempMiDF, tempMidS); 5809 ``` 5810 5811### getUpper<sup>(deprecated)</sup> 5812 5813getUpper(): ScopeType 5814 5815获取当前范围的上限。 5816 5817> **说明：** 5818> 5819> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.getUpper<sup>9+</sup>](#getupper9)替代。 5820 5821**系统能力：** SystemCapability.Utils.Lang 5822 5823**返回值：** 5824 5825| 类型 | 说明 | 5826| -------- | -------- | 5827| [ScopeType](#scopetype8) | 返回当前范围的上限值。 | 5828 5829**示例：** 5830 5831 ```ts 5832 class Temperature{ 5833 private readonly _temp: number; 5834 constructor(value : number) { 5835 this._temp = value; 5836 } 5837 compareTo(value : Temperature ) { 5838 return this._temp >= value.getTemp(); 5839 } 5840 getTemp() { 5841 return this._temp; 5842 } 5843 toString() : string { 5844 return this._temp.toString(); 5845 } 5846 } 5847 5848 let tempLower = new Temperature(30); 5849 let tempUpper = new Temperature(40); 5850 let range = new util.Scope(tempLower, tempUpper); 5851 let result = range.getUpper(); 5852 ``` 5853 5854### getLower<sup>(deprecated)</sup> 5855 5856getLower(): ScopeType 5857 5858获取当前范围的下限。 5859 5860> **说明：** 5861> 5862> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.getLower<sup>9+</sup>](#getlower9)替代。 5863 5864**系统能力：** SystemCapability.Utils.Lang 5865 5866**返回值：** 5867 5868| 类型 | 说明 | 5869| -------- | -------- | 5870| [ScopeType](#scopetype8) | 返回当前范围的下限值。 | 5871 5872**示例：** 5873 5874 ```ts 5875 class Temperature{ 5876 private readonly _temp: number; 5877 constructor(value : number) { 5878 this._temp = value; 5879 } 5880 compareTo(value : Temperature ) { 5881 return this._temp >= value.getTemp(); 5882 } 5883 getTemp() { 5884 return this._temp; 5885 } 5886 toString() : string { 5887 return this._temp.toString(); 5888 } 5889 } 5890 5891 let tempLower = new Temperature(30); 5892 let tempUpper = new Temperature(40); 5893 let range = new util.Scope(tempLower, tempUpper); 5894 let result = range.getLower(); 5895 ``` 5896 5897### expand<sup>(deprecated)</sup> 5898 5899expand(lowerObj: ScopeType,upperObj: ScopeType): Scope 5900 5901创建并返回包括当前范围和给定下限和上限的并集。 5902 5903> **说明：** 5904> 5905> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.expand<sup>9+</sup>](#expand9)替代。 5906 5907**系统能力：** SystemCapability.Utils.Lang 5908 5909**参数：** 5910 5911| 参数名 | 类型 | 必填 | 说明 | 5912| -------- | -------- | -------- | -------- | 5913| lowerObj | [ScopeType](#scopetype8) | 是 | 给定范围的下限。 | 5914| upperObj | [ScopeType](#scopetype8) | 是 | 给定范围的上限。 | 5915 5916**返回值：** 5917 5918| 类型 | 说明 | 5919| -------- | -------- | 5920| [Scope](#scopedeprecated) | 返回当前范围和给定下限和上限的并集。 | 5921 5922**示例：** 5923 5924 ```ts 5925 class Temperature{ 5926 private readonly _temp: number; 5927 constructor(value : number) { 5928 this._temp = value; 5929 } 5930 compareTo(value : Temperature ) { 5931 return this._temp >= value.getTemp(); 5932 } 5933 getTemp() { 5934 return this._temp; 5935 } 5936 toString() : string { 5937 return this._temp.toString(); 5938 } 5939 } 5940 5941 let tempLower = new Temperature(30); 5942 let tempUpper = new Temperature(40); 5943 let tempMiDF = new Temperature(35); 5944 let tempMidS = new Temperature(39); 5945 let range = new util.Scope(tempLower, tempUpper); 5946 let result = range.expand(tempMiDF, tempMidS); 5947 ``` 5948 5949### expand<sup>(deprecated)</sup> 5950 5951expand(range: Scope): Scope 5952 5953创建并返回包括当前范围和给定范围的并集。 5954 5955> **说明：** 5956> 5957> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.expand<sup>9+</sup>](#expand9-1)替代。 5958 5959**系统能力：** SystemCapability.Utils.Lang 5960 5961**参数：** 5962 5963| 参数名 | 类型 | 必填 | 说明 | 5964| -------- | -------- | -------- | -------- | 5965| range | [Scope](#scopedeprecated) | 是 | 传入一个给定范围。 | 5966 5967**返回值：** 5968 5969| 类型 | 说明 | 5970| -------- | -------- | 5971| [Scope](#scopedeprecated) | 返回包括当前范围和给定范围的并集。 | 5972 5973**示例：** 5974 5975 ```ts 5976 class Temperature{ 5977 private readonly _temp: number; 5978 constructor(value : number) { 5979 this._temp = value; 5980 } 5981 compareTo(value : Temperature ) { 5982 return this._temp >= value.getTemp(); 5983 } 5984 getTemp() { 5985 return this._temp; 5986 } 5987 toString() : string { 5988 return this._temp.toString(); 5989 } 5990 } 5991 5992 let tempLower = new Temperature(30); 5993 let tempUpper = new Temperature(40); 5994 let tempMiDF = new Temperature(35); 5995 let tempMidS = new Temperature(39); 5996 let range = new util.Scope(tempLower, tempUpper); 5997 let rangeFir = new util.Scope(tempMiDF, tempMidS); 5998 let result = range.expand(rangeFir); 5999 ``` 6000 6001### expand<sup>(deprecated)</sup> 6002 6003expand(value: ScopeType): Scope 6004 6005创建并返回包括当前范围和给定值的并集。 6006 6007> **说明：** 6008> 6009> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.expand<sup>9+</sup>](#expand9-2)替代。 6010 6011**系统能力：** SystemCapability.Utils.Lang 6012 6013**参数：** 6014 6015| 参数名 | 类型 | 必填 | 说明 | 6016| -------- | -------- | -------- | -------- | 6017| value | [ScopeType](#scopetype8) | 是 | 传入一个给定值。 | 6018 6019**返回值：** 6020 6021| 类型 | 说明 | 6022| -------- | -------- | 6023| [Scope](#scopedeprecated) | 返回包括当前范围和给定值的并集。 | 6024 6025**示例：** 6026 6027 ```ts 6028 class Temperature{ 6029 private readonly _temp: number; 6030 constructor(value : number) { 6031 this._temp = value; 6032 } 6033 compareTo(value : Temperature ) { 6034 return this._temp >= value.getTemp(); 6035 } 6036 getTemp() { 6037 return this._temp; 6038 } 6039 toString() : string { 6040 return this._temp.toString(); 6041 } 6042 } 6043 6044 let tempLower = new Temperature(30); 6045 let tempUpper = new Temperature(40); 6046 let tempMiDF = new Temperature(35); 6047 let range = new util.Scope(tempLower, tempUpper); 6048 let result = range.expand(tempMiDF); 6049 ``` 6050 6051### contains<sup>(deprecated)</sup> 6052 6053contains(value: ScopeType): boolean 6054 6055检查给定value是否包含在当前范围内。 6056 6057> **说明：** 6058> 6059> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.contains<sup>9+</sup>](#contains9-1)替代。 6060 6061**系统能力：** SystemCapability.Utils.Lang 6062 6063**参数：** 6064 6065| 参数名 | 类型 | 必填 | 说明 | 6066| -------- | -------- | -------- | -------- | 6067| value | [ScopeType](#scopetype8) | 是 | 传入一个给定值。 | 6068 6069**返回值：** 6070 6071| 类型 | 说明 | 6072| -------- | -------- | 6073| boolean | 如果给定值包含在当前范围内返回true，否则返回false。 | 6074 6075**示例：** 6076 6077 ```ts 6078 class Temperature{ 6079 private readonly _temp: number; 6080 constructor(value : number) { 6081 this._temp = value; 6082 } 6083 compareTo(value : Temperature ) { 6084 return this._temp >= value.getTemp(); 6085 } 6086 getTemp() { 6087 return this._temp; 6088 } 6089 toString() : string { 6090 return this._temp.toString(); 6091 } 6092 } 6093 6094 let tempLower = new Temperature(30); 6095 let tempUpper = new Temperature(40); 6096 let tempMiDF = new Temperature(35); 6097 let range = new util.Scope(tempLower, tempUpper); 6098 let result = range.contains(tempMiDF); 6099 ``` 6100 6101### contains<sup>(deprecated)</sup> 6102 6103contains(range: Scope): boolean 6104 6105检查给定range是否在当前范围内。 6106 6107> **说明：** 6108> 6109> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.contains<sup>9+</sup>](#contains9-2)替代。 6110 6111**系统能力：** SystemCapability.Utils.Lang 6112 6113**参数：** 6114 6115| 参数名 | 类型 | 必填 | 说明 | 6116| -------- | -------- | -------- | -------- | 6117| range | [Scope](#scopedeprecated) | 是 | 传入一个给定范围。 | 6118 6119**返回值：** 6120 6121| 类型 | 说明 | 6122| -------- | -------- | 6123| boolean | 如果给定范围包含在当前范围内返回true，否则返回false。 | 6124 6125**示例：** 6126 6127 ```ts 6128 class Temperature{ 6129 private readonly _temp: number; 6130 constructor(value : number) { 6131 this._temp = value; 6132 } 6133 compareTo(value : Temperature ) { 6134 return this._temp >= value.getTemp(); 6135 } 6136 getTemp() { 6137 return this._temp; 6138 } 6139 toString() : string { 6140 return this._temp.toString(); 6141 } 6142 } 6143 6144 let tempLower = new Temperature(30); 6145 let tempUpper = new Temperature(40); 6146 let range = new util.Scope(tempLower, tempUpper); 6147 let tempLess = new Temperature(20); 6148 let tempMore = new Temperature(45); 6149 let rangeSec = new util.Scope(tempLess, tempMore); 6150 let result = range.contains(rangeSec); 6151 ``` 6152 6153### clamp<sup>(deprecated)</sup> 6154 6155 6156clamp(value: ScopeType): ScopeType 6157 6158将给定值限定到当前范围内。 6159 6160> **说明：** 6161> 6162> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.clamp<sup>9+</sup>](#clamp9)替代。 6163 6164**系统能力：** SystemCapability.Utils.Lang 6165 6166**参数：** 6167 6168| 参数名 | 类型 | 必填 | 说明 | 6169| -------- | -------- | -------- | -------- | 6170| value | [ScopeType](#scopetype8) | 是 | 传入的给定值。 | 6171 6172**返回值：** 6173 6174| 类型 | 说明 | 6175| -------- | -------- | 6176| [ScopeType](#scopetype8) | 如果传入的value小于下限，则返回lowerObj；如果大于上限值则返回upperObj；如果在当前范围内，则返回value。 | 6177 6178**示例：** 6179 6180 ```ts 6181 class Temperature{ 6182 private readonly _temp: number; 6183 constructor(value : number) { 6184 this._temp = value; 6185 } 6186 compareTo(value : Temperature ) { 6187 return this._temp >= value.getTemp(); 6188 } 6189 getTemp() { 6190 return this._temp; 6191 } 6192 toString() : string { 6193 return this._temp.toString(); 6194 } 6195 } 6196 6197 let tempLower = new Temperature(30); 6198 let tempUpper = new Temperature(40); 6199 let tempMiDF = new Temperature(35); 6200 let range = new util.Scope(tempLower, tempUpper); 6201 let result = range.clamp(tempMiDF); 6202 ``` 6203 6204 6205## Base64<sup>(deprecated)</sup> 6206 6207> **说明：** 6208> 6209> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper<sup>9+</sup>](#base64helper9)替代。 6210 6211### constructor<sup>(deprecated)</sup> 6212 6213constructor() 6214 6215Base64的构造函数。 6216 6217> **说明：** 6218> 6219> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.constructor<sup>9+</sup>](#constructor9-5)替代。 6220 6221**系统能力：** SystemCapability.Utils.Lang 6222 6223**示例：** 6224 6225 ```ts 6226 let base64 = new util.Base64(); 6227 ``` 6228 6229### encodeSync<sup>(deprecated)</sup> 6230 6231encodeSync(src: Uint8Array): Uint8Array 6232 6233通过输入参数编码后输出对应文本。 6234 6235> **说明：** 6236> 6237> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encodeSync<sup>9+</sup>](#encodesync9)替代。 6238 6239**系统能力：** SystemCapability.Utils.Lang 6240 6241**参数：** 6242 6243| 参数名 | 类型 | 必填 | 说明 | 6244| -------- | -------- | -------- | -------- | 6245| src | Uint8Array | 是 | 编码输入Uint8数组。 | 6246 6247**返回值：** 6248 6249| 类型 | 说明 | 6250| -------- | -------- | 6251| Uint8Array | 返回编码后新分配的Uint8数组。 | 6252 6253**示例：** 6254 6255 ```ts 6256 let base64 = new util.Base64(); 6257 let array = new Uint8Array([115,49,51]); 6258 let result = base64.encodeSync(array); 6259 ``` 6260 6261### encodeToStringSync<sup>(deprecated)</sup> 6262 6263encodeToStringSync(src: Uint8Array): string 6264 6265通过输入参数编码后输出对应文本。 6266 6267> **说明：** 6268> 6269> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encodeToStringSync<sup>9+</sup>](#encodetostringsync9)替代。 6270 6271**系统能力：** SystemCapability.Utils.Lang 6272 6273**参数：** 6274 6275| 参数名 | 类型 | 必填 | 说明 | 6276| -------- | -------- | -------- | -------- | 6277| src | Uint8Array | 是 | 编码输入Uint8数组。 | 6278 6279**返回值：** 6280 6281| 类型 | 说明 | 6282| -------- | -------- | 6283| string | 返回编码后的字符串。 | 6284 6285**示例：** 6286 6287 ```ts 6288 let base64 = new util.Base64(); 6289 let array = new Uint8Array([115,49,51]); 6290 let result = base64.encodeToStringSync(array); 6291 ``` 6292 6293### decodeSync<sup>(deprecated)</sup> 6294 6295decodeSync(src: Uint8Array | string): Uint8Array 6296 6297通过输入参数解码后输出对应文本。 6298 6299> **说明：** 6300> 6301> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.decodeSync<sup>9+</sup>](#decodesync9)替代。 6302 6303**系统能力：** SystemCapability.Utils.Lang 6304 6305**参数：** 6306 6307| 参数名 | 类型 | 必填 | 说明 | 6308| -------- | -------- | -------- | -------- | 6309| src | Uint8Array \| string | 是 | 解码输入Uint8数组或者字符串。 | 6310 6311**返回值：** 6312 6313| 类型 | 说明 | 6314| -------- | -------- | 6315| Uint8Array | 返回解码后新分配的Uint8数组。 | 6316 6317**示例：** 6318 6319 ```ts 6320 let base64 = new util.Base64(); 6321 let buff = 'czEz'; 6322 let result = base64.decodeSync(buff); 6323 ``` 6324 6325### encode<sup>(deprecated)</sup> 6326 6327encode(src: Uint8Array): Promise<Uint8Array> 6328 6329通过输入参数异步编码后输出对应文本。 6330 6331> **说明：** 6332> 6333> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encode<sup>9+</sup>](#encode9)替代。 6334 6335**系统能力：** SystemCapability.Utils.Lang 6336 6337**参数：** 6338 6339| 参数名 | 类型 | 必填 | 说明 | 6340| -------- | -------- | -------- | -------- | 6341| src | Uint8Array | 是 | 异步编码输入Uint8数组。 | 6342 6343**返回值：** 6344 6345| 类型 | 说明 | 6346| -------- | -------- | 6347| Promise<Uint8Array> | 返回异步编码后新分配的Uint8数组。 | 6348 6349**示例：** 6350 6351 ```ts 6352 let base64 = new util.Base64(); 6353 let array = new Uint8Array([115,49,51]); 6354 base64.encode(array).then((val) => { 6355 console.info(val.toString()); 6356 }) 6357 ``` 6358 6359### encodeToString<sup>(deprecated)</sup> 6360 6361encodeToString(src: Uint8Array): Promise<string> 6362 6363通过输入参数异步编码后输出对应文本。 6364 6365> **说明：** 6366> 6367> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encodeToString<sup>9+</sup>](#encodetostring9)替代。 6368 6369**系统能力：** SystemCapability.Utils.Lang 6370 6371**参数：** 6372 6373| 参数名 | 类型 | 必填 | 说明 | 6374| -------- | -------- | -------- | -------- | 6375| src | Uint8Array | 是 | 异步编码输入Uint8数组。 | 6376 6377**返回值：** 6378 6379| 类型 | 说明 | 6380| -------- | -------- | 6381| Promise<string> | 返回异步编码后的字符串。 | 6382 6383**示例：** 6384 6385 ```ts 6386 let base64 = new util.Base64(); 6387 let array = new Uint8Array([115,49,51]); 6388 base64.encodeToString(array).then((val) => { 6389 console.info(val); 6390 }) 6391 ``` 6392 6393### decode<sup>(deprecated)</sup> 6394 6395 6396decode(src: Uint8Array | string): Promise<Uint8Array> 6397 6398通过输入参数异步解码后输出对应文本。 6399 6400> **说明：** 6401> 6402> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.decode<sup>9+</sup>](#decode9)替代。 6403 6404**系统能力：** SystemCapability.Utils.Lang 6405 6406**参数：** 6407 6408| 参数名 | 类型 | 必填 | 说明 | 6409| -------- | -------- | -------- | -------- | 6410| src | Uint8Array \| string | 是 | 异步解码输入Uint8数组或者字符串。 | 6411 6412**返回值：** 6413 6414| 类型 | 说明 | 6415| -------- | -------- | 6416| Promise<Uint8Array> | 返回异步解码后新分配的Uint8数组。 | 6417 6418**示例：** 6419 6420 ```ts 6421 let base64 = new util.Base64(); 6422 let array = new Uint8Array([99,122,69,122]); 6423 base64.decode(array).then((val) => { 6424 console.info(val.toString()); 6425 }) 6426 ``` 6427