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