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。为了提升性能，此接口会默认使用缓存，即入参为true，最多可缓存128个随机的UUID。当缓存中128个UUID都被使用后，会重新进行一次缓存UUID的生成，以保证UUID的随机性。假如不需要使用缓存的UUID，请将入参设置为false。 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 1334parseRationalNumber(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 1521getCommonFactor(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 ```ts 4122 import { foo } from './test' 4123 4124 let type = new util.types(); 4125 let result = type.isGeneratorFunction(foo); 4126 console.info("result = " + result); 4127 // 输出结果：result = true 4128 ``` 4129 4130 4131### isGeneratorObject<sup>8+</sup> 4132 4133isGeneratorObject(value: Object): boolean 4134 4135检查输入的value是否是generator对象类型。 4136 4137**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4138 4139**系统能力：** SystemCapability.Utils.Lang 4140 4141**参数：** 4142 4143| 参数名 | 类型 | 必填 | 说明 | 4144| -------- | -------- | -------- | -------- | 4145| value | Object | 是 | 待检测对象。 | 4146 4147**返回值：** 4148 4149| 类型 | 说明 | 4150| -------- | -------- | 4151| boolean | 判断的结果，如果是内置包含的generator对象类型为true，反之为false。 | 4152 4153**示例：** 4154 4155 ```ts 4156 // /entry/src/main/ets/pages/test.ts 4157 function* foo() {} 4158 export const generator = foo(); 4159 ``` 4160 4161 ```ts 4162 import { generator } from './test' 4163 4164 let type = new util.types(); 4165 let result = type.isGeneratorObject(generator); 4166 console.info("result = " + result); 4167 // 输出结果：result = true 4168 ``` 4169 4170 4171### isInt8Array<sup>8+</sup> 4172 4173isInt8Array(value: Object): boolean 4174 4175检查输入的value是否是Int8Array数组类型。 4176 4177**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4178 4179**系统能力：** SystemCapability.Utils.Lang 4180 4181**参数：** 4182 4183| 参数名 | 类型 | 必填 | 说明 | 4184| -------- | -------- | -------- | -------- | 4185| value | Object | 是 | 待检测对象。 | 4186 4187**返回值：** 4188 4189| 类型 | 说明 | 4190| -------- | -------- | 4191| boolean | 判断的结果，如果是内置包含的Int8Array数组类型为true，反之为false。 | 4192 4193**示例：** 4194 4195 ```ts 4196 let type = new util.types(); 4197 let result = type.isInt8Array(new Int8Array([])); 4198 console.info("result = " + result); 4199 // 输出结果：result = true 4200 ``` 4201 4202 4203### isInt16Array<sup>8+</sup> 4204 4205isInt16Array(value: Object): boolean 4206 4207检查输入的value是否是Int16Array数组类型。 4208 4209**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4210 4211**系统能力：** SystemCapability.Utils.Lang 4212 4213**参数：** 4214 4215| 参数名 | 类型 | 必填 | 说明 | 4216| -------- | -------- | -------- | -------- | 4217| value | Object | 是 | 待检测对象。 | 4218 4219**返回值：** 4220 4221| 类型 | 说明 | 4222| -------- | -------- | 4223| boolean | 判断的结果，如果是内置包含的Int16Array数组类型为true，反之为false。 | 4224 4225**示例：** 4226 4227 ```ts 4228 let type = new util.types(); 4229 let result = type.isInt16Array(new Int16Array([])); 4230 console.info("result = " + result); 4231 // 输出结果：result = true 4232 ``` 4233 4234 4235### isInt32Array<sup>8+</sup> 4236 4237isInt32Array(value: Object): boolean 4238 4239检查输入的value是否是Int32Array数组类型。 4240 4241**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4242 4243**系统能力：** SystemCapability.Utils.Lang 4244 4245**参数：** 4246 4247| 参数名 | 类型 | 必填 | 说明 | 4248| -------- | -------- | -------- | -------- | 4249| value | Object | 是 | 待检测对象。 | 4250 4251**返回值：** 4252 4253| 类型 | 说明 | 4254| -------- | -------- | 4255| boolean | 判断的结果，如果是内置包含的Int32Array数组类型为true，反之为false。 | 4256 4257**示例：** 4258 4259 ```ts 4260 let type = new util.types(); 4261 let result = type.isInt32Array(new Int32Array([])); 4262 console.info("result = " + result); 4263 // 输出结果：result = true 4264 ``` 4265 4266 4267### isMap<sup>8+</sup> 4268 4269isMap(value: Object): boolean 4270 4271检查输入的value是否是Map类型。 4272 4273**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4274 4275**系统能力：** SystemCapability.Utils.Lang 4276 4277**参数：** 4278 4279| 参数名 | 类型 | 必填 | 说明 | 4280| -------- | -------- | -------- | -------- | 4281| value | Object | 是 | 待检测对象。 | 4282 4283**返回值：** 4284 4285| 类型 | 说明 | 4286| -------- | -------- | 4287| boolean | 判断的结果，如果是内置包含的Map类型为true，反之为false。 | 4288 4289**示例：** 4290 4291 ```ts 4292 let type = new util.types(); 4293 let result = type.isMap(new Map()); 4294 console.info("result = " + result); 4295 // 输出结果：result = true 4296 ``` 4297 4298 4299### isMapIterator<sup>8+</sup> 4300 4301isMapIterator(value: Object): boolean 4302 4303检查输入的value是否是Map的Iterator类型。 4304 4305**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4306 4307**系统能力：** SystemCapability.Utils.Lang 4308 4309**参数：** 4310 4311 4312| 参数名 | 类型 | 必填 | 说明 | 4313| -------- | -------- | -------- | -------- | 4314| value | Object | 是 | 待检测对象。 | 4315 4316**返回值：** 4317 4318| 类型 | 说明 | 4319| -------- | -------- | 4320| boolean | 判断的结果，如果是内置包含的Map的Iterator类型为true，反之为false。 | 4321 4322**示例：** 4323 4324 ```ts 4325 let type = new util.types(); 4326 const map : Map<number,number> = new Map(); 4327 let result = type.isMapIterator(map.keys()); 4328 console.info("result = " + result); 4329 // 输出结果：result = true 4330 ``` 4331 4332 4333### isNativeError<sup>8+</sup> 4334 4335isNativeError(value: Object): boolean 4336 4337检查输入的value是否是Error类型。 4338 4339**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4340 4341**系统能力：** SystemCapability.Utils.Lang 4342 4343**参数：** 4344 4345| 参数名 | 类型 | 必填 | 说明 | 4346| -------- | -------- | -------- | -------- | 4347| value | Object | 是 | 待检测对象。 | 4348 4349**返回值：** 4350 4351| 类型 | 说明 | 4352| -------- | -------- | 4353| boolean | 判断的结果，如果是内置包含的Error类型为true，反之为false。 | 4354 4355**示例：** 4356 4357 ```ts 4358 let type = new util.types(); 4359 let result = type.isNativeError(new TypeError()); 4360 console.info("result = " + result); 4361 // 输出结果：result = true 4362 ``` 4363 4364 4365### isNumberObject<sup>8+</sup> 4366 4367isNumberObject(value: Object): boolean 4368 4369检查输入的value是否是Number对象类型。 4370 4371**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4372 4373**系统能力：** SystemCapability.Utils.Lang 4374 4375**参数：** 4376 4377| 参数名 | 类型 | 必填 | 说明 | 4378| -------- | -------- | -------- | -------- | 4379| value | Object | 是 | 待检测对象。 | 4380 4381**返回值：** 4382 4383| 类型 | 说明 | 4384| -------- | -------- | 4385| boolean | 判断的结果，如果是内置包含的Number对象类型为true，反之为false。 | 4386 4387**示例：** 4388 4389 ```ts 4390 let type = new util.types(); 4391 let result = type.isNumberObject(new Number(0)); 4392 console.info("result = " + result); 4393 // 输出结果：result = true 4394 ``` 4395 4396 4397### isPromise<sup>8+</sup> 4398 4399isPromise(value: Object): boolean 4400 4401检查输入的value是否是Promise类型。 4402 4403**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4404 4405**系统能力：** SystemCapability.Utils.Lang 4406 4407**参数：** 4408 4409| 参数名 | 类型 | 必填 | 说明 | 4410| -------- | -------- | -------- | -------- | 4411| value | Object | 是 | 待检测对象。 | 4412 4413**返回值：** 4414 4415| 类型 | 说明 | 4416| -------- | -------- | 4417| boolean | 判断的结果，如果是内置包含的Promise类型为true，反之为false。 | 4418 4419**示例：** 4420 4421 ```ts 4422 let type = new util.types(); 4423 let result = type.isPromise(Promise.resolve(1)); 4424 console.info("result = " + result); 4425 // 输出结果：result = true 4426 ``` 4427 4428 4429### isProxy<sup>8+</sup> 4430 4431isProxy(value: Object): boolean 4432 4433检查输入的value是否是Proxy类型。 4434 4435**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4436 4437**系统能力：** SystemCapability.Utils.Lang 4438 4439**参数：** 4440 4441| 参数名 | 类型 | 必填 | 说明 | 4442| -------- | -------- | -------- | -------- | 4443| value | Object | 是 | 待检测对象。 | 4444 4445**返回值：** 4446 4447| 类型 | 说明 | 4448| -------- | -------- | 4449| boolean | 判断的结果，如果是内置包含的Proxy类型为true，反之为false。 | 4450 4451**示例：** 4452 4453 ```ts 4454 class Target{ 4455 } 4456 let type = new util.types(); 4457 const target : Target = {}; 4458 const proxy = new Proxy(target, target); 4459 let result = type.isProxy(proxy); 4460 console.info("result = " + result); 4461 // 输出结果：result = true 4462 ``` 4463 4464 4465### isRegExp<sup>8+</sup> 4466 4467isRegExp(value: Object): boolean 4468 4469检查输入的value是否是RegExp类型。 4470 4471**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4472 4473**系统能力：** SystemCapability.Utils.Lang 4474 4475**参数：** 4476 4477| 参数名 | 类型 | 必填 | 说明 | 4478| -------- | -------- | -------- | -------- | 4479| value | Object | 是 | 待检测对象。 | 4480 4481**返回值：** 4482 4483| 类型 | 说明 | 4484| -------- | -------- | 4485| boolean | 判断的结果，如果是内置包含的RegExp类型为true，反之为false。 | 4486 4487**示例：** 4488 4489 ```ts 4490 let type = new util.types(); 4491 let result = type.isRegExp(new RegExp('abc')); 4492 console.info("result = " + result); 4493 // 输出结果：result = true 4494 ``` 4495 4496 4497### isSet<sup>8+</sup> 4498 4499isSet(value: Object): boolean 4500 4501检查输入的value是否是Set类型。 4502 4503**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4504 4505**系统能力：** SystemCapability.Utils.Lang 4506 4507**参数：** 4508 4509| 参数名 | 类型 | 必填 | 说明 | 4510| -------- | -------- | -------- | -------- | 4511| value | Object | 是 | 待检测对象。 | 4512 4513**返回值：** 4514 4515| 类型 | 说明 | 4516| -------- | -------- | 4517| boolean | 判断的结果，如果是内置包含的Set类型为true，反之为false。 | 4518 4519**示例：** 4520 4521 ```ts 4522 let type = new util.types(); 4523 let set : Set<number> = new Set(); 4524 let result = type.isSet(set); 4525 console.info("result = " + result); 4526 // 输出结果：result = true 4527 ``` 4528 4529 4530### isSetIterator<sup>8+</sup> 4531 4532isSetIterator(value: Object): boolean 4533 4534检查输入的value是否是Set的Iterator类型。 4535 4536**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4537 4538**系统能力：** SystemCapability.Utils.Lang 4539 4540**参数：** 4541 4542| 参数名 | 类型 | 必填 | 说明 | 4543| -------- | -------- | -------- | -------- | 4544| value | Object | 是 | 待检测对象。 | 4545 4546**返回值：** 4547 4548| 类型 | 说明 | 4549| -------- | -------- | 4550| boolean | 判断的结果，如果是内置包含的Set的Iterator类型为true，反之为false。 | 4551 4552**示例：** 4553 4554 ```ts 4555 let type = new util.types(); 4556 const set : Set<number> = new Set(); 4557 let result = type.isSetIterator(set.keys()); 4558 console.info("result = " + result); 4559 // 输出结果：result = true 4560 ``` 4561 4562 4563### isStringObject<sup>8+</sup> 4564 4565isStringObject(value: Object): boolean 4566 4567检查输入的value是否是String对象类型。 4568 4569**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4570 4571**系统能力：** SystemCapability.Utils.Lang 4572 4573**参数：** 4574 4575| 参数名 | 类型 | 必填 | 说明 | 4576| -------- | -------- | -------- | -------- | 4577| value | Object | 是 | 待检测对象。 | 4578 4579**返回值：** 4580 4581| 类型 | 说明 | 4582| -------- | -------- | 4583| boolean | 判断的结果，如果是内置包含的String对象类型为true，反之为false。 | 4584 4585**示例：** 4586 4587 ```ts 4588 let type = new util.types(); 4589 let result = type.isStringObject(new String('foo')); 4590 console.info("result = " + result); 4591 // 输出结果：result = true 4592 ``` 4593 4594 4595### isSymbolObject<sup>8+</sup> 4596 4597isSymbolObject(value: Object): boolean 4598 4599检查输入的value是否是Symbol对象类型。 4600 4601**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4602 4603**系统能力：** SystemCapability.Utils.Lang 4604 4605**参数：** 4606 4607| 参数名 | 类型 | 必填 | 说明 | 4608| -------- | -------- | -------- | -------- | 4609| value | Object | 是 | 待检测对象。 | 4610 4611**返回值：** 4612 4613| 类型 | 说明 | 4614| -------- | -------- | 4615| boolean | 判断的结果，如果是内置包含的Symbol对象类型为true，反之为false。 | 4616 4617**示例：** 4618 4619 ```ts 4620 // /entry/src/main/ets/pages/test.ts 4621 export const symbols = Symbol('foo'); 4622 ``` 4623 4624 ```ts 4625 import { symbols } from './test' 4626 4627 let type = new util.types(); 4628 let result = type.isSymbolObject(Object(symbols)); 4629 console.info("result = " + result); 4630 // 输出结果：result = true 4631 ``` 4632 4633 4634### isTypedArray<sup>8+</sup> 4635 4636isTypedArray(value: Object): boolean 4637 4638检查输入的value是否是TypedArray类型的辅助类型。 4639 4640TypedArray类型的辅助类型，包括Int8Array、Int16Array、Int32Array、Uint8Array、Uint8ClampedArray、Uint16Array、Uint32Array、Float32Array、Float64Array、BigInt64Array、BigUint64Array。 4641 4642**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4643 4644**系统能力：** SystemCapability.Utils.Lang 4645 4646**参数：** 4647 4648| 参数名 | 类型 | 必填 | 说明 | 4649| -------- | -------- | -------- | -------- | 4650| value | Object | 是 | 待检测对象。 | 4651 4652**返回值：** 4653 4654| 类型 | 说明 | 4655| -------- | -------- | 4656| boolean | 判断的结果，如果是内置包含的TypedArray包含的类型为true，反之为false。 | 4657 4658**示例：** 4659 4660 ```ts 4661 let type = new util.types(); 4662 let result = type.isTypedArray(new Float64Array([])); 4663 console.info("result = " + result); 4664 // 输出结果：result = true 4665 ``` 4666 4667 4668### isUint8Array<sup>8+</sup> 4669 4670isUint8Array(value: Object): boolean 4671 4672检查输入的value是否是Uint8Array数组类型。 4673 4674**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4675 4676**系统能力：** SystemCapability.Utils.Lang 4677 4678**参数：** 4679 4680| 参数名 | 类型 | 必填 | 说明 | 4681| -------- | -------- | -------- | -------- | 4682| value | Object | 是 | 待检测对象。 | 4683 4684**返回值：** 4685 4686| 类型 | 说明 | 4687| -------- | -------- | 4688| boolean | 判断的结果，如果是内置包含的Uint8Array数组类型为true，反之为false。 | 4689 4690**示例：** 4691 4692 ```ts 4693 let type = new util.types(); 4694 let result = type.isUint8Array(new Uint8Array([])); 4695 console.info("result = " + result); 4696 // 输出结果：result = true 4697 ``` 4698 4699 4700### isUint8ClampedArray<sup>8+</sup> 4701 4702isUint8ClampedArray(value: Object): boolean 4703 4704检查输入的value是否是Uint8ClampedArray数组类型。 4705 4706**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4707 4708**系统能力：** SystemCapability.Utils.Lang 4709 4710**参数：** 4711 4712| 参数名 | 类型 | 必填 | 说明 | 4713| -------- | -------- | -------- | -------- | 4714| value | Object | 是 | 待检测对象。 | 4715 4716**返回值：** 4717 4718| 类型 | 说明 | 4719| -------- | -------- | 4720| boolean | 判断的结果，如果是内置包含的Uint8ClampedArray数组类型为true，反之为false。 | 4721 4722**示例：** 4723 4724 ```ts 4725 let type = new util.types(); 4726 let result = type.isUint8ClampedArray(new Uint8ClampedArray([])); 4727 console.info("result = " + result); 4728 // 输出结果：result = true 4729 ``` 4730 4731 4732### isUint16Array<sup>8+</sup> 4733 4734isUint16Array(value: Object): boolean 4735 4736检查输入的value是否是Uint16Array数组类型。 4737 4738**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4739 4740**系统能力：** SystemCapability.Utils.Lang 4741 4742**参数：** 4743 4744| 参数名 | 类型 | 必填 | 说明 | 4745| -------- | -------- | -------- | -------- | 4746| value | Object | 是 | 待检测对象。 | 4747 4748**返回值：** 4749 4750| 类型 | 说明 | 4751| -------- | -------- | 4752| boolean | 判断的结果，如果是内置包含的Uint16Array数组类型为true，反之为false。 | 4753 4754**示例：** 4755 4756 ```ts 4757 let type = new util.types(); 4758 let result = type.isUint16Array(new Uint16Array([])); 4759 console.info("result = " + result); 4760 // 输出结果：result = true 4761 ``` 4762 4763 4764### isUint32Array<sup>8+</sup> 4765 4766isUint32Array(value: Object): boolean 4767 4768检查输入的value是否是Uint32Array数组类型。 4769 4770**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4771 4772**系统能力：** SystemCapability.Utils.Lang 4773 4774**参数：** 4775 4776| 参数名 | 类型 | 必填 | 说明 | 4777| -------- | -------- | -------- | -------- | 4778| value | Object | 是 | 待检测对象。 | 4779 4780**返回值：** 4781 4782| 类型 | 说明 | 4783| -------- | -------- | 4784| boolean | 判断的结果，如果是内置包含的Uint32Array数组类型为true，反之为false。 | 4785 4786**示例：** 4787 4788 ```ts 4789 let type = new util.types(); 4790 let result = type.isUint32Array(new Uint32Array([])); 4791 console.info("result = " + result); 4792 // 输出结果：result = true 4793 ``` 4794 4795 4796### isWeakMap<sup>8+</sup> 4797 4798isWeakMap(value: Object): boolean 4799 4800检查输入的value是否是WeakMap类型。 4801 4802**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4803 4804**系统能力：** SystemCapability.Utils.Lang 4805 4806**参数：** 4807 4808| 参数名 | 类型 | 必填 | 说明 | 4809| -------- | -------- | -------- | -------- | 4810| value | Object | 是 | 待检测对象。 | 4811 4812**返回值：** 4813 4814| 类型 | 说明 | 4815| -------- | -------- | 4816| boolean | 判断的结果，如果是内置包含的WeakMap类型为true，反之为false。 | 4817 4818**示例：** 4819 4820 ```ts 4821 let type = new util.types(); 4822 let value : WeakMap<object, number> = new WeakMap(); 4823 let result = type.isWeakMap(value); 4824 console.info("result = " + result); 4825 // 输出结果：result = true 4826 ``` 4827 4828 4829### isWeakSet<sup>8+</sup> 4830 4831isWeakSet(value: Object): boolean 4832 4833检查输入的value是否是WeakSet类型。 4834 4835**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4836 4837**系统能力：** SystemCapability.Utils.Lang 4838 4839**参数：** 4840 4841| 参数名 | 类型 | 必填 | 说明 | 4842| -------- | -------- | -------- | -------- | 4843| value | Object | 是 | 待检测对象。 | 4844 4845**返回值：** 4846 4847| 类型 | 说明 | 4848| -------- | -------- | 4849| boolean | 判断的结果，如果是内置包含的WeakSet类型为true，反之为false。 | 4850 4851**示例：** 4852 4853 ```ts 4854 let type = new util.types(); 4855 let result = type.isWeakSet(new WeakSet()); 4856 console.info("result = " + result); 4857 // 输出结果：result = true 4858 ``` 4859 4860 4861### isBigInt64Array<sup>8+</sup> 4862 4863isBigInt64Array(value: Object): boolean 4864 4865检查输入的value是否是BigInt64Array类型。 4866 4867**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4868 4869**系统能力：** SystemCapability.Utils.Lang 4870 4871**参数：** 4872 4873| 参数名 | 类型 | 必填 | 说明 | 4874| -------- | -------- | -------- | -------- | 4875| value | Object | 是 | 待检测对象。 | 4876 4877**返回值：** 4878 4879| 类型 | 说明 | 4880| -------- | -------- | 4881| boolean | 判断的结果，如果是内置包含的BigInt64Array类型为true，反之为false。 | 4882 4883**示例：** 4884 4885 ```ts 4886 let type = new util.types(); 4887 let result = type.isBigInt64Array(new BigInt64Array([])); 4888 console.info("result = " + result); 4889 // 输出结果：result = true 4890 ``` 4891 4892 4893### isBigUint64Array<sup>8+</sup> 4894 4895isBigUint64Array(value: Object): boolean 4896 4897检查输入的value是否是BigUint64Array类型。 4898 4899**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4900 4901**系统能力：** SystemCapability.Utils.Lang 4902 4903**参数：** 4904 4905| 参数名 | 类型 | 必填 | 说明 | 4906| -------- | -------- | -------- | -------- | 4907| value | Object | 是 | 待检测对象。 | 4908 4909**返回值：** 4910 4911| 类型 | 说明 | 4912| -------- | -------- | 4913| boolean | 判断的结果，如果是内置包含的BigUint64Array类型为true，反之为false。 | 4914 4915**示例：** 4916 4917 ```ts 4918 let type = new util.types(); 4919 let result = type.isBigUint64Array(new BigUint64Array([])); 4920 console.info("result = " + result); 4921 // 输出结果：result = true 4922 ``` 4923 4924 4925### isModuleNamespaceObject<sup>8+</sup> 4926 4927isModuleNamespaceObject(value: Object): boolean 4928 4929检查输入的value是否是Module Namespace Object类型。 4930 4931**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4932 4933**系统能力：** SystemCapability.Utils.Lang 4934 4935**参数：** 4936 4937| 参数名 | 类型 | 必填 | 说明 | 4938| -------- | -------- | -------- | -------- | 4939| value | Object | 是 | 待检测对象。 | 4940 4941**返回值：** 4942 4943| 类型 | 说明 | 4944| -------- | -------- | 4945| boolean | 判断的结果，如果是内置包含的Module Namespace Object类型为true，反之为false。 | 4946 4947**示例：** 4948 4949 ```ts 4950 // /entry/src/main/ets/pages/test.ts 4951 export function func() { 4952 console.info("hello world"); 4953 } 4954 ``` 4955 4956 ```ts 4957 import * as nameSpace from './test'; 4958 4959 let type = new util.types(); 4960 let result = type.isModuleNamespaceObject(nameSpace); 4961 console.info("result = " + result); 4962 // 输出结果：result = true 4963 ``` 4964 4965 4966### isSharedArrayBuffer<sup>8+</sup> 4967 4968isSharedArrayBuffer(value: Object): boolean 4969 4970检查输入的value是否是SharedArrayBuffer类型。 4971 4972**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 4973 4974**系统能力：** SystemCapability.Utils.Lang 4975 4976**参数：** 4977 4978| 参数名 | 类型 | 必填 | 说明 | 4979| -------- | -------- | -------- | -------- | 4980| value | Object | 是 | 待检测对象。 | 4981 4982**返回值：** 4983 4984| 类型 | 说明 | 4985| -------- | -------- | 4986| boolean | 判断的结果，如果是内置包含的SharedArrayBuffer类型为true，反之为false。 | 4987 4988**示例：** 4989 4990 ```ts 4991 let type = new util.types(); 4992 let result = type.isSharedArrayBuffer(new SharedArrayBuffer(0)); 4993 console.info("result = " + result); 4994 // 输出结果：result = true 4995 ``` 4996 4997## LruBuffer<sup>(deprecated)</sup> 4998 4999> **说明：** 5000> 5001> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache<sup>9+</sup>](#lrucache9)替代。 5002 5003### 属性 5004 5005**系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。 5006 5007| 名称 | 类型 | 可读 | 可写 | 说明 | 5008| -------- | -------- | -------- | -------- | -------- | 5009| length | number | 是 | 否 | 当前缓冲区中值的总数。 | 5010 5011**示例：** 5012 5013 ```ts 5014 let pro : util.LruBuffer<number,number>= new util.LruBuffer(); 5015 pro.put(2,10); 5016 pro.put(1,8); 5017 let result = pro.length; 5018 ``` 5019 5020### constructor<sup>(deprecated)</sup> 5021 5022constructor(capacity?: number) 5023 5024默认构造函数用于创建一个新的LruBuffer实例，默认容量为64。 5025 5026> **说明：** 5027> 5028> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.constructor<sup>9+</sup>](#constructor9-3)替代。 5029 5030**系统能力：** SystemCapability.Utils.Lang 5031 5032**参数：** 5033 5034| 参数名 | 类型 | 必填 | 说明 | 5035| -------- | -------- | -------- | -------- | 5036| capacity | number | 否 | 指示要为缓冲区自定义的容量，默认值为64。 | 5037 5038**示例：** 5039 5040 ```ts 5041 let lrubuffer : util.LruBuffer<number,number> = new util.LruBuffer(); 5042 ``` 5043 5044### updateCapacity<sup>(deprecated)</sup> 5045 5046updateCapacity(newCapacity: number): void 5047 5048将缓冲区容量更新为指定容量，如果newCapacity小于或等于0，则抛出异常。 5049 5050> **说明：** 5051> 5052> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.updateCapacity<sup>9+</sup>](#updatecapacity9)替代。 5053 5054**系统能力：** SystemCapability.Utils.Lang 5055 5056**参数：** 5057 5058| 参数名 | 类型 | 必填 | 说明 | 5059| -------- | -------- | -------- | -------- | 5060| newCapacity | number | 是 | 指示要为缓冲区自定义的容量。 | 5061 5062**示例：** 5063 5064 ```ts 5065 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5066 pro.updateCapacity(100); 5067 ``` 5068 5069### toString<sup>(deprecated)</sup> 5070 5071toString(): string 5072 5073返回对象的字符串表示形式。 5074 5075> **说明：** 5076> 5077> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.toString<sup>9+</sup>](#tostring9)替代。 5078 5079**系统能力：** SystemCapability.Utils.Lang 5080 5081**返回值：** 5082 5083| 类型 | 说明 | 5084| -------- | -------- | 5085| string | 返回对象的字符串表示形式。 | 5086 5087**示例：** 5088 5089 ```ts 5090 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5091 pro.put(2,10); 5092 pro.get(2); 5093 pro.remove(20); 5094 let result = pro.toString(); 5095 ``` 5096 5097### getCapacity<sup>(deprecated)</sup> 5098 5099getCapacity(): number 5100 5101获取当前缓冲区的容量。 5102 5103> **说明：** 5104> 5105> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getCapacity<sup>9+</sup>](#getcapacity9)替代。 5106 5107**系统能力：** SystemCapability.Utils.Lang 5108 5109**返回值：** 5110 5111| 类型 | 说明 | 5112| -------- | -------- | 5113| number | 返回当前缓冲区的容量。 | 5114 5115**示例：** 5116 5117 ```ts 5118 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5119 let result = pro.getCapacity(); 5120 ``` 5121 5122### clear<sup>(deprecated)</sup> 5123 5124clear(): void 5125 5126从当前缓冲区清除键值对。后续会调用afterRemoval()方法执行后续操作。 5127 5128> **说明：** 5129> 5130> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.clear<sup>9+</sup>](#clear9)替代。 5131 5132**系统能力：** SystemCapability.Utils.Lang 5133 5134**示例：** 5135 5136 ```ts 5137 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5138 pro.put(2,10); 5139 let result = pro.length; 5140 pro.clear(); 5141 ``` 5142 5143### getCreateCount<sup>(deprecated)</sup> 5144 5145getCreateCount(): number 5146 5147获取createDefault()返回值的次数。 5148 5149> **说明：** 5150> 5151> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getCreateCount<sup>9+</sup>](#getcreatecount9)替代。 5152 5153**系统能力：** SystemCapability.Utils.Lang 5154 5155**返回值：** 5156 5157| 类型 | 说明 | 5158| -------- | -------- | 5159| number | 返回createDefault()返回值的次数。 | 5160 5161**示例：** 5162 5163 ```ts 5164 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5165 pro.put(1,8); 5166 let result = pro.getCreateCount(); 5167 ``` 5168 5169### getMissCount<sup>(deprecated)</sup> 5170 5171getMissCount(): number 5172 5173获取查询值不匹配的次数。 5174 5175> **说明：** 5176> 5177> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getMissCount<sup>9+</sup>](#getmisscount9)替代。 5178 5179**系统能力：** SystemCapability.Utils.Lang 5180 5181**返回值：** 5182 5183| 类型 | 说明 | 5184| -------- | -------- | 5185| number | 返回查询值不匹配的次数。 | 5186 5187**示例：** 5188 5189 ```ts 5190 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5191 pro.put(2,10); 5192 pro.get(2); 5193 let result = pro.getMissCount(); 5194 ``` 5195 5196### getRemovalCount<sup>(deprecated)</sup> 5197 5198getRemovalCount(): number 5199 5200获取从缓冲区中逐出值的次数。 5201 5202> **说明：** 5203> 5204> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getRemovalCount<sup>9+</sup>](#getremovalcount9)替代。 5205 5206**系统能力：** SystemCapability.Utils.Lang 5207 5208**返回值：** 5209 5210| 类型 | 说明 | 5211| -------- | -------- | 5212| number | 返回从缓冲区中驱逐的次数。 | 5213 5214**示例：** 5215 5216 ```ts 5217 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5218 pro.put(2,10); 5219 pro.updateCapacity(2); 5220 pro.put(50,22); 5221 let result = pro.getRemovalCount(); 5222 ``` 5223 5224### getMatchCount<sup>(deprecated)</sup> 5225 5226getMatchCount(): number 5227 5228获取查询值匹配成功的次数。 5229 5230> **说明：** 5231> 5232> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getMatchCount<sup>9+</sup>](#getmatchcount9)替代。 5233 5234**系统能力：** SystemCapability.Utils.Lang 5235 5236**返回值：** 5237 5238| 类型 | 说明 | 5239| -------- | -------- | 5240| number | 返回查询值匹配成功的次数。 | 5241 5242**示例：** 5243 5244 ```ts 5245 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5246 pro.put(2,10); 5247 pro.get(2); 5248 let result = pro.getMatchCount(); 5249 ``` 5250 5251### getPutCount<sup>(deprecated)</sup> 5252 5253getPutCount(): number 5254 5255获取将值添加到缓冲区的次数。 5256 5257> **说明：** 5258> 5259> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getPutCount<sup>9+</sup>](#getputcount9)替代。 5260 5261**系统能力：** SystemCapability.Utils.Lang 5262 5263**返回值：** 5264 5265| 类型 | 说明 | 5266| -------- | -------- | 5267| number | 返回将值添加到缓冲区的次数。 | 5268 5269**示例：** 5270 5271 ```ts 5272 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5273 pro.put(2,10); 5274 let result = pro.getPutCount(); 5275 ``` 5276 5277### isEmpty<sup>(deprecated)</sup> 5278 5279isEmpty(): boolean 5280 5281检查当前缓冲区是否为空。 5282 5283> **说明：** 5284> 5285> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.isEmpty<sup>9+</sup>](#isempty9)替代。 5286 5287**系统能力：** SystemCapability.Utils.Lang 5288 5289**返回值：** 5290 5291| 类型 | 说明 | 5292| -------- | -------- | 5293| boolean | 如果当前缓冲区不包含任何值，则返回true。 | 5294 5295**示例：** 5296 5297 ```ts 5298 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5299 pro.put(2,10); 5300 let result = pro.isEmpty(); 5301 ``` 5302 5303### get<sup>(deprecated)</sup> 5304 5305get(key: K): V | undefined 5306 5307表示要查询的键。 5308 5309> **说明：** 5310> 5311> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.get<sup>9+</sup>](#get9)替代。 5312 5313**系统能力：** SystemCapability.Utils.Lang 5314 5315**参数：** 5316 5317| 参数名 | 类型 | 必填 | 说明 | 5318| -------- | -------- | -------- | -------- | 5319| key | K | 是 | 要查询的键。 | 5320 5321**返回值：** 5322 5323| 类型 | 说明 | 5324| -------- | -------- | 5325| V \| undefined | 如果指定的键存在于缓冲区中，则返回与键关联的值；否则返回undefined。 | 5326 5327**示例：** 5328 5329 ```ts 5330 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5331 pro.put(2,10); 5332 let result = pro.get(2); 5333 ``` 5334 5335### put<sup>(deprecated)</sup> 5336 5337put(key: K,value: V): V 5338 5339将键值对添加到缓冲区。 5340 5341> **说明：** 5342> 5343> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.put<sup>9+</sup>](#put9)替代。 5344 5345**系统能力：** SystemCapability.Utils.Lang 5346 5347**参数：** 5348 5349| 参数名 | 类型 | 必填 | 说明 | 5350| -------- | -------- | -------- | -------- | 5351| key | K | 是 | 要添加的密钥。 | 5352| value | V | 是 | 指示与要添加的键关联的值。 | 5353 5354**返回值：** 5355 5356| 类型 | 说明 | 5357| -------- | -------- | 5358| V | 返回与添加的键关联的值；如果要添加的键已经存在，则返回原始值，如果键或值为空，则抛出此异常。 | 5359 5360**示例：** 5361 5362 ```ts 5363 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5364 let result = pro.put(2,10); 5365 ``` 5366 5367### values<sup>(deprecated)</sup> 5368 5369values(): V[] 5370 5371获取当前缓冲区中所有值从最近访问到最近最少访问的顺序列表。 5372 5373> **说明：** 5374> 5375> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.values<sup>9+</sup>](#values9)替代。 5376 5377**系统能力：** SystemCapability.Utils.Lang 5378 5379**返回值：** 5380 5381| 类型 | 说明 | 5382| -------- | -------- | 5383| V [] | 按从最近访问到最近最少访问的顺序返回当前缓冲区中所有值的列表。 | 5384 5385**示例：** 5386 5387 ```ts 5388 let pro : util.LruBuffer<number|string,number|string> = new util.LruBuffer(); 5389 pro.put(2,10); 5390 pro.put(2,"anhu"); 5391 pro.put("afaf","grfb"); 5392 let result = pro.values(); 5393 ``` 5394 5395### keys<sup>(deprecated)</sup> 5396 5397keys(): K[] 5398 5399获取当前缓冲区中所有键从最近访问到最近最少访问的升序列表。 5400 5401> **说明：** 5402> 5403> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.keys<sup>9+</sup>](#keys9)替代。 5404 5405**系统能力：** SystemCapability.Utils.Lang 5406 5407**返回值：** 5408 5409| 类型 | 说明 | 5410| -------- | -------- | 5411| K [] | 按升序返回当前缓冲区中所有键的列表，从最近访问到最近最少访问。 | 5412 5413**示例：** 5414 5415 ```ts 5416 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5417 pro.put(2,10); 5418 let result = pro.keys(); 5419 ``` 5420 5421### remove<sup>(deprecated)</sup> 5422 5423remove(key: K): V | undefined 5424 5425从当前缓冲区中删除指定的键及其关联的值。 5426 5427> **说明：** 5428> 5429> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.remove<sup>9+</sup>](#remove9)替代。 5430 5431**系统能力：** SystemCapability.Utils.Lang 5432 5433**参数：** 5434 5435| 参数名 | 类型 | 必填 | 说明 | 5436| -------- | -------- | -------- | -------- | 5437| key | K | 是 | 要删除的密钥。 | 5438 5439**返回值：** 5440 5441| 类型 | 说明 | 5442| -------- | -------- | 5443| V \| undefined | 返回一个包含已删除键值对的Optional对象；如果key不存在，则返回一个空的Optional对象，如果key为null，则抛出异常。 | 5444 5445**示例：** 5446 5447 ```ts 5448 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5449 pro.put(2,10); 5450 let result = pro.remove(20); 5451 ``` 5452 5453### afterRemoval<sup>(deprecated)</sup> 5454 5455afterRemoval(isEvict: boolean,key: K,value: V,newValue: V): void 5456 5457删除值后执行后续操作。 5458 5459> **说明：** 5460> 5461> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.afterRemoval<sup>9+</sup>](#afterremoval9)替代。 5462 5463**系统能力：** SystemCapability.Utils.Lang 5464 5465**参数：** 5466 5467| 参数名 | 类型 | 必填 | 说明 | 5468| -------- | -------- | -------- | -------- | 5469| isEvict | boolean | 是 | 因容量不足而调用该方法时，参数值为true，其他情况为false。 | 5470| key | K | 是 | 表示删除的键。 | 5471| value | V | 是 | 表示删除的值。 | 5472| newValue | V | 是 | 如果已调用put方法并且要添加的键已经存在，则参数值是关联的新值。其他情况下参数值为空。 | 5473 5474**示例：** 5475 5476```ts 5477class ChildLruBuffer<K, V> extends util.LruBuffer<K, V> { 5478 constructor(capacity?: number) { 5479 super(capacity); 5480 } 5481 5482 afterRemoval(isEvict: boolean, key: K, value: V, newValue: V): void { 5483 if (isEvict === true) { 5484 console.info('key: ' + key); 5485 console.info('value: ' + value); 5486 console.info('newValue: ' + newValue); 5487 } 5488 } 5489} 5490let lru: ChildLruBuffer<number, number> = new ChildLruBuffer(2); 5491lru.put(11, 1); 5492lru.put(22, 2); 5493lru.put(33, 3); 5494``` 5495 5496### contains<sup>(deprecated)</sup> 5497 5498contains(key: K): boolean 5499 5500检查当前缓冲区是否包含指定的键。 5501 5502 5503> **说明：** 5504> 5505> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.contains<sup>9+</sup>](#contains9)替代。 5506 5507**系统能力：** SystemCapability.Utils.Lang 5508 5509**参数：** 5510 5511| 参数名 | 类型 | 必填 | 说明 | 5512| -------- | -------- | -------- | -------- | 5513| key | K | 是 | 表示要检查的键。 | 5514 5515**返回值：** 5516 5517| 类型 | 说明 | 5518| -------- | -------- | 5519| boolean | 如果缓冲区包含指定的键，则返回 true。 | 5520 5521**示例：** 5522 5523 ```ts 5524 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5525 pro.put(2,10); 5526 let result = pro.contains(20); 5527 ``` 5528 5529### createDefault<sup>(deprecated)</sup> 5530 5531createDefault(key: K): V 5532 5533如果未计算特定键的值，则执行后续操作，参数表示丢失的键，返回与键关联的值。 5534 5535> **说明：** 5536> 5537> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.createDefault<sup>9+</sup>](#createdefault9)替代。 5538 5539**系统能力：** SystemCapability.Utils.Lang 5540 5541**参数：** 5542 5543| 参数名 | 类型 | 必填 | 说明 | 5544| -------- | -------- | -------- | -------- | 5545| key | K | 是 | 表示丢失的键。 | 5546 5547**返回值：** 5548 5549| 类型 | 说明 | 5550| -------- | -------- | 5551| V | 返回与键关联的值。 | 5552 5553**示例：** 5554 5555 ```ts 5556 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5557 let result = pro.createDefault(50); 5558 ``` 5559 5560### entries<sup>(deprecated)</sup> 5561 5562entries(): IterableIterator<[K,V]> 5563 5564允许迭代包含在这个对象中的所有键值对。 5565 5566> **说明：** 5567> 5568> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.entries<sup>9+</sup>](#entries9)替代。 5569 5570**系统能力：** SystemCapability.Utils.Lang 5571 5572**返回值：** 5573 5574| 类型 | 说明 | 5575| -------- | -------- | 5576| [K, V] | 返回一个可迭代数组。 | 5577 5578**示例：** 5579 5580 ```ts 5581 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5582 pro.put(2,10); 5583 let result = pro.entries(); 5584 ``` 5585 5586### [Symbol.iterator]<sup>(deprecated)</sup> 5587 5588[Symbol.iterator]\(): IterableIterator<[K, V]> 5589 5590返回一个键值对形式的二维数组。 5591 5592> **说明：** 5593> 5594> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.Symbol.iterator<sup>9+</sup>](#symboliterator9)替代。 5595 5596**系统能力：** SystemCapability.Utils.Lang 5597 5598**返回值：** 5599 5600| 类型 | 说明 | 5601| -------- | -------- | 5602| [K, V] | 返回一个键值对形式的二维数组。 | 5603 5604**示例：** 5605 5606 ```ts 5607 let pro : util.LruBuffer<number,number> = new util.LruBuffer(); 5608 pro.put(2,10); 5609 let result = pro[Symbol.iterator](); 5610 ``` 5611 5612## Scope<sup>(deprecated)</sup> 5613 5614> **说明：** 5615> 5616> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper<sup>9+</sup>](#scopehelper9)替代。 5617 5618### constructor<sup>(deprecated)</sup> 5619 5620constructor(lowerObj: ScopeType, upperObj: ScopeType) 5621 5622用于创建指定下限和上限的作用域实例的构造函数，返回一个Scope对象。 5623 5624> **说明：** 5625> 5626> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.constructor<sup>9+</sup>](#constructor9-4)替代。 5627 5628 5629**系统能力：** SystemCapability.Utils.Lang 5630 5631**参数：** 5632 5633| 参数名 | 类型 | 必填 | 说明 | 5634| -------- | -------- | -------- | -------- | 5635| lowerObj | [ScopeType](#scopetype8) | 是 | 指定作用域实例的下限。 | 5636| upperObj | [ScopeType](#scopetype8) | 是 | 指定作用域实例的上限。 | 5637 5638**示例：** 5639 ```ts 5640 class Temperature{ 5641 private readonly _temp: number; 5642 constructor(value : number) { 5643 this._temp = value; 5644 } 5645 compareTo(value : Temperature ) { 5646 return this._temp >= value.getTemp(); 5647 } 5648 getTemp() { 5649 return this._temp; 5650 } 5651 toString() : string { 5652 return this._temp.toString(); 5653 } 5654 } 5655 let tempLower = new Temperature(30); 5656 let tempUpper = new Temperature(40); 5657 let range = new util.Scope(tempLower, tempUpper); 5658 ``` 5659 5660### toString<sup>(deprecated)</sup> 5661 5662toString(): string 5663 5664该字符串化方法返回一个包含当前范围的字符串表示形式。 5665 5666> **说明：** 5667> 5668> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.toString<sup>9+</sup>](#tostring9-1)替代。 5669 5670**系统能力：** SystemCapability.Utils.Lang 5671 5672**返回值：** 5673 5674| 类型 | 说明 | 5675| -------- | -------- | 5676| string | 返回包含当前范围对象的字符串表示形式。 | 5677 5678**示例：** 5679 5680 ```ts 5681 class Temperature{ 5682 private readonly _temp: number; 5683 constructor(value : number) { 5684 this._temp = value; 5685 } 5686 compareTo(value : Temperature ) { 5687 return this._temp >= value.getTemp(); 5688 } 5689 getTemp() { 5690 return this._temp; 5691 } 5692 toString() : string { 5693 return this._temp.toString(); 5694 } 5695 } 5696 5697 let tempLower = new Temperature(30); 5698 let tempUpper = new Temperature(40); 5699 let range = new util.Scope(tempLower, tempUpper); 5700 let result = range.toString(); 5701 ``` 5702 5703### intersect<sup>(deprecated)</sup> 5704 5705intersect(range: Scope): Scope 5706 5707获取给定范围和当前范围的交集。 5708 5709> **说明：** 5710> 5711> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.intersect<sup>9+</sup>](#intersect9)替代。 5712 5713**系统能力：** SystemCapability.Utils.Lang 5714 5715**参数：** 5716 5717| 参数名 | 类型 | 必填 | 说明 | 5718| -------- | -------- | -------- | -------- | 5719| range | [Scope](#scopedeprecated) | 是 | 传入一个给定范围。 | 5720 5721**返回值：** 5722 5723| 类型 | 说明 | 5724| -------- | -------- | 5725| [Scope](#scopedeprecated) | 返回给定范围和当前范围的交集。 | 5726 5727**示例：** 5728 5729 ```ts 5730 class Temperature{ 5731 private readonly _temp: number; 5732 constructor(value : number) { 5733 this._temp = value; 5734 } 5735 compareTo(value : Temperature ) { 5736 return this._temp >= value.getTemp(); 5737 } 5738 getTemp() { 5739 return this._temp; 5740 } 5741 toString() : string { 5742 return this._temp.toString(); 5743 } 5744 } 5745 5746 let tempLower = new Temperature(30); 5747 let tempUpper = new Temperature(40); 5748 let range = new util.Scope(tempLower, tempUpper); 5749 let tempMiDF = new Temperature(35); 5750 let tempMidS = new Temperature(39); 5751 let rangeFir = new util.Scope(tempMiDF, tempMidS); 5752 let result = range.intersect(rangeFir ); 5753 ``` 5754 5755### intersect<sup>(deprecated)</sup> 5756 5757intersect(lowerObj:ScopeType,upperObj:ScopeType):Scope 5758 5759获取当前范围与给定下限和上限范围的交集。 5760 5761> **说明：** 5762> 5763> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.intersect<sup>9+</sup>](#intersect9-1)替代。 5764 5765**系统能力：** SystemCapability.Utils.Lang 5766 5767**参数：** 5768 5769| 参数名 | 类型 | 必填 | 说明 | 5770| -------- | -------- | -------- | -------- | 5771| lowerObj | [ScopeType](#scopetype8) | 是 | 给定范围的下限。 | 5772| upperObj | [ScopeType](#scopetype8) | 是 | 给定范围的上限。 | 5773 5774**返回值：** 5775 5776| 类型 | 说明 | 5777| -------- | -------- | 5778| [Scope](#scopedeprecated) | 返回当前范围与给定下限和上限范围的交集。 | 5779 5780**示例：** 5781 5782 ```ts 5783 class Temperature{ 5784 private readonly _temp: number; 5785 constructor(value : number) { 5786 this._temp = value; 5787 } 5788 compareTo(value : Temperature ) { 5789 return this._temp >= value.getTemp(); 5790 } 5791 getTemp() { 5792 return this._temp; 5793 } 5794 toString() : string { 5795 return this._temp.toString(); 5796 } 5797 } 5798 5799 let tempLower = new Temperature(30); 5800 let tempUpper = new Temperature(40); 5801 let tempMiDF = new Temperature(35); 5802 let tempMidS = new Temperature(39); 5803 let range = new util.Scope(tempLower, tempUpper); 5804 let result = range.intersect(tempMiDF, tempMidS); 5805 ``` 5806 5807### getUpper<sup>(deprecated)</sup> 5808 5809getUpper(): ScopeType 5810 5811获取当前范围的上限。 5812 5813> **说明：** 5814> 5815> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.getUpper<sup>9+</sup>](#getupper9)替代。 5816 5817**系统能力：** SystemCapability.Utils.Lang 5818 5819**返回值：** 5820 5821| 类型 | 说明 | 5822| -------- | -------- | 5823| [ScopeType](#scopetype8) | 返回当前范围的上限值。 | 5824 5825**示例：** 5826 5827 ```ts 5828 class Temperature{ 5829 private readonly _temp: number; 5830 constructor(value : number) { 5831 this._temp = value; 5832 } 5833 compareTo(value : Temperature ) { 5834 return this._temp >= value.getTemp(); 5835 } 5836 getTemp() { 5837 return this._temp; 5838 } 5839 toString() : string { 5840 return this._temp.toString(); 5841 } 5842 } 5843 5844 let tempLower = new Temperature(30); 5845 let tempUpper = new Temperature(40); 5846 let range = new util.Scope(tempLower, tempUpper); 5847 let result = range.getUpper(); 5848 ``` 5849 5850### getLower<sup>(deprecated)</sup> 5851 5852getLower(): ScopeType 5853 5854获取当前范围的下限。 5855 5856> **说明：** 5857> 5858> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.getLower<sup>9+</sup>](#getlower9)替代。 5859 5860**系统能力：** SystemCapability.Utils.Lang 5861 5862**返回值：** 5863 5864| 类型 | 说明 | 5865| -------- | -------- | 5866| [ScopeType](#scopetype8) | 返回当前范围的下限值。 | 5867 5868**示例：** 5869 5870 ```ts 5871 class Temperature{ 5872 private readonly _temp: number; 5873 constructor(value : number) { 5874 this._temp = value; 5875 } 5876 compareTo(value : Temperature ) { 5877 return this._temp >= value.getTemp(); 5878 } 5879 getTemp() { 5880 return this._temp; 5881 } 5882 toString() : string { 5883 return this._temp.toString(); 5884 } 5885 } 5886 5887 let tempLower = new Temperature(30); 5888 let tempUpper = new Temperature(40); 5889 let range = new util.Scope(tempLower, tempUpper); 5890 let result = range.getLower(); 5891 ``` 5892 5893### expand<sup>(deprecated)</sup> 5894 5895expand(lowerObj: ScopeType,upperObj: ScopeType): Scope 5896 5897创建并返回包括当前范围和给定下限和上限的并集。 5898 5899> **说明：** 5900> 5901> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.expand<sup>9+</sup>](#expand9)替代。 5902 5903**系统能力：** SystemCapability.Utils.Lang 5904 5905**参数：** 5906 5907| 参数名 | 类型 | 必填 | 说明 | 5908| -------- | -------- | -------- | -------- | 5909| lowerObj | [ScopeType](#scopetype8) | 是 | 给定范围的下限。 | 5910| upperObj | [ScopeType](#scopetype8) | 是 | 给定范围的上限。 | 5911 5912**返回值：** 5913 5914| 类型 | 说明 | 5915| -------- | -------- | 5916| [Scope](#scopedeprecated) | 返回当前范围和给定下限和上限的并集。 | 5917 5918**示例：** 5919 5920 ```ts 5921 class Temperature{ 5922 private readonly _temp: number; 5923 constructor(value : number) { 5924 this._temp = value; 5925 } 5926 compareTo(value : Temperature ) { 5927 return this._temp >= value.getTemp(); 5928 } 5929 getTemp() { 5930 return this._temp; 5931 } 5932 toString() : string { 5933 return this._temp.toString(); 5934 } 5935 } 5936 5937 let tempLower = new Temperature(30); 5938 let tempUpper = new Temperature(40); 5939 let tempMiDF = new Temperature(35); 5940 let tempMidS = new Temperature(39); 5941 let range = new util.Scope(tempLower, tempUpper); 5942 let result = range.expand(tempMiDF, tempMidS); 5943 ``` 5944 5945### expand<sup>(deprecated)</sup> 5946 5947expand(range: Scope): Scope 5948 5949创建并返回包括当前范围和给定范围的并集。 5950 5951> **说明：** 5952> 5953> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.expand<sup>9+</sup>](#expand9-1)替代。 5954 5955**系统能力：** SystemCapability.Utils.Lang 5956 5957**参数：** 5958 5959| 参数名 | 类型 | 必填 | 说明 | 5960| -------- | -------- | -------- | -------- | 5961| range | [Scope](#scopedeprecated) | 是 | 传入一个给定范围。 | 5962 5963**返回值：** 5964 5965| 类型 | 说明 | 5966| -------- | -------- | 5967| [Scope](#scopedeprecated) | 返回包括当前范围和给定范围的并集。 | 5968 5969**示例：** 5970 5971 ```ts 5972 class Temperature{ 5973 private readonly _temp: number; 5974 constructor(value : number) { 5975 this._temp = value; 5976 } 5977 compareTo(value : Temperature ) { 5978 return this._temp >= value.getTemp(); 5979 } 5980 getTemp() { 5981 return this._temp; 5982 } 5983 toString() : string { 5984 return this._temp.toString(); 5985 } 5986 } 5987 5988 let tempLower = new Temperature(30); 5989 let tempUpper = new Temperature(40); 5990 let tempMiDF = new Temperature(35); 5991 let tempMidS = new Temperature(39); 5992 let range = new util.Scope(tempLower, tempUpper); 5993 let rangeFir = new util.Scope(tempMiDF, tempMidS); 5994 let result = range.expand(rangeFir); 5995 ``` 5996 5997### expand<sup>(deprecated)</sup> 5998 5999expand(value: ScopeType): Scope 6000 6001创建并返回包括当前范围和给定值的并集。 6002 6003> **说明：** 6004> 6005> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.expand<sup>9+</sup>](#expand9-2)替代。 6006 6007**系统能力：** SystemCapability.Utils.Lang 6008 6009**参数：** 6010 6011| 参数名 | 类型 | 必填 | 说明 | 6012| -------- | -------- | -------- | -------- | 6013| value | [ScopeType](#scopetype8) | 是 | 传入一个给定值。 | 6014 6015**返回值：** 6016 6017| 类型 | 说明 | 6018| -------- | -------- | 6019| [Scope](#scopedeprecated) | 返回包括当前范围和给定值的并集。 | 6020 6021**示例：** 6022 6023 ```ts 6024 class Temperature{ 6025 private readonly _temp: number; 6026 constructor(value : number) { 6027 this._temp = value; 6028 } 6029 compareTo(value : Temperature ) { 6030 return this._temp >= value.getTemp(); 6031 } 6032 getTemp() { 6033 return this._temp; 6034 } 6035 toString() : string { 6036 return this._temp.toString(); 6037 } 6038 } 6039 6040 let tempLower = new Temperature(30); 6041 let tempUpper = new Temperature(40); 6042 let tempMiDF = new Temperature(35); 6043 let range = new util.Scope(tempLower, tempUpper); 6044 let result = range.expand(tempMiDF); 6045 ``` 6046 6047### contains<sup>(deprecated)</sup> 6048 6049contains(value: ScopeType): boolean 6050 6051检查给定value是否包含在当前范围内。 6052 6053> **说明：** 6054> 6055> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.contains<sup>9+</sup>](#contains9-1)替代。 6056 6057**系统能力：** SystemCapability.Utils.Lang 6058 6059**参数：** 6060 6061| 参数名 | 类型 | 必填 | 说明 | 6062| -------- | -------- | -------- | -------- | 6063| value | [ScopeType](#scopetype8) | 是 | 传入一个给定值。 | 6064 6065**返回值：** 6066 6067| 类型 | 说明 | 6068| -------- | -------- | 6069| boolean | 如果给定值包含在当前范围内返回true，否则返回false。 | 6070 6071**示例：** 6072 6073 ```ts 6074 class Temperature{ 6075 private readonly _temp: number; 6076 constructor(value : number) { 6077 this._temp = value; 6078 } 6079 compareTo(value : Temperature ) { 6080 return this._temp >= value.getTemp(); 6081 } 6082 getTemp() { 6083 return this._temp; 6084 } 6085 toString() : string { 6086 return this._temp.toString(); 6087 } 6088 } 6089 6090 let tempLower = new Temperature(30); 6091 let tempUpper = new Temperature(40); 6092 let tempMiDF = new Temperature(35); 6093 let range = new util.Scope(tempLower, tempUpper); 6094 let result = range.contains(tempMiDF); 6095 ``` 6096 6097### contains<sup>(deprecated)</sup> 6098 6099contains(range: Scope): boolean 6100 6101检查给定range是否在当前范围内。 6102 6103> **说明：** 6104> 6105> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.contains<sup>9+</sup>](#contains9-2)替代。 6106 6107**系统能力：** SystemCapability.Utils.Lang 6108 6109**参数：** 6110 6111| 参数名 | 类型 | 必填 | 说明 | 6112| -------- | -------- | -------- | -------- | 6113| range | [Scope](#scopedeprecated) | 是 | 传入一个给定范围。 | 6114 6115**返回值：** 6116 6117| 类型 | 说明 | 6118| -------- | -------- | 6119| boolean | 如果给定范围包含在当前范围内返回true，否则返回false。 | 6120 6121**示例：** 6122 6123 ```ts 6124 class Temperature{ 6125 private readonly _temp: number; 6126 constructor(value : number) { 6127 this._temp = value; 6128 } 6129 compareTo(value : Temperature ) { 6130 return this._temp >= value.getTemp(); 6131 } 6132 getTemp() { 6133 return this._temp; 6134 } 6135 toString() : string { 6136 return this._temp.toString(); 6137 } 6138 } 6139 6140 let tempLower = new Temperature(30); 6141 let tempUpper = new Temperature(40); 6142 let range = new util.Scope(tempLower, tempUpper); 6143 let tempLess = new Temperature(20); 6144 let tempMore = new Temperature(45); 6145 let rangeSec = new util.Scope(tempLess, tempMore); 6146 let result = range.contains(rangeSec); 6147 ``` 6148 6149### clamp<sup>(deprecated)</sup> 6150 6151 6152clamp(value: ScopeType): ScopeType 6153 6154将给定值限定到当前范围内。 6155 6156> **说明：** 6157> 6158> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.clamp<sup>9+</sup>](#clamp9)替代。 6159 6160**系统能力：** SystemCapability.Utils.Lang 6161 6162**参数：** 6163 6164| 参数名 | 类型 | 必填 | 说明 | 6165| -------- | -------- | -------- | -------- | 6166| value | [ScopeType](#scopetype8) | 是 | 传入的给定值。 | 6167 6168**返回值：** 6169 6170| 类型 | 说明 | 6171| -------- | -------- | 6172| [ScopeType](#scopetype8) | 如果传入的value小于下限，则返回lowerObj；如果大于上限值则返回upperObj；如果在当前范围内，则返回value。 | 6173 6174**示例：** 6175 6176 ```ts 6177 class Temperature{ 6178 private readonly _temp: number; 6179 constructor(value : number) { 6180 this._temp = value; 6181 } 6182 compareTo(value : Temperature ) { 6183 return this._temp >= value.getTemp(); 6184 } 6185 getTemp() { 6186 return this._temp; 6187 } 6188 toString() : string { 6189 return this._temp.toString(); 6190 } 6191 } 6192 6193 let tempLower = new Temperature(30); 6194 let tempUpper = new Temperature(40); 6195 let tempMiDF = new Temperature(35); 6196 let range = new util.Scope(tempLower, tempUpper); 6197 let result = range.clamp(tempMiDF); 6198 ``` 6199 6200 6201## Base64<sup>(deprecated)</sup> 6202 6203> **说明：** 6204> 6205> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper<sup>9+</sup>](#base64helper9)替代。 6206 6207### constructor<sup>(deprecated)</sup> 6208 6209constructor() 6210 6211Base64的构造函数。 6212 6213> **说明：** 6214> 6215> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.constructor<sup>9+</sup>](#constructor9-5)替代。 6216 6217**系统能力：** SystemCapability.Utils.Lang 6218 6219**示例：** 6220 6221 ```ts 6222 let base64 = new util.Base64(); 6223 ``` 6224 6225### encodeSync<sup>(deprecated)</sup> 6226 6227encodeSync(src: Uint8Array): Uint8Array 6228 6229通过输入参数编码后输出对应文本。 6230 6231> **说明：** 6232> 6233> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encodeSync<sup>9+</sup>](#encodesync9)替代。 6234 6235**系统能力：** SystemCapability.Utils.Lang 6236 6237**参数：** 6238 6239| 参数名 | 类型 | 必填 | 说明 | 6240| -------- | -------- | -------- | -------- | 6241| src | Uint8Array | 是 | 编码输入Uint8数组。 | 6242 6243**返回值：** 6244 6245| 类型 | 说明 | 6246| -------- | -------- | 6247| Uint8Array | 返回编码后新分配的Uint8数组。 | 6248 6249**示例：** 6250 6251 ```ts 6252 let base64 = new util.Base64(); 6253 let array = new Uint8Array([115,49,51]); 6254 let result = base64.encodeSync(array); 6255 ``` 6256 6257### encodeToStringSync<sup>(deprecated)</sup> 6258 6259encodeToStringSync(src: Uint8Array): string 6260 6261通过输入参数编码后输出对应文本。 6262 6263> **说明：** 6264> 6265> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encodeToStringSync<sup>9+</sup>](#encodetostringsync9)替代。 6266 6267**系统能力：** SystemCapability.Utils.Lang 6268 6269**参数：** 6270 6271| 参数名 | 类型 | 必填 | 说明 | 6272| -------- | -------- | -------- | -------- | 6273| src | Uint8Array | 是 | 编码输入Uint8数组。 | 6274 6275**返回值：** 6276 6277| 类型 | 说明 | 6278| -------- | -------- | 6279| string | 返回编码后的字符串。 | 6280 6281**示例：** 6282 6283 ```ts 6284 let base64 = new util.Base64(); 6285 let array = new Uint8Array([115,49,51]); 6286 let result = base64.encodeToStringSync(array); 6287 ``` 6288 6289### decodeSync<sup>(deprecated)</sup> 6290 6291decodeSync(src: Uint8Array | string): Uint8Array 6292 6293通过输入参数解码后输出对应文本。 6294 6295> **说明：** 6296> 6297> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.decodeSync<sup>9+</sup>](#decodesync9)替代。 6298 6299**系统能力：** SystemCapability.Utils.Lang 6300 6301**参数：** 6302 6303| 参数名 | 类型 | 必填 | 说明 | 6304| -------- | -------- | -------- | -------- | 6305| src | Uint8Array \| string | 是 | 解码输入Uint8数组或者字符串。 | 6306 6307**返回值：** 6308 6309| 类型 | 说明 | 6310| -------- | -------- | 6311| Uint8Array | 返回解码后新分配的Uint8数组。 | 6312 6313**示例：** 6314 6315 ```ts 6316 let base64 = new util.Base64(); 6317 let buff = 'czEz'; 6318 let result = base64.decodeSync(buff); 6319 ``` 6320 6321### encode<sup>(deprecated)</sup> 6322 6323encode(src: Uint8Array): Promise<Uint8Array> 6324 6325通过输入参数异步编码后输出对应文本。 6326 6327> **说明：** 6328> 6329> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encode<sup>9+</sup>](#encode9)替代。 6330 6331**系统能力：** SystemCapability.Utils.Lang 6332 6333**参数：** 6334 6335| 参数名 | 类型 | 必填 | 说明 | 6336| -------- | -------- | -------- | -------- | 6337| src | Uint8Array | 是 | 异步编码输入Uint8数组。 | 6338 6339**返回值：** 6340 6341| 类型 | 说明 | 6342| -------- | -------- | 6343| Promise<Uint8Array> | 返回异步编码后新分配的Uint8数组。 | 6344 6345**示例：** 6346 6347 ```ts 6348 let base64 = new util.Base64(); 6349 let array = new Uint8Array([115,49,51]); 6350 base64.encode(array).then((val) => { 6351 console.info(val.toString()); 6352 }) 6353 ``` 6354 6355### encodeToString<sup>(deprecated)</sup> 6356 6357encodeToString(src: Uint8Array): Promise<string> 6358 6359通过输入参数异步编码后输出对应文本。 6360 6361> **说明：** 6362> 6363> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encodeToString<sup>9+</sup>](#encodetostring9)替代。 6364 6365**系统能力：** SystemCapability.Utils.Lang 6366 6367**参数：** 6368 6369| 参数名 | 类型 | 必填 | 说明 | 6370| -------- | -------- | -------- | -------- | 6371| src | Uint8Array | 是 | 异步编码输入Uint8数组。 | 6372 6373**返回值：** 6374 6375| 类型 | 说明 | 6376| -------- | -------- | 6377| Promise<string> | 返回异步编码后的字符串。 | 6378 6379**示例：** 6380 6381 ```ts 6382 let base64 = new util.Base64(); 6383 let array = new Uint8Array([115,49,51]); 6384 base64.encodeToString(array).then((val) => { 6385 console.info(val); 6386 }) 6387 ``` 6388 6389### decode<sup>(deprecated)</sup> 6390 6391 6392decode(src: Uint8Array | string): Promise<Uint8Array> 6393 6394通过输入参数异步解码后输出对应文本。 6395 6396> **说明：** 6397> 6398> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.decode<sup>9+</sup>](#decode9)替代。 6399 6400**系统能力：** SystemCapability.Utils.Lang 6401 6402**参数：** 6403 6404| 参数名 | 类型 | 必填 | 说明 | 6405| -------- | -------- | -------- | -------- | 6406| src | Uint8Array \| string | 是 | 异步解码输入Uint8数组或者字符串。 | 6407 6408**返回值：** 6409 6410| 类型 | 说明 | 6411| -------- | -------- | 6412| Promise<Uint8Array> | 返回异步解码后新分配的Uint8数组。 | 6413 6414**示例：** 6415 6416 ```ts 6417 let base64 = new util.Base64(); 6418 let array = new Uint8Array([99,122,69,122]); 6419 base64.decode(array).then((val) => { 6420 console.info(val.toString()); 6421 }) 6422 ``` 6423