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)）等功能。 4 5> **说明：** 6> 7> 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 8 9 10## 导入模块 11 12```js 13import util from '@ohos.util'; 14``` 15 16## util.format<sup>9+</sup> 17 18format(format: string, ...args: Object[]): string 19 20通过式样化字符串对输入的内容按特定格式输出。 21 22**系统能力：** SystemCapability.Utils.Lang 23 24**参数：** 25 26| 参数名 | 类型 | 必填 | 说明 | 27| ------- | -------- | ---- | -------------- | 28| format | string | 是 | 式样化字符串。 | 29| ...args | Object[] | 否 | 替换式样化字符串通配符的数据，此参数缺失时，默认返回第一个参数。 | 30 31**返回值：** 32 33| 类型 | 说明 | 34| ------ | ---------------------------- | 35| string | 按特定格式式样化后的字符串。 | 36 37**示例：** 38 39 ```js 40let res = util.format("%s", "hello world!"); 41console.log(res); 42 ``` 43 44## util.errnoToString<sup>9+</sup> 45 46errnoToString(errno: number): string 47 48获取系统错误码对应的详细信息。 49 50**系统能力：** SystemCapability.Utils.Lang 51 52**参数：** 53 54| 参数名 | 类型 | 必填 | 说明 | 55| ------ | ------ | ---- | -------------------------- | 56| errno | number | 是 | 系统发生错误产生的错误码。 | 57 58**返回值：** 59 60| 类型 | 说明 | 61| ------ | ---------------------- | 62| string | 错误码对应的详细信息。 | 63 64**示例：** 65 66```js 67let errnum = -1; // -1 : a system error number 68let result = util.errnoToString(errnum); 69console.log("result = " + result); 70``` 71 72**部分错误码及信息示例：** 73 74| 错误码 | 信息 | 75| ------ | -------------------------------- | 76| -1 | operation not permitted | 77| -2 | no such file or directory | 78| -3 | no such process | 79| -4 | interrupted system call | 80| -5 | i/o error | 81| -11 | resource temporarily unavailable | 82| -12 | not enough memory | 83| -13 | permission denied | 84| -100 | network is down | 85 86## util.callbackWrapper 87 88callbackWrapper(original: Function): (err: Object, value: Object )=>void 89 90对异步函数进行回调化处理，回调中第一个参数将是拒绝原因（如果 Promise 已解决，则为 null），第二个参数将是已解决的值。 91 92**系统能力：** SystemCapability.Utils.Lang 93 94**参数：** 95 96| 参数名 | 类型 | 必填 | 说明 | 97| -------- | -------- | -------- | -------- | 98| original | Function | 是 | 异步函数。 | 99 100**返回值：** 101 102| 类型 | 说明 | 103| -------- | -------- | 104| Function | 返回一个第一个参数是拒绝原因（如果 Promise 已解决，则为 null），第二个参数是已解决的回调函数。 | 105 106**示例：** 107 108 ```js 109async function fn() { 110 return 'hello world'; 111} 112let cb = util.callbackWrapper(fn); 113cb(1, (err, ret) => { 114 if (err) throw err; 115 console.log(ret); 116}); 117 ``` 118 119## util.promisify<sup>9+</sup> 120 121promisify(original: (err: Object, value: Object) => void): Function 122 123对异步函数处理并返回一个promise的函数。 124 125**系统能力：** SystemCapability.Utils.Lang 126 127**参数：** 128 129| 参数名 | 类型 | 必填 | 说明 | 130| -------- | -------- | -------- | -------- | 131| original | Function | 是 | 异步函数。 | 132 133**返回值：** 134 135| 类型 | 说明 | 136| -------- | -------- | 137| Function | 采用遵循常见的错误优先的回调风格的函数（也就是将 (err, value) => ... 回调作为最后一个参数），并返回一个返回 promise 的函数。 | 138 139**示例：** 140 141 ```js 142function fun(num, callback) { 143 if (typeof num === 'number') { 144 callback(null, num + 3); 145 } else { 146 callback("type err"); 147 } 148} 149 150const addCall = util.promisify(fun); 151(async () => { 152 try { 153 let res = await addCall(2); 154 console.log(res); 155 } catch (err) { 156 console.log(err); 157 } 158})(); 159 ``` 160 161## util.generateRandomUUID<sup>9+</sup> 162 163generateRandomUUID(entropyCache?: boolean): string 164 165使用加密安全随机数生成器生成随机的RFC 4122版本4的string类型UUID。 166 167**系统能力：** SystemCapability.Utils.Lang 168 169**参数：** 170 171| 参数名 | 类型 | 必填 | 说明 | 172| -------- | -------- | -------- | -------- | 173| entropyCache | boolean | 否 | 是否使用已缓存的UUID， 默认true。 | 174 175**返回值：** 176 177| 类型 | 说明 | 178| -------- | -------- | 179| string | 表示此UUID的字符串。 | 180 181**示例：** 182 183 ```js 184 let uuid = util.generateRandomUUID(true); 185 console.log("RFC 4122 Version 4 UUID:" + uuid); 186 // 输出： 187 // RFC 4122 Version 4 UUID:88368f2a-d5db-47d8-a05f-534fab0a0045 188 ``` 189 190## util.generateRandomBinaryUUID<sup>9+</sup> 191 192generateRandomBinaryUUID(entropyCache?: boolean): Uint8Array 193 194使用加密安全随机数生成器生成随机的RFC 4122版本4的Uint8Array类型UUID。 195 196**系统能力：** SystemCapability.Utils.Lang 197 198**参数：** 199 200| 参数名 | 类型 | 必填 | 说明 | 201| -------- | -------- | -------- | -------- | 202| entropyCache | boolean | 否 | 是否使用已缓存的UUID， 默认true。 | 203 204**返回值：** 205 206| 类型 | 说明 | 207| -------- | -------- | 208| Uint8Array | 表示此UUID的Uint8Array值。 | 209 210**示例：** 211 212 ```js 213 let uuid = util.generateRandomBinaryUUID(true); 214 console.log(JSON.stringify(uuid)); 215 // 输出： 216 // 138,188,43,243,62,254,70,119,130,20,235,222,199,164,140,150 217 ``` 218 219## util.parseUUID<sup>9+</sup> 220 221parseUUID(uuid: string): Uint8Array 222 223将generateRandomUUID生成的string类型UUID转换为generateRandomBinaryUUID生成的Uint8Array类型UUID，如RFC 4122版本4中所述。 224 225**系统能力：** SystemCapability.Utils.Lang 226 227**参数：** 228 229| 参数名 | 类型 | 必填 | 说明 | 230| -------- | -------- | -------- | -------- | 231| uuid | string | 是 | UUID字符串。 | 232 233**返回值：** 234 235| 类型 | 说明 | 236| -------- | -------- | 237| Uint8Array | 返回表示此UUID的Uint8Array，如果解析失败，则抛出SyntaxError。 | 238 239**示例：** 240 241 ```js 242 let uuid = util.parseUUID("84bdf796-66cc-4655-9b89-d6218d100f9c"); 243 console.log(JSON.stringify(uuid)); 244 // 输出： 245 // 132,189,247,150,102,204,70,85,155,137,214,33,141,16,15,156 246 ``` 247 248## util.printf<sup>(deprecated)</sup> 249 250printf(format: string, ...args: Object[]): string 251 252通过式样化字符串对输入的内容按特定格式输出。 253 254> **说明：** 255> 256> 从API version 7开始支持，从API version 9开始废弃，建议使用[util.format<sup>9+</sup>](#utilformat9)替代。 257 258**系统能力：** SystemCapability.Utils.Lang 259 260**参数：** 261 262| 参数名 | 类型 | 必填 | 说明 | 263| -------- | -------- | -------- | -------- | 264| format | string | 是 | 式样化字符串。 | 265| ...args | Object[] | 否 | 替换式样化字符串通配符的数据，此参数缺失时，默认返回第一个参数。 | 266 267**返回值：** 268 269| 类型 | 说明 | 270| -------- | -------- | 271| string | 按特定格式式样化后的字符串。 | 272 273**示例：** 274 275 ```js 276 let res = util.printf("%s", "hello world!"); 277 console.log(res); 278 ``` 279 280 281## util.getErrorString<sup>(deprecated)</sup> 282 283getErrorString(errno: number): string 284 285获取系统错误码对应的详细信息。 286 287> **说明：** 288> 289> 从API version 7开始支持，从API version 9开始废弃，建议使用[util.errnoToString<sup>9+</sup>](#utilerrnotostring9)替代。 290 291**系统能力：** SystemCapability.Utils.Lang 292 293**参数：** 294 295| 参数名 | 类型 | 必填 | 说明 | 296| -------- | -------- | -------- | -------- | 297| errno | number | 是 | 系统发生错误产生的错误码。 | 298 299**返回值：** 300 301| 类型 | 说明 | 302| -------- | -------- | 303| string | 错误码对应的详细信息。 | 304 305**示例：** 306 307 ```js 308 let errnum = -1; // -1 : a system error number 309 let result = util.getErrorString(errnum); 310 console.log("result = " + result); 311 ``` 312 313## util.promiseWrapper<sup>(deprecated)</sup> 314 315promiseWrapper(original: (err: Object, value: Object) => void): Object 316 317对异步函数处理并返回一个promise的版本。 318 319> **说明：** 320> 321> 此接口不可用，建议使用[util.promisify<sup>9+</sup>](#utilpromisify9)替代。 322 323**系统能力：** SystemCapability.Utils.Lang 324 325**参数：** 326 327| 参数名 | 类型 | 必填 | 说明 | 328| -------- | -------- | -------- | -------- | 329| original | Function | 是 | 异步函数。 | 330 331**返回值：** 332 333| 类型 | 说明 | 334| -------- | -------- | 335| Function | 采用遵循常见的错误优先的回调风格的函数（也就是将 (err, value) => ... 回调作为最后一个参数），并返回一个返回 promise 的版本。 | 336 337 338## TextDecoder 339 340TextDecoder用于将字节数组解码为字符串，可以处理多种编码格式，包括utf-8、utf-16le/be、iso-8859和windows-1251等不同的编码格式。 341 342### 属性 343 344**系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。 345 346| 名称 | 类型 | 可读 | 可写 | 说明 | 347| -------- | -------- | -------- | -------- | -------- | 348| 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-cyrilli、gbk、gb18030、big5、euc-jp、iso-2022-jp、shift_jis、euc-kr、utf-16be、utf-16le。 | 349| fatal | boolean | 是 | 否 | 是否显示致命错误。 | 350| ignoreBOM | boolean | 是 | 否 | 是否忽略BOM（byte order marker）标记，默认值为false ，表示解码结果包含BOM标记。 | 351 352### constructor<sup>9+</sup> 353 354constructor() 355 356TextDecoder的构造函数。 357 358**系统能力：** SystemCapability.Utils.Lang 359 360### create<sup>9+</sup> 361 362create(encoding?: string,options?: { fatal?: boolean; ignoreBOM?: boolean }): TextDecoder; 363 364替代有参构造功能。 365 366**系统能力：** SystemCapability.Utils.Lang 367 368**参数：** 369 370| 参数名 | 类型 | 必填 | 说明 | 371| -------- | ------ | ---- | ------------------------------------------------ | 372| encoding | string | 否 | 编码格式，默认值是'utf-8'。 | 373| options | Object | 否 | 编码相关选项参数，存在两个属性fatal和ignoreBOM。 | 374 375**表1.1**options 376 377| 名称 | 参数类型 | 必填 | 说明 | 378| --------- | -------- | ---- | ------------------ | 379| fatal | boolean | 否 | 是否显示致命错误，默认值是false。 | 380| ignoreBOM | boolean | 否 | 是否忽略BOM标记，默认值是false。 | 381 382**示例：** 383 384```js 385let result = util.TextDecoder.create('utf-8', { ignoreBOM : true }) 386let retStr = result.encoding 387``` 388 389### decodeWithStream<sup>9+</sup> 390 391decodeWithStream(input: Uint8Array, options?: { stream?: boolean }): string 392 393通过输入参数解码后输出对应文本。 394 395**系统能力：** SystemCapability.Utils.Lang 396 397**参数：** 398 399| 参数名 | 类型 | 必填 | 说明 | 400| -------- | -------- | -------- | -------- | 401| input | Uint8Array | 是 | 符合格式需要解码的数组。 | 402| options | Object | 否 | 解码相关选项参数。 | 403 404**表2** options 405 406| 名称 | 参数类型 | 必填 | 说明 | 407| -------- | -------- | -------- | -------- | 408| stream | boolean | 否 | 在随后的decodeWithStream()调用中是否跟随附加数据块。如果以块的形式处理数据，则设置为true；如果处理最后的数据块或数据未分块，则设置为false。默认为false。 | 409 410**返回值：** 411 412| 类型 | 说明 | 413| -------- | -------- | 414| string | 解码后的数据。 | 415 416**示例：** 417 418 ```js 419 let textDecoder = new util.TextDecoder("utf-8",{ignoreBOM: true}); 420 let result = new Uint8Array(6); 421 result[0] = 0xEF; 422 result[1] = 0xBB; 423 result[2] = 0xBF; 424 result[3] = 0x61; 425 result[4] = 0x62; 426 result[5] = 0x63; 427 console.log("input num:"); 428 let retStr = textDecoder.decodeWithStream( result , {stream: false}); 429 console.log("retStr = " + retStr); 430 ``` 431 432### constructor<sup>(deprecated)</sup> 433 434constructor(encoding?: string, options?: { fatal?: boolean; ignoreBOM?: boolean }) 435 436TextDecoder的构造函数。 437 438> **说明：** 439> 440> 从API version 7开始支持，从API version 9开始废弃，建议使用[create<sup>9+</sup>](#create9)替代。 441 442**系统能力：** SystemCapability.Utils.Lang 443 444**参数：** 445 446| 参数名 | 类型 | 必填 | 说明 | 447| -------- | -------- | -------- | -------- | 448| encoding | string | 否 | 编码格式，默认值是'utf-8'。 | 449| options | Object | 否 | 编码相关选项参数，存在两个属性fatal和ignoreBOM。 | 450 451 **表1** options 452 453| 名称 | 参数类型 | 必填 | 说明 | 454| -------- | -------- | -------- | -------- | 455| fatal | boolean | 否 | 是否显示致命错误，默认值是false。 | 456| ignoreBOM | boolean | 否 | 是否忽略BOM标记，默认值是false。 | 457 458**示例：** 459 460 ```js 461 let textDecoder = new util.TextDecoder("utf-8",{ignoreBOM: true}); 462 ``` 463 464### decode<sup>(deprecated)</sup> 465 466decode(input: Uint8Array, options?: { stream?: false }): string 467 468通过输入参数解码后输出对应文本。 469 470> **说明：** 471> 472> 从API version 7开始支持，从API version 9开始废弃，建议使用[decodeWithStream<sup>9+</sup>](#decodewithstream9)替代。 473 474**系统能力：** SystemCapability.Utils.Lang 475 476**参数：** 477 478| 参数名 | 类型 | 必填 | 说明 | 479| -------- | -------- | -------- | -------- | 480| input | Uint8Array | 是 | 符合格式需要解码的数组。 | 481| options | Object | 否 | 解码相关选项参数。 | 482 483**表2** options 484 485| 名称 | 参数类型 | 必填 | 说明 | 486| -------- | -------- | -------- | -------- | 487| stream | boolean | 否 | 在随后的decode()调用中是否跟随附加数据块。如果以块的形式处理数据，则设置为true；如果处理最后的数据块或数据未分块，则设置为false。默认为false。 | 488 489**返回值：** 490 491| 类型 | 说明 | 492| -------- | -------- | 493| string | 解码后的数据。 | 494 495**示例：** 496 497 ```js 498 let textDecoder = new util.TextDecoder("utf-8",{ignoreBOM: true}); 499 let result = new Uint8Array(6); 500 result[0] = 0xEF; 501 result[1] = 0xBB; 502 result[2] = 0xBF; 503 result[3] = 0x61; 504 result[4] = 0x62; 505 result[5] = 0x63; 506 console.log("input num:"); 507 let retStr = textDecoder.decode( result , {stream: false}); 508 console.log("retStr = " + retStr); 509 ``` 510 511## TextEncoder 512 513TextEncoder用于将字符串编码为字节数组，支持多种编码格式，包括utf-8、utf-16le/be等。需要注意的是，在使用TextEncoder进行编码时，不同编码格式下字符所占的字节数是不同的。例如，utf-8编码下中文字符通常占3个字节，而utf-16le/be编码下中文字符通常占2个字节。因此，在使用TextEncoder时需要明确指定要使用的编码格式，以确保编码结果正确。 514 515### 属性 516 517**系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。 518 519| 名称 | 类型 | 可读 | 可写 | 说明 | 520| -------- | -------- | -------- | -------- | -------- | 521| encoding | string | 是 | 否 | 编码格式，默认值是'utf-8'。 | 522 523 524### constructor 525 526constructor() 527 528TextEncoder的构造函数。 529 530**系统能力：** SystemCapability.Utils.Lang 531 532**示例：** 533 534 ```js 535 let textEncoder = new util.TextEncoder(); 536 ``` 537 538### constructor<sup>9+</sup> 539 540constructor(encoding?: string) 541 542TextEncoder的构造函数。 543 544**系统能力：** SystemCapability.Utils.Lang 545 546**参数：** 547 548| 参数名 | 类型 | 必填 | 说明 | 549| ----- | ---- | ---- | ---- | 550| encoding | string | 否 | 编码格式，默认值为'utf-8'。 | 551 552**示例：** 553 554 ```js 555 let textEncoder = new util.TextEncoder("utf-8"); 556 ``` 557 558### encodeInto<sup>9+</sup> 559 560encodeInto(input?: string): Uint8Array 561 562通过输入参数编码后输出对应文本。 563 564**系统能力：** SystemCapability.Utils.Lang 565 566**参数：** 567 568| 参数名 | 类型 | 必填 | 说明 | 569| ------ | ------ | ---- | ------------------ | 570| input | string | 否 | 需要编码的字符串，默认值是空字符串。 | 571 572**返回值：** 573 574| 类型 | 说明 | 575| ---------- | ------------------ | 576| Uint8Array | 返回编码后的文本。 | 577 578**示例：** 579 580 ```js 581let textEncoder = new util.TextEncoder(); 582let buffer = new ArrayBuffer(20); 583let result = new Uint8Array(buffer); 584result = textEncoder.encodeInto("\uD800¥¥"); 585 ``` 586 587### encodeIntoUint8Array<sup>9+</sup> 588 589encodeIntoUint8Array(input: string, dest: Uint8Array, ): { read: number; written: number } 590 591放置生成的UTF-8编码文本。 592 593**系统能力：** SystemCapability.Utils.Lang 594 595**参数：** 596 597| 参数名 | 类型 | 必填 | 说明 | 598| ------ | ---------- | ---- | ------------------------------------------------------- | 599| input | string | 是 | 需要编码的字符串。 | 600| dest | Uint8Array | 是 | Uint8Array对象实例，用于将生成的UTF-8编码文本放入其中。 | 601 602**返回值：** 603 604| 类型 | 说明 | 605| ---------- | ------------------ | 606| Uint8Array | 返回编码后的文本。 | 607 608**示例：** 609 610 ```js 611let that = new util.TextEncoder() 612let buffer = new ArrayBuffer(4) 613let dest = new Uint8Array(buffer) 614let result = new Object() 615result = that.encodeIntoUint8Array('abcd', dest) 616 ``` 617 618### encodeInto<sup>(deprecated)</sup> 619 620encodeInto(input: string, dest: Uint8Array, ): { read: number; written: number } 621 622放置生成的UTF-8编码文本。 623 624> **说明：** 625> 626> 从API version 7开始支持，从API version 9开始废弃，建议使用[encodeIntoUint8Array<sup>9+</sup>](#encodeintouint8array9)替代。 627 628**系统能力：** SystemCapability.Utils.Lang 629 630**参数：** 631 632| 参数名 | 类型 | 必填 | 说明 | 633| -------- | -------- | -------- | -------- | 634| input | string | 是 | 需要编码的字符串。 | 635| dest | Uint8Array | 是 | Uint8Array对象实例，用于将生成的UTF-8编码文本放入其中。 | 636 637**返回值：** 638 639| 类型 | 说明 | 640| -------- | -------- | 641| Uint8Array | 返回编码后的文本。 | 642 643**示例：** 644 ```js 645 let that = new util.TextEncoder() 646 let buffer = new ArrayBuffer(4) 647 let dest = new Uint8Array(buffer) 648 let result = new Object() 649 result = that.encodeInto('abcd', dest) 650 ``` 651 652### encode<sup>(deprecated)</sup> 653 654encode(input?: string): Uint8Array 655 656通过输入参数编码后输出对应文本。 657 658> **说明：** 659> 660> 从API version 7开始支持，从API version 9开始废弃，建议使用[encodeInto<sup>9+</sup>](#encodeinto9)替代。 661 662**系统能力：** SystemCapability.Utils.Lang 663 664**参数：** 665 666| 参数名 | 类型 | 必填 | 说明 | 667| -------- | -------- | -------- | -------- | 668| input | string | 否 | 需要编码的字符串，默认值是空字符串。 | 669 670**返回值：** 671 672| 类型 | 说明 | 673| -------- | -------- | 674| Uint8Array | 返回编码后的文本。 | 675 676**示例：** 677 ```js 678 let textEncoder = new util.TextEncoder(); 679 let buffer = new ArrayBuffer(20); 680 let result = new Uint8Array(buffer); 681 result = textEncoder.encode("\uD800¥¥"); 682 ``` 683 684## RationalNumber<sup>8+</sup> 685 686RationalNumber主要是对有理数进行比较，获取分子分母等方法。例如使用toString()方法可以将有理数转换为字符串形式，使用该类可以方便地进行有理数的各种操作。 687 688### constructor<sup>9+</sup> 689 690constructor() 691 692RationalNumber的构造函数。 693 694**系统能力：** SystemCapability.Utils.Lang 695 696**示例：** 697 698```js 699let rationalNumber = new util.RationalNumber(); 700``` 701 702### parseRationalNumber<sup>9+</sup> 703 704parseRationalNumber(numerator: number,denominator: number): RationalNumber 705 706替代原有参构造的参数处理。 707 708**系统能力：** SystemCapability.Utils.Lang 709 710**参数：** 711 712| 参数名 | 类型 | 必填 | 说明 | 713| ----------- | ------ | ---- | ---------------- | 714| numerator | number | 是 | 分子，整数类型。 | 715| denominator | number | 是 | 分母，整数类型。 | 716 717**示例：** 718 719```js 720let rationalNumber = util.RationalNumber.parseRationalNumber(1,2) 721``` 722 723### createRationalFromString<sup>8+</sup> 724 725static createRationalFromString(rationalString: string): RationalNumber 726 727基于给定的字符串创建一个RationalNumber对象。 728 729**系统能力：** SystemCapability.Utils.Lang 730 731**参数：** 732 733| 参数名 | 类型 | 必填 | 说明 | 734| -------- | -------- | -------- | -------- | 735| rationalString | string | 是 | 字符串格式。 | 736 737**返回值：** 738 739| 类型 | 说明 | 740| -------- | -------- | 741| object | 返回有理数类的对象。 | 742 743**示例：** 744 745```js 746let rationalNumber = new util.RationalNumber(1,2); 747let rational = util.RationalNumber.createRationalFromString("3/4"); 748``` 749 750### compare<sup>9+</sup> 751 752compare(another: RationalNumber): number 753 754将当前的RationalNumber对象与给定的对象进行比较。 755 756**系统能力：** SystemCapability.Utils.Lang 757 758**参数：** 759 760| 参数名 | 类型 | 必填 | 说明 | 761| ------- | -------------- | ---- | ------------------ | 762| another | RationalNumber | 是 | 其他的有理数对象。 | 763 764**返回值：** 765 766| 类型 | 说明 | 767| ------ | ------------------------------------------------------------ | 768| number | 如果两个对象相等，则返回0；如果给定对象小于当前对象，则返回1；如果给定对象大于当前对象，则返回-1。 | 769 770**示例：** 771 772 ```js 773let rationalNumber = new util.RationalNumber(1,2); 774let rational = util.RationalNumber.createRationalFromString("3/4"); 775let result = rationalNumber.compare(rational); 776 ``` 777 778### valueOf<sup>8+</sup> 779 780valueOf(): number 781 782以整数形式或者浮点数的形式获取当前RationalNumber对象的值。 783 784**系统能力：** SystemCapability.Utils.Lang 785 786**返回值：** 787 788| 类型 | 说明 | 789| -------- | -------- | 790| number | 返回整数或者浮点数的值。 | 791 792**示例：** 793 794```js 795let rationalNumber = new util.RationalNumber(1,2); 796let result = rationalNumber.valueOf(); 797``` 798 799### equals<sup>8+</sup> 800 801equals(obj: Object): boolean 802 803将当前的RationalNumber对象与给定的对象进行比较是否相等。 804 805**系统能力：** SystemCapability.Utils.Lang 806 807**参数：** 808 809| 参数名 | 类型 | 必填 | 说明 | 810| -------- | -------- | -------- | -------- | 811| object | Object | 是 | 其他类型对象。 | 812 813**返回值：** 814 815| 类型 | 说明 | 816| -------- | -------- | 817| boolean | 如果给定对象与当前对象相同，则返回true；否则返回false。 | 818 819**示例：** 820 821```js 822let rationalNumber = new util.RationalNumber(1,2); 823let rational = util.RationalNumber.createRationalFromString("3/4"); 824let result = rationalNumber.equals(rational); 825``` 826 827### getCommonFactor<sup>9+</sup> 828 829getCommonFactor(number1: number,number2: number): number 830 831获取两个指定整数的最大公约数。 832 833**系统能力：** SystemCapability.Utils.Lang 834 835**参数：** 836 837| 参数名 | 类型 | 必填 | 说明 | 838| ------- | ------ | ---- | ---------- | 839| number1 | number | 是 | 整数类型。 | 840| number2 | number | 是 | 整数类型。 | 841 842**返回值：** 843 844| 类型 | 说明 | 845| ------ | ------------------------------ | 846| number | 返回两个给定数字的最大公约数。 | 847 848**示例：** 849 850```js 851let rationalNumber = new util.RationalNumber(1,2); 852let result = util.RationalNumber.getCommonFactor(4,6); 853``` 854 855### getNumerator<sup>8+</sup> 856 857getNumerator(): number 858 859获取当前RationalNumber对象的分子。 860 861**系统能力：** SystemCapability.Utils.Lang 862 863**返回值：** 864 865| 类型 | 说明 | 866| -------- | -------- | 867| number | 返回RationalNumber对象的分子的值。 | 868 869**示例：** 870 871```js 872let rationalNumber = new util.RationalNumber(1,2); 873let result = rationalNumber.getNumerator(); 874``` 875 876### getDenominator<sup>8+</sup> 877 878getDenominator(): number 879 880获取当前RationalNumber对象的分母。 881 882**系统能力：** SystemCapability.Utils.Lang 883 884**返回值：** 885 886| 类型 | 说明 | 887| -------- | -------- | 888| number | 返回RationalNumber对象的分母的值。 | 889 890**示例：** 891 892```js 893let rationalNumber = new util.RationalNumber(1,2); 894let result = rationalNumber.getDenominator(); 895``` 896 897### isZero<sup>8+</sup> 898 899isZero():boolean 900 901检查当前RationalNumber对象是否为0。 902 903**系统能力：** SystemCapability.Utils.Lang 904 905**返回值：** 906 907| 类型 | 说明 | 908| -------- | -------- | 909| boolean | 如果当前对象表示的值为0，则返回true；否则返回false。 | 910 911**示例：** 912 913```js 914let rationalNumber = new util.RationalNumber(1,2); 915let result = rationalNumber.isZero(); 916``` 917 918### isNaN<sup>8+</sup> 919 920isNaN(): boolean 921 922检查当前RationalNumber对象是否表示非数字(NaN)值。 923 924**系统能力：** SystemCapability.Utils.Lang 925 926**返回值：** 927 928| 类型 | 说明 | 929| -------- | -------- | 930| boolean | 如果分母和分子都为0，则返回true；否则返回false。 | 931 932**示例：** 933 934```js 935let rationalNumber = new util.RationalNumber(1,2); 936let result = rationalNumber.isNaN(); 937``` 938 939### isFinite<sup>8+</sup> 940 941isFinite():boolean 942 943检查当前RationalNumber对象是否表示一个有限值。 944 945**系统能力：** SystemCapability.Utils.Lang 946 947**返回值：** 948 949| 类型 | 说明 | 950| -------- | -------- | 951| boolean | 如果分母不为0，则返回true；否则返回false。 | 952 953**示例：** 954 955```js 956let rationalNumber = new util.RationalNumber(1,2); 957let result = rationalNumber.isFinite(); 958``` 959 960### toString<sup>8+</sup> 961 962toString(): string 963 964获取当前RationalNumber对象的字符串表示形式。 965 966**系统能力：** SystemCapability.Utils.Lang 967 968**返回值：** 969 970| 类型 | 说明 | 971| -------- | -------- | 972| string | 返回Numerator/Denominator格式的字符串，例如3/5，如果当前对象的分子和分母都为0，则返回NaN。 | 973 974**示例：** 975 976```js 977let rationalNumber = new util.RationalNumber(1,2); 978let result = rationalNumber.toString(); 979``` 980 981### constructor<sup>(deprecated)</sup> 982 983constructor(numerator: number,denominator: number) 984 985RationalNumber的构造函数。 986 987> **说明：** 988> 989> 从API version 8开始支持，从API version 9开始废弃，建议使用[constructor<sup>9+</sup>](#constructor9)替代。 990 991**系统能力：** SystemCapability.Utils.Lang 992 993**参数：** 994 995| 参数名 | 类型 | 必填 | 说明 | 996| -------- | -------- | -------- | -------- | 997| numerator | number | 是 | 分子，整数类型。 | 998| denominator | number | 是 | 分母，整数类型。 | 999 1000**示例：** 1001 1002```js 1003let rationalNumber = new util.RationalNumber(1,2); 1004``` 1005 1006### compareTo<sup>(deprecated)</sup> 1007 1008compareTo(another: RationalNumber): number 1009 1010将当前的RationalNumber对象与给定的对象进行比较。 1011 1012> **说明：** 1013> 1014> 从API version 8开始支持，从API version 9开始废弃，建议使用[compare<sup>9+</sup>](#compare9)替代。 1015 1016**系统能力：** SystemCapability.Utils.Lang 1017 1018**参数：** 1019 1020| 参数名 | 类型 | 必填 | 说明 | 1021| -------- | -------- | -------- | -------- | 1022| another | RationalNumber | 是 | 其他的有理数对象。 | 1023 1024**返回值：** 1025 1026| 类型 | 说明 | 1027| -------- | -------- | 1028| number | 如果两个对象相等，则返回0；如果给定对象小于当前对象，则返回1；如果给定对象大于当前对象，则返回-1。 | 1029 1030**示例：** 1031 1032```js 1033let rationalNumber = new util.RationalNumber(1,2); 1034let rational = util.RationalNumber.createRationalFromString("3/4"); 1035let result = rationalNumber.compareTo(rational); 1036``` 1037 1038### getCommonDivisor<sup>(deprecated)</sup> 1039 1040static getCommonDivisor(number1: number,number2: number): number 1041 1042获取两个指定整数的最大公约数。 1043 1044> **说明：** 1045> 1046> 从API version 8开始支持，从API version 9开始废弃，建议使用[getCommonFactor<sup>9+</sup>](#getcommonfactor9)替代。 1047 1048**系统能力：** SystemCapability.Utils.Lang 1049 1050**参数：** 1051 1052| 参数名 | 类型 | 必填 | 说明 | 1053| -------- | -------- | -------- | -------- | 1054| number1 | number | 是 | 整数类型。 | 1055| number2 | number | 是 | 整数类型。 | 1056 1057**返回值：** 1058 1059| 类型 | 说明 | 1060| -------- | -------- | 1061| number | 返回两个给定数字的最大公约数。 | 1062 1063**示例：** 1064 1065```js 1066let rationalNumber = new util.RationalNumber(1,2); 1067let result = util.RationalNumber.getCommonDivisor(4,6); 1068``` 1069 1070## LRUCache<sup>9+</sup> 1071 1072LRUCache用于在缓存空间不够的时候，将近期最少使用的数据替换为新数据。此设计基于资源访问的考虑：近期访问的数据，可能在不久的将来会再次访问。于是最少访问的数据就是价值最小的数据，是最应该踢出缓存空间的数据。 1073 1074### 属性 1075 1076**系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。 1077 1078| 名称 | 类型 | 可读 | 可写 | 说明 | 1079| ------ | ------ | ---- | ---- | ---------------------- | 1080| length | number | 是 | 否 | 当前缓冲区中值的总数。 | 1081 1082**示例：** 1083 1084```js 1085let pro = new util.LRUCache(); 1086pro.put(2,10); 1087pro.put(1,8); 1088let result = pro.length; 1089``` 1090 1091### constructor<sup>9+</sup> 1092 1093constructor(capacity?: number) 1094 1095默认构造函数用于创建一个新的LruBuffer实例，默认容量为64。 1096 1097**系统能力：** SystemCapability.Utils.Lang 1098 1099**参数：** 1100 1101| 参数名 | 类型 | 必填 | 说明 | 1102| -------- | ------ | ---- | ---------------------------- | 1103| capacity | number | 否 | 指示要为缓冲区自定义的容量。 | 1104 1105**示例：** 1106 1107```js 1108let lrubuffer= new util.LRUCache(); 1109``` 1110 1111 1112### updateCapacity<sup>9+</sup> 1113 1114updateCapacity(newCapacity: number): void 1115 1116将缓冲区容量更新为指定容量，如果newCapacity小于或等于0，则抛出异常。 1117 1118**系统能力：** SystemCapability.Utils.Lang 1119 1120**参数：** 1121 1122| 参数名 | 类型 | 必填 | 说明 | 1123| ----------- | ------ | ---- | ---------------------------- | 1124| newCapacity | number | 是 | 指示要为缓冲区自定义的容量。 | 1125 1126**示例：** 1127 1128```js 1129let pro = new util.LRUCache(); 1130pro.updateCapacity(100); 1131``` 1132 1133 1134### toString<sup>9+</sup> 1135 1136toString(): string 1137 1138返回对象的字符串表示形式。 1139 1140**系统能力：** SystemCapability.Utils.Lang 1141 1142**返回值：** 1143 1144| 类型 | 说明 | 1145| ------ | -------------------------- | 1146| string | 返回对象的字符串表示形式。 | 1147 1148**示例：** 1149 1150```js 1151let pro = new util.LRUCache(); 1152pro.put(2,10); 1153pro.get(2); 1154pro.remove(20); 1155let result = pro.toString(); 1156``` 1157 1158 1159### getCapacity<sup>9+</sup> 1160 1161getCapacity(): number 1162 1163获取当前缓冲区的容量。 1164 1165**系统能力：** SystemCapability.Utils.Lang 1166 1167**返回值：** 1168 1169| 类型 | 说明 | 1170| ------ | ---------------------- | 1171| number | 返回当前缓冲区的容量。 | 1172 1173**示例：** 1174 1175 ```js 1176let pro = new util.LRUCache(); 1177let result = pro.getCapacity(); 1178 ``` 1179 1180 1181### clear<sup>9+</sup> 1182 1183clear(): void 1184 1185从当前缓冲区清除键值对。后续会调用afterRemoval()方法执行后续操作。 1186 1187**系统能力：** SystemCapability.Utils.Lang 1188 1189**示例：** 1190 1191 ```js 1192let pro = new util.LRUCache(); 1193pro.put(2,10); 1194let result = pro.length; 1195pro.clear(); 1196 ``` 1197 1198 1199### getCreateCount<sup>9+</sup> 1200 1201getCreateCount(): number 1202 1203获取createDefault()返回值的次数。 1204 1205**系统能力：** SystemCapability.Utils.Lang 1206 1207**返回值：** 1208 1209| 类型 | 说明 | 1210| ------ | --------------------------------- | 1211| number | 返回createDefault()返回值的次数。 | 1212 1213**示例：** 1214 1215 ```js 1216let pro = new util.LRUCache(); 1217pro.put(1,8); 1218let result = pro.getCreateCount(); 1219 ``` 1220 1221 1222### getMissCount<sup>9+</sup> 1223 1224getMissCount(): number 1225 1226获取查询值不匹配的次数。 1227 1228**系统能力：** SystemCapability.Utils.Lang 1229 1230**返回值：** 1231 1232| 类型 | 说明 | 1233| ------ | ------------------------ | 1234| number | 返回查询值不匹配的次数。 | 1235 1236**示例：** 1237 1238 ```js 1239let pro = new util.LRUCache(); 1240pro.put(2,10); 1241pro.get(2); 1242let result = pro.getMissCount(); 1243 ``` 1244 1245 1246### getRemovalCount<sup>9+</sup> 1247 1248getRemovalCount(): number 1249 1250获取从缓冲区中逐出值的次数。 1251 1252**系统能力：** SystemCapability.Utils.Lang 1253 1254**返回值：** 1255 1256| 类型 | 说明 | 1257| ------ | -------------------------- | 1258| number | 返回从缓冲区中驱逐的次数。 | 1259 1260**示例：** 1261 1262 ```js 1263let pro = new util.LRUCache(); 1264pro.put(2,10); 1265pro.updateCapacity(2); 1266pro.put(50,22); 1267let result = pro.getRemovalCount(); 1268 ``` 1269 1270 1271### getMatchCount<sup>9+</sup> 1272 1273getMatchCount(): number 1274 1275获取查询值匹配成功的次数。 1276 1277**系统能力：** SystemCapability.Utils.Lang 1278 1279**返回值：** 1280 1281| 类型 | 说明 | 1282| ------ | -------------------------- | 1283| number | 返回查询值匹配成功的次数。 | 1284 1285**示例：** 1286 1287 ```js 1288let pro = new util.LRUCache(); 1289pro.put(2,10); 1290pro.get(2); 1291let result = pro.getMatchCount(); 1292 ``` 1293 1294 1295### getPutCount<sup>9+</sup> 1296 1297getPutCount(): number 1298 1299获取将值添加到缓冲区的次数。 1300 1301**系统能力：** SystemCapability.Utils.Lang 1302 1303**返回值：** 1304 1305| 类型 | 说明 | 1306| ------ | ---------------------------- | 1307| number | 返回将值添加到缓冲区的次数。 | 1308 1309**示例：** 1310 1311 ```js 1312let pro = new util.LRUCache(); 1313pro.put(2,10); 1314let result = pro.getPutCount(); 1315 ``` 1316 1317 1318### isEmpty<sup>9+</sup> 1319 1320isEmpty(): boolean 1321 1322检查当前缓冲区是否为空。 1323 1324**系统能力：** SystemCapability.Utils.Lang 1325 1326**返回值：** 1327 1328| 类型 | 说明 | 1329| ------- | ---------------------------------------- | 1330| boolean | 如果当前缓冲区不包含任何值，则返回true。 | 1331 1332**示例：** 1333 1334 ```js 1335let pro = new util.LRUCache(); 1336pro.put(2,10); 1337let result = pro.isEmpty(); 1338 ``` 1339 1340 1341### get<sup>9+</sup> 1342 1343get(key: K): V | undefined 1344 1345表示要查询的键。 1346 1347**系统能力：** SystemCapability.Utils.Lang 1348 1349**参数：** 1350 1351| 参数名 | 类型 | 必填 | 说明 | 1352| ------ | ---- | ---- | ------------ | 1353| key | K | 是 | 要查询的键。 | 1354 1355**返回值：** 1356 1357| 类型 | 说明 | 1358| ------------------------ | ------------------------------------------------------------ | 1359| V \| undefined | 如果指定的键存在于缓冲区中，则返回与键关联的值；否则返回undefined。 | 1360 1361**示例：** 1362 1363 ```js 1364let pro = new util.LRUCache(); 1365pro.put(2,10); 1366let result = pro.get(2); 1367 ``` 1368 1369 1370### put<sup>9+</sup> 1371 1372put(key: K,value: V): V 1373 1374将键值对添加到缓冲区。 1375 1376**系统能力：** SystemCapability.Utils.Lang 1377 1378**参数：** 1379 1380| 参数名 | 类型 | 必填 | 说明 | 1381| ------ | ---- | ---- | -------------------------- | 1382| key | K | 是 | 要添加的密钥。 | 1383| value | V | 是 | 指示与要添加的键关联的值。 | 1384 1385**返回值：** 1386 1387| 类型 | 说明 | 1388| ---- | ------------------------------------------------------------ | 1389| V | 返回与添加的键关联的值；如果要添加的键已经存在，则返回原始值，如果键或值为空，则抛出此异常。 | 1390 1391**示例：** 1392 1393 ```js 1394let pro = new util.LRUCache(); 1395let result = pro.put(2,10); 1396 ``` 1397 1398### values<sup>9+</sup> 1399 1400values(): V[] 1401 1402获取当前缓冲区中所有值从最近访问到最近最少访问的顺序列表 。 1403 1404**系统能力：** SystemCapability.Utils.Lang 1405 1406**返回值：** 1407 1408| 类型 | 说明 | 1409| --------- | ------------------------------------------------------------ | 1410| V [] | 按从最近访问到最近最少访问的顺序返回当前缓冲区中所有值的列表。 | 1411 1412**示例：** 1413 1414 ```js 1415let pro = new util.LRUCache(); 1416pro.put(2,10); 1417pro.put(2,"anhu"); 1418pro.put("afaf","grfb"); 1419let result = pro.values(); 1420 ``` 1421 1422 1423### keys<sup>9+</sup> 1424 1425keys(): K[] 1426 1427获取当前缓冲区中所有键从最近访问到最近最少访问的升序列表。 1428 1429**系统能力：** SystemCapability.Utils.Lang 1430 1431**返回值：** 1432 1433| 类型 | 说明 | 1434| --------- | ------------------------------------------------------------ | 1435| K [] | 按升序返回当前缓冲区中所有键的列表，从最近访问到最近最少访问。 | 1436 1437**示例：** 1438 1439 ```js 1440let pro = new util.LRUCache(); 1441pro.put(2,10); 1442let result = pro.keys(); 1443 ``` 1444 1445 1446### remove<sup>9+</sup> 1447 1448remove(key: K): V | undefined 1449 1450从当前缓冲区中删除指定的键及其关联的值。 1451 1452**系统能力：** SystemCapability.Utils.Lang 1453 1454**参数：** 1455 1456| 参数名 | 类型 | 必填 | 说明 | 1457| ------ | ---- | ---- | -------------- | 1458| key | K | 是 | 要删除的密钥。 | 1459 1460**返回值：** 1461 1462| 类型 | 说明 | 1463| ------------------------ | ------------------------------------------------------------ | 1464| V \| undefined | 返回一个包含已删除键值对的Optional对象；如果key不存在，则返回一个空的Optional对象，如果key为null，则抛出异常。 | 1465 1466**示例：** 1467 1468 ```js 1469let pro = new util.LRUCache(); 1470pro.put(2,10); 1471let result = pro.remove(20); 1472 ``` 1473 1474 1475### afterRemoval<sup>9+</sup> 1476 1477afterRemoval(isEvict: boolean,key: K,value: V,newValue: V): void 1478 1479删除值后执行后续操作。 1480 1481**系统能力：** SystemCapability.Utils.Lang 1482 1483**参数：** 1484 1485| 参数名 | 类型 | 必填 | 说明 | 1486| -------- | ------- | ---- | ------------------------------------------------------------ | 1487| isEvict | boolean | 是 | 因容量不足而调用该方法时，参数值为true，其他情况为false。 | 1488| key | K | 是 | 表示删除的键。 | 1489| value | V | 是 | 表示删除的值。 | 1490| newValue | V | 是 | 如果已调用put方法并且要添加的键已经存在，则参数值是关联的新值。其他情况下参数值为空。 | 1491 1492**示例：** 1493 1494 ```js 1495let arr = []; 1496class ChildLruBuffer<K, V> extends util.LRUCache<K, V> 1497{ 1498 constructor() 1499 { 1500 super(); 1501 } 1502 afterRemoval(isEvict, key, value, newValue) 1503 { 1504 if (isEvict === false) 1505 { 1506 arr = [key, value, newValue]; 1507 } 1508 } 1509} 1510let lru = new ChildLruBuffer(); 1511lru.afterRemoval(false,10,30,null); 1512 ``` 1513 1514 1515### contains<sup>9+</sup> 1516 1517contains(key: K): boolean 1518 1519检查当前缓冲区是否包含指定的键。 1520 1521**系统能力：** SystemCapability.Utils.Lang 1522 1523**参数：** 1524 1525| 参数名 | 类型 | 必填 | 说明 | 1526| ------ | ------ | ---- | ---------------- | 1527| key | K | 是 | 表示要检查的键。 | 1528 1529**返回值：** 1530 1531| 类型 | 说明 | 1532| ------- | ------------------------------------------ | 1533| boolean | 如果缓冲区包含指定的键，则返回 true。 | 1534 1535**示例：** 1536 1537 ```js 1538let pro = new util.LRUCache(); 1539pro.put(2,10); 1540let obj = {1:"key"}; 1541let result = pro.contains(obj); 1542 ``` 1543 1544 1545### createDefault<sup>9+</sup> 1546 1547createDefault(key: K): V 1548 1549如果未计算特定键的值，则执行后续操作，参数表示丢失的键，返回与键关联的值。 1550 1551**系统能力：** SystemCapability.Utils.Lang 1552 1553**参数：** 1554 1555| 参数名 | 类型 | 必填 | 说明 | 1556| ------ | ---- | ---- | -------------- | 1557| key | K | 是 | 表示丢失的键。 | 1558 1559**返回值：** 1560 1561| 类型 | 说明 | 1562| ---- | ------------------ | 1563| V | 返回与键关联的值。 | 1564 1565**示例：** 1566 1567 ```js 1568let pro = new util.LRUCache(); 1569let result = pro.createDefault(50); 1570 ``` 1571 1572 1573### entries<sup>9+</sup> 1574 1575entries(): IterableIterator<[K,V]> 1576 1577允许迭代包含在这个对象中的所有键值对。 1578 1579**系统能力：** SystemCapability.Utils.Lang 1580 1581**返回值：** 1582 1583| 类型 | 说明 | 1584| ----------- | -------------------- | 1585| [K, V] | 返回一个可迭代数组。 | 1586 1587**示例：** 1588 1589 ```js 1590let pro = new util.LRUCache(); 1591pro.put(2,10); 1592let result = pro.entries(); 1593 ``` 1594 1595### [Symbol.iterator]<sup>9+</sup> 1596 1597[Symbol.iterator]\(): IterableIterator<[K, V]> 1598 1599返回一个键值对形式的二维数组。 1600 1601**系统能力：** SystemCapability.Utils.Lang 1602 1603**返回值：** 1604 1605| 类型 | 说明 | 1606| ----------- | ------------------------------ | 1607| [K, V] | 返回一个键值对形式的二维数组。 | 1608 1609**示例：** 1610 1611 ```js 1612let pro = new util.LRUCache(); 1613pro.put(2,10); 1614let result = pro[Symbol.iterator](); 1615 ``` 1616 1617## ScopeComparable<sup>8+</sup> 1618 1619ScopeComparable类型的值需要实现compareTo方法，确保传入的数据具有可比性。 1620 1621**系统能力：** SystemCapability.Utils.Lang 1622 1623### compareTo<sup>8+</sup> 1624 1625compareTo(other: ScopeComparable): boolean; 1626 1627比较两个值的大小，返回一个布尔值。 1628 1629**系统能力：** SystemCapability.Utils.Lang 1630 1631**参数：** 1632 1633| 参数名 | 类型 | 必填 | 说明 | 1634| ------ | ---- | ---- | -------------- | 1635| other | [ScopeComparable](#scopecomparable8) | 是 | 表示要比较的值。 | 1636 1637**返回值：** 1638 1639| 类型 | 说明 | 1640| ---- | ------------------ | 1641| boolean | 调用compareTo的值大于等于传入的值返回true，否则返回false。| 1642 1643**示例：** 1644 1645构造新类，实现compareTo方法。后续示例代码中，均以此Temperature类为例。 1646 1647```js 1648class Temperature{ 1649 // 当使用ArkTS语言开发时，需要补充以下代码： 1650 // private readonly _temp: Temperature; 1651 constructor(value) { 1652 this._temp = value; 1653 } 1654 compareTo(value) { 1655 return this._temp >= value.getTemp(); 1656 } 1657 getTemp() { 1658 return this._temp; 1659 } 1660 toString() { 1661 return this._temp.toString(); 1662 } 1663} 1664``` 1665 1666## ScopeType<sup>8+</sup> 1667 1668用于表示范围中的值的类型。 1669 1670**系统能力：** SystemCapability.Utils.Lang 1671 1672| 类型 | 说明 | 1673| -------- | -------- | 1674| number | 表示值的类型为数字。 | 1675| [ScopeComparable](#scopecomparable8) | 表示值的类型为ScopeComparable。| 1676 1677## ScopeHelper<sup>9+</sup> 1678 1679ScopeHelper接口用于描述一个字段的有效范围。ScopeHelper实例的构造函数用于创建具有指定下限和上限的对象，并要求这些对象必须具有可比性。 1680 1681### constructor<sup>9+</sup> 1682 1683constructor(lowerObj: ScopeType, upperObj: ScopeType) 1684 1685用于创建指定下限和上限的作用域实例的构造函数，返回一个ScopeHelper对象。 1686 1687**系统能力：** SystemCapability.Utils.Lang 1688 1689**参数：** 1690 1691| 参数名 | 类型 | 必填 | 说明 | 1692| -------- | ------------------------ | ---- | ---------------------- | 1693| lowerObj | [ScopeType](#scopetype8) | 是 | 指定作用域实例的下限。 | 1694| upperObj | [ScopeType](#scopetype8) | 是 | 指定作用域实例的上限。 | 1695 1696**示例：** 1697 1698 ```js 1699let tempLower = new Temperature(30); 1700let tempUpper = new Temperature(40); 1701let range = new util.ScopeHelper(tempLower, tempUpper); 1702 ``` 1703 1704 1705### toString<sup>9+</sup> 1706 1707toString(): string 1708 1709该字符串化方法返回一个包含当前范围的字符串表示形式。 1710 1711**系统能力：** SystemCapability.Utils.Lang 1712 1713**返回值：** 1714 1715| 类型 | 说明 | 1716| ------ | -------------------------------------- | 1717| string | 返回包含当前范围对象的字符串表示形式。 | 1718 1719**示例：** 1720 1721 ```js 1722let tempLower = new Temperature(30); 1723let tempUpper = new Temperature(40); 1724let range = new util.ScopeHelper(tempLower, tempUpper); 1725let result = range.toString(); 1726 ``` 1727 1728 1729### intersect<sup>9+</sup> 1730 1731intersect(range: ScopeHelper): ScopeHelper 1732 1733获取给定范围和当前范围的交集。 1734 1735**系统能力：** SystemCapability.Utils.Lang 1736 1737**参数：** 1738 1739| 参数名 | 类型 | 必填 | 说明 | 1740| ------ | ---------------------------- | ---- | ------------------ | 1741| range | [ScopeHelper](#scopehelper9) | 是 | 传入一个给定范围。 | 1742 1743**返回值：** 1744 1745| 类型 | 说明 | 1746| ------------------------------ | ------------------------------ | 1747| [ScopeHelper9+](#scopehelper9) | 返回给定范围和当前范围的交集。 | 1748 1749**示例：** 1750 1751 ```js 1752let tempLower = new Temperature(30); 1753let tempUpper = new Temperature(40); 1754let range = new util.ScopeHelper(tempLower, tempUpper); 1755let tempMiDF = new Temperature(35); 1756let tempMidS = new Temperature(39); 1757let rangeFir = new util.ScopeHelper(tempMiDF, tempMidS); 1758range.intersect(rangeFir); 1759 ``` 1760 1761 1762### intersect<sup>9+</sup> 1763 1764intersect(lowerObj:ScopeType,upperObj:ScopeType):ScopeHelper 1765 1766获取当前范围与给定下限和上限范围的交集。 1767 1768**系统能力：** SystemCapability.Utils.Lang 1769 1770**参数：** 1771 1772| 参数名 | 类型 | 必填 | 说明 | 1773| -------- | ------------------------ | ---- | ---------------- | 1774| lowerObj | [ScopeType](#scopetype8) | 是 | 给定范围的下限。 | 1775| upperObj | [ScopeType](#scopetype8) | 是 | 给定范围的上限。 | 1776 1777**返回值：** 1778 1779| 类型 | 说明 | 1780| ---------------------------- | ---------------------------------------- | 1781| [ScopeHelper](#scopehelper9) | 返回当前范围与给定下限和上限范围的交集。 | 1782 1783**示例：** 1784 1785 ```js 1786let tempLower = new Temperature(30); 1787let tempUpper = new Temperature(40); 1788let tempMiDF = new Temperature(35); 1789let tempMidS = new Temperature(39); 1790let range = new util.ScopeHelper(tempLower, tempUpper); 1791let result = range.intersect(tempMiDF, tempMidS); 1792 ``` 1793 1794 1795### getUpper<sup>9+</sup> 1796 1797getUpper(): ScopeType 1798 1799获取当前范围的上限。 1800 1801**系统能力：** SystemCapability.Utils.Lang 1802 1803**返回值：** 1804 1805| 类型 | 说明 | 1806| ------------------------ | ---------------------- | 1807| [ScopeType](#scopetype8) | 返回当前范围的上限值。 | 1808 1809**示例：** 1810 1811 ```js 1812let tempLower = new Temperature(30); 1813let tempUpper = new Temperature(40); 1814let range = new util.ScopeHelper(tempLower, tempUpper); 1815let result = range.getUpper(); 1816 ``` 1817 1818 1819### getLower<sup>9+</sup> 1820 1821getLower(): ScopeType 1822 1823获取当前范围的下限。 1824 1825**系统能力：** SystemCapability.Utils.Lang 1826 1827**返回值：** 1828 1829| 类型 | 说明 | 1830| ------------------------ | ---------------------- | 1831| [ScopeType](#scopetype8) | 返回当前范围的下限值。 | 1832 1833**示例：** 1834 1835 ```js 1836let tempLower = new Temperature(30); 1837let tempUpper = new Temperature(40); 1838let range = new util.ScopeHelper(tempLower, tempUpper); 1839let result = range.getLower(); 1840 ``` 1841 1842 1843### expand<sup>9+</sup> 1844 1845expand(lowerObj: ScopeType,upperObj: ScopeType): ScopeHelper 1846 1847创建并返回包括当前范围和给定下限和上限的并集。 1848 1849**系统能力：** SystemCapability.Utils.Lang 1850 1851**参数：** 1852 1853| 参数名 | 类型 | 必填 | 说明 | 1854| -------- | ------------------------ | ---- | ---------------- | 1855| lowerObj | [ScopeType](#scopetype8) | 是 | 给定范围的下限。 | 1856| upperObj | [ScopeType](#scopetype8) | 是 | 给定范围的上限。 | 1857 1858**返回值：** 1859 1860| 类型 | 说明 | 1861| ---------------------------- | ------------------------------------ | 1862| [ScopeHelper](#scopehelper9) | 返回当前范围和给定下限和上限的并集。 | 1863 1864**示例：** 1865 1866 ```js 1867let tempLower = new Temperature(30); 1868let tempUpper = new Temperature(40); 1869let tempMiDF = new Temperature(35); 1870let tempMidS = new Temperature(39); 1871let range = new util.ScopeHelper(tempLower, tempUpper); 1872let result = range.expand(tempMiDF, tempMidS); 1873 ``` 1874 1875 1876### expand<sup>9+</sup> 1877 1878expand(range: ScopeHelper): ScopeHelper 1879 1880创建并返回包括当前范围和给定范围的并集。 1881 1882**系统能力：** SystemCapability.Utils.Lang 1883 1884**参数：** 1885 1886| 参数名 | 类型 | 必填 | 说明 | 1887| ------ | ---------------------------- | ---- | ------------------ | 1888| range | [ScopeHelper](#scopehelper9) | 是 | 传入一个给定范围。 | 1889 1890**返回值：** 1891 1892| 类型 | 说明 | 1893| ---------------------------- | ---------------------------------- | 1894| [ScopeHelper](#scopehelper9) | 返回包括当前范围和给定范围的并集。 | 1895 1896**示例：** 1897 1898 ```js 1899let tempLower = new Temperature(30); 1900let tempUpper = new Temperature(40); 1901let tempMiDF = new Temperature(35); 1902let tempMidS = new Temperature(39); 1903let range = new util.ScopeHelper(tempLower, tempUpper); 1904let rangeFir = new util.ScopeHelper(tempMiDF, tempMidS); 1905let result = range.expand(rangeFir); 1906 ``` 1907 1908 1909### expand<sup>9+</sup> 1910 1911expand(value: ScopeType): ScopeHelper 1912 1913创建并返回包括当前范围和给定值的并集。 1914 1915**系统能力：** SystemCapability.Utils.Lang 1916 1917**参数：** 1918 1919| 参数名 | 类型 | 必填 | 说明 | 1920| ------ | ------------------------ | ---- | ---------------- | 1921| value | [ScopeType](#scopetype8) | 是 | 传入一个给定值。 | 1922 1923**返回值：** 1924 1925| 类型 | 说明 | 1926| ---------------------------- | -------------------------------- | 1927| [ScopeHelper](#scopehelper9) | 返回包括当前范围和给定值的并集。 | 1928 1929**示例：** 1930 1931 ```js 1932let tempLower = new Temperature(30); 1933let tempUpper = new Temperature(40); 1934let tempMiDF = new Temperature(35); 1935let range = new util.ScopeHelper(tempLower, tempUpper); 1936let result = range.expand(tempMiDF); 1937 ``` 1938 1939 1940### contains<sup>9+</sup> 1941 1942contains(value: ScopeType): boolean 1943 1944检查给定value是否包含在当前范围内。 1945 1946**系统能力：** SystemCapability.Utils.Lang 1947 1948**参数：** 1949 1950| 参数名 | 类型 | 必填 | 说明 | 1951| ------ | ------------------------ | ---- | ---------------- | 1952| value | [ScopeType](#scopetype8) | 是 | 传入一个给定值。 | 1953 1954**返回值：** 1955 1956| 类型 | 说明 | 1957| ------- | --------------------------------------------------- | 1958| boolean | 如果给定值包含在当前范围内返回true，否则返回false。 | 1959 1960**示例：** 1961 1962 ```js 1963let tempLower = new Temperature(30); 1964let tempUpper = new Temperature(40); 1965let tempMiDF = new Temperature(35); 1966let range = new util.ScopeHelper(tempLower, tempUpper); 1967let result = range.contains(tempMiDF); 1968 ``` 1969 1970 1971### contains<sup>9+</sup> 1972 1973contains(range: ScopeHelper): boolean 1974 1975检查给定range是否在当前范围内。 1976 1977**系统能力：** SystemCapability.Utils.Lang 1978 1979**参数：** 1980 1981| 参数名 | 类型 | 必填 | 说明 | 1982| ------ | ---------------------------- | ---- | ------------------ | 1983| range | [ScopeHelper](#scopehelper9) | 是 | 传入一个给定范围。 | 1984 1985**返回值：** 1986 1987| 类型 | 说明 | 1988| ------- | ----------------------------------------------------- | 1989| boolean | 如果给定范围包含在当前范围内返回true，否则返回false。 | 1990 1991**示例：** 1992 1993 ```js 1994let tempLower = new Temperature(30); 1995let tempUpper = new Temperature(40); 1996let range = new util.ScopeHelper(tempLower, tempUpper); 1997let tempLess = new Temperature(20); 1998let tempMore = new Temperature(45); 1999let rangeSec = new util.ScopeHelper(tempLess, tempMore); 2000let result = range.contains(rangeSec); 2001 ``` 2002 2003 2004### clamp<sup>9+</sup> 2005 2006clamp(value: ScopeType): ScopeType 2007 2008将给定值限定到当前范围内。 2009 2010**系统能力：** SystemCapability.Utils.Lang 2011 2012**参数：** 2013 2014| 参数名 | 类型 | 必填 | 说明 | 2015| ------ | ------------------------ | ---- | -------------- | 2016| value | [ScopeType](#scopetype8) | 是 | 传入的给定值。 | 2017 2018**返回值：** 2019 2020| 类型 | 说明 | 2021| ------------------------ | ------------------------------------------------------------ | 2022| [ScopeType](#scopetype8) | 如果传入的value小于下限，则返回lowerObj；如果大于上限值则返回upperObj；如果在当前范围内，则返回value。 | 2023 2024**示例：** 2025 2026 ```js 2027let tempLower = new Temperature(30); 2028let tempUpper = new Temperature(40); 2029let tempMiDF = new Temperature(35); 2030let range = new util.ScopeHelper(tempLower, tempUpper); 2031let result = range.clamp(tempMiDF); 2032 ``` 2033 2034## Base64Helper<sup>9+</sup> 2035 2036Base64编码表包含A-Z、a-z、0-9这62个字符，以及"+"和"/"这两个特殊字符。在编码时，将原始数据按3个字节一组进行划分，得到若干个6位的数字，然后使用Base64编码表中对应的字符来表示这些数字。如果最后剩余1或2个字节，则需要使用"="字符进行补齐。 2037 2038### constructor<sup>9+</sup> 2039 2040constructor() 2041 2042Base64Helper的构造函数。 2043 2044**系统能力：** SystemCapability.Utils.Lang 2045 2046**示例：** 2047 2048 ```js 2049let base64 = new util.Base64Helper(); 2050 ``` 2051 2052### encodeSync<sup>9+</sup> 2053 2054encodeSync(src: Uint8Array): Uint8Array 2055 2056通过输入参数编码后输出对应文本。 2057 2058**系统能力：** SystemCapability.Utils.Lang 2059 2060**参数：** 2061 2062| 参数名 | 类型 | 必填 | 说明 | 2063| ------ | ---------- | ---- | ------------------- | 2064| src | Uint8Array | 是 | 编码输入Uint8数组。 | 2065 2066**返回值：** 2067 2068| 类型 | 说明 | 2069| ---------- | ----------------------------- | 2070| Uint8Array | 返回编码后新分配的Uint8数组。 | 2071 2072**示例：** 2073 2074 ```js 2075let that = new util.Base64Helper(); 2076let array = new Uint8Array([115,49,51]); 2077let result = that.encodeSync(array); 2078 ``` 2079 2080 2081### encodeToStringSync<sup>9+</sup> 2082 2083encodeToStringSync(src: Uint8Array): string 2084 2085通过输入参数编码后输出对应文本。 2086 2087**系统能力：** SystemCapability.Utils.Lang 2088 2089**参数：** 2090 2091| 参数名 | 类型 | 必填 | 说明 | 2092| ------ | ---------- | ---- | ------------------- | 2093| src | Uint8Array | 是 | 编码输入Uint8数组。 | 2094 2095**返回值：** 2096 2097| 类型 | 说明 | 2098| ------ | -------------------- | 2099| string | 返回编码后的字符串。 | 2100 2101**示例：** 2102 2103 ```js 2104let that = new util.Base64Helper(); 2105let array = new Uint8Array([115,49,51]); 2106let result = that.encodeToStringSync(array); 2107 ``` 2108 2109 2110### decodeSync<sup>9+</sup> 2111 2112decodeSync(src: Uint8Array | string): Uint8Array 2113 2114通过输入参数解码后输出对应文本。 2115 2116**系统能力：** SystemCapability.Utils.Lang 2117 2118**参数：** 2119 2120| 参数名 | 类型 | 必填 | 说明 | 2121| ------ | ------------------------------ | ---- | ----------------------------- | 2122| src | Uint8Array \| string | 是 | 解码输入Uint8数组或者字符串。 | 2123 2124**返回值：** 2125 2126| 类型 | 说明 | 2127| ---------- | ----------------------------- | 2128| Uint8Array | 返回解码后新分配的Uint8数组。 | 2129 2130**示例：** 2131 2132 ```js 2133let that = new util.Base64Helper(); 2134let buff = 'czEz'; 2135let result = that.decodeSync(buff); 2136 ``` 2137 2138 2139### encode<sup>9+</sup> 2140 2141encode(src: Uint8Array): Promise<Uint8Array> 2142 2143通过输入参数异步编码后输出对应文本。 2144 2145**系统能力：** SystemCapability.Utils.Lang 2146 2147**参数：** 2148 2149| 参数名 | 类型 | 必填 | 说明 | 2150| ------ | ---------- | ---- | ----------------------- | 2151| src | Uint8Array | 是 | 异步编码输入Uint8数组。 | 2152 2153**返回值：** 2154 2155| 类型 | 说明 | 2156| ------------------------- | --------------------------------- | 2157| Promise<Uint8Array> | 返回异步编码后新分配的Uint8数组。 | 2158 2159**示例：** 2160 2161 ```js 2162let that = new util.Base64Helper(); 2163let array = new Uint8Array([115,49,51]); 2164let rarray = new Uint8Array([99,122,69,122]); 2165that.encode(array).then(val=>{ 2166 for (var i = 0; i < rarray.length; i++) { 2167 console.log(val[i].toString()) 2168 } 2169}) 2170 ``` 2171 2172 2173### encodeToString<sup>9+</sup> 2174 2175encodeToString(src: Uint8Array): Promise<string> 2176 2177通过输入参数异步编码后输出对应文本。 2178 2179**系统能力：** SystemCapability.Utils.Lang 2180 2181**参数：** 2182 2183| 参数名 | 类型 | 必填 | 说明 | 2184| ------ | ---------- | ---- | ----------------------- | 2185| src | Uint8Array | 是 | 异步编码输入Uint8数组。 | 2186 2187**返回值：** 2188 2189| 类型 | 说明 | 2190| --------------------- | ------------------------ | 2191| Promise<string> | 返回异步编码后的字符串。 | 2192 2193**示例：** 2194 2195 ```js 2196let that = new util.Base64Helper(); 2197let array = new Uint8Array([115,49,51]); 2198that.encodeToString(array).then(val=>{ 2199 console.log(val) 2200}) 2201 ``` 2202 2203 2204### decode<sup>9+</sup> 2205 2206decode(src: Uint8Array | string): Promise<Uint8Array> 2207 2208通过输入参数异步解码后输出对应文本。 2209 2210**系统能力：** SystemCapability.Utils.Lang 2211 2212**参数：** 2213 2214| 参数名 | 类型 | 必填 | 说明 | 2215| ------ | ------------------------------ | ---- | --------------------------------- | 2216| src | Uint8Array \| string | 是 | 异步解码输入Uint8数组或者字符串。 | 2217 2218**返回值：** 2219 2220| 类型 | 说明 | 2221| ------------------------- | --------------------------------- | 2222| Promise<Uint8Array> | 返回异步解码后新分配的Uint8数组。 | 2223 2224**示例：** 2225 2226 ```js 2227let that = new util.Base64Helper(); 2228let array = new Uint8Array([99,122,69,122]); 2229let rarray = new Uint8Array([115,49,51]); 2230that.decode(array).then(val=>{ 2231 for (var i = 0; i < rarray.length; i++) { 2232 console.log(val[i].toString()) 2233 } 2234}) 2235 ``` 2236 2237## types<sup>8+</sup> 2238 2239types为不同类型的内置对象提供类型检查，可以避免由于类型错误导致的异常或崩溃。该模块包含了多个工具函数，用于判断JS对象是否属于各种类型例如：ArrayBuffer、Map、Set等。 2240 2241### constructor<sup>8+</sup> 2242 2243constructor() 2244 2245Types的构造函数。 2246 2247**系统能力：** SystemCapability.Utils.Lang 2248 2249**示例：** 2250 2251 ```js 2252 let type = new util.types(); 2253 ``` 2254 2255 2256### isAnyArrayBuffer<sup>8+</sup> 2257 2258isAnyArrayBuffer(value: Object): boolean 2259 2260检查输入的value是否是ArrayBuffer类型。 2261 2262**系统能力：** SystemCapability.Utils.Lang 2263 2264**参数：** 2265 2266| 参数名 | 类型 | 必填 | 说明 | 2267| -------- | -------- | -------- | -------- | 2268| value | Object | 是 | 待检测对象。 | 2269 2270**返回值：** 2271 2272| 类型 | 说明 | 2273| -------- | -------- | 2274| boolean | 判断的结果，如果是ArrayBuffer类型为true，反之为false。 | 2275 2276**示例：** 2277 2278 ```js 2279 let that = new util.types(); 2280 let result = that.isAnyArrayBuffer(new ArrayBuffer(0)); 2281 ``` 2282 2283 2284### isArrayBufferView<sup>8+</sup> 2285 2286isArrayBufferView(value: Object): boolean 2287 2288检查输入的value是否是内置ArrayBufferView辅助类型。 2289 2290ArrayBufferView辅助类型包括：Int8Array、Int16Array、Int32Array、Uint8Array、Uint8ClampedArray、Uint32Array、Float32Array、Float64Array、DataView。 2291 2292**系统能力：** SystemCapability.Utils.Lang 2293 2294**参数：** 2295 2296| 参数名 | 类型 | 必填 | 说明 | 2297| -------- | -------- | -------- | -------- | 2298| value | Object | 是 | 待检测对象。 | 2299 2300**返回值：** 2301 2302| 类型 | 说明 | 2303| -------- | -------- | 2304| boolean | 判断的结果，如果是内置包含的ArrayBufferView辅助类型为true，反之为false。 | 2305 2306**示例：** 2307 2308 ```js 2309 let that = new util.types(); 2310 let result = that.isArrayBufferView(new Int8Array([])); 2311 ``` 2312 2313 2314### isArgumentsObject<sup>8+</sup> 2315 2316isArgumentsObject(value: Object): boolean 2317 2318检查输入的value是否是一个arguments对象类型。 2319 2320**系统能力：** SystemCapability.Utils.Lang 2321 2322**参数：** 2323 2324| 参数名 | 类型 | 必填 | 说明 | 2325| -------- | -------- | -------- | -------- | 2326| value | Object | 是 | 待检测对象。 | 2327 2328**返回值：** 2329 2330| 类型 | 说明 | 2331| -------- | -------- | 2332| boolean | 判断的结果，如果是内置包含的arguments类型为true，反之为false。 | 2333 2334**示例：** 2335 2336 ```js 2337 let that = new util.types(); 2338 function foo() { 2339 var result = that.isArgumentsObject(arguments); 2340 } 2341 let f = foo(); 2342 ``` 2343 2344 2345### isArrayBuffer<sup>8+</sup> 2346 2347isArrayBuffer(value: Object): boolean 2348 2349检查输入的value是否是ArrayBuffer类型。 2350 2351**系统能力：** SystemCapability.Utils.Lang 2352 2353**参数：** 2354 2355| 参数名 | 类型 | 必填 | 说明 | 2356| -------- | -------- | -------- | -------- | 2357| value | Object | 是 | 待检测对象。 | 2358 2359**返回值：** 2360 2361| 类型 | 说明 | 2362| -------- | -------- | 2363| boolean | 判断的结果，如果是内置包含的ArrayBuffer类型为true，反之为false。 | 2364 2365**示例：** 2366 2367 ```js 2368 let that = new util.types(); 2369 let result = that.isArrayBuffer(new ArrayBuffer(0)); 2370 ``` 2371 2372 2373### isAsyncFunction<sup>8+</sup> 2374 2375isAsyncFunction(value: Object): boolean 2376 2377检查输入的value是否是一个异步函数类型。 2378 2379**系统能力：** SystemCapability.Utils.Lang 2380 2381**参数：** 2382 2383| 参数名 | 类型 | 必填 | 说明 | 2384| -------- | -------- | -------- | -------- | 2385| value | Object | 是 | 待检测对象。 | 2386 2387**返回值：** 2388 2389| 类型 | 说明 | 2390| -------- | -------- | 2391| boolean | 判断的结果，如果是内置包含的异步函数类型为true，反之为false。 | 2392 2393**示例：** 2394 2395 ```js 2396 let that = new util.types(); 2397 let result = that.isAsyncFunction(async function foo() {}); 2398 ``` 2399 2400 2401### isBooleanObject<sup>8+</sup> 2402 2403isBooleanObject(value: Object): boolean 2404 2405检查输入的value是否是一个Boolean对象类型。 2406 2407**系统能力：** SystemCapability.Utils.Lang 2408 2409**参数：** 2410 2411| 参数名 | 类型 | 必填 | 说明 | 2412| -------- | -------- | -------- | -------- | 2413| value | Object | 是 | 待检测对象。 | 2414 2415**返回值：** 2416 2417| 类型 | 说明 | 2418| -------- | -------- | 2419| boolean | 判断的结果，如果是内置包含的Boolean对象类型为true，反之为false。 | 2420 2421**示例：** 2422 2423 ```js 2424 let that = new util.types(); 2425 let result = that.isBooleanObject(new Boolean(true)); 2426 ``` 2427 2428 2429### isBoxedPrimitive<sup>8+</sup> 2430 2431isBoxedPrimitive(value: Object): boolean 2432 2433检查输入的value是否是Boolean或Number或String或Symbol对象类型。 2434 2435**系统能力：** SystemCapability.Utils.Lang 2436 2437**参数：** 2438 2439| 参数名 | 类型 | 必填 | 说明 | 2440| -------- | -------- | -------- | -------- | 2441| value | Object | 是 | 待检测对象。 | 2442 2443**返回值：** 2444 2445| 类型 | 说明 | 2446| -------- | -------- | 2447| boolean | 判断的结果，如果是内置包含的Boolean或Number或String或Symbol对象类型为true，反之为false。 | 2448 2449**示例：** 2450 2451 ```js 2452 let that = new util.types(); 2453 let result = that.isBoxedPrimitive(new Boolean(false)); 2454 ``` 2455 2456 2457### isDataView<sup>8+</sup> 2458 2459isDataView(value: Object): boolean 2460 2461检查输入的value是否是DataView类型。 2462 2463**系统能力：** SystemCapability.Utils.Lang 2464 2465**参数：** 2466 2467| 参数名 | 类型 | 必填 | 说明 | 2468| -------- | -------- | -------- | -------- | 2469| value | Object | 是 | 待检测对象。 | 2470 2471**返回值：** 2472 2473| 类型 | 说明 | 2474| -------- | -------- | 2475| boolean | 判断的结果，如果是内置包含的DataView对象类型为true，反之为false。 | 2476 2477**示例：** 2478 2479 ```js 2480 let that = new util.types(); 2481 const ab = new ArrayBuffer(20); 2482 let result = that.isDataView(new DataView(ab)); 2483 ``` 2484 2485 2486### isDate<sup>8+</sup> 2487 2488isDate(value: Object): boolean 2489 2490检查输入的value是否是Date类型。 2491 2492**系统能力：** SystemCapability.Utils.Lang 2493 2494**参数：** 2495 2496| 参数名 | 类型 | 必填 | 说明 | 2497| -------- | -------- | -------- | -------- | 2498| value | Object | 是 | 待检测对象。 | 2499 2500**返回值：** 2501 2502| 类型 | 说明 | 2503| -------- | -------- | 2504| boolean | 判断的结果，如果是内置包含的Date对象类型为true，反之为false。 | 2505 2506**示例：** 2507 2508 ```js 2509 let that = new util.types(); 2510 let result = that.isDate(new Date()); 2511 ``` 2512 2513 2514### isExternal<sup>8+</sup> 2515 2516isExternal(value: Object): boolean 2517 2518检查输入的value是否是native External类型。 2519 2520**系统能力：** SystemCapability.Utils.Lang 2521 2522**参数：** 2523 2524| 参数名 | 类型 | 必填 | 说明 | 2525| -------- | -------- | -------- | -------- | 2526| value | Object | 是 | 待检测对象。 | 2527 2528**返回值：** 2529 2530| 类型 | 说明 | 2531| -------- | -------- | 2532| boolean | 判断的结果，如果是内置包含native External类型为true，反之为false。 | 2533 2534**示例：** 2535 2536 ```js 2537 let that = new util.types(); 2538 let result = that.isExternal(true); 2539 ``` 2540 2541 2542### isFloat32Array<sup>8+</sup> 2543 2544isFloat32Array(value: Object): boolean 2545 2546检查输入的value是否是Float32Array数组类型。 2547 2548**系统能力：** SystemCapability.Utils.Lang 2549 2550**参数：** 2551 2552| 参数名 | 类型 | 必填 | 说明 | 2553| -------- | -------- | -------- | -------- | 2554| value | Object | 是 | 待检测对象。 | 2555 2556**返回值：** 2557 2558| 类型 | 说明 | 2559| -------- | -------- | 2560| boolean | 判断的结果，如果是内置包含的Float32Array数组类型为true，反之为false。 | 2561 2562**示例：** 2563 2564 ```js 2565 let that = new util.types(); 2566 let result = that.isFloat32Array(new Float32Array()); 2567 ``` 2568 2569 2570### isFloat64Array<sup>8+</sup> 2571 2572isFloat64Array(value: Object): boolean 2573 2574检查输入的value是否是Float64Array数组类型。 2575 2576**系统能力：** SystemCapability.Utils.Lang 2577 2578**参数：** 2579 2580| 参数名 | 类型 | 必填 | 说明 | 2581| -------- | -------- | -------- | -------- | 2582| value | Object | 是 | 待检测对象。 | 2583 2584**返回值：** 2585 2586| 类型 | 说明 | 2587| -------- | -------- | 2588| boolean | 判断的结果，如果是内置包含的Float64Array数组类型为true，反之为false。 | 2589 2590**示例：** 2591 2592 ```js 2593 let that = new util.types(); 2594 let result = that.isFloat64Array(new Float64Array()); 2595 ``` 2596 2597 2598### isGeneratorFunction<sup>8+</sup> 2599 2600isGeneratorFunction(value: Object): boolean 2601 2602检查输入的value是否是generator函数类型。 2603 2604**系统能力：** SystemCapability.Utils.Lang 2605 2606**参数：** 2607 2608| 参数名 | 类型 | 必填 | 说明 | 2609| -------- | -------- | -------- | -------- | 2610| value | Object | 是 | 待检测对象。 | 2611 2612**返回值：** 2613 2614| 类型 | 说明 | 2615| -------- | -------- | 2616| boolean | 判断的结果，如果是内置包含的generator函数类型为true，反之为false。 | 2617 2618**示例：** 2619 2620 ```js 2621 let that = new util.types(); 2622 let result = that.isGeneratorFunction(function* foo() {}); 2623 ``` 2624 2625 2626### isGeneratorObject<sup>8+</sup> 2627 2628isGeneratorObject(value: Object): boolean 2629 2630检查输入的value是否是generator对象类型。 2631 2632**系统能力：** SystemCapability.Utils.Lang 2633 2634**参数：** 2635 2636| 参数名 | 类型 | 必填 | 说明 | 2637| -------- | -------- | -------- | -------- | 2638| value | Object | 是 | 待检测对象。 | 2639 2640**返回值：** 2641 2642| 类型 | 说明 | 2643| -------- | -------- | 2644| boolean | 判断的结果，如果是内置包含的generator对象类型为true，反之为false。 | 2645 2646**示例：** 2647 2648 ```js 2649 let that = new util.types(); 2650 function* foo() {} 2651 const generator = foo(); 2652 let result = that.isGeneratorObject(generator); 2653 ``` 2654 2655 2656### isInt8Array<sup>8+</sup> 2657 2658isInt8Array(value: Object): boolean 2659 2660检查输入的value是否是Int8Array数组类型。 2661 2662**系统能力：** SystemCapability.Utils.Lang 2663 2664**参数：** 2665 2666| 参数名 | 类型 | 必填 | 说明 | 2667| -------- | -------- | -------- | -------- | 2668| value | Object | 是 | 待检测对象。 | 2669 2670**返回值：** 2671 2672| 类型 | 说明 | 2673| -------- | -------- | 2674| boolean | 判断的结果，如果是内置包含的Int8Array数组类型为true，反之为false。 | 2675 2676**示例：** 2677 2678 ```js 2679 let that = new util.types(); 2680 let result = that.isInt8Array(new Int8Array([])); 2681 ``` 2682 2683 2684### isInt16Array<sup>8+</sup> 2685 2686isInt16Array(value: Object): boolean 2687 2688检查输入的value是否是Int16Array数组类型。 2689 2690**系统能力：** SystemCapability.Utils.Lang 2691 2692**参数：** 2693 2694| 参数名 | 类型 | 必填 | 说明 | 2695| -------- | -------- | -------- | -------- | 2696| value | Object | 是 | 待检测对象。 | 2697 2698**返回值：** 2699 2700| 类型 | 说明 | 2701| -------- | -------- | 2702| boolean | 判断的结果，如果是内置包含的Int16Array数组类型为true，反之为false。 | 2703 2704**示例：** 2705 2706 ```js 2707 let that = new util.types(); 2708 let result = that.isInt16Array(new Int16Array([])); 2709 ``` 2710 2711 2712### isInt32Array<sup>8+</sup> 2713 2714isInt32Array(value: Object): boolean 2715 2716检查输入的value是否是Int32Array数组类型。 2717 2718**系统能力：** SystemCapability.Utils.Lang 2719 2720**参数：** 2721 2722| 参数名 | 类型 | 必填 | 说明 | 2723| -------- | -------- | -------- | -------- | 2724| value | Object | 是 | 待检测对象。 | 2725 2726**返回值：** 2727 2728| 类型 | 说明 | 2729| -------- | -------- | 2730| boolean | 判断的结果，如果是内置包含的Int32Array数组类型为true，反之为false。 | 2731 2732**示例：** 2733 2734 ```js 2735 let that = new util.types(); 2736 let result = that.isInt32Array(new Int32Array([])); 2737 ``` 2738 2739 2740### isMap<sup>8+</sup> 2741 2742isMap(value: Object): boolean 2743 2744检查输入的value是否是Map类型。 2745 2746**系统能力：** SystemCapability.Utils.Lang 2747 2748**参数：** 2749 2750| 参数名 | 类型 | 必填 | 说明 | 2751| -------- | -------- | -------- | -------- | 2752| value | Object | 是 | 待检测对象。 | 2753 2754**返回值：** 2755 2756| 类型 | 说明 | 2757| -------- | -------- | 2758| boolean | 判断的结果，如果是内置包含的Map类型为true，反之为false。 | 2759 2760**示例：** 2761 2762 ```js 2763 let that = new util.types(); 2764 let result = that.isMap(new Map()); 2765 ``` 2766 2767 2768### isMapIterator<sup>8+</sup> 2769 2770isMapIterator(value: Object): boolean 2771 2772检查输入的value是否是Map的Iterator类型。 2773 2774**系统能力：** SystemCapability.Utils.Lang 2775 2776**参数：** 2777 2778 2779| 参数名 | 类型 | 必填 | 说明 | 2780| -------- | -------- | -------- | -------- | 2781| value | Object | 是 | 待检测对象。 | 2782 2783**返回值：** 2784 2785| 类型 | 说明 | 2786| -------- | -------- | 2787| boolean | 判断的结果，如果是内置包含的Map的Iterator类型为true，反之为false。 | 2788 2789**示例：** 2790 2791 ```js 2792 let that = new util.types(); 2793 const map = new Map(); 2794 let result = that.isMapIterator(map.keys()); 2795 ``` 2796 2797 2798### isNativeError<sup>8+</sup> 2799 2800isNativeError(value: Object): boolean 2801 2802检查输入的value是否是Error类型。 2803 2804**系统能力：** SystemCapability.Utils.Lang 2805 2806**参数：** 2807 2808| 参数名 | 类型 | 必填 | 说明 | 2809| -------- | -------- | -------- | -------- | 2810| value | Object | 是 | 待检测对象。 | 2811 2812**返回值：** 2813 2814| 类型 | 说明 | 2815| -------- | -------- | 2816| boolean | 判断的结果，如果是内置包含的Error类型为true，反之为false。 | 2817 2818**示例：** 2819 2820 ```js 2821 let that = new util.types(); 2822 let result = that.isNativeError(new TypeError()); 2823 ``` 2824 2825 2826### isNumberObject<sup>8+</sup> 2827 2828isNumberObject(value: Object): boolean 2829 2830检查输入的value是否是Number对象类型。 2831 2832**系统能力：** SystemCapability.Utils.Lang 2833 2834**参数：** 2835 2836| 参数名 | 类型 | 必填 | 说明 | 2837| -------- | -------- | -------- | -------- | 2838| value | Object | 是 | 待检测对象。 | 2839 2840**返回值：** 2841 2842| 类型 | 说明 | 2843| -------- | -------- | 2844| boolean | 判断的结果，如果是内置包含的Number对象类型为true，反之为false。 | 2845 2846**示例：** 2847 2848 ```js 2849 let that = new util.types(); 2850 let result = that.isNumberObject(new Number(0)); 2851 ``` 2852 2853 2854### isPromise<sup>8+</sup> 2855 2856isPromise(value: Object): boolean 2857 2858检查输入的value是否是Promise类型。 2859 2860**系统能力：** SystemCapability.Utils.Lang 2861 2862**参数：** 2863 2864| 参数名 | 类型 | 必填 | 说明 | 2865| -------- | -------- | -------- | -------- | 2866| value | Object | 是 | 待检测对象。 | 2867 2868**返回值：** 2869 2870| 类型 | 说明 | 2871| -------- | -------- | 2872| boolean | 判断的结果，如果是内置包含的Promise类型为true，反之为false。 | 2873 2874**示例：** 2875 2876 ```js 2877 let that = new util.types(); 2878 let result = that.isPromise(Promise.resolve(1)); 2879 ``` 2880 2881 2882### isProxy<sup>8+</sup> 2883 2884isProxy(value: Object): boolean 2885 2886检查输入的value是否是Proxy类型。 2887 2888**系统能力：** SystemCapability.Utils.Lang 2889 2890**参数：** 2891 2892| 参数名 | 类型 | 必填 | 说明 | 2893| -------- | -------- | -------- | -------- | 2894| value | Object | 是 | 待检测对象。 | 2895 2896**返回值：** 2897 2898| 类型 | 说明 | 2899| -------- | -------- | 2900| boolean | 判断的结果，如果是内置包含的Proxy类型为true，反之为false。 | 2901 2902**示例：** 2903 2904 ```js 2905 let that = new util.types(); 2906 const target = {}; 2907 const proxy = new Proxy(target, {}); 2908 let result = that.isProxy(proxy); 2909 ``` 2910 2911 2912### isRegExp<sup>8+</sup> 2913 2914isRegExp(value: Object): boolean 2915 2916检查输入的value是否是RegExp类型。 2917 2918**系统能力：** SystemCapability.Utils.Lang 2919 2920**参数：** 2921 2922| 参数名 | 类型 | 必填 | 说明 | 2923| -------- | -------- | -------- | -------- | 2924| value | Object | 是 | 待检测对象。 | 2925 2926**返回值：** 2927 2928| 类型 | 说明 | 2929| -------- | -------- | 2930| boolean | 判断的结果，如果是内置包含的RegExp类型为true，反之为false。 | 2931 2932**示例：** 2933 2934 ```js 2935 let that = new util.types(); 2936 let result = that.isRegExp(new RegExp('abc')); 2937 ``` 2938 2939 2940### isSet<sup>8+</sup> 2941 2942isSet(value: Object): boolean 2943 2944检查输入的value是否是Set类型。 2945 2946**系统能力：** SystemCapability.Utils.Lang 2947 2948**参数：** 2949 2950| 参数名 | 类型 | 必填 | 说明 | 2951| -------- | -------- | -------- | -------- | 2952| value | Object | 是 | 待检测对象。 | 2953 2954**返回值：** 2955 2956| 类型 | 说明 | 2957| -------- | -------- | 2958| boolean | 判断的结果，如果是内置包含的Set类型为true，反之为false。 | 2959 2960**示例：** 2961 2962 ```js 2963 let that = new util.types(); 2964 let result = that.isSet(new Set()); 2965 ``` 2966 2967 2968### isSetIterator<sup>8+</sup> 2969 2970isSetIterator(value: Object): boolean 2971 2972检查输入的value是否是Set的Iterator类型。 2973 2974**系统能力：** SystemCapability.Utils.Lang 2975 2976**参数：** 2977 2978| 参数名 | 类型 | 必填 | 说明 | 2979| -------- | -------- | -------- | -------- | 2980| value | Object | 是 | 待检测对象。 | 2981 2982**返回值：** 2983 2984| 类型 | 说明 | 2985| -------- | -------- | 2986| boolean | 判断的结果，如果是内置包含的Set的Iterator类型为true，反之为false。 | 2987 2988**示例：** 2989 2990 ```js 2991 let that = new util.types(); 2992 const set = new Set(); 2993 let result = that.isSetIterator(set.keys()); 2994 ``` 2995 2996 2997### isStringObject<sup>8+</sup> 2998 2999isStringObject(value: Object): boolean 3000 3001检查输入的value是否是String对象类型。 3002 3003**系统能力：** SystemCapability.Utils.Lang 3004 3005**参数：** 3006 3007| 参数名 | 类型 | 必填 | 说明 | 3008| -------- | -------- | -------- | -------- | 3009| value | Object | 是 | 待检测对象。 | 3010 3011**返回值：** 3012 3013| 类型 | 说明 | 3014| -------- | -------- | 3015| boolean | 判断的结果，如果是内置包含的String对象类型为true，反之为false。 | 3016 3017**示例：** 3018 3019 ```js 3020 let that = new util.types(); 3021 let result = that.isStringObject(new String('foo')); 3022 ``` 3023 3024 3025### isSymbolObjec<sup>8+</sup> 3026 3027isSymbolObject(value: Object): boolean 3028 3029检查输入的value是否是Symbol对象类型。 3030 3031**系统能力：** SystemCapability.Utils.Lang 3032 3033**参数：** 3034 3035| 参数名 | 类型 | 必填 | 说明 | 3036| -------- | -------- | -------- | -------- | 3037| value | Object | 是 | 待检测对象。 | 3038 3039**返回值：** 3040 3041| 类型 | 说明 | 3042| -------- | -------- | 3043| boolean | 判断的结果，如果是内置包含的Symbol对象类型为true，反之为false。 | 3044 3045**示例：** 3046 3047 ```js 3048 let that = new util.types(); 3049 const symbols = Symbol('foo'); 3050 let result = that.isSymbolObject(Object(symbols)); 3051 ``` 3052 3053 3054### isTypedArray<sup>8+</sup> 3055 3056isTypedArray(value: Object): boolean 3057 3058检查输入的value是否是TypedArray类型的辅助类型。 3059 3060TypedArray类型的辅助类型，包括Int8Array、Int16Array、Int32Array、Uint8Array、Uint8ClampedArray、Uint16Array、Uint32Array、Float32Array、Float64Array、DataView。 3061 3062**系统能力：** SystemCapability.Utils.Lang 3063 3064**参数：** 3065 3066| 参数名 | 类型 | 必填 | 说明 | 3067| -------- | -------- | -------- | -------- | 3068| value | Object | 是 | 待检测对象。 | 3069 3070**返回值：** 3071 3072| 类型 | 说明 | 3073| -------- | -------- | 3074| boolean | 判断的结果，如果是内置包含的TypedArray包含的类型为true，反之为false。 | 3075 3076**示例：** 3077 3078 ```js 3079 let that = new util.types(); 3080 let result = that.isTypedArray(new Float64Array([])); 3081 ``` 3082 3083 3084### isUint8Array<sup>8+</sup> 3085 3086isUint8Array(value: Object): boolean 3087 3088检查输入的value是否是Uint8Array数组类型。 3089 3090**系统能力：** SystemCapability.Utils.Lang 3091 3092**参数：** 3093 3094| 参数名 | 类型 | 必填 | 说明 | 3095| -------- | -------- | -------- | -------- | 3096| value | Object | 是 | 待检测对象。 | 3097 3098**返回值：** 3099 3100| 类型 | 说明 | 3101| -------- | -------- | 3102| boolean | 判断的结果，如果是内置包含的Uint8Array数组类型为true，反之为false。 | 3103 3104**示例：** 3105 3106 ```js 3107 let that = new util.types(); 3108 let result = that.isUint8Array(new Uint8Array([])); 3109 ``` 3110 3111 3112### isUint8ClampedArray<sup>8+</sup> 3113 3114isUint8ClampedArray(value: Object): boolean 3115 3116检查输入的value是否是Uint8ClampedArray数组类型。 3117 3118**系统能力：** SystemCapability.Utils.Lang 3119 3120**参数：** 3121 3122| 参数名 | 类型 | 必填 | 说明 | 3123| -------- | -------- | -------- | -------- | 3124| value | Object | 是 | 待检测对象。 | 3125 3126**返回值：** 3127 3128| 类型 | 说明 | 3129| -------- | -------- | 3130| boolean | 判断的结果，如果是内置包含的Uint8ClampedArray数组类型为true，反之为false。 | 3131 3132**示例：** 3133 3134 ```js 3135 let that = new util.types(); 3136 let result = that.isUint8ClampedArray(new Uint8ClampedArray([])); 3137 ``` 3138 3139 3140### isUint16Array<sup>8+</sup> 3141 3142isUint16Array(value: Object): boolean 3143 3144检查输入的value是否是Uint16Array数组类型。 3145 3146**系统能力：** SystemCapability.Utils.Lang 3147 3148**参数：** 3149 3150| 参数名 | 类型 | 必填 | 说明 | 3151| -------- | -------- | -------- | -------- | 3152| value | Object | 是 | 待检测对象。 | 3153 3154**返回值：** 3155 3156| 类型 | 说明 | 3157| -------- | -------- | 3158| boolean | 判断的结果，如果是内置包含的Uint16Array数组类型为true，反之为false。 | 3159 3160**示例：** 3161 3162 ```js 3163 let that = new util.types(); 3164 let result = that.isUint16Array(new Uint16Array([])); 3165 ``` 3166 3167 3168### isUint32Array<sup>8+</sup> 3169 3170isUint32Array(value: Object): boolean 3171 3172检查输入的value是否是Uint32Array数组类型。 3173 3174**系统能力：** SystemCapability.Utils.Lang 3175 3176**参数：** 3177 3178| 参数名 | 类型 | 必填 | 说明 | 3179| -------- | -------- | -------- | -------- | 3180| value | Object | 是 | 待检测对象。 | 3181 3182**返回值：** 3183 3184| 类型 | 说明 | 3185| -------- | -------- | 3186| boolean | 判断的结果，如果是内置包含的Uint32Array数组类型为true，反之为false。 | 3187 3188**示例：** 3189 3190 ```js 3191 let that = new util.types(); 3192 let result = that.isUint32Array(new Uint32Array([])); 3193 ``` 3194 3195 3196### isWeakMap<sup>8+</sup> 3197 3198isWeakMap(value: Object): boolean 3199 3200检查输入的value是否是WeakMap类型。 3201 3202**系统能力：** SystemCapability.Utils.Lang 3203 3204**参数：** 3205 3206| 参数名 | 类型 | 必填 | 说明 | 3207| -------- | -------- | -------- | -------- | 3208| value | Object | 是 | 待检测对象。 | 3209 3210**返回值：** 3211 3212| 类型 | 说明 | 3213| -------- | -------- | 3214| boolean | 判断的结果，如果是内置包含的WeakMap类型为true，反之为false。 | 3215 3216**示例：** 3217 3218 ```js 3219 let that = new util.types(); 3220 let result = that.isWeakMap(new WeakMap()); 3221 ``` 3222 3223 3224### isWeakSet<sup>8+</sup> 3225 3226isWeakSet(value: Object): boolean 3227 3228检查输入的value是否是WeakSet类型。 3229 3230**系统能力：** SystemCapability.Utils.Lang 3231 3232**参数：** 3233 3234| 参数名 | 类型 | 必填 | 说明 | 3235| -------- | -------- | -------- | -------- | 3236| value | Object | 是 | 待检测对象。 | 3237 3238**返回值：** 3239 3240| 类型 | 说明 | 3241| -------- | -------- | 3242| boolean | 判断的结果，如果是内置包含的WeakSet类型为true，反之为false。 | 3243 3244**示例：** 3245 3246 ```js 3247 let that = new util.types(); 3248 let result = that.isWeakSet(new WeakSet()); 3249 ``` 3250 3251 3252### isBigInt64Array<sup>8+</sup> 3253 3254isBigInt64Array(value: Object): boolean 3255 3256检查输入的value是否是BigInt64Array类型。 3257 3258**系统能力：** SystemCapability.Utils.Lang 3259 3260**参数：** 3261 3262| 参数名 | 类型 | 必填 | 说明 | 3263| -------- | -------- | -------- | -------- | 3264| value | Object | 是 | 待检测对象。 | 3265 3266**返回值：** 3267 3268| 类型 | 说明 | 3269| -------- | -------- | 3270| boolean | 判断的结果，如果是内置包含的BigInt64Array类型为true，反之为false。 | 3271 3272**示例：** 3273 3274 ```js 3275 let that = new util.types(); 3276 let result = that.isBigInt64Array(new BigInt64Array([])); 3277 ``` 3278 3279 3280### isBigUint64Array<sup>8+</sup> 3281 3282isBigUint64Array(value: Object): boolean 3283 3284检查输入的value是否是BigUint64Array类型。 3285 3286**系统能力：** SystemCapability.Utils.Lang 3287 3288**参数：** 3289 3290| 参数名 | 类型 | 必填 | 说明 | 3291| -------- | -------- | -------- | -------- | 3292| value | Object | 是 | 待检测对象。 | 3293 3294**返回值：** 3295 3296| 类型 | 说明 | 3297| -------- | -------- | 3298| boolean | 判断的结果，如果是内置包含的BigUint64Array类型为true，反之为false。 | 3299 3300**示例：** 3301 3302 ```js 3303 let that = new util.types(); 3304 let result = that.isBigUint64Array(new BigUint64Array([])); 3305 ``` 3306 3307 3308### isModuleNamespaceObject<sup>8+</sup> 3309 3310isModuleNamespaceObject(value: Object): boolean 3311 3312检查输入的value是否是Module Namespace Object类型。 3313 3314**系统能力：** SystemCapability.Utils.Lang 3315 3316**参数：** 3317 3318| 参数名 | 类型 | 必填 | 说明 | 3319| -------- | -------- | -------- | -------- | 3320| value | Object | 是 | 待检测对象。 | 3321 3322**返回值：** 3323 3324| 类型 | 说明 | 3325| -------- | -------- | 3326| boolean | 判断的结果，如果是内置包含的Module Namespace Object类型为true，反之为false。 | 3327 3328**示例：** 3329 3330 ```js 3331 import url from '@ohos.url' 3332 let that = new util.types(); 3333 let result = that.isModuleNamespaceObject(url); 3334 ``` 3335 3336 3337### isSharedArrayBuffer<sup>8+</sup> 3338 3339isSharedArrayBuffer(value: Object): boolean 3340 3341检查输入的value是否是SharedArrayBuffer类型。 3342 3343**系统能力：** SystemCapability.Utils.Lang 3344 3345**参数：** 3346 3347| 参数名 | 类型 | 必填 | 说明 | 3348| -------- | -------- | -------- | -------- | 3349| value | Object | 是 | 待检测对象。 | 3350 3351**返回值：** 3352 3353| 类型 | 说明 | 3354| -------- | -------- | 3355| boolean | 判断的结果，如果是内置包含的SharedArrayBuffer类型为true，反之为false。 | 3356 3357**示例：** 3358 3359 ```js 3360 let that = new util.types(); 3361 let result = that.isSharedArrayBuffer(new SharedArrayBuffer(0)); 3362 ``` 3363 3364## LruBuffer<sup>(deprecated)</sup> 3365 3366> **说明：** 3367> 3368> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache<sup>9+</sup>](#lrucache9)替代。 3369 3370### 属性 3371 3372**系统能力：** 以下各项对应的系统能力均为SystemCapability.Utils.Lang。 3373 3374| 名称 | 类型 | 可读 | 可写 | 说明 | 3375| -------- | -------- | -------- | -------- | -------- | 3376| length | number | 是 | 否 | 当前缓冲区中值的总数。 | 3377 3378**示例：** 3379 3380 ```js 3381 let pro = new util.LruBuffer(); 3382 pro.put(2,10); 3383 pro.put(1,8); 3384 let result = pro.length; 3385 ``` 3386 3387### constructor<sup>(deprecated)</sup> 3388 3389constructor(capacity?: number) 3390 3391默认构造函数用于创建一个新的LruBuffer实例，默认容量为64。 3392 3393> **说明：** 3394> 3395> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.constructor<sup>9+</sup>](#constructor9-3)替代。 3396 3397**系统能力：** SystemCapability.Utils.Lang 3398 3399**参数：** 3400 3401| 参数名 | 类型 | 必填 | 说明 | 3402| -------- | -------- | -------- | -------- | 3403| capacity | number | 否 | 指示要为缓冲区自定义的容量。 | 3404 3405**示例：** 3406 3407 ```js 3408 let lrubuffer= new util.LruBuffer(); 3409 ``` 3410 3411### updateCapacity<sup>(deprecated)</sup> 3412 3413updateCapacity(newCapacity: number): void 3414 3415将缓冲区容量更新为指定容量，如果newCapacity小于或等于0，则抛出异常。 3416 3417> **说明：** 3418> 3419> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.updateCapacity<sup>9+</sup>](#updatecapacity9)替代。 3420 3421**系统能力：** SystemCapability.Utils.Lang 3422 3423**参数：** 3424 3425| 参数名 | 类型 | 必填 | 说明 | 3426| -------- | -------- | -------- | -------- | 3427| newCapacity | number | 是 | 指示要为缓冲区自定义的容量。 | 3428 3429**示例：** 3430 3431 ```js 3432 let pro = new util.LruBuffer(); 3433 let result = pro.updateCapacity(100); 3434 ``` 3435 3436### toString<sup>(deprecated)</sup> 3437 3438toString(): string 3439 3440返回对象的字符串表示形式。 3441 3442> **说明：** 3443> 3444> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.toString<sup>9+</sup>](#tostring9)替代。 3445 3446**系统能力：** SystemCapability.Utils.Lang 3447 3448**返回值：** 3449 3450| 类型 | 说明 | 3451| -------- | -------- | 3452| string | 返回对象的字符串表示形式。 | 3453 3454**示例：** 3455 3456 ```js 3457 let pro = new util.LruBuffer(); 3458 pro.put(2,10); 3459 pro.get(2); 3460 pro.remove(20); 3461 let result = pro.toString(); 3462 ``` 3463 3464### getCapacity<sup>(deprecated)</sup> 3465 3466getCapacity(): number 3467 3468获取当前缓冲区的容量。 3469 3470> **说明：** 3471> 3472> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getCapacity<sup>9+</sup>](#getcapacity9)替代。 3473 3474**系统能力：** SystemCapability.Utils.Lang 3475 3476**返回值：** 3477 3478| 类型 | 说明 | 3479| -------- | -------- | 3480| number | 返回当前缓冲区的容量。 | 3481 3482**示例：** 3483 ```js 3484 let pro = new util.LruBuffer(); 3485 let result = pro.getCapacity(); 3486 ``` 3487 3488### clear<sup>(deprecated)</sup> 3489 3490clear(): void 3491 3492从当前缓冲区清除键值对。后续会调用afterRemoval()方法执行后续操作。 3493 3494> **说明：** 3495> 3496> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.clear<sup>9+</sup>](#clear9)替代。 3497 3498**系统能力：** SystemCapability.Utils.Lang 3499 3500**示例：** 3501 3502 ```js 3503 let pro = new util.LruBuffer(); 3504 pro.put(2,10); 3505 let result = pro.length; 3506 pro.clear(); 3507 ``` 3508 3509### getCreateCount<sup>(deprecated)</sup> 3510 3511getCreateCount(): number 3512 3513获取createDefault()返回值的次数。 3514 3515> **说明：** 3516> 3517> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getCreateCount<sup>9+</sup>](#getcreatecount9)替代。 3518 3519**系统能力：** SystemCapability.Utils.Lang 3520 3521**返回值：** 3522 3523| 类型 | 说明 | 3524| -------- | -------- | 3525| number | 返回createDefault()返回值的次数。 | 3526 3527**示例：** 3528 3529 ```js 3530 let pro = new util.LruBuffer(); 3531 pro.put(1,8); 3532 let result = pro.getCreateCount(); 3533 ``` 3534 3535### getMissCount<sup>(deprecated)</sup> 3536 3537getMissCount(): number 3538 3539获取查询值不匹配的次数。 3540 3541> **说明：** 3542> 3543> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getMissCount<sup>9+</sup>](#getmisscount9)替代。 3544 3545**系统能力：** SystemCapability.Utils.Lang 3546 3547**返回值：** 3548 3549| 类型 | 说明 | 3550| -------- | -------- | 3551| number | 返回查询值不匹配的次数。 | 3552 3553**示例：** 3554 3555 ```js 3556 let pro = new util.LruBuffer(); 3557 pro.put(2,10); 3558 pro.get(2); 3559 let result = pro.getMissCount(); 3560 ``` 3561 3562### getRemovalCount<sup>(deprecated)</sup> 3563 3564getRemovalCount(): number 3565 3566获取从缓冲区中逐出值的次数。 3567 3568> **说明：** 3569> 3570> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getRemovalCount<sup>9+</sup>](#getremovalcount9)替代。 3571 3572**系统能力：** SystemCapability.Utils.Lang 3573 3574**返回值：** 3575 3576| 类型 | 说明 | 3577| -------- | -------- | 3578| number | 返回从缓冲区中驱逐的次数。 | 3579 3580**示例：** 3581 3582 ```js 3583 let pro = new util.LruBuffer(); 3584 pro.put(2,10); 3585 pro.updateCapacity(2); 3586 pro.put(50,22); 3587 let result = pro.getRemovalCount(); 3588 ``` 3589 3590### getMatchCount<sup>(deprecated)</sup> 3591 3592getMatchCount(): number 3593 3594获取查询值匹配成功的次数。 3595 3596> **说明：** 3597> 3598> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getMatchCount<sup>9+</sup>](#getmatchcount9)替代。 3599 3600**系统能力：** SystemCapability.Utils.Lang 3601 3602**返回值：** 3603 3604| 类型 | 说明 | 3605| -------- | -------- | 3606| number | 返回查询值匹配成功的次数。 | 3607 3608**示例：** 3609 3610 ```js 3611 let pro = new util.LruBuffer(); 3612 pro.put(2,10); 3613 pro.get(2); 3614 let result = pro.getMatchCount(); 3615 ``` 3616 3617### getPutCount<sup>(deprecated)</sup> 3618 3619getPutCount(): number 3620 3621获取将值添加到缓冲区的次数。 3622 3623> **说明：** 3624> 3625> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.getPutCount<sup>9+</sup>](#getputcount9)替代。 3626 3627**系统能力：** SystemCapability.Utils.Lang 3628 3629**返回值：** 3630 3631| 类型 | 说明 | 3632| -------- | -------- | 3633| number | 返回将值添加到缓冲区的次数。 | 3634 3635**示例：** 3636 3637 ```js 3638 let pro = new util.LruBuffer(); 3639 pro.put(2,10); 3640 let result = pro.getPutCount(); 3641 ``` 3642 3643### isEmpty<sup>(deprecated)</sup> 3644 3645isEmpty(): boolean 3646 3647检查当前缓冲区是否为空。 3648 3649> **说明：** 3650> 3651> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.isEmpty<sup>9+</sup>](#isempty9)替代。 3652 3653**系统能力：** SystemCapability.Utils.Lang 3654 3655**返回值：** 3656 3657| 类型 | 说明 | 3658| -------- | -------- | 3659| boolean | 如果当前缓冲区不包含任何值，则返回true。 | 3660 3661**示例：** 3662 3663 ```js 3664 let pro = new util.LruBuffer(); 3665 pro.put(2,10); 3666 let result = pro.isEmpty(); 3667 ``` 3668 3669### get<sup>(deprecated)</sup> 3670 3671get(key: K): V | undefined 3672 3673表示要查询的键。 3674 3675> **说明：** 3676> 3677> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.get<sup>9+</sup>](#get9)替代。 3678 3679**系统能力：** SystemCapability.Utils.Lang 3680 3681**参数：** 3682 3683| 参数名 | 类型 | 必填 | 说明 | 3684| -------- | -------- | -------- | -------- | 3685| key | K | 是 | 要查询的键。 | 3686 3687**返回值：** 3688 3689| 类型 | 说明 | 3690| -------- | -------- | 3691| V \| undefined | 如果指定的键存在于缓冲区中，则返回与键关联的值；否则返回undefined。 | 3692 3693**示例：** 3694 3695 ```js 3696 let pro = new util.LruBuffer(); 3697 pro.put(2,10); 3698 let result = pro.get(2); 3699 ``` 3700 3701### put<sup>(deprecated)</sup> 3702 3703put(key: K,value: V): V 3704 3705将键值对添加到缓冲区。 3706 3707> **说明：** 3708> 3709> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.put<sup>9+</sup>](#put9)替代。 3710 3711**系统能力：** SystemCapability.Utils.Lang 3712 3713**参数：** 3714 3715| 参数名 | 类型 | 必填 | 说明 | 3716| -------- | -------- | -------- | -------- | 3717| key | K | 是 | 要添加的密钥。 | 3718| value | V | 是 | 指示与要添加的键关联的值。 | 3719 3720**返回值：** 3721 3722| 类型 | 说明 | 3723| -------- | -------- | 3724| V | 返回与添加的键关联的值；如果要添加的键已经存在，则返回原始值，如果键或值为空，则抛出此异常。 | 3725 3726**示例：** 3727 3728 ```js 3729 let pro = new util.LruBuffer(); 3730 let result = pro.put(2,10); 3731 ``` 3732 3733### values<sup>(deprecated)</sup> 3734 3735values(): V[] 3736 3737获取当前缓冲区中所有值从最近访问到最近最少访问的顺序列表。 3738 3739> **说明：** 3740> 3741> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.values<sup>9+</sup>](#values9)替代。 3742 3743**系统能力：** SystemCapability.Utils.Lang 3744 3745**返回值：** 3746 3747| 类型 | 说明 | 3748| -------- | -------- | 3749| V [] | 按从最近访问到最近最少访问的顺序返回当前缓冲区中所有值的列表。 | 3750 3751**示例：** 3752 3753 ```js 3754 let pro = new util.LruBuffer(); 3755 pro.put(2,10); 3756 pro.put(2,"anhu"); 3757 pro.put("afaf","grfb"); 3758 let result = pro.values(); 3759 ``` 3760 3761### keys<sup>(deprecated)</sup> 3762 3763keys(): K[] 3764 3765获取当前缓冲区中所有键从最近访问到最近最少访问的升序列表。 3766 3767> **说明：** 3768> 3769> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.keys<sup>9+</sup>](#keys9)替代。 3770 3771**系统能力：** SystemCapability.Utils.Lang 3772 3773**返回值：** 3774 3775| 类型 | 说明 | 3776| -------- | -------- | 3777| K [] | 按升序返回当前缓冲区中所有键的列表，从最近访问到最近最少访问。 | 3778 3779**示例：** 3780 3781 ```js 3782 let pro = new util.LruBuffer(); 3783 pro.put(2,10); 3784 let result = pro.keys(); 3785 ``` 3786 3787### remove<sup>(deprecated)</sup> 3788 3789remove(key: K): V | undefined 3790 3791从当前缓冲区中删除指定的键及其关联的值。 3792 3793> **说明：** 3794> 3795> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.remove<sup>9+</sup>](#remove9)替代。 3796 3797**系统能力：** SystemCapability.Utils.Lang 3798 3799**参数：** 3800 3801| 参数名 | 类型 | 必填 | 说明 | 3802| -------- | -------- | -------- | -------- | 3803| key | K | 是 | 要删除的密钥。 | 3804 3805**返回值：** 3806 3807| 类型 | 说明 | 3808| -------- | -------- | 3809| V \| undefined | 返回一个包含已删除键值对的Optional对象；如果key不存在，则返回一个空的Optional对象，如果key为null，则抛出异常。 | 3810 3811**示例：** 3812 ```js 3813 let pro = new util.LruBuffer(); 3814 pro.put(2,10); 3815 let result = pro.remove(20); 3816 ``` 3817 3818### afterRemoval<sup>(deprecated)</sup> 3819 3820afterRemoval(isEvict: boolean,key: K,value: V,newValue: V): void 3821 3822删除值后执行后续操作。 3823 3824> **说明：** 3825> 3826> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.afterRemoval<sup>9+</sup>](#afterremoval9)替代。 3827 3828**系统能力：** SystemCapability.Utils.Lang 3829 3830**参数：** 3831 3832| 参数名 | 类型 | 必填 | 说明 | 3833| -------- | -------- | -------- | -------- | 3834| isEvict | boolean | 是 | 因容量不足而调用该方法时，参数值为true，其他情况为false。 | 3835| key | K | 是 | 表示删除的键。 | 3836| value | V | 是 | 表示删除的值。 | 3837| newValue | V | 是 | 如果已调用put方法并且要添加的键已经存在，则参数值是关联的新值。其他情况下参数值为空。 | 3838 3839**示例：** 3840 3841 ```js 3842 let arr = []; 3843 class ChildLruBuffer<K, V> extends util.LruBuffer<K, V> 3844 { 3845 constructor() 3846 { 3847 super(); 3848 } 3849 afterRemoval(isEvict, key, value, newValue) 3850 { 3851 if (isEvict === false) 3852 { 3853 arr = [key, value, newValue]; 3854 } 3855 } 3856 } 3857 let lru = new ChildLruBuffer(); 3858 lru.afterRemoval(false,10,30,null); 3859 ``` 3860 3861### contains<sup>(deprecated)</sup> 3862 3863contains(key: K): boolean 3864 3865检查当前缓冲区是否包含指定的键。 3866 3867 3868> **说明：** 3869> 3870> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.contains<sup>9+</sup>](#contains9)替代。 3871 3872**系统能力：** SystemCapability.Utils.Lang 3873 3874**参数：** 3875 3876| 参数名 | 类型 | 必填 | 说明 | 3877| -------- | -------- | -------- | -------- | 3878| key | K | 是 | 表示要检查的键。 | 3879 3880**返回值：** 3881 3882| 类型 | 说明 | 3883| -------- | -------- | 3884| boolean | 如果缓冲区包含指定的键，则返回 true。 | 3885 3886**示例：** 3887 3888 ```js 3889 let pro = new util.LruBuffer(); 3890 pro.put(2,10); 3891 let result = pro.contains(20); 3892 ``` 3893 3894### createDefault<sup>(deprecated)</sup> 3895 3896createDefault(key: K): V 3897 3898如果未计算特定键的值，则执行后续操作，参数表示丢失的键，返回与键关联的值。 3899 3900> **说明：** 3901> 3902> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.createDefault<sup>9+</sup>](#createdefault9)替代。 3903 3904**系统能力：** SystemCapability.Utils.Lang 3905 3906**参数：** 3907 3908| 参数名 | 类型 | 必填 | 说明 | 3909| -------- | -------- | -------- | -------- | 3910| key | K | 是 | 表示丢失的键。 | 3911 3912**返回值：** 3913 3914| 类型 | 说明 | 3915| -------- | -------- | 3916| V | 返回与键关联的值。 | 3917 3918**示例：** 3919 3920 ```js 3921 let pro = new util.LruBuffer(); 3922 let result = pro.createDefault(50); 3923 ``` 3924 3925### entries<sup>(deprecated)</sup> 3926 3927entries(): IterableIterator<[K,V]> 3928 3929允许迭代包含在这个对象中的所有键值对。 3930 3931> **说明：** 3932> 3933> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.entries<sup>9+</sup>](#entries9)替代。 3934 3935**系统能力：** SystemCapability.Utils.Lang 3936 3937**返回值：** 3938 3939| 类型 | 说明 | 3940| -------- | -------- | 3941| [K, V] | 返回一个可迭代数组。 | 3942 3943**示例：** 3944 3945 ```js 3946 let pro = new util.LruBuffer(); 3947 pro.put(2,10); 3948 let result = pro.entries(); 3949 ``` 3950 3951### [Symbol.iterator]<sup>(deprecated)</sup> 3952 3953[Symbol.iterator]\(): IterableIterator<[K, V]> 3954 3955返回一个键值对形式的二维数组。 3956 3957> **说明：** 3958> 3959> 从API version 8开始支持，从API version 9开始废弃，建议使用[LRUCache.Symbol.iterator<sup>9+</sup>](#symboliterator9)替代。 3960 3961**系统能力：** SystemCapability.Utils.Lang 3962 3963**返回值：** 3964 3965| 类型 | 说明 | 3966| -------- | -------- | 3967| [K, V] | 返回一个键值对形式的二维数组。 | 3968 3969**示例：** 3970 3971 ```js 3972 let pro = new util.LruBuffer(); 3973 pro.put(2,10); 3974 let result = pro[Symbol.iterator](); 3975 ``` 3976 3977## Scope<sup>(deprecated)</sup> 3978 3979> **说明：** 3980> 3981> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper<sup>9+</sup>](#scopehelper9)替代。 3982 3983### constructor<sup>(deprecated)</sup> 3984 3985constructor(lowerObj: ScopeType, upperObj: ScopeType) 3986 3987用于创建指定下限和上限的作用域实例的构造函数，返回一个Scope对象。 3988 3989> **说明：** 3990> 3991> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.constructor<sup>9+</sup>](#constructor9-4)替代。 3992 3993 3994**系统能力：** SystemCapability.Utils.Lang 3995 3996**参数：** 3997 3998| 参数名 | 类型 | 必填 | 说明 | 3999| -------- | -------- | -------- | -------- | 4000| lowerObj | [ScopeType](#scopetype8) | 是 | 指定作用域实例的下限。 | 4001| upperObj | [ScopeType](#scopetype8) | 是 | 指定作用域实例的上限。 | 4002 4003**示例：** 4004 ```js 4005 let tempLower = new Temperature(30); 4006 let tempUpper = new Temperature(40); 4007 let range = new util.Scope(tempLower, tempUpper); 4008 ``` 4009 4010### toString<sup>(deprecated)</sup> 4011 4012toString(): string 4013 4014该字符串化方法返回一个包含当前范围的字符串表示形式。 4015 4016> **说明：** 4017> 4018> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.toString<sup>9+</sup>](#tostring9-1)替代。 4019 4020**系统能力：** SystemCapability.Utils.Lang 4021 4022**返回值：** 4023 4024| 类型 | 说明 | 4025| -------- | -------- | 4026| string | 返回包含当前范围对象的字符串表示形式。 | 4027 4028**示例：** 4029 4030 ```js 4031 let tempLower = new Temperature(30); 4032 let tempUpper = new Temperature(40); 4033 let range = new util.Scope(tempLower, tempUpper); 4034 let result = range.toString(); 4035 ``` 4036 4037### intersect<sup>(deprecated)</sup> 4038 4039intersect(range: Scope): Scope 4040 4041获取给定范围和当前范围的交集。 4042 4043> **说明：** 4044> 4045> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.intersect<sup>9+</sup>](#intersect9)替代。 4046 4047**系统能力：** SystemCapability.Utils.Lang 4048 4049**参数：** 4050 4051| 参数名 | 类型 | 必填 | 说明 | 4052| -------- | -------- | -------- | -------- | 4053| range | [Scope](#scopedeprecated) | 是 | 传入一个给定范围。 | 4054 4055**返回值：** 4056 4057| 类型 | 说明 | 4058| -------- | -------- | 4059| [Scope](#scopedeprecated) | 返回给定范围和当前范围的交集。 | 4060 4061**示例：** 4062 4063 ```js 4064 let tempLower = new Temperature(30); 4065 let tempUpper = new Temperature(40); 4066 let range = new util.Scope(tempLower, tempUpper); 4067 let tempMiDF = new Temperature(35); 4068 let tempMidS = new Temperature(39); 4069 let rangeFir = new util.Scope(tempMiDF, tempMidS); 4070 range.intersect(rangeFir ); 4071 ``` 4072 4073### intersect<sup>(deprecated)</sup> 4074 4075intersect(lowerObj:ScopeType,upperObj:ScopeType):Scope 4076 4077获取当前范围与给定下限和上限范围的交集。 4078 4079> **说明：** 4080> 4081> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.intersect<sup>9+</sup>](#intersect9-1)替代。 4082 4083**系统能力：** SystemCapability.Utils.Lang 4084 4085**参数：** 4086 4087| 参数名 | 类型 | 必填 | 说明 | 4088| -------- | -------- | -------- | -------- | 4089| lowerObj | [ScopeType](#scopetype8) | 是 | 给定范围的下限。 | 4090| upperObj | [ScopeType](#scopetype8) | 是 | 给定范围的上限。 | 4091 4092**返回值：** 4093 4094| 类型 | 说明 | 4095| -------- | -------- | 4096| [Scope](#scopedeprecated) | 返回当前范围与给定下限和上限范围的交集。 | 4097 4098**示例：** 4099 4100 ```js 4101 let tempLower = new Temperature(30); 4102 let tempUpper = new Temperature(40); 4103 let tempMiDF = new Temperature(35); 4104 let tempMidS = new Temperature(39); 4105 let range = new util.Scope(tempLower, tempUpper); 4106 let result = range.intersect(tempMiDF, tempMidS); 4107 ``` 4108 4109### getUpper<sup>(deprecated)</sup> 4110 4111getUpper(): ScopeType 4112 4113获取当前范围的上限。 4114 4115> **说明：** 4116> 4117> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.getUpper<sup>9+</sup>](#getupper9)替代。 4118 4119**系统能力：** SystemCapability.Utils.Lang 4120 4121**返回值：** 4122 4123| 类型 | 说明 | 4124| -------- | -------- | 4125| [ScopeType](#scopetype8) | 返回当前范围的上限值。 | 4126 4127**示例：** 4128 4129 ```js 4130 let tempLower = new Temperature(30); 4131 let tempUpper = new Temperature(40); 4132 let range = new util.Scope(tempLower, tempUpper); 4133 let result = range.getUpper(); 4134 ``` 4135 4136### getLower<sup>(deprecated)</sup> 4137 4138getLower(): ScopeType 4139 4140获取当前范围的下限。 4141 4142> **说明：** 4143> 4144> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.getLower<sup>9+</sup>](#getlower9)替代。 4145 4146**系统能力：** SystemCapability.Utils.Lang 4147 4148**返回值：** 4149 4150| 类型 | 说明 | 4151| -------- | -------- | 4152| [ScopeType](#scopetype8) | 返回当前范围的下限值。 | 4153 4154**示例：** 4155 4156 ```js 4157 let tempLower = new Temperature(30); 4158 let tempUpper = new Temperature(40); 4159 let range = new util.Scope(tempLower, tempUpper); 4160 let result = range.getLower(); 4161 ``` 4162 4163### expand<sup>(deprecated)</sup> 4164 4165expand(lowerObj: ScopeType,upperObj: ScopeType): Scope 4166 4167创建并返回包括当前范围和给定下限和上限的并集。 4168 4169> **说明：** 4170> 4171> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.expand<sup>9+</sup>](#expand9)替代。 4172 4173**系统能力：** SystemCapability.Utils.Lang 4174 4175**参数：** 4176 4177| 参数名 | 类型 | 必填 | 说明 | 4178| -------- | -------- | -------- | -------- | 4179| lowerObj | [ScopeType](#scopetype8) | 是 | 给定范围的下限。 | 4180| upperObj | [ScopeType](#scopetype8) | 是 | 给定范围的上限。 | 4181 4182**返回值：** 4183 4184| 类型 | 说明 | 4185| -------- | -------- | 4186| [Scope](#scopedeprecated) | 返回当前范围和给定下限和上限的并集。 | 4187 4188**示例：** 4189 4190 ```js 4191 let tempLower = new Temperature(30); 4192 let tempUpper = new Temperature(40); 4193 let tempMiDF = new Temperature(35); 4194 let tempMidS = new Temperature(39); 4195 let range = new util.Scope(tempLower, tempUpper); 4196 let result = range.expand(tempMiDF, tempMidS); 4197 ``` 4198 4199### expand<sup>(deprecated)</sup> 4200 4201expand(range: Scope): Scope 4202 4203创建并返回包括当前范围和给定范围的并集。 4204 4205> **说明：** 4206> 4207> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.expand<sup>9+</sup>](#expand9-1)替代。 4208 4209**系统能力：** SystemCapability.Utils.Lang 4210 4211**参数：** 4212 4213| 参数名 | 类型 | 必填 | 说明 | 4214| -------- | -------- | -------- | -------- | 4215| range | [Scope](#scopedeprecated) | 是 | 传入一个给定范围。 | 4216 4217**返回值：** 4218 4219| 类型 | 说明 | 4220| -------- | -------- | 4221| [Scope](#scopedeprecated) | 返回包括当前范围和给定范围的并集。 | 4222 4223**示例：** 4224 4225 ```js 4226 let tempLower = new Temperature(30); 4227 let tempUpper = new Temperature(40); 4228 let tempMiDF = new Temperature(35); 4229 let tempMidS = new Temperature(39); 4230 let range = new util.Scope(tempLower, tempUpper); 4231 let rangeFir = new util.Scope(tempMiDF, tempMidS); 4232 let result = range.expand(rangeFir); 4233 ``` 4234 4235### expand<sup>(deprecated)</sup> 4236 4237expand(value: ScopeType): Scope 4238 4239创建并返回包括当前范围和给定值的并集。 4240 4241> **说明：** 4242> 4243> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.expand<sup>9+</sup>](#expand9-2)替代。 4244 4245**系统能力：** SystemCapability.Utils.Lang 4246 4247**参数：** 4248 4249| 参数名 | 类型 | 必填 | 说明 | 4250| -------- | -------- | -------- | -------- | 4251| value | [ScopeType](#scopetype8) | 是 | 传入一个给定值。 | 4252 4253**返回值：** 4254 4255| 类型 | 说明 | 4256| -------- | -------- | 4257| [Scope](#scopedeprecated) | 返回包括当前范围和给定值的并集。 | 4258 4259**示例：** 4260 4261 ```js 4262 let tempLower = new Temperature(30); 4263 let tempUpper = new Temperature(40); 4264 let tempMiDF = new Temperature(35); 4265 let range = new util.Scope(tempLower, tempUpper); 4266 let result = range.expand(tempMiDF); 4267 ``` 4268 4269### contains<sup>(deprecated)</sup> 4270 4271contains(value: ScopeType): boolean 4272 4273检查给定value是否包含在当前范围内。 4274 4275> **说明：** 4276> 4277> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.contains<sup>9+</sup>](#contains9-1)替代。 4278 4279**系统能力：** SystemCapability.Utils.Lang 4280 4281**参数：** 4282 4283| 参数名 | 类型 | 必填 | 说明 | 4284| -------- | -------- | -------- | -------- | 4285| value | [ScopeType](#scopetype8) | 是 | 传入一个给定值。 | 4286 4287**返回值：** 4288 4289| 类型 | 说明 | 4290| -------- | -------- | 4291| boolean | 如果给定值包含在当前范围内返回true，否则返回false。 | 4292 4293**示例：** 4294 4295 ```js 4296 let tempLower = new Temperature(30); 4297 let tempUpper = new Temperature(40); 4298 let tempMiDF = new Temperature(35); 4299 let range = new util.Scope(tempLower, tempUpper); 4300 range.contains(tempMiDF); 4301 ``` 4302 4303### contains<sup>(deprecated)</sup> 4304 4305contains(range: Scope): boolean 4306 4307检查给定range是否在当前范围内。 4308 4309> **说明：** 4310> 4311> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.contains<sup>9+</sup>](#contains9-2)替代。 4312 4313**系统能力：** SystemCapability.Utils.Lang 4314 4315**参数：** 4316 4317| 参数名 | 类型 | 必填 | 说明 | 4318| -------- | -------- | -------- | -------- | 4319| range | [Scope](#scopedeprecated) | 是 | 传入一个给定范围。 | 4320 4321**返回值：** 4322 4323| 类型 | 说明 | 4324| -------- | -------- | 4325| boolean | 如果给定范围包含在当前范围内返回true，否则返回false。 | 4326 4327**示例：** 4328 4329 ```js 4330 let tempLower = new Temperature(30); 4331 let tempUpper = new Temperature(40); 4332 let range = new util.Scope(tempLower, tempUpper); 4333 let tempLess = new Temperature(20); 4334 let tempMore = new Temperature(45); 4335 let rangeSec = new util.Scope(tempLess, tempMore); 4336 let result = range.contains(rangeSec); 4337 ``` 4338 4339### clamp<sup>(deprecated)</sup> 4340 4341 4342clamp(value: ScopeType): ScopeType 4343 4344将给定值限定到当前范围内。 4345 4346> **说明：** 4347> 4348> 从API version 8开始支持，从API version 9开始废弃，建议使用[ScopeHelper.clamp<sup>9+</sup>](#clamp9)替代。 4349 4350**系统能力：** SystemCapability.Utils.Lang 4351 4352**参数：** 4353 4354| 参数名 | 类型 | 必填 | 说明 | 4355| -------- | -------- | -------- | -------- | 4356| value | [ScopeType](#scopetype8) | 是 | 传入的给定值。 | 4357 4358**返回值：** 4359 4360| 类型 | 说明 | 4361| -------- | -------- | 4362| [ScopeType](#scopetype8) | 如果传入的value小于下限，则返回lowerObj；如果大于上限值则返回upperObj；如果在当前范围内，则返回value。 | 4363 4364**示例：** 4365 4366 ```js 4367 let tempLower = new Temperature(30); 4368 let tempUpper = new Temperature(40); 4369 let tempMiDF = new Temperature(35); 4370 let range = new util.Scope(tempLower, tempUpper); 4371 let result = range.clamp(tempMiDF); 4372 ``` 4373 4374 4375## Base64<sup>(deprecated)</sup> 4376 4377> **说明：** 4378> 4379> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper<sup>9+</sup>](#base64helper9)替代。 4380 4381### constructor<sup>(deprecated)</sup> 4382 4383constructor() 4384 4385Base64的构造函数。 4386 4387> **说明：** 4388> 4389> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.constructor<sup>9+</sup>](#constructor9-5)替代。 4390 4391**系统能力：** SystemCapability.Utils.Lang 4392 4393**示例：** 4394 4395 ```js 4396 let base64 = new util.Base64(); 4397 ``` 4398 4399### encodeSync<sup>(deprecated)</sup> 4400 4401encodeSync(src: Uint8Array): Uint8Array 4402 4403通过输入参数编码后输出对应文本。 4404 4405> **说明：** 4406> 4407> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encodeSync<sup>9+</sup>](#encodesync9)替代。 4408 4409**系统能力：** SystemCapability.Utils.Lang 4410 4411**参数：** 4412 4413| 参数名 | 类型 | 必填 | 说明 | 4414| -------- | -------- | -------- | -------- | 4415| src | Uint8Array | 是 | 编码输入Uint8数组。 | 4416 4417**返回值：** 4418 4419| 类型 | 说明 | 4420| -------- | -------- | 4421| Uint8Array | 返回编码后新分配的Uint8数组。 | 4422 4423**示例：** 4424 4425 ```js 4426 let that = new util.Base64(); 4427 let array = new Uint8Array([115,49,51]); 4428 let result = that.encodeSync(array); 4429 ``` 4430 4431### encodeToStringSync<sup>(deprecated)</sup> 4432 4433encodeToStringSync(src: Uint8Array): string 4434 4435通过输入参数编码后输出对应文本。 4436 4437> **说明：** 4438> 4439> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encodeToStringSync<sup>9+</sup>](#encodetostringsync9)替代。 4440 4441**系统能力：** SystemCapability.Utils.Lang 4442 4443**参数：** 4444 4445| 参数名 | 类型 | 必填 | 说明 | 4446| -------- | -------- | -------- | -------- | 4447| src | Uint8Array | 是 | 编码输入Uint8数组。 | 4448 4449**返回值：** 4450 4451| 类型 | 说明 | 4452| -------- | -------- | 4453| string | 返回编码后的字符串。 | 4454 4455**示例：** 4456 4457 ```js 4458 let that = new util.Base64(); 4459 let array = new Uint8Array([115,49,51]); 4460 let result = that.encodeToStringSync(array); 4461 ``` 4462 4463### decodeSync<sup>(deprecated)</sup> 4464 4465decodeSync(src: Uint8Array | string): Uint8Array 4466 4467通过输入参数解码后输出对应文本。 4468 4469> **说明：** 4470> 4471> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.decodeSync<sup>9+</sup>](#decodesync9)替代。 4472 4473**系统能力：** SystemCapability.Utils.Lang 4474 4475**参数：** 4476 4477| 参数名 | 类型 | 必填 | 说明 | 4478| -------- | -------- | -------- | -------- | 4479| src | Uint8Array \| string | 是 | 解码输入Uint8数组或者字符串。 | 4480 4481**返回值：** 4482 4483| 类型 | 说明 | 4484| -------- | -------- | 4485| Uint8Array | 返回解码后新分配的Uint8数组。 | 4486 4487**示例：** 4488 4489 ```js 4490 let that = new util.Base64(); 4491 let buff = 'czEz'; 4492 let result = that.decodeSync(buff); 4493 ``` 4494 4495### encode<sup>(deprecated)</sup> 4496 4497encode(src: Uint8Array): Promise<Uint8Array> 4498 4499通过输入参数异步编码后输出对应文本。 4500 4501> **说明：** 4502> 4503> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encode<sup>9+</sup>](#encode9)替代。 4504 4505**系统能力：** SystemCapability.Utils.Lang 4506 4507**参数：** 4508 4509| 参数名 | 类型 | 必填 | 说明 | 4510| -------- | -------- | -------- | -------- | 4511| src | Uint8Array | 是 | 异步编码输入Uint8数组。 | 4512 4513**返回值：** 4514 4515| 类型 | 说明 | 4516| -------- | -------- | 4517| Promise<Uint8Array> | 返回异步编码后新分配的Uint8数组。 | 4518 4519**示例：** 4520 4521 ```js 4522 let that = new util.Base64(); 4523 let array = new Uint8Array([115,49,51]); 4524 let rarray = new Uint8Array([99,122,69,122]); 4525 that.encode(array).then(val=>{ 4526 for (var i = 0; i < rarray.length; i++) { 4527 console.log(val[i].toString()) 4528 } 4529 }) 4530 ``` 4531 4532### encodeToString<sup>(deprecated)</sup> 4533 4534encodeToString(src: Uint8Array): Promise<string> 4535 4536通过输入参数异步编码后输出对应文本。 4537 4538> **说明：** 4539> 4540> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.encodeToString<sup>9+</sup>](#encodetostring9)替代。 4541 4542**系统能力：** SystemCapability.Utils.Lang 4543 4544**参数：** 4545 4546| 参数名 | 类型 | 必填 | 说明 | 4547| -------- | -------- | -------- | -------- | 4548| src | Uint8Array | 是 | 异步编码输入Uint8数组。 | 4549 4550**返回值：** 4551 4552| 类型 | 说明 | 4553| -------- | -------- | 4554| Promise<string> | 返回异步编码后的字符串。 | 4555 4556**示例：** 4557 4558 ```js 4559 let that = new util.Base64(); 4560 let array = new Uint8Array([115,49,51]); 4561 that.encodeToString(array).then(val=>{ 4562 console.log(val) 4563 }) 4564 ``` 4565 4566### decode<sup>(deprecated)</sup> 4567 4568 4569decode(src: Uint8Array | string): Promise<Uint8Array> 4570 4571通过输入参数异步解码后输出对应文本。 4572 4573> **说明：** 4574> 4575> 从API version 8开始支持，从API version 9开始废弃，建议使用[Base64Helper.decode<sup>9+</sup>](#decode9)替代。 4576 4577**系统能力：** SystemCapability.Utils.Lang 4578 4579**参数：** 4580 4581| 参数名 | 类型 | 必填 | 说明 | 4582| -------- | -------- | -------- | -------- | 4583| src | Uint8Array \| string | 是 | 异步解码输入Uint8数组或者字符串。 | 4584 4585**返回值：** 4586 4587| 类型 | 说明 | 4588| -------- | -------- | 4589| Promise<Uint8Array> | 返回异步解码后新分配的Uint8数组。 | 4590 4591**示例：** 4592 4593 ```js 4594 let that = new util.Base64(); 4595 let array = new Uint8Array([99,122,69,122]); 4596 let rarray = new Uint8Array([115,49,51]); 4597 that.decode(array).then(val=>{ 4598 for (var i = 0; i < rarray.length; i++) { 4599 console.log(val[i].toString()) 4600 } 4601 }) 4602 ``` 4603