1# JSNApi接口说明 2 3## ArrayBufferRef 4 5ArrayBufferRef 是一种通用的、固定长度的原始二进制数据缓冲区。它不能直接读取或操作，需要通过类型数组或 DataView 对象来操作其中的数据。 6 7### New 8 9Local<ArrayBufferRef> ArrayBufferRef::New(const EcmaVM *vm, int32_t length)； 10 11Local<ArrayBufferRef> ArrayBufferRef::New(const EcmaVM *vm, void *buffer, int32_t length, const NativePointerCallback &deleter, void *data)； 12 13创建一个ArrayBuffer对象。 14 15**参数：** 16 17| 参数名 | 类型 | 必填 | 说明 | 18| ------- | --------------- | ---- | --------------------------- | 19| vm | const EcmaVM * | 是 | 虚拟机对象。 | 20| length | int32_t | 是 | 指定的长度。 | 21| buffer | void * | 是 | 指定缓冲区。 | 22| deleter | const NativePointerCallback & | 是 | 删除ArrayBuffer时所作的操作 | 23| data | void * | 是 | 指定数据。 | 24 25**返回值：** 26 27| 类型 | 说明 | 28| --------------------- | -------------------------------- | 29| Local<ArrayBufferRef> | 返回新创建的ArrayBufferRef对象。 | 30 31**示例：** 32 33```C++ 34Local<ArrayBufferRef> arrayBuffer1 = ArrayBufferRef::New(vm, 10); 35uint8_t *buffer = new uint8_t[10](); 36int *data = new int; 37*data = 10; 38NativePointerCallback deleter = [](void *env, void *buffer, void *data) -> void { 39 delete[] reinterpret_cast<uint8_t *>(buffer); 40 int *currentData = reinterpret_cast<int *>(data); 41 delete currentData; 42}; 43Local<ArrayBufferRef> arrayBuffer2 = ArrayBufferRef::New(vm, buffer, 10, deleter, data); 44``` 45 46### GetBuffer 47 48void *ArrayBufferRef::GetBuffer()； 49 50获取ArrayBufferRef的原始缓冲区。 51 52**参数：** 53 54| 参数名 | 类型 | 必填 | 说明 | 55| ------ | ---- | ---- | ---- | 56| 无参 | | | | 57 58**返回值：** 59 60| 类型 | 说明 | 61| ------ | ------------------------------------------------ | 62| void * | 返回为void *，使用时需强转为缓冲区创建时的类型。 | 63 64**示例：** 65 66```c++ 67uint8_t *buffer = new uint8_t[10](); 68int *data = new int; 69*data = 10; 70NativePointerCallback deleter = [](void *env, void *buffer, void *data) -> void { 71delete[] reinterpret_cast<uint8_t *>(buffer); 72 int *currentData = reinterpret_cast<int *>(data); 73 delete currentData; 74}; 75Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, buffer, 10, deleter, data); 76uint8_t *getBuffer = reinterpret_cast<uint8_t *>(arrayBuffer->GetBuffer()); 77``` 78 79### ByteLength 80 81int32_t ArrayBufferRef::ByteLength([[maybe_unused]] const EcmaVM *vm)； 82 83此函数返回此ArrayBufferRef缓冲区的长度（以字节为单位）。 84 85**参数：** 86 87| 参数名 | 类型 | 必填 | 说明 | 88| ------ | -------------- | ---- | ------------ | 89| vm | const EcmaVM * | 是 | 虚拟机对象。 | 90 91**返回值：** 92 93| 类型 | 说明 | 94| ------- | ------------------------------- | 95| int32_t | 以int32_t类型返回buffer的长度。 | 96 97**示例：** 98 99```c++ 100Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, 10); 101int lenth = arrayBuffer->ByteLength(vm); 102``` 103 104### IsDetach 105 106bool ArrayBufferRef::IsDetach()； 107 108判断ArrayBufferRef与其缓冲区是否已经分离。 109 110**参数：** 111 112| 参数名 | 类型 | 必填 | 说明 | 113| ------ | -------------- | ---- | ------------ | 114| vm | const EcmaVM * | 是 | 虚拟机对象。 | 115 116**返回值：** 117 118| 类型 | 说明 | 119| ---- | ----------------------------------------- | 120| bool | 缓冲区已经分离返回true，未分离返回false。 | 121 122**示例：** 123 124```C++ 125Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, 10); 126bool b = arrayBuffer->IsDetach(); 127``` 128 129### Detach 130 131void ArrayBufferRef::Detach(const EcmaVM *vm)； 132 133将ArrayBufferRef与其缓冲区分离，并将缓冲区长度置为0。 134 135**参数：** 136 137| 参数名 | 类型 | 必填 | 说明 | 138| ------ | ---- | ---- | ---- | 139| 无参 | | | | 140 141**返回值：** 142 143| 类型 | 说明 | 144| ---- | -------------------------------- | 145| void | 将ArrayBufferRef与其缓冲区分离。 | 146 147**示例：** 148 149```C++ 150Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, 10); 151arrayBuffer->Detach(vm); 152``` 153 154 155 156## BooleanRef 157 158Boolean是一个基本数据类型，用于表示真或假。 159 160### New 161 162Local<BooleanRef> BooleanRef::New(const EcmaVM *vm, bool input)； 163 164创建一个BooleanRef对象。 165 166**参数：** 167 168| 参数名 | 类型 | 必填 | 说明 | 169| ------ | -------------- | ---- | ---------------------------- | 170| vm | const EcmaVM * | 是 | 虚拟机对象。虚拟机对象。 | 171| input | bool | 是 | 指定BooleanRef对象的bool值。 | 172 173**返回值：** 174 175| 类型 | 说明 | 176| ----------------- | ---------------------------- | 177| Local<BooleanRef> | 返回新创建的BooleanRef对象。 | 178 179**示例：** 180 181```c++ 182Local<BooleanRef> boolRef = BooleanRef::New(vm, true); 183``` 184 185## BufferRef 186 187用于在数据从一个位置传输到另一个位置时临时存储数据。 188 189### New 190 191Local<BufferRef> BufferRef::New(const EcmaVM *vm, int32_t length); 192 193Local<BufferRef> BufferRef::New(const EcmaVM *vm, void *buffer, int32_t length, const NativePointerCallback &deleter, void *data) 194 195创建一个BufferRef对象。 196 197**参数：** 198 199| 参数名 | 类型 | 必填 | 说明 | 200| ------- | --------------- | ---- | -------------------------------------------------- | 201| vm | const EcmaVM * | 是 | 虚拟机对象。 | 202| length | int32_t | 是 | 指定的长度。 | 203| buffer | void * | 是 | 指定缓冲区 | 204| deleter | const NativePointerCallback & | 是 | 一个删除器对象，用于在不再需要缓冲区时释放其内存。 | 205| data | void * | 是 | 传递给删除器的额外数据。 | 206 207**返回值：** 208 209| 类型 | 说明 | 210| ---------------- | --------------------------- | 211| Local<BufferRef> | 返回新创建的BufferRef对象。 | 212 213**示例：** 214 215```c++ 216Local<BufferRef> bufferRef1 = BufferRef::New(vm, 10); 217uint8_t *buffer = new uint8_t[10](); 218int *data = new int; 219*data = 10; 220NativePointerCallback deleter = [](void *env, void *buffer, void *data) -> void { 221 delete[] reinterpret_cast<uint8_t *>(buffer); 222 int *currentData = reinterpret_cast<int *>(data); 223 delete currentData; 224}; 225Local<BufferRef> bufferRef2 = BufferRef::New(vm, buffer, 10, deleter, data); 226``` 227 228### ByteLength 229 230int32_t BufferRef::ByteLength(const EcmaVM *vm)； 231 232此函数返回此ArrayBufferRef缓冲区的长度（以字节为单位）。 233 234**参数：** 235 236| 参数名 | 类型 | 必填 | 说明 | 237| :----: | -------------- | ---- | ------------ | 238| vm | const EcmaVM * | 是 | 虚拟机对象。 | 239 240**返回值：** 241 242| 类型 | 说明 | 243| ------- | ------------------------------- | 244| int32_t | 以int32_t类型返回buffer的长度。 | 245 246**示例：** 247 248```c++ 249Local<BufferRef> buffer = BufferRef::New(vm, 10); 250int32_t lenth = buffer->ByteLength(vm); 251``` 252 253### GetBuffer 254 255void *BufferRef::GetBuffer()； 256 257获取BufferRef的原始缓冲区。 258 259**参数：** 260 261| 参数名 | 类型 | 必填 | 说明 | 262| ------ | ---- | ---- | ---- | 263| 无参 | | | | 264 265**返回值：** 266 267| 类型 | 说明 | 268| ------ | ------------------------------------------------ | 269| void * | 返回为void *，使用时需强转为缓冲区创建时的类型。 | 270 271**示例：** 272 273```c++ 274uint8_t *buffer = new uint8_t[10](); 275int *data = new int; 276*data = 10; 277NativePointerCallback deleter = [](void *env, void *buffer, void *data) -> void { 278 delete[] reinterpret_cast<uint8_t *>(buffer); 279 int *currentData = reinterpret_cast<int *>(data); 280 delete currentData; 281}; 282Local<BufferRef> bufferRef = BufferRef::New(vm, buffer, 10, deleter, data); 283uint8_t *getBuffer = reinterpret_cast<uint8_t *>(bufferRef->GetBuffer()); 284``` 285### BufferToStringCallback 286 287static ecmascript::JSTaggedValue BufferToStringCallback(ecmascript::EcmaRuntimeCallInfo *ecmaRuntimeCallInfo); 288 289调用ToString函数时会触发的回调函数。 290 291**参数：** 292 293| 参数名 | 类型 | 必填 | 说明 | 294| ------------------- | ---------------------- | ---- | -------------------------------------- | 295| ecmaRuntimeCallInfo | EcmaRuntimeCallInfo * | 是 | 设置指定的回调函数，以及所需要的参数。 | 296 297**返回值：** 298 299| 类型 | 说明 | 300| ------------- | ------------------------------------------------------------ | 301| JSTaggedValue | 将设置回调函数的结果转换为JSTaggedValue类型，并作为此函数的返回值。 | 302 303**示例：** 304 305```C++ 306Local<BufferRef> bufferRef = BufferRef::New(vm, 10); 307Local<StringRef> bufferStr = bufferRef->ToString(vm); 308``` 309 310## DataViewRef 311 312一种用于操作二进制数据的视图对象，它提供了一种方式来访问和修改 ArrayBuffer 中的字节。 313 314### New 315 316static Local<DataViewRef> New(const EcmaVM *vm, Local<ArrayBufferRef> arrayBuffer, uint32_t byteOffset,uint32_t byteLength)； 317 318创建一个新的DataView对象。 319 320**参数：** 321 322| 参数名 | 类型 | 必填 | 说明 | 323| ----------- | --------------------- | ---- | -------------------------- | 324| vm | const EcmaVM * | 是 | 虚拟机对象。 | 325| arrayBuffer | Local<ArrayBufferRef> | 是 | 指定的缓冲区。 | 326| byteOffset | uint32_t | 是 | 从第几个字节开始写入数据。 | 327| byteLength | uint32_t | 是 | 要操作的缓冲区的长度。 | 328 329**返回值：** 330 331| 类型 | 说明 | 332| ------------------ | ---------------------- | 333| Local<DataViewRef> | 一个新的DataView对象。 | 334 335**示例：** 336 337```c++ 338const int32_t length = 15; 339Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, length); 340Local<DataViewRef> dataObj = DataViewRef::New(vm, arrayBuffer, 5, 7); 341``` 342 343### ByteOffset 344 345uint32_t DataViewRef::ByteOffset()； 346 347获取DataViewRef缓冲区的偏移量。 348 349**参数：** 350 351| 参数名 | 类型 | 必填 | 说明 | 352| ------ | ---- | ---- | ---- | 353| 无参 | | | | 354 355**返回值：** 356 357| 类型 | 说明 | 358| -------- | ---------------------------------- | 359| uint32_t | 该缓冲区从那个字节开始写入或读取。 | 360 361**示例：** 362 363```C++ 364const int32_t length = 15; 365Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, length); 366Local<DataViewRef> dataView = DataViewRef::New(vm, arrayBuffer, 5, 7); 367uint32_t offSet = dataView->ByteOffset(); 368``` 369 370### ByteLength 371 372uint32_t DataViewRef::ByteLength()； 373 374获取DataViewRef缓冲区可操作的长度。 375 376**参数：** 377 378| 参数名 | 类型 | 必填 | 说明 | 379| ------ | ---- | ---- | ---- | 380| 无参 | | | | 381 382**返回值：** 383 384| 类型 | 说明 | 385| -------- | ------------------------------- | 386| uint32_t | DataViewRef缓冲区可操作的长度。 | 387 388**示例：** 389 390```C++ 391const int32_t length = 15; 392Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, length); 393Local<DataViewRef> dataView = DataViewRef::New(vm, arrayBuffer, 5, 7); 394uint32_t offSet = dataView->ByteLength(); 395``` 396 397### GetArrayBuffer 398 399Local<ArrayBufferRef> DataViewRef::GetArrayBuffer(const EcmaVM *vm)； 400 401获取DataViewRef对象的缓冲区。 402 403**参数：** 404 405| 参数名 | 类型 | 必填 | 说明 | 406| :----: | -------------- | ---- | ------------ | 407| vm | const EcmaVM * | 是 | 虚拟机对象。 | 408 409**返回值：** 410 411| 类型 | 说明 | 412| --------------------- | ------------------------------------------------------------ | 413| Local<ArrayBufferRef> | 获取DataViewRef的缓冲区，将其转换为Local<ArrayBufferRef>类型，并作为函数的返回值。 | 414 415**示例：** 416 417```c++ 418const int32_t length = 15; 419Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, length); 420Local<DataViewRef> dataView = DataViewRef::New(vm, arrayBuffer, 5, 7); 421Local<ArrayBufferRef> getBuffer = dataView->GetArrayBuffer(vm); 422``` 423 424## DateRef 425 426Date对象用于表示日期和时间。它提供了许多方法和属性来处理日期和时间。 427 428### GetTime 429 430double DateRef::GetTime()； 431 432该方法返回自纪元以来该日期的毫秒数，该纪元定义为 1970 年 1 月 1 日，UTC 开始时的午夜。 433 434**参数：** 435 436| 参数名 | 类型 | 必填 | 说明 | 437| ------ | ---- | ---- | ---- | 438| 无参 | | | | 439 440**返回值：** 441 442| 类型 | 说明 | 443| ------ | ------------------------------------------------ | 444| double | 一个double数字，表示此日期的时间戳以毫秒为单位。 | 445 446**示例：** 447 448```c++ 449double time = 1690854800000; // 2023-07-04T00:00:00.000Z 450Local<DateRef> object = DateRef::New(vm, time); 451double getTime = object->GetTime(); 452``` 453 454## JSNApi 455 456JSNApi提供了一些通用的接口用于查询或获取一些对象属性。 457 458### IsBundle 459 460bool JSNApi::IsBundle(EcmaVM *vm)； 461 462判断将文件或者模块打包时，是不是JSBundle模式。 463 464**参数：** 465 466| 参数名 | 类型 | 必填 | 说明 | 467| :----: | -------------- | ---- | ------------ | 468| vm | const EcmaVM * | 是 | 虚拟机对象。 | 469 470**返回值：** 471 472| 类型 | 说明 | 473| ---- | --------------------------------------------- | 474| bool | 当为JSBundle模式时时返回true，否则返回false。 | 475 476**示例：** 477 478```c++ 479bool b = JSNApi::IsBundle(vm); 480``` 481 482### addWorker 483 484void JSNApi::addWorker(EcmaVM *hostVm, EcmaVM *workerVm) 485 486创建一个新的虚拟机添加到指定虚拟机的工作列表中。 487 488**参数：** 489 490| 参数名 | 类型 | 必填 | 说明 | 491| :------: | -------------- | ---- | -------------------- | 492| hostVm | const EcmaVM * | 是 | 指定虚拟机对象。 | 493| workerVm | const EcmaVM * | 是 | 创建新的工作虚拟机。 | 494 495**返回值：** 496 497| 类型 | 说明 | 498| ---- | ---------- | 499| void | 无返回值。 | 500 501**示例：** 502 503```c++ 504JSRuntimeOptions option; 505EcmaVM *workerVm = JSNApi::CreateEcmaVM(option); 506JSNApi::addWorker(hostVm, workerVm); 507``` 508 509### SerializeValue 510 511void *JSNApi::SerializeValue(const EcmaVM *vm, Local<JSValueRef> value, Local<JSValueRef> transfer) 512 513将value序列化为transfer类型。 514 515**参数：** 516 517| 参数名 | 类型 | 必填 | 说明 | 518| :------: | ----------------- | ---- | ------------------ | 519| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 520| value | Local<JSValueRef> | 是 | 需要序列化的数据。 | 521| transfer | Local<JSValueRef> | 是 | 序列化的类型。 | 522 523**返回值：** 524 525| 类型 | 说明 | 526| ------ | ------------------------------------------------------------ | 527| void * | 转化为SerializationData *可调用GetData，GetSize获取序列化的数据以及大小。 | 528 529**示例：** 530 531```c++ 532Local<JSValueRef> value = StringRef::NewFromUtf8(vm, "abcdefbb"); 533Local<JSValueRef> transfer = StringRef::NewFromUtf8(vm, "abcdefbb"); 534SerializationData *ptr = JSNApi::SerializeValue(vm, value, transfer); 535``` 536 537### DisposeGlobalHandleAddr 538 539static void DisposeGlobalHandleAddr(const EcmaVM *vm, uintptr_t addr); 540 541释放全局句柄 542 543**参数：** 544 545| 参数名 | 类型 | 必填 | 说明 | 546| :----: | -------------- | ---- | ---------------- | 547| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 548| addr | uintptr_t | 是 | 全局句柄的地址。 | 549 550**返回值：** 551 552| 类型 | 说明 | 553| ---- | ---------- | 554| void | 无返回值。 | 555 556**示例：** 557 558```C++ 559Local<JSValueRef> value = StringRef::NewFromUtf8(vm, "abc"); 560uintptr_t address = JSNApi::GetGlobalHandleAddr(vm, reinterpret_cast<uintptr_t>(*value)); 561JSNApi::DisposeGlobalHandleAddr(vm, address); 562``` 563 564### CheckSecureMem 565 566static bool CheckSecureMem(uintptr_t mem); 567 568检查给定的内存地址是否安全。 569 570**参数：** 571 572| 参数名 | 类型 | 必填 | 说明 | 573| :----: | --------- | ---- | -------------------- | 574| mem | uintptr_t | 是 | 需要检查的内存地址。 | 575 576**返回值：** 577 578| 类型 | 说明 | 579| ---- | ----------------------------------- | 580| bool | 内存地址安全返回true否则返回false。 | 581 582**示例：** 583 584```c++ 585Local<JSValueRef> value = StringRef::NewFromUtf8(vm, "abc"); 586uintptr_t address = JSNApi::GetGlobalHandleAddr(vm, reinterpret_cast<uintptr_t>(*value)); 587bool b = CheckSecureMem(address); 588``` 589 590### GetGlobalObject 591 592Local<ObjectRef> JSNApi::GetGlobalObject(const EcmaVM *vm) 593 594用于能否成功获取JavaScript虚拟机的env全局对象，以及该全局对象是否为非空对象。 595 596**参数：** 597 598| 参数名 | 类型 | 必填 | 说明 | 599| :----: | -------------- | ---- | ---------------- | 600| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 601 602**返回值：** 603 604| 类型 | 说明 | 605| ---------------- | --------------------------------------------------------- | 606| Local<ObjectRef> | 可调用ObjectRef以及父类JSValueRef的函数来判断其是否有效。 | 607 608**示例：** 609 610```C++ 611Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm); 612bool b = globalObject.IsEmpty(); 613``` 614 615### GetUncaughtException 616 617Local<ObjectRef> JSNApi::GetUncaughtException(const EcmaVM *vm)； 618 619获取虚拟机未捕获的异常 620 621**参数：** 622 623| 参数名 | 类型 | 必填 | 说明 | 624| :----: | -------------- | ---- | ---------------- | 625| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 626 627**返回值：** 628 629| 类型 | 说明 | 630| ---------------- | --------------------------------------------------------- | 631| Local<ObjectRef> | 可调用ObjectRef以及父类JSValueRef的函数来判断其是否有效。 | 632 633**示例：** 634 635```c++ 636Local<ObjectRef> excep = JSNApi::GetUncaughtException(vm); 637if (!excep.IsNull()) { 638 // Error Message ... 639} 640``` 641 642### GetAndClearUncaughtException 643 644Local<ObjectRef> JSNApi::GetAndClearUncaughtException(const EcmaVM *vm)； 645 646用于获取并清除未捕获的虚拟机异常。 647 648**参数：** 649 650| 参数名 | 类型 | 必填 | 说明 | 651| :----: | -------------- | ---- | ---------------- | 652| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 653 654**返回值：** 655 656| 类型 | 说明 | 657| ---------------- | --------------------------------------------------------- | 658| Local<ObjectRef> | 可调用ObjectRef以及父类JSValueRef的函数来判断其是否有效。 | 659 660**示例：** 661 662```C++ 663Local<ObjectRef> excep = JSNApi::GetUncaughtException(vm); 664if (!excep.IsNull()) { 665 // Error Message ... 666 JSNApi::GetAndClearUncaughtException(vm); 667} 668``` 669 670### HasPendingException 671 672bool JSNApi::HasPendingException(const EcmaVM *vm)； 673 674用于检查虚拟机是否有未处理的异常。 675 676**参数：** 677 678| 参数名 | 类型 | 必填 | 说明 | 679| :----: | -------------- | ---- | ---------------- | 680| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 681 682**返回值：** 683 684| 类型 | 说明 | 685| ---- | --------------------------------------------- | 686| bool | 如果此虚拟机有异常产生返回true否则返回false。 | 687 688**示例：** 689 690```c++ 691if (JSNApi::HasPendingException(vm)) { 692 JSNApi::PrintExceptionInfo(const EcmaVM *vm); 693} 694``` 695 696### PrintExceptionInfo 697 698void JSNApi::PrintExceptionInfo(const EcmaVM *vm)； 699 700用于打印未捕获的异常，并清除此虚拟机的异常。 701 702**参数：** 703 704| 参数名 | 类型 | 必填 | 说明 | 705| :----: | -------------- | ---- | ---------------- | 706| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 707 708**返回值：** 709 710| 类型 | 说明 | 711| ---- | ---------- | 712| void | 无返回值。 | 713 714**示例：** 715 716```C++ 717if (JSNApi::HasPendingException(vm)) { 718 JSNApi::PrintExceptionInfo(vm); 719} 720``` 721 722### SetWeakCallback 723 724uintptr_t JSNApi::SetWeakCallback(const EcmaVM *vm, uintptr_t localAddress, void *ref, WeakRefClearCallBack freeGlobalCallBack, WeakRefClearCallBack nativeFinalizeCallback)； 725 726此函数用于设置一个弱回调函数。弱回调函数是一种特殊类型的回调函数，它可以在不需要时自动释放内存，以避免内存泄漏问题。 727 728**参数：** 729 730| 参数名 | 类型 | 必填 | 说明 | 731| :--------------------: | -------------------- | ---- | ---------------------------------------------------------- | 732| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 733| localAddress | uintptr_t | 是 | 本地地址，指设置的弱引用在内存地址 | 734| ref | void * | 是 | 需要引用对象的内存地址。 | 735| freeGlobalCallBack | WeakRefClearCallBack | 是 | 弱引用清除回调函数，当弱引用被清除时，该回调函数将被调用。 | 736| nativeFinalizeCallback | WeakRefClearCallBack | 是 | C++原生对象的析构函数。 | 737 738**返回值：** 739 740| 类型 | 说明 | 741| --------- | -------------------------- | 742| uintptr_t | 弱引用在内存空间中的地址。 | 743 744**示例：** 745 746```C++ 747template <typename T> void FreeGlobalCallBack(void *ptr) 748{ 749 T *i = static_cast<T *>(ptr); 750} 751template <typename T> void NativeFinalizeCallback(void *ptr) 752{ 753 T *i = static_cast<T *>(ptr); 754 delete i; 755} 756Global<JSValueRef> global(vm, BooleanRef::New(vm, true)); 757void *ref = new char('a'); 758WeakRefClearCallBack freeGlobalCallBack = FreeGlobalCallBack<char>; 759WeakRefClearCallBack nativeFinalizeCallback = NativeFinalizeCallback<char>; 760global.SetWeakCallback(ref, freeGlobalCallBack, nativeFinalizeCallback); 761``` 762 763### ThrowException 764 765void JSNApi::ThrowException(const EcmaVM *vm, Local<JSValueRef> error)； 766 767VM虚拟机抛出指定异常。 768 769**参数：** 770 771| 参数名 | 类型 | 必填 | 说明 | 772| :----: | ----------------- | ---- | ---------------- | 773| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 774| error | Local<JSValueRef> | 是 | 指定error信息。 | 775 776**返回值：** 777 778| 类型 | 说明 | 779| ---- | ---------- | 780| void | 无返回值。 | 781 782**示例：** 783 784```C++ 785Local<JSValueRef> error = Exception::Error(vm, StringRef::NewFromUtf8(vm, "Error Message")); 786JSNApi::ThrowException(vm, error); 787``` 788 789### NotifyNativeCalling 790 791static void NotifyNativeCalling(const EcmaVM *vm, const void *nativeAddress); 792 793void JSNApi::NotifyNativeCalling([[maybe_unused]] const EcmaVM *vm, [[maybe_unused]] const void *nativeAddress)； 794 795在特定条件下通知原生调用事件。 796 797**参数：** 798 799| 参数名 | 类型 | 必填 | 说明 | 800| ------------- | ------------------------------- | ---- | ------------------- | 801| vm | [[maybe_unused]] const EcmaVM * | 是 | 虚拟机对象。 | 802| nativeAddress | [[maybe_unused]] const void * | 是 | C++原生对象的地址。 | 803 804**返回值：** 805 806无 807 808**示例：** 809 810```c++ 811void *par = new int(0); 812JSNApi::NotifyNativeCalling(vm_, par); 813``` 814 815### function 816 817std::function<bool(std::string dirPath, uint8_t **buff, size_t *buffSize)> cb); 818 819一个函数对象，可以用于存储、传递和调用一个可调用对象（如函数、lambda表达式或函数对象），以便在需要时执行相应的操作。 820 821**参数：** 822 823| 参数名 | 类型 | 必填 | 说明 | 824| -------- | ----------- | ---- | ----------------------------------------------- | 825| dirPath | std::string | 是 | 字符串类型的参数，表示目录路径。 | 826| buff | uint8_t ** | 是 | 指向uint8_t类型指针的指针，用于存储缓冲区数据。 | 827| buffSize | size_t * | 是 | 指向size_t类型的指针，用于存储缓冲区大小。 | 828 829**返回值：** 830 831| 类型 | 说明 | 832| ---- | ----------------------------------------------------- | 833| bool | 布尔值：true 或 false。表示该函数执行的操作是否成功。 | 834 835**示例：** 836 837```c++ 838static *void *SetHostResolveBufferTracker(EcmaVM **vm*, std::function<*bool*(std::string dirPath, *uint8_t* **buff, *size_t* *buffSize)> *cb*); 839``` 840 841### SetProfilerState 842 843static void JSNApi::SetProfilerState(const EcmaVM *vm, bool value); 844 845用于设置虚拟机（EcmaVM）的CPUProfiler采样状态。 846 847**参数：** 848 849| 参数名 | 类型 | 必填 | 说明 | 850| ------ | -------------- | ---- | ----------------------- | 851| vm | const EcmaVM * | 是 | 虚拟机对象。 | 852| value | bool | 是 | 布尔值：true 或 false。 | 853 854**返回值：** 855 856无 857 858**示例：** 859 860```c++ 861bool ret = true; 862JSNApi::SetProfilerState(vm_, ret); 863``` 864 865### IsProfiling 866 867static bool JSNApi::IsProfiling(EcmaVM *vm); 868 869用于检查虚拟机（EcmaVM）是否处于CPUProfiling采样状态。 870 871**参数：** 872 873| 参数名 | 类型 | 必填 | 说明 | 874| ------ | -------- | ---- | ------------ | 875| vm | EcmaVM * | 是 | 虚拟机对象。 | 876 877**返回值：** 878 879| 类型 | 说明 | 880| ---- | ------------------------------------------------------------ | 881| bool | 如果虚拟机（EcmaVM）处于CPUProfiling采样状态，返回true。否则，返回false。 | 882 883**示例：** 884 885```c++ 886bool b = JSNApi::IsProfiling(vm_); 887``` 888 889### SynchronizVMInfo 890 891static void JSNApi::SynchronizVMInfo(EcmaVM *vm, const EcmaVM *hostVM); 892 893将一个EcmaVM对象的信息复制到另一个EcmaVM对象中，使它们具有相同的信息和属性。 894 895**参数：** 896 897| 参数名 | 类型 | 必填 | 说明 | 898| ------ | -------- | ---- | -------------------------- | 899| vm | EcmaVM * | 是 | 虚拟机对象（复制源）。 | 900| hostVM | EcmaVM * | 是 | 虚拟机对象（复制目的地）。 | 901 902**返回值：** 903 904无 905 906**示例：** 907 908```c++ 909JSNApi::SynchronizVMInfo(vm_, hostVM_); 910``` 911 912### SetLoop 913 914static void JSNApi::SetLoop(EcmaVM *vm, void *loop); 915 916将loop指针传递给EcmaVM对象vm的SetLoop方法。 917 918**参数：** 919 920| 参数名 | 类型 | 必填 | 说明 | 921| ------ | -------- | ---- | -------------- | 922| vm | EcmaVM * | 是 | 虚拟机对象。 | 923| loop | void * | 是 | 循环回调函数。 | 924 925**返回值：** 926 927无 928 929**示例：** 930 931```c++ 932JSNApi::SetLoop(vm_, loop); 933``` 934 935### SetAssetPath 936 937static void JSNApi::SetAssetPath(EcmaVM *vm, const std::string &assetPath); 938 939将assetPath字符串转换为C风格的字符串，并将其传递给EcmaVM对象vm的SetAssetPath方法。 940 941**参数：** 942 943| 参数名 | 类型 | 必填 | 说明 | 944| --------- | ------------------- | ---- | ---------------- | 945| vm | EcmaVM * | 是 | 虚拟机对象。 | 946| assetPath | const std::string & | 是 | 要设置的资源路径 | 947 948**返回值：** 949 950无 951 952**示例：** 953 954```c++ 955JSNApi::SetAssetPath(vm_, assetPath); 956``` 957 958### SetBundle 959 960static void JSNApi::SetBundle(EcmaVM *vm, bool value); 961 962将value传递给EcmaVM对象vm的SetIsBundlePack方法。 963 964**参数：** 965 966| 参数名 | 类型 | 必填 | 说明 | 967| ------ | -------- | ---- | ----------------------- | 968| vm | EcmaVM * | 是 | 虚拟机对象。 | 969| value | bool | 是 | 布尔值：true 或 false。 | 970 971**返回值：** 972 973无 974 975**示例：** 976 977```c++ 978JSNApi::SetBundle(vm_, value); 979``` 980 981### SwitchCurrentContext 982 983static void JSNApi::SwitchCurrentContext(EcmaVM *vm, EcmaContext *context); 984 985将当前上下文切换到指定的context。 986 987**参数：** 988 989| 参数名 | 类型 | 必填 | 说明 | 990| ------- | ------------- | ---- | ------------------ | 991| vm | EcmaVM * | 是 | 虚拟机对象。 | 992| context | EcmaContext * | 是 | 要切换到的上下文。 | 993 994**返回值：** 995 996无 997 998**示例：** 999 1000```c++ 1001JSNApi::SwitchCurrentContext(vm_, context); 1002``` 1003 1004### LoadAotFile 1005 1006static void JSNApi::LoadAotFile(EcmaVM *vm, const std::string &moduleName); 1007 1008加载一个Ahead-of-Time（AOT）文件。 1009 1010**参数：** 1011 1012| 参数名 | 类型 | 必填 | 说明 | 1013| ---------- | ------------------- | ---- | ------------------------- | 1014| vm | EcmaVM * | 是 | 虚拟机对象。 | 1015| moduleName | const std::string & | 是 | 要加载的 AOT 文件的名称。 | 1016 1017**返回值：** 1018 1019无 1020 1021**示例：** 1022 1023```c++ 1024JSNApi::LoadAotFile(vm_, moduleName); 1025``` 1026 1027### DestroyJSVM 1028 1029static void JSNApi::DestroyJSVM(EcmaVM *ecmaVm); 1030 1031销毁一个指定的ECMA虚拟机（EcmaVM）。 1032 1033**参数：** 1034 1035| 参数名 | 类型 | 必填 | 说明 | 1036| ------ | -------- | ---- | -------------------- | 1037| ecmaVm | EcmaVM * | 是 | 要销毁的虚拟机对象。 | 1038 1039**返回值：** 1040 1041无 1042 1043**示例：** 1044 1045```c++ 1046 JSNApi::DestroyJSVM(ecmaVm); 1047``` 1048 1049### DeleteSerializationData 1050 1051void JSNApi::DeleteSerializationData(void *data); 1052 1053删除一个序列化数据对象。 1054 1055**参数：** 1056 1057| 参数名 | 类型 | 必填 | 说明 | 1058| ------ | ------ | ---- | -------------------- | 1059| data | void * | 是 | 要删除的序列化数据。 | 1060 1061**返回值：** 1062 1063无 1064 1065**示例：** 1066 1067```c++ 1068JSNApi::DeleteSerializationData(data); 1069``` 1070 1071### DeserializeValue 1072 1073Local<JSValueRef> JSNApi::DeserializeValue(const EcmaVM *vm, void *recoder, void *hint); 1074 1075将序列化数据反序列化为JavaScript值。 1076 1077**参数：** 1078 1079| 参数名 | 类型 | 必填 | 说明 | 1080| ------- | -------------- | ---- | ------------------------ | 1081| vm | const EcmaVM * | 是 | 虚拟机对象。 | 1082| recoder | void * | 是 | 用于反序列化的编解码器。 | 1083| hint | void * | 是 | 可选的提示对象。 | 1084 1085**返回值;** 1086 1087| 类型 | 说明 | 1088| ----------------- | ------------------------------------------ | 1089| Local<JSValueRef> | 返回转换成 JSValueRef 类型的反序列化数据。 | 1090 1091**示例：** 1092 1093```c++ 1094 Local<JSValueRef> value = JSNApi::DeserializeValue(vm_, recoder, hint); 1095``` 1096 1097### Execute 1098 1099bool JSNApi::Execute(EcmaVM *vm, const uint8_t *data, int32_t size, const std::string &entry,const std::string &filename, bool needUpdate); 1100 1101执行一个Ark缓冲区文件。 1102 1103**参数：** 1104 1105| 参数名 | 类型 | 必填 | 说明 | 1106| ---------- | ------------------- | ---- | ----------------------------------------------------------- | 1107| vm | EcmaVM * | 是 | 虚拟机对象。 | 1108| data | const uint8_t * | 是 | JavaScript代码的字节数组。 | 1109| size | int32_t | 是 | JavaScript代码的大小（以字节为单位）。 | 1110| entry | const std::string & | 是 | JavaScript代码入口点的名称。 | 1111| filename | const std::string & | 是 | JavaScript代码文件名。 | 1112| needUpdate | bool | 是 | 布尔值：true 或 false。（表示是否需要更新虚拟机对象的状态） | 1113 1114**返回值：** 1115 1116| 类型 | 说明 | 1117| ---- | -------------------------------------------------- | 1118| bool | 执行Ark缓冲区文件成功，返回true。否则，返回false。 | 1119 1120**示例：** 1121 1122```c++ 1123bool b = JSNApi::Execute(vm_, data, size, entry,filename, needUpdate); 1124``` 1125 1126### Execute 1127 1128bool JSNApi::Execute(EcmaVM *vm, const std::string &fileName, const std::string &entry, bool needUpdate); 1129 1130执行一个Ark文件。 1131 1132**参数：** 1133 1134| 参数名 | 类型 | 必填 | 说明 | 1135| ---------- | ------------------- | ---- | ----------------------------------------------------------- | 1136| vm | EcmaVM * | 是 | 虚拟机对象。 | 1137| fileName | const std::string & | 是 | JavaScript代码文件名。 | 1138| entry | const std::string & | 是 | JavaScript代码入口点的名称。 | 1139| needUpdate | bool | 是 | 布尔值：true 或 false。（表示是否需要更新虚拟机对象的状态） | 1140 1141**返回值：** 1142 1143| 类型 | 说明 | 1144| ---- | -------------------------------------------- | 1145| bool | 执行Ark文件成功，返回true。否则，返回false。 | 1146 1147**示例：** 1148 1149```c++ 1150bool b = JSNApi::Execute(vm_, fileName, entry, needUpdate); 1151``` 1152 1153### SetHostPromiseRejectionTracker 1154 1155void JSNApi::SetHostPromiseRejectionTracker(EcmaVM *vm, void *cb, void* data); 1156 1157用于设置与JavaScript虚拟机（EcmaVM）相关联的宿主Promise拒绝跟踪器（Host Promise Rejection Tracker）。 1158 1159**参数：** 1160 1161| 参数名 | 类型 | 必填 | 说明 | 1162| ------ | -------- | ---- | --------------------------------------------- | 1163| vm | EcmaVM * | 是 | 虚拟机对象。 | 1164| cb | void | 是 | 要设置为当前ECMA上下文的Promise拒绝回调函数。 | 1165| data | void | 是 | 要设置为当前ECMA上下文的数据。 | 1166 1167**返回值：** 1168 1169无 1170 1171**示例：** 1172 1173```c++ 1174JSNApi::SetHostPromiseRejectionTracker(vm_, cb, data); 1175``` 1176 1177### ExecuteModuleFromBuffer 1178 1179static bool ExecuteModuleFromBuffer(EcmaVM *vm, const void *data, int32_t size, const std::string &file); 1180 1181从给定的数据缓冲区中执行一个模块。 1182 1183**参数：** 1184 1185| 参数名 | 类型 | 必填 | 说明 | 1186| ------ | ----------------- | ---- | ---------------------- | 1187| vm | EcmaVM * | 是 | 虚拟机对象 | 1188| data | const void * | 是 | 要执行的模块数据 | 1189| size | int32_t | 是 | 要执行的模块数据的大小 | 1190| file | const std::string | 是 | 要执行的模块文件的名称 | 1191 1192**返回值：** 1193 1194| 类型 | 说明 | 1195| :------ | :-------------------------------------------- | 1196| boolean | 如果执行模块成功，则返回true，否则返回false。 | 1197 1198**示例：** 1199 1200```c++ 1201const void *data = "TestData"; 1202int32_t size = 8; 1203const std::string file = "TestFile"; 1204bool result = JSNApi::ExecuteModuleFromBuffer(vm_, data, size, file); 1205``` 1206 1207### GetExportObject 1208 1209static Local<ObjectRef> GetExportObject(EcmaVM *vm, const std::string &file, const std::string &key); 1210 1211根据指定的文件和key值获取并导出对象。 1212 1213**参数：** 1214 1215| 参数名 | 类型 | 必填 | 说明 | 1216| ------ | ----------------- | ---- | -------------- | 1217| vm | EcmaVM * | 是 | 虚拟机对象 | 1218| file | const std::string | 是 | 指定的文件名称 | 1219| key | const std::string | 是 | 指定的key值 | 1220 1221**返回值：** 1222 1223| 类型 | 说明 | 1224| :--------------- | :--------------------- | 1225| Local<ObjectRef> | 返回获取并导出的对象。 | 1226 1227**示例：** 1228 1229```c++ 1230const std::string file = "TestFile"; 1231const std::string key = "TestKey"; 1232Local<ObjectRef> result = GetExportObject(vm_, file, key); 1233``` 1234 1235### GetExportObjectFromBuffer 1236 1237static Local<ObjectRef> GetExportObjectFromBuffer(EcmaVM *vm, const std::string &file, const std::string &key); 1238 1239从给定的缓冲区中根据指定的文件和key值获取并导出对象。 1240 1241**参数：** 1242 1243| 参数名 | 类型 | 必填 | 说明 | 1244| ------ | ----------------- | ---- | -------------- | 1245| vm | EcmaVM * | 是 | 虚拟机对象 | 1246| file | const std::string | 是 | 指定的文件名称 | 1247| key | const std::string | 是 | 指定的key值 | 1248 1249**返回值：** 1250 1251| 类型 | 说明 | 1252| :--------------- | :------------------------------------- | 1253| Local<ObjectRef> | 返回从给定的缓冲区中获取并导出的对象。 | 1254 1255**示例：** 1256 1257```c++ 1258const std::string file = "TestFile"; 1259const std::string key = "TestKey"; 1260Local<ObjectRef> result = GetExportObjectFromBuffer(vm_, file, key); 1261``` 1262 1263### GetAndClearUncaughtException 1264 1265static Local<ObjectRef> GetAndClearUncaughtException(const EcmaVM *vm); 1266 1267获取并清理未捕获的异常。 1268 1269**参数：** 1270 1271| 参数名 | 类型 | 必填 | 说明 | 1272| ------ | -------------- | ---- | ---------- | 1273| vm | const EcmaVM * | 是 | 虚拟机对象 | 1274 1275**返回值：** 1276 1277| 类型 | 说明 | 1278| :--------------- | :--------------------- | 1279| Local<ObjectRef> | 返回未捕获的异常对象。 | 1280 1281**示例：** 1282 1283```c++ 1284Local<ObjectRef> result = JSNApi::GetAndClearUncaughtException(vm_); 1285``` 1286 1287### GetUncaughtException 1288 1289static Local<ObjectRef> GetUncaughtException(const EcmaVM *vm); 1290 1291获取未捕获的异常。 1292 1293**参数：** 1294 1295| 参数名 | 类型 | 必填 | 说明 | 1296| ------ | -------------- | ---- | ---------- | 1297| vm | const EcmaVM * | 是 | 虚拟机对象 | 1298 1299**返回值：** 1300 1301| 类型 | 说明 | 1302| :--------------- | :--------------------- | 1303| Local<ObjectRef> | 返回未捕获的异常对象。 | 1304 1305**示例：** 1306 1307```c++ 1308Local<ObjectRef> result = JSNApi::GetUncaughtException(vm_); 1309``` 1310 1311### HasPendingException 1312 1313static bool HasPendingException(const EcmaVM *vm); 1314 1315检查是否有待处理的异常。 1316 1317**参数：** 1318 1319| 参数名 | 类型 | 必填 | 说明 | 1320| ------ | -------------- | ---- | ---------- | 1321| vm | const EcmaVM * | 是 | 虚拟机对象 | 1322 1323**返回值：** 1324 1325| 类型 | 说明 | 1326| :------ | :---------------------------------------------- | 1327| boolean | 如果有待处理的异常，则返回true，否则返回false。 | 1328 1329**示例：** 1330 1331```c++ 1332bool result = JSNApi::HasPendingException(vm_); 1333``` 1334 1335### HasPendingJob 1336 1337static bool HasPendingJob(const EcmaVM *vm); 1338 1339检查是否有待处理的任务。 1340 1341**参数：** 1342 1343| 参数名 | 类型 | 必填 | 说明 | 1344| ------ | -------------- | ---- | ---------- | 1345| vm | const EcmaVM * | 是 | 虚拟机对象 | 1346 1347**返回值：** 1348 1349| 类型 | 说明 | 1350| :------ | :---------------------------------------------- | 1351| boolean | 如果有待处理的任务，则返回true，否则返回false。 | 1352 1353**示例：** 1354 1355```c++ 1356bool result = JSNApi::HasPendingJob(vm_); 1357``` 1358 1359### DestroyJSContext 1360 1361static void DestroyJSContext(EcmaVM *vm, EcmaContext *context); 1362 1363该函数的作用是销毁与给定虚拟机和上下文相关联的资源，通过 `EcmaContext::CheckAndDestroy` 方法实现检查和销毁过程。 1364 1365**参数：** 1366 1367| 参数名 | 类型 | 必填 | 说明 | 1368| ------- | ------------- | ---- | ---------------------- | 1369| vm | EcmaVM * | 是 | 虚拟机对象。 | 1370| context | EcmaContext * | 是 | 表示Ecma上下文的指针。 | 1371 1372**返回值：** 1373 1374无 1375 1376**示例：** 1377 1378```c++ 1379EcmaContext *context1 = JSNApi::CreateJSContext(vm); 1380JSNApi::DestroyJSContext(vm, context1); 1381``` 1382 1383### SetMockModuleList 1384 1385static void SetMockModuleList(EcmaVM *vm, const std::map<std::string, std::string> &list); 1386 1387将给定的模拟模块列表设置到指定的Ecma虚拟机中。 1388 1389**参数：** 1390 1391| 参数名 | 类型 | 必填 | 说明 | 1392| ------ | ------------------------------------------ | ---- | ------------------------------------------------------------ | 1393| vm | EcmaVM * | 是 | 虚拟机对象。 | 1394| list | const std::map<std::string, std::string> & | 是 | 表示一个从字符串到字符串的映射，<br/>其中第一个字符串是模块的名称，第二个字符串是模块的内容。 | 1395 1396**返回值：** 1397 1398无 1399 1400**示例：** 1401 1402```c++ 1403std::map<std::string, std::string> mockModuleList; 1404mockModuleList["Module1"] = "Module1Context"; 1405mockModuleList["Module2"] = "Module2Context"; 1406JSNApi::SetMockModuleList(vm, mockModuleList); 1407``` 1408 1409### SetHostPromiseRejectionTracker 1410 1411static void SetHostPromiseRejectionTracker(EcmaVM *vm, void *cb, void *data); 1412 1413该函数用于设置 Ecma 上下文的主机 Promise 拒绝跟踪器，以及相关的回调函数和数据。 1414 1415`SetHostPromiseRejectionTracker` 方法设置主机 Promise 拒绝跟踪器的回调函数。 1416 1417`SetPromiseRejectCallback` 方法设置 Promise 拒绝的回调函数。 1418 1419`SetData` 方法设置特定的数据。 1420 1421**参数：** 1422 1423| 参数名 | 类型 | 必填 | 说明 | 1424| ------ | -------- | ---- | --------------------------------------- | 1425| vm | EcmaVM * | 是 | 虚拟机对象。 | 1426| cb | Void * | 是 | 表示主机 Promise 拒绝跟踪器的回调函数。 | 1427| data | Void * | 是 | 表示将要设置的数据。 | 1428 1429**返回值：** 1430 1431无 1432 1433**示例：** 1434 1435```c++ 1436void *data = reinterpret_cast<void *>(builtins::BuiltinsFunction::FunctionPrototypeInvokeSelf); 1437JSNApi::SetHostPromiseRejectionTracker(vm, data, data); 1438``` 1439 1440### SetHostResolveBufferTracker 1441 1442static void SetHostResolveBufferTracker(EcmaVM vm,std::function<bool(std::string dirPath, uint8_t*buff, size_t buffSize)> cb); 1443 1444该函数用于设置 Ecma 虚拟机的主机解析缓冲区跟踪器回调函数。 1445 1446回调函数通过 `std::function` 传递，接受目录路径（`dirPath`）和缓冲区指针（`uint8_t** buff`）及其大小指针（`size_t* buffSize`）作为参数，并返回一个布尔值，表示是否成功解析缓冲区。 1447 1448**参数：** 1449 1450| 参数名 | 类型 | 必填 | 说明 | 1451| ------ | ------------------------------------------------------------ | ---- | ----------------------------------- | 1452| vm | EcmaVM * | 是 | 虚拟机对象。 | 1453| cb | std::function<bool(std::string dirPath, uint8_t **buff, size_t *buffSize)> | 是 | 主机解析缓冲区跟踪器<br/>的回调函数 | 1454 1455**返回值：** 1456 1457无 1458 1459**示例：** 1460 1461```c++ 1462std::function<bool(std::string dirPath, uint8_t * *buff, size_t * buffSize)> cb = [](const std::string &inputPath, 1463 uint8_t **buff, size_t *buffSize) -> bool { 1464 if (inputPath.empty() || buff == nullptr || buffSize == nullptr) { 1465 return false; 1466 } 1467 return false; 1468}; 1469JSNApi::SetHostResolveBufferTracker(vm, cb); 1470``` 1471 1472### SetUnloadNativeModuleCallback 1473 1474static void SetUnloadNativeModuleCallback(EcmaVM *vm, const std::function<bool(const std::string &moduleKey)> &cb); 1475 1476自定义卸载本体模块时的行为。 1477 1478**参数：** 1479 1480| 参数名 | 类型 | 必填 | 说明 | 1481| ------ | ------------------------------------------------- | ---- | ------------------------------------------------------------ | 1482| vm | EcmaVM * | 是 | 虚拟机对象。 | 1483| cb | std::function<bool(const std::string &moduleKey)> | 是 | 回调函数接受一个 `moduleKey` 参数（字符串类型）<br/>并返回一个布尔值，表示是否成功卸载本地模块 | 1484 1485**返回值：** 1486 1487无 1488 1489**示例：** 1490 1491```c++ 1492bool UnloadNativeModuleCallback(const std::string &moduleKey) { 1493 return true; 1494} 1495JSNApi::SetUnloadNativeModuleCallback(vm, UnloadNativeModuleCallback); 1496``` 1497 1498### SetNativePtrGetter 1499 1500static void SetNativePtrGetter(EcmaVM *vm, void *cb); 1501 1502该函数用于设置 Ecma 虚拟机的本机指针获取器的回调函数。 1503 1504**参数：** 1505 1506| 参数名 | 类型 | 必填 | 说明 | 1507| ------ | -------- | ---- | -------------- | 1508| vm | EcmaVM * | 是 | 虚拟机对象。 | 1509| cb | Void * | 是 | 回调函数指针。 | 1510 1511**返回值：** 1512 1513无 1514 1515**示例：** 1516 1517```c++ 1518void *cb = reinterpret_cast<void *>(NativePtrGetterCallback); 1519JSNApi::SetNativePtrGetter(vm, cb); 1520``` 1521 1522### SetSourceMapTranslateCallback 1523 1524static void SetSourceMapTranslateCallback(EcmaVM *vm, SourceMapTranslateCallback cb); 1525 1526该函数用于设置 Ecma 虚拟机的源映射翻译回调函数。 1527 1528**参数：** 1529 1530| 参数名 | 类型 | 必填 | 说明 | 1531| -------- | -------------------------- | ---- | ---------------------------------- | 1532| vm | EcmaVM * | 是 | 虚拟机对象。 | 1533| callback | SourceMapTranslateCallback | 是 | 回调函数用于设置源映射翻译的回调。 | 1534 1535**返回值：** 1536 1537无 1538 1539**示例：** 1540 1541```c++ 1542bool SourceMapTranslateCallback(const std::string& sourceLocation, std::string& translatedLocation) { 1543 return true; 1544} 1545JSNApi::SetSourceMapTranslateCallback(vm, SourceMapTranslateCallback); 1546``` 1547 1548### DestroyMemMapAllocator 1549 1550static void DestroyMemMapAllocator(); 1551 1552该函数用于销毁内存映射分配器（MemMapAllocator）的实例。 1553 1554**参数：** 1555 1556无 1557 1558**返回值：** 1559 1560无 1561 1562**示例：** 1563 1564```c++ 1565JSNApi::DestroyMemMapAllocator(); 1566``` 1567 1568### DestroyPGOProfiler 1569 1570static void DestroyPGOProfiler(); 1571 1572该函数用于销毁性能分析（PGO，Profile-Guided Optimization）的分析器管理器实例。 1573 1574通过调用 `ecmascript::pgo::PGOProfilerManager::GetInstance()`获取 PGOProfilerManager 的单例实例，并调用 `Destroy` 方法进行销毁。 1575 1576**参数：** 1577 1578无 1579 1580**返回值：** 1581 1582无 1583 1584**示例：** 1585 1586```c++ 1587JSNApi::DestroyPGOProfiler(); 1588``` 1589 1590### ExecutePendingJob 1591 1592static void ExecutePendingJob(const EcmaVM *vm); 1593 1594该函数用于执行当前 Ecma 上下文中挂起的 Promise 任务。 1595 1596在执行前，通过 `CHECK_HAS_PENDING_EXCEPTION_WITHOUT_RETURN` 宏检查是否存在潜在的异常。 1597 1598**参数：** 1599 1600| 参数名 | 类型 | 必填 | 说明 | 1601| ------ | -------------- | ---- | ------------ | 1602| vm | const EcmaVM * | 是 | 虚拟机对象。 | 1603 1604**返回值：** 1605 1606无 1607 1608**示例：** 1609 1610```c++ 1611JSNApi::ExecutePendingJob(vm); 1612``` 1613 1614### PreFork 1615 1616static void PreFork(EcmaVM *vm); 1617 1618函数用于在执行 fork 操作之前，执行与 Ecma 虚拟机相关的预处理步骤。 1619 1620**参数：** 1621 1622| 参数名 | 类型 | 必填 | 说明 | 1623| ------ | -------- | ---- | ------------ | 1624| vm | EcmaVM * | 是 | 虚拟机对象。 | 1625 1626**返回值：** 1627 1628无 1629 1630**示例：** 1631 1632```c++ 1633JSRuntimeOptions option; 1634EcmaVM *workerVm = JSNApi::CreateEcmaVM(option); 1635JSNApi::PreFork(workerVm); 1636``` 1637 1638### PostFork 1639 1640static void PostFork(EcmaVM *vm, const RuntimeOption &option); 1641 1642该函数用于在执行 fork 操作之后，执行与 Ecma 虚拟机相关的后处理步骤。 1643 1644**参数：** 1645 1646| 参数名 | 类型 | 必填 | 说明 | 1647| ------ | --------------------- | ---- | -------------------- | 1648| vm | EcmaVM * | 是 | 虚拟机对象。 | 1649| option | const RuntimeOption & | 是 | 运行时选项和配置的类 | 1650 1651**返回值：** 1652 1653无 1654 1655**示例：** 1656 1657```c++ 1658RuntimeOption option; 1659JSNApi::PostFork(vm, option); 1660``` 1661 1662### ExecuteModuleBuffer 1663 1664static bool ExecuteModuleBuffer(EcmaVM *vm, const uint8_t *data, int32_t size, const std::string &filename = "",bool needUpdate = false); 1665 1666该函数用于执行传入的模块数据。 1667 1668在执行前，函数会检查是否存在潜在的异常（`CHECK_HAS_PENDING_EXCEPTION` 宏）。 1669 1670如果模块执行失败，会输出错误日志并返回 `false`，否则返回 `true`。 1671 1672**参数：** 1673 1674| 参数名 | 类型 | 必填 | 说明 | 1675| ---------- | ------------------ | ---- | ---------------------- | 1676| vm | EcmaVM * | 是 | 虚拟机对象。 | 1677| data | const uint8_t* | 是 | 表示模块数据的指针。 | 1678| size | int32_t | 是 | 表示模块数据的大小。 | 1679| filename | const std::string& | 否 | 表示模块的文件名。 | 1680| needUpdate | bool | 否 | 表示是否需要更新模块。 | 1681 1682**返回值：** 1683 1684| 类型 | 说明 | 1685| ---- | ---------------------- | 1686| bool | 表示模块执行是否成功。 | 1687 1688**示例：** 1689 1690```c++ 1691const char *fileName = "__JSNApiTests_ExecuteModuleBuffer.abc"; 1692const char *data = R"( 1693 .language ECMAScript 1694 .function any func_main_0(any a0, any a1, any a2) { 1695 ldai 1 1696 return 1697 } 1698)"; 1699bool res = 1700 JSNApi::ExecuteModuleBuffer(vm, reinterpret_cast<const uint8_t *>(data), sizeof(data), fileName); 1701``` 1702 1703### TriggerGC 1704 1705static void TriggerGC(const EcmaVM *vm, TRIGGER_GC_TYPE gcType = TRIGGER_GC_TYPE::SEMI_GC); 1706 1707该函数用于触发垃圾回收（GC）操作，可以选择不同的垃圾回收类型。 1708 1709通过调用虚拟机的 CollectGarbage 方法执行垃圾回收操作。 1710 1711在触发垃圾回收之前，通过 CHECK_HAS_PENDING_EXCEPTION_WITHOUT_RETURN 宏检查是否存在潜在的异常。 1712 1713**参数：** 1714 1715| 参数名 | 类型 | 必填 | 说明 | 1716| ------ | --------------- | ---- | ---------------------------------------------- | 1717| vm | const EcmaVM * | 是 | 虚拟机对象。 | 1718| gcType | TRIGGER_GC_TYPE | 否 | 是一个枚举类型，表示触发GC（垃圾回收）的类型。 | 1719 1720**返回值：** 1721 1722无 1723 1724**示例：** 1725 1726```c++ 1727JSNApi::TriggerGC(vm); 1728``` 1729 1730### ThrowException 1731 1732static void ThrowException(const EcmaVM *vm, Local<JSValueRef> error); 1733 1734该函数用于在 Ecma 虚拟机中抛出一个异常。 1735 1736在抛出之前，首先检查是否已经存在挂起的异常，如果存在则记录日志并返回，以保留先前的异常信息。 1737 1738通过 SetException 方法将传入的异常对象设置为当前线程的异常。 1739 1740**参数：** 1741 1742| 参数名 | 类型 | 必填 | 说明 | 1743| ------ | ----------------- | ---- | ------------ | 1744| vm | const EcmaVM * | 是 | 虚拟机对象。 | 1745| error | Local<JSValueRef> | 是 | 异常对象 | 1746 1747**返回值：** 1748 1749无 1750 1751**示例：** 1752 1753```c++ 1754Local<StringRef> message = StringRef::NewFromUtf8(vm, "ErrorTest"); 1755Local<JSValueRef> error = Exception::Error(vm,message); 1756JSNApi::ThrowException(vm, error); 1757``` 1758 1759### PrintExceptionInfo 1760 1761static void PrintExceptionInfo(const EcmaVM *vm); 1762 1763该函数用于打印当前潜在的异常信息，获取当前潜在的异常，如果不存在异常则直接返回。 1764 1765如果异常是 `JSError` 类型，会调用虚拟机的 `PrintJSErrorInfo` 方法打印详细错误信息。 1766 1767否则，将异常转化为字符串并输出到日志中。 1768 1769**参数：** 1770 1771| 参数名 | 类型 | 必填 | 说明 | 1772| ------ | -------------- | ---- | ------------ | 1773| vm | const EcmaVM * | 是 | 虚拟机对象。 | 1774 1775**返回值：** 1776 1777无 1778 1779**示例：** 1780 1781```c++ 1782 JSNApi::PrintExceptionInfo(vm); 1783``` 1784 1785## JSValueRef 1786 1787JSValueRef是一个用于表示JS值的类。它提供了一些方式来操作和访问JS中的各种数据类型，如字符串、数字、布尔值、对象、数组等。通过使用JSValueRef，您可以获取和设置JS值的属性和方法，执行函数调用，转换数据类型等。 1788 1789### Undefined 1790 1791Local<PrimitiveRef> JSValueRef::Undefined(const EcmaVM *vm)； 1792 1793用于获取一个表示未定义值的`Value`对象。这个函数通常在处理JavaScript和C++之间的数据转换时使用。 1794 1795**参数：** 1796 1797| 参数名 | 类型 | 必填 | 说明 | 1798| :----: | -------------- | ---- | ---------------- | 1799| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 1800 1801**返回值：** 1802 1803| 类型 | 说明 | 1804| ------------------- | ---------------- | 1805| Local<PrimitiveRef> | 返回为原生对象。 | 1806 1807**示例：** 1808 1809```C++ 1810Local<PrimitiveRef> primitive =JSValueRef::Undefined(vm); 1811``` 1812 1813### Null 1814 1815Local<PrimitiveRef> JSValueRef::Null(const EcmaVM *vm)； 1816 1817用于获取一个表示为Null的`Value`对象。这个函数通常在处理JavaScript和C++之间的数据转换时使用。 1818 1819**参数：** 1820 1821| 参数名 | 类型 | 必填 | 说明 | 1822| :----: | -------------- | ---- | ---------------- | 1823| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 1824 1825**返回值：** 1826 1827| 类型 | 说明 | 1828| ------------------- | ---------------- | 1829| Local<PrimitiveRef> | 返回为原生对象。 | 1830 1831**示例：** 1832 1833```C++ 1834Local<PrimitiveRef> primitive = JSValueRef::Null(vm); 1835``` 1836 1837### IsGeneratorObject 1838 1839bool JSValueRef::IsGeneratorObject()； 1840 1841判断是否为生成器对象。 1842 1843**参数：** 1844 1845| 参数名 | 类型 | 必填 | 说明 | 1846| ------ | ---- | ---- | ---- | 1847| 无参 | | | | 1848 1849**返回值：** 1850 1851| 类型 | 说明 | 1852| ---- | ------------------------------------- | 1853| bool | 是生成器对象返回true。否则返回false。 | 1854 1855**示例：** 1856 1857```C++ 1858ObjectFactory *factory = vm->GetFactory(); 1859auto env = vm->GetGlobalEnv(); 1860JSHandle<JSTaggedValue> genFunc = env->GetGeneratorFunctionFunction(); 1861JSHandle<JSGeneratorObject> genObjHandleVal = factory->NewJSGeneratorObject(genFunc); 1862JSHandle<JSHClass> hclass = JSHandle<JSHClass>::Cast(env->GetGeneratorFunctionClass()); 1863JSHandle<JSFunction> generatorFunc = JSHandle<JSFunction>::Cast(factory->NewJSObject(hclass)); 1864JSFunction::InitializeJSFunction(vm->GetJSThread(), generatorFunc, FunctionKind::GENERATOR_FUNCTION); 1865JSHandle<GeneratorContext> generatorContext = factory->NewGeneratorContext(); 1866generatorContext->SetMethod(vm->GetJSThread(), generatorFunc.GetTaggedValue()); 1867JSHandle<JSTaggedValue> generatorContextVal = JSHandle<JSTaggedValue>::Cast(generatorContext); 1868genObjHandleVal->SetGeneratorContext(vm->GetJSThread(), generatorContextVal.GetTaggedValue()); 1869JSHandle<JSTaggedValue> genObjTagHandleVal = JSHandle<JSTaggedValue>::Cast(genObjHandleVal); 1870Local<GeneratorObjectRef> genObjectRef = JSNApiHelper::ToLocal<GeneratorObjectRef>(genObjTagHandleVal); 1871bool b = genObjectRef->IsGeneratorObject(); 1872``` 1873 1874### IsUint8Array 1875 1876bool JSValueRef::IsUint8Array(); 1877 1878判断一个JSValueRef对象是否为Uint8Array类型。 1879 1880**参数：** 1881 1882无 1883 1884**返回值：** 1885 1886| 类型 | 说明 | 1887| ---- | ------------------------------------------------------------ | 1888| bool | 如果JSValueRef对象为Uint8Array类型，返回true。否则，返回false。 | 1889 1890**示例：** 1891 1892```c++ 1893Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm_, 5); 1894Local<Uint8ArrayRef> object = Uint8ArrayRef::New(vm_, buffer, 4, 5); 1895bool b = object->IsUint8Array(); 1896``` 1897 1898### IsInt8Array 1899 1900bool JSValueRef::IsInt8Array(); 1901 1902判断一个JSValueRef对象是否为Int8Array类型。 1903 1904**参数：** 1905 1906无 1907 1908**返回值：** 1909 1910| 类型 | 说明 | 1911| ---- | ------------------------------------------------------------ | 1912| bool | 如果JSValueRef对象为Int8Array类型，返回true。否则，返回false。 | 1913 1914**示例：** 1915 1916```c++ 1917Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm_, 5); 1918Local<ObjectRef> object = Int8ArrayRef::New(vm_, buffer, 4, 5); 1919bool b = object->IsInt8Array(); 1920``` 1921 1922### IsError 1923 1924bool JSValueRef::IsError(); 1925 1926判断一个JSValueRef对象是否为错误类型。 1927 1928**参数：** 1929 1930无 1931 1932**返回值：** 1933 1934| 类型 | 说明 | 1935| ---- | --------------------------------------------------------- | 1936| bool | 如果JSValueRef对象为错误类型，返回true。否则，返回false。 | 1937 1938**示例：** 1939 1940```c++ 1941Local<StringRef> message = StringRef::NewFromUtf8(vm_, "ErrorTest"); 1942bool b = message->IsError(); 1943``` 1944 1945### InstanceOf 1946 1947bool JSValueRef::InstanceOf(const EcmaVM *vm, Local<JSValueRef> value); 1948 1949检查一个特定的JSValueRef是否属于一个特定的EcmaVM对象。 1950 1951**参数：** 1952 1953| 参数名 | 类型 | 必填 | 说明 | 1954| ------ | ----------------- | ---- | ------------- | 1955| vm | const EcmaVM * | 是 | 虚拟机对象。 | 1956| value | Local<JSValueRef> | 是 | 指定的value。 | 1957 1958**返回值：** 1959 1960| 类型 | 说明 | 1961| ---- | ------------------------------------------------------------ | 1962| bool | 如果特定的JSValueRef属于特定的EcmaVM对象，返回true。否则，返回false。 | 1963 1964**示例：** 1965 1966```c++ 1967Local<ObjectRef> origin = ObjectRef::New(vm_); 1968Local<JSValueRef> ConstructObjectJSValueRef(const EcmaVM *vm){ 1969 // 构造一个JSValueRef类型的对象value 1970 // ... 1971 return value; // 返回参数value 1972} 1973bool b = origin->InstanceOf(vm_, ConstructObjectJSValueRef(vm_)); 1974``` 1975 1976### IsPromise 1977 1978bool JSValueRef::IsPromise(); 1979 1980判断一个JSValueRef对象是否为Promise类型。 1981 1982**参数：** 1983 1984无 1985 1986**返回值：** 1987 1988| 类型 | 说明 | 1989| ---- | ------------------------------------------------------------ | 1990| bool | 如果JSValueRef对象为PromiseRef类型，返回true。否则，返回false。 | 1991 1992**示例：** 1993 1994```c++ 1995Local<JSValueRef> tag = PromiseCapabilityRef::New(vm_)->GetPromise(vm_); 1996bool b = tag->IsPromise(); 1997``` 1998 1999### IsDate 2000 2001bool JSValueRef::IsDate(); 2002 2003判断一个JSValueRef对象是否为日期类型。 2004 2005**参数：** 2006 2007无 2008 2009**返回值：** 2010 2011| 类型 | 说明 | 2012| ---- | --------------------------------------------------------- | 2013| bool | 如果JSValueRef对象为日期类型，返回true。否则，返回false。 | 2014 2015**示例：** 2016 2017```c++ 2018double timeRef = 1.1; 2019Local<DateRef> dateRef = DateRef::New(vm_, timeRef); 2020bool b = dateRef->IsDate(); 2021``` 2022 2023### IsTypedArray 2024 2025bool JSValueRef::IsTypedArray(); 2026 2027检查一个JSValueRef对象是否为类型化数组（TypedArray）。 2028 2029**参数：** 2030 2031无 2032 2033**返回值：** 2034 2035| 类型 | 说明 | 2036| ---- | ----------------------------------------------------------- | 2037| bool | 如果JSValueRef对象为类型化数组，返回true。否则，返回false。 | 2038 2039**示例：** 2040 2041```c++ 2042int input = 123; 2043Local<JSValueRef> res = IntegerRef::New(vm_, input); 2044bool b = res->IsTypedArray(); 2045``` 2046 2047### IsDataView 2048 2049bool JSValueRef::IsDataView(); 2050 2051判断一个JSValueRef对象是否为DataView类型。 2052 2053**参数：** 2054 2055无 2056 2057**返回值：** 2058 2059| 类型 | 说明 | 2060| ---- | ------------------------------------------------------------ | 2061| bool | 如果JSValueRef对象为DataViewRef类型，返回true。否则，返回false。 | 2062 2063**示例：** 2064 2065```c++ 2066Local<JSValueRef> tag = DataViewRef::New(vm_,ArrayBufferRef::New(vm_,0),0,0); 2067bool b = tag->IsDataView(); 2068``` 2069 2070### IsBuffer 2071 2072bool JSValueRef::IsBuffer(); 2073 2074判断一个JSValueRef对象是否为Buffer类型。 2075 2076**参数：** 2077 2078无 2079 2080**返回值：** 2081 2082| 类型 | 说明 | 2083| ---- | ----------------------------------------------------------- | 2084| bool | 如果JSValueRef对象为Buffer类型，返回true。否则，返回false。 | 2085 2086**示例：** 2087 2088```c++ 2089int32_t length = 15; 2090Local<BufferRef> bufferRef = BufferRef::New(vm_, length); 2091bool b = bufferRef->IsBuffer(); 2092``` 2093 2094### IsArrayBuffer 2095 2096bool JSValueRef::IsArrayBuffer(); 2097 2098判断一个JSValueRef对象是否为ArrayBuffer类型。 2099 2100**参数：** 2101 2102无 2103 2104**返回值：** 2105 2106| 类型 | 说明 | 2107| ---- | ------------------------------------------------------------ | 2108| bool | 如果JSValueRef对象为ArrayBuffer类型，返回true。否则，返回false。 | 2109 2110**示例：** 2111 2112```c++ 2113Local<ArrayBufferRef> ConstructObjectArrBufRef(const EcmaVM *vm, const int32_t length_){ 2114 // 构造一个ArrayBufferRef类型的对象arrayBuffer 2115 // ... 2116 return arrayBuffer; // 返回arrayBuffer 2117} 2118Local<ArrayBufferRef> arrayBuf = ConstructObjectArrBufRef(vm_, 15); 2119bool b = arrayBuf->IsArrayBuffer(); 2120``` 2121 2122### IsArray 2123 2124bool JSValueRef::IsArray(const EcmaVM *vm); 2125 2126判断一个JSValueRef对象是否为数组类型。 2127 2128**参数：** 2129 2130| 参数名 | 类型 | 必填 | 说明 | 2131| ------ | -------------- | ---- | ------------ | 2132| vm | const EcmaVM * | 是 | 虚拟机对象。 | 2133 2134**返回值：** 2135 2136| 类型 | 说明 | 2137| ---- | --------------------------------------------------------- | 2138| bool | 如果JSValueRef对象是数组类型，返回true。否则，返回false。 | 2139 2140**示例：** 2141 2142```c++ 2143uint32_t length = 3; 2144Local<ArrayRef> arrayObject = ArrayRef::New(vm_, length); 2145bool b = arrayObject->IsArray(vm_); 2146``` 2147 2148### ToObject 2149 2150Local<ObjectRef> JSValueRef::ToObject(const EcmaVM *vm); 2151 2152将一个JSValueRef对象转换为ObjectRef对象。 2153 2154**参数：** 2155 2156| 参数名 | 类型 | 必填 | 说明 | 2157| ------ | -------------- | ---- | ------------ | 2158| vm | const EcmaVM * | 是 | 虚拟机对象。 | 2159 2160**返回值：** 2161 2162| 类型 | 说明 | 2163| ---------------- | ----------------------------------- | 2164| Local<ObjectRef> | 返回转换后的 ObjectRef 类型的对象。 | 2165 2166**示例：** 2167 2168```c++ 2169int input = 0; 2170Local<IntegerRef> intValue = IntegerRef::New(vm_, input); 2171Local<ObjectRef> object = intValue->ToObject(vm_); 2172``` 2173 2174### ToNumber 2175 2176Local<NumberRef> JSValueRef::ToNumber(const EcmaVM *vm); 2177 2178将一个JSValueRef对象转换为NumberRef对象。 2179 2180**参数：** 2181 2182| 参数名 | 类型 | 必填 | 说明 | 2183| ------ | -------------- | ---- | ------------ | 2184| vm | const EcmaVM * | 是 | 虚拟机对象。 | 2185 2186**返回值：** 2187 2188| 类型 | 说明 | 2189| ---------------- | ----------------------------------- | 2190| Local<NumberRef> | 返回转换后的 NumberRef 类型的对象。 | 2191 2192**示例：** 2193 2194```c++ 2195Local<StringRef> toString = StringRef::NewFromUtf8(vm_, "-123.3"); 2196Local<JSValueRef> toValue(toString); 2197Local<NumberRef> number = toString->ToNumber(vm_); 2198``` 2199 2200### ToBoolean 2201 2202Local<BooleanRef> JSValueRef::ToBoolean(const EcmaVM *vm); 2203 2204将一个JSValueRef对象转换为布尔值（BooleanRef）。 2205 2206**参数：** 2207 2208| 参数名 | 类型 | 必填 | 说明 | 2209| ------ | -------------- | ---- | ------------ | 2210| vm | const EcmaVM * | 是 | 虚拟机对象。 | 2211 2212**返回值：** 2213 2214| 类型 | 说明 | 2215| ----------------- | ------------------------------------ | 2216| Local<BooleanRef> | 返回转换后的 BooleanRef 类型的对象。 | 2217 2218**示例：** 2219 2220```c++ 2221Local<IntegerRef> intValue = IntegerRef::New(vm_, 0); 2222Local<BooleanRef> boo = intValue->ToBoolean(vm_); 2223``` 2224 2225### IsObject 2226 2227bool JSValueRef::IsObject(); 2228 2229判断一个JSValueRef对象是否为Object类型。 2230 2231**参数：** 2232 2233无 2234 2235**返回值：** 2236 2237| 类型 | 说明 | 2238| ---- | ----------------------------------------------------------- | 2239| bool | 如果JSValueRef对象是Object类型，返回true。否则，返回false。 | 2240 2241**示例：** 2242 2243```c++ 2244Local<JSValueRef> res = ObjectRef::New(vm_); 2245bool b = res->IsObject(); 2246``` 2247 2248### IsBigInt 2249 2250bool JSValueRef::IsBigInt(); 2251 2252判断一个JSValueRef对象是否为BigInt类型。 2253 2254**参数：** 2255 2256无 2257 2258**返回值：** 2259 2260| 类型 | 说明 | 2261| ---- | ----------------------------------------------------------- | 2262| bool | 如果JSValueRef对象为BigInt类型，返回true。否则，返回false。 | 2263 2264**示例：** 2265 2266```c++ 2267int input = 2147483646; 2268Local<IntegerRef> intValue = IntegerRef::New(vm_, input); 2269bool b = intValue->IsBigInt(); 2270``` 2271 2272### IsSymbol 2273 2274bool JSValueRef::IsSymbol(); 2275 2276判断一个JSValueRef对象是否为Symbol类型。 2277 2278**参数：** 2279 2280无 2281 2282**返回值：** 2283 2284| 类型 | 说明 | 2285| ---- | ----------------------------------------------------------- | 2286| bool | 如果JSValueRef对象是Symbol类型，返回true。否则，返回false。 | 2287 2288**示例：** 2289 2290```c++ 2291int input = 123; 2292Local<JSValueRef> res = IntegerRef::New(vm_,input); 2293bool b = res->IsSymbol(); 2294``` 2295 2296### IsUndefined 2297 2298bool JSValueRef::IsUndefined(); 2299 2300判断一个JSValueRef对象是否为未定义类型。 2301 2302**参数：** 2303 2304无 2305 2306**返回值：** 2307 2308| 类型 | 说明 | 2309| ---- | ----------------------------------------------------------- | 2310| bool | 如果JSValueRef对象为未定义类型，返回true。否则，返回false。 | 2311 2312**示例：** 2313 2314```c++ 2315Local<JSValueRef> tag = JSValueRef::Undefined(vm_); 2316bool b = tag->IsUndefined(); 2317``` 2318 2319 2320 2321### IsBoolean 2322 2323bool JSValueRef::IsBoolean(); 2324 2325判断一个JSValueRef对象是否为布尔值。 2326 2327**参数：** 2328 2329无 2330 2331**返回值：** 2332 2333| 类型 | 说明 | 2334| ---- | ------------------------------------------------------- | 2335| bool | 如果JSValueRef对象为布尔值，返回true。否则，返回false。 | 2336 2337**示例：** 2338 2339```c++ 2340Local<JSValueRef> tag = BooleanRef::New(vm_,false); 2341bool b = tag->IsBoolean(); 2342``` 2343 2344### IsNull 2345 2346bool JSValueRef::IsNull(); 2347 2348判断一个JSValueRef对象是否为空。 2349 2350**参数：** 2351 2352无 2353 2354**返回值：** 2355 2356| 类型 | 说明 | 2357| ---- | --------------------------------------------------- | 2358| bool | 如果JSValueRef对象为空，返回true。否则，返回false。 | 2359 2360**示例：** 2361 2362```c++ 2363Local<JSValueRef> tag = JSValueRef::Null(vm_); 2364bool b = tag->IsNull(); 2365``` 2366 2367 2368 2369### IsNativePointer 2370 2371bool JSValueRef::IsNativePointer(); 2372 2373判断一个JSValueRef对象是否为本地指针。 2374 2375**参数：** 2376 2377无 2378 2379**返回值：** 2380 2381| 类型 | 说明 | 2382| ---- | --------------------------------------------------------- | 2383| bool | 如果JSValueRef对象为本地指针，返回true。否则，返回false。 | 2384 2385**示例：** 2386 2387```c++ 2388void *vps = static_cast<void *>(new std::string("test")); 2389void *vps1 = static_cast<void *>(new std::string("test")); 2390Local<NativePointerRef> res_vps = 2391 NativePointerRef::New(vm_, vps, NativeAreaAllocator::FreeBufferFunc, vps1, 0); 2392bool b = res_vps->IsNativePointer(); 2393``` 2394 2395### IsFunction 2396 2397bool JSValueRef::IsFunction(); 2398 2399判断一个JSValueRef对象是否为函数。 2400 2401**参数：** 2402 2403无 2404 2405**返回值：** 2406 2407| 类型 | 说明 | 2408| ---- | ----------------------------------------------------- | 2409| bool | 如果JSValueRef对象为函数，返回true。否则，返回false。 | 2410 2411**示例：** 2412 2413```c++ 2414Local<FunctionRef> ConstructObjectFunctionRef(EcmaVM *vm, size_t nativeBindingsize){ 2415 // 构造一个FunctionRef类型对象obj 2416 // ... 2417 return obj; // 返回obj 2418} 2419Local<FunctionRef> object = ConstructObjectFunctionRef(vm_, 15); 2420bool b = object->IsFunction(); 2421``` 2422 2423### IsString 2424 2425bool JSValueRef::IsString(); 2426 2427判断一个JSValueRef对象是否为字符串。 2428 2429**参数：** 2430 2431无 2432 2433**返回值：** 2434 2435| 类型 | 说明 | 2436| ---- | ------------------------------------------------------- | 2437| bool | 如果JSValueRef对象为字符串，返回true。否则，返回false。 | 2438 2439**示例：** 2440 2441```c++ 2442Local<JSValueRef> tag = StringRef::NewFromUtf8(vm_,"abc"); 2443bool b = tag->IsString(); 2444``` 2445 2446### IsNumber 2447 2448bool JSValueRef::IsNumber(); 2449 2450判断一个JSValueRef对象是否为数字。 2451 2452**参数：** 2453 2454无 2455 2456**返回值：** 2457 2458| 类型 | 说明 | 2459| ---- | ----------------------------------------------------- | 2460| bool | 如果JSValueRef对象为数字，返回true。否则，返回false。 | 2461 2462**示例：** 2463 2464```c++ 2465Local<NumberRef> resUnit32 = NumberRef::New(vm_, inputUnit32); 2466bool b = resUnit32->IsNumber(); 2467``` 2468 2469### True 2470 2471static Local<PrimitiveRef> True(const EcmaVM *vm); 2472 2473检查一个值是否为True对象。 2474 2475**参数：** 2476 2477| 参数名 | 类型 | 必填 | 说明 | 2478| ------ | -------------- | ---- | ---------- | 2479| vm | const EcmaVM * | 是 | 虚拟机对象 | 2480 2481**返回值：** 2482 2483| 类型 | 说明 | 2484| :------------------ | :----------------------------------------------------------- | 2485| Local<PrimitiveRef> | 创建一个表示布尔值true的JSValueRef对象，转换为PrimitiveRef类型的本地引用，并返回。 | 2486 2487**示例：** 2488 2489```c++ 2490Local<BooleanRef> boolValue = BooleanRef::New(vm_, true); 2491Local<PrimitiveRef> result = boolValue->True(vm_); 2492``` 2493 2494### False 2495 2496static Local<PrimitiveRef> False(const EcmaVM *vm); 2497 2498检查一个值是否为False对象。 2499 2500**参数：** 2501 2502| 参数名 | 类型 | 必填 | 说明 | 2503| ------ | -------------- | ---- | ---------- | 2504| vm | const EcmaVM * | 是 | 虚拟机对象 | 2505 2506**返回值：** 2507 2508| 类型 | 说明 | 2509| :------------------ | :----------------------------------------------------------- | 2510| Local<PrimitiveRef> | 创建一个表示布尔值false的JSValueRef对象，转换为PrimitiveRef类型的本地引用，并返回。 | 2511 2512**示例：** 2513 2514```c++ 2515Local<BooleanRef> boolValue = BooleanRef::New(vm_, false); 2516Local<PrimitiveRef> result = boolValue->True(vm_); 2517``` 2518 2519### IsFalse 2520 2521bool IsFalse(); 2522 2523用于判断该对象是否为False对象。 2524 2525**参数：** 2526 2527无 2528 2529**返回值：** 2530 2531| 类型 | 说明 | 2532| :------ | :--------------------------------------------- | 2533| boolean | 如果该对象为false，则返回true，否则返回false。 | 2534 2535**示例：** 2536 2537```c++ 2538Local<BooleanRef> boolValue = BooleanRef::New(vm_, false); 2539bool result = boolValue->IsFalse(); 2540``` 2541 2542### IsJSArray 2543 2544bool IsJSArray(const EcmaVM *vm); 2545 2546用于判断是否为JS的数组类型。 2547 2548**参数：** 2549 2550| 参数名 | 类型 | 必填 | 说明 | 2551| ------ | -------------- | ---- | ---------- | 2552| vm | const EcmaVM * | 是 | 虚拟机对象 | 2553 2554**返回值：** 2555 2556| 类型 | 说明 | 2557| :------ | :---------------------------------------------------- | 2558| boolean | 如果该对象是JS的数组类型，则返回true，否则返回false。 | 2559 2560**示例：** 2561 2562```c++ 2563JSArray *arr = JSArray::ArrayCreate(thread_, JSTaggedNumber(number)).GetObject<JSArray>(); 2564JSHandle<JSTaggedValue> obj(thread_, arr); 2565Local<JSValueRef> JSArrayObject = JSNApiHelper::ToLocal<JSValueRef>(obj); 2566bool result = JSArrayObject->IsJSArray(vm_); 2567``` 2568 2569### IsConstructor 2570 2571bool IsConstructor(); 2572 2573用于判断是否为构造函数类型。 2574 2575**参数：** 2576 2577无 2578 2579**返回值：** 2580 2581| 类型 | 说明 | 2582| :------ | :---------------------------------------------------- | 2583| boolean | 如果该对象是构造函数类型，则返回true，否则返回false。 | 2584 2585**示例：** 2586 2587```c++ 2588ObjectFactory *factory = vm_->GetFactory(); 2589JSHandle<GlobalEnv> env = vm_->GetGlobalEnv(); 2590JSHandle<JSFunction> func = factory->NewJSFunction(env, static_cast<void *>(nullptr), FunctionKind::BASE_CONSTRUCTOR); 2591JSHandle<JSObject> nullHandle(thread_, JSTaggedValue::Null()); 2592JSHandle<JSObject> obj = JSObject::ObjectCreate(thread_, nullHandle); 2593JSHandle<JSTaggedValue> objValue(obj); 2594[[maybe_unused]] bool makeConstructor = JSFunction::MakeConstructor(thread_, func, objValue); 2595JSHandle<JSTaggedValue> funcHandle(func); 2596Local<JSValueRef> funConstructor = JSNApiHelper::ToLocal<JSValueRef>(funcHandle); 2597bool result = funConstructor->IsConstructor(); 2598``` 2599 2600### IsWeakRef 2601 2602bool IsWeakRef(); 2603 2604用于判断是否为WeakRef对象。 2605 2606**参数：** 2607 2608无 2609 2610**返回值：** 2611 2612| 类型 | 说明 | 2613| :------ | :----------------------------------------------- | 2614| boolean | 如果该对象是WeakRef，则返回true，否则返回false。 | 2615 2616**示例：** 2617 2618```c++ 2619JSFunction *jsFunc = vm_->GetGlobalEnv()->GetObjectFunction().GetObject<JSFunction>(); 2620JSHandle<JSTaggedValue> jsFuncTagValue(thread, jsFunc); 2621JSHandle<JSObject> newObj = vm_->GetFactory()->NewJSObjectByConstructor(JSHandle<JSFunction>(jsFunc), jsFuncTagValue); 2622JSTaggedValue value(newObj); 2623value.CreateWeakRef(); 2624bool result = JSNApiHelper::ToLocal<JSValueRef>(value);->IsWeakRef(); 2625``` 2626 2627### IsArrayIterator 2628 2629bool IsArrayIterator(); 2630 2631用于判断该对象是否为数组迭代器。 2632 2633**参数：** 2634 2635无 2636 2637**返回值：** 2638 2639| 类型 | 说明 | 2640| :------ | :-------------------------------------------------- | 2641| boolean | 如果该对象是数组迭代器，则返回true，否则返回false。 | 2642 2643**示例：** 2644 2645```c++ 2646ObjectFactory *factory = vm_->GetFactory(); 2647JSHandle<TaggedArray> handleTaggedArrayFrom = vm_->GetFactory()->NewTaggedArray(arrayLength); 2648JSHandle<JSObject> handleJSObjectTaggedArrayFrom = JSArray::CreateArrayFromList(thread, handleTaggedArrayFrom); 2649JSHandle<JSArrayIterator> handleJSArrayIter = 2650 factory->NewJSArrayIterator(handleJSObjectTaggedArrayFrom,IterationKind::KEY); 2651JSHandle<JSTaggedValue> jsTagValue = JSHandle<JSTaggedValue>::Cast(handleJSArrayIter); 2652bool result = JSNApiHelper::ToLocal<JSValueRef>(jsTagValue)->IsStringIterator(); 2653``` 2654 2655### IsStringIterator 2656 2657bool IsStringIterator(); 2658 2659用于判断该对象是否为字符串迭代器。 2660 2661**参数：** 2662 2663无 2664 2665**返回值：** 2666 2667| 类型 | 说明 | 2668| :------ | :------------------------------------------------------ | 2669| boolean | 如果该对象是字符串的迭代器，则返回true，否则返回false。 | 2670 2671**示例：** 2672 2673```c++ 2674JSHandle<EcmaString> recordName = vm_->GetFactory()->NewFromUtf8("646458"); 2675JSHandle<JSStringIterator> jsStringIter = JSStringIterator::CreateStringIterator(vm_->GetJSThread(), recordName); 2676JSHandle<JSTaggedValue> setTag = JSHandle<JSTaggedValue>::Cast(jsStringIter); 2677bool result = JSNApiHelper::ToLocal<StringRef>(setTag)->IsStringIterator(); 2678``` 2679 2680### IsJSPrimitiveInt 2681 2682bool IsJSPrimitiveInt(); 2683 2684用于判断是否为JS的原始整数类型。 2685 2686**参数：** 2687 2688无 2689 2690**返回值：** 2691 2692| 类型 | 说明 | 2693| :------ | :-------------------------------------------------------- | 2694| boolean | 如果该对象是JS的原始整数类型，则返回true，否则返回false。 | 2695 2696**示例：** 2697 2698```c++ 2699JSHandle<JSTaggedValue> jsTagValue; 2700JSHandle<JSPrimitiveRef> jsPrimitive = 2701 vm_->GetFactory()->NewJSPrimitiveRef(PrimitiveType::PRIMITIVE_BIGINT, jsTagValue); 2702JSHandle<JSTaggedValue> jsPriTagValue = JSHandle<JSTaggedValue>::Cast(jsPrimitive); 2703bool result = JSNApiHelper::ToLocal<JSValueRef>(jsPriTagValue)->IsJSPrimitiveInt(); 2704``` 2705 2706### IsTreeMap 2707 2708bool IsTreeMap(); 2709 2710用于判断该对象是否为TreeMap类型。 2711 2712**参数：** 2713 2714无 2715 2716**返回值：** 2717 2718| 类型 | 说明 | 2719| :------ | :--------------------------------------------------- | 2720| boolean | 如果该对象是TreeMap类型，则返回true，否则返回false。 | 2721 2722**示例：** 2723 2724```c++ 2725JSHandle<JSTaggedValue> proto = vm_->GetGlobalEnv()->GetObjectFunctionPrototype(); 2726JSHandle<JSHClass> mapClass = vm_->GetFactory()->NewEcmaHClass(JSAPITreeMap::SIZE, JSType::JS_API_TREE_MAP, proto); 2727JSHandle<JSAPITreeMap> jsTreeMap = JSHandle<JSAPITreeMap>::Cast(factory->NewJSObjectWithInit(mapClass)); 2728JSHandle<TaggedTreeMap> treeMap(thread, TaggedTreeMap::Create(thread)); 2729jsTreeMap->SetTreeMap(thread, treeMap); 2730JSHandle<JSTaggedValue> treeMapTagValue = JSHandle<JSTaggedValue>::Cast(jsTreeMap); 2731bool result = JSNApiHelper::ToLocal<ArrayRef>(treeMapTagValue)->IsTreeMap(); 2732``` 2733 2734### IsTreeSet 2735 2736bool IsTreeSet(); 2737 2738用于判断该对象是否为树集。 2739 2740**参数：** 2741 2742无 2743 2744**返回值：** 2745 2746| 类型 | 说明 | 2747| :------ | :-------------------------------------------- | 2748| boolean | 如果该对象是树集，则返回true，否则返回false。 | 2749 2750**示例：** 2751 2752```c++ 2753JSHandle<JSTaggedValue> proto = vm_->GetGlobalEnv()->GetObjectFunctionPrototype(); 2754JSHandle<JSHClass> setClass = vm_->GetFactory()->NewEcmaHClass(JSAPITreeSet::SIZE, JSType::JS_API_TREE_SET, proto); 2755JSHandle<JSAPITreeSet> jsTreeSet = JSHandle<JSAPITreeSet>::Cast(factory->NewJSObjectWithInit(setClass)); 2756JSHandle<TaggedTreeSet> treeSet(thread, TaggedTreeSet::Create(thread)); 2757jsTreeSet->SetTreeSet(thread, treeSet); 2758JSHandle<JSTaggedValue> treeSetTagValue = JSHandle<JSTaggedValue>::Cast(jsTreeSet); 2759bool result = JSNApiHelper::ToLocal<ArrayRef>(treeSetTagValue)->IsTreeSet(); 2760``` 2761 2762### IsVector 2763 2764bool IsVector(); 2765 2766用于判断该对象是否为Vector容器。 2767 2768**参数：** 2769 2770无 2771 2772**返回值：** 2773 2774| 类型 | 说明 | 2775| :------ | :-------------------------------------------------- | 2776| boolean | 如果该对象是Vector容器，则返回true，否则返回false。 | 2777 2778**示例：** 2779 2780```c++ 2781JSHandle<JSTaggedValue> proto = vm_->GetGlobalEnv()->GetFunctionPrototype(); 2782JSHandle<JSHClass> vectorClass = vm_->GetFactory()->NewEcmaHClass(JSAPIVector::SIZE, JSType::JS_API_VECTOR, proto); 2783JSHandle<JSAPIVector> jsVector = JSHandle<JSAPIVector>::Cast(factory->NewJSObjectWithInit(vectorClass)); 2784jsVector->SetLength(length); 2785JSHandle<JSTaggedValue> vectorTagValue = JSHandle<JSTaggedValue>::Cast(jsVector); 2786bool result = JSNApiHelper::ToLocal<ArrayRef>(vectorTagValue)->IsVector(); 2787``` 2788 2789### IsArgumentsObject 2790 2791bool IsArgumentsObject(); 2792 2793用于判断该对象是否为参数对象。 2794 2795**参数：** 2796 2797无 2798 2799**返回值：** 2800 2801| 类型 | 说明 | 2802| :------ | :------------------------------------------------ | 2803| boolean | 如果该对象是参数对象，则返回true，否则返回false。 | 2804 2805**示例：** 2806 2807```c++ 2808JSHandle<JSArguments> obj = vm_->GetFactory()->NewJSArguments(); 2809JSHandle<JSTaggedValue> argumentTag = JSHandle<JSTaggedValue>::Cast(obj); 2810bool result = JSNApiHelper::ToLocal<ObjectRef>(argumentTag)->IsArgumentsObject(); 2811``` 2812 2813### IsAsyncFunction 2814 2815bool IsAsyncFunction(); 2816 2817用于判断是否为异步函数。 2818 2819**参数：** 2820 2821无 2822 2823**返回值：** 2824 2825| 类型 | 说明 | 2826| :------ | :------------------------------------------ | 2827| boolean | 如果是异步函数，则返回true，否则返回false。 | 2828 2829**示例：** 2830 2831```c++ 2832JSHandle<JSAsyncFuncObject> asyncFuncObj = vm_->GetFactory()->NewJSAsyncFuncObject(); 2833JSHandle<JSTaggedValue> asyncFuncTag = JSHandle<JSTaggedValue>::Cast(asyncFuncObj); 2834bool result = JSNApiHelper::ToLocal<ObjectRef>(asyncFuncTag)->IsAsyncFunction(); 2835``` 2836 2837### IsGeneratorFunction 2838 2839bool IsGeneratorFunction(); 2840 2841用于判断是否为生成器函数。 2842 2843**参数：** 2844 2845无 2846 2847**返回值：** 2848 2849| 类型 | 说明 | 2850| :------ | :-------------------------------------------------- | 2851| boolean | 如果该对象是生成器函数，则返回true，否则返回false。 | 2852 2853**示例：** 2854 2855```c++ 2856JSHandle<JSTaggedValue> genFunc = vm_->GetGlobalEnv()->GetGeneratorFunctionFunction(); 2857JSHandle<JSGeneratorObject> genObjHandleVal = vm_->GetFactory()->NewJSGeneratorObject(genFunc); 2858JSHandle<JSTaggedValue> genObjTagHandleVal = JSHandle<JSTaggedValue>::Cast(genObjHandleVal); 2859Local<GeneratorObjectRef> genObjectRef = JSNApiHelper::ToLocal<GeneratorObjectRef>(genObjTagHandleVal); 2860Local<JSValueRef> object = genObjectRef->GetGeneratorFunction(vm_); 2861bool result = res->IsGeneratorFunction(); 2862``` 2863 2864### IsBigInt64Array 2865 2866bool IsBigInt64Array(); 2867 2868用于判断该对象是否为用于存储任意长度的有符号64位整数数组。 2869 2870**参数：** 2871 2872无 2873 2874**返回值：** 2875 2876| 类型 | 说明 | 2877| :------ | :----------------------------------------------------------- | 2878| boolean | 如果该对象是任意长度的有符号64位整数数组，则返回true，否则返回false。 | 2879 2880**示例：** 2881 2882```c++ 2883Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm_, bufferLength); 2884Local<ObjectRef> object = BigInt64ArrayRef::New(vm_, buffer, bufferOffset, offsetLength); 2885bool result = object->IsBigInt64Array(); 2886``` 2887 2888### IsBigUint64Array 2889 2890bool IsBigUint64Array(); 2891 2892用于判断该对象是否为用于存储任意长度的无符号64位整数数组。 2893 2894**参数：** 2895 2896无 2897 2898**返回值：** 2899 2900| 类型 | 说明 | 2901| :------ | :----------------------------------------------------------- | 2902| boolean | 如果该对象是任意长度的无符号64位整数数组，则返回true，否则返回false。 | 2903 2904**示例：** 2905 2906```c++ 2907Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm_, 5); 2908Local<ObjectRef> object = BigUint64ArrayRef::New(vm_, buffer, bufferOffset, offsetLength); 2909bool result = object->IsBigUint64Array(); 2910``` 2911 2912### IsSharedArrayBuffer 2913 2914bool IsSharedArrayBuffer(); 2915 2916用于判断该对象是否为共享的ArrayBuffer对象。 2917 2918**参数：** 2919 2920无 2921 2922**返回值：** 2923 2924| 类型 | 说明 | 2925| :------ | :--------------------------------------------------------- | 2926| boolean | 如果该对象是共享的ArrayBuffer，则返回true，否则返回false。 | 2927 2928**示例：** 2929 2930```c++ 2931JSHandle<JSArrayBuffer> jsArrayBuffer = vm_->GetFactory()->NewJSSharedArrayBuffer(bufferLength); 2932JSHandle<JSTaggedValue> jsTagValueBuffer = JSHandle<JSTaggedValue>::Cast(jsArrayBuffer); 2933bool result = JSNApiHelper::ToLocal<ArrayRef>(jsTagValueBuffer)->IsSharedArrayBuffer(); 2934``` 2935 2936### IsUint8ClampedArray 2937 2938bool JSValueRef::IsUint8ClampedArray(); 2939 2940判断对象是否为Uint8ClampedArray类型。 2941 2942**参数：** 2943 2944无 2945 2946**返回值：** 2947 2948| 类型 | 说明 | 2949| ---- | ---------------------------------------------------------- | 2950| bool | 如果调用对象的类型为Uint8ClampedArray返回True否则返回False | 2951 2952**示例：** 2953 2954```c++ 2955Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm, arrayLenth); 2956Local<JSValueRef> val = Uint8ClampedArrayRef::New(vm, buffer, Offset, OffsetLenth); 2957bool res = val->IsUint8ClampedArray(); 2958``` 2959 2960### IsInt16Array 2961 2962bool JSValueRef::IsInt16Array(); 2963 2964判断对象是否为Int16Array类型。 2965 2966**参数：** 2967 2968无 2969 2970**返回值：** 2971 2972| 类型 | 说明 | 2973| ---- | --------------------------------------------------- | 2974| bool | 如果调用对象的类型为Int16Array返回True否则返回False | 2975 2976**示例：** 2977 2978```c++ 2979Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm, arrayLenth); 2980Local<JSValueRef> val = Int16ArrayRef::New(vm, buffer, Offset, OffsetLenth); 2981bool res = val->IsInt16Array(); 2982``` 2983 2984### IsUint16Array 2985 2986bool JSValueRef::IsUint16Array(); 2987 2988判断对象是否为Uint16Array类型。 2989 2990**参数：** 2991 2992无 2993 2994**返回值：** 2995 2996| 类型 | 说明 | 2997| ---- | ---------------------------------------------------- | 2998| bool | 如果调用对象的类型为Uint16Array返回True否则返回False | 2999 3000**示例：** 3001 3002```c++ 3003Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm, arrayLenth); 3004Local<JSValueRef> val = Uint16ArrayRef::New(vm, buffer, Offset, OffsetLenth); 3005bool res = val->IsUint16Array(); 3006``` 3007 3008### IsInt32Array 3009 3010bool JSValueRef::IsInt32Array(); 3011 3012判断对象是否为Int32Array类型。 3013 3014**参数：** 3015 3016无 3017 3018**返回值：** 3019 3020| 类型 | 说明 | 3021| ---- | --------------------------------------------------- | 3022| bool | 如果调用对象的类型为Int32Array返回True否则返回False | 3023 3024**示例：** 3025 3026```c++ 3027Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm, 30); 3028Local<JSValueRef> val = Int32ArrayRef::New(vm, buffer, 4, 6); 3029bool res = val->IsInt32Array(); 3030``` 3031 3032### IsUint32Array 3033 3034bool JSValueRef::IsUint32Array(); 3035 3036判断对象是否为Uint32Array类型。 3037 3038**参数：** 3039 3040无 3041 3042**返回值：** 3043 3044| 类型 | 说明 | 3045| ---- | ---------------------------------------------------- | 3046| bool | 如果调用对象的类型为Uint32Array返回True否则返回False | 3047 3048**示例：** 3049 3050```c++ 3051Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm, 30); 3052Local<JSValueRef> val = Uint32ArrayRef::New(vm, buffer, 4, 6); 3053bool res = val->IsUint32Array(); 3054``` 3055 3056### IsFloat32Array 3057 3058bool JSValueRef::IsFloat32Array(); 3059 3060判断对象是否为Float32Array类型。 3061 3062**参数：** 3063 3064无 3065 3066**返回值：** 3067 3068| 类型 | 说明 | 3069| ---- | ----------------------------------------------------- | 3070| bool | 如果调用对象的类型为Float32Array返回True否则返回False | 3071 3072**示例：** 3073 3074```c++ 3075Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm, 30); 3076Local<JSValueRef> val = Float32ArrayRef::New(vm, buffer, 4, 6); 3077bool res = val->IsFloat32Array(); 3078``` 3079 3080### IsFloat64Array 3081 3082bool JSValueRef::IsFloat64Array(); 3083 3084判断对象是否为Float64Array类型。 3085 3086**参数：** 3087 3088无 3089 3090**返回值：** 3091 3092| 类型 | 说明 | 3093| ---- | ----------------------------------------------------- | 3094| bool | 如果调用对象的类型为Float64Array返回True否则返回False | 3095 3096**示例：** 3097 3098```c++ 3099Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm, arrayLength); 3100Local<JSValueRef> val = Float64ArrayRef::New(vm, buffer, eOffset, eOffsetLength); 3101bool res = val->IsFloat64Array(); 3102``` 3103 3104### IsJSPrimitiveBoolean 3105 3106bool JSValueRef::IsJSPrimitiveBoolean(); 3107 3108判断对象是否为JSPrimitiveBoolean类型。 3109 3110**参数：** 3111 3112无 3113 3114**返回值：** 3115 3116| 类型 | 说明 | 3117| ---- | ----------------------------------------------------------- | 3118| bool | 如果调用对象的类型为JSPrimitiveBoolean返回True否则返回False | 3119 3120**示例：** 3121 3122```c++ 3123ObjectFactory *factory = vm->GetFactory(); 3124 JSHandle<JSTaggedValue> jstagvalue; 3125 JSHandle<JSPrimitiveRef> jsprimitive = factory->NewJSPrimitiveRef(PrimitiveType::PRIMITIVE_BOOLEAN, jstagvalue); 3126 JSHandle<JSTaggedValue> jspri = JSHandle<JSTaggedValue>::Cast(jsprimitive); 3127 Local<JSValueRef> object = JSNApiHelper::ToLocal<JSValueRef>(jspri); 3128bool res = object->IsJSPrimitiveBoolean(); 3129``` 3130 3131### IsMapIterator 3132 3133bool JSValueRef::IsMapIterator(); 3134 3135判断对象是否为MapIterator类型。 3136 3137**参数：** 3138 3139无 3140 3141**返回值：** 3142 3143| 类型 | 说明 | 3144| ---- | ---------------------------------------------------- | 3145| bool | 如果调用对象的类型为MapIterator返回True否则返回False | 3146 3147**示例：** 3148 3149```c++ 3150JSHandle<GlobalEnv> env = thread_->GetEcmaVM()->GetGlobalEnv(); 3151ObjectFactory *factory = thread_->GetEcmaVM()->GetFactory(); 3152JSHandle<JSTaggedValue> builtinsMapFunc = env->GetBuiltinsMapFunction(); 3153JSHandle<JSMap> jsMap(factory->NewJSObjectByConstructor(JSHandle<JSFunction>(builtinsMapFunc), builtinsMapFunc)); 3154JSHandle<JSTaggedValue> linkedHashMap(LinkedHashMap::Create(thread_)); 3155jsMap->SetLinkedMap(thread_, linkedHashMap); 3156JSHandle<JSTaggedValue> mapIteratorVal = 3157 JSMapIterator::CreateMapIterator(thread_, JSHandle<JSTaggedValue>::Cast(jsMap), IterationKind::KEY); 3158Local<MapIteratorRef> object = JSNApiHelper::ToLocal<MapIteratorRef>(mapIteratorVal); 3159bool res = object->IsMapIterator(); 3160``` 3161 3162### IsSetIterator 3163 3164bool JSValueRef::IsSetIterator(); 3165 3166判断对象是否为SetIterator类型。 3167 3168**参数：** 3169 3170无 3171 3172**返回值：** 3173 3174| 类型 | 说明 | 3175| ---- | ---------------------------------------------------- | 3176| bool | 如果调用对象的类型为SetIterator返回True否则返回False | 3177 3178**示例：** 3179 3180```c++ 3181ObjectFactory *factory = vm->GetFactory(); 3182JSHandle<JSTaggedValue> proto = thread_->GetEcmaVM()->GetGlobalEnv()->GetFunctionPrototype(); 3183JSHandle<JSHClass> setClass = factory->NewEcmaHClass(JSSet::SIZE, JSType::JS_SET, proto); 3184JSHandle<JSSet> jsSet = JSHandle<JSSet>::Cast(factory->NewJSObjectWithInit(setClass)); 3185JSHandle<LinkedHashSet> linkedSet(LinkedHashSet::Create(thread_)); 3186jsSet->SetLinkedSet(thread_, linkedSet); 3187JSHandle<JSSetIterator> jsSetIter = factory->NewJSSetIterator(jsSet, IterationKind::KEY); 3188JSHandle<JSTaggedValue> setIter = JSHandle<JSTaggedValue>::Cast(jsSetIter); 3189bool res = JSNApiHelper::ToLocal<JSValueRef>(setiter)->IsSetIterator(); 3190``` 3191 3192### IsModuleNamespaceObject 3193 3194bool JSValueRef::IsModuleNamespaceObject(); 3195 3196判断对象是否为ModuleNamespaceObject类型。 3197 3198**参数：** 3199 3200无 3201 3202**返回值：** 3203 3204| 类型 | 说明 | 3205| ---- | ------------------------------------------------------------ | 3206| bool | 如果调用对象的类型为ModuleNamespaceObject返回True否则返回False | 3207 3208**示例：** 3209 3210```c++ 3211ObjectFactory *factory = vm->GetFactory(); 3212JSHandle<ModuleNamespace> moduleNamespace = factory->NewModuleNamespace(); 3213JSHandle<JSTaggedValue> modname = JSHandle<JSTaggedValue>::Cast(moduleNamespace); 3214JSNApiHelper::ToLocal<ObjectRef>(modname)->IsModuleNamespaceObject(); 3215bool res =object->IsModuleNamespaceObject() 3216``` 3217 3218### IsProxy 3219 3220bool JSValueRef::IsProxy(); 3221 3222判断对象是否为Proxy类型。 3223 3224**参数：** 3225 3226无 3227 3228**返回值：** 3229 3230| 类型 | 说明 | 3231| ---- | ---------------------------------------------- | 3232| bool | 如果调用对象的类型为Proxy返回True否则返回False | 3233 3234**示例：** 3235 3236```c++ 3237Local<ProxyRef> tag = ProxyRef::New(vm); 3238bool res = tag->IsProxy(); 3239``` 3240 3241### IsRegExp 3242 3243bool JSValueRef::IsRegExp(); 3244 3245判断对象是否为RegExp类型。 3246 3247**参数：** 3248 3249无 3250 3251**返回值：** 3252 3253| 类型 | 说明 | 3254| ---- | ----------------------------------------------- | 3255| bool | 如果调用对象的类型为RegExp返回True否则返回False | 3256 3257**示例：** 3258 3259```c++ 3260Local<RegExp> val = RegExp::New(vm); 3261bool res = val->IsRegExp(); 3262``` 3263 3264### IsJSPrimitiveNumber 3265 3266bool JSValueRef::IsJSPrimitiveNumber(); 3267 3268判断对象是否为JSPrimitiveNumber类型。 3269 3270**参数：** 3271 3272无 3273 3274**返回值：** 3275 3276| 类型 | 说明 | 3277| ---- | ---------------------------------------------------------- | 3278| bool | 如果调用对象的类型为JSPrimitiveNumber返回True否则返回False | 3279 3280**示例：** 3281 3282```c++ 3283ObjectFactory *factory = vm->GetFactory(); 3284JSHandle<JSTaggedValue> jstagvalue; 3285JSHandle<JSPrimitiveRef> jsprimitive = factory->NewJSPrimitiveRef(PrimitiveType::PRIMITIVE_NUMBER, jstagvalue); 3286JSHandle<JSTaggedValue> jspri = JSHandle<JSTaggedValue>::Cast(jsprimitive); 3287Local<JSValueRef> object = JSNApiHelper::ToLocal<JSValueRef>(jspri); 3288bool res = object->IsJSPrimitiveNumber(); 3289``` 3290 3291### IsMap 3292 3293bool JSValueRef::IsMap(); 3294 3295判断对象是否为Map类型。 3296 3297**参数：** 3298 3299无 3300 3301**返回值：** 3302 3303| 类型 | 说明 | 3304| ---- | -------------------------------------------- | 3305| bool | 如果调用对象的类型为Map返回True否则返回False | 3306 3307**示例：** 3308 3309```c++ 3310Local<MapRef> mapRef = MapRef::New(vm); 3311bool res = mapRef->IsMap(); 3312``` 3313 3314### IsSet 3315 3316bool JSValueRef::IsSet(); 3317 3318判断对象是否为Set类型。 3319 3320**参数：** 3321 3322无 3323 3324**返回值：** 3325 3326| 类型 | 说明 | 3327| ---- | -------------------------------------------- | 3328| bool | 如果调用对象的类型为Set返回True否则返回False | 3329 3330**示例：** 3331 3332```c++ 3333Local<SetRef> setRef = SetRef::New(vm); 3334bool res = setRef->IsSet(); 3335``` 3336 3337### IsJSPrimitiveString 3338 3339bool JSValueRef::IsJSPrimitiveString(); 3340 3341判断对象是否为JSPrimitiveString类型。 3342 3343**参数：** 3344 3345无 3346 3347**返回值：** 3348 3349| 类型 | 说明 | 3350| ---- | ---------------------------------------------------------- | 3351| bool | 如果调用对象的类型为JSPrimitiveString返回True否则返回False | 3352 3353**示例：** 3354 3355```c++ 3356ObjectFactory *factory = vm->GetFactory(); 3357JSHandle<JSTaggedValue> jstagValue; 3358JSHandle<JSPrimitiveRef> jsprimitive = factory->NewJSPrimitiveRef(PrimitiveType::PRIMITIVE_STRING, jstagvalue); 3359JSHandle<JSTaggedValue> jspString = JSHandle<JSTaggedValue>::Cast(jsprimitive); 3360Local<JSValueRef> object = JSNApiHelper::ToLocal<JSValueRef>(jspString); 3361bool res = object->IsJSPrimitiveNumber(); 3362``` 3363 3364### IsJSPrimitiveSymbol 3365 3366bool JSValueRef::IsJSPrimitiveSymbol(); 3367 3368判断对象是否为JSPrimitiveSymbol类型。 3369 3370**参数：** 3371 3372无 3373 3374**返回值：** 3375 3376| 类型 | 说明 | 3377| ---- | ---------------------------------------------------------- | 3378| bool | 如果调用对象的类型为JSPrimitiveSymbol返回True否则返回False | 3379 3380**示例：** 3381 3382```c++ 3383ObjectFactory *factory = vm->GetFactory(); 3384JSHandle<JSTaggedValue> jstagValue; 3385JSHandle<JSPrimitiveRef> jsprimitive = factory->NewJSPrimitiveRef(PrimitiveType::PRIMITIVE_SYMBOL, jstagvalue); 3386JSHandle<JSTaggedValue> jspSymbol = JSHandle<JSTaggedValue>::Cast(jsprimitive); 3387Local<JSValueRef> object = JSNApiHelper::ToLocal<JSValueRef>(jspSymbol); 3388bool res = object->IsJSPrimitiveNumber(); 3389``` 3390 3391### IsWeakMap 3392 3393bool JSValueRef::IsWeakMap(); 3394 3395判断对象是否为WeakMap类型。 3396 3397**参数：** 3398 3399无 3400 3401**返回值：** 3402 3403| 类型 | 说明 | 3404| ---- | ------------------------------------------------ | 3405| bool | 如果调用对象的类型为WeakMap返回True否则返回False | 3406 3407**示例：** 3408 3409```c++ 3410Local<JSValueRef> tag = WeakMapRef::New(vm); 3411bool res = tag->IsWeakMap(); 3412``` 3413 3414### IsWeakSet 3415 3416bool JSValueRef::IsWeakSet(); 3417 3418判断对象是否为WeakSet类型。 3419 3420**参数：** 3421 3422无 3423 3424**返回值：** 3425 3426| 类型 | 说明 | 3427| ---- | ------------------------------------------------ | 3428| bool | 如果调用对象的类型为WeakSet返回True否则返回False | 3429 3430**示例：** 3431 3432```c++ 3433Local<JSValueRef> tag = WeakSetRef::New(vm); 3434bool res = tag->IsWeakSet(); 3435``` 3436 3437 3438 3439## ObjectRef 3440 3441继承于JSValueRef，提供了一些方法，用于获取对象对象的一些JSValueRef类型的值。 3442 3443### New 3444 3445static Local<ObjectRef> New(const EcmaVM *vm); 3446 3447用于构造一个ObjectRef类的对象。 3448 3449**参数：** 3450 3451| 参数名 | 类型 | 必填 | 说明 | 3452| ------ | -------------- | ---- | ---------- | 3453| vm | const EcmaVM * | 是 | 虚拟机对象 | 3454 3455**返回值：** 3456 3457| 类型 | 说明 | 3458| :--------------- | :-------------------------------- | 3459| Local<ObjectRef> | 返回构造成功的ObjectRef类的对象。 | 3460 3461**示例：** 3462 3463```c++ 3464 Local<ObjectRef> result = ObjectRef::New(vm_); 3465``` 3466 3467### GetPrototype 3468 3469Local<JSValueRef> GetPrototype(const EcmaVM *vm); 3470 3471验证是否正确返回函数或对象的原型，并验证返回的原型是否为对象类型。 3472 3473**参数：** 3474 3475| 参数名 | 类型 | 必填 | 说明 | 3476| ------ | -------------- | ---- | ---------- | 3477| vm | const EcmaVM * | 是 | 虚拟机对象 | 3478 3479**返回值：** 3480 3481| 类型 | 说明 | 3482| :---------------- | :--------------------------------------------- | 3483| Local<JSValueRef> | 将获取到的对象原型转换为JSValueRef类型并返回。 | 3484 3485**示例：** 3486 3487```c++ 3488Local<ObjectRef> object = ObjectRef::New(vm_); 3489Local<JSValueRef> result = object->GetPrototype(vm_); 3490``` 3491 3492### GetOwnPropertyNames 3493 3494Local<ArrayRef> GetOwnPropertyNames(const EcmaVM *vm); 3495 3496用于获取该对象所有的自有属性名称。 3497 3498**参数：** 3499 3500| 参数名 | 类型 | 必填 | 说明 | 3501| ------ | -------------- | ---- | ---------- | 3502| vm | const EcmaVM * | 是 | 虚拟机对象 | 3503 3504**返回值：** 3505 3506| 类型 | 说明 | 3507| :-------------- | :------------------------------------- | 3508| Local<ArrayRef> | 返回存储该对象所有自由属性名称的数组。 | 3509 3510**示例：** 3511 3512```c++ 3513Local<ObjectRef> object = ObjectRef::New(vm_); 3514Local<JSValueRef> value = ObjectRef::New(vm_); 3515PropertyAttribute attribute(value, true, true, true); 3516Local<ArrayRef> result = object->GetOwnPropertyNames(vm_); 3517``` 3518 3519### Set 3520 3521bool Set(const EcmaVM *vm, uint32_t key, Local<JSValueRef> value); 3522 3523用于设置ObjectRef对象的属性值。 3524 3525**参数：** 3526 3527| 参数名 | 类型 | 必填 | 说明 | 3528| ------ | ----------------- | ---- | ------------------ | 3529| vm | const EcmaVM * | 是 | 虚拟机对象 | 3530| key | uint32_t | 是 | 指定的key值 | 3531| value | Local<JSValueRef> | 是 | key值对应的value值 | 3532 3533**返回值：** 3534 3535| 类型 | 说明 | 3536| :------ | :--------------------------------------------------------- | 3537| boolean | ObjectRef对象的属性值设置成功，则返回true，否则返回false。 | 3538 3539**示例：** 3540 3541```c++ 3542Local<FunctionRef> object = ObjectRef::New(vm_); 3543Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 3544Local<JSValueRef> value = ObjectRef::New(vm_); 3545bool result = object->Set(vm_, key, value); 3546``` 3547 3548### Has 3549 3550bool Has(const EcmaVM *vm, Local<JSValueRef> key); 3551 3552用于检查ObjectRef对象是否具有指定的键。 3553 3554**参数：** 3555 3556| 参数名 | 类型 | 必填 | 说明 | 3557| ------ | ----------------- | ---- | ----------- | 3558| vm | const EcmaVM * | 是 | 虚拟机对象 | 3559| key | Local<JSValueRef> | 是 | 指定的key值 | 3560 3561**返回值：** 3562 3563| 类型 | 说明 | 3564| :------ | :----------------------------------------------------------- | 3565| boolean | 如果该ObjectRef对象具有指定的键，则返回true，否则返回false。 | 3566 3567**示例：** 3568 3569```c++ 3570Local<ObjectRef> object = ObjectRef::New(vm_); 3571Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 3572bool result = object->Has(vm_, key); 3573``` 3574 3575### Delete 3576 3577bool Delete(const EcmaVM *vm, Local<JSValueRef> key); 3578 3579用于根据指定的键值删除ObjectRef对象的属性值。 3580 3581**参数：** 3582 3583| 参数名 | 类型 | 必填 | 说明 | 3584| ------ | ----------------- | ---- | ----------- | 3585| vm | const EcmaVM * | 是 | 虚拟机对象 | 3586| key | Local<JSValueRef> | 是 | 指定的key值 | 3587 3588**返回值：** 3589 3590| 类型 | 说明 | 3591| :------ | :----------------------------------------------------------- | 3592| boolean | ObjectRef对象的属性值成功被删除，则返回true，否则返回false。 | 3593 3594**示例：** 3595 3596```c++ 3597Local<ObjectRef> object = ObjectRef::New(vm_, reinterpret_cast<void *>(detach1), reinterpret_cast<void *>(attach1)); 3598Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 3599bool result = object->Delete(vm_, key); 3600``` 3601 3602### Get 3603 3604Local<JSValueRef> Get(const EcmaVM *vm, int32_t key); 3605 3606根据指定的key值获取对象的value值。 3607 3608**参数：** 3609 3610| 参数名 | 类型 | 必填 | 说明 | 3611| ------ | -------------- | ---- | ----------- | 3612| vm | const EcmaVM * | 是 | 虚拟机对象 | 3613| key | int32_t | 是 | 指定的key值 | 3614 3615**返回值：** 3616 3617| 类型 | 说明 | 3618| :---------------- | :------------------------------------- | 3619| Local<JSValueRef> | 返回值为根据指定的key值获取的value值。 | 3620 3621**示例：** 3622 3623```c++ 3624Local<FunctionRef> object = ObjectRef::New(vm_); 3625int32_t key = 123; 3626Local<JSValueRef> result = object->Get(vm_, key); 3627``` 3628 3629### Delete 3630 3631bool Delete(const EcmaVM *vm, uint32_t key); 3632 3633用于根据指定的键值删除ObjectRef对象的属性值。 3634 3635**参数：** 3636 3637| 参数名 | 类型 | 必填 | 说明 | 3638| ------ | -------------- | ---- | ----------- | 3639| vm | const EcmaVM * | 是 | 虚拟机对象 | 3640| key | uint32_t | 是 | 指定的key值 | 3641 3642**返回值：** 3643 3644| 类型 | 说明 | 3645| :------ | :----------------------------------------------------------- | 3646| boolean | ObjectRef对象的属性值成功被删除，则返回true，否则返回false。 | 3647 3648**示例：** 3649 3650```c++ 3651Local<ObjectRef> object = ObjectRef::New(vm_, reinterpret_cast<void *>(detach1), reinterpret_cast<void *>(attach1)); 3652uint32_t key = 123; 3653bool result = object->Delete(vm_, key); 3654``` 3655 3656### DefineProperty 3657 3658bool DefineProperty(const EcmaVM *vm, Local<JSValueRef> key, PropertyAttribute attribute); 3659 3660用于设置Key值及对应的属性值。 3661 3662**参数：** 3663 3664| 参数名 | 类型 | 必填 | 说明 | 3665| --------- | ----------------- | ---- | -------------- | 3666| vm | const EcmaVM * | 是 | 虚拟机对象 | 3667| key | Local<JSValueRef> | 是 | 指定的key值 | 3668| attribute | PropertyAttribute | 是 | 要设置的属性值 | 3669 3670**返回值：** 3671 3672| 类型 | 说明 | 3673| :------ | :--------------------------------------------------------- | 3674| boolean | ObjectRef对象的属性值设置成功，则返回true，否则返回false。 | 3675 3676**示例：** 3677 3678```c++ 3679Local<ObjectRef> object = ObjectRef::New(vm_, reinterpret_cast<void *>(detach1), reinterpret_cast<void *>(attach1)); 3680Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 3681Local<JSValueRef> value = ObjectRef::New(vm_); 3682PropertyAttribute attribute(value, true, true, true); 3683bool result = object->DefineProperty(vm_, key, attribute); 3684``` 3685 3686### GetAllPropertyNames 3687 3688Local<ArrayRef> GetAllPropertyNames(const EcmaVM *vm, uint32_t filter); 3689 3690用于获取对象的所有属性名，并返回一个Local<ArrayRef>类型的结果。 3691 3692**参数：** 3693 3694| 参数名 | 类型 | 必填 | 说明 | 3695| ------ | -------------- | ---- | -------------- | 3696| vm | const EcmaVM * | 是 | 虚拟机对象 | 3697| filter | uint32_t | 是 | 指定的过滤条件 | 3698 3699**返回值：** 3700 3701| 类型 | 说明 | 3702| :-------------- | :--------------------------- | 3703| Local<ArrayRef> | 返回值为获取到的所有属性名。 | 3704 3705**示例：** 3706 3707```c++ 3708Local<ObjectRef> object = ObjectRef::New(vm_); 3709uint32_t filter = 123; 3710Local<ArrayRef> result = object->GetAllPropertyNames(vm_, filter); 3711``` 3712 3713### GetOwnEnumerablePropertyNames 3714 3715Local<ArrayRef> GetOwnEnumerablePropertyNames(const EcmaVM *vm); 3716 3717获取对象自身的所有可枚举属性名，并返回一个Local<ArrayRef>类型的结果。 3718 3719**参数：** 3720 3721| 参数名 | 类型 | 必填 | 说明 | 3722| ------ | -------------- | ---- | ---------- | 3723| vm | const EcmaVM * | 是 | 虚拟机对象 | 3724 3725**返回值：** 3726 3727| 类型 | 说明 | 3728| :-------------- | :--------------------------------- | 3729| Local<ArrayRef> | 返回值为获取到的所有可枚举属性名。 | 3730 3731**示例：** 3732 3733```c++ 3734Local<ObjectRef> object = ObjectRef::New(vm_); 3735Local<ArrayRef> result = object->GetOwnEnumerablePropertyNames(vm_); 3736``` 3737 3738### Get 3739 3740Local<JSValueRef> ObjectRef::Get(const EcmaVM *vm, Local<JSValueRef> key); 3741 3742从一个JavaScript对象中获取一个属性的值。 3743 3744**参数：** 3745 3746| 参数名 | 类型 | 必填 | 说明 | 3747| ------ | ----------------- | ---- | ---------------------------------------------------------- | 3748| vm | const EcmaVM * | 是 | 虚拟机对象。 | 3749| key | Local<JSValueRef> | 是 | 要获取的属性的键。这个键可以是字符串、数字或其他类型的值。 | 3750 3751**返回值：** 3752 3753| 类型 | 说明 | 3754| ----------------- | ------------------------------------------------------------ | 3755| Local<JSValueRef> | 将获取到的属性值转换为JSValueRef类型，并通过scope.Escape(JSNApiHelper::ToLocal<JSValueRef>(ret.GetValue()))将其转回局部变量，并返回该值。 | 3756 3757**示例：** 3758 3759```c++ 3760Local<FunctionRef> object = ObjectRef::New(vm_); 3761int32_t key = 123; 3762Local<JSValueRef> value = object->Get(vm_, key); 3763``` 3764 3765### GetOwnProperty 3766 3767获取对象的属性。 3768 3769bool ObjectRef::GetOwnProperty(const EcmaVM *vm, Local<JSValueRef> key, PropertyAttribute &property); 3770 3771**参数：** 3772 3773| 参数名 | 类型 | 必填 | 说明 | 3774| -------- | ------------------- | ---- | ---------------------------- | 3775| vm | const EcmaVM * | 是 | 虚拟机对象。 | 3776| key | Local<JSValueRef> | 是 | 要获取的属性的键。 | 3777| property | PropertyAttribute & | 是 | 用于存储获取到的属性的信息。 | 3778 3779**返回值：** 3780 3781| 类型 | 说明 | 3782| ---- | ------------------------------------------------------------ | 3783| bool | 如果成功获取到属性描述符，函数会将属性值、getter、setter、可写性、可枚举性和可配置性等信息设置到property对象中。最后，返回`true`表示成功获取属性。否则，返回false。 | 3784 3785**示例：** 3786 3787```c++ 3788Local<ObjectRef> object = ObjectRef::New(vm_); 3789Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 3790Local<JSValueRef> value = ObjectRef::New(vm_); 3791PropertyAttribute attribute(value, true, true, true); 3792bool b = object->GetOwnProperty(vm_, key, attribute); 3793``` 3794 3795### SetAccessorProperty 3796 3797bool ObjectRef::SetAccessorProperty(const EcmaVM *vm, Local<JSValueRef> key, Local<FunctionRef> getter, Local<FunctionRef> setter, PropertyAttribute attribute); 3798 3799设置对象的属性。 3800 3801**参数：** 3802 3803| 参数名 | 类型 | 必填 | 说明 | 3804| --------- | ------------------ | ---- | ------------------------------------------------ | 3805| vm | const EcmaVM * | 是 | 虚拟机对象。 | 3806| key | Local<JSValueRef> | 是 | 要设置的属性的键。 | 3807| getter | Local<FunctionRef> | 是 | 表示属性的getter函数。 | 3808| setter | Local<FunctionRef> | 是 | 表示属性的setter函数。 | 3809| attribute | PropertyAttribute | 是 | 表示属性的特性（如可写性、可枚举性和可配置性）。 | 3810 3811**返回值：** 3812 3813| 类型 | 说明 | 3814| ---- | ------------------------------------------------------------ | 3815| bool | 表示是否成功设置了属性。如果设置成功，返回true。否则，返回false。 | 3816 3817**示例：** 3818 3819```c++ 3820Local<FunctionRef> object = ObjectRef::New(vm_); 3821Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 3822Local<FunctionRef> target1 = FunctionRef::New(vm_, nullptr); 3823Local<FunctionRef> target2 = FunctionRef::New(vm_, nullptr); 3824bool b = object->SetAccessorProperty(vm_, key, target1, target2); 3825``` 3826 3827### GetNativePointerField 3828 3829void *ObjectRef::GetNativePointerField(int32_t index); 3830 3831获取一个对象的指定索引处的原生指针字段。 3832 3833**参数：** 3834 3835| 参数名 | 类型 | 必填 | 说明 | 3836| ------ | ------- | ---- | ------------------------------------ | 3837| index | int32_t | 是 | 用于指定要获取的原生指针字段的索引。 | 3838 3839**返回值：** 3840 3841| 类型 | 说明 | 3842| ------ | -------------------------------- | 3843| void * | 表示返回一个指向任意类型的指针。 | 3844 3845**示例：** 3846 3847```c++ 3848Local<ObjectRef> object = ObjectRef::New(vm_); 3849NativePointerCallback callBack = nullptr; 3850void *vp1 = static_cast<void *>(new std::string("test")); 3851void *vp2 = static_cast<void *>(new std::string("test")); 3852object->SetNativePointerField(33, vp1, callBack, vp2); 3853void *ptr = object.GetNativePointerField(33); 3854``` 3855 3856### SetNativePointerFieldCount 3857 3858void ObjectRef::SetNativePointerFieldCount(int32_t count); 3859 3860设置一个对象的本地指针字段的数量。 3861 3862**参数：** 3863 3864| 参数名 | 类型 | 必填 | 说明 | 3865| ------ | ------- | ---- | -------------------------------- | 3866| count | int32_t | 是 | 指定要设置的本地指针字段的数量。 | 3867 3868**返回值：** 3869 3870无 3871 3872**示例：** 3873 3874```c++ 3875Local<ObjectRef> object = ObjectRef::New(vm_); 3876int32_t input = 34; 3877object->SetNativePointerFieldCount(input); 3878``` 3879 3880### set 3881 3882bool Set(const EcmaVM *vm, Local<JSValueRef> key, Local<JSValueRef> value); 3883 3884bool Set(const EcmaVM *vm, uint32_t key, Local<JSValueRef> value); 3885 3886在当前 `ObjectRef` 对象中设置键值对。 3887 3888在设置之前，通过 `CHECK_HAS_PENDING_EXCEPTION` 宏检查是否存在潜在的异常。 3889 3890使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `ObjectRef` 对象转换为 JavaScript 中的 `JSTaggedValue` 对象。 3891 3892使用 `JSNApiHelper::ToJSHandle(key)` 和 `JSNApiHelper::ToJSHandle(value)` 将键和值转换为 JavaScript 中的 `JSTaggedValue` 对象。 3893 3894调用 `JSTaggedValue::SetProperty` 方法在对象中设置键值对。 3895 3896**参数：** 3897 3898| 参数名 | 类型 | 必填 | 说明 | 3899| ------- | ----------------- | ---- | ---------------- | 3900| vm | const EcmaVM * | 是 | 虚拟机对象。 | 3901| key | Local<JSValueRef> | 是 | 表示要设置的键。 | 3902| key | uint32_t | 是 | 表示要设置的键。 | 3903| value | Local<JSValueRef> | 是 | 表示要设置的值。 | 3904 3905**返回值：** 3906 3907| 类型 | 说明 | 3908| ---- | --------------------------- | 3909| bool | 设置成功返回True反之False。 | 3910 3911**示例：** 3912 3913```c++ 3914Local<ObjectRef> object = ObjectRef::New(vm_); 3915Local<StringRef> toString = StringRef::NewFromUtf8(vm_, "-123.3"); 3916Local<JSValueRef> toValue(toString); 3917bool res = object->Set(vm_, key, toValue); 3918bool res = object->Set(vm_, toValue, toValue); 3919``` 3920 3921### Has 3922 3923bool Has(const EcmaVM *vm, uint32_t key); 3924 3925 检查当前 `ObjectRef` 对象是否包含指定键的属性。 3926 3927 在检查之前，通过 `CHECK_HAS_PENDING_EXCEPTION` 宏检查是否存在潜在的异常。 3928 3929使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `ObjectRef` 对象转换为 JavaScript 中的 `JSTaggedValue` 对象。 3930 3931调用 `JSTaggedValue::HasProperty` 方法检查对象是否包含指定键的属性。 3932 3933**参数：** 3934 3935| 参数名 | 类型 | 必填 | 说明 | 3936| ------ | -------------- | ---- | -------------------- | 3937| vm | const EcmaVM * | 是 | 虚拟机对象。 | 3938| key | uint32_t | 是 | 表示要检查的属性键。 | 3939 3940**返回值：** 3941 3942| 类型 | 说明 | 3943| ---- | ------------------------- | 3944| bool | 如果有返回True反之False。 | 3945 3946**示例：** 3947 3948```c++ 3949Local<ObjectRef> object = ObjectRef::New(vm_); 3950Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 3951bool res = object->Has(vm_, key); 3952``` 3953 3954### SetNativePointerField 3955 3956void SetNativePointerField(int32_t index,void *nativePointer = nullptr,NativePointerCallback callBack = nullptr,void *data = nullptr, size_t nativeBindingsize = 0); 3957 3958在当前 `ObjectRef` 对象中设置指定索引的本机指针字段。 3959 3960在设置之前，通过 `LOG_IF_SPECIAL` 宏检查是否存在潜在的异常。 3961 3962使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `ObjectRef` 对象转换为 JavaScript 中的 `JSObject` 对象。 3963 3964调用 `JSObject::SetNativePointerField` 方法设置本机指针字段。 3965 3966**参数：** 3967 3968| 参数名 | 类型 | 必填 | 说明 | 3969| ----------------- | --------------------- | ---- | -------------------------------- | 3970| index | int32_t | 是 | 表示要设置的本机指针字段的索引。 | 3971| nativePointer | void* | 否 | 表示要设置的本机指针。 | 3972| callBack | NativePointerCallback | 否 | 表示本机指针的回调函数。 | 3973| data | void* | 否 | 表示与本机指针相关联的数据。 | 3974| nativeBindingsize | size_t | 是 | 表示本机绑定的大小。 | 3975 3976**返回值：** 3977 3978无 3979 3980**示例：** 3981 3982```c++ 3983NativePointerCallback callBack = nullptr; 3984void *vp1 = static_cast<void*>(new std::string("test")); 3985void *vp2 = static_cast<void*>(new std::string("test")); 3986object->SetNativePointerField(index, vp1, callBack, vp2); 3987``` 3988 3989### Freeze 3990 3991static void TriggerGC(const EcmaVM *vm, TRIGGER_GC_TYPE gcType = TRIGGER_GC_TYPE::SEMI_GC); 3992 3993该函数用于触发垃圾回收（GC）操作，可以选择不同的垃圾回收类型。 3994 3995通过调用虚拟机的 CollectGarbage 方法执行垃圾回收操作。 3996 3997在触发垃圾回收之前，通过 CHECK_HAS_PENDING_EXCEPTION_WITHOUT_RETURN 宏检查是否存在潜在的异常。 3998 3999**参数：** 4000 4001| 参数名 | 类型 | 必填 | 说明 | 4002| -------- | --------------- | ---- | ---------------------------------------------- | 4003| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4004| gcType | TRIGGER_GC_TYPE | 否 | 是一个枚举类型，表示触发GC（垃圾回收）的类型。 | 4005 4006**返回值：** 4007 4008无 4009 4010**示例：** 4011 4012```c++ 4013JSNApi::TriggerGC(vm); 4014``` 4015 4016### Seal 4017 4018static void TriggerGC(const EcmaVM *vm, TRIGGER_GC_TYPE gcType = TRIGGER_GC_TYPE::SEMI_GC); 4019 4020该函数用于触发垃圾回收（GC）操作，可以选择不同的垃圾回收类型。 4021 4022通过调用虚拟机的 CollectGarbage 方法执行垃圾回收操作。 4023 4024在触发垃圾回收之前，通过 CHECK_HAS_PENDING_EXCEPTION_WITHOUT_RETURN 宏检查是否存在潜在的异常。 4025 4026**参数：** 4027 4028| 参数名 | 类型 | 必填 | 说明 | 4029| -------- | --------------- | ---- | ---------------------------------------------- | 4030| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4031| gcType | TRIGGER_GC_TYPE | 否 | 是一个枚举类型，表示触发GC（垃圾回收）的类型。 | 4032 4033**返回值：** 4034 4035无 4036 4037**示例：** 4038 4039```c++ 4040JSNApi::TriggerGC(vm); 4041``` 4042 4043### New 4044 4045Local<ObjectRef> ObjectRef::New(const EcmaVM *vm)； 4046 4047创建一个新的 JavaScript 对象，并返回对该对象的本地引用。 4048 4049在创建之前，通过 `CHECK_HAS_PENDING_EXCEPTION_RETURN_UNDEFINED` 宏检查是否存在潜在的异常。 4050 4051获取虚拟机的工厂对象和全局环境。 4052 4053使用全局环境中的 `GetObjectFunction` 函数获取对象构造函数。 4054 4055调用工厂的 `NewJSObjectByConstructor` 方法创建新的 JavaScript 对象。 4056 4057**参数：** 4058 4059| 参数名 | 类型 | 必填 | 说明 | 4060| ------ | -------------- | ---- | ------------ | 4061| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4062 4063**返回值：** 4064 4065| 类型 | 说明 | 4066| ---------------- | -------------------------- | 4067| Local<ObjectRef> | 返回新的 JavaScript 对象。 | 4068 4069**示例：** 4070 4071```c++ 4072Local<ObjectRef> myObject = ObjectRef::New(vm); 4073``` 4074 4075### SetPrototype 4076 4077bool ObjectRef::SetPrototype(const EcmaVM *vm, Local<ObjectRef> prototype) 4078 4079设置当前 `ObjectRef` 对象的原型为指定的 `prototype` 对象。 4080 4081在设置之前，通过 `LOG_IF_SPECIAL` 宏检查是否存在潜在的异常。 4082 4083使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `ObjectRef` 对象转换为 JavaScript 中的 `JSObject` 对象。 4084 4085使用 `JSNApiHelper::ToJSHandle(prototype)` 将传入的 `prototype` 对象转换为 JavaScript 中的 `JSObject` 对象。 4086 4087调用 `JSTaggedValue::SetPrototype` 方法设置对象的原型。 4088 4089**参数：** 4090 4091| 参数名 | 类型 | 必填 | 说明 | 4092| --------- | ---------------- | ---- | ---------------------- | 4093| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4094| prototype | Local<ObjectRef> | 是 | 表示要设置的原型对象。 | 4095 4096**返回值：** 4097 4098| 类型 | 说明 | 4099| ---- | --------------------------- | 4100| bool | 设置成功返回True反之False。 | 4101 4102**示例：** 4103 4104```c++ 4105Local<ObjectRef> object = ObjectRef::New(vm_); 4106Local<ObjectRef> prototype = object->GetPrototype(vm_); 4107object->SetPrototype(vm_, prototype); 4108``` 4109 4110 static Local<PromiseCapabilityRef> New(const EcmaVM *vm); 4111 4112 4113 4114## FunctionRef 4115 4116提供方法将函数封装为一个对象，以及对封装函数的调用。 4117 4118### New 4119 4120Local<FunctionRef> FunctionRef::New(EcmaVM *vm, FunctionCallback nativeFunc, NativePointerCallback deleter, void *data, bool callNapi, size_t nativeBindingsize)； 4121 4122创建一个新的函数对象。 4123 4124**参数：** 4125 4126| 参数名 | 类型 | 必填 | 说明 | 4127| :---------------: | ---------------- | ---- | ------------------------------------------------------------ | 4128| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 4129| nativeFunc | FunctionCallback | 是 | 一个回调函数，当JS调用这个本地函数时，将调用这个回调函。 | 4130| deleter | NativePointerCallback | 否 | 一个删除器函数，用于在不再需要`FunctionRef`对象时释放其资源。 | 4131| data | void * | 否 | 一个可选的指针，可以传递给回调函数或删除器函数。 | 4132| callNapi | bool | 否 | 一个布尔值，表示是否在创建`FunctionRef`对象时立即调用回调函数。如果为`true`，则在创建对象时立即调用回调函数；如果为`false`，则需要手动调用回调函数。 | 4133| nativeBindingsize | size_t | 否 | 表示nativeFunc函数的大小，0表示未知大小。 | 4134 4135**返回值：** 4136 4137| 类型 | 说明 | 4138| ------------------ | ------------------------ | 4139| Local<FunctionRef> | 返回为一个新的函数对象。 | 4140 4141**示例：** 4142 4143```C++ 4144Local<JSValueRef> FunCallback(JsiRuntimeCallInfo *info) 4145{ 4146 EscapeLocalScope scope(info->GetVM()); 4147 return scope.Escape(ArrayRef::New(info->GetVM(), info->GetArgsNumber())); 4148} 4149Local<FunctionRef> callback = FunctionRef::New(vm, FunCallback); 4150``` 4151 4152### NewClassFunction 4153 4154Local<FunctionRef> FunctionRef::NewClassFunction(EcmaVM *vm, FunctionCallback nativeFunc, NativePointerCallback deleter, void *data, bool callNapi, size_t nativeBindingsize)； 4155 4156创建一个新的类函数对象。 4157 4158**参数：** 4159 4160| 参数名 | 类型 | 必填 | 说明 | 4161| :---------------: | ---------------- | ---- | ------------------------------------------------------------ | 4162| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 4163| nativeFunc | FunctionCallback | 是 | 一个回调函数，当JS调用这个本地函数时，将调用这个回调函。 | 4164| deleter | NativePointerCallback | 否 | 一个删除器函数，用于在不再需要`FunctionRef`对象时释放其资源。 | 4165| data | void * | 否 | 一个可选的指针，可以传递给回调函数或删除器函数。 | 4166| callNapi | bool | 否 | 一个布尔值，表示是否在创建`FunctionRef`对象时立即调用回调函数。如果为`true`，则在创建对象时立即调用回调函数；如果为`false`，则需要手动调用回调函数。 | 4167| nativeBindingsize | size_t | 否 | 表示nativeFunc函数的大小，0表示未知大小。 | 4168 4169**返回值：** 4170 4171| 类型 | 说明 | 4172| ------------------ | ------------------------ | 4173| Local<FunctionRef> | 返回为一个新的函数对象。 | 4174 4175**示例：** 4176 4177```C++ 4178Local<JSValueRef> FunCallback(JsiRuntimeCallInfo *info) 4179{ 4180 EscapeLocalScope scope(info->GetVM()); 4181 return scope.Escape(ArrayRef::New(info->GetVM(), info->GetArgsNumber())); 4182} 4183NativePointerCallback deleter = nullptr; 4184void *cb = reinterpret_cast<void *>(BuiltinsFunction::FunctionPrototypeInvokeSelf); 4185bool callNative = true; 4186size_t nativeBindingSize = 15; 4187Local<FunctionRef> obj(FunctionRef::NewClassFunction(vm, FunCallback, deleter, cb, callNative, nativeBindingSize)); 4188``` 4189 4190### Call 4191 4192Local<JSValueRef> FunctionRef::Call(const EcmaVM *vm, Local<JSValueRef> thisObj, const Local<JSValueRef> argv[], int32_t length)； 4193 4194设置指定对象调用FunctionRef对象设置的回调函数。 4195 4196**参数：** 4197 4198| 参数名 | 类型 | 必填 | 说明 | 4199| :-----: | ----------------------- | ---- | ------------------------------- | 4200| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 4201| thisObj | FunctionCallback | 是 | 指定调用回调函数的对象。 | 4202| argv[] | const Local<JSValueRef> | 否 | Local<JSValueRef>对象数组。 | 4203| length | int32_t | 否 | Local<JSValueRef>对象数组长度。 | 4204 4205**返回值：** 4206 4207| 类型 | 说明 | 4208| ----------------- | ------------------------ | 4209| Local<JSValueRef> | 用于返回函数执行的结果。 | 4210 4211**示例：** 4212 4213```C++ 4214Local<JSValueRef> FunCallback(JsiRuntimeCallInfo *info) 4215{ 4216 EscapeLocalScope scope(info->GetVM()); 4217 return scope.Escape(ArrayRef::New(info->GetVM(), info->GetArgsNumber())); 4218} 4219Local<IntegerRef> intValue = IntegerRef::New(vm, 0); 4220std::vector<Local<JSValueRef>> argumentsInt; 4221argumentsInt.emplace_back(intValue); 4222Local<FunctionRef> callback = FunctionRef::New(vm, FunCallback); 4223callback->Call(vm, JSValueRef::Undefined(vm), argumentsInt.data(), argumentsInt.size()); 4224``` 4225 4226### GetSourceCode 4227 4228Local<StringRef> GetSourceCode(const EcmaVM *vm, int lineNumber)； 4229 4230获取调用此函数的CPP文件内，指定行号的源代码。 4231 4232**参数：** 4233 4234| 参数名 | 类型 | 必填 | 说明 | 4235| :--------: | -------------- | ---- | ---------------- | 4236| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 4237| lineNumber | int | 是 | 指定行号。 | 4238 4239**返回值：** 4240 4241| 类型 | 说明 | 4242| ---------------- | --------------------- | 4243| Local<StringRef> | 返回为StringRef对象。 | 4244 4245**示例：** 4246 4247```C++ 4248Local<JSValueRef> FunCallback(JsiRuntimeCallInfo *info) 4249{ 4250 EscapeLocalScope scope(info->GetVM()); 4251 return scope.Escape(ArrayRef::New(info->GetVM(), info->GetArgsNumber())); 4252} 4253Local<FunctionRef> callback = FunctionRef::New(vm, FunCallback); 4254Local<StringRef> src = callback->GetSourceCode(vm, 10); 4255``` 4256 4257### Constructor 4258 4259Local<JSValueRef> FunctionRef::Constructor(const EcmaVM *vm, const Local<JSValueRef> argv[], int32_t length)； 4260 4261用于一个函数对象的构造。 4262 4263**参数：** 4264 4265| 参数名 | 类型 | 必填 | 说明 | 4266| :----: | ----------------------- | ---- | -------------------- | 4267| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 4268| argv | const Local<JSValueRef> | 是 | 参数数组。 | 4269| length | int32_t | 是 | argv参数的数组大小。 | 4270 4271**返回值：** 4272 4273| 类型 | 说明 | 4274| ----------------- | ------------------------------------------------------------ | 4275| Local<JSValueRef> | 生成一个FunctionRef，并将其转为Local<JSValueRef>类型，作为函数返回值。 | 4276 4277**示例：** 4278 4279```C++ 4280Local<FunctionRef> cls = FunctionRef::NewClassFunction(vm, FunCallback, nullptr, nullptr); 4281Local<JSValueRef> argv[1]; 4282int num = 3; 4283argv[0] = NumberRef::New(vm, num); 4284Local<JSValueRef>functionObj = cls->Constructor(vm, argv, 1); 4285``` 4286 4287### GetFunctionPrototype 4288 4289Local<JSValueRef> FunctionRef::GetFunctionPrototype(const EcmaVM *vm)； 4290 4291获取prototype对象，它包含了所有函数的原型方法，这些方法可以被所有的函数实例共享和重写。 4292 4293**参数：** 4294 4295| 参数名 | 类型 | 必填 | 说明 | 4296| :----: | -------------- | ---- | ---------------- | 4297| vm | const EcmaVM * | 是 | 指定虚拟机对象。 | 4298 4299**返回值：** 4300 4301| 类型 | 说明 | 4302| ----------------- | ------------------------------------------------------------ | 4303| Local<JSValueRef> | 将prototype对象转为Local<JSValueRef>类型，并作为此函数的返回值。 | 4304 4305**示例：** 4306 4307```C++ 4308Local<JSValueRef> FunCallback(JsiRuntimeCallInfo *info) 4309{ 4310 EscapeLocalScope scope(info->GetVM()); 4311 return scope.Escape(ArrayRef::New(info->GetVM(), info->GetArgsNumber())); 4312} 4313Local<FunctionRef> res = FunctionRef::New(vm, FunCallback); 4314Local<JSValueRef> prototype = res->GetFunctionPrototype(vm); 4315``` 4316 4317## TypedArrayRef 4318 4319一种用于处理二进制数据的内置对象。它类似于普通数组，但只能存储和操作特定类型的数据。 4320 4321### ByteLength 4322 4323uint32_t TypedArrayRef::ByteLength([[maybe_unused]] const EcmaVM *vm)； 4324 4325此函数返回此ArrayBufferRef缓冲区的长度（以字节为单位）。 4326 4327**参数：** 4328 4329| 参数名 | 类型 | 必填 | 说明 | 4330| :----: | -------------- | ---- | ------------ | 4331| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4332 4333**返回值：** 4334 4335| 类型 | 说明 | 4336| -------- | --------------------------------- | 4337| uint32_t | 以uint32_t 类型返回buffer的长度。 | 4338 4339**示例：** 4340 4341```c++ 4342Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, 10); 4343Local<DataViewRef> dataView = DataViewRef::New(vm, arrayBuffer, 5, 7); 4344uint32_t len = dataView->ByteLength(); 4345``` 4346 4347### ByteOffset 4348 4349uint32_t TypedArrayRef::ByteOffset([[maybe_unused]] const EcmaVM *vm); 4350 4351获取当前 `TypedArrayRef` 对象在关联的底层数组缓冲区中的字节偏移位置。 4352 4353在获取字节偏移之前，通过 `CHECK_HAS_PENDING_EXCEPTION` 宏检查是否存在潜在的异常。 4354 4355使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `TypedArrayRef` 对象转换为 JavaScript 中的 `JSTypedArray` 对象。 4356 4357调用 `GetByteOffset` 方法获取实际的 TypedArray 在 ArrayBuffer 中的字节偏移位置。 4358 4359**参数：** 4360 4361| 参数名 | 类型 | 必填 | 说明 | 4362| ------ | -------------- | ---- | ------------ | 4363| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4364 4365**返回值：** 4366 4367| 类型 | 说明 | 4368| ------- | --------------------------------------------------------- | 4369| int32_t | 表示 TypedArray 对象在关联 ArrayBuffer 中的字节偏移位置。 | 4370 4371**示例：** 4372 4373```c++ 4374Local<ArrayBufferRef> arrayOffsetBuffer = ArrayBufferRef::New(vm, length); 4375Local<Int8ArrayRef> objOffset = Int8ArrayRef::New(vm, arrayOffsetBuffer, Offset, length); 4376uint32_t byteOffset = obj->ByteOffset(vm); 4377``` 4378 4379### ArrayLength 4380 4381uint32_t TypedArrayRef::ArrayLength(const EcmaVM *vm); 4382 4383获取当前 `TypedArrayRef` 对象的数组长度，即其中存储的元素的数量。 4384 4385在获取数组长度之前，通过 `CHECK_HAS_PENDING_EXCEPTION` 宏检查是否存在潜在的异常。 4386 4387使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `TypedArrayRef` 对象转换为 JavaScript 中的 `JSTypedArray` 对象。 4388 4389调用 `GetArrayLength` 方法获取实际的数组长度。 4390 4391**参数：** 4392 4393| 参数名 | 类型 | 必填 | 说明 | 4394| ------ | -------------- | ---- | ------------ | 4395| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4396 4397**返回值：** 4398 4399| 类型 | 说明 | 4400| ------- | -------------------------------------------- | 4401| int32_t | 表示 TypedArray 对象的数组长度（元素数量）。 | 4402 4403**示例：** 4404 4405```c++ 4406Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, length); 4407Local<Int8ArrayRef> obj = Int8ArrayRef::New(vm, arrayBuffer, 5, 6); 4408uint32_t byteOffset = obj->ArrayLength(vm); 4409``` 4410 4411### GetArrayBuffer 4412 4413Local<ArrayBufferRef> TypedArrayRef::GetArrayBuffer(const EcmaVM *vm); 4414 4415获取当前 `TypedArrayRef` 对象关联的 ArrayBufferRef 对象。 4416 4417在获取 ArrayBufferRef 之前，通过 `CHECK_HAS_PENDING_EXCEPTION_RETURN_UNDEFINED` 宏检查是否存在潜在的异常。 4418 4419使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `TypedArrayRef` 对象转换为 JavaScript 中的 `JSTypedArray` 对象。 4420 4421调用 `JSTypedArray::GetOffHeapBuffer` 方法获取实际的 ArrayBuffer 对象。 4422 4423使用 `JSNApiHelper::ToLocal<ArrayBufferRef>(arrayBuffer)` 4424将 JavaScript 中的 ArrayBuffer 对象转换为本地的 `ArrayBufferRef` 对象。 4425 4426**参数：** 4427 4428| 参数名 | 类型 | 必填 | 说明 | 4429| ------ | -------------- | ---- | ------------ | 4430| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4431 4432**返回值：** 4433 4434| 类型 | 说明 | 4435| --------------------- | ----------------------------- | 4436| Local<ArrayBufferRef> | `ArrayBufferRef` 类型的对象。 | 4437 4438**示例：** 4439 4440```c++ 4441Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm, length); 4442Local<Int8ArrayRef> obj = Int8ArrayRef::New(vm, arrayBuffer, 5, 6); 4443Local<ArrayBufferRef> byteOffset = obj->GetArrayBuffer(vm); 4444``` 4445 4446 4447 4448## Exception 4449 4450提供了一些静态方法，用于根据不同的错误类型创建一个对应的JS异常对象，并返回一个指向该对象的引用。 4451 4452### AggregateError 4453 4454static Local<JSValueRef> AggregateError(const EcmaVM *vm, Local<StringRef> message)； 4455 4456当需要将多个错误包装在一个错误中时，AggregateError对象表示一个错误。 4457 4458**参数：** 4459 4460| 参数名 | 类型 | 必填 | 说明 | 4461| :-----: | ---------------- | ---- | ------------ | 4462| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4463| message | Local<StringRef> | 是 | 错误信息。 | 4464 4465**返回值：** 4466 4467| 类型 | 说明 | 4468| ----------------- | ------------------------------------------------------------ | 4469| Local<JSValueRef> | 将多个错误包装为AggregateError对象，并将其转为Local<JSValueRef>类型，作为函数的返回值。 | 4470 4471**示例：** 4472 4473```C++ 4474Local<JSValueRef> error = Exception::AggregateError(vm, StringRef::NewFromUtf8(vm, "test aggregate error")); 4475``` 4476 4477### EvalError 4478 4479static Local<JSValueRef> EvalError(const EcmaVM *vm, Local<StringRef> message)； 4480 4481用于表示在执行 `eval()` 函数时发生的错误。当 `eval()` 函数无法解析或执行传入的字符串代码时，会抛出一个 `EvalError` 异常。 4482 4483**参数：** 4484 4485| 参数名 | 类型 | 必填 | 说明 | 4486| :-----: | ---------------- | ---- | ------------ | 4487| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4488| message | Local<StringRef> | 是 | 错误信息。 | 4489 4490**返回值：** 4491 4492| 类型 | 说明 | 4493| ----------------- | ---- | 4494| Local<JSValueRef> | | 4495 4496**示例：** 4497 4498```C++ 4499Local<JSValueRef> error = Exception::EvalError(vm, StringRef::NewFromUtf8(vm, "test eval error")); 4500``` 4501 4502 4503 4504### OOMError 4505 4506static Local<JSValueRef> OOMError(const EcmaVM *vm, Local<StringRef> message); 4507 4508在内存不足的情况下抛出一个错误对象。（由于这是一个静态成员函数，因此可以直接通过类名调用，而无需创建类的实例。） 4509 4510**参数：** 4511 4512| 参数名 | 类型 | 必填 | 说明 | 4513| ------- | ---------------- | ---- | ------------------------------ | 4514| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4515| message | Local<StringRef> | 是 | 传递给OOMError函数的错误消息。 | 4516 4517**返回值：** 4518 4519| 类型 | 说明 | 4520| ----------------- | ---------------------------------------------------------- | 4521| Local<JSValueRef> | 返回一个 JSValueRef 对象，表示JavaScript中的值或错误信息。 | 4522 4523**示例：** 4524 4525```c++ 4526Local<JSValueRef> value = Exception::OOMError(vm_, message); 4527``` 4528 4529### TypeError 4530 4531static Local<JSValueRef> TypeError(const EcmaVM *vm, Local<StringRef> message); 4532 4533在给定的虚拟机（EcmaVM）中创建一个表示类型错误的 JavaScript 值引用（JSValueRef）。 4534 4535**参数：** 4536 4537| 参数名 | 类型 | 必填 | 说明 | 4538| ------- | ---------------- | ---- | ------------------------------- | 4539| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4540| message | Local<StringRef> | 是 | 传递给TypeError函数的错误消息。 | 4541 4542**返回值：** 4543 4544| 类型 | 说明 | 4545| ----------------- | ------------------------------------------------------------ | 4546| Local<JSValueRef> | 返回一个 JSValueRef 对象，表示JavaScript中的错误信息。可以用于进一步处理或传递该错误对象。 | 4547 4548**示例：** 4549 4550```c++ 4551Local<JSValueRef> value = Exception::TypeError(vm_, message); 4552``` 4553 4554### Error 4555 4556static Local<JSValueRef> Error(const EcmaVM *vm, Local<StringRef> message); 4557 4558用于检测error并创建一个新的错误对象。 4559 4560**参数：** 4561 4562| 参数名 | 类型 | 必填 | 说明 | 4563| ------- | ---------------- | ---- | -------------- | 4564| vm | const EcmaVM * | 是 | 虚拟机对象 | 4565| message | Local<StringRef> | 是 | 传入的错误消息 | 4566 4567**返回值：** 4568 4569| 类型 | 说明 | 4570| :---------------- | :------------------- | 4571| Local<JSValueRef> | 返回创建的错误对象。 | 4572 4573**示例：** 4574 4575```c++ 4576Local<StringRef> message = StringRef::NewFromUtf8(vm_, "test error"); 4577Local<JSValueRef> result = Exception::Error(vm_, message); 4578``` 4579 4580### RangeError 4581 4582static Local<JSValueRef> RangeError(const EcmaVM *vm, Local<StringRef> message); 4583 4584用于检测范围错误并创建一个新的错误对象。 4585 4586**参数：** 4587 4588| 参数名 | 类型 | 必填 | 说明 | 4589| ------- | ---------------- | ---- | -------------- | 4590| vm | const EcmaVM * | 是 | 虚拟机对象 | 4591| message | Local<StringRef> | 是 | 传入的错误消息 | 4592 4593**返回值：** 4594 4595| 类型 | 说明 | 4596| :---------------- | :------------------- | 4597| Local<JSValueRef> | 返回创建的错误对象。 | 4598 4599**示例：** 4600 4601```c++ 4602Local<StringRef> message = StringRef::NewFromUtf8(vm_, "test error"); 4603Local<JSValueRef> result = Exception::RangeError(vm_, message); 4604``` 4605 4606### ReferenceError 4607 4608static Local<JSValueRef> ReferenceError(const EcmaVM *vm, Local<StringRef> message); 4609 4610用于检测引用错误并创建一个新的错误对象。 4611 4612**参数：** 4613 4614| 参数名 | 类型 | 必填 | 说明 | 4615| ------- | ---------------- | ---- | -------------- | 4616| vm | const EcmaVM * | 是 | 虚拟机对象 | 4617| message | Local<StringRef> | 是 | 传入的错误消息 | 4618 4619**返回值：** 4620 4621| 类型 | 说明 | 4622| :---------------- | :------------------- | 4623| Local<JSValueRef> | 返回创建的错误对象。 | 4624 4625**示例：** 4626 4627```c++ 4628Local<StringRef> message = StringRef::NewFromUtf8(vm_, "test error"); 4629Local<JSValueRef> result = Exception::ReferenceError(vm_, message); 4630``` 4631 4632### SyntaxError 4633 4634static Local<JSValueRef> SyntaxError(const EcmaVM *vm, Local<StringRef> message); 4635 4636创建一个 SyntaxError 类型的 JavaScript 异常对象。 4637 4638如果存在挂起的异常，则清除之。 4639 4640获取 `message` 的 `EcmaString` 对象，用于表示异常错误的消息。 4641 4642用 `ObjectFactory` 获取工厂实例，创建一个新的 JavaScript SyntaxError 对象。 4643 4644返回结果作为本地引用。 4645 4646**参数：** 4647 4648| 参数名 | 类型 | 必填 | 说明 | 4649| ------- | ---------------- | ---- | -------------------- | 4650| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4651| message | Local<StringRef> | 是 | 表示异常错误的消息。 | 4652 4653**返回值：** 4654 4655| 类型 | 说明 | 4656| ------------------------ | --------------------- | 4657| static Local<JSValueRef> | ArrayRef 类型的对象。 | 4658 4659**示例：** 4660 4661```c++ 4662Local<StringRef> errorMessage = StringRef::NewFromUtf8(vm, "Invalid syntax"); 4663Local<JSValueRef> syntaxError = SyntaxError(vm, errorMessage); 4664``` 4665 4666 4667 4668## MapIteratorRef 4669 4670用于表示和操作JS Map对象的迭代器引用的类，它继承自ObjectRef类，并提供了一些操作JS Map迭代器方法。 4671 4672### GetKind 4673 4674Local<JSValueRef> GetKind(const EcmaVM *vm)； 4675 4676获取MapIterator迭代元素的类型，分别为key，value，keyAndValue。 4677 4678**参数：** 4679 4680| 参数名 | 类型 | 必填 | 说明 | 4681| :----: | -------------- | ---- | ------------ | 4682| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4683 4684**返回值：** 4685 4686| 类型 | 说明 | 4687| ----------------- | ------------------------------------------------------------ | 4688| Local<JSValueRef> | 获取迭代器的类型并将其转为Local<JSValueRef>，作为函数的返回值。 | 4689 4690**示例：** 4691 4692```c++ 4693JSHandle<GlobalEnv> env = vm->GetGlobalEnv(); 4694ObjectFactory *factory = vm->GetFactory(); 4695JSHandle<JSTaggedValue> builtinsMapFunc = env->GetBuiltinsMapFunction(); 4696JSHandle<JSMap> jsMap(factory->NewJSObjectByConstructor(JSHandle<JSFunction>(builtinsMapFunc), builtinsMapFunc)); 4697JSHandle<JSTaggedValue> linkedHashMap(LinkedHashMap::Create(vm->GetJSThread())); 4698jsMap->SetLinkedMap(vm->GetJSThread(), linkedHashMap); 4699JSHandle<JSTaggedValue> mapValue(jsMap); 4700JSHandle<JSTaggedValue> mapIteratorVal = JSMapIterator::CreateMapIterator(vm->GetJSThread(), mapValue, IterationKind::KEY); 4701JSHandle<JSMapIterator> mapIterator = JSHandle<JSMapIterator>::Cast(mapIteratorVal); 4702mapIterator->SetIterationKind(IterationKind::VALUE); 4703mapIterator->SetIterationKind(IterationKind::KEY_AND_VALUE); 4704Local<MapIteratorRef> object = JSNApiHelper::ToLocal<MapIteratorRef>(mapIteratorVal); 4705Local<JSValueRef> type = object->GetKind(vm); 4706``` 4707 4708### GetIndex 4709 4710int32_t GetIndex(); 4711 4712用于获取Map迭代器的索引值，并使用断言验证结果是否为0，即初始索引值。 4713 4714**参数：** 4715 4716无 4717 4718**返回值：** 4719 4720| 类型 | 说明 | 4721| :------ | :---------------------------- | 4722| int32_t | 返回获取的Map迭代器的索引值。 | 4723 4724**示例：** 4725 4726```c++ 4727ObjectFactory *factory = vm_->GetFactory(); 4728JSHandle<JSTaggedValue> builtinsMapFunc = vm_->GetGlobalEnv()->GetBuiltinsMapFunction(); 4729JSHandle<JSMap> jsMap(factory->NewJSObjectByConstructor(JSHandle<JSFunction>(builtinsMapFunc), builtinsMapFunc)); 4730JSHandle<JSTaggedValue> linkedHashMap(LinkedHashMap::Create(thread_)); 4731jsMap->SetLinkedMap(thread_, linkedHashMap); 4732JSHandle<JSTaggedValue> mapValue(jsMap); 4733JSHandle<JSTaggedValue> mapIteratorVal = JSMapIterator::CreateMapIterator(thread_, mapValue, IterationKind::KEY); 4734JSHandle<JSMapIterator> mapIterator = JSHandle<JSMapIterator>::Cast(mapIteratorVal); 4735mapIterator->SetNextIndex(index); 4736Local<MapIteratorRef> object = JSNApiHelper::ToLocal<MapIteratorRef>(mapIteratorVal); 4737int32_t result = object->GetIndex(); 4738``` 4739 4740 4741 4742## PrimitiveRef 4743 4744表述为原始对象，包括Undefined，Null，Boolean，Number，String，Symbol，BigInt 这些Primitive类型的值是不可变的，即一旦创建就不能修改。 4745 4746### GetValue 4747 4748Local<JSValueRef> GetValue(const EcmaVM *vm)； 4749 4750获取原始对象的值。 4751 4752**参数：** 4753 4754| 参数名 | 类型 | 必填 | 说明 | 4755| :----: | -------------- | ---- | ------------ | 4756| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4757 4758**返回值：** 4759 4760| 类型 | 说明 | 4761| ----------------- | ------------------------------------------------------------ | 4762| Local<JSValueRef> | 获取值将其转换为 Local<JSValueRef>类型对象，并作为函数的返回值。 | 4763 4764**示例：** 4765 4766```C++ 4767Local<IntegerRef> intValue = IntegerRef::New(vm, 10); 4768Local<JSValueRef> jsValue = intValue->GetValue(vm); 4769``` 4770 4771## IntegerRef 4772 4773用于表示一个整数，它通常用于处理整数运算，IntegerRef可以存储更大的整数，最多可以存储16个整数。 4774 4775### New 4776 4777static Local<IntegerRef> New(const EcmaVM *vm, int input)； 4778 4779创建一个新的IntegerRef对象。 4780 4781**参数：** 4782 4783| 参数名 | 类型 | 必填 | 说明 | 4784| :----: | -------------- | ---- | -------------------- | 4785| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4786| input | int | 是 | IntegerRef对象的值。 | 4787 4788**返回值：** 4789 4790| 类型 | 说明 | 4791| ----------------- | ---------------------------- | 4792| Local<IntegerRef> | 返回一个新的IntegerRef对象。 | 4793 4794**示例：** 4795 4796```C++ 4797Local<IntegerRef> intValue = IntegerRef::New(vm, 0); 4798``` 4799 4800### NewFromUnsigned 4801 4802static Local<IntegerRef> NewFromUnsigned(const EcmaVM *vm, unsigned int input)； 4803 4804创建无符号的IntegerRef对象。 4805 4806**参数：** 4807 4808| 参数名 | 类型 | 必填 | 说明 | 4809| :----: | -------------- | ---- | -------------------- | 4810| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4811| input | int | 是 | IntegerRef对象的值。 | 4812 4813**返回值：** 4814 4815| 类型 | 说明 | 4816| ----------------- | ---------------------------- | 4817| Local<IntegerRef> | 返回一个新的IntegerRef对象。 | 4818 4819**示例：** 4820 4821```C++ 4822Local<IntegerRef> intValue = IntegerRef::NewFromUnsigned(vm, 0); 4823``` 4824 4825### Value 4826 4827int IntegerRef::Value(); 4828 4829获取一个IntegerRef对象的整数值。 4830 4831**参数：** 4832 4833无 4834 4835**返回值：** 4836 4837| 类型 | 说明 | 4838| ---- | ----------------------- | 4839| int | 返回一个int类型的数值。 | 4840 4841**示例：** 4842 4843```c++ 4844int num = 0; 4845Local<IntegerRef> intValue = IntegerRef::New(vm_, num); 4846int i = intValue->Value(); 4847``` 4848 4849 4850 4851 4852 4853## PromiseRef 4854 4855用于处理异步操作，它表示一个尚未完成但预计在未来会完成的操作，并且返回一个值。Promise有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。 4856 4857### Catch 4858 4859Local<PromiseRef> Catch(const EcmaVM *vm, Local<FunctionRef> handler)； 4860 4861用于捕获异步操作中的错误，当一个Promise被rejected时，可以使用catch方法来处理错误。 4862 4863**参数：** 4864 4865| 参数名 | 类型 | 必填 | 说明 | 4866| :-----: | ------------------ | ---- | ------------------------------------------------------------ | 4867| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4868| handler | Local<FunctionRef> | 是 | 指向FunctionRef类型的局部变量，表示处理异常的回调函数。将在Promise对象中发生异常时被调用。 | 4869 4870**返回值：** 4871 4872| 类型 | 说明 | 4873| ----------------- | ------------------------------------------------------------ | 4874| Local<PromiseRef> | 如果在调用过程中发生中断，则返回未定义（undefined）。否则，将结果转换为PromiseRef类型并返回。 | 4875 4876**示例：** 4877 4878```C++ 4879Local<JSValueRef> FunCallback(JsiRuntimeCallInfo *info) 4880{ 4881 EscapeLocalScope scope(info->GetVM()); 4882 return scope.Escape(ArrayRef::New(info->GetVM(), info->GetArgsNumber())); 4883} 4884Local<PromiseCapabilityRef> capability = PromiseCapabilityRef::New(vm); 4885Local<PromiseRef> promise = capability->GetPromise(vm); 4886Local<FunctionRef> reject = FunctionRef::New(vm, FunCallback); 4887Local<PromiseRef> result = promise->Catch(vm, reject); 4888``` 4889 4890### Then 4891 4892Local<PromiseRef> Then(const EcmaVM *vm, Local<FunctionRef> handler)； 4893 4894对Promise设置一个回调函数，Promise对象敲定时执行的函数。 4895 4896Local<PromiseRef> Then(const EcmaVM *vm, Local<FunctionRef> onFulfilled, Local<FunctionRef> onRejected)； 4897 4898对Promise设置一个回调函数，Promise对象敲定执行onFulfilled，Promise对象拒绝执行onRejected。 4899 4900**参数：** 4901 4902| 参数名 | 类型 | 必填 | 说明 | 4903| :---------: | ------------------ | ---- | --------------------------- | 4904| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4905| onFulfilled | Local<FunctionRef> | 是 | Promise对象敲定执行的函数。 | 4906| onRejected | Local<FunctionRef> | 是 | Promise对象拒绝执行的函数。 | 4907 4908**返回值：** 4909 4910| 类型 | 说明 | 4911| ----------------- | ------------------------------------------------------------ | 4912| Local<PromiseRef> | 将其结果为 Local<JSValueRef>类型对象，并作为函数的返回值，用于判断异步函数是否设置成功。 | 4913 4914**示例：** 4915 4916```C++ 4917Local<JSValueRef> FunCallback(JsiRuntimeCallInfo *info) 4918{ 4919 EscapeLocalScope scope(info->GetVM()); 4920 return scope.Escape(ArrayRef::New(info->GetVM(), info->GetArgsNumber())); 4921} 4922Local<PromiseCapabilityRef> capability = PromiseCapabilityRef::New(vm); 4923Local<PromiseRef> promise = capability->GetPromise(vm); 4924Local<FunctionRef> callback = FunctionRef::New(vm, FunCallback); 4925Local<PromiseRef> result = promise->Then(vm, callback, callback); 4926``` 4927 4928### Finally 4929 4930Local<PromiseRef> Finally(const EcmaVM *vm, Local<FunctionRef> handler)； 4931 4932无论Promise对象敲定还是拒绝都会执行的函数。 4933 4934**参数：** 4935 4936| 参数名 | 类型 | 必填 | 说明 | 4937| :-----: | ------------------ | ---- | ---------------- | 4938| vm | const EcmaVM * | 是 | 虚拟机对象。 | 4939| handler | Local<FunctionRef> | 是 | 需要执行的函数。 | 4940 4941**返回值：** 4942 4943| 类型 | 说明 | 4944| ----------------- | ------------------------------------------------------------ | 4945| Local<PromiseRef> | 将其结果为 Local<JSValueRef>类型对象，并作为函数的返回值，用于判断异步函数是否设置成功。 | 4946 4947**示例：** 4948 4949```C++ 4950Local<JSValueRef> FunCallback(JsiRuntimeCallInfo *info) 4951{ 4952 EscapeLocalScope scope(info->GetVM()); 4953 return scope.Escape(ArrayRef::New(info->GetVM(), info->GetArgsNumber())); 4954} 4955Local<PromiseCapabilityRef> capability = PromiseCapabilityRef::New(vm); 4956Local<PromiseRef> promise = capability->GetPromise(vm); 4957Local<FunctionRef> callback = FunctionRef::New(vm, FunCallback); 4958Local<PromiseRef> result = promise->Finally(vm, callback); 4959``` 4960 4961## TryCatch 4962 4963异常处理类，用于在JS中捕获和处理一些异常。 4964 4965### GetAndClearException 4966 4967Local<ObjectRef> GetAndClearException()； 4968 4969获取和清除捕获到的异常对象。 4970 4971**参数：** 4972 4973| 参数名 | 类型 | 必填 | 说明 | 4974| ------ | ---- | ---- | ---- | 4975| 无参 | | | | 4976 4977**返回值：** 4978 4979| 类型 | 说明 | 4980| ---------------- | ------------------------------------------------------------ | 4981| Local<ObjectRef> | 获取捕获到的异常，并将其转换为 Local<ObjectRef>类型对象，并将作为函数的返回值。 | 4982 4983**示例：** 4984 4985```C++ 4986Local<StringRef> message = StringRef::NewFromUtf8(vm, "ErrorTest"); 4987JSNApi::ThrowException(vm, Exception::Error(vm, message);); 4988TryCatch tryCatch(vm); 4989Local<ObjectRef> error = tryCatch.GetAndClearException(); 4990``` 4991 4992### TryCatch 4993 4994explicit TryCatch(const EcmaVM *ecmaVm) : ecmaVm_(ecmaVm) {}; 4995 4996用于构造TryCatch类的对象。 4997 4998**参数：** 4999 5000| 参数名 | 类型 | 必填 | 说明 | 5001| ------ | -------------- | ---- | ---------- | 5002| ecmaVm | const EcmaVM * | 是 | 虚拟机对象 | 5003 5004**返回值：** 5005 5006无 5007 5008**示例：** 5009 5010```c++ 5011TryCatch(vm_); 5012``` 5013 5014### HasCaught 5015 5016bool HasCaught() const; 5017 5018用于检查是否有异常对象被捕获。 5019 5020**参数：** 5021 5022无 5023 5024**返回值：** 5025 5026| 类型 | 说明 | 5027| :------ | :------------------------------------------------ | 5028| boolean | 如果有异常对象被捕获，则返回true，否则返回false。 | 5029 5030**示例：** 5031 5032```c++ 5033Local<StringRef> message = StringRef::NewFromUtf8(vm_, "ErrorTest"); 5034Local<JSValueRef> error = Exception::Error(vm_, message); 5035JSNApi::ThrowException(vm_, error); 5036TryCatch tryCatch(vm_); 5037bool result = tryCatch.HasCaught(); 5038``` 5039 5040### Rethrow 5041 5042void Rethrow(); 5043 5044如果有异常被捕获并处理，通过检查rethrow_的值来确定是否需要重新抛出异常。 5045 5046**参数：** 5047 5048无 5049 5050**返回值：** 5051 5052无。 5053 5054**示例：** 5055 5056```c++ 5057TryCatch tryCatch(vm_); 5058tryCatch.Rethrow(); 5059``` 5060 5061 5062 5063## Uint32ArrayRef 5064 5065用于表示一个无符号32位整数数组的引用，继承自TypedArrayRef，并提供了创建一个新的Uint32Array对象的方法。 5066 5067### New 5068 5069static Local<Uint32ArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset, int32_t length); 5070 5071用于构造一个使用ArrayBuffer对象指定偏移量和长度转换的Uint32Array对象。 5072 5073**参数：** 5074 5075| 参数名 | 类型 | 必填 | 说明 | 5076| ---------- | --------------------- | ---- | ------------------------------------ | 5077| vm | const EcmaVM * | 是 | 虚拟机对象 | 5078| buffer | Local<ArrayBufferRef> | 是 | 要转换为Uint32Array的ArrayBuffer对象 | 5079| byteOffset | int32_t | 是 | ArrayBuffer对象的指定位置偏移量 | 5080| length | int32_t | 是 | ArrayBuffer对象的指定长度 | 5081 5082**返回值：** 5083 5084| 类型 | 说明 | 5085| :-------------------- | :-------------------------- | 5086| Local<Uint32ArrayRef> | 返回构造的Uint32Array对象。 | 5087 5088**示例：** 5089 5090```c++ 5091Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm_, bufferLength); 5092Local<Uint32ArrayRef> result = Uint32ArrayRef::New(vm_,arrayBuffer,bufferOffset,offsetLength); 5093``` 5094 5095 5096 5097## Uint8ArrayRef 5098 5099用于表示一个无符号8位整数数组的引用，继承自TypedArrayRef，并提供了创建一个新的Uint8Array对象的方法。 5100 5101### New 5102 5103static Local<Uint8ArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset, int32_t length); 5104 5105用于构造一个使用ArrayBuffer对象指定偏移量和长度转换的Uint8Array对象。 5106 5107**参数：** 5108 5109| 参数名 | 类型 | 必填 | 说明 | 5110| ---------- | --------------------- | ---- | ----------------------------------- | 5111| vm | const EcmaVM * | 是 | 虚拟机对象 | 5112| buffer | Local<ArrayBufferRef> | 是 | 要转换为Uint8Array的ArrayBuffer对象 | 5113| byteOffset | int32_t | 是 | ArrayBuffer对象的指定位置偏移量 | 5114| length | int32_t | 是 | ArrayBuffer对象的指定长度 | 5115 5116**返回值：** 5117 5118| 类型 | 说明 | 5119| :-------------------- | :-------------------------- | 5120| Local<Uint32ArrayRef> | 返回构造的Uint32Array对象。 | 5121 5122**示例：** 5123 5124```c++ 5125Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm_, 30); 5126Local<Uint8ArrayRef> result = Uint8ArrayRef::New(vm_,arrayBuffer,10,10); 5127``` 5128 5129 5130 5131## MapRef 5132 5133用于表示和操作JS Map对象的引用，它继承自ObjectRef类，并提供了一些操作JSMap对象的方法。 5134 5135### New 5136 5137static Local<MapRef> New(const EcmaVM *vm); 5138 5139用于创建一个Map对象。 5140 5141**参数：** 5142 5143| 参数名 | 类型 | 必填 | 说明 | 5144| ------ | -------------- | ---- | ---------- | 5145| vm | const EcmaVM * | 是 | 虚拟机对象 | 5146 5147**返回值：** 5148 5149| 类型 | 说明 | 5150| :------------ | :------------------ | 5151| Local<MapRef> | 返回创建的Map对象。 | 5152 5153**示例：** 5154 5155```c++ 5156Local<MapRef> result = MapRef::New(vm_); 5157``` 5158 5159### GetSize 5160 5161int32_t GetSize(); 5162 5163 返回 `MapRef` 对象中键值对的数量，即 `Map` 对象的大小。 5164 5165通过 `JSNApiHelper::ToJSHandle(this)` 将当前的 `MapRef` 对象转换为 JavaScript 中的 `JSMap` 对象。 5166 5167调用 `JSMap::GetSize` 方法获取 `Map` 对象的大小。 5168 5169**参数：** 5170 5171无 5172 5173**返回值：** 5174 5175| 类型 | 说明 | 5176| ------- | ---------------------- | 5177| int32_t | 返回`Map` 对象的大小。 | 5178 5179**示例：** 5180 5181```c++ 5182Local<MapRef> mapRef = MapRef::New(vm_); 5183int32_t size = mapRef->GetSize(); 5184``` 5185 5186### GetTotalElements 5187 5188int32_t GetTotalElements(); 5189 5190返回 `MapRef` 对象中所有元素的数量，包括实际存在的元素和已删除的元素。 5191 5192通过 `JSNApiHelper::ToJSHandle(this)` 将当前的 `MapRef` 对象转换为 JavaScript 中的 `JSMap` 对象。 5193 5194调用 `JSMap::GetSize` 方法获取 `Map` 对象的大小，加上已删除元素的数量。 5195 5196**参数：** 5197 5198无 5199 5200**返回值：** 5201 5202| 类型 | 说明 | 5203| ------- | ---------------------- | 5204| int32_t | 对象中所有元素的数量。 | 5205 5206**示例：** 5207 5208```c++ 5209Local<MapRef> mapRef = MapRef::New(vm_); 5210int32_t totalElements = mapRef->GetTotalElements(); 5211``` 5212 5213### Get 5214 5215Local<JSValueRef> Get(const EcmaVM *vm, Local<JSValueRef> key); 5216 5217返回 `MapRef` 对象中指定键的值。 5218 5219在获取之前，通过 `CHECK_HAS_PENDING_EXCEPTION_RETURN_UNDEFINED` 宏检查是否存在潜在的异常。 5220 5221使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `MapRef` 对象转换为 JavaScript 中的 `JSMap` 对象。 5222 5223调用 `map->Get` 方法获取与给定键对应的值。 5224 5225**参数：** 5226 5227| 参数名 | 类型 | 必填 | 说明 | 5228| ------ | ----------------- | ---- | ---------------- | 5229| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5230| key | Local<JSValueRef> | 是 | 表示要获取的键。 | 5231 5232**返回值：** 5233 5234| 类型 | 说明 | 5235| ----------------- | ---------------------------- | 5236| Local<JSValueRef> | 返回表示迭代类型的字符串值。 | 5237 5238**示例：** 5239 5240```c++ 5241Local<MapRef> mapRef = MapRef::New(vm_); 5242Local<JSValueRef> myValue = MapRef->Get(myEcmaVM, myKey); 5243``` 5244 5245### GetKey 5246 5247Local<JSValueRef> GetKey(const EcmaVM *vm, int entry); 5248 5249获取 Map 对象中指定索引处的键。 5250 5251在获取之前，通过 `CHECK_HAS_PENDING_EXCEPTION_RETURN_UNDEFINED` 宏检查是否存在潜在的异常。 5252 5253使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `MapRef` 对象转换为 JavaScript 中的 `JSMap` 对象。 5254 5255 调用 `map->GetKey(entry)` 方法获取 Map 对象中指定索引处的键，并将结果转换为 `Local<JSValueRef>`。 5256 5257**参数：** 5258 5259| 参数名 | 类型 | 必填 | 说明 | 5260| ------ | -------------- | ---- | --------------------------------------------- | 5261| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5262| entry | int | 是 | 表示 Map 对象中的条目索引，用于获取相应的键。 | 5263 5264**返回值：** 5265 5266| 类型 | 说明 | 5267| ----------------- | --------------------------------- | 5268| Local<JSValueRef> | 返回了 Map 对象中指定索引处的键。 | 5269 5270**示例：** 5271 5272```c++ 5273Local<MapRef> mapRef = MapRef::New(vm_); 5274Local<JSValueRef> myKey = MapRef->GetKey(myEcmaVM, myEntry); 5275``` 5276 5277### GetValue 5278 5279Local<JSValueRef> GetValue(const EcmaVM *vm, int entry); 5280 5281获取 Map 对象中指定索引处的值。 5282 5283在获取之前，通过 `CHECK_HAS_PENDING_EXCEPTION_RETURN_UNDEFINED` 宏检查是否存在潜在的异常。 5284 5285使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `MapRef` 对象转换为 JavaScript 中的 `JSMap` 对象。 5286 5287调用 `map->GetValue(entry)` 方法获取 Map 对象中指定索引处的值，并将结果转换为 `Local<JSValueRef>`。 5288 5289**参数：** 5290 5291| 参数名 | 类型 | 必填 | 说明 | 5292| ------ | -------------- | ---- | ------------------ | 5293| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5294| entry | int | 是 | 用于获取相应的值。 | 5295 5296**返回值：** 5297 5298| 类型 | 说明 | 5299| ----------------- | --------------------------------- | 5300| Local<JSValueRef> | 返回了 Map 对象中指定索引处的值。 | 5301 5302**示例：** 5303 5304```c++ 5305Local<MapRef> mapRef = MapRef::New(vm_); 5306Local<JSValueRef> myValue = MapRef->Get(myEcmaVM, myEntry); 5307``` 5308 5309### Set 5310 5311void Set(const EcmaVM *vm, Local<JSValueRef> key, Local<JSValueRef> value); 5312 5313 向当前 `MapRef` 对象中设置键值对。 5314 5315在设置之前，通过 `CHECK_HAS_PENDING_EXCEPTION_WITHOUT_RETURN` 宏检查是否存在潜在的异常。 5316 5317使用 `JSNApiHelper::ToJSHandle(this)` 将当前的 `MapRef` 对象转换为 JavaScript 中的 `JSMap` 对象。 5318 5319调用 `JSMap::Set` 方法在 Map 对象中设置键值对。 5320 5321**参数：** 5322 5323| 参数名 | 类型 | 必填 | 说明 | 5324| ------ | ----------------- | ---- | ---------------- | 5325| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5326| key | Local<JSValueRef> | 是 | 表示要设置的键。 | 5327| value | Local<JSValueRef> | 是 | 表示要设置的值。 | 5328 5329**返回值：** 5330 5331无 5332 5333**示例：** 5334 5335```c++ 5336myMap.Set(myEcmaVM, myKey, myValue); 5337``` 5338 5339 5340 5341## WeakMapRef 5342 5343用于表示和操作JS WeakMap对象的类，它继承自ObjectRef类，并提供了一些操作JS WeakMap对象的方法。 5344 5345### GetSize 5346 5347int32_t GetSize(); 5348 5349用于获取WeakMap的大小。 5350 5351**参数：** 5352 5353无 5354 5355**返回值：** 5356 5357| 类型 | 说明 | 5358| :------ | :-------------------------- | 5359| int32_t | 返回获取到的WeakMap的大小。 | 5360 5361**示例：** 5362 5363```c++ 5364Local<WeakMapRef> object = WeakMapRef::New(vm_); 5365Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 5366Local<JSValueRef> value = StringRef::NewFromUtf8(vm_, "TestValue"); 5367object->Set(vm_, key, value); 5368int32_t result = object->GetSize(); 5369``` 5370 5371### GetTotalElements 5372 5373int32_t GetTotalElements(); 5374 5375用于获取WeakMap的元素个数。 5376 5377**参数：** 5378 5379无 5380 5381**返回值：** 5382 5383| 类型 | 说明 | 5384| :------ | :------------------------------ | 5385| int32_t | 返回获取到的WeakMap的元素个数。 | 5386 5387**示例：** 5388 5389```c++ 5390Local<WeakMapRef> object = WeakMapRef::New(vm_); 5391Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 5392Local<JSValueRef> value = StringRef::NewFromUtf8(vm_, "TestValue"); 5393object->Set(vm_, key, value); 5394int32_t result = object->GetTotalElements(); 5395``` 5396 5397### GetKey 5398 5399Local<JSValueRef> GetKey(const EcmaVM *vm, int entry); 5400 5401通过指定的入口位置获取WeakMap中指定的键。 5402 5403**参数：** 5404 5405| 参数名 | 类型 | 必填 | 说明 | 5406| ------ | -------------- | ---- | -------------------- | 5407| vm | const EcmaVM * | 是 | 虚拟机对象 | 5408| entry | int | 是 | 要获取的键的入口位置 | 5409 5410**返回值：** 5411 5412| 类型 | 说明 | 5413| :---------------- | :--------------------- | 5414| Local<JSValueRef> | 返回获取到的指定的键。 | 5415 5416**示例：** 5417 5418```c++ 5419Local<WeakMapRef> object = WeakMapRef::New(vm_); 5420Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 5421Local<JSValueRef> value = StringRef::NewFromUtf8(vm_, "TestValue"); 5422object->Set(vm_, key, value); 5423Local<JSValueRef> result = object->GetKey(vm_, entry); 5424``` 5425 5426### GetValue 5427 5428Local<JSValueRef> GetValue(const EcmaVM *vm, int entry); 5429 5430通过指定的入口位置获取WeakMap中指定的Value值。 5431 5432**参数：** 5433 5434| 参数名 | 类型 | 必填 | 说明 | 5435| ------ | -------------- | ---- | ------------------------- | 5436| vm | const EcmaVM * | 是 | 虚拟机对象 | 5437| entry | int | 是 | 要获取的Value值的入口位置 | 5438 5439**返回值：** 5440 5441| 类型 | 说明 | 5442| :---------------- | :-------------------------- | 5443| Local<JSValueRef> | 返回获取到的指定的Value值。 | 5444 5445**示例：** 5446 5447```c++ 5448Local<WeakMapRef> object = WeakMapRef::New(vm_); 5449Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 5450Local<JSValueRef> value = StringRef::NewFromUtf8(vm_, "TestValue"); 5451object->Set(vm_, key, value); 5452Local<JSValueRef> result = object->GetValue(vm_, entry); 5453``` 5454 5455 5456 5457## WeakSetRef 5458 5459用于表示和操作JS WeakSet对象的类，它继承自ObjectRef类，并提供了一些操作JS WeakSet对象的方法。 5460 5461### GetSize 5462 5463int32_t GetSize(); 5464 5465用于获取WeakSet的大小。 5466 5467**参数：** 5468 5469无 5470 5471**返回值：** 5472 5473| 类型 | 说明 | 5474| :------ | :-------------------------- | 5475| int32_t | 返回获取到的WeakSet的大小。 | 5476 5477**示例：** 5478 5479```c++ 5480Local<WeakSetRef> object = WeakSetRef::New(vm_); 5481Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 5482Local<JSValueRef> value = StringRef::NewFromUtf8(vm_, "TestValue"); 5483object->Set(vm_, key, value); 5484int32_t result = object->GetSize(); 5485``` 5486 5487### GetTotalElements 5488 5489int32_t GetTotalElements(); 5490 5491用于获取WeakSet的元素个数。 5492 5493**参数：** 5494 5495无 5496 5497**返回值：** 5498 5499| 类型 | 说明 | 5500| :------ | :------------------------------ | 5501| int32_t | 返回获取到的WeakSet的元素个数。 | 5502 5503**示例：** 5504 5505```c++ 5506Local<WeakSetRef> object = WeakSetRef::New(vm_); 5507Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 5508Local<JSValueRef> value = StringRef::NewFromUtf8(vm_, "TestValue"); 5509object->Set(vm_, key, value); 5510int32_t result = object->GetTotalElements(); 5511``` 5512 5513### GetValue 5514 5515Local<JSValueRef> GetValue(const EcmaVM *vm, int entry); 5516 5517通过指定的入口位置获取WeakSet中指定的Value值。 5518 5519**参数：** 5520 5521| 参数名 | 类型 | 必填 | 说明 | 5522| ------ | -------------- | ---- | ------------------------- | 5523| vm | const EcmaVM * | 是 | 虚拟机对象 | 5524| entry | int | 是 | 要获取的Value值的入口位置 | 5525 5526**返回值：** 5527 5528| 类型 | 说明 | 5529| :---------------- | :-------------------------- | 5530| Local<JSValueRef> | 返回获取到的指定的Value值。 | 5531 5532**示例：** 5533 5534```c++ 5535Local<WeakSetRef> object = WeakSetRef::New(vm_); 5536Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 5537Local<JSValueRef> value = StringRef::NewFromUtf8(vm_, "TestValue"); 5538object->Set(vm_, key, value); 5539Local<JSValueRef> result = object->GetValue(vm_, 0); 5540``` 5541 5542 5543 5544## JSExecutionScope 5545 5546用于表示JS执行作用域的类，管理JS代码在特定执行环境中的上下文。 5547 5548### JSExecutionScope 5549 5550explicit JSExecutionScope(const EcmaVM *vm); 5551 5552用于构造一个 JSExecutionScope类型的对象。 5553 5554**参数：** 5555 5556| 参数名 | 类型 | 必填 | 说明 | 5557| ------ | -------------- | ---- | ---------- | 5558| vm | const EcmaVM * | 是 | 虚拟机对象 | 5559 5560**返回值：** 5561 5562无 5563 5564**示例：** 5565 5566```c++ 5567JSExecutionScope(vm_); 5568``` 5569 5570 5571 5572## NativePointerRef 5573 5574继承于JSValueRef，提供了构造原生指针的方法。 5575 5576### New 5577 5578static Local<NativePointerRef> New(const EcmaVM *vm, void *nativePointer, size_t nativeBindingsize = 0); 5579 5580static Local<NativePointerRef> New(const EcmaVM *vm, void *nativePointer, NativePointerCallback callBack, void *data, size_t nativeBindingsize = 0); 5581 5582用于构造一个原生指针类型的对象。 5583 5584**参数：** 5585 5586| 参数名 | 类型 | 必填 | 说明 | 5587| ----------------- | --------------------- | ---- | -------------------------------- | 5588| vm | const EcmaVM * | 是 | 虚拟机对象 | 5589| nativePointer | void * | 是 | 原生指针 | 5590| nativeBindingsize | size_t | 否 | 原生绑定的大小 | 5591| callBack | NativePointerCallback | 是 | 原生指针的回调函数 | 5592| data | void * | 是 | 任意数据指针，作为回调函数的参数 | 5593 5594**返回值：** 5595 5596| 类型 | 说明 | 5597| :---------------------- | :----------------------------------------- | 5598| Local<NativePointerRef> | 返回构造成功的NativePointerRef类型的对象。 | 5599 5600**示例：** 5601 5602```c++ 5603void *vps = static_cast<void *>(new std::string("test")); 5604Local<NativePointerRef> result = NativePointerRef::New(vm_, vps, 0); 5605NativePointerCallback callBack = nullptr; 5606void *vps = static_cast<void *>(new std::string("test")); 5607void *vpsdata = static_cast<void *>(new std::string("test")); 5608Local<NativePointerRef> result = NativePointerRef::New(vm_, vps, callBack, vpsdata, 0); 5609``` 5610 5611### Value 5612 5613void *Value(); 5614 5615获取一个外部指针，并将它指向一个本地指针并返回。 5616 5617**参数：** 5618 5619无 5620 5621**返回值：** 5622 5623| 类型 | 说明 | 5624| :----- | :--------------------------- | 5625| void * | 返回值为获取原生对象的指针。 | 5626 5627**示例：** 5628 5629```c++ 5630void *vps = static_cast<void *>(new std::string("test")); 5631void *vps1 = static_cast<void *>(new std::string("test")); 5632Local<NativePointerRef> res_vps = NativePointerRef::New(vm_, vps, NativeAreaAllocator::FreeBufferFunc, vps1, 0); 5633void *result = res_vps->Value(); 5634``` 5635 5636 5637 5638## BigInt64ArrayRef 5639 5640用于表示一个64位整数数组，它通常用于处理大整数运算，因为普通的Number类型在JavaScript中只能精确表示到53位整数 5641 5642### New 5643 5644static Local<BigInt64ArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset, int32_t length)； 5645 5646创建一个BigInt64ArrayRef对象。 5647 5648**参数：** 5649 5650| 参数名 | 类型 | 必填 | 说明 | 5651| ---------- | --------------------- | ---- | ------------------------------------- | 5652| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5653| buffer | Local<ArrayBufferRef> | 是 | 一个 ArrayBuffer 对象，用于存储数据。 | 5654| byteOffset | int32_t | 是 | 表示从缓冲区的哪个字节开始读取数据。 | 5655| length | int32_t | 是 | 表示要读取的元素数量。 | 5656 5657**返回值：** 5658 5659| 类型 | 说明 | 5660| ----------------------- | ------------------------------ | 5661| Local<BigInt64ArrayRef> | 一个新的BigInt64ArrayRef对象。 | 5662 5663**示例：** 5664 5665```C++ 5666Local<ArrayBufferRef> buffer = ArrayBufferRef::New(vm, 5); 5667Local<ObjectRef> object = BigInt64ArrayRef::New(vm, buffer, 0, 5); 5668``` 5669 5670## BigIntRef 5671 5672用于表示任意大的整数。它提供了一种方法来处理超过Number类型能表示的整数范围的数字。 5673 5674### New 5675 5676static Local<BigIntRef> New(const EcmaVM *vm, int64_t input)； 5677 5678创建一个新的BigIntRef对象。 5679 5680**参数：** 5681 5682| 参数名 | 类型 | 必填 | 说明 | 5683| ------ | -------------- | ---- | ----------------------------- | 5684| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5685| input | int64_t | 是 | 需要转为BigIntRef对象的数值。 | 5686 5687**返回值：** 5688 5689| 类型 | 说明 | 5690| ---------------- | ----------------------- | 5691| Local<BigIntRef> | 一个新的BigIntRef对象。 | 5692 5693**示例：** 5694 5695```C++ 5696int64_t maxInt64 = std::numeric_limits<int64_t>::max(); 5697Local<BigIntRef> valie = BigIntRef::New(vm, maxInt64); 5698``` 5699 5700### BigIntToInt64 5701 5702void BigIntRef::BigIntToInt64(const EcmaVM *vm, int64_t *cValue, bool *lossless)； 5703 5704将BigInt对象转换为64位有符号整数，是否能够正确处理无损转换。 5705 5706**参数：** 5707 5708| 参数名 | 类型 | 必填 | 说明 | 5709| -------- | -------------- | ---- | --------------------------------------- | 5710| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5711| cValue | int64_t * | 是 | 用于存储转换为Int64数值的变量。 | 5712| lossless | bool * | 是 | 用于判断超大数是否能够转换为Int64类型。 | 5713 5714**返回值：** 5715 5716| 类型 | 说明 | 5717| ---- | ---------- | 5718| void | 无返回值。 | 5719 5720**示例：** 5721 5722```C++ 5723uint64_t maxUint64 = std::numeric_limits<uint64_t>::max(); 5724Local<BigIntRef> maxBigintUint64 = BigIntRef::New(vm, maxUint64); 5725int64_t toNum; 5726bool lossless = true; 5727maxBigintUint64->BigIntToInt64(vm, &toNum, &lossless); 5728``` 5729 5730### BigIntToUint64 5731 5732void BigIntRef::BigIntToUint64(const EcmaVM *vm, uint64_t *cValue, bool *lossless)； 5733 5734将BigInt对象转换为64位无符号整数，无损转换是否可以正确处理。 5735 5736**参数：** 5737 5738| 参数名 | 类型 | 必填 | 说明 | 5739| -------- | -------------- | ---- | --------------------------------------- | 5740| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5741| cValue | uint64_t * | 是 | 用于存储转换为uint64_t数值的变量。 | 5742| lossless | bool * | 是 | 用于判断超大数是否能够转换为Int64类型。 | 5743 5744**返回值：** 5745 5746| 类型 | 说明 | 5747| ---- | ---------- | 5748| void | 无返回值。 | 5749 5750**示例：** 5751 5752```C++ 5753uint64_t maxUint64 = std::numeric_limits<uint64_t>::max(); 5754Local<BigIntRef> maxBigintUint64 = BigIntRef::New(vm, maxUint64); 5755int64_t toNum; 5756bool lossless = true; 5757maxBigintUint64->BigIntToInt64(vm, &toNum, &lossless); 5758``` 5759 5760### CreateBigWords 5761 5762Local<JSValueRef> BigIntRef::CreateBigWords(const EcmaVM *vm, bool sign, uint32_t size, const uint64_t* words)； 5763 5764将一个uint64_t数组包装为一个BigIntRef对象。 5765 5766**参数：** 5767 5768| 参数名 | 类型 | 必填 | 说明 | 5769| ------ | --------------- | ---- | ------------------------------------ | 5770| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5771| sign | bool | 是 | 确定生成的 `BigInt` 是正数还是负数。 | 5772| size | uint32_t | 是 | uint32_t 数组大小。 | 5773| words | const uint64_t* | 是 | uint32_t 数组。 | 5774 5775**返回值：** 5776 5777| 类型 | 说明 | 5778| ----------------- | ------------------------------------------------------------ | 5779| Local<JSValueRef> | 将uint32_t 转换为BigIntRef对象，并将其转换为Local<JSValueRef>类型，作为函数的返回值。 | 5780 5781**示例：** 5782 5783```C++ 5784bool sign = false; 5785uint32_t size = 3; 5786const uint64_t words[3] = { 5787 std::numeric_limits<uint64_t>::min() - 1, 5788 std::numeric_limits<uint64_t>::min(), 5789 std::numeric_limits<uint64_t>::max(), 5790}; 5791Local<JSValueRef> bigWords = BigIntRef::CreateBigWords(vm, sign, size, words); 5792``` 5793 5794### GetWordsArraySize 5795 5796uint32_t GetWordsArraySize()； 5797 5798获取BigIntRef对象包装uint64_t数组的大小。 5799 5800**参数：** 5801 5802| 参数名 | 类型 | 必填 | 说明 | 5803| ------ | ---- | ---- | ---- | 5804| 无参 | | | | 5805 5806**返回值：** 5807 5808| 类型 | 说明 | 5809| -------- | ----------------------------------------- | 5810| uint32_t | 返回BigIntRef对象包装uint64_t数组的大小。 | 5811 5812**示例：** 5813 5814```C++ 5815bool sign = false; 5816uint32_t size = 3; 5817const uint64_t words[3] = { 5818 std::numeric_limits<uint64_t>::min() - 1, 5819 std::numeric_limits<uint64_t>::min(), 5820 std::numeric_limits<uint64_t>::max(), 5821}; 5822Local<JSValueRef> bigWords = BigIntRef::CreateBigWords(vm, sign, size, words); 5823Local<BigIntRef> bigWordsRef(bigWords); 5824uint32_t cnt = bigWordsRef->GetWordsArraySize(); 5825``` 5826 5827### GetWordsArray 5828 5829void BigIntRef::GetWordsArray(bool *signBit, size_t wordCount, uint64_t *words); 5830 5831获取一个BigIntRef对象的值，并将其表示为一个64位无符号整数数组。同时，它还会设置一个布尔值signBit，表示该BigIntRef对象的符号（正数或负数）。 5832 5833**参数：** 5834 5835| 参数名 | 类型 | 必填 | 说明 | 5836| --------- | ---------- | ---- | ------------------------------------------------------------ | 5837| signBit | bool * | 是 | 指向布尔值的指针，用于存储BigIntRef对象的符号（正数或负数）。 | 5838| wordCount | size_t | 是 | 无符号整数，表示要获取的64位无符号整数数组的长度。 | 5839| words | uint64_t * | 是 | 指向64位无符号整数的指针，用于存储BigIntRef对象的值。 | 5840 5841**返回值：** 5842 5843无 5844 5845**示例：** 5846 5847```c++ 5848bool sign = false; 5849uint32_t size = 3; 5850const uint64_t words[3] = { 5851 std::numeric_limits<uint64_t>::min() - 1, 5852 std::numeric_limits<uint64_t>::min(), 5853 std::numeric_limits<uint64_t>::max(), 5854}; 5855Local<JSValueRef> bigWords = BigIntRef::CreateBigWords(vm_, sign, size, words); 5856Local<BigIntRef> bigWordsRef(bigWords); 5857bool resultSignBit = true; 5858uint64_t *resultWords = new uint64_t[3](); 5859bigWordsRef->GetWordsArray(&resultSignBit, size, resultWords); 5860``` 5861 5862 5863 5864## StringRef 5865 5866继承于PrimitiveRef，用于表示字符串类型数据的引用，提供了一些对字符串的操作方法。 5867 5868### NewFromUtf8 5869 5870Local<StringRef> StringRef::NewFromUtf8(const EcmaVM *vm, const char *utf8, int length)。 5871 5872创建utf8类型的StringRef对象。 5873 5874**参数：** 5875 5876| 参数名 | 类型 | 必填 | 说明 | 5877| ------ | -------------- | ---- | ---------------- | 5878| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5879| utf8 | char * | 是 | char类型字符串。 | 5880| int | length | 是 | 字符串长度。 | 5881 5882**返回值：** 5883 5884| 类型 | 说明 | 5885| ---------------- | ----------------------- | 5886| Local<StringRef> | 一个新的StringRef对象。 | 5887 5888**示例：** 5889 5890```C++ 5891std::string testUtf8 = "Hello world"; 5892Local<StringRef> description = StringRef::NewFromUtf8(vm, testUtf8.c_str()); 5893``` 5894 5895### NewFromUtf16 5896 5897Local<StringRef> StringRef::NewFromUtf16(const EcmaVM *vm, const char16_t *utf16, int length)； 5898 5899创建utf16类型的StringRef对象。 5900 5901**参数：** 5902 5903| 参数名 | 类型 | 必填 | 说明 | 5904| ------ | -------------- | ---- | --------------------- | 5905| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5906| utf16 | char16_t * | 是 | char16_t 类型字符串。 | 5907| int | length | 是 | 字符串长度。 | 5908 5909**返回值：** 5910 5911| 类型 | 说明 | 5912| ---------------- | ----------------------- | 5913| Local<StringRef> | 一个新的StringRef对象。 | 5914 5915**示例：** 5916 5917```C++ 5918char16_t data = 0Xdf06; 5919Local<StringRef> obj = StringRef::NewFromUtf16(vm, &data); 5920``` 5921 5922### Utf8Length 5923 5924int32_t StringRef::Utf8Length(const EcmaVM *vm)； 5925 5926按utf8类型读取StringRef的值长度。 5927 5928**参数：** 5929 5930| 参数名 | 类型 | 必填 | 说明 | 5931| ------ | -------------- | ---- | ------------ | 5932| vm | const EcmaVM * | 是 | 虚拟机对象。 | 5933 5934**返回值：** 5935 5936| 类型 | 说明 | 5937| ------- | ---------------------- | 5938| int32_t | utf8类型字符串的长度。 | 5939 5940**示例：** 5941 5942```C++ 5943std::string testUtf8 = "Hello world"; 5944Local<StringRef> stringObj = StringRef::NewFromUtf8(vm, testUtf8.c_str()); 5945int32_t lenght = stringObj->Utf8Length(vm); 5946``` 5947 5948### WriteUtf8 5949 5950int StringRef::WriteUtf8(char *buffer, int length, bool isWriteBuffer)； 5951 5952将StringRef的值写入char数组缓冲区。 5953 5954**参数：** 5955 5956| 参数名 | 类型 | 必填 | 说明 | 5957| ------------- | ------ | ---- | ------------------------------------- | 5958| buffer | char * | 是 | 需要写入的缓冲区。 | 5959| length | int | 是 | 需要写入缓冲区的长度。 | 5960| isWriteBuffer | bool | 否 | 是否需要将StringRef的值写入到缓冲区。 | 5961 5962**返回值：** 5963 5964| 类型 | 说明 | 5965| ---- | --------------------------------- | 5966| int | 将StringRef的值转为Utf8后的长度。 | 5967 5968**示例：** 5969 5970```C++ 5971Local<StringRef> local = StringRef::NewFromUtf8(vm, "abcdefbb"); 5972char cs[16] = {0}; 5973int length = local->WriteUtf8(cs, 6); 5974``` 5975 5976### WriteUtf16 5977 5978int StringRef::WriteUtf16(char16_t *buffer, int length)； 5979 5980将StringRef的值写入char数组缓冲区。 5981 5982**参数：** 5983 5984| 参数名 | 类型 | 必填 | 说明 | 5985| ------ | ------ | ---- | ---------------------- | 5986| buffer | char * | 是 | 需要写入的缓冲区。 | 5987| length | int | 是 | 需要写入缓冲区的长度。 | 5988 5989**返回值：** 5990 5991| 类型 | 说明 | 5992| ---- | --------------------------------- | 5993| int | 将StringRef的值转为Utf8后的长度。 | 5994 5995**示例：** 5996 5997```c++ 5998Local<StringRef> local = StringRef::NewFromUtf16(vm, u"您好，华为！"); 5999char cs[16] = {0}; 6000int length = local->WriteUtf16(cs, 3); 6001``` 6002 6003### Length 6004 6005uint32_t StringRef::Length()； 6006 6007获取StringRef的值的长度。 6008 6009**参数：** 6010 6011| 参数名 | 类型 | 必填 | 说明 | 6012| ------ | ---- | ---- | ---- | 6013| 无参 | | | | 6014 6015**返回值：** 6016 6017| 类型 | 说明 | 6018| ---- | --------------------- | 6019| int | StringRef的值的长度。 | 6020 6021**示例：** 6022 6023```c++ 6024Local<StringRef> local = StringRef::NewFromUtf8(vm, "abcdefbb"); 6025int len = local->Length() 6026``` 6027 6028### ToString 6029 6030std::string StringRef::ToString()； 6031 6032将StringRef的值转换为std::string。 6033 6034**参数：** 6035 6036| 参数名 | 类型 | 必填 | 说明 | 6037| ------ | ---- | ---- | ---- | 6038| 无参 | | | | 6039 6040**返回值：** 6041 6042| 类型 | 说明 | 6043| ----------- | ------------------------------------- | 6044| std::string | 将StringRef的value转为C++string类型。 | 6045 6046**示例：** 6047 6048```c++ 6049Local<StringRef> stringObj = StringRef::NewFromUtf8(vm, "abc"); 6050std::string str = stringObj->ToString(); 6051``` 6052 6053### GetNapiWrapperString 6054 6055Local<StringRef> StringRef::GetNapiWrapperString(const EcmaVM *vm); 6056 6057获取一个表示NAPI包装字符串的StringRef对象。 6058 6059**参数：** 6060 6061| 参数名 | 类型 | 必填 | 说明 | 6062| ------ | -------------- | ---- | ------------ | 6063| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6064 6065**返回值：** 6066 6067| 类型 | 说明 | 6068| ---------------- | ------------------------------------------------------------ | 6069| Local<StringRef> | 将表示NAPI包装字符串的对象转换为StringRef对象，并将其作为函数的返回值。 | 6070 6071**示例：** 6072 6073```c++ 6074Local<StringRef> local = StringRef::GetNapiWrapperString(vm_); 6075``` 6076 6077### WriteLatin1 6078 6079int WriteLatin1(char *buffer, int length); 6080 6081将字符串写入到指定的缓冲区中。 6082 6083**参数：** 6084 6085| 参数名 | 类型 | 必填 | 说明 | 6086| ------ | ------ | ---- | ---------------- | 6087| buffer | char * | 是 | 指定的缓冲区 | 6088| length | int | 是 | 要写入的数据长度 | 6089 6090**返回值：** 6091 6092| 类型 | 说明 | 6093| :--- | :--------------------- | 6094| int | 返回值为写入的字节数。 | 6095 6096**示例：** 6097 6098```c++ 6099Local<StringRef> object = StringRef::NewFromUtf8(vm_, "abcdefbb"); 6100char cs[16] = {0}; 6101int result = object->WriteLatin1(cs, length); 6102``` 6103 6104 6105 6106## NumberRef 6107 6108继承于PrimitiveRef，用于表示Number类型数据的引用，并提供了构造NumberRef对象的方法，以及对Number类型数据的一些操作。 6109 6110### New 6111 6112static Local<NumberRef> New(const EcmaVM *vm, double input); 6113 6114static Local<NumberRef> New(const EcmaVM *vm, int32_t input); 6115 6116static Local<NumberRef> New(const EcmaVM *vm, uint32_t input); 6117 6118static Local<NumberRef> New(const EcmaVM *vm, int64_t input); 6119 6120该接口为重载函数，用于构造不同数据类型的NumberRef对象。 6121 6122**参数：** 6123 6124| 参数名 | 类型 | 必填 | 说明 | 6125| ------ | -------------- | ---- | ---------------- | 6126| vm | const EcmaVM * | 是 | 虚拟机对象 | 6127| input | double | 是 | double类型数据 | 6128| input | int32_t | 是 | int32_t类型数据 | 6129| input | uint32_t | 是 | uint32_t类型数据 | 6130| input | int64_t | 是 | int64_t类型数据 | 6131 6132**返回值：** 6133 6134| 类型 | 说明 | 6135| :--------------- | :---------------------------------------- | 6136| Local<NumberRef> | 返回构造成功的不同数据类型的NumberRef对象 | 6137 6138**示例：** 6139 6140```c++ 6141double doubleValue = 3.14; 6142Local<NumberRef> result = NumberRef::New(vm_, doubleValue); 6143int32_t int32Value = 10; 6144Local<NumberRef> result = NumberRef::New(vm_, int32Value); 6145uint32_t uint32Value = 10; 6146Local<NumberRef> result = NumberRef::New(vm_, uint32Value); 6147int64_t int64Value = 10; 6148Local<NumberRef> result = NumberRef::New(vm_, int64Value); 6149``` 6150 6151 6152 6153## ArrayRef 6154 6155继承于ObjectRef，用于构造一个数组对象，并提供了一些操作数组的方法。 6156 6157### Length 6158 6159uint32_t Length(const EcmaVM *vm); 6160 6161获取数组对象的长度。 6162 6163**参数：** 6164 6165| 参数名 | 类型 | 必填 | 说明 | 6166| ------ | -------------- | ---- | ---------- | 6167| vm | const EcmaVM * | 是 | 虚拟机对象 | 6168 6169**返回值：** 6170 6171| 类型 | 说明 | 6172| :------- | :--------------------- | 6173| uint32_t | 返回获取到的数组长度。 | 6174 6175**示例：** 6176 6177```c++ 6178Local<ArrayRef> arrayObj = ArrayRef::New(vm_, 3); 6179uint32_t result = arrayObj->Length(vm_); 6180``` 6181 6182### SetValueAt 6183 6184static bool SetValueAt(const EcmaVM *vm, Local<JSValueRef> obj, uint32_t index, Local<JSValueRef> value); 6185 6186用于在给定的数组对象中设置指定索引位置的值。 6187 6188**参数：** 6189 6190| 参数名 | 类型 | 必填 | 说明 | 6191| ------ | ----------------- | ---- | -------------------- | 6192| vm | const EcmaVM * | 是 | 虚拟机对象 | 6193| obj | Local<JSValueRef> | 是 | 指定的数组对象 | 6194| index | uint32_t | 是 | 要设置的指定索引位置 | 6195| value | Local<JSValueRef> | 是 | 要设置的值 | 6196 6197**返回值：** 6198 6199| 类型 | 说明 | 6200| :------ | :---------------------------------------------------- | 6201| boolean | 指定索引位置的值设置成功，则返回true，否则返回false。 | 6202 6203**示例：** 6204 6205```c++ 6206Local<ArrayRef> arrayObj = ArrayRef::New(vm_, 1); 6207Local<IntegerRef> intValue = IntegerRef::New(vm_, 0); 6208bool result = ArrayRef::SetValueAt(vm_, arrayObj, index, intValue); 6209``` 6210 6211### GetValueAt 6212 6213static Local<JSValueRef> GetValueAt(const EcmaVM *vm, Local<JSValueRef> obj, uint32_t index); 6214 6215用于在给定的数组对象中获取指定索引位置的值。 6216 6217**参数：** 6218 6219| 参数名 | 类型 | 必填 | 说明 | 6220| ------ | ----------------- | ---- | -------------------- | 6221| vm | const EcmaVM * | 是 | 虚拟机对象 | 6222| obj | Local<JSValueRef> | 是 | 指定的数组对象 | 6223| index | uint32_t | 是 | 要获取的指定索引位置 | 6224 6225**返回值：** 6226 6227| 类型 | 说明 | 6228| :---------------- | :----------------------------- | 6229| Local<JSValueRef> | 返回获取到的指定索引位置的值。 | 6230 6231**示例：** 6232 6233```c++ 6234Local<ArrayRef> arrayObj = ArrayRef::New(vm_, 1); 6235Local<IntegerRef> intValue = IntegerRef::New(vm_, 0); 6236ArrayRef::SetValueAt(vm_, arrayObj, index, intValue); 6237Local<JSValueRef> result = ArrayRef::GetValueAt(vm_, arrayObj, 0); 6238``` 6239 6240### New 6241 6242Local<ArrayRef> ArrayRef::New(const EcmaVM *vm, uint32_t length = 0); 6243 6244创建一个具有指定长度的 JavaScript 数组对象。 6245 6246在创建数组对象之前，通过 `CHECK_HAS_PENDING_EXCEPTION_RETURN_UNDEFINED` 宏检查是否存在潜在的异常。 6247 6248使用 `JSArray::ArrayCreate` 方法创建 JavaScript 中的数组对象，指定数组的长度为 `length`。 6249 6250使用 `JSNApiHelper::ToLocal<ArrayRef>(array)` 将 JavaScript 中的数组对象转换为本地的 `ArrayRef` 对象。 6251 6252**参数：** 6253 6254| 参数名 | 类型 | 必填 | 说明 | 6255| ------ | -------------- | ---- | ------------------------ | 6256| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6257| length | uint32_t | 否 | 表示要创建的数组的长度。 | 6258 6259**返回值：** 6260 6261| 类型 | 说明 | 6262| --------------- | ---------------------- | 6263| Local<ArrayRef> | ArrayRef 类型的对象。 | 6264 6265**示例：** 6266 6267```c++ 6268 Local<ArrayRef> myArray = ArrayRef::New(VM, length); 6269``` 6270 6271 6272 6273## JsiRuntimeCallInfo 6274 6275主要用于处理JS运行时调用的信息，并提供了一些方法。 6276 6277### GetData 6278 6279void* GetData(); 6280 6281获取JsiRuntimeCallInfo的数据。 6282 6283**参数：** 6284 6285无 6286 6287**返回值：** 6288 6289| 类型 | 说明 | 6290| :----- | :------------------------------------------- | 6291| void * | 返回值为从JsiRuntimeCallInfo中获取到的数据。 | 6292 6293**示例：** 6294 6295```c++ 6296JsiRuntimeCallInfo object; 6297void *result = object.GetData(); 6298``` 6299 6300### GetVM 6301 6302EcmaVM *GetVM() const; 6303 6304获取与当前 `JsiRuntimeCallInfo` 对象相关联的 `EcmaVM` 指针。 6305 6306**参数：** 6307 6308无 6309 6310**返回值：** 6311 6312| 类型 | 说明 | 6313| ------- | ---------------- | 6314| EcmaVM* | 返回EcmaVM指针。 | 6315 6316**示例：** 6317 6318```c++ 6319JsiRuntimeCallInfo callInfo; 6320EcmaVM *vm = callInfo.GetVM(); 6321``` 6322 6323 6324 6325## PromiseRejectInfo 6326 6327`PromiseRejectInfo` 类用于存储有关 Promise 被拒绝事件的信息，包括被拒绝的 Promise 对象、拒绝的原因、事件类型和与事件相关的数据。提供了相应的访问方法用于获取这些信息。 6328 6329### GetPromise 6330 6331Local<JSValueRef> GetPromise() const； 6332 6333获取一个Promise对象。 6334 6335**参数：** 6336 6337| 参数名 | 类型 | 必填 | 说明 | 6338| ------ | ---- | ---- | ---- | 6339| 无参 | | | | 6340 6341**返回值：** 6342 6343| 类型 | 说明 | 6344| ----------------- | ------------------------------------------------------------ | 6345| Local<JSValueRef> | 获取Promise对象，并将其转换为Local<JSValueRef>类型，作为函数的返回值。 | 6346 6347**示例：** 6348 6349```C++ 6350Local<JSValueRef> promise(PromiseCapabilityRef::New(vm)->GetPromise(vm)); 6351Local<StringRef> toStringReason = StringRef::NewFromUtf8(vm, "3.14"); 6352Local<JSValueRef> reason(toStringReason); 6353void *data = static_cast<void *>(new std::string("promisereject")); 6354PromiseRejectInfo promisereject(promise, reason, PromiseRejectInfo::PROMISE_REJECTION_EVENT::REJECT, data); 6355Local<JSValueRef> obj = promisereject.GetPromise(); 6356``` 6357 6358### GetData 6359 6360void* PromiseRejectInfo::GetData() const 6361 6362返回存储在类的私有成员变量data_中的额外数据。 6363 6364**参数：** 6365 6366无 6367 6368**返回值：** 6369 6370| 类型 | 说明 | 6371| ------ | ------------------------------------------------------------ | 6372| void * | 返回值是一个通用指针（void *），它指向存储在类的私有成员变量data_中的额外数据。 | 6373 6374**示例：** 6375 6376```c++ 6377Local<StringRef> toStringPromise = StringRef::NewFromUtf8(vm_, "-3.14"); 6378Local<JSValueRef> promise(toStringPromise); 6379Local<StringRef> toStringReason = StringRef::NewFromUtf8(vm_, "3.14"); 6380Local<JSValueRef> reason(toStringReason); 6381void *data = static_cast<void *>(new std::string("promisereject")); 6382PromiseRejectInfo promisereject(promise, reason, PromiseRejectInfo::PROMISE_REJECTION_EVENT::REJECT, data); 6383void *ptr = promisereject.GetData(); 6384``` 6385 6386### PromiseRejectInfo 6387 6388PromiseRejectInfo(Local<JSValueRef> promise, Local<JSValueRef> reason,PromiseRejectInfo::PROMISE_REJECTION_EVENT operation, void* data); 6389 6390创建一个 `PromiseRejectInfo` 对象，用于保存与 Promise 被拒绝事件相关的信息。 6391 6392将传入的 `promise`、`reason`、`operation` 和 `data` 参数存储在对象的成员变量中。 6393 6394**参数：** 6395 6396| 参数名 | 类型 | 必填 | 说明 | 6397| --------- | ------------------------------------------ | ---- | ------------------------------------- | 6398| promise | Local<JSValueRef> | 是 | 表示被拒绝的 Promise 对象。 | 6399| reason | Local<JSValueRef> | 是 | 表示 Promise 被拒绝的原因。 | 6400| operation | PromiseRejectInfo::PROMISE_REJECTION_EVENT | 是 | 表示 Promise 被拒绝的事件类型。 | 6401| data | void* | 是 | 表示与 Promise 被拒绝事件相关的数据。 | 6402 6403**返回值：** 6404 6405| 类型 | 说明 | 6406| ------------------------------------------ | ------------------------------------------ | 6407| PromiseRejectInfo::PROMISE_REJECTION_EVENT | `PromiseRejectInfo` 对象的操作类型枚举值。 | 6408 6409**示例：** 6410 6411```c++ 6412PromiseRejectInfo::PROMISE_REJECTION_EVENT operationType = myRejectInfo.GetOperation(); 6413``` 6414 6415### GetReason 6416 6417 Local<JSValueRef> GetReason() const; 6418 6419获取存储在 `PromiseRejectInfo` 对象中的被拒绝的 Promise 的原因。 6420 6421**参数：** 6422 6423无 6424 6425**返回值：** 6426 6427| 类型 | 说明 | 6428| ----------------- | ------------------------------------------ | 6429| Local<JSValueRef> | `PromiseRejectInfo` 对象的操作类型枚举值。 | 6430 6431**示例：** 6432 6433```c++ 6434Local<JSValueRef> rejectionReason = myRejectInfo.GetReason(); 6435``` 6436 6437### GetOperation 6438 6439PromiseRejectInfo::PROMISE_REJECTION_EVENT GetOperation() const; 6440 6441获取当前 `PromiseRejectInfo` 对象的操作类型。 6442 6443返回值是一个枚举值，表示 Promise 拒绝事件的具体操作类型。 6444 6445**参数：** 6446 6447无 6448 6449**返回值：** 6450 6451| 类型 | 说明 | 6452| ------------------------------------------ | ------------------------------------------ | 6453| PromiseRejectInfo::PROMISE_REJECTION_EVENT | `PromiseRejectInfo` 对象的操作类型枚举值。 | 6454 6455**示例：** 6456 6457```c++ 6458PromiseRejectInfo::PROMISE_REJECTION_EVENT operationType = myRejectInfo.GetOperation(); 6459``` 6460 6461 6462 6463## PromiseCapabilityRef 6464 6465`PromiseCapabilityRef` 类是 `ObjectRef` 类的子类，专门用于处理 Promise 对象的功能。它提供了创建新的 PromiseCapability 对象、解决 Promise、拒绝 Promise 以及获取 Promise 的方法。 6466 6467### Resolve 6468 6469bool Resolve(const EcmaVM *vm, Local<JSValueRef> value)； 6470 6471用于敲定Promise对象。 6472 6473**参数：** 6474 6475| 参数名 | 类型 | 必填 | 说明 | 6476| ------ | ----------------- | ---- | ---------------------------- | 6477| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6478| value | Local<JSValueRef> | 是 | 执行回调函数是所需要的参数。 | 6479 6480**返回值：** 6481 6482| 类型 | 说明 | 6483| ---- | ----------------------------------- | 6484| bool | Promise对象的回调函数是否成功调用。 | 6485 6486**示例：** 6487 6488```c++ 6489Local<JSValueRef> FunCallback(JsiRuntimeCallInfo *info) 6490{ 6491 EscapeLocalScope scope(info->GetVM()); 6492 return scope.Escape(ArrayRef::New(info->GetVM(), info->GetArgsNumber())); 6493} 6494Local<PromiseCapabilityRef> capability = PromiseCapabilityRef::New(vm); 6495Local<PromiseRef> promise = capability->GetPromise(vm); 6496promise->Then(vm, FunctionRef::New(vm, FunCallback), FunctionRef::New(vm, FunCallback)); 6497bool b = capability->Resolve(vm, NumberRef::New(vm, 300.3)); 6498``` 6499 6500### Reject 6501 6502bool Reject(const EcmaVM *vm, Local<JSValueRef> reason)； 6503 6504用于拒绝Promise对象。 6505 6506**参数：** 6507 6508| 参数名 | 类型 | 必填 | 说明 | 6509| ------ | ----------------- | ---- | ---------------------------- | 6510| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6511| value | Local<JSValueRef> | 是 | 执行回调函数是所需要的参数。 | 6512 6513**返回值：** 6514 6515| 类型 | 说明 | 6516| ---- | ----------------------------------- | 6517| bool | Promise对象的回调函数是否成功调用。 | 6518 6519**示例：** 6520 6521```C++ 6522Local<JSValueRef> FunCallback(JsiRuntimeCallInfo *info) 6523{ 6524 EscapeLocalScope scope(info->GetVM()); 6525 return scope.Escape(ArrayRef::New(info->GetVM(), info->GetArgsNumber())); 6526} 6527Local<PromiseCapabilityRef> capability = PromiseCapabilityRef::New(vm); 6528Local<PromiseRef> promise = capability->GetPromise(vm); 6529promise->Then(vm, FunctionRef::New(vm, FunCallback), FunctionRef::New(vm, FunCallback)); 6530bool b = capability->Reject(vm, NumberRef::New(vm, 300.3)); 6531``` 6532 6533### GetPromise 6534 6535Local<PromiseRef> GetPromise(const EcmaVM *vm); 6536 6537获取与当前对象关联的Promise对象。 6538 6539**参数：** 6540 6541| 参数名 | 类型 | 必填 | 说明 | 6542| ------ | -------------- | ---- | ------------ | 6543| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6544 6545**返回值：** 6546 6547| 类型 | 说明 | 6548| ----------------- | ------------------------------------------------------------ | 6549| Local<PromiseRef> | 获取Promise对象，并将其转换为本地引用（PromiseRef类型）返回。 | 6550 6551**示例：** 6552 6553```c++ 6554Local<PromiseCapabilityRef> capability = PromiseCapabilityRef::New(vm_); 6555Local<PromiseRef> promise = capability->GetPromise(vm_); 6556``` 6557 6558### new 6559 6560static Local<PromiseCapabilityRef> New(const EcmaVM *vm); 6561 6562创建一个新的 `PromiseCapability` 对象，并返回对该对象的本地引用。 6563 6564在创建之前，通过 `CHECK_HAS_PENDING_EXCEPTION_RETURN_UNDEFINED` 宏检查是否存在潜在的异常。 6565 6566获取虚拟机的线程、工厂对象和全局环境。 6567 6568使用全局环境中的 `GetPromiseFunction` 函数获取 `Promise` 构造函数。 6569 6570调用 `JSPromise::NewPromiseCapability` 方法创建新的 `PromiseCapability` 对象。 6571 6572**参数：** 6573 6574| 参数名 | 类型 | 必填 | 说明 | 6575| ------ | -------------- | ---- | ------------ | 6576| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6577 6578**返回值：** 6579 6580| 类型 | 说明 | 6581| --------------------------- | ------------------------------------------ | 6582| Local<PromiseCapabilityRef> | `PromiseRejectInfo` 对象的操作类型枚举值。 | 6583 6584**示例：** 6585 6586```c++ 6587Local<PromiseCapabilityRef> myPromiseCapability = PromiseCapabilityRef::New(vm); 6588``` 6589 6590 6591 6592## SymbolRef : public PrimitiveRef 6593 6594这个类继承自PrimitiveRef类，主要用于定义一个名为`SymbolRef`的公共API类。 6595 6596### New 6597 6598static Local<SymbolRef> New(const EcmaVM *vm, Local<StringRef> description = Local<StringRef>()); 6599 6600用于创建一个新的`SymbolRef`对象。 6601 6602**参数：** 6603 6604| 参数名 | 类型 | 必填 | 说明 | 6605| ----------- | ---------------- | ---- | ------------------------------------------------------------ | 6606| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6607| description | Local<StringRef> | 否 | 可选的`Local<StringRef>`类型的描述。如果没有提供描述，则默认为空。 | 6608 6609**返回值：** 6610 6611| 类型 | 说明 | 6612| ---------------- | ----------------------------------------- | 6613| Local<SymbolRef> | 创建一个新的SymbolRef类型对象并将其返回。 | 6614 6615**示例：** 6616 6617```c++ 6618SymbolRef::New(vm_); 6619``` 6620 6621### GetDescription 6622 6623Local<StringRef> GetDescription(const EcmaVM *vm); 6624 6625获取符号引用的描述。 6626 6627| 参数名 | 类型 | 必填 | 说明 | 6628| ------ | -------------- | ---- | ------------ | 6629| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6630 6631**返回值：** 6632 6633| 类型 | 说明 | 6634| ---------------- | -------------------------------------- | 6635| Local<StringRef> | 将符号描述的句柄转换为本地引用并返回。 | 6636 6637**示例：** 6638 6639```c++ 6640SymbolRef::GetDescription(vm_); 6641``` 6642 6643 6644 6645## FunctionCallScope 6646 6647这个类用于管理函数调用的作用域。 6648 6649### FunctionCallScope 6650 6651FunctionCallScope::FunctionCallScope(EcmaVM *vm) : vm_(vm); 6652 6653FunctionCallScope类的带参构造函数。 6654 6655**参数：** 6656 6657| 参数名 | 类型 | 必填 | 说明 | 6658| ------ | -------------- | ---- | ------------ | 6659| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6660 6661**返回值：** 6662 6663无 6664 6665**示例：** 6666 6667```c++ 6668FunctionCallScope::FunctionCallScope FC(vm_); 6669``` 6670 6671 6672 6673## LocalScope 6674 6675该类的作用是管理局部作用域，包括跟踪前一个和后一个局部作用域、前一个局部作用域的结束位置、前一个局部作用域的句柄存储索引以及线程信息。 6676 6677### LocalScope 6678 6679explicit LocalScope(const EcmaVM *vm); 6680 6681初始化 LocalScope 对象，并设置其关联的 EcmaVM实例。 6682 6683**参数：** 6684 6685| 参数名 | 类型 | 必填 | 说明 | 6686| ------ | -------------- | ---- | ------------ | 6687| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6688 6689**返回值：** 6690 6691无 6692 6693**示例：** 6694 6695```c++ 6696LocalScope::LocalScope Scope(vm_); 6697``` 6698 6699### LocalScope 6700 6701inline LocalScope(const EcmaVM *vm, JSTaggedType value); 6702 6703构造函数：用于初始化 `LocalScope` 类的对象。 6704 6705获取当前线程的 `JSThread` 对象。 6706 6707通过 `reinterpret_cast` 将线程对象转换为 `JSThread*` 类型。 6708 6709使用 `EcmaHandleScope::NewHandle` 方法在句柄作用域中创建一个新的本地句柄。 6710 6711**参数：** 6712 6713| 参数名 | 类型 | 必填 | 说明 | 6714| ------ | -------------- | ---- | ---------------------------- | 6715| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6716| value | JSTaggedType | 是 | 表示要存储在本地句柄中的值。 | 6717 6718**返回值：** 6719 6720无 6721 6722**示例：** 6723 6724```c++ 6725 LocalScope myLocalScope(myEcmaVM, someJSTaggedValue); 6726``` 6727 6728 6729 6730## SetRef : public ObjectRef 6731 6732该类是继承自ObjectRef类的子类。它的作用是表示一个JavaScript的Set对象，并提供了获取其大小、总元素数量以及获取指定索引位置的元素值的方法。 6733 6734### GetSize 6735 6736int32_t SetRef::GetSize(); 6737 6738获取一个SetRef对象的大小。 6739 6740**参数：** 6741 6742无 6743 6744**返回值：** 6745 6746| 类型 | 说明 | 6747| ------- | ------------------------------------------------- | 6748| int32_t | 返回一个int32_t类型的数值，表示SetRef对象的大小。 | 6749 6750**示例：** 6751 6752```c++ 6753Local<SetRef> object = SetRef::New(vm_); 6754Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 6755Local<JSValueRef> value = StringRef::NewFromUtf8(vm_, "TestValue"); 6756object->Set(vm_, key, value); 6757int32_t size = object->GetSize(); 6758``` 6759 6760### GetTotalElements 6761 6762int32_t SetRef::GetTotalElements(); 6763 6764获取一个SetRef对象中所有元素的总数，包括已删除的元素。 6765 6766**参数：** 6767 6768无 6769 6770**返回值：** 6771 6772| 类型 | 说明 | 6773| ------- | ------------------------------------------------------------ | 6774| int32_t | 返回一个int32_t类型的数值，表示SetRef对象中所有元素的总数，包括已删除的元素。 | 6775 6776**示例：** 6777 6778```c++ 6779Local<SetRef> object = SetRef::New(vm_); 6780Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 6781Local<JSValueRef> value = StringRef::NewFromUtf8(vm_, "TestValue"); 6782object->Set(vm_, key, value); 6783int32_t element = object->GetTotalElements(); 6784``` 6785 6786### GetValue 6787 6788Local<JSValueRef> SetRef::GetValue(const EcmaVM *vm, int entry); 6789 6790获取SetRef对象中指定索引位置的元素值。 6791 6792**参数：** 6793 6794| 参数名 | 类型 | 必填 | 说明 | 6795| ------ | -------------- | ---- | ---------------------------------------------------- | 6796| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6797| entry | int | 是 | 一个整数，表示要获取的元素在SetRef对象中的索引位置。 | 6798 6799**返回值：** 6800 6801| 类型 | 说明 | 6802| ----------------- | ------------------------------------------------------------ | 6803| Local<JSValueRef> | 获取指定索引位置的元素值后，将其转换为Local<JSValueRef>类型的对象，并作为函数的返回值。 | 6804 6805**示例：** 6806 6807```c++ 6808Local<SetRef> object = SetRef::New(vm_); 6809Local<JSValueRef> key = StringRef::NewFromUtf8(vm_, "TestKey"); 6810Local<JSValueRef> value = StringRef::NewFromUtf8(vm_, "TestValue"); 6811object->Set(vm_, key, value); 6812Local<JSValueRef> value = object->GetValue(vm_, 0); 6813``` 6814 6815 6816 6817## BigUint64ArrayRef : public TypedArrayRef 6818 6819该类继承自TypedArrayRef类，用于表示一个64位无符号整数数组。 6820 6821### New 6822 6823static Local<BigUint64ArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset, int32_t length); 6824 6825静态成员函数，用于创建一个新的BigUint64ArrayRef对象。 6826 6827**参数：** 6828 6829| 参数名 | 类型 | 必填 | 说明 | 6830| ---------- | --------------------- | ---- | ------------------------------------------------------ | 6831| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6832| buffer | Local<ArrayBufferRef> | 是 | 一个ArrayBufferRef类型的局部变量，要存储数据的缓冲区。 | 6833| byteOffset | int32_t | 是 | 一个32位整数，表示在缓冲区中的字节偏移量。 | 6834| length | int32_t | 是 | 一个32位整数，表示数组的长度。 | 6835 6836**返回值：** 6837 6838| 类型 | 说明 | 6839| ------------------------ | --------------------------------------------- | 6840| Local<BigUint64ArrayRef> | 返回一个创建好的BigUint64ArrayRef类型的对象。 | 6841 6842**示例：** 6843 6844```c++ 6845Local<ArrayBufferRef> array = ArrayBufferRef::New(/*....所需参数....*/); 6846int32_t byteOffset = 3; 6847int32_t length = 40; 6848Local<BigUint64ArrayRef> bu64array = BigUint64ArrayRef::New(vm_, array, byteOffset, length); 6849``` 6850 6851 6852 6853## Float32ArrayRef : public TypedArrayRef 6854 6855该类继承自TypedArrayRef类，作用是创建一个浮点数类型的数组引用，可以用于操作和访问浮点数类型的数据。 6856 6857### New 6858 6859static Local<Float32ArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset, int32_t length); 6860 6861静态成员函数，用于创建一个新的Float32ArrayRef对象。 6862 6863**参数：** 6864 6865| 参数名 | 类型 | 必填 | 说明 | 6866| ---------- | --------------------- | ---- | ------------------------------------------------------ | 6867| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6868| buffer | Local<ArrayBufferRef> | 是 | 一个ArrayBufferRef类型的局部变量，要存储数据的缓冲区。 | 6869| byteOffset | int32_t | 是 | 一个32位整数，表示在缓冲区中的字节偏移量。 | 6870| length | int32_t | 是 | 一个32位整数，表示数组的长度。 | 6871 6872**返回值：** 6873 6874| 类型 | 说明 | 6875| ---------------------- | ------------------------------------------------------------ | 6876| Local<Float32ArrayRef> | 返回一个Float32ArrayRef类型的对象，表示创建的浮点数类型数组引用。 | 6877 6878**示例：** 6879 6880```c++ 6881Local<ArrayBufferRef> array = ArrayBufferRef::New(/*....所需参数....*/); 6882int32_t byteOffset = 3; 6883int32_t length = 40; 6884Local<Float32ArrayRef> fl32array = Float32ArrayRef::New(vm_, array, byteOffset, length); 6885``` 6886 6887 6888 6889## Float64ArrayRef : public TypedArrayRef 6890 6891该类继承自TypedArrayRef类，表示一个64位浮点数类型的数组引用。 6892 6893### New 6894 6895static Local<Float64ArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset, int32_t length); 6896 6897静态成员函数，用于创建一个新的Float64ArrayRef对象。 6898 6899**参数：** 6900 6901| 参数名 | 类型 | 必填 | 说明 | 6902| ---------- | --------------------- | ---- | ------------------------------------------------------ | 6903| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6904| buffer | Local<ArrayBufferRef> | 是 | 一个ArrayBufferRef类型的局部变量，要存储数据的缓冲区。 | 6905| byteOffset | int32_t | 是 | 一个32位整数，表示在缓冲区中的字节偏移量。 | 6906| length | int32_t | 是 | 一个32位整数，表示数组的长度。 | 6907 6908**返回值：** 6909 6910| 类型 | 说明 | 6911| ---------------------- | ------------------------------------------------------------ | 6912| Local<Float64ArrayRef> | 返回一个Float64ArrayRef类型的对象，表示创建的浮点数类型数组引用。 | 6913 6914**示例：** 6915 6916```c++ 6917Local<ArrayBufferRef> array = ArrayBufferRef::New(/*....所需参数....*/); 6918int32_t byteOffset = 3; 6919int32_t length = 40; 6920Local<Float64ArrayRef> fl32array = Float64ArrayRef::New(vm_, array, byteOffset, length); 6921``` 6922 6923 6924 6925## Int8ArrayRef : public TypedArrayRef 6926 6927该类继承自 TypedArrayRef 类。其作用是创建一个表示 8 位整数类型的数组引用。 6928 6929### New 6930 6931static Local<Int8ArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset, int32_t length); 6932 6933创建一个新的Int8ArrayRef对象。 6934 6935**参数：** 6936 6937| 参数名 | 类型 | 必填 | 说明 | 6938| ---------- | --------------------- | ---- | ------------------------------------------------------ | 6939| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6940| buffer | Local<ArrayBufferRef> | 是 | 一个ArrayBufferRef类型的局部变量，要存储数据的缓冲区。 | 6941| byteOffset | int32_t | 是 | 一个32位整数，表示在缓冲区中的字节偏移量。 | 6942| length | int32_t | 是 | 一个32位整数，表示数组的长度。 | 6943 6944**返回值：** 6945 6946| 类型 | 说明 | 6947| ------------------- | -------------------------------------------- | 6948| Local<Int8ArrayRef> | 返回一个新创建的Int8ArrayRef对象的本地引用。 | 6949 6950**示例：** 6951 6952```c++ 6953const int32_t length = 15; 6954Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm_, length); 6955Local<Int8ArrayRef> obj = Int8ArrayRef::New(vm_, arrayBuffer, 5, 6); 6956``` 6957 6958 6959 6960## Int16ArrayRef : public TypedArrayRef 6961 6962该类继承自 TypedArrayRef 类。其作用是创建一个表示 16位整数类型的数组引用。 6963 6964### New 6965 6966static Local<Int16ArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset, int32_t length); 6967 6968创建一个新的Int16ArrayRef对象。 6969 6970**参数：** 6971 6972| 参数名 | 类型 | 必填 | 说明 | 6973| ---------- | --------------------- | ---- | ------------------------------------------------------ | 6974| vm | const EcmaVM * | 是 | 虚拟机对象。 | 6975| buffer | Local<ArrayBufferRef> | 是 | 一个ArrayBufferRef类型的局部变量，要存储数据的缓冲区。 | 6976| byteOffset | int32_t | 是 | 一个32位整数，表示在缓冲区中的字节偏移量。 | 6977| length | int32_t | 是 | 一个32位整数，表示数组的长度。 | 6978 6979**返回值：** 6980 6981| 类型 | 说明 | 6982| -------------------- | --------------------------------------------- | 6983| Local<Int16ArrayRef> | 返回一个新创建的Int16ArrayRef对象的本地引用。 | 6984 6985**示例：** 6986 6987```c++ 6988const int32_t length = 15; 6989Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm_, length); 6990Local<Int16ArrayRef> obj = Int16ArrayRef::New(vm_, arrayBuffer, 5, 6); 6991``` 6992 6993 6994 6995## Int32ArrayRef : public TypedArrayRef 6996 6997该类继承自 TypedArrayRef 类。其作用是创建一个表示 32位整数类型的数组引用。 6998 6999### New 7000 7001static Local<Int32ArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset, int32_t length); 7002 7003创建一个新的Int32ArrayRef对象。 7004 7005**参数：** 7006 7007| 参数名 | 类型 | 必填 | 说明 | 7008| ---------- | --------------------- | ---- | ------------------------------------------------------ | 7009| vm | const EcmaVM * | 是 | 虚拟机对象。 | 7010| buffer | Local<ArrayBufferRef> | 是 | 一个ArrayBufferRef类型的局部变量，要存储数据的缓冲区。 | 7011| byteOffset | int32_t | 是 | 一个32位整数，表示在缓冲区中的字节偏移量。 | 7012| length | int32_t | 是 | 一个32位整数，表示数组的长度。 | 7013 7014**返回值：** 7015 7016| 类型 | 说明 | 7017| -------------------- | --------------------------------------------- | 7018| Local<Int32ArrayRef> | 返回一个新创建的Int32ArrayRef对象的本地引用。 | 7019 7020**示例：** 7021 7022```c++ 7023const int32_t length = 15; 7024Local<ArrayBufferRef> arrayBuffer = ArrayBufferRef::New(vm_, length); 7025Local<Int32ArrayRef> obj = Int32ArrayRef::New(vm_, arrayBuffer, 5, 6); 7026``` 7027 7028 7029 7030## ProxyRef : public ObjectRef 7031 7032该类继承自ObjectRef类，主要用于处理JavaScript代理对象。 7033 7034### GetTarget 7035 7036Local<JSValueRef> GetTarget(const EcmaVM *vm); 7037 7038获取JavaScript代理对象的目标对象。 7039 7040**参数：** 7041 7042| 参数名 | 类型 | 必填 | 说明 | 7043| ------ | -------------- | ---- | ------------ | 7044| vm | const EcmaVM * | 是 | 虚拟机对象。 | 7045 7046**返回值：** 7047 7048| 类型 | 说明 | 7049| ----------------- | ------------------------------------------------------------ | 7050| Local<JSValueRef> | 返回一个JSValueRef类型的对象，它表示JavaScript代理对象的目标对象。 | 7051 7052**示例：** 7053 7054```c++ 7055JSHandle<GlobalEnv> env = vm_->GetGlobalEnv(); 7056ObjectFactory *factory = thread_->GetEcmaVM()->GetFactory(); 7057JSHandle<JSTaggedValue> hclass(thread_, env->GetObjectFunction().GetObject<JSFunction>()); 7058JSHandle<JSTaggedValue> targetHandle(factory->NewJSObjectByConstructor(JSHandle<JSFunction>::Cast(hclass), hclass)); 7059JSHandle<JSTaggedValue> key(factory->NewFromASCII("x")); 7060JSHandle<JSTaggedValue> value(thread_, JSTaggedValue(1)); 7061JSObject::SetProperty(thread_, targetHandle, key, value); 7062JSHandle<JSTaggedValue> handlerHandle( 7063 factory->NewJSObjectByConstructor(JSHandle<JSFunction>::Cast(hclass), hclass)); 7064JSHandle<JSProxy> proxyHandle = JSProxy::ProxyCreate(thread_, targetHandle, handlerHandle); 7065JSHandle<JSTaggedValue> proxytagvalue = JSHandle<JSTaggedValue>::Cast(proxyHandle); 7066Local<ProxyRef> object = JSNApiHelper::ToLocal<ProxyRef>(proxytagvalue); 7067Local<JSValueRef> value = object->GetTarget(vm_); 7068``` 7069 7070### IsRevoked 7071 7072bool ProxyRef::IsRevoked(); 7073 7074检查JavaScript代理对象是否已被撤销。 7075 7076**参数：** 7077 7078无 7079 7080**返回值：** 7081 7082| 类型 | 说明 | 7083| ---- | ------------------------------------------------------------ | 7084| bool | 布尔值：true 或 false。如果代理对象已被撤销，返回true。否则，返回false。 | 7085 7086**示例：** 7087 7088```c++ 7089JSHandle<GlobalEnv> env = vm_->GetGlobalEnv(); 7090ObjectFactory *factory = thread_->GetEcmaVM()->GetFactory(); 7091JSHandle<JSTaggedValue> hclass(thread_, env->GetObjectFunction().GetObject<JSFunction>()); 7092JSHandle<JSTaggedValue> targetHandle(factory->NewJSObjectByConstructor(JSHandle<JSFunction>::Cast(hclass), hclass)); 7093JSHandle<JSTaggedValue> key(factory->NewFromASCII("x")); 7094JSHandle<JSTaggedValue> value(thread_, JSTaggedValue(1)); 7095JSObject::SetProperty(thread_, targetHandle, key, value); 7096JSHandle<JSTaggedValue> handlerHandle( 7097 factory->NewJSObjectByConstructor(JSHandle<JSFunction>::Cast(hclass), hclass)); 7098JSHandle<JSProxy> proxyHandle = JSProxy::ProxyCreate(thread_, targetHandle, handlerHandle); 7099JSHandle<JSTaggedValue> proxytagvalue = JSHandle<JSTaggedValue>::Cast(proxyHandle); 7100Local<ProxyRef> object = JSNApiHelper::ToLocal<ProxyRef>(proxytagvalue); 7101bool b = object->IsRevoked(); 7102``` 7103 7104### GetHandler 7105 7106Local<JSValueRef> GetHandler(const EcmaVM *vm); 7107 7108获取对象的处理程序。 7109 7110**参数：** 7111 7112| 参数名 | 类型 | 必填 | 说明 | 7113| ------ | -------------- | ---- | ---------- | 7114| vm | const EcmaVM * | 是 | 虚拟机对象 | 7115 7116**返回值：** 7117 7118| 类型 | 说明 | 7119| :---------------- | :------------------- | 7120| Local<JSValueRef> | 返回对象的处理程序。 | 7121 7122**示例：** 7123 7124```c++ 7125JSHandle<JSTaggedValue> targetHandle; 7126JSHandle<JSTaggedValue> handlerHandle; 7127JSHandle<JSProxy> proxyHandle = JSProxy::ProxyCreate(thread_, targetHandle, handlerHandle); 7128JSHandle<JSTaggedValue> proxytagvalue = JSHandle<JSTaggedValue>::Cast(proxyHandle); 7129Local<JSValueRef> result = JSNApiHelper::ToLocal<ProxyRef>(proxytagvalue)->GetHandler(vm_); 7130``` 7131 7132## EscapeLocalScope：LocalScope 7133 7134`EscapeLocalScope` 类是一个继承自 `LocalScope` 的具体子类，用于管理局部变量的生命周期。 7135它提供了一个方法 `Escape`，允许在局部范围内提前返回局部变量的 `Local` 对象。 7136 7137### EscapeLocalScope 7138 7139explicit EscapeLocalScope(const EcmaVM *vm); 7140 7141构造EscapeLocalScope对象。 7142 7143**参数：** 7144 7145| 参数名 | 类型 | 必填 | 说明 | 7146| ------ | -------------- | ---- | ------------ | 7147| vm | const EcmaVM * | 是 | 虚拟机对象。 | 7148 7149**返回值：** 7150 7151无 7152 7153**示例：** 7154 7155```c++ 7156EscapeLocalScope scope(vm); 7157``` 7158 7159## SetIteratorRef：ObjectRef 7160 7161SetIteratorRef 类是一个继承自 ObjectRef 的具体子类，用于操作 JavaScript Set 对象的迭代器。 7162 7163### GetIndex 7164 7165int32_t GetIndex(); 7166 7167获取当前 `SetIteratorRef` 对象关联的 Set 迭代器的当前索引。 7168 7169通过 `JSNApiHelper::ToJSHandle(this)` 将当前的 `SetIteratorRef` 对象转换为 JavaScript 中的 `JSSetIterator` 对象。 7170 7171调用 `JSSetIterator` 对象的 `GetNextIndex` 方法获取当前迭代器的索引。 7172 7173**参数：** 7174 7175无 7176 7177**返回值：** 7178 7179| 类型 | 说明 | 7180| ------- | ------------------ | 7181| int32_t | 当前迭代器的索引。 | 7182 7183**示例：** 7184 7185```c++ 7186int32_t currentIndex = mySetIterator.GetIndex(); 7187``` 7188 7189### GetKind 7190 7191Local<JSValueRef> GetKind(const EcmaVM *vm); 7192 7193获取当前 `SetIteratorRef` 对象关联的 Set 迭代器的迭代类型。 7194 7195在获取之前，通过 `CHECK_HAS_PENDING_EXCEPTION_RETURN_UNDEFINED` 宏检查是否存在潜在的异常。 7196 7197 通过 `JSNApiHelper::ToJSHandle(this)` 将当前的 `SetIteratorRef` 对象转换为 JavaScript 中的 `JSSetIterator` 对象。 7198 7199调用 `JSSetIterator` 对象的 `GetIterationKind` 方法获取迭代类型。 7200 7201根据迭代类型选择相应的字符串，然后使用 `StringRef::NewFromUtf8` 方法创建一个 `Local<JSValueRef>` 对象，表示字符串值。 7202 7203**参数：** 7204 7205| 参数名 | 类型 | 必填 | 说明 | 7206| ------ | -------------- | ---- | ------------ | 7207| vm | const EcmaVM * | 是 | 虚拟机对象。 | 7208 7209**返回值：** 7210 7211| 类型 | 说明 | 7212| ----------------- | ---------------------------- | 7213| Local<JSValueRef> | 返回表示迭代类型的字符串值。 | 7214 7215**示例：** 7216 7217```c++ 7218Local<JSValueRef> iterationType = mySetIterator.GetKind(myEcmaVM); 7219``` 7220 7221## Uint8ClampedArrayRef：TypedArrayRef 7222 7223Uint8ClampedArrayRef 类是一个继承自 TypedArrayRef 的具体子类，用于操作 JavaScript 中的 Uint8ClampedArray 对象。 7224 7225### New 7226static Local<Uint8ClampedArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset,int32_t length); 7227构造Uint8ClampedArrayRef对象。 7228 7229会调用宏定义创建 TypedArray 的通用模板。 7230 7231**参数：** 7232 7233| 参数名 | 类型 | 必填 | 说明 | 7234| ---------- | --------------------- | ---- | ----------------------------------------------------------- | 7235| vm | const EcmaVM * | 是 | 虚拟机对象。 | 7236| buffer | Local<ArrayBufferRef> | 是 | 表示与 `Uint8ClampedArray` 关联的 ArrayBuffer 对象。 | 7237| byteOffset | int32_t | 是 | 表示从 ArrayBuffer 的哪个字节开始创建 `Uint8ClampedArray`。 | 7238| length | int32_t | 是 | 表示要创建的 `Uint8ClampedArray` 的长度。 | 7239 7240**返回值：** 7241 7242| 类型 | 说明 | 7243| --------------------------- | ---------------------------------------- | 7244| Local<Uint8ClampedArrayRef> | 返回`Local<Uint8ClampedArrayRef>` 对象。 | 7245 7246 7247 7248**示例：** 7249 7250```c++ 7251Local<Uint8ClampedArrayRef> myUint8ClampedArray = Uint8ClampedArrayRef::New(myEcmaVM, myArrayBuffer, Offset, length); 7252``` 7253 7254## Uint16ArrayRef：TypedArrayRef 7255 7256Uint16ArrayRef 类是一个继承自 TypedArrayRef 的具体子类，用于操作 JavaScript 中的 Uint16Array 对象。 7257 7258### New 7259 7260static Local<Uint16ArrayRef> New(const EcmaVM *vm, Local<ArrayBufferRef> buffer, int32_t byteOffset,int32_t length); 7261 7262通过该函数在 JavaScript 环境中创建一个新的 `Uint16Array` 对象。 7263 7264**参数：** 7265 7266| 参数名 | 类型 | 必填 | 说明 | 7267| ---------- | --------------------- | ---- | ----------------------------------------------------- | 7268| vm | const EcmaVM * | 是 | 虚拟机对象。 | 7269| buffer | Local<ArrayBufferRef> | 是 | 表示与 `Uint16Array` 关联的 ArrayBuffer 对象。 | 7270| byteOffset | int32_t | 是 | 表示从 ArrayBuffer 的哪个字节开始创建 `Uint16Array`。 | 7271| length | int32_t | 是 | 表示要创建的 `Uint16Array` 的长度。 | 7272 7273**返回值：** 7274 7275| 类型 | 说明 | 7276| --------------------- | ---------------------------------- | 7277| Local<Uint16ArrayRef> | 返回`Local<Uint16ArrayRef>` 对象。 | 7278 7279**示例：** 7280 7281```c++ 7282Local<Uint16ArrayRef> myUint16Array = Uint16ArrayRef::New(myEcmaVM, myArrayBuffer, Offset, length); 7283``` 7284