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