1# @arkts.utils (ArkTS工具库)
2
3本模块提供了各种ArkTS实用工具函数。
4
5> **说明:**
6>
7> 本模块首批接口从API version 12开始支持。后续版本的新增接口,采用上角标单独标记接口的起始版本。
8
9## 导入模块
10
11```ts
12import { ArkTSUtils } from '@kit.ArkTS'
13```
14
15## ArkTSUtils.locks
16
17为了解决多并发实例间的数据竞争问题,ArkTS语言基础库引入了异步锁能力。为了开发者的开发效率,AsyncLock对象支持跨并发实例引用传递。
18
19由于ArkTS语言支持异步操作,阻塞锁容易产生死锁问题,因此我们在ArkTS中仅支持异步锁(非阻塞式锁)。
20
21使用异步锁的方法需要标记为async,调用方需要await修饰调用,才能保证时序正确。因此会导致外层调用函数全部标记成async。
22
23### AsyncLockCallback
24
25type AsyncLockCallback\<T> = () => T | Promise\<T>
26
27这是一个补充类型别名,表示[lockAsync](#lockasync)函数所有重载中的回调。
28
29**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
30
31**系统能力:** SystemCapability.Utils.Lang
32
33### AsyncLock
34
35实现异步锁功能的类,允许在锁下执行异步操作。
36
37#### 属性
38
39**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
40
41**系统能力:** SystemCapability.Utils.Lang
42
43| 名称 | 类型   | 可读 | 可写 | 说明       |
44| ---- | ------ | ---- | ---- | ---------- |
45| name | string | 是   | 否   | 锁的名称。 |
46
47**示例:**
48
49```ts
50// 示例一:
51@Sendable
52class A {
53  count_: number = 0;
54  async getCount(): Promise<number> {
55    let lock: ArkTSUtils.locks.AsyncLock = ArkTSUtils.locks.AsyncLock.request("lock_1");
56    return lock.lockAsync(() => {
57      return this.count_;
58    })
59  }
60  async setCount(count: number) {
61    let lock: ArkTSUtils.locks.AsyncLock = ArkTSUtils.locks.AsyncLock.request("lock_1");
62    await lock.lockAsync(() => {
63      this.count_ = count;
64    })
65  }
66}
67
68// 示例二:
69@Sendable
70class A {
71  count_: number = 0;
72  lock_: ArkTSUtils.locks.AsyncLock = new ArkTSUtils.locks.AsyncLock();
73  async getCount(): Promise<number> {
74    return this.lock_.lockAsync(() => {
75      return this.count_;
76    })
77  }
78  async setCount(count: number) {
79    await this.lock_.lockAsync(() => {
80      this.count_ = count;
81    })
82  }
83}
84
85@Concurrent
86async function foo(a: A) {
87  await a.setCount(10)
88}
89```
90
91#### constructor
92
93constructor()
94
95默认构造函数。创建一个异步锁。
96
97**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
98
99**系统能力:** SystemCapability.Utils.Lang
100
101**返回值:**
102
103| 类型                    | 说明               |
104| ----------------------- | ------------------ |
105| [AsyncLock](#asynclock) | 创建的异步锁实例。 |
106
107**示例:**
108
109```ts
110let lock = new ArkTSUtils.locks.AsyncLock();
111```
112
113#### request
114
115static request(name: string): AsyncLock
116
117使用指定的名称查找或创建(如果未找到)异步锁实例。
118
119**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
120
121**系统能力:** SystemCapability.Utils.Lang
122
123**参数:**
124
125| 名称 | 类型   | 必填 | 说明                             |
126| ---- | ------ | ---- | -------------------------------- |
127| name | string | 是   | 按指定名称查找或创建异步锁实例。 |
128
129**返回值:**
130
131| 类型                    | 说明                             |
132| ----------------------- | -------------------------------- |
133| [AsyncLock](#asynclock) | 返回查找到或创建后的异步锁实例。 |
134
135**示例:**
136
137```ts
138let lockName = 'isAvailableLock';
139let lock = ArkTSUtils.locks.AsyncLock.request(lockName);
140```
141
142#### query
143
144static query(name: string): AsyncLockState
145
146查询指定异步锁的信息。
147
148**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
149
150**系统能力:** SystemCapability.Utils.Lang
151
152**参数:**
153
154| 名称 | 类型   | 必填 | 说明       |
155| ---- | ------ | ---- | ---------- |
156| name | string | 是   | 锁的名称。 |
157
158**返回值:**
159
160| 类型                              | 说明                               |
161| --------------------------------- | ---------------------------------- |
162| [AsyncLockState](#asynclockstate) | 一个包含状态描述的异步锁状态实例。 |
163
164**错误码:**
165
166以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。
167
168| 错误码ID | 错误信息      |
169| -------- | ------------- |
170| 10200030 | The lock does not exist. |
171
172**示例:**
173
174```ts
175// 你已经在别的地方创建了一个锁。
176// let lock = ArkTSUtils.locks.AsyncLock.request("queryTestLock");
177let state = ArkTSUtils.locks.AsyncLock.query('queryTestLock');
178if (!state) {
179    throw new Error('测试失败:期望有效的状态,但得到的是 ' + state);
180}
181let pending: ArkTSUtils.locks.AsyncLockInfo[] = state.pending;
182let held: ArkTSUtils.locks.AsyncLockInfo[] = state.held;
183```
184
185#### queryAll
186
187static queryAll(): AsyncLockState[]
188
189查询所有现有锁的信息。
190
191**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
192
193**系统能力:** SystemCapability.Utils.Lang
194
195**返回值:**
196
197| 类型                                | 说明                             |
198| ----------------------------------- | -------------------------------- |
199| [AsyncLockState](#asynclockstate)[] | 包含锁状态信息的异步锁状态数组。 |
200
201**示例:**
202
203```ts
204let states: ArkTSUtils.locks.AsyncLockState[] = ArkTSUtils.locks.AsyncLock.queryAll();
205if (states.length == 0) {
206    throw new Error('测试失败:期望至少有1个状态,但得到的是 ' + states.length);
207}
208```
209
210#### lockAsync
211
212lockAsync\<T>(callback: AsyncLockCallback\<T>): Promise\<T>
213
214在获取的锁下独占执行操作。该方法首先获取锁,然后调用回调,最后释放锁。回调在调用[lockAsync](#lockasync)的同一线程中以异步方式执行。
215
216**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
217
218**系统能力:** SystemCapability.Utils.Lang
219
220**参数:**
221
222| 名称     | 类型                                    | 必填 | 说明                   |
223| -------- | --------------------------------------- | ---- | ---------------------- |
224| callback | [AsyncLockCallback](#asynclockcallback) | 是   | 获取锁后要调用的函数。 |
225
226**返回值:**
227
228| 类型        | 说明                        |
229| ----------- | --------------------------- |
230| Promise\<T> | 回调执行后将解决的Promise。 |
231
232**错误码:**
233
234以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。
235
236| 错误码ID | 错误信息      |
237| -------- | ------------- |
238| 10200030 | The lock does not exist. |
239
240**示例:**
241
242```ts
243let lock = new ArkTSUtils.locks.AsyncLock();
244let p1 = lock.lockAsync<void>(() => {
245    // 执行某些操作
246});
247```
248
249#### lockAsync
250
251lockAsync\<T>(callback: AsyncLockCallback\<T>, mode: AsyncLockMode): Promise\<T>
252
253在获取的锁下执行操作。该方法首先获取锁,然后调用回调,最后释放锁。回调在调用[lockAsync](#lockasync)的同一线程中以异步方式执行。
254
255**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
256
257**系统能力:** SystemCapability.Utils.Lang
258
259**参数:**
260
261| 名称     | 类型                                    | 必填 | 说明                   |
262| -------- | --------------------------------------- | ---- | ---------------------- |
263| callback | [AsyncLockCallback](#asynclockcallback) | 是   | 获取锁后要调用的函数。 |
264| mode     | [AsyncLockMode](#asynclockmode)         | 是   | 锁的操作模式。         |
265
266**返回值:**
267
268| 类型        | 说明                        |
269| ----------- | --------------------------- |
270| Promise\<T> | 回调执行后将解决的Promise。 |
271
272**错误码:**
273
274以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。
275
276| 错误码ID | 错误信息      |
277| -------- | ------------- |
278| 10200030 | The lock does not exist. |
279
280**示例:**
281
282```ts
283let lock = new ArkTSUtils.locks.AsyncLock();
284let p1 = lock.lockAsync<void>(() => {
285    // 执行某些操作
286}, ArkTSUtils.locks.AsyncLockMode.EXCLUSIVE);
287```
288
289#### lockAsync
290
291lockAsync\<T, U>(callback: AsyncLockCallback\<T>, mode: AsyncLockMode, options: AsyncLockOptions\<U>): Promise\<T | U>
292
293在获取的锁下执行操作。该方法首先获取锁,然后调用回调,最后释放锁。回调在调用[lockAsync](#lockasync)的同一线程中以异步方式执行。在[AsyncLockOptions](#asynclockoptions)中可以提供一个可选的超时值。在这种情况下,如果超时前未能获取锁,lockAsync将拒绝返回的Promise并带上一个BusinessError实例。这种情况下,错误信息将包含持有的锁和等待的锁的信息以及可能的死锁警告。
294
295**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
296
297**系统能力:** SystemCapability.Utils.Lang
298
299**参数:**
300
301| 名称     | 类型                                      | 必填 | 说明                   |
302| -------- | ----------------------------------------- | ---- | ---------------------- |
303| callback | [AsyncLockCallback](#asynclockcallback)   | 是   | 获取锁后要调用的函数。 |
304| mode     | [AsyncLockMode](#asynclockmode)           | 是   | 锁的操作模式。         |
305| options  | [AsyncLockOptions\<U>](#asynclockoptions) | 是   | 锁的操作选项。         |
306
307**返回值:**
308
309| 类型             | 说明                                               |
310| ---------------- | -------------------------------------------------- |
311| Promise\<T \| U> | 回调执行后解决的 Promise,或者在超时情况下被拒绝。 |
312
313**错误码:**
314
315以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。
316
317| 错误码ID | 错误信息          |
318| -------- | ----------------- |
319| 10200030 | The lock does not exist.     |
320| 10200031 | Timeout exceeded. |
321
322**示例:**
323
324```ts
325let lock = new ArkTSUtils.locks.AsyncLock();
326let options = new ArkTSUtils.locks.AsyncLockOptions<void>();
327options.timeout = 1000;
328let p: Promise<void> = lock.lockAsync<void, void>(
329    () => {
330        // 执行某些操作
331    },
332    ArkTSUtils.locks.AsyncLockMode.EXCLUSIVE,
333    options
334);
335```
336
337### AsyncLockMode
338
339锁操作对应的模式枚举。
340
341**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
342
343**系统能力:** SystemCapability.Utils.Lang
344
345| 名称      | 值  | 说明                                                     |
346| --------- | --- | -------------------------------------------------------- |
347| SHARED    | 1   | 共享锁模式。如果指定了此模式,可以在任意线程同时执行。   |
348| EXCLUSIVE | 2   | 独占锁模式。如果指定了此模式,仅在独占获取锁时才能执行。 |
349
350**示例:**
351
352```ts
353let lock = new ArkTSUtils.locks.AsyncLock();
354// shared0可获取锁并开始执行
355lock.lockAsync(async () => {
356    console.log('shared0');
357    await new Promise<void>((resolve) => setTimeout(resolve, 1000));
358}, ArkTSUtils.locks.AsyncLockMode.SHARED);
359// shared1可获取锁并开始执行,无需等待shared0
360lock.lockAsync(async () => {
361    console.log('shared1');
362    await new Promise<void>((resolve) => setTimeout(resolve, 1000));
363}, ArkTSUtils.locks.AsyncLockMode.SHARED);
364// exclusive0需等待shared0、1执行完后才可获取锁并执行
365lock.lockAsync(async () => {
366    console.log('exclusive0');
367    await new Promise<void>((resolve) => setTimeout(resolve, 1000));
368}, ArkTSUtils.locks.AsyncLockMode.EXCLUSIVE);
369// shared2需等待exclusive0执行完后才可获取锁并执行
370lock.lockAsync(async () => {
371    console.log('shared2');
372    await new Promise<void>((resolve) => setTimeout(resolve, 1000));
373}, ArkTSUtils.locks.AsyncLockMode.SHARED);
374// shared3需等待exclusive0执行完后才可获取锁并执行,无需等待shared2
375lock.lockAsync(async () => {
376    console.log('shared3');
377    await new Promise<void>((resolve) => setTimeout(resolve, 1000));
378}, ArkTSUtils.locks.AsyncLockMode.SHARED);
379```
380
381### AsyncLockOptions
382
383class AsyncLockOptions\<T>
384
385表示锁操作选项的类。
386
387**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
388
389**系统能力:** SystemCapability.Utils.Lang
390
391#### constructor
392
393constructor()
394
395默认构造函数。创建一个所有属性均具有默认值的异步锁配置项实例。
396
397**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
398
399**系统能力:** SystemCapability.Utils.Lang
400
401**返回值:**
402
403| 类型                                  | 说明                   |
404| ------------------------------------- | ---------------------- |
405| [AsyncLockOptions](#asynclockoptions) | 新的异步锁配置项实例。 |
406
407**示例:**
408
409```ts
410let s: ArkTSUtils.locks.AbortSignal<string> = { aborted: false, reason: 'Aborted' };
411let options = new ArkTSUtils.locks.AsyncLockOptions<string>();
412options.isAvailable = false;
413options.signal = s;
414```
415
416#### 属性
417
418| 名称        | 类型                                  | 可读 | 可写 | 说明                                                                                                                      |
419| ----------- | ------------------------------------- | ---- | ---- | ------------------------------------------------------------------------------------------------------------------------- |
420| isAvailable | boolean                               | 是   | 是   | 当前锁是否可用。取值为true,则只有在尚未持有锁定请求时才会授予该锁定请求;为false则表示将等待当前锁被释放。默认为 false。 |
421| signal      | [AbortSignal\<T>](#abortsignal)\|null | 是   | 是   | 用于中止异步操作的对象。如果signal.aborted为true,则锁请求将被丢弃;为null则请求正常排队运行。默认为 null。               |
422| timeout     | number                                | 是   | 是   | 锁操作的超时时间(毫秒)。如果该值大于零,且运行超过该时间,[lockAsync](#lockasync)将返回被拒绝的Promise。默认为 0。      |
423
424### AsyncLockState
425
426用于存储特定异步锁实例上当前执行的所有锁操作的信息的类。
427
428**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
429
430**系统能力:** SystemCapability.Utils.Lang
431
432#### 属性
433
434| 名称    | 类型                              | 可读 | 可写 | 说明             |
435| ------- | --------------------------------- | ---- | ---- | ---------------- |
436| held    | [AsyncLockInfo[]](#asynclockinfo) | 是   | 是   | 持有的锁信息。   |
437| pending | [AsyncLockInfo[]](#asynclockinfo) | 是   | 是   | 等待中的锁信息。 |
438
439### AsyncLockInfo
440
441关于锁的信息。
442
443**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
444
445**系统能力:** SystemCapability.Utils.Lang
446
447#### 属性
448
449| 名称      | 类型                            | 可读 | 可写 | 说明                                                      |
450| --------- | ------------------------------- | ---- | ---- | --------------------------------------------------------- |
451| name      | string                          | 是   | 是   | 锁的名称。                                                |
452| mode      | [AsyncLockMode](#asynclockmode) | 是   | 是   | 锁的模式。                                                |
453| contextId | number                          | 是   | 是   | [AsyncLockMode](#asynclockmode)调用者的执行上下文标识符。 |
454
455### AbortSignal
456
457用于中止异步操作的对象。该类的实例必须在其创建的同一线程中访问。从其他线程访问此类的字段会导致未定义的行为。
458
459**原子化服务API**:从API version 12 开始,该接口支持在原子化服务中使用。
460
461**系统能力:** SystemCapability.Utils.Lang
462
463#### 属性
464
465| 名称    | 类型    | 可读 | 可写 | 说明                                                             |
466| ------- | ------- | ---- | ---- | ---------------------------------------------------------------- |
467| aborted | boolean | 是   | 是   | 设置为true以中止操作。                                           |
468| reason  | \<T>    | 是   | 是   | 中止的原因。此值将用于拒绝[lockAsync](#lockasync)返回的Promise。 |
469
470## ArkTSUtils.ASON
471
472为支持将JSON字符串解析成共享数据,即[Sendable支持的数据类型](../../arkts-utils/arkts-sendable.md#sendable支持的数据类型),ArkTS语言基础库新增了ASON工具。ASON支持开发者解析JSON字符串,并生成共享数据进行跨并发域传输,同时ASON也支持将共享数据转换成JSON字符串。
473
474### ISendable
475
476type ISendable = lang.ISendable
477
478ISendable是所有Sendable类型(除`null`和`undefined`)的父类型。自身没有任何必须的方法和属性。
479
480**原子化服务API:** 从API version 12开始,该接口支持在原子化服务中使用。
481
482**系统能力:** SystemCapability.Utils.Lang
483
484| 类型 | 说明   |
485| ------ | ------ |
486| [lang.ISendable](js-apis-arkts-lang.md#langisendable)   | 所有Sendable类型的父类型。 |
487
488### Transformer
489
490type Transformer = (this: ISendable, key: string, value: ISendable | undefined | null) => ISendable | undefined | null
491
492用于转换结果函数的类型。
493
494**原子化服务API:** 从API version 12开始,该接口支持在原子化服务中使用。
495
496**系统能力:** SystemCapability.Utils.Lang
497
498**参数:**
499
500| 参数名 | 类型   | 必填 | 说明            |
501| ------ | ------ | ---- | --------------- |
502| this   | [ISendable](#isendable) | 是 | 在解析的键值对所属的对象。|
503| key  | string | 是 | 属性名。|
504| value  | [ISendable](#isendable) | 是 | 在解析的键值对的值。|
505
506**返回值:**
507
508| 类型 | 说明 |
509| -------- | -------- |
510| [ISendable](#isendable) \| undefined \| null | 返回转换结果后的ISendable对象或undefined或null。|
511
512### BigIntMode
513
514定义处理BigInt的模式。
515
516**原子化服务API:** 从API version 12开始,该接口支持在原子化服务中使用。
517
518**系统能力:** SystemCapability.Utils.Lang
519
520| 名称 | 值| 说明            |
521| ------ | ------ | --------------- |
522| DEFAULT   | 0 |不支持BigInt。|
523| PARSE_AS_BIGINT   | 1 |当整数小于-(2^53-1)或大于(2^53-1)时,解析为BigInt。|
524| ALWAYS_PARSE_AS_BIGINT   | 2 |所有整数都解析为BigInt。|
525
526### ParseReturnType
527
528定义解析结果的返回类型。
529
530**系统能力:** SystemCapability.Utils.Lang
531
532| 名称 | 值| 说明            |
533| ------ | ------ | --------------- |
534| OBJECT   | 0 |返回 SendableObject 对象。<br>**原子化服务API:** 从API version 12开始,该接口支持在原子化服务中使用。|
535| MAP<sup>13+</sup>   | 1 |返回 SendableMap 对象。<br>**原子化服务API:** 从API version 13开始,该接口支持在原子化服务中使用。|
536
537### ParseOptions
538
539解析的选项,可定义处理BigInt的模式与解析结果的返回类型。
540
541**原子化服务API:** 从API version 12开始,该接口支持在原子化服务中使用。
542
543**系统能力:** SystemCapability.Utils.Lang
544
545| 名称 | 类型| 必填 | 说明            |
546| ------ | ------ | ---- | --------------- |
547| bigIntMode   | [BigIntMode](#bigintmode) | 是 |定义处理BigInt的模式。|
548| parseReturnType   | [ParseReturnType](#parsereturntype) | 是 |定义解析结果的返回类型。|
549
550### parse
551
552parse(text: string, reviver?: Transformer, options?: ParseOptions): ISendable | null
553
554用于解析JSON字符串生成ISendable数据或null。
555
556**原子化服务API:** 从API version 12开始,该接口支持在原子化服务中使用。
557
558**系统能力:** SystemCapability.Utils.Lang
559
560**参数:**
561
562| 参数名 | 类型   | 必填 | 说明            |
563| ------ | ------ | ---- | --------------- |
564| text   | string | 是 | 有效的JSON字符串。|
565| reviver   | [Transformer](#transformer) | 否 | 转换函数,传入该参数,可以用来修改解析生成的原始值。默认值是undefined。目前只支持传入undefined。|
566| options   | [ParseOptions](#parseoptions) | 否 | 解析的配置,传入该参数,可以用来控制解析生成的结果类型。默认值是undefined。|
567
568**返回值:**
569
570| 类型 | 说明 |
571| -------- | -------- |
572| [ISendable](#isendable) \| null | 返回ISendable数据或null。当入参是null时,返回null。|
573
574**示例:**
575
576```ts
577import { lang } from '@kit.ArkTS';
578import { collections } from '@kit.ArkTS';
579
580type ISendable = lang.ISendable;
581let jsonText = '{"name": "John", "age": 30, "city": "ChongQing"}';
582let obj = ArkTSUtils.ASON.parse(jsonText) as ISendable;
583console.info((obj as object)?.["name"]);
584// 期望输出: 'John'
585console.info((obj as object)?.["age"]);
586// 期望输出: 30
587console.info((obj as object)?.["city"]);
588// 期望输出: 'ChongQing'
589
590let options: ArkTSUtils.ASON.ParseOptions = {
591  bigIntMode: ArkTSUtils.ASON.BigIntMode.PARSE_AS_BIGINT,
592  parseReturnType: ArkTSUtils.ASON.ParseReturnType.OBJECT,
593}
594let numberText = '{"largeNumber":112233445566778899}';
595let numberObj = ArkTSUtils.ASON.parse(numberText,undefined,options) as ISendable;
596
597console.info((numberObj as object)?.["largeNumber"]);
598// 期望输出: 112233445566778899
599
600let options2: ArkTSUtils.ASON.ParseOptions = {
601    bigIntMode: ArkTSUtils.ASON.BigIntMode.PARSE_AS_BIGINT,
602    parseReturnType: ArkTSUtils.ASON.ParseReturnType.MAP,
603  }
604let mapText = '{"largeNumber":112233445566778899}';
605let map  = ArkTSUtils.ASON.parse(mapText,undefined,options2);
606console.info("map is " + map);
607// 期望输出: map is [object SendableMap]
608console.info("largeNumber is " + (map as collections.Map<string,bigint>).get("largeNumber"));
609// 期望输出: largeNumber is 112233445566778899
610```
611
612### stringify
613
614stringify(value: ISendable | null | undefined): string
615
616该方法将ISendable数据转换为JSON字符串。
617
618能力扩展:该方法支持将Map、Set、[collections.Map](./js-apis-arkts-collections.md#collectionsmap)、[collections.Set](./js-apis-arkts-collections.md#collectionsset)、[HashMap](./js-apis-hashmap.md#hashmap)、[HashSet](./js-apis-hashset.md#hashset)转换为JSON字符串。
619
620**原子化服务API:** 从API version 12开始,该接口支持在原子化服务中使用。
621
622**系统能力:** SystemCapability.Utils.Lang
623
624**参数:**
625
626| 参数名 | 类型 | 必填 | 说明 |
627| -------- | -------- | -------- | -------- |
628| value | [ISendable](#isendable) \| null \| undefined  | 是 | ISendable数据。|
629
630**返回值:**
631
632| 类型 | 说明 |
633| -------- | -------- |
634| string | 转换后的JSON字符串。|
635
636**示例:**
637
638```ts
639import { collections, lang, ArkTSUtils } from '@kit.ArkTS';
640
641let arr = new collections.Array(1, 2, 3);
642let str = ArkTSUtils.ASON.stringify(arr);
643console.info(str);
644// 期望输出: '[1,2,3]'
645
646let map = new collections.Map<string, string>();
647map.set("key1", "value1");
648map.set("key2", "value2");
649let str2 = ArkTSUtils.ASON.stringify(map);
650console.info(str2);
651// 期望输出: '{"key1":"value1","key2":"value2"}'
652
653let set = new Set<number>();
654set.add(1);
655set.add(2);
656set.add(3);
657let str3 = ArkTSUtils.ASON.stringify(set as Object as lang.ISendable);
658console.info(str3);
659// 期望输出: '[1,2,3]'
660```
661
662### isSendable
663
664isSendable(value: Object | null | undefined): boolean
665
666该方法用于判断value是否为Sendable数据类型。
667
668**原子化服务API:** 从API version 12开始,该接口支持在原子化服务中使用。
669
670**系统能力:** SystemCapability.Utils.Lang
671
672**参数:**
673
674| 参数名 | 类型 | 必填 | 说明 |
675| -------- | -------- | -------- | -------- |
676| value | Object \| null \| undefined  | 是 | 待校验的对象。|
677
678**返回值:**
679
680| 类型 | 说明 |
681| -------- | -------- |
682| boolean | value是否为Sendable数据类型,true表示value是Sendable数据类型,否则为false。|
683
684**示例:**
685
686```ts
687import { ArkTSUtils } from '@kit.ArkTS'
688
689@Sendable
690function sendableFunc() {
691  console.info("sendableFunc")
692}
693
694if (ArkTSUtils.isSendable(sendableFunc)) {
695  console.info("sendableFunc is Sendable");
696} else {
697  console.info("sendableFunc is not Sendable");
698}
699// 期望输出: 'SendableFunc is Sendable'
700```
701