1# @ohos.buffer (Buffer) 2 3Buffer对象用于表示固定长度的字节序列，是专门存放二进制数据的缓存区。 4 5**推荐使用场景：** 可用于处理大量二进制数据，图片处理、文件接收上传等。 6 7> **说明：** 8> 9> 本模块首批接口从API version 9开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 10 11## 导入模块 12 13```ts 14import buffer from '@ohos.buffer'; 15``` 16 17## BufferEncoding 18 19表示支持的编码格式类型。 20 21**系统能力：** SystemCapability.Utils.Lang 22 23| 类型 | 说明 | 24| ------- | -------------------- | 25| 'ascii' | 表示ascii格式。 | 26| 'utf8' | 表示utf8格式。 | 27| 'utf-8' | 表示utf8格式。 | 28| 'utf16le' | 表示utf16小端序格式。 | 29| 'ucs2' | utf16le的别名。 | 30| 'ucs-2' | utf16le的别名。 | 31| 'base64' | 表示base64格式。 | 32| 'base64url' | 表示base64url格式。 | 33| 'latin1' | iso-8859-1的别名, 向下兼容ascii格式。 | 34| 'binary' | 表示二进制格式。 | 35| 'hex' | 表示十六进制格式。 | 36 37## buffer.alloc 38 39alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer 40 41创建一定字节长度的Buffer对象，并初始化。 42 43**系统能力：** SystemCapability.Utils.Lang 44 45**参数：** 46 47| 参数名 | 类型 | 必填 | 说明 | 48| -------- | -------- | -------- | -------- | 49| size | number | 是 | 指定的Buffer对象长度，单位：字节。 | 50| fill | string \| Buffer \| number | 否 | 填充至新缓存区的值，默认值: 0。 | 51| encoding | [BufferEncoding](#bufferencoding) | 否 | 编码格式（当`fill`为string时，才有意义）。 默认值: 'utf8'。 | 52 53**返回值：** 54 55| 类型 | 说明 | 56| -------- | -------- | 57| Buffer | 返回一个Buffer对象。 | 58 59**示例：** 60 61```ts 62import buffer from '@ohos.buffer'; 63 64let buf1 = buffer.alloc(5); 65let buf2 = buffer.alloc(5, 'a'); 66let buf3 = buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64'); 67``` 68 69## buffer.allocUninitializedFromPool 70 71allocUninitializedFromPool(size: number): Buffer 72 73创建指定大小未被初始化的Buffer对象。内存从缓冲池分配。 74创建的Buffer的内容未知，需要使用[fill](#fill)函数来初始化Buffer对象。 75 76**系统能力：** SystemCapability.Utils.Lang 77 78**参数：** 79 80| 参数名 | 类型 | 必填 | 说明 | 81| -------- | -------- | -------- | -------- | 82| size | number | 是 | 指定的Buffer对象长度，单位：字节。 | 83 84**返回值：** 85 86| 类型 | 说明 | 87| -------- | -------- | 88| Buffer | 未初始化的Buffer实例。 | 89 90**示例：** 91 92```ts 93import buffer from '@ohos.buffer'; 94 95let buf = buffer.allocUninitializedFromPool(10); 96buf.fill(0); 97``` 98 99## buffer.allocUninitialized 100 101allocUninitialized(size: number): Buffer 102 103创建指定大小未被初始化的Buffer实例。内存不从缓冲池分配。 104创建的Buffer的内容未知，需要使用[fill](#fill)函数来初始化Buffer对象。 105 106**系统能力：** SystemCapability.Utils.Lang 107 108**参数：** 109 110| 参数名 | 类型 | 必填 | 说明 | 111| -------- | -------- | -------- | -------- | 112| size | number | 是 |指定的Buffer对象长度，单位：字节。 | 113 114**返回值：** 115 116| 类型 | 说明 | 117| -------- | -------- | 118| Buffer | 未初始化的Buffer实例。 | 119 120**示例：** 121 122```ts 123import buffer from '@ohos.buffer'; 124 125let buf = buffer.allocUninitialized(10); 126buf.fill(0); 127``` 128 129## buffer.byteLength 130 131byteLength(string: string | Buffer | TypedArray | DataView | ArrayBuffer | SharedArrayBuffer, encoding?: BufferEncoding): number 132 133根据不同的编码方法，返回指定字符串的字节数。 134 135**系统能力：** SystemCapability.Utils.Lang 136 137**参数：** 138 139| 参数名 | 类型 | 必填 | 说明 | 140| -------- | -------- | -------- | -------- | 141| string | string \| Buffer \| TypedArray \| DataView \| ArrayBuffer \| SharedArrayBuffer | 是 | 指定字符串。 | 142| encoding | [BufferEncoding](#bufferencoding) | 否 | 编码格式。 默认值: 'utf8'。 | 143 144**返回值：** 145 146| 类型 | 说明 | 147| -------- | -------- | 148| number | 返回指定字符串的字节数。 | 149 150**示例：** 151 152```ts 153import buffer from '@ohos.buffer'; 154 155let str = '\u00bd + \u00bc = \u00be'; 156console.log(`${str}: ${str.length} characters, ${buffer.byteLength(str, 'utf-8')} bytes`); 157// 打印: ½ + ¼ = ¾: 9 characters, 12 bytes 158``` 159 160## buffer.compare 161 162compare(buf1: Buffer | Uint8Array, buf2: Buffer | Uint8Array): -1 | 0 | 1 163 164返回两个数组的比较结果，通常用于对Buffer对象数组进行排序。 165 166 167**系统能力：** SystemCapability.Utils.Lang 168 169**参数：** 170 171| 参数名 | 类型 | 必填 | 说明 | 172| -------- | -------- | -------- | -------- | 173| buf1 | Buffer \| Uint8Array | 是 | 待比较数组。 | 174| buf2 | Buffer \| Uint8Array | 是 | 待比较数组。 | 175 176**返回值：** 177 178| 类型 | 说明 | 179| -------- | -------- | 180| -1 \| 0 \| 1 | 如果buf1与buf2相同，则返回0。<br/>如果排序时buf1位于buf2之后，则返回1。<br/>如果排序时buf1位于buf2之前，则返回-1。 | 181 182**示例：** 183 184```ts 185import buffer from '@ohos.buffer'; 186 187let buf1 = buffer.from('1234'); 188let buf2 = buffer.from('0123'); 189let res = buf1.compare(buf2); 190 191console.log(Number(res).toString()); // 打印 1 192``` 193 194## buffer.concat 195 196concat(list: Buffer[] | Uint8Array[], totalLength?: number): Buffer 197 198将数组中的内容复制指定字节长度到新的Buffer对象中并返回。 199 200**系统能力：** SystemCapability.Utils.Lang 201 202**参数：** 203 204| 参数名 | 类型 | 必填 | 说明 | 205| -------- | -------- | -------- | -------- | 206| list | Buffer[] \| Uint8Array[] | 是 | 实例数组。 | 207| totalLength | number | 否 | 需要复制的总字节长度，默认值为0。 | 208 209**返回值：** 210 211| 类型 | 说明 | 212| -------- | -------- | 213| Buffer | 返回新的Buffer对象。 | 214 215**错误码：** 216 217以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 218 219| 错误码ID | 错误信息 | 220| -------- | -------- | 221| 10200001 | The value of "length" is out of range. It must be >= 0 and <= uint32 max. Received value is: [length] | 222 223**示例：** 224 225```ts 226import buffer from '@ohos.buffer'; 227 228let buf1 = buffer.from("1234"); 229let buf2 = buffer.from("abcd"); 230let buf = buffer.concat([buf1, buf2]); 231console.log(buf.toString('hex')); // 3132333461626364 232``` 233 234## buffer.from 235 236from(array: number[]): Buffer; 237 238根据指定数组创建新的Buffer对象。 239 240**系统能力：** SystemCapability.Utils.Lang 241 242**参数：** 243 244| 参数名 | 类型 | 必填 | 说明 | 245| -------- | -------- | -------- | -------- | 246| array | number[] | 是 | 指定数组。 | 247 248**返回值：** 249 250| 类型 | 说明 | 251| -------- | -------- | 252| Buffer | 新的Buffer对象。 | 253 254**示例：** 255 256```ts 257import buffer from '@ohos.buffer'; 258 259let buf = buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]); 260console.log(buf.toString('hex')); // 627566666572 261``` 262 263## buffer.from 264 265from(arrayBuffer: ArrayBuffer | SharedArrayBuffer, byteOffset?: number, length?: number): Buffer 266 267创建指定长度的与`arrayBuffer`共享内存的Buffer对象。 268 269**系统能力：** SystemCapability.Utils.Lang 270 271**参数：** 272 273| 参数名 | 类型 | 必填 | 说明 | 274| -------- | -------- | -------- | -------- | 275| arrayBuffer | ArrayBuffer \| SharedArrayBuffer | 是 | 实例对象。 | 276| byteOffset | number | 否 | 字节偏移量，默认值: 0。 | 277| length | number | 否 | 字节长度， 默认值: (arrayBuffer.byteLength - byteOffset)。 | 278 279**返回值：** 280 281| 类型 | 说明 | 282| -------- | -------- | 283| Buffer | 返回一个共享内存的Buffer对象。 | 284 285**错误码：** 286 287以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 288 289| 错误码ID | 错误信息 | 290| -------- | -------- | 291| 10200001 | The value of "[byteOffset/length]" is out of range. | 292 293**示例：** 294 295```ts 296import buffer from '@ohos.buffer'; 297 298let ab = new ArrayBuffer(10); 299let buf = buffer.from(ab, 0, 2); 300``` 301 302## buffer.from 303 304from(buffer: Buffer | Uint8Array): Buffer 305 306创建并复制`buffer`数据到新的Buffer对象并返回。 307 308**系统能力：** SystemCapability.Utils.Lang 309 310**参数：** 311 312| 参数名 | 类型 | 必填 | 说明 | 313| -------- | -------- | -------- | -------- | 314| buffer | Buffer \| Uint8Array | 是 | 对象数据。 | 315 316**返回值：** 317 318| 类型 | 说明 | 319| -------- | -------- | 320| Buffer | 新的Buffer对象。 | 321 322**示例：** 323 324```ts 325import buffer from '@ohos.buffer'; 326 327let buf1 = buffer.from('buffer'); 328let buf2 = buffer.from(buf1); 329``` 330 331## buffer.from 332 333from(object: Object, offsetOrEncoding: number | string, length: number): Buffer 334 335根据指定的`object`类型数据，创建新的Buffer对象。 336 337**系统能力：** SystemCapability.Utils.Lang 338 339**参数：** 340 341| 参数名 | 类型 | 必填 | 说明 | 342| -------- | -------- | -------- | -------- | 343| object | Object | 是 | 支持Symbol.toPrimitive或valueOf()的对象。 | 344| offsetOrEncoding | number \| string | 是 | 字节偏移量或编码格式。 | 345| length | number | 是 | 字节长度(此入参仅在object的valueOf()返回值为arraybuffer时生效)。其他情况下可填任意number类型值，该参数不会对结果产生影响。 | 346 347**返回值：** 348 349| 类型 | 说明 | 350| -------- | -------- | 351| Buffer | 返回新的Buffer对象。 | 352 353**示例：** 354 355```ts 356import buffer from '@ohos.buffer'; 357 358let buf = buffer.from(new String('this is a test'), 'utf8', 14); 359``` 360 361## buffer.from 362 363from(string: String, encoding?: BufferEncoding): Buffer 364 365根据指定编码格式的字符串，创建新的Buffer对象。 366 367**系统能力：** SystemCapability.Utils.Lang 368 369**参数：** 370 371| 参数名 | 类型 | 必填 | 说明 | 372| -------- | -------- | -------- | -------- | 373| string | String | 是 | 字符串 | 374| encoding | [BufferEncoding](#bufferencoding) | 否 | 编码格式。 默认值: 'utf8'。 | 375 376**返回值：** 377 378| 类型 | 说明 | 379| -------- | -------- | 380| Buffer | 返回新的Buffer对象。 | 381 382**示例：** 383 384```ts 385import buffer from '@ohos.buffer'; 386 387let buf1 = buffer.from('this is a test'); 388let buf2 = buffer.from('7468697320697320612074c3a97374', 'hex'); 389 390console.log(buf1.toString()); // 打印: this is a test 391console.log(buf2.toString()); // 打印: this is a test 392``` 393 394 395## buffer.isBuffer 396 397isBuffer(obj: Object): boolean 398 399判断`obj`是否为Buffer。 400 401**系统能力：** SystemCapability.Utils.Lang 402 403**参数：** 404 405| 参数名 | 类型 | 必填 | 说明 | 406| -------- | -------- | -------- | -------- | 407| obj | Object | 是 | 判断对象 | 408 409**返回值：** 410 411| 类型 | 说明 | 412| -------- | -------- | 413| boolean | 如果obj是Buffer，则返回true，否则返回false。 | 414 415**示例：** 416 417```ts 418import buffer from '@ohos.buffer'; 419 420let result = buffer.isBuffer(buffer.alloc(10)); // true 421let result1 = buffer.isBuffer(buffer.from('foo')); // true 422let result2 = buffer.isBuffer('a string'); // false 423let result3 = buffer.isBuffer([]); // false 424let result4 = buffer.isBuffer(new Uint8Array(1024)); // false 425``` 426 427## buffer.isEncoding 428 429isEncoding(encoding: string): boolean 430 431判断`encoding`是否为支持的编码格式。 432 433**系统能力：** SystemCapability.Utils.Lang 434 435**参数：** 436 437| 参数名 | 类型 | 必填 | 说明 | 438| -------- | -------- | -------- | -------- | 439| encoding | string | 是 | 编码格式。 | 440 441**返回值：** 442 443| 类型 | 说明 | 444| -------- | -------- | 445| boolean | 是支持的编码格式返回true，反之则返回false。 | 446 447**示例：** 448 449```ts 450import buffer from '@ohos.buffer'; 451 452console.log(buffer.isEncoding('utf-8').toString()); // 打印: true 453console.log(buffer.isEncoding('hex').toString()); // 打印: true 454console.log(buffer.isEncoding('utf/8').toString()); // 打印: false 455console.log(buffer.isEncoding('').toString()); // 打印: false 456``` 457 458## buffer.transcode 459 460transcode(source: Buffer | Uint8Array, fromEnc: string, toEnc: string): Buffer 461 462将给定的Buffer或Uint8Array对象从一种字符编码重新编码为另一种。 463 464**系统能力：** SystemCapability.Utils.Lang 465 466**参数：** 467 468| 参数名 | 类型 | 必填 | 说明 | 469| -------- | -------- | -------- | -------- | 470| source | Buffer \| Uint8Array | 是 | 实例对象。 | 471| fromEnc | string | 是 | 当前编码。 | 472| toEnc | string | 是 | 目标编码。 | 473 474**返回值：** 475 476| 类型 | 说明 | 477| -------- | -------- | 478| Buffer | 根据当前编码转换成目标编码，并返回一个新的buffer实例。 | 479 480**示例：** 481 482```ts 483import buffer from '@ohos.buffer'; 484 485let newBuf = buffer.transcode(buffer.from('€'), 'utf-8', 'ascii'); 486console.log(newBuf.toString('ascii')); 487``` 488 489## Buffer 490 491### 属性 492 493**系统能力：** SystemCapability.Utils.Lang 494 495| 名称 | 类型 | 可读 | 可写 | 说明 | 496| -------- | -------- | -------- | -------- | -------- | 497| length | number | 是 | 否 | Buffer对象的字节长度。 | 498| buffer | ArrayBuffer | 是 | 否 | ArrayBuffer对象。 | 499| byteOffset | number | 是 | 否 | 当前Buffer所在内存池的偏移量。 | 500 501**错误码：** 502 503以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 504 505| 错误码ID | 错误信息 | 506| -------- | -------- | 507| 10200013 | Cannot set property ${propertyName} of Buffer which has only a getter. | 508 509**示例：** 510 511```ts 512import buffer from '@ohos.buffer'; 513 514let buf = buffer.from("1236"); 515console.log(JSON.stringify(buf.length)); 516let arrayBuffer = buf.buffer; 517console.log(JSON.stringify(new Uint8Array(arrayBuffer))); 518console.log(JSON.stringify(buf.byteOffset)); 519``` 520 521### compare 522 523compare(target: Buffer | Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 | 0 | 1 524 525当前Buffer对象与目标Buffer对象进行比较，并返回Buffer在排序中的顺序结果。 526 527**系统能力：** SystemCapability.Utils.Lang 528 529**参数：** 530 531| 参数名 | 类型 | 必填 | 说明 | 532| -------- | -------- | -------- | -------- | 533| target | Buffer \| Uint8Array | 是 | 要比较的实例对象。 | 534| targetStart | number | 否 | `target`实例中开始的偏移量。 默认值: 0。 | 535| targetEnd | number | 否 | `target`实例中结束的偏移量（不包含结束位置）。 默认值: 目标对象的字节长度。 | 536| sourceStart | number | 否 | `this`实例中开始的偏移量。 默认值: 0。 | 537| sourceEnd | number | 否 | `this`实例中结束的偏移量（不包含结束位置）。 默认值: 当前对象的字节长度。 | 538 539**返回值：** 540 541| 类型 | 说明 | 542| -------- | -------- | 543| number | 返回比较结果。-1：当前排列在目标前，0：当前与目标相同，1：当前排列在目标后。 | 544 545**错误码：** 546 547以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 548 549| 错误码ID | 错误信息 | 550| -------- | -------- | 551| 10200001 | The value of "[targetStart/targetEnd/sourceStart/sourceEnd]" is out of range. | 552 553**示例：** 554 555```ts 556import buffer from '@ohos.buffer'; 557 558let buf1 = buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]); 559let buf2 = buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]); 560 561console.log(buf1.compare(buf2, 5, 9, 0, 4).toString()); // 打印: 0 562console.log(buf1.compare(buf2, 0, 6, 4).toString()); // 打印: -1 563console.log(buf1.compare(buf2, 5, 6, 5).toString()); // 打印: 1 564``` 565 566### copy 567 568copy(target: Buffer| Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number 569 570将`this`实例中指定位置的数据复制到`target`的指定位置上，并返回复制的字节总长度。 571 572**系统能力：** SystemCapability.Utils.Lang 573 574**参数：** 575 576| 参数名 | 类型 | 必填 | 说明 | 577| -------- | -------- | -------- | -------- | 578| target | Buffer \| Uint8Array | 是 | 要复制到的Buffer或Uint8Array实例。 | 579| targetStart | number | 否 | `target`实例中开始写入的偏移量。 默认值: 0。 | 580| sourceStart | number | 否 | `this`实例中开始复制的偏移量。 默认值: 0。 | 581| sourceEnd | number | 否 | `this`实例中结束复制的偏移量（不包含结束位置）。 默认值: 当前对象的字节长度。 | 582 583**返回值：** 584 585| 类型 | 说明 | 586| -------- | -------- | 587| number | 复制的字节总长度。 | 588 589**错误码：** 590 591以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 592 593| 错误码ID | 错误信息 | 594| -------- | -------- | 595| 10200001 | The value of "[targetStart/sourceStart/sourceEnd]" is out of range. | 596 597**示例：** 598 599```ts 600import buffer from '@ohos.buffer'; 601 602let buf1 = buffer.allocUninitializedFromPool(26); 603let buf2 = buffer.allocUninitializedFromPool(26).fill('!'); 604 605for (let i = 0; i < 26; i++) { 606 buf1.writeInt8(i + 97, i); 607} 608 609buf1.copy(buf2, 8, 16, 20); 610console.log(buf2.toString('ascii', 0, 25)); 611// 打印: !!!!!!!!qrst!!!!!!!!!!!!! 612``` 613 614### entries 615 616entries(): IterableIterator<[number, number]> 617 618返回一个包含key和value的迭代器。 619 620**系统能力：** SystemCapability.Utils.Lang 621 622**返回值：** 623 624| 类型 | 说明 | 625| -------- | -------- | 626| IterableIterator<[number, number]> | 包含key和value的迭代器，同时两者皆为number类型。 | 627 628**示例：** 629 630```ts 631import buffer from '@ohos.buffer'; 632 633let buf = buffer.from('buffer'); 634let pair = buf.entries(); 635let next: IteratorResult<Object[]> = pair.next(); 636while (!next.done) { 637 console.info("buffer: " + next.value); 638 next = pair.next(); 639} 640``` 641 642### equals 643 644equals(otherBuffer: Uint8Array | Buffer): boolean 645 646比较`this`实例和otherBuffer实例是否相等。 647 648**系统能力：** SystemCapability.Utils.Lang 649 650**参数：** 651 652| 参数名 | 类型 | 必填 | 说明 | 653| -------- | -------- | -------- | -------- | 654| otherBuffer | Uint8Array \| Buffer | 是 | 比较的目标对象。 | 655 656**返回值：** 657 658| 类型 | 说明 | 659| -------- | -------- | 660| boolean | 相等则返回true，否则返回false。 | 661 662**示例：** 663 664```ts 665import buffer from '@ohos.buffer'; 666 667let buf1 = buffer.from('ABC'); 668let buf2 = buffer.from('414243', 'hex'); 669let buf3 = buffer.from('ABCD'); 670 671console.log(buf1.equals(buf2).toString()); // 打印: true 672console.log(buf1.equals(buf3).toString()); // 打印: false 673``` 674 675### fill 676 677fill(value: string | Buffer | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): Buffer 678 679用`value`填充当前对象指定位置的数据，默认为循环填充，并返回填充后的Buffer对象。 680 681**系统能力：** SystemCapability.Utils.Lang 682 683**参数：** 684 685| 参数名 | 类型 | 必填 | 说明 | 686| -------- | -------- | -------- | -------- | 687| value | string \| Buffer \| Uint8Array \| number | 是 | 用于填充的值。 | 688| offset | number | 否 | 起始偏移量。 默认值: 0。 | 689| end | number | 否 | 结束偏移量（不包含结束位置）。 默认值: 当前对象的字节长度。 | 690| encoding | [BufferEncoding](#bufferencoding) | 否 | 字符编码格式（`value`为string才有意义）。 默认值: 'utf8'。 | 691 692**返回值：** 693 694| 类型 | 说明 | 695| -------- | -------- | 696| Buffer | 返回一个填充后的Buffer对象。 | 697 698**错误码：** 699 700以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 701 702| 错误码ID | 错误信息 | 703| -------- | -------- | 704| 10200001 | The value of "[offset/end]" is out of range. | 705 706**示例：** 707 708```ts 709import buffer from '@ohos.buffer'; 710 711let b = buffer.allocUninitializedFromPool(50).fill('h'); 712console.log(b.toString()); 713``` 714 715 716### includes 717 718includes(value: string | number | Buffer | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): boolean 719 720检查Buffer对象是否包含`value`值。 721 722**系统能力：** SystemCapability.Utils.Lang 723 724**参数：** 725 726| 参数名 | 类型 | 必填 | 说明 | 727| -------- | -------- | -------- | -------- | 728| value | string \| number \| Buffer \| Uint8Array | 是 | 要搜索的内容。 | 729| byteOffset | number | 否 | 字节偏移量。 如果为负数，则从末尾开始计算偏移量。 默认值: 0。 | 730| encoding | [BufferEncoding](#bufferencoding) | 否 | 字符编码格式。 默认值: 'utf8'。 | 731 732**返回值：** 733 734| 类型 | 说明 | 735| -------- | -------- | 736| boolean | 存在为true，否则为false。 | 737 738**示例：** 739 740```ts 741import buffer from '@ohos.buffer'; 742 743let buf = buffer.from('this is a buffer'); 744console.log(buf.includes('this').toString()); // 打印: true 745console.log(buf.includes('be').toString()); // 打印: false 746``` 747 748### indexOf 749 750indexOf(value: string | number | Buffer | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number 751 752查找当前对象中第一次出现`value`的索引，如果不包含`value`，则为-1。 753 754**系统能力：** SystemCapability.Utils.Lang 755 756**参数：** 757 758| 参数名 | 类型 | 必填 | 说明 | 759| -------- | -------- | -------- | -------- | 760| value | string \| number \| Buffer \| Uint8Array | 是 | 要查找的内容。 | 761| byteOffset | number | 否 | 字节偏移量。 如果为负数，则从末尾开始计算偏移量。 默认值: 0。 | 762| encoding | [BufferEncoding](#bufferencoding) | 否 | 字符编码格式。 默认值: 'utf8'。 | 763 764**返回值：** 765 766| 类型 | 说明 | 767| -------- | -------- | 768| number | 第一次出现位置。 | 769 770**示例：** 771 772```ts 773import buffer from '@ohos.buffer'; 774 775let buf = buffer.from('this is a buffer'); 776console.log(buf.indexOf('this').toString()); // 打印: 0 777console.log(buf.indexOf('is').toString()); // 打印: 2 778``` 779 780### keys 781 782keys(): IterableIterator<number> 783 784返回一个包含key值的迭代器。 785 786**系统能力：** SystemCapability.Utils.Lang 787 788**返回值：** 789 790| 类型 | 说明 | 791| -------- | -------- | 792| IterableIterator<number> | 返回一个包含key值的迭代器。 | 793 794**示例：** 795 796```ts 797import buffer from '@ohos.buffer'; 798 799let buf = buffer.from('buffer'); 800let numbers = Array.from(buf.values()); 801for (const key of numbers) { 802 console.log(key.toString()); 803} 804``` 805 806### lastIndexOf 807 808lastIndexOf(value: string | number | Buffer | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number 809 810返回`this`实例中最后一次出现`value`的索引，如果对象不包含，则为-1。 811 812**系统能力：** SystemCapability.Utils.Lang 813 814**参数：** 815 816| 参数名 | 类型 | 必填 | 说明 | 817| -------- | -------- | -------- | -------- | 818| value | string \| number \| Buffer \| Uint8Array | 是 | 要搜索的内容。 | 819| byteOffset | number | 否 | 字节偏移量。 如果为负数，则从末尾开始计算偏移量。 默认值: 0。 | 820| encoding | [BufferEncoding](#bufferencoding) | 否 | 字符编码格式。 默认值: 'utf8'。 | 821 822**返回值：** 823 824| 类型 | 说明 | 825| -------- | -------- | 826| number | 最后一次出现`value`值的索引。 | 827 828**示例：** 829 830```ts 831import buffer from '@ohos.buffer'; 832 833let buf = buffer.from('this buffer is a buffer'); 834console.log(buf.lastIndexOf('this').toString()); // 打印: 0 835console.log(buf.lastIndexOf('buffer').toString()); // 打印: 17 836``` 837 838 839### readBigInt64BE 840 841readBigInt64BE(offset?: number): bigint 842 843从指定的`offset`处读取有符号的大端序64位整数。 844 845**系统能力：** SystemCapability.Utils.Lang 846 847**参数：** 848 849| 参数名 | 类型 | 必填 | 说明 | 850| -------- | -------- | -------- | -------- | 851| offset | number | 否 | 偏移量。默认值: 0。取值范围：0 <= offset <= Buffer.length - 8 | 852 853**返回值：** 854 855| 类型 | 说明 | 856| -------- | -------- | 857| bigint | 读取出的内容。 | 858 859**错误码：** 860 861以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 862 863| 错误码ID | 错误信息 | 864| -------- | -------- | 865| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 8. Received value is: [offset]. | 866 867**示例：** 868 869```ts 870import buffer from '@ohos.buffer'; 871 872let buf = buffer.from([0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 873 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78]); 874console.log(buf.readBigInt64BE(0).toString()); 875 876let buf1 = buffer.allocUninitializedFromPool(8); 877let result = buf1.writeBigInt64BE(BigInt(0x0102030405060708), 0); 878``` 879 880### readBigInt64LE 881 882readBigInt64LE(offset?: number): bigint 883 884从指定的`offset`处读取有符号的小端序64位整数。 885 886**系统能力：** SystemCapability.Utils.Lang 887 888**参数：** 889 890| 参数名 | 类型 | 必填 | 说明 | 891| -------- | -------- | -------- | -------- | 892| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 8，默认值: 0。 | 893 894**返回值：** 895 896| 类型 | 说明 | 897| -------- | -------- | 898| bigint | 读取出的内容。 | 899 900**错误码：** 901 902以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 903 904| 错误码ID | 错误信息 | 905| -------- | -------- | 906| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 8. Received value is: [offset]. | 907 908**示例：** 909 910```ts 911import buffer from '@ohos.buffer'; 912 913let buf = buffer.from([0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 914 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78]); 915console.log(buf.readBigInt64LE(0).toString()); 916 917let buf1 = buffer.allocUninitializedFromPool(8); 918let result = buf1.writeBigInt64BE(BigInt(0x0102030405060708), 0); 919``` 920 921### readBigUInt64BE 922 923readBigUInt64BE(offset?: number): bigint 924 925从指定的`offset`处读取无符号的大端序64位整数。 926 927**系统能力：** SystemCapability.Utils.Lang 928 929**参数：** 930 931| 参数名 | 类型 | 必填 | 说明 | 932| -------- | -------- | -------- | -------- | 933| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 8，默认值: 0。 | 934 935**返回值：** 936 937| 类型 | 说明 | 938| -------- | -------- | 939| bigint | 读取出的内容。 | 940 941**错误码：** 942 943以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 944 945| 错误码ID | 错误信息 | 946| -------- | -------- | 947| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 8. Received value is: [offset]. | 948 949**示例：** 950 951```ts 952import buffer from '@ohos.buffer'; 953 954let buf = buffer.from([0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 955 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78]); 956console.log(buf.readBigUInt64BE(0).toString()); 957 958let buf1 = buffer.allocUninitializedFromPool(8); 959let result = buf1.writeBigUInt64BE(BigInt(0xdecafafecacefade), 0); 960``` 961 962### readBigUInt64LE 963 964readBigUInt64LE(offset?: number): bigint 965 966从指定的`offset`处读取无符号的小端序64位整数。 967 968**系统能力：** SystemCapability.Utils.Lang 969 970**参数：** 971 972| 参数名 | 类型 | 必填 | 说明 | 973| -------- | -------- | -------- | -------- | 974| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 8，默认值: 0。 | 975 976**返回值：** 977 978| 类型 | 说明 | 979| -------- | -------- | 980| bigint | 读取出的内容。 | 981 982**错误码：** 983 984以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 985 986| 错误码ID | 错误信息 | 987| -------- | -------- | 988| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 8. Received value is: [offset]. | 989 990**示例：** 991 992```ts 993import buffer from '@ohos.buffer'; 994 995let buf = buffer.from([0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 996 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78]); 997console.log(buf.readBigUInt64LE(0).toString()); 998 999let buf1 = buffer.allocUninitializedFromPool(8); 1000let result = buf1.writeBigUInt64BE(BigInt(0xdecafafecacefade), 0); 1001``` 1002 1003### readDoubleBE 1004 1005readDoubleBE(offset?: number): number 1006 1007从指定`offset`处读取64位大端序双精度值。 1008 1009**系统能力：** SystemCapability.Utils.Lang 1010 1011**参数：** 1012 1013| 参数名 | 类型 | 必填 | 说明 | 1014| -------- | -------- | -------- | -------- | 1015| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 8，默认值: 0。 | 1016 1017**返回值：** 1018 1019| 类型 | 说明 | 1020| -------- | -------- | 1021| number | 读取出的内容。 | 1022 1023**错误码：** 1024 1025以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1026 1027| 错误码ID | 错误信息 | 1028| -------- | -------- | 1029| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 8. Received value is: [offset]. | 1030 1031**示例：** 1032 1033```ts 1034import buffer from '@ohos.buffer'; 1035 1036let buf = buffer.from([1, 2, 3, 4, 5, 6, 7, 8]); 1037console.log(buf.readDoubleBE(0).toString()); 1038 1039let buf1 = buffer.allocUninitializedFromPool(8); 1040let result = buf1.writeDoubleBE(123.456, 0); 1041``` 1042 1043### readDoubleLE 1044 1045readDoubleLE(offset?: number): number 1046 1047从指定`offset`处读取64位小端序双精度值。 1048 1049**系统能力：** SystemCapability.Utils.Lang 1050 1051**参数：** 1052 1053| 参数名 | 类型 | 必填 | 说明 | 1054| -------- | -------- | -------- | -------- | 1055| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 8，默认值: 0。 | 1056 1057**返回值：** 1058 1059| 类型 | 说明 | 1060| -------- | -------- | 1061| number | 读取出的内容。 | 1062 1063**错误码：** 1064 1065以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1066 1067| 错误码ID | 错误信息 | 1068| -------- | -------- | 1069| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 8. Received value is: [offset]. | 1070 1071**示例：** 1072 1073```ts 1074import buffer from '@ohos.buffer'; 1075 1076let buf = buffer.from([1, 2, 3, 4, 5, 6, 7, 8]); 1077console.log(buf.readDoubleLE(0).toString()); 1078 1079let buf1 = buffer.allocUninitializedFromPool(8); 1080let result = buf1.writeDoubleLE(123.456, 0); 1081``` 1082 1083### readFloatBE 1084 1085readFloatBE(offset?: number): number 1086 1087从指定`offset`处读取32位大端序浮点数。 1088 1089**系统能力：** SystemCapability.Utils.Lang 1090 1091**参数：** 1092 1093| 参数名 | 类型 | 必填 | 说明 | 1094| -------- | -------- | -------- | -------- | 1095| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 4，默认值: 0。 | 1096 1097**返回值：** 1098 1099| 类型 | 说明 | 1100| -------- | -------- | 1101| number | 读取出的内容。 | 1102 1103**错误码：** 1104 1105以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1106 1107| 错误码ID | 错误信息 | 1108| -------- | -------- | 1109| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 4. Received value is: [offset]. | 1110 1111**示例：** 1112 1113```ts 1114import buffer from '@ohos.buffer'; 1115 1116let buf = buffer.from([1, 2, 3, 4, 5, 6, 7, 8]); 1117console.log(buf.readFloatBE(0).toString()); 1118 1119let buf1 = buffer.allocUninitializedFromPool(4); 1120let result = buf1.writeFloatBE(0xcabcbcbc, 0); 1121``` 1122 1123### readFloatLE 1124 1125readFloatLE(offset?: number): number 1126 1127从指定`offset`处读取32位小端序浮点数。 1128 1129**系统能力：** SystemCapability.Utils.Lang 1130 1131**参数：** 1132 1133| 参数名 | 类型 | 必填 | 说明 | 1134| -------- | -------- | -------- | -------- | 1135| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 4，默认值: 0。 | 1136 1137**返回值：** 1138 1139| 类型 | 说明 | 1140| -------- | -------- | 1141| number | 读取出的内容。 | 1142 1143**错误码：** 1144 1145以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1146 1147| 错误码ID | 错误信息 | 1148| -------- | -------- | 1149| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 4. Received value is: [offset]. | 1150 1151**示例：** 1152 1153```ts 1154import buffer from '@ohos.buffer'; 1155 1156let buf = buffer.from([1, 2, 3, 4, 5, 6, 7, 8]); 1157console.log(buf.readFloatLE(0).toString()); 1158 1159let buf1 = buffer.allocUninitializedFromPool(4); 1160let result = buf1.writeFloatLE(0xcabcbcbc, 0); 1161``` 1162 1163### readInt8 1164 1165readInt8(offset?: number): number 1166 1167从指定的`offset`处读取有符号的8位整数。 1168 1169**系统能力：** SystemCapability.Utils.Lang 1170 1171**参数：** 1172 1173| 参数名 | 类型 | 必填 | 说明 | 1174| -------- | -------- | -------- | -------- | 1175| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 1，默认值: 0。 | 1176 1177**返回值：** 1178 1179| 类型 | 说明 | 1180| -------- | -------- | 1181| number | 读取出的内容。 | 1182 1183**错误码：** 1184 1185以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1186 1187| 错误码ID | 错误信息 | 1188| -------- | -------- | 1189| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 1. Received value is: [offset]. | 1190 1191**示例：** 1192 1193```ts 1194import buffer from '@ohos.buffer'; 1195 1196let buf = buffer.from([-1, 5]); 1197console.log(buf.readInt8(0).toString()); // 打印: 0 1198console.log(buf.readInt8(1).toString()); // 打印: 5 1199 1200let buf1 = buffer.allocUninitializedFromPool(2); 1201let result = buf1.writeInt8(0x12); 1202``` 1203 1204### readInt16BE 1205 1206readInt16BE(offset?: number): number 1207 1208从指定的`offset`处读取有符号的大端序16位整数。 1209 1210**系统能力：** SystemCapability.Utils.Lang 1211 1212**参数：** 1213 1214| 参数名 | 类型 | 必填 | 说明 | 1215| -------- | -------- | -------- | -------- | 1216| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 2，默认值: 0。 | 1217 1218**返回值：** 1219 1220| 类型 | 说明 | 1221| -------- | -------- | 1222| number | 读取出的内容。 | 1223 1224**错误码：** 1225 1226以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1227 1228| 错误码ID | 错误信息 | 1229| -------- | -------- | 1230| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 2. Received value is: [offset]. | 1231 1232**示例：** 1233 1234```ts 1235import buffer from '@ohos.buffer'; 1236 1237let buf = buffer.from([0, 5]); 1238console.log(buf.readInt16BE(0).toString()); // 打印: 5 1239 1240let buf1 = buffer.alloc(2); 1241let result = buf1.writeInt16BE(0x1234, 0); 1242``` 1243 1244### readInt16LE 1245 1246readInt16LE(offset?: number): number 1247 1248从指定的`offset`处读取有符号的小端序16位整数。 1249 1250**系统能力：** SystemCapability.Utils.Lang 1251 1252**参数：** 1253 1254| 参数名 | 类型 | 必填 | 说明 | 1255| -------- | -------- | -------- | -------- | 1256| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 2，默认值: 0。 | 1257 1258**返回值：** 1259 1260| 类型 | 说明 | 1261| -------- | -------- | 1262| number | 读取出的内容。 | 1263 1264**错误码：** 1265 1266以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1267 1268| 错误码ID | 错误信息 | 1269| -------- | -------- | 1270| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 2. Received value is: [offset]. | 1271 1272**示例：** 1273 1274```ts 1275import buffer from '@ohos.buffer'; 1276 1277let buf = buffer.from([0, 5]); 1278console.log(buf.readInt16LE(0).toString()); // 打印: 1280 1279 1280let buf1 = buffer.alloc(2); 1281let result = buf1.writeInt16BE(0x1234, 0); 1282``` 1283 1284### readInt32BE 1285 1286readInt32BE(offset?: number): number 1287 1288从指定的`offset`处读取有符号的大端序32位整数。 1289 1290**系统能力：** SystemCapability.Utils.Lang 1291 1292**参数：** 1293 1294| 参数名 | 类型 | 必填 | 说明 | 1295| -------- | -------- | -------- | -------- | 1296| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 4，默认值: 0。 | 1297 1298**返回值：** 1299 1300| 类型 | 说明 | 1301| -------- | -------- | 1302| number | 读取出的内容。 | 1303 1304**错误码：** 1305 1306以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1307 1308| 错误码ID | 错误信息 | 1309| -------- | -------- | 1310| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 4. Received value is: [offset]. | 1311 1312**示例：** 1313 1314```ts 1315import buffer from '@ohos.buffer'; 1316 1317let buf = buffer.from([0, 0, 0, 5]); 1318console.log(buf.readInt32BE(0).toString()); // 打印: 5 1319 1320let buf1 = buffer.alloc(4); 1321let result = buf1.writeInt32BE(0x12345678, 0); 1322``` 1323 1324### readInt32LE 1325 1326readInt32LE(offset?: number): number 1327 1328从指定的`offset`处读取有符号的小端序32位整数。 1329 1330**系统能力：** SystemCapability.Utils.Lang 1331 1332**参数：** 1333 1334| 参数名 | 类型 | 必填 | 说明 | 1335| -------- | -------- | -------- | -------- | 1336| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 4，默认值: 0。 | 1337 1338**返回值：** 1339 1340| 类型 | 说明 | 1341| -------- | -------- | 1342| number | 读取出的内容。 | 1343 1344**错误码：** 1345 1346以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1347 1348| 错误码ID | 错误信息 | 1349| -------- | -------- | 1350| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 4. Received value is: [offset]. | 1351 1352**示例：** 1353 1354```ts 1355import buffer from '@ohos.buffer'; 1356 1357let buf = buffer.from([0, 0, 0, 5]); 1358console.log(buf.readInt32LE(0).toString()); // 打印: 83886080 1359 1360let buf1 = buffer.alloc(4); 1361let result = buf1.writeInt32BE(0x12345678, 0); 1362``` 1363 1364### readIntBE 1365 1366readIntBE(offset: number, byteLength: number): number 1367 1368从指定的`offset`处的buf读取byteLength个字节，并将结果解释为支持最高48位精度的大端序、二进制补码有符号值。 1369 1370**系统能力：** SystemCapability.Utils.Lang 1371 1372**参数：** 1373 1374| 参数名 | 类型 | 必填 | 说明 | 1375| -------- | -------- | -------- | -------- | 1376| offset | number | 是 | 偏移量。取值范围：0 <= offset <= Buffer.length - byteLength，默认值: 0。 | 1377| byteLength | number | 是 | 读取的字节数。 | 1378 1379 1380**返回值：** 1381 1382| 类型 | 说明 | 1383| -------- | -------- | 1384| number | 读取的内容。 | 1385 1386**错误码：** 1387 1388以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1389 1390| 错误码ID | 错误信息 | 1391| -------- | -------- | 1392| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 1393 1394**示例：** 1395 1396```ts 1397import buffer from '@ohos.buffer'; 1398 1399let buf = buffer.from("ab"); 1400let num = buf.readIntBE(0, 1); 1401console.log(num.toString()); // 97 1402 1403let buf1 = buffer.allocUninitializedFromPool(6); 1404let result = buf1.writeIntBE(0x123456789011, 0, 6); 1405``` 1406 1407 1408### readIntLE 1409 1410readIntLE(offset: number, byteLength: number): number 1411 1412从指定的`offset`处的buf读取`byteLength`个字节，并将结果解释为支持最高48位精度的小端序、二进制补码有符号值。 1413 1414**系统能力：** SystemCapability.Utils.Lang 1415 1416**参数：** 1417 1418| 参数名 | 类型 | 必填 | 说明 | 1419| -------- | -------- | -------- | -------- | 1420| offset | number | 是 | 偏移量。取值范围：0 <= offset <= Buffer.length - byteLength，默认值: 0。 | 1421| byteLength | number | 是 | 读取的字节数。 | 1422 1423 1424**返回值：** 1425 1426| 类型 | 说明 | 1427| -------- | -------- | 1428| number | 读取出的内容。 | 1429 1430**错误码：** 1431 1432以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1433 1434| 错误码ID | 错误信息 | 1435| -------- | -------- | 1436| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 1437 1438**示例：** 1439 1440```ts 1441import buffer from '@ohos.buffer'; 1442 1443let buf = buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); 1444console.log(buf.readIntLE(0, 6).toString(16)); 1445 1446let buf1 = buffer.allocUninitializedFromPool(6); 1447let result = buf1.writeIntLE(0x123456789011, 0, 6); 1448``` 1449 1450### readUInt8 1451 1452readUInt8(offset?: number): number 1453 1454从`offset`处读取8位无符号整型数。 1455 1456**系统能力：** SystemCapability.Utils.Lang 1457 1458**参数：** 1459 1460| 参数名 | 类型 | 必填 | 说明 | 1461| -------- | -------- | -------- | -------- | 1462| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 1，默认值: 0。 | 1463 1464 1465**返回值：** 1466 1467| 类型 | 说明 | 1468| -------- | -------- | 1469| number | 读取出的内容。 | 1470 1471**错误码：** 1472 1473以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1474 1475| 错误码ID | 错误信息 | 1476| -------- | -------- | 1477| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 1. Received value is: [offset]. | 1478 1479**示例：** 1480 1481```ts 1482import buffer from '@ohos.buffer'; 1483 1484let buf = buffer.from([1, -2]); 1485console.log(buf.readUInt8(0).toString()); 1486console.log(buf.readUInt8(1).toString()); 1487 1488let buf1 = buffer.allocUninitializedFromPool(4); 1489let result = buf1.writeUInt8(0x42); 1490``` 1491 1492### readUInt16BE 1493 1494readUInt16BE(offset?: number): number 1495 1496从指定的`offset`处的buf读取无符号的大端序16位整数。 1497 1498**系统能力：** SystemCapability.Utils.Lang 1499 1500**参数：** 1501 1502| 参数名 | 类型 | 必填 | 说明 | 1503| -------- | -------- | -------- | -------- | 1504| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 2，默认值: 0。 | 1505 1506 1507**返回值：** 1508 1509| 类型 | 说明 | 1510| -------- | -------- | 1511| number | 读取出的内容。 | 1512 1513**错误码：** 1514 1515以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1516 1517| 错误码ID | 错误信息 | 1518| -------- | -------- | 1519| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 2. Received value is: [offset]. | 1520 1521**示例：** 1522 1523```ts 1524import buffer from '@ohos.buffer'; 1525 1526let buf = buffer.from([0x12, 0x34, 0x56]); 1527console.log(buf.readUInt16BE(0).toString(16)); 1528console.log(buf.readUInt16BE(1).toString(16)); 1529 1530let buf1 = buffer.allocUninitializedFromPool(4); 1531let result = buf1.writeUInt16BE(0x1234, 0); 1532``` 1533 1534### readUInt16LE 1535 1536readUInt16LE(offset?: number): number 1537 1538从指定的`offset`处的buf读取无符号的小端序16位整数。 1539 1540**系统能力：** SystemCapability.Utils.Lang 1541 1542**参数：** 1543 1544| 参数名 | 类型 | 必填 | 说明 | 1545| -------- | -------- | -------- | -------- | 1546| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 2，默认值: 0。 | 1547 1548 1549**返回值：** 1550 1551| 类型 | 说明 | 1552| -------- | -------- | 1553| number | 读取出的内容。 | 1554 1555**错误码：** 1556 1557以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1558 1559| 错误码ID | 错误信息 | 1560| -------- | -------- | 1561| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 2. Received value is: [offset]. | 1562 1563**示例：** 1564 1565```ts 1566import buffer from '@ohos.buffer'; 1567 1568let buf = buffer.from([0x12, 0x34, 0x56]); 1569console.log(buf.readUInt16LE(0).toString(16)); 1570console.log(buf.readUInt16LE(1).toString(16)); 1571 1572let buf1 = buffer.allocUninitializedFromPool(4); 1573let result = buf1.writeUInt16LE(0x1234, 0); 1574``` 1575 1576### readUInt32BE 1577 1578readUInt32BE(offset?: number): number 1579 1580从指定的`offset`处的buf读取无符号的大端序32位整数。 1581 1582**系统能力：** SystemCapability.Utils.Lang 1583 1584**参数：** 1585 1586| 参数名 | 类型 | 必填 | 说明 | 1587| -------- | -------- | -------- | -------- | 1588| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 4，默认值: 0。 | 1589 1590 1591**返回值：** 1592 1593| 类型 | 说明 | 1594| -------- | -------- | 1595| number | 读取出的内容。 | 1596 1597**错误码：** 1598 1599以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1600 1601| 错误码ID | 错误信息 | 1602| -------- | -------- | 1603| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 4. Received value is: [offset]. | 1604 1605**示例：** 1606 1607```ts 1608import buffer from '@ohos.buffer'; 1609 1610let buf = buffer.from([0x12, 0x34, 0x56, 0x78]); 1611console.log(buf.readUInt32BE(0).toString(16)); 1612 1613let buf1 = buffer.allocUninitializedFromPool(4); 1614let result = buf1.writeUInt32BE(0x12345678, 0); 1615``` 1616 1617### readUInt32LE 1618 1619readUInt32LE(offset?: number): number 1620 1621从指定的`offset`处的buf读取无符号的小端序32位整数。 1622 1623**系统能力：** SystemCapability.Utils.Lang 1624 1625**参数：** 1626 1627| 参数名 | 类型 | 必填 | 说明 | 1628| -------- | -------- | -------- | -------- | 1629| offset | number | 否 | 偏移量。取值范围：0 <= offset <= Buffer.length - 4，默认值: 0。 | 1630 1631 1632**返回值：** 1633 1634| 类型 | 说明 | 1635| -------- | -------- | 1636| number | 读取出的内容。 | 1637 1638**错误码：** 1639 1640以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1641 1642| 错误码ID | 错误信息 | 1643| -------- | -------- | 1644| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 4. Received value is: [offset]. | 1645 1646**示例：** 1647 1648```ts 1649import buffer from '@ohos.buffer'; 1650 1651let buf = buffer.from([0x12, 0x34, 0x56, 0x78]); 1652console.log(buf.readUInt32LE(0).toString(16)); 1653 1654let buf1 = buffer.allocUninitializedFromPool(4); 1655let result = buf1.writeUInt32LE(0x12345678, 0); 1656``` 1657 1658### readUIntBE 1659 1660readUIntBE(offset: number, byteLength: number): number 1661 1662从指定的`offset`处的buf读取`byteLength`个字节，并将结果解释为支持最高48位精度的无符号大端序整数。 1663 1664**系统能力：** SystemCapability.Utils.Lang 1665 1666**参数：** 1667 1668| 参数名 | 类型 | 必填 | 说明 | 1669| -------- | -------- | -------- | -------- | 1670| offset | number | 是 | 偏移量。取值范围：0 <= offset <= Buffer.length - byteLength，默认值: 0。 | 1671| byteLength | number | 是 | 要读取的字节数。 | 1672 1673 1674**返回值：** 1675 1676| 类型 | 说明 | 1677| -------- | -------- | 1678| number | 读取出的内容。 | 1679 1680**错误码：** 1681 1682以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1683 1684| 错误码ID | 错误信息 | 1685| -------- | -------- | 1686| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 1687 1688**示例：** 1689 1690```ts 1691import buffer from '@ohos.buffer'; 1692 1693let buf = buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); 1694console.log(buf.readUIntBE(0, 6).toString(16)); 1695 1696let buf1 = buffer.allocUninitializedFromPool(4); 1697let result = buf1.writeUIntBE(0x13141516, 0, 4); 1698``` 1699 1700### readUIntLE 1701 1702readUIntLE(offset: number, byteLength: number): number 1703 1704从指定的`offset`处的buf读取`byteLength`个字节，并将结果解释为支持最高48位精度的无符号小端序整数。 1705 1706**系统能力：** SystemCapability.Utils.Lang 1707 1708**参数：** 1709 1710| 参数名 | 类型 | 必填 | 说明 | 1711| -------- | -------- | -------- | -------- | 1712| offset | number | 是 | 偏移量。取值范围：0 <= offset <= Buffer.length - byteLength，默认值: 0。 | 1713| byteLength | number | 是 | 要读取的字节数。 | 1714 1715 1716**返回值：** 1717 1718| 类型 | 说明 | 1719| -------- | -------- | 1720| number | 读取出的内容。 | 1721 1722**错误码：** 1723 1724以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1725 1726| 错误码ID | 错误信息 | 1727| -------- | -------- | 1728| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 1729 1730**示例：** 1731 1732```ts 1733import buffer from '@ohos.buffer'; 1734 1735let buf = buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); 1736console.log(buf.readUIntLE(0, 6).toString(16)); 1737 1738let buf1 = buffer.allocUninitializedFromPool(4); 1739let result = buf1.writeUIntLE(0x13141516, 0, 4); 1740``` 1741 1742### subarray 1743 1744subarray(start?: number, end?: number): Buffer 1745 1746截取当前对象指定位置的数据并返回。 1747 1748**系统能力：** SystemCapability.Utils.Lang 1749 1750**参数：** 1751 1752| 参数名 | 类型 | 必填 | 说明 | 1753| -------- | -------- | -------- | -------- | 1754| start | number | 否 | 截取开始位置。 默认值: 0。 | 1755| end | number | 否 | 截取结束位置（不包含结束位置）。 默认值: 当前对象的字节长度。 | 1756 1757**返回值：** 1758 1759| 类型 | 说明 | 1760| -------- | -------- | 1761| Buffer | 返回新的Buffer对象。 | 1762 1763**示例：** 1764 1765```ts 1766import buffer from '@ohos.buffer'; 1767 1768let buf1 = buffer.allocUninitializedFromPool(26); 1769 1770for (let i = 0; i < 26; i++) { 1771 buf1.writeInt8(i + 97, i); 1772} 1773const buf2 = buf1.subarray(0, 3); 1774console.log(buf2.toString('ascii', 0, buf2.length)); 1775// 打印: abc 1776``` 1777 1778### swap16 1779 1780swap16(): Buffer 1781 1782将当前对象解释为无符号的16位整数数组，并交换字节顺序。 1783 1784**系统能力：** SystemCapability.Utils.Lang 1785 1786 1787**返回值：** 1788 1789| 类型 | 说明 | 1790| -------- | -------- | 1791| Buffer | 交换之后的Buffer实例。 | 1792 1793**错误码：** 1794 1795以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1796 1797| 错误码ID | 错误信息 | 1798| -------- | -------- | 1799| 10200009 | Buffer size must be a multiple of 16-bits | 1800 1801**示例：** 1802 1803```ts 1804import buffer from '@ohos.buffer'; 1805 1806let buf1 = buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); 1807console.log(buf1.toString('hex')); // 打印: 0102030405060708 1808 1809buf1.swap16(); 1810console.log(buf1.toString('hex')); // 打印: 0201040306050807 1811``` 1812 1813### swap32 1814 1815swap32(): Buffer 1816 1817将当前对象解释为无符号的32位整数数组，并交换字节顺序。 1818 1819**系统能力：** SystemCapability.Utils.Lang 1820 1821 1822**返回值：** 1823 1824| 类型 | 说明 | 1825| -------- | -------- | 1826| Buffer | 交换之后的Buffer对象。 | 1827 1828**错误码：** 1829 1830以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1831 1832| 错误码ID | 错误信息 | 1833| -------- | -------- | 1834| 10200009 | Buffer size must be a multiple of 32-bits | 1835 1836**示例：** 1837 1838```ts 1839import buffer from '@ohos.buffer'; 1840 1841let buf1 = buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); 1842console.log(buf1.toString('hex')); // 打印: 0102030405060708 1843 1844buf1.swap32(); 1845console.log(buf1.toString('hex')); // 打印: 0403020108070605 1846``` 1847 1848### swap64 1849 1850swap64(): Buffer 1851 1852将当前对象解释为无符号的64位整数数组，并交换字节顺序。 1853 1854**系统能力：** SystemCapability.Utils.Lang 1855 1856 1857**返回值：** 1858 1859| 类型 | 说明 | 1860| -------- | -------- | 1861| Buffer | 交换之后的Buffer对象。 | 1862 1863**错误码：** 1864 1865以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1866 1867| 错误码ID | 错误信息 | 1868| -------- | -------- | 1869| 10200009 | Buffer size must be a multiple of 64-bits | 1870 1871**示例：** 1872 1873```ts 1874import buffer from '@ohos.buffer'; 1875 1876let buf1 = buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); 1877console.log(buf1.toString('hex')); // 打印: 0102030405060708 1878buf1.swap64(); 1879console.log(buf1.toString('hex')); // 打印: 0807060504030201 1880``` 1881 1882### toJSON 1883 1884toJSON(): Object 1885 1886将Buffer转为JSON并返回。 1887 1888**系统能力：** SystemCapability.Utils.Lang 1889 1890 1891**返回值：** 1892 1893| 类型 | 说明 | 1894| -------- | -------- | 1895| Object | JSON对象。 | 1896 1897**示例：** 1898 1899```ts 1900import buffer from '@ohos.buffer'; 1901 1902let buf1 = buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]); 1903let obj = buf1.toJSON(); 1904console.log(JSON.stringify(obj)); 1905// 打印: {"type":"Buffer","data":[1,2,3,4,5]} 1906``` 1907 1908### toString 1909 1910toString(encoding?: string, start?: number, end?: number): string 1911 1912将当前对象中指定位置数据转成指定编码格式字符串并返回。 1913 1914**系统能力：** SystemCapability.Utils.Lang 1915 1916**参数：** 1917 1918| 参数名 | 类型 | 必填 | 说明 | 1919| -------- | -------- | -------- | -------- | 1920| encoding | string | 否 | 字符编码格式。 默认值: 'utf8'。 | 1921| start | number | 否 | 开始位置。 默认值: 0。 | 1922| end | number | 否 | 结束位置。 默认值: Buffer.length。 | 1923 1924**返回值：** 1925 1926| 类型 | 说明 | 1927| -------- | -------- | 1928| string | 字符串。 | 1929 1930**示例：** 1931 1932```ts 1933import buffer from '@ohos.buffer'; 1934 1935let buf1 = buffer.allocUninitializedFromPool(26); 1936for (let i = 0; i < 26; i++) { 1937 buf1.writeInt8(i + 97, i); 1938} 1939console.log(buf1.toString('utf-8')); 1940// 打印: abcdefghijklmnopqrstuvwxyz 1941``` 1942 1943### values 1944 1945values(): IterableIterator<number> 1946 1947返回一个包含value的迭代器。 1948 1949**系统能力：** SystemCapability.Utils.Lang 1950 1951**返回值：** 1952 1953| 类型 | 说明 | 1954| -------- | -------- | 1955| IterableIterator<number> | 迭代器。 | 1956 1957**示例：** 1958 1959```ts 1960import buffer from '@ohos.buffer'; 1961 1962let buf1 = buffer.from('buffer'); 1963let pair = buf1.values() 1964let next:IteratorResult<number> = pair.next() 1965while (!next.done) { 1966 console.log(next.value.toString()); 1967 next = pair.next(); 1968} 1969``` 1970 1971### write 1972 1973write(str: string, offset?: number, length?: number, encoding?: string): number 1974 1975从Buffer对象的offset偏移写入指定编码的字符串str，写入的字节长度为length。 1976 1977**系统能力：** SystemCapability.Utils.Lang 1978 1979**参数：** 1980 1981| 参数名 | 类型 | 必填 | 说明 | 1982| -------- | -------- | -------- | -------- | 1983| str | string | 是 | 要写入Buffer的字符串。 | 1984| offset | number | 否 | 偏移量。 默认值: 0。 | 1985| length | number | 否 | 最大字节长度。 默认值: (Buffer.length - offset)。| 1986| encoding | string | 否 | 字符编码。 默认值: 'utf8'。 | 1987 1988 1989**返回值：** 1990 1991| 类型 | 说明 | 1992| -------- | -------- | 1993| number | 返回写入的字节数。 | 1994 1995**错误码：** 1996 1997以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1998 1999| 错误码ID | 错误信息 | 2000| -------- | -------- | 2001| 10200001 | The value of "[offset/length]" is out of range. It must be >= 0 and <= buf.length. Received value is: [offset/length]. | 2002 2003**示例：** 2004 2005```ts 2006import buffer from '@ohos.buffer'; 2007 2008let buf = buffer.alloc(256); 2009let len = buf.write('\u00bd + \u00bc = \u00be', 0); 2010console.log(`${len} bytes: ${buf.toString('utf-8', 0, len)}`); 2011// 打印: 12 bytes: ½ + ¼ = ¾ 2012 2013let buffer1 = buffer.alloc(10); 2014let length = buffer1.write('abcd', 8); 2015``` 2016 2017### writeBigInt64BE 2018 2019writeBigInt64BE(value: bigint, offset?: number): number 2020 2021从Buffer对象的offset偏移写入有符号的大端序64位BigInt型数据value。 2022 2023**系统能力：** SystemCapability.Utils.Lang 2024 2025**参数：** 2026 2027| 参数名 | 类型 | 必填 | 说明 | 2028| -------- | -------- | -------- | -------- | 2029| value | bigint | 是 | 写入Buffer的数据。 | 2030| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 8。 | 2031 2032 2033**返回值：** 2034 2035| 类型 | 说明 | 2036| -------- | -------- | 2037| number | 写入的字节数。 | 2038 2039**错误码：** 2040 2041以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2042 2043| 错误码ID | 错误信息 | 2044| -------- | -------- | 2045| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2046 2047**示例：** 2048 2049```ts 2050import buffer from '@ohos.buffer'; 2051 2052let buf = buffer.allocUninitializedFromPool(8); 2053let result = buf.writeBigInt64BE(BigInt(0x0102030405060708), 0); 2054``` 2055 2056### writeBigInt64LE 2057 2058writeBigInt64LE(value: bigint, offset?: number): number 2059 2060从Buffer对象的offset偏移写入有符号的小端序64位BigInt型数据value。 2061 2062**系统能力：** SystemCapability.Utils.Lang 2063 2064**参数：** 2065 2066| 参数名 | 类型 | 必填 | 说明 | 2067| -------- | -------- | -------- | -------- | 2068| value | bigint | 是 | 写入Buffer的数据。 | 2069| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 8。 | 2070 2071 2072**返回值：** 2073 2074| 类型 | 说明 | 2075| -------- | -------- | 2076| number | 写入的字节数。 | 2077 2078**错误码：** 2079 2080以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2081 2082| 错误码ID | 错误信息 | 2083| -------- | -------- | 2084| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2085 2086**示例：** 2087 2088```ts 2089import buffer from '@ohos.buffer'; 2090 2091let buf = buffer.allocUninitializedFromPool(8); 2092let result = buf.writeBigInt64LE(BigInt(0x0102030405060708), 0); 2093``` 2094 2095### writeBigUInt64BE 2096 2097writeBigUInt64BE(value: bigint, offset?: number): number 2098 2099从Buffer对象的offset偏移写入无符号的大端序64位BigUInt型数据value。 2100 2101**系统能力：** SystemCapability.Utils.Lang 2102 2103**参数：** 2104 2105| 参数名 | 类型 | 必填 | 说明 | 2106| -------- | -------- | -------- | -------- | 2107| value | bigint | 是 | 写入Buffer的数据。 | 2108| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 8。 | 2109 2110 2111**返回值：** 2112 2113| 类型 | 说明 | 2114| -------- | -------- | 2115| number | 写入的字节数。 | 2116 2117**错误码：** 2118 2119以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2120 2121| 错误码ID | 错误信息 | 2122| -------- | -------- | 2123| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2124 2125**示例：** 2126 2127```ts 2128import buffer from '@ohos.buffer'; 2129 2130let buf = buffer.allocUninitializedFromPool(8); 2131let result = buf.writeBigUInt64BE(BigInt(0xdecafafecacefade), 0); 2132``` 2133 2134### writeBigUInt64LE 2135 2136writeBigUInt64LE(value: bigint, offset?: number): number 2137 2138从Buffer对象的offset偏移写入无符号的小端序64位BigUInt型数据value。 2139 2140**系统能力：** SystemCapability.Utils.Lang 2141 2142**参数：** 2143 2144| 参数名 | 类型 | 必填 | 说明 | 2145| -------- | -------- | -------- | -------- | 2146| value | bigint | 是 | 写入Buffer的数据。 | 2147| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 8。 | 2148 2149 2150**返回值：** 2151 2152| 类型 | 说明 | 2153| -------- | -------- | 2154| number | 写入的字节数。 | 2155 2156**错误码：** 2157 2158以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2159 2160| 错误码ID | 错误信息 | 2161| -------- | -------- | 2162| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2163 2164**示例：** 2165 2166```ts 2167import buffer from '@ohos.buffer'; 2168 2169let buf = buffer.allocUninitializedFromPool(8); 2170let result = buf.writeBigUInt64LE(BigInt(0xdecafafecacefade), 0); 2171``` 2172 2173### writeDoubleBE 2174 2175writeDoubleBE(value: number, offset?: number): number 2176 2177从Buffer对象的offset偏移写入大端序的64位双浮点型数据value。 2178 2179**系统能力：** SystemCapability.Utils.Lang 2180 2181**参数：** 2182 2183| 参数名 | 类型 | 必填 | 说明 | 2184| -------- | -------- | -------- | -------- | 2185| value | number | 是 | 写入Buffer的数据。 | 2186| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 8。 | 2187 2188 2189**返回值：** 2190 2191| 类型 | 说明 | 2192| -------- | -------- | 2193| number | 写入的字节数。 | 2194 2195**错误码：** 2196 2197以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2198 2199| 错误码ID | 错误信息 | 2200| -------- | -------- | 2201| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 8. Received value is: [offset] | 2202 2203**示例：** 2204 2205```ts 2206import buffer from '@ohos.buffer'; 2207 2208let buf = buffer.allocUninitializedFromPool(8); 2209let result = buf.writeDoubleBE(123.456, 0); 2210``` 2211 2212### writeDoubleLE 2213 2214writeDoubleLE(value: number, offset?: number): number 2215 2216从Buffer对象的offset偏移写入小端序的64位双浮点型数据value。 2217 2218**系统能力：** SystemCapability.Utils.Lang 2219 2220**参数：** 2221 2222| 参数名 | 类型 | 必填 | 说明 | 2223| -------- | -------- | -------- | -------- | 2224| value | number | 是 | 写入Buffer的数据。 | 2225| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 4。 | 2226 2227 2228**返回值：** 2229 2230| 类型 | 说明 | 2231| -------- | -------- | 2232| number | 写入的字节数。 | 2233 2234**错误码：** 2235 2236以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2237 2238| 错误码ID | 错误信息 | 2239| -------- | -------- | 2240| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 8. Received value is: [offset] | 2241 2242**示例：** 2243 2244```ts 2245import buffer from '@ohos.buffer'; 2246 2247let buf = buffer.allocUninitializedFromPool(8); 2248let result = buf.writeDoubleLE(123.456, 0); 2249``` 2250 2251### writeFloatBE 2252 2253writeFloatBE(value: number, offset?: number): number 2254 2255从Buffer对象的offset偏移写入大端序的32位浮点型数据value。 2256 2257**系统能力：** SystemCapability.Utils.Lang 2258 2259**参数：** 2260 2261| 参数名 | 类型 | 必填 | 说明 | 2262| -------- | -------- | -------- | -------- | 2263| value | number | 是 | 写入Buffer的数据。 | 2264| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 4。 | 2265 2266 2267**返回值：** 2268 2269| 类型 | 说明 | 2270| -------- | -------- | 2271| number | 写入的字节数。 | 2272 2273**错误码：** 2274 2275以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2276 2277| 错误码ID | 错误信息 | 2278| -------- | -------- | 2279| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 4. Received value is: [offset] | 2280 2281**示例：** 2282 2283```ts 2284import buffer from '@ohos.buffer'; 2285 2286let buf = buffer.allocUninitializedFromPool(8); 2287let result = buf.writeFloatBE(0xcafebabe, 0); 2288``` 2289 2290 2291### writeFloatLE 2292 2293writeFloatLE(value: number, offset?: number): number 2294 2295从Buffer对象的offset偏移写入小端序的32位浮点型数据value。 2296 2297**系统能力：** SystemCapability.Utils.Lang 2298 2299**参数：** 2300 2301| 参数名 | 类型 | 必填 | 说明 | 2302| -------- | -------- | -------- | -------- | 2303| value | number | 是 | 写入Buffer的数据。 | 2304| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 4。 | 2305 2306 2307**返回值：** 2308 2309| 类型 | 说明 | 2310| -------- | -------- | 2311| number | 写入的字节数。 | 2312 2313**错误码：** 2314 2315以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2316 2317| 错误码ID | 错误信息 | 2318| -------- | -------- | 2319| 10200001 | The value of "offset" is out of range. It must be >= 0 and <= buf.length - 4. Received value is: [offset] | 2320 2321**示例：** 2322 2323```ts 2324import buffer from '@ohos.buffer'; 2325 2326let buf = buffer.allocUninitializedFromPool(8); 2327let result = buf.writeFloatLE(0xcafebabe, 0); 2328``` 2329 2330### writeInt8 2331 2332writeInt8(value: number, offset?: number): number 2333 2334从Buffer对象的offset偏移写入8位有符号整型数据value。 2335 2336**系统能力：** SystemCapability.Utils.Lang 2337 2338**参数：** 2339 2340| 参数名 | 类型 | 必填 | 说明 | 2341| -------- | -------- | -------- | -------- | 2342| value | number | 是 | 写入Buffer的数据。 | 2343| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 1。 | 2344 2345 2346**返回值：** 2347 2348| 类型 | 说明 | 2349| -------- | -------- | 2350| number | 写入的字节数。 | 2351 2352**错误码：** 2353 2354以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2355 2356| 错误码ID | 错误信息 | 2357| -------- | -------- | 2358| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2359 2360**示例：** 2361 2362```ts 2363import buffer from '@ohos.buffer'; 2364 2365let buf = buffer.allocUninitializedFromPool(2); 2366let result = buf.writeInt8(2, 0); 2367let result1 = buf.writeInt8(-2, 1); 2368``` 2369 2370 2371### writeInt16BE 2372 2373writeInt16BE(value: number, offset?: number): number 2374 2375从Buffer对象的offset偏移写入大端序的16位有符号整型数据value。 2376 2377**系统能力：** SystemCapability.Utils.Lang 2378 2379**参数：** 2380 2381| 参数名 | 类型 | 必填 | 说明 | 2382| -------- | -------- | -------- | -------- | 2383| value | number | 是 | 写入Buffer的数据。 | 2384| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 2。 | 2385 2386 2387**返回值：** 2388 2389| 类型 | 说明 | 2390| -------- | -------- | 2391| number | 写入的字节数。 | 2392 2393**错误码：** 2394 2395以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2396 2397| 错误码ID | 错误信息 | 2398| -------- | -------- | 2399| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2400 2401**示例：** 2402 2403```ts 2404import buffer from '@ohos.buffer'; 2405 2406let buf = buffer.allocUninitializedFromPool(2); 2407let result = buf.writeInt16BE(0x0102, 0); 2408``` 2409 2410 2411### writeInt16LE 2412 2413writeInt16LE(value: number, offset?: number): number 2414 2415从Buffer对象的offset偏移写入小端序的16位有符号整型数据value。 2416 2417**系统能力：** SystemCapability.Utils.Lang 2418 2419**参数：** 2420 2421| 参数名 | 类型 | 必填 | 说明 | 2422| -------- | -------- | -------- | -------- | 2423| value | number | 是 | 写入Buffer的数据。 | 2424| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 2。 | 2425 2426 2427**返回值：** 2428 2429| 类型 | 说明 | 2430| -------- | -------- | 2431| number | 写入的字节数。 | 2432 2433**错误码：** 2434 2435以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2436 2437| 错误码ID | 错误信息 | 2438| -------- | -------- | 2439| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2440 2441**示例：** 2442 2443```ts 2444import buffer from '@ohos.buffer'; 2445 2446let buf = buffer.allocUninitializedFromPool(2); 2447let result = buf.writeInt16LE(0x0304, 0); 2448``` 2449 2450### writeInt32BE 2451 2452writeInt32BE(value: number, offset?: number): number 2453 2454从Buffer对象的offset偏移写入大端序的32位有符号整型数据value。 2455 2456**系统能力：** SystemCapability.Utils.Lang 2457 2458**参数：** 2459 2460| 参数名 | 类型 | 必填 | 说明 | 2461| -------- | -------- | -------- | -------- | 2462| value | number | 是 | 写入Buffer的数据。 | 2463| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 4。 | 2464 2465 2466**返回值：** 2467 2468| 类型 | 说明 | 2469| -------- | -------- | 2470| number | 写入的字节数。 | 2471 2472**错误码：** 2473 2474以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2475 2476| 错误码ID | 错误信息 | 2477| -------- | -------- | 2478| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2479 2480**示例：** 2481 2482```ts 2483import buffer from '@ohos.buffer'; 2484 2485let buf = buffer.allocUninitializedFromPool(4); 2486let result = buf.writeInt32BE(0x01020304, 0); 2487``` 2488 2489 2490### writeInt32LE 2491 2492writeInt32LE(value: number, offset?: number): number 2493 2494从Buffer对象的offset偏移写入小端序的32位有符号整型数据value。 2495 2496**系统能力：** SystemCapability.Utils.Lang 2497 2498**参数：** 2499 2500| 参数名 | 类型 | 必填 | 说明 | 2501| -------- | -------- | -------- | -------- | 2502| value | number | 是 | 写入Buffer的数据。 | 2503| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 4。 | 2504 2505 2506**返回值：** 2507 2508| 类型 | 说明 | 2509| -------- | -------- | 2510| number | 写入的字节数。 | 2511 2512**错误码：** 2513 2514以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2515 2516| 错误码ID | 错误信息 | 2517| -------- | -------- | 2518| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2519 2520**示例：** 2521 2522```ts 2523import buffer from '@ohos.buffer'; 2524 2525let buf = buffer.allocUninitializedFromPool(4); 2526let result = buf.writeInt32LE(0x05060708, 0); 2527``` 2528 2529### writeIntBE 2530 2531writeIntBE(value: number, offset: number, byteLength: number): number 2532 2533从Buffer对象的offset偏移写入大端序的有符号value数据，value字节长度为byteLength。 2534 2535**系统能力：** SystemCapability.Utils.Lang 2536 2537**参数：** 2538 2539| 参数名 | 类型 | 必填 | 说明 | 2540| -------- | -------- | -------- | -------- | 2541| value | number | 是 | 写入Buffer的数据。 | 2542| offset | number | 是 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - byteLength。 | 2543| byteLength | number | 是 | 要写入的字节数。 | 2544 2545 2546**返回值：** 2547 2548| 类型 | 说明 | 2549| -------- | -------- | 2550| number | 写入的字节数。 | 2551 2552**错误码：** 2553 2554以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2555 2556| 错误码ID | 错误信息 | 2557| -------- | -------- | 2558| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2559 2560**示例：** 2561 2562```ts 2563import buffer from '@ohos.buffer'; 2564 2565let buf = buffer.allocUninitializedFromPool(6); 2566let result = buf.writeIntBE(0x1234567890ab, 0, 6); 2567``` 2568 2569 2570### writeIntLE 2571 2572writeIntLE(value: number, offset: number, byteLength: number): number 2573 2574从Buffer对象的offset偏移写入小端序的有符号value数据，value字节长度为byteLength。 2575 2576**系统能力：** SystemCapability.Utils.Lang 2577 2578**参数：** 2579 2580| 参数名 | 类型 | 必填 | 说明 | 2581| -------- | -------- | -------- | -------- | 2582| value | number | 是 | 写入Buffer的数据。 | 2583| offset | number | 是 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - byteLength。 | 2584| byteLength | number | 是 | 要写入的字节数。 | 2585 2586 2587**返回值：** 2588 2589| 类型 | 说明 | 2590| -------- | -------- | 2591| number | 写入的字节数。 | 2592 2593**错误码：** 2594 2595以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2596 2597| 错误码ID | 错误信息 | 2598| -------- | -------- | 2599| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2600 2601**示例：** 2602 2603```ts 2604import buffer from '@ohos.buffer'; 2605 2606let buf = buffer.allocUninitializedFromPool(6); 2607let result = buf.writeIntLE(0x1234567890ab, 0, 6); 2608``` 2609 2610### writeUInt8 2611 2612writeUInt8(value: number, offset?: number): number 2613 2614从Buffer对象的offset偏移写入8位无符号整型数据value。 2615 2616**系统能力：** SystemCapability.Utils.Lang 2617 2618**参数：** 2619 2620| 参数名 | 类型 | 必填 | 说明 | 2621| -------- | -------- | -------- | -------- | 2622| value | number | 是 | 写入Buffer的数据。 | 2623| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 1。 | 2624 2625 2626**返回值：** 2627 2628| 类型 | 说明 | 2629| -------- | -------- | 2630| number | 写入的字节数。 | 2631 2632**错误码：** 2633 2634以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2635 2636| 错误码ID | 错误信息 | 2637| -------- | -------- | 2638| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2639 2640**示例：** 2641 2642```ts 2643import buffer from '@ohos.buffer'; 2644 2645let buf = buffer.allocUninitializedFromPool(4); 2646let result = buf.writeUInt8(0x3, 0); 2647let result1 = buf.writeUInt8(0x4, 1); 2648let result2 = buf.writeUInt8(0x23, 2); 2649let result3 = buf.writeUInt8(0x42, 3); 2650``` 2651 2652### writeUInt16BE 2653 2654writeUInt16BE(value: number, offset?: number): number 2655 2656从Buffer对象的offset偏移写入大端序的16位无符号整型数据value。 2657 2658**系统能力：** SystemCapability.Utils.Lang 2659 2660**参数：** 2661 2662| 参数名 | 类型 | 必填 | 说明 | 2663| -------- | -------- | -------- | -------- | 2664| value | number | 是 | 写入Buffer的数据。 | 2665| offset | number | 否 | 偏移量。 默认值为0。取值范围：0 <= offset <= Buffer.length - 2。 | 2666 2667 2668**返回值：** 2669 2670| 类型 | 说明 | 2671| -------- | -------- | 2672| number | 写入的字节数。 | 2673 2674**错误码：** 2675 2676以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2677 2678| 错误码ID | 错误信息 | 2679| -------- | -------- | 2680| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2681 2682**示例：** 2683 2684```ts 2685import buffer from '@ohos.buffer'; 2686 2687let buf = buffer.allocUninitializedFromPool(4); 2688let result = buf.writeUInt16BE(0xdead, 0); 2689let result1 = buf.writeUInt16BE(0xbeef, 2); 2690``` 2691 2692### writeUInt16LE 2693 2694writeUInt16LE(value: number, offset?: number): number 2695 2696从Buffer对象的offset偏移写入小端序的16位无符号整型数据value。 2697 2698**系统能力：** SystemCapability.Utils.Lang 2699 2700**参数：** 2701 2702| 参数名 | 类型 | 必填 | 说明 | 2703| -------- | -------- | -------- | -------- | 2704| value | number | 是 | 写入Buffer的数据。 | 2705| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 2。 | 2706 2707 2708**返回值：** 2709 2710| 类型 | 说明 | 2711| -------- | -------- | 2712| number | 写入的字节数。 | 2713 2714**错误码：** 2715 2716以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2717 2718| 错误码ID | 错误信息 | 2719| -------- | -------- | 2720| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2721 2722**示例：** 2723 2724```ts 2725import buffer from '@ohos.buffer'; 2726 2727let buf = buffer.allocUninitializedFromPool(4); 2728let result = buf.writeUInt16LE(0xdead, 0); 2729let result1 = buf.writeUInt16LE(0xbeef, 2); 2730``` 2731 2732### writeUInt32BE 2733 2734writeUInt32BE(value: number, offset?: number): number 2735 2736从Buffer对象的offset偏移写入大端序的32位无符号整型数据value。 2737 2738**系统能力：** SystemCapability.Utils.Lang 2739 2740**参数：** 2741 2742| 参数名 | 类型 | 必填 | 说明 | 2743| -------- | -------- | -------- | -------- | 2744| value | number | 是 | 写入Buffer的数据。 | 2745| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 4。 | 2746 2747 2748**返回值：** 2749 2750| 类型 | 说明 | 2751| -------- | -------- | 2752| number | 写入的字节数。 | 2753 2754**错误码：** 2755 2756以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2757 2758| 错误码ID | 错误信息 | 2759| -------- | -------- | 2760| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2761 2762**示例：** 2763 2764```ts 2765import buffer from '@ohos.buffer'; 2766 2767let buf = buffer.allocUninitializedFromPool(4); 2768let result = buf.writeUInt32BE(0xfeedface, 0); 2769``` 2770 2771### writeUInt32LE 2772 2773writeUInt32LE(value: number, offset?: number): number 2774 2775从Buffer对象的offset偏移写入小端序的32位无符号整型数据value。 2776 2777**系统能力：** SystemCapability.Utils.Lang 2778 2779**参数：** 2780 2781| 参数名 | 类型 | 必填 | 说明 | 2782| -------- | -------- | -------- | -------- | 2783| value | number | 是 | 写入Buffer对象的数字。 | 2784| offset | number | 否 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - 4。 | 2785 2786 2787**返回值：** 2788 2789| 类型 | 说明 | 2790| -------- | -------- | 2791| number | 写入的字节数。 | 2792 2793**错误码：** 2794 2795以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2796 2797| 错误码ID | 错误信息 | 2798| -------- | -------- | 2799| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2800 2801**示例：** 2802 2803```ts 2804import buffer from '@ohos.buffer'; 2805 2806let buf = buffer.allocUninitializedFromPool(4); 2807let result = buf.writeUInt32LE(0xfeedface, 0); 2808``` 2809 2810### writeUIntBE 2811 2812writeUIntBE(value: number, offset: number, byteLength: number): number 2813 2814从Buffer对象的offset偏移写入大端序的无符号value数据，value字节长度为byteLength。 2815 2816**系统能力：** SystemCapability.Utils.Lang 2817 2818**参数：** 2819 2820| 参数名 | 类型 | 必填 | 说明 | 2821| -------- | -------- | -------- | -------- | 2822| value | number | 是 | 写入Buffer的数据。 | 2823| offset | number | 是 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - byteLength。 | 2824| byteLength | number | 是 | 要写入的字节数。 | 2825 2826 2827**返回值：** 2828 2829| 类型 | 说明 | 2830| -------- | -------- | 2831| number | 写入的字节数。 | 2832 2833**错误码：** 2834 2835以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2836 2837| 错误码ID | 错误信息 | 2838| -------- | -------- | 2839| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2840 2841**示例：** 2842 2843```ts 2844import buffer from '@ohos.buffer'; 2845 2846let buf = buffer.allocUninitializedFromPool(6); 2847let result = buf.writeUIntBE(0x1234567890ab, 0, 6); 2848``` 2849 2850### writeUIntLE 2851 2852writeUIntLE(value: number, offset: number, byteLength: number): number 2853 2854从Buffer对象的offset偏移写入小端序的无符号value数据，value字节长度为byteLength。 2855 2856**系统能力：** SystemCapability.Utils.Lang 2857 2858**参数：** 2859 2860| 参数名 | 类型 | 必填 | 说明 | 2861| -------- | -------- | -------- | -------- | 2862| value | number | 是 | 写入Buffer的数据。 | 2863| offset | number | 是 | 偏移量。 默认值: 0。取值范围：0 <= offset <= Buffer.length - byteLength。 | 2864| byteLength | number | 是 | 要写入的字节数。 | 2865 2866 2867**返回值：** 2868 2869| 类型 | 说明 | 2870| -------- | -------- | 2871| number | 写入的字节数。 | 2872 2873**错误码：** 2874 2875以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 2876 2877| 错误码ID | 错误信息 | 2878| -------- | -------- | 2879| 10200001 | The value of "[param]" is out of range. It must be >= [left range] and <= [right range]. Received value is: [param] | 2880 2881**示例：** 2882 2883```ts 2884import buffer from '@ohos.buffer'; 2885 2886let buf = buffer.allocUninitializedFromPool(6); 2887let result = buf.writeUIntLE(0x1234567890ab, 0, 6); 2888``` 2889 2890## Blob 2891 2892### 属性 2893 2894**系统能力：** SystemCapability.Utils.Lang 2895 2896| 名称 | 类型 | 可读 | 可写 | 说明 | 2897| -------- | -------- | -------- | -------- | -------- | 2898| size | number | 是 | 否 | Blob实例的总字节大小。 | 2899| type | string | 是 | 否 | Blob实例的内容类型。 | 2900 2901### constructor 2902 2903constructor(sources: string[] | ArrayBuffer[] | TypedArray[] | DataView[] | Blob[] , options?: Object) 2904 2905Blob的构造函数。 2906 2907**系统能力：** SystemCapability.Utils.Lang 2908 2909**参数：** 2910 2911| 参数名 | 类型 | 必填 | 说明 | 2912| -------- | -------- | -------- | -------- | 2913| sources | string[] \| ArrayBuffer[] \| TypedArray[] \| DataView[] \| Blob[] | 是 | Blob实例的数据源。 | 2914| options | Object | 否 | options:<br/>- endings:含义为结束符'\n'的字符串如何被输出，为'transparent'或'native'。native代表行结束符会跟随系统。'transparent'代表会保持Blob中保存的结束符不变。此参数非必填，默认值为'transparent'。<br/>- type:Blob内容类型。其目的是让类型传达数据的MIME媒体类型，但是不执行类型格式的验证。此参数非必填，默认参数为''。 | 2915 2916 2917**示例：** 2918```ts 2919import buffer from '@ohos.buffer'; 2920 2921let blob: buffer.Blob = new buffer.Blob(['a', 'b', 'c']); 2922 2923class option { 2924 endings: string = ""; 2925 type: string = ""; 2926} 2927let o1: option = {endings:'native', type: 'MIME'} 2928let blob1: buffer.Blob = new buffer.Blob(['a', 'b', 'c'], o1); 2929``` 2930 2931### arrayBuffer 2932 2933arrayBuffer(): Promise<ArrayBuffer> 2934 2935将Blob中的数据放入到ArrayBuffer中，并返回一个Promise。 2936 2937**系统能力：** SystemCapability.Utils.Lang 2938 2939**返回值：** 2940| 类型 | 说明 | 2941| -------- | -------- | 2942| Promise<ArrayBuffer> | Promise对象，返回包含Blob数据的ArrayBuffer。 | 2943 2944**示例：** 2945```ts 2946import buffer from '@ohos.buffer'; 2947 2948let blob: buffer.Blob = new buffer.Blob(['a', 'b', 'c']); 2949let pro = blob.arrayBuffer(); 2950pro.then((val: ArrayBuffer) => { 2951 let uintarr: Uint8Array = new Uint8Array(val); 2952 console.log(uintarr.toString()); 2953}); 2954``` 2955### slice 2956 2957slice(start?: number, end?: number, type?: string): Blob 2958 2959创建并返回一个复制原Blob对象中指定数据长度的Blob新对象。 2960 2961**系统能力：** SystemCapability.Utils.Lang 2962 2963**参数：** 2964 2965| 参数名 | 类型 | 必填 | 说明 | 2966| -------- | -------- | -------- | -------- | 2967| start | number | 否 | 起始位置。默认值为0。 | 2968| end | number | 否 | 结束位置。默认值为原Blob对象中的数据长度。 | 2969| type | string | 否 | 内容类型。默认值为''。 | 2970 2971**返回值：** 2972| 类型 | 说明 | 2973| -------- | -------- | 2974| Blob | 新的Blob实例对象。 | 2975 2976**示例：** 2977```ts 2978import buffer from '@ohos.buffer'; 2979 2980let blob: buffer.Blob = new buffer.Blob(['a', 'b', 'c']); 2981let blob2 = blob.slice(0, 2); 2982let blob3 = blob.slice(0, 2, "MIME"); 2983``` 2984 2985### text 2986 2987text(): Promise<string> 2988 2989使用UTF8进行解码并返回一个文本。使用Promise异步回调。 2990 2991**系统能力：** SystemCapability.Utils.Lang 2992 2993**返回值：** 2994| 类型 | 说明 | 2995| -------- | -------- | 2996| Promise<string> | Promise对象，返回包含以UTF8解码的文本。 | 2997 2998**示例：** 2999```ts 3000import buffer from '@ohos.buffer'; 3001 3002let blob: buffer.Blob = new buffer.Blob(['a', 'b', 'c']); 3003let pro = blob.text(); 3004pro.then((val: string) => { 3005 console.log(val); 3006}); 3007```