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