README.md
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