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