Skip to content

U
unidocs-uni-app-x-zh

DCloud / unidocs-uni-app-x-zh

通知 144
Star 2
Fork 33
U
unidocs-uni-app-x-zh
切换分支/标签
查找文件 普通视图历史永久链接Permalink
utsJson.json 261.8 KB
Newer Older
D
chore: uts api json、uts json  
DCloud_LXH 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 
{
	"String": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.String)",
		"length": {
			"name": "### length",
			"description": "\r\n返回字符串的 UTF-16 码元长度。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"toString": {
			"name": "### toString()",
			"description": "\r\n返回一个字符串，表示指定的字符串。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | String 包装对象的字符串值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"charAt": {
			"name": "### charAt(pos)",
			"description": "\r\n返回一个由给定索引处的单个 UTF-16 码元构成的新字符串。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| pos | number | 是 | 要返回的字符的索引，从零开始。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 返回一个字符串，该字符串表示指定 index 处的字符（恰好是一个 UTF-16 码元）。如果 index 超出了 0 – str.length - 1 的范围，charAt() 将返回一个空字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"charCodeAt": {
			"name": "### charCodeAt(index)",
			"description": "\r\n返回 0 到 65535 之间的整数，表示给定索引处的 UTF-16 代码单元",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| index | number | 是 | 一个大于等于 0，小于字符串长度的整数。如果不是一个数值，则默认为 0。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 指定 index 处字符的 UTF-16 代码单元值的一个数字；如果 index 超出范围，charCodeAt() 返回 NaN。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"concat": {
			"name": "### concat(...strings)",
			"description": "\r\n将字符串参数连接到调用的字符串，并返回一个新的字符串。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| strings | string[\\] | 否 | T要连接到 str 的一个或多个字符串。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个包含所提供的多个字符串文本组合的新字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"indexOf": {
			"name": "### indexOf(searchString, position?)",
			"description": "\r\n在字符串中搜索指定子字符串，并返回其第一次出现的位置索引。它可以接受一个可选的参数指定搜索的起始位置，如果找到了指定的子字符串，则返回的位置索引大于或等于指定的数字。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| searchString | string | 是 | 要搜索的子字符串。 |\n| position | number | 否 | 该方法返回指定子字符串在大于或等于 position 位置的第一次出现的索引，默认为 0。如果 position 大于调用字符串的长度，则该方法根本不搜索调用字符串。如果 position 小于零，该方法的行为就像 position 为 0 时一样。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 查找的字符串 searchValue 的第一次出现的索引，如果没有找到，则返回 -1。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"lastIndexOf": {
			"name": "### lastIndexOf(searchString, position?)",
			"description": "\r\n搜索该字符串并返回指定子字符串最后一次出现的索引。它可以接受一个可选的起始位置参数，并返回指定子字符串在小于或等于指定数字的索引中的最后一次出现的位置。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| searchString | string | 是 | 要搜索的子字符串。 |\n| position | number | 否 | 该方法返回指定子字符串在小于或等于 position 的位置中的最后一次出现的索引，默认为 +Infinity。如果 position 大于调用字符串的长度，则该方法将搜索整个字符串。如果 position 小于 0，则行为与 0 相同，即该方法只在索引 0 处查找指定的子字符串。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 如果找到了 searchString，则返回最后一次出现的索引，否则返回 -1。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"localeCompare": {
			"name": "### localeCompare(that)",
			"description": "\r\n返回一个数字，表示参考字符串在排序顺序中是在给定字符串之前、之后还是与之相同。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| that | string | 是 | 与 referenceStr 进行比较的字符串。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个数字表示 referenceStr 在排序中是否位于 compareString 的前面、后面或二者相同。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"match": {
			"name": "### match(regexp)",
			"description": "\r\nmatch() 方法检索字符串与正则表达式进行匹配的结果。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| regexp | string \\| RegExp | 是 | 一个正则表达式对象或者任何具有 Symbol.match 方法的对象。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| RegExpMatchArray \\| null | 一个 Array，其内容取决于是否存在全局（g）标志，如果没有匹配，则返回 null。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"replace": {
			"name": "### replace(searchValue, replaceValue)",
			"description": "\r\n返回一个由替换值（replacement）替换部分或所有的模式（pattern）匹配项后的新字符串。模式可以是一个字符串或者一个正则表达式。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| searchValue | string \\| RegExp | 是 | RegExp: 一个RegExp 对象或者其字面量。该正则所匹配的内容会被第二个参数的返回值替换掉。string: 一个将被 newSubStr 替换的 字符串。其被视为一整个字符串，而不是一个正则表达式。仅第一个匹配项会被替换。 |\n| replaceValue | string | 是 | 用于替换掉第一个参数在原字符串中的匹配部分的字符串。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个部分或全部匹配由替代模式所取代的新的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"replace_1": {
			"name": "### replace(searchValue, replacer)",
			"description": "\r\n返回一个由替换值（replacement）替换部分或所有的模式（pattern）匹配项后的新字符串。模式可以是一个字符串或者一个正则表达式，替换值是一个每次匹配都要调用的回调函数。如果pattern是字符串，则仅替换第一个匹配项。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| searchValue | string \\| RegExp | 是 | RegExp: 一个RegExp 对象或者其字面量。该正则所匹配的内容会被第二个参数的返回值替换掉。string: 一个将被 newSubStr 替换的 字符串。其被视为一整个字符串，而不是一个正则表达式。仅第一个匹配项会被替换。 |\n| replacer | (substring : string, ...args : any[\\]) => string | 是 | 一个用来创建新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的结果。在iOS中replacer的第二个参数是字符串数组而非可变参数。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个部分或全部匹配由替代模式所取代的新的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"search": {
			"name": "### search(regexp)",
			"description": "\r\nsearch() 方法执行正则表达式和 String 对象之间的一个搜索匹配。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| regexp | string \\| RegExp | 是 | 一个正则表达式（regular expression）对象。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 如果匹配成功，则 search() 返回正则表达式在字符串中首次匹配项的索引;否则，返回 -1。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"slice": {
			"name": "### slice(start?, end?)",
			"description": "\r\nslice() 方法提取某个字符串的一部分，并返回一个新的字符串，且不会改动原字符串。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| start | number | 否 | 可选。从该索引（以 0 为基数）处开始提取原字符串中的字符。如果值为负数，会被当做 strLength + beginIndex 看待，这里的strLength 是字符串的长度（例如，如果 beginIndex 是 -3 则看作是：strLength - 3） |\n| end | number | 否 | 可选。在该索引（以 0 为基数）处结束提取字符串。如果省略该参数，slice() 会一直提取到字符串末尾。如果该参数为负数，则被看作是 strLength + endIndex，这里的 strLength 就是字符串的长度 (例如，如果 endIndex 是 -3，则是，strLength - 3)。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 返回一个从原字符串中提取出来的新字符串 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"split": {
			"name": "### split(separator, limit?)",
			"description": "\r\nsplit() 方法接受一个模式，通过搜索模式将字符串分割成一个有序的子串列表，将这些子串放入一个数组，并返回该数组。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| separator | string \\| RegExp | 是 | 描述每个分割应该发生在哪里的模式。 |\n| limit | number | 否 | 一个非负整数，指定数组中包含的子字符串的数量限制。当提供此参数时，split 方法会在指定 separator 每次出现时分割该字符串，但在已经有 limit 个元素时停止分割。任何剩余的文本都不会包含在数组中。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string[\\] | 在给定字符串中出现 separator 的每一个点上进行分割而成的字符串数组。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"substring": {
			"name": "### substring(start, end?)",
			"description": "\r\n返回一个字符串在开始索引到结束索引之间的一个子集，或从开始索引直到字符串的末尾的一个子集。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| start | number | 是 | 要截取的第一个字符的索引，该索引位置的字符作为返回的字符串的首字母。 |\n| end | number | 否 | 可选。一个 0 到字符串长度之间的整数，以该数字为索引的字符不包含在截取的字符串内。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 包含给定字符串的指定部分的新字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"toLowerCase": {
			"name": "### toLowerCase()",
			"description": "toLowerCase() 会将调用该方法的字符串值转为小写形式，并返回。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个新的字符串，表示转换为小写的调用字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"toLocaleLowerCase": {
			"name": "### toLocaleLowerCase(locales?)",
			"description": "\r\n根据任何指定区域语言环境设置的大小写映射，返回调用字符串被转换为小写的格式。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| locales | string \\| string[\\] | 否 | 可选。指明要转换成小写格式的特定语言区域。如果以一个数组 Array 形式给出多个 locales, 最合适的地区将被选出来应用。默认的 locale 是主机环境的当前区域 (locale) 设置。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 根据任何特定于语言环境的案例映射规则将被调用字串转换成小写格式的一个新字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"toUpperCase": {
			"name": "### toUpperCase()",
			"description": "\r\n将调用该方法的字符串转为大写形式并返回（如果调用该方法的值不是字符串类型会被强制转换）。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个新的字符串，表示转换为大写的调用字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"toLocaleUpperCase": {
			"name": "### toLocaleUpperCase(locales?)",
			"description": "\r\n根据本地主机语言环境把字符串转换为大写格式，并返回转换后的字符串。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| locales | string \\| string[\\] | 否 | locales参数指示要用于根据任何特定于语言环境的大小写映射转换为大写的语言环境。如果Array中给出了多个区域设置，则使用最佳可用区域设置。默认语言环境是主机环境的当前语言环境。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 根据任何特定于语言环境的大小写映射，表示转换为大写的调用字符串的新字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"trim": {
			"name": "### trim()",
			"description": "\r\n从字符串的两端清除空格，返回一个新的字符串，而不修改原始字符串。此上下文中的空格是指所有的空白字符（空格、tab、不换行空格等）以及所有行终止符字符（如 LF、CR 等）。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个表示 str 去掉了开头和结尾的空白字符后的新字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"substr": {
			"name": "### substr(from, length?)",
			"description": "\r\n返回一个字符串中从指定位置开始到指定字符数的字符。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| from | number | 是 | 开始提取字符的位置。如果为负值，则被看作 strLength + start，其中 strLength 为字符串的长度（例如，如果 start 为 -3，则被看作 strLength + (-3)）。 |\n| length | number | 否 | 可选。提取的字符数。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 返回一个字符串中从指定位置开始到指定字符数的字符。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"valueOf": {
			"name": "### valueOf()",
			"description": "返回 String 对象的原始值",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | String 对象的原始值 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"padStart": {
			"name": "### padStart(targetLength, padString?)",
			"description": "\r\n用另一个字符串填充当前字符串（如果需要会重复填充），直到达到给定的长度。填充是从当前字符串的开头开始的。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| targetLength | number | 是 | 当前 str 填充后的长度。如果该值小于或等于 str.length，则会直接返回当前 str。 |\n| padString | string | 否 | 可选。用于填充当前 str 的字符串。如果 padString 太长，无法适应 targetLength，则会从末尾被截断。默认值为“ ”字符（U+0020）。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 在开头填充 padString 直到达到给定的 targetLength 所形成的 String。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"padEnd": {
			"name": "### padEnd(targetLength, padString?)",
			"description": "\r\n将当前字符串从末尾开始填充给定的字符串（如果需要会重复填充），直到达到给定的长度。填充是从当前字符串的末尾开始的。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| targetLength | number | 是 | 当前 str 填充后的长度。如果该值小于或等于 str.length，则会直接返回当前 str。 |\n| padString | string | 否 | 可选。用于填充当前 str 的字符串。如果 padString 太长，无法适应 targetLength，则会被截断。默认值为“ ”字符（U+0020）。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 在开头填充 padString 直到达到给定的 targetLength 所形成的 String。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"codePointAt": {
			"name": "### codePointAt(pos)",
			"description": "\r\n返回一个小于 1114112 (0x110000) 的非负整数 Number，它是 UTF-16 编码的代码点的代码点值，该代码点始于将此对象转换为字符串而产生的字符串中位置 pos 处的字符串元素。\r\n如果该位置没有元素，则结果未定义。\r\n如果有效的 UTF-16 代理项对不是从 pos 开始，则结果是 pos 处的代码单元。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| pos | number | 是 | 这个字符串中需要转码的元素的位置。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number \\| null | 返回值是在字符串中的给定索引的编码单元体现的数字，如果在索引处没找到元素则返回 null。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"includes": {
			"name": "### includes(searchString, position?)",
			"description": "\r\n如果 searchString 作为此对象转换为 String 的结果的子字符串出现在大于或等于position的一个或多个位置，则返回 true；否则，返回 false。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| searchString | string | 是 | 要在 str 中搜索的字符串。不能是正则表达式。 |\n| position | number | 否 | 在字符串中开始搜索 searchString 的位置。（默认为 0。） |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果在给定的字符串中找到了要搜索的字符串（包括 searchString 为空字符串的情况），则返回 true，否则返回 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"endsWith": {
			"name": "### endsWith(searchString, endPosition?)",
			"description": "\r\nendsWith() 方法用于判断一个字符串是否以指定字符串结尾，如果是则返回 true，否则返回 false。该方法区分大小写。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| searchString | string | 是 | 要搜索的作为结尾的字符串，不能是正则表达式。所有非正则表达式的值都会被强制转换为字符串。 |\n| endPosition | number | 否 | 可选，预期找到 searchString 的末尾位置（即 searchString 最后一个字符的索引加 1）。默认为 str.length。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果被检索字符串的末尾出现了指定的字符串（包括 searchString 为空字符串的情况），则返回 true；否则返回 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"normalize": {
			"name": "### normalize(form)",
			"description": "\r\nnormalize() 方法会按照指定的一种 Unicode 正规形式将当前字符串规范化。（如果该值不是字符串，则首先将其转换为一个字符串）。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| form | \"NFC\" \\| \"NFD\" \\| \"NFKC\" \\| \"NFKD\" | 是 | 四种 Unicode 正规形式（Unicode Normalization Form）\"NFC\"、\"NFD\"、\"NFKC\"，或 \"NFKD\" 其中的一个，默认值为 \"NFC\"。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 含有给定字符串的 Unicode 规范化形式的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"normalize_1": {
			"name": "### normalize(form?)",
			"description": "\r\nnormalize() 方法会按照指定的一种 Unicode 正规形式将当前字符串规范化。（如果该值不是字符串，则首先将其转换为一个字符串）。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| form | string | 否 | 四种 Unicode 正规形式（Unicode Normalization Form）\"NFC\"、\"NFD\"、\"NFKC\"，或 \"NFKD\" 其中的一个，默认值为 \"NFC\"。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 含有给定字符串的 Unicode 规范化形式的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"repeat": {
			"name": "### repeat(count)",
			"description": "\r\nrepeat() 构造并返回一个新字符串，该字符串包含被连接在一起的指定数量的字符串的副本。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| count | number | 是 | 介于 0 和 +Infinity 之间的整数。表示在新构造的字符串中重复了多少遍原字符串。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 包含指定字符串的指定数量副本的新字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"startsWith": {
			"name": "### startsWith(searchString, position?)",
			"description": "\r\nstartsWith() 方法用来判断当前字符串是否以另外一个给定的子字符串开头，并根据判断结果返回 true 或 false。这个方法区分大小写。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| searchString | string | 是 | 要搜索的子字符串。 |\n| position | number | 否 | 在 str 中搜索 searchString 的开始位置，默认值为 0。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果在字符串的开头找到了给定的字符则返回 true；否则返回 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"anchor": {
			"name": "### anchor(name)",
			"description": "\r\nanchor() 方法创建一个 \\<a> HTML 锚元素，被用作超文本靶标（hypertext target）。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| name | string | 是 | 一个字符串，表示被创建的标签的 name 属性。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 包含 \\<a> HTML 元素的一个字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"big": {
			"name": "### big()",
			"description": "\r\n创建一个使字符串显示大号字体的\\<big>标签。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 带有 \\<big>标签的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"blink": {
			"name": "### blink()",
			"description": "\r\nblink() 方法创建一个字符串，其在 \\<blink>str\\</blink> 中嵌入字符串，这使得字符串在旧版浏览器中闪烁。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 包含 \\<blink> HTML 元素的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"bold": {
			"name": "### bold()",
			"description": "\r\nbold() 方法会创建 HTML 元素“b”，并将字符串加粗展示。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 包含 HTML 元素 \\<b> 的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"fixed": {
			"name": "### fixed()",
			"description": "\r\nfixed() 方法创建了一个 \\<tt> 标签元素将字符串包裹起来，从而让这个字符串里面的内容具有固定间距。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 返回一个表示 \\<tt> HTML 元素的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"fontcolor": {
			"name": "### fontcolor(color)",
			"description": "\r\n创建一个\\<font>的 HTML 元素让字符串被显示成指定的字体颜色。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| color | string | 是 | 代表颜色的一个字符串，可以是三个一组的十六进制的 RGB 值，也可以是一个颜色名称的字符串字面量. |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个包含一个\\<font> HTML 元素的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"fontsize": {
			"name": "### fontsize(size)",
			"description": "\r\n返回一个' \\<font> ' HTML元素并设置size属性值",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| size | number | 是 | 1到7之间的整数。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 包含\\<font> HTML元素的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"fontsize_1": {
			"name": "### fontsize(size)",
			"description": "\r\n返回一个' \\<font> ' HTML元素并设置size属性值",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| size | string | 是 | 表示1到7之间的有符号整数的字符串。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 包含\\<font> HTML元素的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"italics": {
			"name": "### italics()",
			"description": "\r\nitalics()方法创建一个\\<i> HTML元素，使字符串变为斜体。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 返回一个\\<i> HTML元素，使字符串变为斜体。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"link": {
			"name": "### link(url)",
			"description": "\r\nlink() 方法创建一个 HTML 元素 \\<a> ，用该字符串作为超链接的显示文本，参数作为指向另一个 URL 的超链接。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| url | string | 是 | 任何能够指定 a 标签的 href 属性的字符串；它应当是有效的 URL（相对或绝对），任何 & 字符将会被转义为 &amp;，任何 \" 字符将会被转义为 &quot;。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个带有一个 HTML 元素 \\<a> 的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"small": {
			"name": "### small()",
			"description": "\r\nsmall() 方法的作用是创建一个使字符串显示小号字体的 \\<small> 标签。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 带有 \\<small> 标签的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"strike": {
			"name": "### strike()",
			"description": "\r\nstrike()方法创建\\<strike> HTML 元素，使字符串展示为被删除的文本。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 包含\\<strike> HTML 元素的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"sub": {
			"name": "### sub()",
			"description": "\r\nsub()方法创建一个 \\<sub> HTML 元素，使字符串展示为下标。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 包含\\<sub> HTML 元素的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"sup": {
			"name": "### sup()",
			"description": "\r\nsup()方法创建 一个\\<sup>HTML 元素，使字符串显示为上标。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 包含\\<sup> HTML 元素的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"at": {
			"name": "### at(index)",
			"description": "\r\n方法接受一个整数值，并返回一个新的 String，该字符串由位于指定偏移量处的单个 UTF-16 码元组成",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| index | number | 是 | 字符指定偏移量处，允许正整数和负整数，负整数从字符串中的最后一个字符开始倒数。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string \\| null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"fromCharCode": {
			"name": "### fromCharCode(...codes)",
			"description": "",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| codes | number[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | - |\n",
			"itemType": "method"
		}
	},
	"Number": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.Number)",
		"MAX_VALUE": {
			"name": "### MAX_VALUE",
			"description": "\r\n在 JavaScript 里所能表示的最大数值。无限接近于 1.79E+308。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "prop"
		},
		"MIN_VALUE": {
			"name": "### MIN_VALUE",
			"description": "\r\n表示在 JavaScript 中所能表示的最小的正值。 无限接近于 5.00E-324。\r\n",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "prop"
		},
		"NaN": {
			"name": "### NaN",
			"description": "\r\n表示“非数字”（Not-A-Number）。和 NaN 相同。\r\n在相等比较中，NaN不等于任何值，包括它自己。要测试一个值是否等于NaN，使用isNaN函数。\r\n",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "prop"
		},
		"NEGATIVE_INFINITY": {
			"name": "### NEGATIVE_INFINITY",
			"description": "\r\n表示负无穷大。\r\nNumber.NEGATIVE_INFINITY 的值和全局对象的 Infinity 属性的负值相同。\r\n",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "prop"
		},
		"POSITIVE_INFINITY": {
			"name": "### POSITIVE_INFINITY",
			"description": "\r\n表示正无穷大。\r\nNumber.POSITIVE_INFINITY 的值同全局对象 Infinity 属性的值相同。\r\n",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "prop"
		},
		"toString": {
			"name": "### toString(radix?)",
			"description": "\r\n返回指定 Number 对象的字符串表示形式。如果转换的基数大于 10，则会使用字母来表示大于 9 的数字，比如基数为 16 的情况，则使用 a 到 f 的字母来表示 10 到 15。如果基数没有指定，则使用 10。如果对象是负数，则会保留负号。即使 radix 是 2 时也是如此：返回的字符串包含一个负号（-）前缀和正数的二进制表示，不是 数值的二进制补码。进行数字到字符串的转换时，建议用小括号将要转换的目标括起来，防止出错。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| radix | number | 否 | 指定要用于数字到字符串的转换的基数 (从 2 到 36)。如果未指定 radix 参数，则默认值为 10。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"toFixed": {
			"name": "### toFixed(fractionDigits?)",
			"description": "\r\n使用定点表示法来格式化一个数值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| fractionDigits | number | 否 | 小数点后数字的个数；介于 0 到 20（包括）之间，实现环境可能支持更大范围。如果忽略该参数，则默认为 0。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 使用定点表示法表示给定数字的字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"toExponential": {
			"name": "### toExponential(fractionDigits?)",
			"description": "\r\n以指数表示法返回该数值字符串表示形式。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| fractionDigits | number | 否 | 可选。一个整数，用来指定小数点后有几位数字。默认情况下用尽可能多的位数来显示数字。如果 fractionDigits 太小或太大将会抛出该错误。必须介于 0 和 20（包括 20）之间。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个用幂的形式 (科学记数法) 来表示Number 对象的字符串。小数点后以 fractionDigits 提供的值来四舍五入。如果 fractionDigits 参数被忽略了，小数点后的将尽可能用最多的位数来表示该数值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"toPrecision": {
			"name": "### toPrecision(precision?)",
			"description": "\r\n以指定的精度返回该数值对象的字符串表示。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| precision | number | 否 | 一个用来指定有效数个数的整数。 必须介于 1 到 21 之间。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 以定点表示法或指数表示法表示的一个数值对象的字符串表示，四舍五入到 precision 参数指定的显示数字位数。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"valueOf": {
			"name": "### valueOf()",
			"description": "\r\n返回一个被 Number 对象包装的原始值。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 表示指定 Number 对象的原始值的数字。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"toInt": {
			"name": "### toInt()",
			"description": "\r\n返回一个Int 值",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Int | 返回 number 对应的 Int 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | x |\n",
			"itemType": "method"
		},
		"toFloat": {
			"name": "### toFloat()",
			"description": "\r\n返回一个Float 值",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Float | 返回 number 对应的 Float 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | x |\n",
			"itemType": "method"
		},
		"toDouble": {
			"name": "### toDouble()",
			"description": "\r\n返回一个 Double 值",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Double | 返回 number 对应的 Double 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | x |\n",
			"itemType": "method"
		},
		"toInt64": {
			"name": "### toInt64()",
			"description": "\r\n返回一个 Int64 值, app-iOS平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Int64 | 返回 number 对应的 Int64 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | x |\n",
			"itemType": "method"
		},
		"toInt32": {
			"name": "### toInt32()",
			"description": "\r\n返回一个 Int32 值, app-iOS平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Int32 | 返回 number 对应的 Int32 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | x |\n",
			"itemType": "method"
		},
		"toInt16": {
			"name": "### toInt16()",
			"description": "\r\n返回一个 Int16 值, app-iOS平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Int16 | 返回 number 对应的 Int16 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | x |\n",
			"itemType": "method"
		},
		"toInt8": {
			"name": "### toInt8()",
			"description": "\r\n返回一个 Int8 值, app-iOS平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Int8 | 返回 number 对应的 Int8 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | x |\n",
			"itemType": "method"
		},
		"toUInt": {
			"name": "### toUInt()",
			"description": "\r\n返回一个 UInt 值",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UInt | 返回 number 对应的 UInt 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | x |\n",
			"itemType": "method"
		},
		"toUInt64": {
			"name": "### toUInt64()",
			"description": "\r\n返回一个 UInt64 值, app-iOS平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UInt64 | 返回 number 对应的 UInt64 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | x |\n",
			"itemType": "method"
		},
		"toUInt32": {
			"name": "### toUInt32()",
			"description": "\r\n返回一个 UInt32 值, app-iOS平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UInt32 | 返回 number 对应的 UInt32 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | x |\n",
			"itemType": "method"
		},
		"toUInt16": {
			"name": "### toUInt16()",
			"description": "\r\n返回一个 UInt16 值, app-iOS平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UInt16 | 返回 number 对应的 UInt16 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | x |\n",
			"itemType": "method"
		},
		"toUInt8": {
			"name": "### toUInt8()",
			"description": "\r\n返回一个 UInt8 值, app-iOS平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UInt8 | 返回 number 对应的 UInt8 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | x |\n",
			"itemType": "method"
		},
		"toByte": {
			"name": "### toByte()",
			"description": "\r\n将当前的Number数据转换为Byte表示，如果超出Byte最大值表示范围，会得到溢出后余数表示, app-andorid平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Byte | 返回 number 对应的 Byte 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | x |\n",
			"itemType": "method"
		},
		"toLong": {
			"name": "### toLong()",
			"description": "\r\n将当前的Number数据转换为Long表示，如果超出Long最大值表示范围，会得到溢出后余数表示, app-andorid平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Long | 返回 number 对应的 Long 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | x |\n",
			"itemType": "method"
		},
		"toShort": {
			"name": "### toShort()",
			"description": "\r\n将当前的Number数据转换为Short表示，如果超出Short最大值表示范围，会得到溢出后余数表示, app-andorid平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Short | 返回 number 对应的 Short 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | x |\n",
			"itemType": "method"
		},
		"toUShort": {
			"name": "### toUShort()",
			"description": "\r\n将当前的 Number 数据转换为 UShort 表示，如果超出 UShort 最大值表示范围，会得到溢出后余数表示, app-andorid平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UShort | 返回 number 对应的 UShort 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | x |\n",
			"itemType": "method"
		},
		"toULong": {
			"name": "### toULong()",
			"description": "\r\n将当前的 Number 数据转换为 ULong 表示，如果超出 ULong 最大值表示范围，会得到溢出后余数表示, app-andorid平台特有。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| ULong | 返回 number 对应的 ULong 值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | x |\n",
			"itemType": "method"
		},
		"from": {
			"name": "### from(value)",
			"description": "\r\n通过 Int \\| Float \\| Double \\| Int64 \\| Int32 \\| Int16 \\| Int8 \\| UInt \\| UInt64 \\| UInt32 \\| UInt16 \\| UInt8  \\| Byte \\| Short \\| Long 类型创建一个 number",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| value | Int \\| Float \\| Double \\| Int64 \\| Int32 \\| Int16 \\| Int8 \\| UInt \\| UInt64 \\| UInt32 \\| UInt16 \\| UInt8  \\| Byte \\| Short \\| Long | 是 | 必填。一个 Swfit 或者 Kottlin 专有数字类型的值。其中 Swift 平台 支持 Int, Float, Double, Int64, Int32, Int16, Int8, UInt,  UInt64, UInt32, UInt16, UInt8。Kottlin 平台支持  Int, Float, Double, Byte, Short, Long |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回 number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | x |\n",
			"itemType": "method"
		}
	},
	"Math": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.Math)",
		"E": {
			"name": "### E",
			"description": "\r\nMath.E 属性表示自然对数的底数（或称为基数），e，约等于 2.718。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"LN10": {
			"name": "### LN10",
			"description": "\r\nMath.LN10 属性表示 10 的自然对数，约为 2.302\r\n",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"LN2": {
			"name": "### LN2",
			"description": "\r\nMath.LN2 属性表示 2 的自然对数，约为 0.693",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"LOG2E": {
			"name": "### LOG2E",
			"description": "\r\nMath.LOG2E 属性表示以 2 为底数，e 的对数，约为 1.442",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"LOG10E": {
			"name": "### LOG10E",
			"description": "\r\nMath.LOG10E 属性表示以 10 为底数，e 的对数，约为 0.434",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"PI": {
			"name": "### PI",
			"description": "\r\nMath.PI 表示一个圆的周长与直径的比例，约为 3.14159",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"SQRT1_2": {
			"name": "### SQRT1_2",
			"description": "\r\nMath.SQRT1_2 属性表示 1/2 的平方根，约为 0.707",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"SQRT2": {
			"name": "### SQRT2",
			"description": "\r\nMath.SQRT2 属性表示 2 的平方根，约为 1.414",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"abs": {
			"name": "### abs(x)",
			"description": "\r\nRMath.abs(x) 函数返回一个数字的绝对值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数字 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | x 的绝对值。如果 x 是负数（包括 -0），则返回 -x。否则，返回 x | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"acos": {
			"name": "### acos(x)",
			"description": "\r\nMath.acos() 返回一个数的反余弦值（单位为弧度）",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值. |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"asin": {
			"name": "### asin(x)",
			"description": "\r\nMath.asin() 方法返回一个数值的反正弦（单位为弧度）",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"atan": {
			"name": "### atan(x)",
			"description": "\r\nMath.atan() 函数返回一个数值的反正切（以弧度为单位）",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"atan2": {
			"name": "### atan2(y, x)",
			"description": "\r\nMath.atan2() 返回从原点 (0,0) 到 (x,y) 点的线段与 x 轴正方向之间的平面角度 (弧度值)，也就是 Math.atan2(y,x)",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| y | number | 是 | 数值 |\n| x | number | 是 | 数值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"ceil": {
			"name": "### ceil(x)",
			"description": "\r\nMath.ceil() 函数总是四舍五入并返回大于等于给定数字的最小整数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"cos": {
			"name": "### cos(x)",
			"description": "\r\nMath.cos() 函数返回一个数值的余弦值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个以弧度为单位的数值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"exp": {
			"name": "### exp(x)",
			"description": "\r\nMath.exp() 函数返回 e^x，x 表示参数，e 是欧拉常数（Euler's constant），自然对数的底数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"floor": {
			"name": "### floor(x)",
			"description": "\r\nMath.floor() 函数总是返回小于等于一个给定数字的最大整数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"log": {
			"name": "### log(x)",
			"description": "\r\nMath.log() 函数返回一个数的自然对数",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"max": {
			"name": "### max(...values)",
			"description": "\r\nMath.max() 函数返回作为输入参数的最大数字，如果没有参数，则返回 -Infinity",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| values | number[\\] | 否 | 0 个或多个数字，将在其中选择，并返回最大的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 给定数值中最大的数。如果任一参数不能转换为数值，则返回 NaN。如果没有提供参数，返回 -Infinity。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"min": {
			"name": "### min(...values)",
			"description": "\r\nMath.min() 函数返回作为输入参数的数字中最小的一个，如果没有参数，则返回 Infinity。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| values | number[\\] | 否 | 0 个或多个数字，将在其中选择，并返回最小值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 给定数值中最小的数。如果任一参数不能转换为数值，则返回 NaN。如果没有提供参数，返回 Infinity。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"pow": {
			"name": "### pow(x, y)",
			"description": "\r\nMath.pow() 函数返回基数（base）的指数（exponent）次幂，即 base^exponent。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 基数 |\n| y | number | 是 | 指数 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"random": {
			"name": "### random()",
			"description": "\r\nMath.random() 函数返回一个浮点数，伪随机数在范围从0 到小于1，也就是说，从 0（包括 0）往上，但是不包括 1（排除 1），然后您可以缩放到所需的范围。实现将初始种子选择到随机数生成算法;它不能被用户选择或重置。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 一个浮点型伪随机数字，在0（包括 0）和1（不包括）之间。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"round": {
			"name": "### round(x)",
			"description": "\r\nMath.round() 函数返回一个数字四舍五入后最接近的整数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 给定数字的值四舍五入到最接近的整数。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"sin": {
			"name": "### sin(x)",
			"description": "\r\nMath.sin() 函数返回一个数值的正弦值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值（以弧度为单位）。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"sqrt": {
			"name": "### sqrt(x)",
			"description": "\r\nMath.sqrt() 函数返回一个数的平方根",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"tan": {
			"name": "### tan(x)",
			"description": "\r\nMath.tan() 方法返回一个数值的正切值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值，表示一个角（单位：弧度）。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"clz32": {
			"name": "### clz32(x)",
			"description": "\r\nMath.clz32() 函数返回一个数字在转换成 32 无符号整形数字的二进制形式后，开头的 0 的个数",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"imul": {
			"name": "### imul(x, y)",
			"description": "\r\n该函数将两个参数分别转换为 32 位整数，相乘后返回 32 位结果，类似 C 语言的 32 位整数相乘。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 被乘数。 |\n| y | number | 是 | 乘数。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"sign": {
			"name": "### sign(x)",
			"description": "\r\nMath.sin() 函数返回一个数值的正弦值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值（以弧度为单位）。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"log10": {
			"name": "### log10(x)",
			"description": "\r\nMath.log10() 函数返回一个数字以 10 为底的对数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 任意数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"log2": {
			"name": "### log2(x)",
			"description": "\r\nMath.log2() 函数返回一个数字以 2 为底的对数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 任意数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"log1p": {
			"name": "### log1p(x)",
			"description": "\r\nMath.log1p() 函数返回一个数字加 1 后的自然对数 (底为 E), 既log(x+1).",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 任意数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"expm1": {
			"name": "### expm1(x)",
			"description": "\r\nMath.expm1() 函数返回 E^x - 1, 其中 x 是该函数的参数，E 是自然对数的底数 2.718281828459045。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 任意数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"cosh": {
			"name": "### cosh(x)",
			"description": "\r\nMath.cosh() 函数返回数值的双曲余弦函数",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 数值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"sinh": {
			"name": "### sinh(x)",
			"description": "\r\nMath.sinh() 函数返回一个数字 (单位为角度) 的双曲正弦值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 任意数字 (单位为度). |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"tanh": {
			"name": "### tanh(x)",
			"description": "\r\nMath.tanh() 函数将会返回一个数的双曲正切函数值",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 待计算的数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"acosh": {
			"name": "### acosh(x)",
			"description": "\r\nMath.acosh() 函数返回一个数的反双曲余弦值",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"asinh": {
			"name": "### asinh(x)",
			"description": "\r\nMath.asinh() 返回一个数值的反双曲正弦值",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"atanh": {
			"name": "### atanh(x)",
			"description": "\r\nMath.atanh() 函数返回一个数值反双曲正切值",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个数值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"hypot": {
			"name": "### hypot(...values)",
			"description": "\r\nMath.hypot() 函数返回所有参数的平方和的平方根",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| values | number[\\] | 否 | 任意个数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"trunc": {
			"name": "### trunc(x)",
			"description": "\r\nMath.trunc() 方法会将数字的小数部分去掉，只保留整数部分。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 任意数字 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"fround": {
			"name": "### fround(x)",
			"description": "\r\nMath.fround() 可以将任意的数字转换为离它最近的单精度浮点数形式的数字。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 一个 Number。若参数为非数字类型，则会被转投成数字。无法转换时，设置成NaN。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"cbrt": {
			"name": "### cbrt(x)",
			"description": "\r\nMath.cbrt() 函数返回任意数字的立方根。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | number | 是 | 任意数字。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		}
	},
	"Date": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.Date)",
		"toString": {
			"name": "### toString()",
			"description": "\r\n返回一个字符串，以本地的时区表示该 Date 对象。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"toDateString": {
			"name": "### toDateString()",
			"description": "\r\n以美式英语和人类易读的形式返回一个日期对象日期部分的字符串。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"toTimeString": {
			"name": "### toTimeString()",
			"description": "\r\n以人类易读形式返回一个日期对象时间部分的字符串，该字符串以美式英语格式化。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"toLocaleString": {
			"name": "### toLocaleString()",
			"description": "\r\n返回该日期对象的字符串，该字符串格式因不同语言而不同。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"toLocaleDateString": {
			"name": "### toLocaleDateString()",
			"description": "\r\n返回指定日期对象日期部分的字符串，该字符串格式因不同语言而不同。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"toLocaleTimeString": {
			"name": "### toLocaleTimeString()",
			"description": "\r\n返回该日期对象时间部分的字符串，该字符串格式因语言而异。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"valueOf": {
			"name": "### valueOf()",
			"description": "\r\n返回从UTC时间1970年1月1日午夜开始以毫秒为单位存储的时间值。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"getTime": {
			"name": "### getTime()",
			"description": "\r\n返回从UTC时间1970年1月1日午夜开始以毫秒为单位存储的时间值。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getFullYear": {
			"name": "### getFullYear()",
			"description": "\r\n根据本地时间返回指定日期的年份。此方法替代 getYear() 。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 根据当地时间，返回一个对应于给定日期的年份数字。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getUTCFullYear": {
			"name": "### getUTCFullYear()",
			"description": "\r\n以世界时为标准，返回一个指定的日期对象的年份。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"getMonth": {
			"name": "### getMonth()",
			"description": "\r\n根据本地时间，返回一个指定的日期对象的月份，为基于 0 的值（0 表示一年中的第一月）。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 一个 0 到 11 的整数值：0 代表一月份，1 代表二月份，2 代表三月份，依次类推。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getUTCMonth": {
			"name": "### getUTCMonth()",
			"description": "\r\n以世界时为标准，返回一个指定的日期对象的月份，它是从 0 开始计数的（0 代表一年的第一个月）。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个 0 到 11 的整数，分别对应以下月份：0 代表一月，1 代表二月，2 代表三月，依次类推。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"getDate": {
			"name": "### getDate()",
			"description": "\r\n根据本地时间，返回一个指定的日期对象为一个月中的哪一日（从 1--31）。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个 1 到 31 的整数值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getUTCDate": {
			"name": "### getUTCDate()",
			"description": "\r\n以世界时为标准，返回一个指定的日期对象为一个月中的第几天",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个 1 到 31 的整数值 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"getDay": {
			"name": "### getDay()",
			"description": "\r\n根据本地时间，返回一个具体日期中一周的第几天，0 表示星期天。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 根据本地时间，返回一个 0 到 6 之间的整数值，代表星期几：0 代表星期日，1 代表星期一，2 代表星期二，依次类推。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getUTCDay": {
			"name": "### getUTCDay()",
			"description": "\r\n以世界时为标准，返回一个指定的日期对象为一星期中的第几天，其中 0 代表星期天。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个对应一星期中第几天的整数：0 代表星期天，1 代表星期一，2 代表星期二，依次类推。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"getHours": {
			"name": "### getHours()",
			"description": "\r\n根据本地时间，返回一个指定的日期对象的小时。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个 0 到 23 之间的整数值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getUTCHours": {
			"name": "### getUTCHours()",
			"description": "\r\n以世界时为标准，返回一个指定的日期对象的小时数。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个 0 到 23 的整数。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"getMinutes": {
			"name": "### getMinutes()",
			"description": "\r\n根据本地时间，返回一个指定的日期对象的分钟数。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个 0 到 59 的整数值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getUTCMinutes": {
			"name": "### getUTCMinutes()",
			"description": "\r\n以世界时为标准，返回一个指定的日期对象的分钟数。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个 0 到 59 的整数。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"getSeconds": {
			"name": "### getSeconds()",
			"description": "\r\n根据本地时间，返回一个指定的日期对象的秒数。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个 0 到 59 的整数值。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getUTCSeconds": {
			"name": "### getUTCSeconds()",
			"description": "\r\n以世界时为标准，返回一个指定的日期对象的秒数。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个 0 到 59 的整数。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"getUTCMilliseconds": {
			"name": "### getUTCMilliseconds()",
			"description": "\r\n以世界时为标准，返回一个指定的日期对象的毫秒数。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回一个 0 到 999 的整数。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"getTimezoneOffset": {
			"name": "### getTimezoneOffset()",
			"description": "\r\n返回协调世界时（UTC）相对于当前时区的时间差值，单位为分钟。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 时区偏差（time-zone offset）表示协调世界时（UTC）与本地时区之间的差值，单位为分钟。需要注意的是如果本地时区后于协调世界时，则该差值为正值，如果先于协调世界时则为负值。例如你所在时区为 UTC+10（澳大利亚东部标准时间），将会返回 -600。对于同一个时区，夏令时（Daylight Saving Time）将会改变这个值。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"setTime": {
			"name": "### setTime(time)",
			"description": "\r\n以一个表示从 1970-1-1 00:00:00 UTC 计时的毫秒数为来为 Date 对象设置时间。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| time | number | 是 | 一个整数，表示从 1970-1-1 00:00:00 UTC 开始计时的毫秒数。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | UTC 1970 年 1 月 1 日 00:00:00 与更新日期之间的毫秒数（实际上是自变量的值）。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"setMilliseconds": {
			"name": "### setMilliseconds(ms)",
			"description": "\r\n根据本地时间设置一个日期对象的豪秒数。如果指定的数字超出了合理范围，则日期对象的时间信息会被相应地更新。例如，如果指定了 1005，则秒数加 1，豪秒数为 5。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| ms | number | 是 | 一个 0 到 999 的数字，表示豪秒数。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回更新后的时间距 1970 年 1 月 1 日 00:00:00 的毫秒数。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"setUTCMilliseconds": {
			"name": "### setUTCMilliseconds(ms)",
			"description": "\r\n根据世界时来设置指定时间的毫秒数。如果传递的参数超出了指定的范围，setUTCMilliseconds() 方法会相应地尝试更新储存在 Date 的时间信息。例如，假设你传递参数的值是 1100，存储在 Date 的秒数会加 1，然后使用 100 来作为毫秒数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| ms | number | 是 | 0 - 999 之间的数值，代表毫秒数。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回更新后的时间距 1970 年 1 月 1 日 00:00:00 (UTC) 的毫秒数。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"setSeconds": {
			"name": "### setSeconds(sec)",
			"description": "\r\n根据本地时间设置一个日期对象的秒数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| sec | number | 是 | 一个 0 到 59 的整数。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"setUTCSeconds": {
			"name": "### setUTCSeconds(sec)",
			"description": "\r\n为一个依据国际通用时间的特定日期设置秒数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| sec | number | 是 | 一个在 0 到 59 之间的整数，表示秒数。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"setMinutes": {
			"name": "### setMinutes(min)",
			"description": "\r\n根据本地时间为一个日期对象设置分钟数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| min | number | 是 | 一个 0 到 59 的整数，表示分钟数。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"setUTCMinutes": {
			"name": "### setUTCMinutes(min)",
			"description": "\r\n根据世界协调时（UTC）来设置指定日期的分钟数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| min | number | 是 | 必填，表示要设置的分钟数，是一个介于 0 和 59 之间的整数。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回从 UTC 时间 1970 年 1 月 1 日 0 时 0 分 0 秒至设置后的时间的毫秒数。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"setHours": {
			"name": "### setHours(hours)",
			"description": "\r\n根据本地时间为一个日期对象设置小时数，返回从 1970-01-01 00:00:00 UTC 到更新后的 日期 对象实例所表示时间的毫秒数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| hours | number | 是 | 必填，一个 0 到 23 的整数，表示小时。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"setUTCHours": {
			"name": "### setUTCHours(hours)",
			"description": "\r\n根据世界协调时（UTC）为一个日期对象设置小时数，返回从 1970-01-01 00:00:00 UTC 到更新后的 日期 对象实例所表示时间的毫秒数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| hours | number | 是 | 必填，表示小时的整数，取值 0 到 23 之间。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回从 1970-01-01 00:00:00 UTC 到更新后的日期所表示时间的毫秒数。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"setDate": {
			"name": "### setDate(date)",
			"description": "\r\n根据本地时间来指定一个日期对象的天数。如果 dayValue 超出了月份的合理范围，setDate 将会相应地更新 Date 对象。例如，如果为 dayValue 指定 0，那么日期就会被设置为上个月的最后一天。如果 dayValue 被设置为负数，日期会设置为上个月最后一天往前数这个负数绝对值天数后的日期。-1 会设置为上月最后一天的前一天（译者注：例如当前为 4 月，如果 setDate(-2),则为 3 月 29 日）",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| date | number | 是 | 一个整数，表示该月的第几天。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"setUTCDate": {
			"name": "### setUTCDate(date)",
			"description": "\r\n根据全球时间设置特定 date 对象的日期。如果你指定的参数超出了范围，setUTCDate() 会尝试更新对应的Date 中的日期信息。例如，如果你使用了 40 来作为参数，但是Date 中存储的月份为 6 月，那么日期将被改写为 10 且月份被增到 7 月。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| date | number | 是 | 一个 1-31 的整形数字，用来指定日期。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"setMonth": {
			"name": "### setMonth(month)",
			"description": "\r\n根据本地时间为一个日期对象设置月份。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| month | number | 是 | 必填参数，介于 0 到 11 之间的整数（表示一月到十二月）。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 基于 1 January 1970 00:00:00 UTC 开始计算的毫秒数。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"setUTCMonth": {
			"name": "### setUTCMonth(month)",
			"description": "\r\n根据通用的时间（ UTC ）来设置一个准确的月份。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| month | number | 是 | 必填参数，一个 0-11 的整数，代表 1 月到 12 月。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 这个数值是从 1970 年 1 月 1 号 00:00:00 到当前时间的毫秒数（国际通用时间） | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"setFullYear": {
			"name": "### setFullYear(year)",
			"description": "\r\n根据本地时间为一个日期对象设置年份。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| year | number | 是 | 指定年份的整数值，例如 1995。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"setUTCFullYear": {
			"name": "### setUTCFullYear(year)",
			"description": "\r\n根据世界标准时间 (UTC) 为一个具体日期设置年份。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| year | number | 是 | 指定年份整数值，例如，1995 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"toUTCString": {
			"name": "### toUTCString()",
			"description": "把一个日期转换为一个字符串，使用 UTC 时区。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"toISOString": {
			"name": "### toISOString()",
			"description": "一个 ISO（ISO 8601 Extended Format）格式的字符串： YYYY-MM-DDTHH:mm:ss.sssZ。时区总是 UTC（协调世界时），加一个后缀“Z”标识。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"toJSON": {
			"name": "### toJSON(key?)",
			"description": "返回 Date 对象的字符串形式。调用 toJSON() 返回一个 JSON 格式字符串 (使用 toISOString())，表示该日期对象的值。默认情况下，这个方法常用于 JSON序列化Date对象。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | any | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"parse": {
			"name": "### parse(s)",
			"description": "\r\n解析一个表示某个日期的字符串，并返回从 1970-1-1 00:00:00 UTC 到该日期对象（该日期对象的 UTC 时间）的毫秒数，如果该字符串无法识别，或者一些情况下，包含了不合法的日期数值（如：2015-02-31），则返回值为 NaN。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| s | string | 是 | 一个符合 RFC2822 或 ISO 8601 日期格式的字符串（其他格式也许也支持，但结果可能与预期不符）。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 一个表示从 1970-1-1 00:00:00 UTC 到给定日期字符串所表示时间的毫秒数的数值。如果参数不能解析为一个有效的日期，则返回NaN。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"UTC": {
			"name": "### UTC(year, monthIndex, date?, hours?, minutes?, seconds?, ms?)",
			"description": "\r\n接受的参数同 Date 构造函数接受最多参数时一样，但该前者会视它们为 UTC 时间，其返回从 1970 年 1 月 1 日 00:00:00 UTC 到指定时间的毫秒数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| year | number | 是 | 一个表示年份的整数值。从 0 到 99 的值会被映射到 1900 至 1999 年。其他的值则代表实际的年份。 |\n| monthIndex | number | 是 | 0（一月）到 11（十二月）之间的一个整数，表示月份。从 ECMAScript 2017 开始，如果忽略该值，则默认为 0。（直到 ECMAScript 2016，month 都是必须的参数。而从 ES2017 开始，它不再是必须的。） |\n| date | number | 否 | 1 到 31 之间的一个整数，表示某月当中的第几天。如果忽略该值，则默认为 1。 |\n| hours | number | 否 | 0 到 23 之间的一个整数，表示小时。如果忽略该值，则默认为 0。 |\n| minutes | number | 否 | 0 到 59 之间的一个整数，表示分钟。如果忽略该值，则默认为 0。 |\n| seconds | number | 否 | 0 到 59 之间的一个整数，表示秒。如果忽略该值，则默认为 0。 |\n| ms | number | 否 | 0 到 999 之间的一个整数，表示毫秒。如果忽略该值，则默认为 0。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 一个数字，表示从 1970 年 1 月 1 日 00:00:00 UTC 到给定时间的毫秒数。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"now": {
			"name": "### now()",
			"description": "\r\n返回自 1970 年 1 月 1 日 00:00:00 (UTC) 到当前时间的毫秒数。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		}
	},
	"RegExp": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.RegExp)",
		"flags": {
			"name": "### flags",
			"description": "\r\n返回一个字符串，由当前正则表达式对象的标志组成。此属性是一个只读属性\r\n此字符串中的字符按以下顺序排序和连接:\r\n\r\n   - \"g\" for global\r\n   - \"i\" for ignoreCase\r\n   - \"m\" for multiline\r\n   - \"u\" for unicode\r\n   - \"y\" for sticky\r\n\r\n如果没有设置标志，则该值为空字符串。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"sticky": {
			"name": "### sticky",
			"description": "\r\n搜索是否具有粘性（仅从正则表达式的 lastIndex 属性表示的索引处搜索）。sticky 是正则表达式对象的只读属性。默认为false。只读的。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "prop"
		},
		"unicode": {
			"name": "### unicode",
			"description": "\r\n表明正则表达式带有\"u\" 标志。 unicode 是正则表达式独立实例的只读属性。unicode 的值是 Boolean，并且如果使用了 \"u\" 标志则为 true；否则为 false。\"u\" 标志开启了多种 Unicode 相关的特性。使用 \"u\" 标志，任何 Unicode 代码点的转义都会被解释。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "prop"
		},
		"source": {
			"name": "### source",
			"description": "\r\n返回一个值为当前正则表达式对象的模式文本的字符串，该字符串不会包含正则字面量两边的斜杠以及任何的标志字符。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"global": {
			"name": "### global",
			"description": "\r\n表明正则表达式是否使用了 \"g\" 标志。global 是一个正则表达式实例的只读属性。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"ignoreCase": {
			"name": "### ignoreCase",
			"description": "\r\n表明正则表达式是否使用了 \"i\" 标志。ignoreCase 是正则表达式实例的只读属性。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"multiline": {
			"name": "### multiline",
			"description": "\r\n表明正则表达式是否使用了 \"m\" 标志。multiline 是正则表达式实例的一个只读属性。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"lastIndex": {
			"name": "### lastIndex",
			"description": "\r\n正则表达式的一个可读可写的整型属性，用来指定下一次匹配的起始索引。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"exec": {
			"name": "### exec(string)",
			"description": "\r\n在一个指定字符串中执行一个搜索匹配。返回一个结果数组或 null。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| string | string | 是 | 要匹配正则表达式的字符串。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| RegExpExecArray \\| null | 如果匹配失败，exec() 方法返回 null，并将正则表达式的 lastIndex 重置为 0。如果匹配成功，exec() 方法返回一个数组，并更新正则表达式对象的 lastIndex 属性。完全匹配成功的文本将作为返回数组的第一项，从第二项起，后续每项都对应一个匹配的捕获组。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"test": {
			"name": "### test(string)",
			"description": "\r\n执行一个检索，用来查看正则表达式与指定的字符串是否匹配。返回 true 或 false。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| string | string | 是 | 用来与正则表达式匹配的字符串。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果正则表达式与指定的字符串匹配，返回true；否则false。如果正则表达式设置了全局标志，test() 的执行会改变正则表达式 lastIndex属性。连续的执行test()方法，后续的执行将会从 lastIndex 处开始匹配字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		}
	},
	"JSON": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.JSON)",
		"parse": {
			"name": "### parse(text, reviver?)",
			"description": "\r\nJSON.parse() 方法用来解析 JSON 字符串，构造由字符串描述的 JavaScript 值或对象。提供可选的 reviver 函数用以在返回之前对所得到的对象执行变换 (操作)。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| text | string | 是 | 要被解析成 JavaScript 值的字符串 |\n| reviver | (this : any, key : string, value : any) => any | 否 | [可选\\] 转换器，如果传入该参数 (函数)，可以用来修改解析生成的原始值，调用时机在 parse 函数返回之前。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| any | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"parse_1": {
			"name": "### parse(text)",
			"description": "\r\nJSON.parse() 方法用来解析 JSON 字符串，构造由字符串描述的值或者对象，其类型由泛型参数T决定\r\n如果输入的是一个合法的json值或者对象，返回一个对应的T值或者对象，如果json描述的值或对象和 T 指定的类型不符，将返回null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| text | string | 是 | 要被解析成 JavaScript 值的字符串 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| T \\| null | 返回一个T类型的值或者对象 或者 null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"parseObject": {
			"name": "### parseObject(text)",
			"description": "\r\nJSON.parseObject() 方法用来解析 JSON 字符串，构造由字符串描述的对象。\r\n如果输入的是一个合法的json对象，返回一个对应的UTSJSONObject，如果是json array 或者其他格式的字符串返回null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| text | string | 是 | 要被解析成 JavaScript 值的字符串 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UTSJSONObject \\| null | 返回一个UTSJSONObjet 或者 null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"parseObject_1": {
			"name": "### parseObject(text)",
			"description": "\r\nJSON.parseObject() 方法用来解析 JSON 字符串，构造由字符串描述的对象，该对象的类型由泛型参数T决定\r\n如果输入的是一个合法的json对象，返回一个对应的T对象，如果是json array 或者其他格式的字符串返回null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| text | string | 是 | 要被解析成 JavaScript 值的字符串 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| T \\| null | 返回一个T类型对象 或者 null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"parseArray": {
			"name": "### parseArray(text)",
			"description": "\r\nJSON.parseArray() 方法用来解析 JSON 字符串，构造由字符串描述的数组。数组元素类型为any\r\n如果输入的是一个合法的json数组，返回一个对应的Array，如果是json object 或者其他格式的字符串返回null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| text | string | 是 | 要被解析成 JavaScript 值的字符串 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Array\\<any> \\| null | 返回一个Array 或者 null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"parseArray_1": {
			"name": "### parseArray(text)",
			"description": "\r\nJSON.parseArray() 方法用来解析 JSON 字符串，构造由字符串描述的数组。数组元素类型由泛型T决定\r\n如果输入的是一个合法的json数组，返回一个对应的Array，如果是json object 或者其他格式的字符串返回null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| text | string | 是 | 要被解析成 JavaScript 值的字符串 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Array\\<T> \\| null | 返回一个Array 或者 null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"stringify": {
			"name": "### stringify(value)",
			"description": "\r\nJSON.stringify() 方法将一个 JavaScript 对象或值转换为 JSON 字符串，如果指定了一个 replacer 函数，则可以选择性地替换值，或者指定的 replacer 是数组，则可选择性地仅包含数组指定的属性",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| value | any \\| null | 是 | 将要序列化成 一个 JSON 字符串的值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | 3.9 | 4.0 |\n",
			"itemType": "method"
		}
	},
	"Array": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.Array)",
		"length": {
			"name": "### length",
			"description": "\r\nlength 是 Array 的实例属性，表示该数组中元素的个数。该值是一个无符号 32 位整数，并且其数值总是大于数组最大索引。",
			"param": "",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"toString": {
			"name": "### toString()",
			"description": "\r\ntoString() 方法返回一个字符串，表示指定的数组及其元素。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"toKotlinList": {
			"name": "### toKotlinList()",
			"description": "\r\ntoKotlinList() 将当前的Array对象转换为 kotlin 中对应的List对象",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| kotlin.collections.List\\<any> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | - |\n",
			"itemType": "method"
		},
		"toLocaleString": {
			"name": "### toLocaleString()",
			"description": "\r\ntoLocaleString() 方法返回一个字符串，表示数组中的所有元素。每个元素通过调用它们自己的 toLocaleString 方法转换为字符串，并且使用特定于语言环境的字符串（例如逗号“,”）分隔开。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"pop": {
			"name": "### pop()",
			"description": "\r\npop() 方法从数组中删除最后一个元素，并返回该元素的值。此方法会更改数组的长度。\r\n",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T \\| null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"push": {
			"name": "### push(...items)",
			"description": "\r\npush() 方法将指定的元素添加到数组的末尾，并返回新的数组长度。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| items | T[\\] | 否 | 添加到数组末尾的元素。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 调用方法的对象的新 length 属性。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"concat": {
			"name": "### concat(...items)",
			"description": "\r\nconcat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。\r\n",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| items | ConcatArray\\<T>[\\] | 否 | 数组和/或值，将被合并到一个新的数组中。如果省略了所有 valueN 参数，则 concat 会返回调用此方法的现存数组的一个浅拷贝。详情请参阅下文描述。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| T[\\] | 新的 Array 实例。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"concat_1": {
			"name": "### concat(...items)",
			"description": "\r\nconcat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| items | (T \\| ConcatArray\\<T>)[\\] | 否 | 数组和/或值，将被合并到一个新的数组中。如果省略了所有 valueN 参数，则 concat 会返回调用此方法的现存数组的一个浅拷贝。详情请参阅下文描述。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| T[\\] | 新的 Array 实例。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"join": {
			"name": "### join(separator?)",
			"description": "\r\njoin() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串，用逗号或指定的分隔符字符串分隔。如果数组只有一个元素，那么将返回该元素而不使用分隔符。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| separator | string | 否 | 指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果省略，数组元素用逗号（,）分隔。如果 separator 是空字符串（\"\"），则所有元素之间都没有任何字符。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个所有数组元素连接的字符串。如果 arr.length 为 0，则返回空字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | - |\n",
			"itemType": "method"
		},
		"reverse": {
			"name": "### reverse()",
			"description": "\r\nreverse() 方法就地反转数组中的元素，并返回同一数组的引用。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。换句话说，数组中的元素顺序将被翻转，变为与之前相反的方向。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| T[\\] | 原始数组反转后的引用。注意，数组是就地反转的，并且没有复制。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"shift": {
			"name": "### shift()",
			"description": "\r\nshift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| T \\| null | 从数组中删除的元素；如果数组为空则返回 null。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"slice": {
			"name": "### slice(start?, end?)",
			"description": "\r\nslice() 方法返回一个新的数组对象，这一对象是一个由 start 和 end 决定的原数组的浅拷贝（包括 start，不包括 end），其中 start 和 end 代表了数组元素的索引。原始数组不会被改变。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| start | number | 否 | 提取起始处的索引（从 0 开始），会转换为整数。 |\n| end | number | 否 | 提取终止处的索引（从 0 开始），会转换为整数。slice() 会提取到但不包括 end 的位置。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T[\\] | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"sort": {
			"name": "### sort(compareFn?)",
			"description": "\r\nsort() 方法就地对数组的元素进行排序，并返回对相同数组的引用。默认排序是将元素转换为字符串，然后按照它们的 UTF-16 码元值升序排序。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| compareFn | (a : T, b : T) => number | 否 | 定义排序顺序的函数。返回值应该是一个数字，其正负性表示两个元素的相对顺序。该函数使用以下参数调用： a:第一个用于比较的元素。不会是 null。 b:第二个用于比较的元素。不会是 null。 如果省略该函数，数组元素会被转换为字符串，然后根据每个字符的 Unicode 码位值进行排序。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| this | 经过排序的原始数组的引用。注意数组是就地排序的，不会进行复制。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"splice": {
			"name": "### splice(start, deleteCount?)",
			"description": "\r\nsplice() 方法通过移除或者替换已存在的元素和/或添加新元素就地改变一个数组的内容。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| start | number | 是 | 从 0 开始计算的索引，表示要开始改变数组的位置，它会被转换成整数。 |\n| deleteCount | number | 否 | 一个整数，表示数组中要从 start 开始删除的元素数量。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| T[\\] | 一个包含了删除的元素的数组。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"splice_1": {
			"name": "### splice(start, deleteCount, ...items)",
			"description": "\r\nsplice() 方法通过移除或者替换已存在的元素和/或添加新元素就地改变一个数组的内容。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| start | number | 是 | 从 0 开始计算的索引，表示要开始改变数组的位置，它会被转换成整数。 |\n| deleteCount | number | 是 | 一个整数，表示数组中要从 start 开始删除的元素数量。 |\n| items | T[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| T[\\] | 一个包含了删除的元素的数组。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"unshift": {
			"name": "### unshift(...items)",
			"description": "\r\nunshift() 方法将指定元素添加到数组的开头，并返回数组的新长度。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| items | T[\\] | 否 | 添加到 arr 开头的元素。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"indexOf": {
			"name": "### indexOf(searchElement, fromIndex?)",
			"description": "\r\nindexOf() 方法返回数组中第一次出现给定元素的下标，如果不存在则返回 -1。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| searchElement | T | 是 | 数组中要查找的元素。 |\n| fromIndex | number | 否 | 开始搜索的索引（从零开始），会转换为整数。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"lastIndexOf": {
			"name": "### lastIndexOf(searchElement, fromIndex?)",
			"description": "\r\nlastIndexOf() 方法返回数组中给定元素最后一次出现的索引，如果不存在则返回 -1。该方法从 fromIndex 开始向前搜索数组。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| searchElement | T | 是 | 被查找的元素。 |\n| fromIndex | number | 否 | 以 0 起始的索引，表明反向搜索的起始位置，会被转换为整数。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"every": {
			"name": "### every(predicate, thisArg?)",
			"description": "\r\nevery() 方法测试一个数组内的所有元素是否都能通过指定函数的测试。它返回一个布尔值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index ?: number, array ?: T[\\]) => value is S | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以指示元素通过测试，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 array:调用了 every() 的数组本身。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| this is S[\\] | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"every_1": {
			"name": "### every(predicate, thisArg?)",
			"description": "\r\nevery() 方法测试一个数组内的所有元素是否都能通过指定函数的测试。它返回一个布尔值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index : number, array : T[\\]) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以指示元素通过测试，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 array:调用了 every() 的数组本身。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| boolean | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"every_2": {
			"name": "### every(predicate, thisArg?)",
			"description": "\r\nevery() 方法测试一个数组内的所有元素是否都能通过指定函数的测试。它返回一个布尔值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index : number) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以指示元素通过测试，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| boolean | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"every_3": {
			"name": "### every(predicate, thisArg?)",
			"description": "\r\nevery() 方法测试一个数组内的所有元素是否都能通过指定函数的测试。它返回一个布尔值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以指示元素通过测试，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| boolean | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"some": {
			"name": "### some(predicate, thisArg?)",
			"description": "\r\nsome() 方法测试数组中是否至少有一个元素通过了由提供的函数实现的测试。如果在数组中找到一个元素使得提供的函数返回 true，则返回 true；否则返回 false。它不会修改数组。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index : number, array : T[\\]) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以指示元素通过测试，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 array:调用了 some() 的数组本身。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果回调函数对数组中至少一个元素返回一个真值，则返回 true。否则返回 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"some_1": {
			"name": "### some(predicate, thisArg?)",
			"description": "\r\nsome() 方法测试数组中是否至少有一个元素通过了由提供的函数实现的测试。如果在数组中找到一个元素使得提供的函数返回 true，则返回 true；否则返回 false。它不会修改数组。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index : number) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以指示元素通过测试，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果回调函数对数组中至少一个元素返回一个真值，则返回 true。否则返回 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"some_2": {
			"name": "### some(predicate, thisArg?)",
			"description": "\r\nsome() 方法测试数组中是否至少有一个元素通过了由提供的函数实现的测试。如果在数组中找到一个元素使得提供的函数返回 true，则返回 true；否则返回 false。它不会修改数组。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以指示元素通过测试，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果回调函数对数组中至少一个元素返回一个真值，则返回 true。否则返回 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"forEach": {
			"name": "### forEach(callbackfn, thisArg?)",
			"description": "\r\nforEach() 方法对数组的每个元素执行一次给定的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : T, index : number, array : T[\\]) => void | 是 | 为数组中每个元素执行的函数。并会丢弃它的返回值。该函数被调用时将传入以下参数： value:数组中正在处理的当前元素。 index:数组中正在处理的当前元素的索引。 array:调用了 forEach() 的数组本身。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"forEach_1": {
			"name": "### forEach(callbackfn, thisArg?)",
			"description": "\r\nforEach() 方法对数组的每个元素执行一次给定的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : T, index : number) => void | 是 | 为数组中每个元素执行的函数。并会丢弃它的返回值。该函数被调用时将传入以下参数： value:数组中正在处理的当前元素。 index:数组中正在处理的当前元素的索引。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"forEach_2": {
			"name": "### forEach(callbackfn, thisArg?)",
			"description": "\r\nforEach() 方法对数组的每个元素执行一次给定的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : T) => void | 是 | 为数组中每个元素执行的函数。并会丢弃它的返回值。该函数被调用时将传入以下参数： value:数组中正在处理的当前元素。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"map": {
			"name": "### map(callbackfn, thisArg?)",
			"description": "\r\nmap() 方法创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : T, index : number, array : T[\\]) => U | 是 | 为数组中的每个元素执行的函数。它的返回值作为一个元素被添加为新数组中。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 array:调用了 map() 的数组本身。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| U[\\] | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"map_1": {
			"name": "### map(callbackfn, thisArg?)",
			"description": "\r\nmap() 方法创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : T, index : number) => U | 是 | 为数组中的每个元素执行的函数。它的返回值作为一个元素被添加为新数组中。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| U[\\] | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"map_2": {
			"name": "### map(callbackfn, thisArg?)",
			"description": "\r\nmap() 方法创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : T) => U | 是 | 为数组中的每个元素执行的函数。它的返回值作为一个元素被添加为新数组中。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| U[\\] | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"filter": {
			"name": "### filter(predicate, thisArg?)",
			"description": "\r\nfilter() 方法创建给定数组一部分的浅拷贝，其包含通过所提供函数实现的测试的所有元素。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index ?: number, array ?: T[\\]) => value is S | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以将元素保留在结果数组中，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 array:调用了 filter() 的数组本身。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| S[\\] | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"filter_1": {
			"name": "### filter(predicate, thisArg?)",
			"description": "\r\nfilter() 方法创建给定数组一部分的浅拷贝，其包含通过所提供函数实现的测试的所有元素。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index : number, array : T[\\]) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以将元素保留在结果数组中，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 array:调用了 filter() 的数组本身。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T[\\] | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"filter_2": {
			"name": "### filter(predicate, thisArg?)",
			"description": "\r\nfilter() 方法创建给定数组一部分的浅拷贝，其包含通过所提供函数实现的测试的所有元素。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index : number) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以将元素保留在结果数组中，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T[\\] | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"filter_3": {
			"name": "### filter(predicate, thisArg?)",
			"description": "\r\nfilter() 方法创建给定数组一部分的浅拷贝，其包含通过所提供函数实现的测试的所有元素。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以将元素保留在结果数组中，否则返回一个假值。该函数被调用时将传入以下参数： value:数组中当前正在处理的元素。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T[\\] | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduce": {
			"name": "### reduce(callbackfn)",
			"description": "\r\nreduce() 方法对数组中的每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T, currentIndex : number, array : T[\\]) => T | 是 | 为数组中每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将作为 reduce() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为 array[0\\] 的值。 currentValue:当前元素的值。在第一次调用时，如果指定了 initialValue，则为 array[0\\] 的值，否则为 array[1\\]。 currentIndex:currentValue 在数组中的索引位置。在第一次调用时，如果指定了 initialValue 则为 0，否则为 1 array:调用了 reduce() 的数组本身。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduce_1": {
			"name": "### reduce(callbackfn)",
			"description": "\r\nreduce() 方法对数组中的每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T, currentIndex : number) => T | 是 | 为数组中每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将作为 reduce() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为 array[0\\] 的值。 currentValue:当前元素的值。在第一次调用时，如果指定了 initialValue，则为 array[0\\] 的值，否则为 array[1\\]。 currentIndex:currentValue 在数组中的索引位置。在第一次调用时，如果指定了 initialValue 则为 0，否则为 1 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduce_2": {
			"name": "### reduce(callbackfn, initialValue)",
			"description": "\r\nreduce() 方法对数组中的每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T, currentIndex : number, array : T[\\]) => T | 是 | 为数组中每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将作为 reduce() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为 array[0\\] 的值。 currentValue:当前元素的值。在第一次调用时，如果指定了 initialValue，则为 array[0\\] 的值，否则为 array[1\\]。 currentIndex:currentValue 在数组中的索引位置。在第一次调用时，如果指定了 initialValue 则为 0，否则为 1 array:调用了 reduce() 的数组本身。 |\n| initialValue | T | 是 | 第一次调用回调时初始化 accumulator 的值。如果指定了 initialValue，则 callbackFn 从数组中的第一个值作为 currentValue 开始执行。如果没有指定 initialValue，则 accumulator 初始化为数组中的第一个值，并且 callbackFn 从数组中的第二个值作为 currentValue 开始执行。在这种情况下，如果数组为空（没有第一个值可以作为 accumulator 返回），则会抛出错误。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduce_3": {
			"name": "### reduce(callbackfn, initialValue)",
			"description": "\r\nreduce() 方法对数组中的每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T, currentIndex : number) => T | 是 | 为数组中每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将作为 reduce() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为 array[0\\] 的值。 currentValue:当前元素的值。在第一次调用时，如果指定了 initialValue，则为 array[0\\] 的值，否则为 array[1\\]。 currentIndex:currentValue 在数组中的索引位置。在第一次调用时，如果指定了 initialValue 则为 0，否则为 1 |\n| initialValue | T | 是 | 第一次调用回调时初始化 accumulator 的值。如果指定了 initialValue，则 callbackFn 从数组中的第一个值作为 currentValue 开始执行。如果没有指定 initialValue，则 accumulator 初始化为数组中的第一个值，并且 callbackFn 从数组中的第二个值作为 currentValue 开始执行。在这种情况下，如果数组为空（没有第一个值可以作为 accumulator 返回），则会抛出错误。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduce_4": {
			"name": "### reduce(callbackfn, initialValue)",
			"description": "\r\nreduce() 方法对数组中的每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T) => T | 是 | 为数组中每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将作为 reduce() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为 array[0\\] 的值。 currentValue:当前元素的值。在第一次调用时，如果指定了 initialValue，则为 array[0\\] 的值，否则为 array[1\\]。 |\n| initialValue | T | 是 | 第一次调用回调时初始化 accumulator 的值。如果指定了 initialValue，则 callbackFn 从数组中的第一个值作为 currentValue 开始执行。如果没有指定 initialValue，则 accumulator 初始化为数组中的第一个值，并且 callbackFn 从数组中的第二个值作为 currentValue 开始执行。在这种情况下，如果数组为空（没有第一个值可以作为 accumulator 返回），则会抛出错误。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduce_5": {
			"name": "### reduce(callbackfn, initialValue)",
			"description": "\r\nreduce() 方法对数组中的每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : U, currentValue : T, currentIndex ?: number, array ?: T[\\]) => U | 是 | 为数组中每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将作为 reduce() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为 array[0\\] 的值。 currentValue:当前元素的值。在第一次调用时，如果指定了 initialValue，则为 array[0\\] 的值，否则为 array[1\\]。 currentIndex:currentValue 在数组中的索引位置。在第一次调用时，如果指定了 initialValue 则为 0，否则为 1 array:调用了 reduce() 的数组本身。 |\n| initialValue | U | 是 | 第一次调用回调时初始化 accumulator 的值。如果指定了 initialValue，则 callbackFn 从数组中的第一个值作为 currentValue 开始执行。如果没有指定 initialValue，则 accumulator 初始化为数组中的第一个值，并且 callbackFn 从数组中的第二个值作为 currentValue 开始执行。在这种情况下，如果数组为空（没有第一个值可以作为 accumulator 返回），则会抛出错误。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| U | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduceRight": {
			"name": "### reduceRight(callbackfn)",
			"description": "\r\nreduceRight() 方法对累加器（accumulator）和数组的每个值（按从右到左的顺序）应用一个函数，并使其成为单个值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T, currentIndex : number, array : T[\\]) => T | 是 | 为数组中的每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将成为 reduceRight() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为数组最后一个元素的值。 currentValue:数组中当前正在处理的元素。 currentIndex:正在处理的元素在数组中的索引。 array:调用了 reduceRight() 的数组本身。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduceRight_1": {
			"name": "### reduceRight(callbackfn)",
			"description": "\r\nreduceRight() 方法对累加器（accumulator）和数组的每个值（按从右到左的顺序）应用一个函数，并使其成为单个值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T, currentIndex : number) => T | 是 | 为数组中的每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将成为 reduceRight() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为数组最后一个元素的值。 currentValue:数组中当前正在处理的元素。 currentIndex:正在处理的元素在数组中的索引。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduceRight_2": {
			"name": "### reduceRight(callbackfn)",
			"description": "\r\nreduceRight() 方法对累加器（accumulator）和数组的每个值（按从右到左的顺序）应用一个函数，并使其成为单个值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T) => T | 是 | 为数组中的每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将成为 reduceRight() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为数组最后一个元素的值。 currentValue:数组中当前正在处理的元素。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduceRight_3": {
			"name": "### reduceRight(callbackfn, initialValue)",
			"description": "\r\nreduceRight() 方法对累加器（accumulator）和数组的每个值（按从右到左的顺序）应用一个函数，并使其成为单个值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T, currentIndex : number, array : T[\\]) => T | 是 | 为数组中的每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将成为 reduceRight() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为数组最后一个元素的值。 currentValue:数组中当前正在处理的元素。 currentIndex:正在处理的元素在数组中的索引。 array:调用了 reduceRight() 的数组本身。 |\n| initialValue | T | 是 | 首次调用 callbackFn 时累加器的值。如果不提供初始值，则将使用数组中的最后一个元素，并在迭代时跳过它。没有初始值的情况下，在空数组上调用 reduceRight() 会产生 TypeError。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduceRight_4": {
			"name": "### reduceRight(callbackfn, initialValue)",
			"description": "\r\nreduceRight() 方法对累加器（accumulator）和数组的每个值（按从右到左的顺序）应用一个函数，并使其成为单个值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T, currentIndex : number) => T | 是 | 为数组中的每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将成为 reduceRight() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为数组最后一个元素的值。 currentValue:数组中当前正在处理的元素。 currentIndex:正在处理的元素在数组中的索引。 |\n| initialValue | T | 是 | 首次调用 callbackFn 时累加器的值。如果不提供初始值，则将使用数组中的最后一个元素，并在迭代时跳过它。没有初始值的情况下，在空数组上调用 reduceRight() 会产生 TypeError。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduceRight_5": {
			"name": "### reduceRight(callbackfn, initialValue)",
			"description": "\r\nreduceRight() 方法对累加器（accumulator）和数组的每个值（按从右到左的顺序）应用一个函数，并使其成为单个值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : T, currentValue : T) => T | 是 | 为数组中的每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将成为 reduceRight() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为数组最后一个元素的值。 currentValue:数组中当前正在处理的元素。 |\n| initialValue | T | 是 | 首次调用 callbackFn 时累加器的值。如果不提供初始值，则将使用数组中的最后一个元素，并在迭代时跳过它。没有初始值的情况下，在空数组上调用 reduceRight() 会产生 TypeError。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| T | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reduceRight_6": {
			"name": "### reduceRight(callbackfn, initialValue)",
			"description": "\r\nreduceRight() 方法对累加器（accumulator）和数组的每个值（按从右到左的顺序）应用一个函数，并使其成为单个值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (previousValue : U, currentValue : T, currentIndex ?: number, array ?: T[\\]) => U | 是 | 为数组中的每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将成为 reduceRight() 的返回值。该函数被调用时将传入以下参数： previousValue:上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为数组最后一个元素的值。 currentValue:数组中当前正在处理的元素。 index:正在处理的元素在数组中的索引。 array:调用了 reduceRight() 的数组本身。 |\n| initialValue | U | 是 | 首次调用 callbackFn 时累加器的值。如果不提供初始值，则将使用数组中的最后一个元素，并在迭代时跳过它。没有初始值的情况下，在空数组上调用 reduceRight() 会产生 TypeError。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| U | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"find": {
			"name": "### find(predicate, thisArg?)",
			"description": "\r\nfind() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 null。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index : number, obj : T[\\]) => value is S | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值来表示已经找到了匹配的元素。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| S \\| null | 数组中第一个满足所提供测试函数的元素的值，否则返回 null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"find_1": {
			"name": "### find(predicate, thisArg?)",
			"description": "\r\nfind() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 null。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index : number) => value is S | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值来表示已经找到了匹配的元素。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| S \\| null | 数组中第一个满足所提供测试函数的元素的值，否则返回 null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"find_2": {
			"name": "### find(predicate, thisArg?)",
			"description": "\r\nfind() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 null。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T) => value is S | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值来表示已经找到了匹配的元素。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| S \\| null | 数组中第一个满足所提供测试函数的元素的值，否则返回 null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"findIndex": {
			"name": "### findIndex(predicate, thisArg?)",
			"description": "\r\nfindIndex() 方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回 -1。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index : number, obj : T[\\]) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以指示已找到匹配元素，否则返回一个假值。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 数组中第一个满足测试条件的元素的索引。否则返回 -1。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"findIndex_1": {
			"name": "### findIndex(predicate, thisArg?)",
			"description": "\r\nfindIndex() 方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回 -1。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T, index : number) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以指示已找到匹配元素，否则返回一个假值。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 数组中第一个满足测试条件的元素的索引。否则返回 -1。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"findIndex_2": {
			"name": "### findIndex(predicate, thisArg?)",
			"description": "\r\nfindIndex() 方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回 -1。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| predicate | (value : T) => unknown | 是 | 为数组中的每个元素执行的函数。它应该返回一个真值以指示已找到匹配元素，否则返回一个假值。 |\n| thisArg | any | 否 | 执行 callbackFn 时用作 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 数组中第一个满足测试条件的元素的索引。否则返回 -1。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"fill": {
			"name": "### fill(value, start?, end?)",
			"description": "\r\nfill() 方法用一个固定值填充一个数组中从起始索引（默认为 0）到终止索引（默认为 array.length）内的全部元素。它返回修改后的数组。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| value | T | 是 | 用来填充数组元素的值。注意所有数组中的元素都将是这个确定的值：如果 value 是个对象，那么数组的每一项都会引用这个元素。 |\n| start | number | 否 | 基于零的索引，从此开始填充，转换为整数。 |\n| end | number | 否 | 基于零的索引，在此结束填充，转换为整数。fill() 填充到但不包含 end 索引。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| this | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"copyWithin": {
			"name": "### copyWithin(target, start?, end?)",
			"description": "\r\ncopyWithin() 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| target | number | 是 | 序列开始替换的目标位置，以 0 为起始的下标表示，且将被转换为整数 |\n| start | number | 否 | 要复制的元素序列的起始位置，以 0 为起始的下标表示，且将被转换为整数 |\n| end | number | 否 | 要复制的元素序列的结束位置，以 0 为起始的下标表示，且将被转换为整数。copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| this | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"includes": {
			"name": "### includes(searchElement, fromIndex?)",
			"description": "\r\nincludes() 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| searchElement | any | 是 | 需要查找的值。 |\n| fromIndex | number | 否 | 可选。开始搜索的索引（从零开始），会转换为整数。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 一个布尔值，如果在数组中（或者在 fromIndex 所指示的数组部分中，如果指定 fromIndex 的话）找到 searchElement 值，则该值为 true。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"isArray": {
			"name": "### isArray(arg)",
			"description": "\r\nArray.isArray() 静态方法用于确定传递的值是否是一个 Array。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| arg | any | 是 | 需要检测的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| arg is any[\\] | 如果 value 是 Array，则为 true；否则为 false。如果 value 是 TypedArray 实例，则总是返回 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		}
	},
	"Map": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.Map)",
		"size": {
			"name": "### size",
			"description": "",
			"param": "",
			"returnValue": "**返回值** \n\nMap 对象的成员数量。",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"clear": {
			"name": "### clear()",
			"description": "\r\n移除 Map 对象中的所有元素。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"delete": {
			"name": "### delete(key)",
			"description": "\r\n用于移除 Map 对象中指定的元素。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | K | 是 | 要从 Map 对象中删除的元素的键。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果 Map 对象中的元素存在并已被移除，则为 true；如果该元素不存在，则为 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"forEach": {
			"name": "### forEach(callbackfn, thisArg?)",
			"description": "\r\n按照插入顺序依次对 Map 中每个键/值对执行一次给定的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : V, key : K, map : Map\\<K, V>) => void | 是 | Map 中每个元素所要执行的函数。它具有如下的参数： value: 每个迭代的值。 key: 每个迭代的键。 map: 正在迭代的 Map。 |\n| thisArg | any | 否 | 在 callbackfn 执行中使用的 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"forEach_1": {
			"name": "### forEach(callbackfn, thisArg?)",
			"description": "\r\n按照插入顺序依次对 Map 中每个键/值对执行一次给定的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : V, key : K) => void | 是 | Map 中每个元素所要执行的函数。它具有如下的参数： value: 每个迭代的值。 key: 每个迭代的键。 |\n| thisArg | any | 否 | 在 callbackfn 执行中使用的 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"forEach_2": {
			"name": "### forEach(callbackfn, thisArg?)",
			"description": "\r\n按照插入顺序依次对 Map 中每个键/值对执行一次给定的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : V) => void | 是 | Map 中每个元素所要执行的函数。它具有如下的参数： value: 每个迭代的值。 |\n| thisArg | any | 否 | 在 callbackfn 执行中使用的 this 的值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"get": {
			"name": "### get(key)",
			"description": "\r\n从 Map 对象返回指定的元素。如果与所提供的键相关联的值是一个对象，那么你将获得该对象的引用，对该对象所做的任何更改都会有效地在 Map 对象中修改它。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | K | 是 | 从 Map 对象返回的元素的键。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| V \\| null | 与指定键相关联的元素，如果键在 Map 对象中找不到，则返回 null。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"has": {
			"name": "### has(key)",
			"description": "\r\n返回一个布尔值，指示具有指定键的元素是否存在。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | K | 是 | 用于测试 Map 对象中是否存在的元素的键。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果 Map 对象中存在具有指定键的元素，则返回 true；否则返回 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"set": {
			"name": "### set(key, value)",
			"description": "\r\n为 Map 对象添加或更新一个指定了键（key）和值（value）的（新）键值对。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | K | 是 | 要添加到 Map 对象的元素的键。该值可以是任何数据类型（任何原始值或任何类型的对象）。 |\n| value | V | 是 | 要添加到 Map 对象的元素的值。该值可以是任何数据类型（任何原始值或任何类型的对象）。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| this | Map 对象 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		}
	},
	"Set": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.Set)",
		"size": {
			"name": "### size",
			"description": "\r\n返回 Set 对象中（唯一的）元素的个数。",
			"param": "",
			"returnValue": "**返回值** \n\n返回 Set 对象中（唯一的）元素的个数。",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "prop"
		},
		"add": {
			"name": "### add(value)",
			"description": "\r\n如果 Set 对象中没有具有相同值的元素，则 add() 方法将插入一个具有指定值的新元素到 Set 对象中。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| value | T | 是 | 要添加到 Set 对象的元素的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| this | Set 对象本身。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"clear": {
			"name": "### clear()",
			"description": "\r\n移除 Set 对象中所有元素。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"delete": {
			"name": "### delete(value)",
			"description": "\r\n从 Set 对象中删除指定的值（如果该值在 Set 中）。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| value | T | 是 | 要从 Set 中移除的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 成功删除返回 true，否则返回 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | 3.9 | 4.0 |\n",
			"itemType": "method"
		},
		"forEach": {
			"name": "### forEach(callbackfn, thisArg?)",
			"description": "\r\n对 Set 对象中的每个值按插入顺序执行一次提供的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : T, value2 : T, set : Set\\<T>) => void | 是 | 为集合中每个元素执行的回调函数，该函数接收三个参数：value、key: Set 中正在处理的当前元素。因为 Set 中没有键，所以 value 会被共同传递给这两个参数。set: 调用 forEach() 的 Set 对象。 |\n| thisArg | any | 否 | 值在执行 callbackFn 时作为 this 使用。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"forEach_1": {
			"name": "### forEach(callbackfn, thisArg?)",
			"description": "\r\n对 Set 对象中的每个值按插入顺序执行一次提供的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : T, value2 : T) => void | 是 | 为集合中每个元素执行的回调函数，该函数接收两个参数：value、key。 |\n| thisArg | any | 否 | 值在执行 callbackFn 时作为 this 使用。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"forEach_2": {
			"name": "### forEach(callbackfn, thisArg?)",
			"description": "\r\n对 Set 对象中的每个值按插入顺序执行一次提供的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callbackfn | (value : T) => void | 是 | 为集合中每个元素执行的回调函数，该函数接收一个参数：value。 |\n| thisArg | any | 否 | 值在执行 callbackFn 时作为 this 使用。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"has": {
			"name": "### has(value)",
			"description": "\r\n返回一个布尔值来指示对应的值是否存在于 Set 对象中。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| value | T | 是 | 要测试是否存在于 Set 对象中的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果 Set 对象中存在具有指定值的元素，则返回 true；否则返回 false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		}
	},
	"Promise": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.Promise)",
		"Constructor": {
			"name": "### Constructor(fn)",
			"description": "\r\n创建一个新的 Promise 对象。该构造函数主要用于封装还没有添加 promise 支持的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| fn | (   resolve: (value: T) => void,   reject: (reason: any \\| null) => void ) => void | 是 | 在构造函数中执行的 function。 |",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"Constructor_1": {
			"name": "### Constructor(fn)",
			"description": "\r\n创建一个新的 Promise 对象。该构造函数主要用于封装还没有添加 promise 支持的函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| fn | (resolve: (value: T) => void) => void | 是 | 在构造函数中执行的 function。 |",
			"returnValue": "",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"then": {
			"name": "### then()",
			"description": "\r\n将一个兑现处理器和拒绝处理器附加到 Promise 上，并返回一个新的 Promise，解决为调用处理器得到的返回值，或者如果 Promise 没有被处理（即相关处理器 onFulfilled 或 onRejected 不是函数），则以原始敲定值解决。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<T> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"then_1": {
			"name": "### then(onFulfilled, onRejected?)",
			"description": "\r\n将一个兑现处理器和拒绝处理器附加到 Promise 上，并返回一个新的 Promise，解决为调用处理器得到的返回值，或者如果 Promise 没有被处理（即相关处理器 onFulfilled 或 onRejected 不是函数），则以原始敲定值解决。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| onFulfilled | () => R | 是 | 一个在此 Promise 对象被兑现时异步执行的函数。它的返回值将成为 then() 返回的 Promise 对象的兑现值。 |\n| onRejected | Function \\| null | 否 | 一个在此 Promise 对象被拒绝时异步执行的函数。它的返回值将成为 catch() 返回的 Promise 对象的兑现值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<R> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"then_2": {
			"name": "### then(onFulfilled, onRejected?)",
			"description": "\r\n将一个兑现处理器和拒绝处理器附加到 Promise 上，并返回一个新的 Promise，解决为调用处理器得到的返回值，或者如果 Promise 没有被处理（即相关处理器 onFulfilled 或 onRejected 不是函数），则以原始敲定值解决。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| onFulfilled | () => Promise\\<R> | 是 | 一个在此 Promise 对象被兑现时异步执行的函数。它的返回值将成为 then() 返回的 Promise 对象的兑现值。 |\n| onRejected | Function \\| null | 否 | 一个在此 Promise 对象被拒绝时异步执行的函数。它的返回值将成为 catch() 返回的 Promise 对象的兑现值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<R> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"then_3": {
			"name": "### then(onFulfilled, onRejected?)",
			"description": "\r\n将一个兑现处理器和拒绝处理器附加到 Promise 上，并返回一个新的 Promise，解决为调用处理器得到的返回值，或者如果 Promise 没有被处理（即相关处理器 onFulfilled 或 onRejected 不是函数），则以原始敲定值解决。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| onFulfilled | (res: T) => R | 是 | 一个在此 Promise 对象被兑现时异步执行的函数。它的返回值将成为 then() 返回的 Promise 对象的兑现值。 |\n| onRejected | Function \\| null | 否 | 一个在此 Promise 对象被拒绝时异步执行的函数。它的返回值将成为 catch() 返回的 Promise 对象的兑现值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<R> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"then_4": {
			"name": "### then(onFulfilled, onRejected?)",
			"description": "\r\n将一个兑现处理器和拒绝处理器附加到 Promise 上，并返回一个新的 Promise，解决为调用处理器得到的返回值，或者如果 Promise 没有被处理（即相关处理器 onFulfilled 或 onRejected 不是函数），则以原始敲定值解决。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| onFulfilled | (res: T) => Promise\\<R> | 是 | 一个在此 Promise 对象被兑现时异步执行的函数。它的返回值将成为 then() 返回的 Promise 对象的兑现值。 |\n| onRejected | Function \\| null | 否 | 一个在此 Promise 对象被拒绝时异步执行的函数。它的返回值将成为 catch() 返回的 Promise 对象的兑现值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<R> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"catch": {
			"name": "### catch()",
			"description": "\r\n将一个拒绝处理回调函数附加到 Promise 上，并返回一个新的 Promise，如果回调被调用，则解决为回调的返回值，如果 Promise 被兑现，解决为其原始兑现值。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<T> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"catch_1": {
			"name": "### catch(onRejected)",
			"description": "\r\n将一个拒绝处理回调函数附加到 Promise 上，并返回一个新的 Promise，如果回调被调用，则解决为回调的返回值，如果 Promise 被兑现，解决为其原始兑现值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| onRejected | () => R | 是 | 一个在此 Promise 对象被拒绝时异步执行的函数。它的返回值将成为 catch() 返回的 Promise 对象的兑现值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<R> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"catch_2": {
			"name": "### catch(onRejected)",
			"description": "\r\n将一个拒绝处理回调函数附加到 Promise 上，并返回一个新的 Promise，如果回调被调用，则解决为回调的返回值，如果 Promise 被兑现，解决为其原始兑现值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| onRejected | () => Promise\\<R> | 是 | 一个在此 Promise 对象被拒绝时异步执行的函数。它的返回值将成为 catch() 返回的 Promise 对象的兑现值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<R> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"catch_3": {
			"name": "### catch(onRejected)",
			"description": "\r\n将一个拒绝处理回调函数附加到 Promise 上，并返回一个新的 Promise，如果回调被调用，则解决为回调的返回值，如果 Promise 被兑现，解决为其原始兑现值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| onRejected | (res: any \\| null) => R | 是 | 一个在此 Promise 对象被拒绝时异步执行的函数。它的返回值将成为 catch() 返回的 Promise 对象的兑现值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<R> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"catch_4": {
			"name": "### catch(onRejected)",
			"description": "\r\n将一个拒绝处理回调函数附加到 Promise 上，并返回一个新的 Promise，如果回调被调用，则解决为回调的返回值，如果 Promise 被兑现，解决为其原始兑现值。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| onRejected | (res: any \\| null) => Promise\\<R> | 是 | 一个在此 Promise 对象被拒绝时异步执行的函数。它的返回值将成为 catch() 返回的 Promise 对象的兑现值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<R> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"finally": {
			"name": "### finally(callback)",
			"description": "\r\n将一个处理器附加到 Promise 上，并返回一个新的 Promise，当原始 Promise 被解决时解决。无论 Promise 是否被兑现还是被拒绝，处理器都会在 Promise 敲定时被调用。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | Function | 是 | 一个当 promise 敲定时异步执行的函数。它的返回值将被忽略，除非返回一个被拒绝的 promise。调用该函数时不带任何参数。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<T> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"resolve": {
			"name": "### resolve()",
			"description": "\r\n返回一个新的 Promise 对象，该对象以给定的值兑现。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<void> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"resolve_1": {
			"name": "### resolve(value)",
			"description": "\r\n返回一个新的 Promise 对象，该对象以给定的值兑现。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| value | T \\| null | 是 | 一个兑现的值。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<T> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"resolve_2": {
			"name": "### resolve(value)",
			"description": "\r\n返回一个新的 Promise 对象，该对象以给定的值兑现。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| value | Promise\\<T> \\| null | 是 | 一个 Promise。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<T> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"reject": {
			"name": "### reject(value?)",
			"description": "\r\n返回一个新的 Promise 对象，该对象以给定的原因拒绝。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| value | any \\| null | 否 | 一个拒绝的原因。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<never> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"all": {
			"name": "### all(arr)",
			"description": "\r\n接受一个 Promise 可迭代对象作为输入，并返回单个 Promise。返回的 Promise 在所有输入的 Promise 都兑现时（包括传入的可迭代对象为空时）被兑现，其值为一个包含所有兑现值的数组。如果输入的任何 Promise 被拒绝，返回的 Promise 也会被拒绝，并返回第一个拒绝的原因。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| arr | Array\\<Promise\\<T>> | 是 | 一个 Promise 数组。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<Array\\<T>> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"race": {
			"name": "### race(arr)",
			"description": "\r\n接受一个 Promise 可迭代对象作为输入，并返回单个 Promise。返回的 Promise 与第一个敲定的 Promise 的最终状态保持一致。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| arr | Array\\<Promise\\<T>> | 是 | 一个 Promise 数组。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<T> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"any": {
			"name": "### any(arr)",
			"description": "\r\n接受一个 Promise 可迭代对象作为输入，并返回单个 Promise。返回的 Promise 在任何输入的 Promise 兑现时兑现，其值为第一个兑现的值。如果所有输入的 Promise 都被拒绝（包括传入的可迭代对象为空时），返回的 Promise 将以带有一个包含拒绝原因的数组的 AggregateError 拒绝。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| arr | Array\\<Promise\\<T>> | 是 | 一个 Promise 数组。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<T> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"allSettled": {
			"name": "### allSettled(arr)",
			"description": "\r\n接受一个 Promise 可迭代对象作为输入，并返回单个 Promise。返回的 Promise 在所有输入的 Promise 都敲定时兑现（包括传入的可迭代对象为空时），其值为一个描述每个 Promise 结果的对象数组。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| arr | Array\\<Promise\\<T>> | 是 | 一个 Promise 数组。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| Promise\\<Array\\<PromiseSettledResult\\<T>>> | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		}
	},
	"UTSJSONObject": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.UTSJSONObject)",
		"get": {
			"name": "### get(key)",
			"description": "\r\n获取一个 属性，返回类型是any 或者 null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | string | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| any\\|null | 如果属性存在返回结果，不存在返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"set": {
			"name": "### set(key, value)",
			"description": "\r\n获取一个 属性，返回类型是any 或者 null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | string | 是 | - |\n| value | any | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| void | 如果属性存在返回结果，不存在返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getAny": {
			"name": "### getAny(key)",
			"description": "\r\n获取一个 属性，返回类型是any 或者 null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | string | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| any\\|null | 如果属性存在返回结果，不存在返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getBoolean": {
			"name": "### getBoolean(key)",
			"description": "\r\n获取一个Boolean属性，返回类型是Boolean 或者 null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | string | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean\\|null | 如果属性名存在，且类型为Boolean返回对应的结果，不存在返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getNumber": {
			"name": "### getNumber(key)",
			"description": "\r\n获取一个number属性，返回类型是number 或者 null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | string | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number\\|null | 如果属性名存在，且类型为number返回对应的结果，不存在返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getString": {
			"name": "### getString(key)",
			"description": "\r\n获取一个string属性，返回类型是string 或者 null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | string | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string\\|null | 如果属性名存在，且类型为string返回对应的结果，不存在返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getJSON": {
			"name": "### getJSON(key)",
			"description": "\r\n获取一个UTSJSONObject属性，返回类型是UTSJSONObject 或者 null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | string | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UTSJSONObject\\|null | 如果属性名存在，且类型为UTSJSONObject返回对应的结果，不存在返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getArray": {
			"name": "### getArray(key)",
			"description": "\r\n获取一个Array属性，返回类型是Array 或者 null, 数组元素类型由泛型T决定",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | string | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Array\\<T>\\|null | 如果属性名存在，且类型为Array返回对应的结果，不存在返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"getArray_1": {
			"name": "### getArray(key)",
			"description": "\r\n获取一个Array属性，返回类型是Array 或者 null",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| key | string | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Array\\<any>\\|null | 如果属性名存在，且类型为Array返回对应的结果，不存在返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"toMap": {
			"name": "### toMap()",
			"description": "\r\n将当前 UTSJSONObject 实例转换为 Map 实例。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Map\\<string, any> | 返回 Map\\<string, any> 类型的 map | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		}
	},
	"Console": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.buildInObject.Console)",
		"assert": {
			"name": "### assert(condition?, ...data)",
			"description": "\r\n如果断言为 false，则将一个错误消息写入控制台。如果断言是 true，没有任何反应。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| condition | boolean | 否 | - |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"clear": {
			"name": "### clear()",
			"description": "\r\nconsole.clear() 方法清空控制台，但前提是该控制台允许清空。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"count": {
			"name": "### count(label?)",
			"description": "\r\nconsole.count() 方法会记录调用 count() 的次数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| label | string | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"countReset": {
			"name": "### countReset(label?)",
			"description": "\r\n重置计数器。此函数有一个可选参数 label。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| label | string | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"debug": {
			"name": "### debug(...data)",
			"description": "\r\n在控制台打印 debug 日志",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"dir": {
			"name": "### dir(item?, options?)",
			"description": "\r\nconsole.dir() 方法可以显示指定 JavaScript 对象的属性列表，并以交互式的形式展现。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| item | any \\| null | 否 | - |\n| options | any \\| null | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"dirxml": {
			"name": "### dirxml(...data)",
			"description": "\r\n显示一个明确的 XML/HTML 元素的包括所有后代元素的交互树。\r\n非标准: 该特性是非标准的，请尽量不要在生产环境中使用它！",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"error": {
			"name": "### error(...data)",
			"description": "\r\n在控制台打印 error 日志",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"group": {
			"name": "### group(...data)",
			"description": "\r\nconsole.group() 方法在控制台上创建一个新的分组。随后输出到控制台上的内容都会被添加一个缩进，表示该内容属于当前分组，直到调用 console.groupEnd() 之后，当前分组结束。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"groupCollapsed": {
			"name": "### groupCollapsed(...data)",
			"description": "\r\nconsole.groupCollapsed() 方法在控制台上创建一个新的分组。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"groupEnd": {
			"name": "### groupEnd()",
			"description": "\r\n在控制台中退出一格缩进 (结束分组).",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"info": {
			"name": "### info(...data)",
			"description": "\r\n在控制台打印 info 日志",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"log": {
			"name": "### log(...data)",
			"description": "\r\n在控制台打印 log 日志",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		},
		"table": {
			"name": "### table(tabularData?, properties?)",
			"description": "\r\n将数据以表格的形式显示。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| tabularData | any \\| null | 否 | - |\n| properties | string[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"time": {
			"name": "### time(label?)",
			"description": "\r\n你可以启动一个计时器来跟踪某一个操作的占用时长。每一个计时器必须拥有唯一的名字，页面中最多能同时运行 10,000 个计时器。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| label | string | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"timeEnd": {
			"name": "### timeEnd(label?)",
			"description": "\r\n停止一个通过 console.time() 启动的计时器\r\n非标准: 该特性是非标准的，请尽量不要在生产环境中使用它！",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| label | string | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"timeLog": {
			"name": "### timeLog(label?, ...data)",
			"description": "\r\n在控制台输出计时器的值，该计时器必须已经通过 console.time() 启动。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| label | string | 否 | - |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"timeStamp": {
			"name": "### timeStamp(label?)",
			"description": "\r\n非标准: 该特性是非标准的，请尽量不要在生产环境中使用它！",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| label | string | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"trace": {
			"name": "### trace(...data)",
			"description": "\r\n向控制台 输出一个堆栈跟踪。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method"
		},
		"warn": {
			"name": "### warn(...data)",
			"description": "\r\n在控制台打印 warn 日志",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| data | (any \\| null)[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method"
		}
	},
	"Global": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods)",
		"eval": {
			"name": "### eval(x)",
			"description": "\r\neval() 函数会将传入的字符串当做 JavaScript 代码进行执行。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | string | 是 | 一个表示 JavaScript 表达式、语句或一系列语句的字符串。表达式可以包含变量与已存在对象的属性。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| any | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.eval)"
		},
		"parseInt": {
			"name": "### parseInt(string, radix?)",
			"description": "\r\nparseInt(string, radix) 解析一个字符串并返回指定基数的十进制整数，radix 是 2-36 之间的整数，表示被解析字符串的基数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| string | string | 是 | 要被解析的值。字符串开头的空白符将会被忽略。（注意：只接收字符串类型的参数，其他类型将编译报错。） |\n| radix | number | 否 | 从 2 到 36 的整数，表示进制的基数。例如指定 16 表示被解析值是十六进制数。如果超出这个范围，将返回 NaN。假如指定 0 或未指定，基数将会根据字符串的值进行推算。注意，推算的结果不会永远是默认值 10！ |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 从给定的字符串中解析出的一个整数，或者 NaN。当radix 小于 2 或大于 36，或第一个非空格字符不能转换为数字时返回 NAN。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.parseInt)"
		},
		"parseFloat": {
			"name": "### parseFloat(string)",
			"description": "\r\nparseFloat() 函数解析一个参数（直接收字符串类型的参数，其他类型编译报错）并返回一个浮点数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| string | string | 是 | 需要被解析成为浮点数的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 给定值被解析成浮点数。如果给定值不能被转换成数值，则会返回 NaN。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.parseFloat)"
		},
		"isNaN": {
			"name": "### isNaN(number)",
			"description": "\r\nisNaN() 函数用来确定一个值是否为NaN 。注：isNaN函数内包含一些非常有趣的规则；你也可以使用 ECMAScript 2015 中定义的 Number.isNaN() 来判断。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| number | number | 是 | 要被检测的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果给定值为 NaN则返回值为true；否则为false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.isNaN)"
		},
		"isFinite": {
			"name": "### isFinite(number)",
			"description": "\r\nisFinite() 函数用来判断被传入的参数值是否为一个有限数值（finite number）。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| number | number | 是 | 要被检测的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果参数是 NaN，正无穷大或者负无穷大，会返回false，其他返回 true。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.isFinite)"
		},
		"decodeURI": {
			"name": "### decodeURI(encodedURI)",
			"description": "\r\ndecodeURI() 函数能解码由encodeURI 创建或其他流程得到的统一资源标识符（URI）。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| encodedURI | string | 是 | 一个完整的编码过的 URI |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 返回一个给定编码统一资源标识符 (URI) 的未编码版本的新字符串, 当 encodedURI 包含无效字符序列时，会返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.91 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.decodeURI)"
		},
		"decodeURIComponent": {
			"name": "### decodeURIComponent(encodedURIComponent)",
			"description": "\r\ndecodeURIComponent() 方法用于解码由 encodeURIComponent 方法或者其他类似方法编码的部分统一资源标识符（URI）。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| encodedURIComponent | string | 是 | 编码后的部分 URI |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个解码后的统一资源标识符（URI）字符串，处理前的 URI 经过了给定格式的编码。当 encodedURI 包含无效字符序列时，会返回null. | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.91 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.decodeURIComponent)"
		},
		"encodeURI": {
			"name": "### encodeURI(uri)",
			"description": "\r\nencodeURI() 函数通过将特定字符的每个实例替换为一个、两个、三或四转义序列来对统一资源标识符 (URI) 进行编码 (该字符的 UTF-8 编码仅为四转义序列) 由两个 \"代理\" 字符组成)。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| uri | string | 是 | 一个完整的 URI。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个新字符串，表示提供的字符串编码为统一资源标识符 (URI)。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.91 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.encodeURI)"
		},
		"encodeURIComponent": {
			"name": "### encodeURIComponent(uriComponent)",
			"description": "\r\nencodeURIComponent() 函数通过将特定字符的每个实例替换成代表字符的 UTF-8 编码的一个、两个、三个或四个转义序列来编码 URI（只有由两个“代理”字符组成的字符会被编码为四个转义序列）。与 encodeURI() 相比，此函数会编码更多的字符，包括 URI 语法的一部分。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| uriComponent | string | 是 | 要被检测的 string 值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 原字串作为 URI 组成部分被被编码后的新字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.91 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.encodeURIComponent)"
		},
		"setInterval": {
			"name": "### setInterval(handler, timeout?, ...arguments)",
			"description": "\r\nsetInterval() 方法重复调用一个函数或执行一个代码片段，在每次调用之间具有固定的时间间隔。\r\n它返回一个 interval ID，该 ID 唯一地标识时间间隔，因此你可以稍后通过调用 clearInterval() 来移除定时器。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| handler | string \\| Function | 是 | - |\n| timeout | number | 否 | - |\n| arguments | any[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.setInterval)"
		},
		"setTimeout": {
			"name": "### setTimeout(handler, timeout?, ...arguments)",
			"description": "\r\n全局的 setTimeout() 方法设置一个定时器，一旦定时器到期，就会执行一个函数或指定的代码片段。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| handler | string \\| Function | 是 | - |\n| timeout | number | 否 | - |\n| arguments | any[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.setTimeout)"
		},
		"clearInterval": {
			"name": "### clearInterval(id)",
			"description": "\r\nclearInterval() 方法可取消先前通过 setInterval() 设置的重复定时任务。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| id | number \\| undefined | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.clearInterval)"
		},
		"clearTimeout": {
			"name": "### clearTimeout(id)",
			"description": "\r\nclearTimeout() 方法取消了先前通过调用setTimeout()建立的定时器",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| id | number \\| undefined | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.globleMethods.clearTimeout)"
		}
	},
	"Timers": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods)",
		"eval": {
			"name": "### eval(x)",
			"description": "\r\neval() 函数会将传入的字符串当做 JavaScript 代码进行执行。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| x | string | 是 | 一个表示 JavaScript 表达式、语句或一系列语句的字符串。表达式可以包含变量与已存在对象的属性。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| any | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.eval)"
		},
		"parseInt": {
			"name": "### parseInt(string, radix?)",
			"description": "\r\nparseInt(string, radix) 解析一个字符串并返回指定基数的十进制整数，radix 是 2-36 之间的整数，表示被解析字符串的基数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| string | string | 是 | 要被解析的值。字符串开头的空白符将会被忽略。（注意：只接收字符串类型的参数，其他类型将编译报错。） |\n| radix | number | 否 | 从 2 到 36 的整数，表示进制的基数。例如指定 16 表示被解析值是十六进制数。如果超出这个范围，将返回 NaN。假如指定 0 或未指定，基数将会根据字符串的值进行推算。注意，推算的结果不会永远是默认值 10！ |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 从给定的字符串中解析出的一个整数，或者 NaN。当radix 小于 2 或大于 36，或第一个非空格字符不能转换为数字时返回 NAN。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.parseInt)"
		},
		"parseFloat": {
			"name": "### parseFloat(string)",
			"description": "\r\nparseFloat() 函数解析一个参数（直接收字符串类型的参数，其他类型编译报错）并返回一个浮点数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| string | string | 是 | 需要被解析成为浮点数的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 给定值被解析成浮点数。如果给定值不能被转换成数值，则会返回 NaN。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.parseFloat)"
		},
		"isNaN": {
			"name": "### isNaN(number)",
			"description": "\r\nisNaN() 函数用来确定一个值是否为NaN 。注：isNaN函数内包含一些非常有趣的规则；你也可以使用 ECMAScript 2015 中定义的 Number.isNaN() 来判断。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| number | number | 是 | 要被检测的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果给定值为 NaN则返回值为true；否则为false。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.isNaN)"
		},
		"isFinite": {
			"name": "### isFinite(number)",
			"description": "\r\nisFinite() 函数用来判断被传入的参数值是否为一个有限数值（finite number）。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| number | number | 是 | 要被检测的值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果参数是 NaN，正无穷大或者负无穷大，会返回false，其他返回 true。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.isFinite)"
		},
		"decodeURI": {
			"name": "### decodeURI(encodedURI)",
			"description": "\r\ndecodeURI() 函数能解码由encodeURI 创建或其他流程得到的统一资源标识符（URI）。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| encodedURI | string | 是 | 一个完整的编码过的 URI |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 返回一个给定编码统一资源标识符 (URI) 的未编码版本的新字符串, 当 encodedURI 包含无效字符序列时，会返回null | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.91 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.decodeURI)"
		},
		"decodeURIComponent": {
			"name": "### decodeURIComponent(encodedURIComponent)",
			"description": "\r\ndecodeURIComponent() 方法用于解码由 encodeURIComponent 方法或者其他类似方法编码的部分统一资源标识符（URI）。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| encodedURIComponent | string | 是 | 编码后的部分 URI |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个解码后的统一资源标识符（URI）字符串，处理前的 URI 经过了给定格式的编码。当 encodedURI 包含无效字符序列时，会返回null. | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.91 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.decodeURIComponent)"
		},
		"encodeURI": {
			"name": "### encodeURI(uri)",
			"description": "\r\nencodeURI() 函数通过将特定字符的每个实例替换为一个、两个、三或四转义序列来对统一资源标识符 (URI) 进行编码 (该字符的 UTF-8 编码仅为四转义序列) 由两个 \"代理\" 字符组成)。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| uri | string | 是 | 一个完整的 URI。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 一个新字符串，表示提供的字符串编码为统一资源标识符 (URI)。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.91 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.encodeURI)"
		},
		"encodeURIComponent": {
			"name": "### encodeURIComponent(uriComponent)",
			"description": "\r\nencodeURIComponent() 函数通过将特定字符的每个实例替换成代表字符的 UTF-8 编码的一个、两个、三个或四个转义序列来编码 URI（只有由两个“代理”字符组成的字符会被编码为四个转义序列）。与 encodeURI() 相比，此函数会编码更多的字符，包括 URI 语法的一部分。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| uriComponent | string | 是 | 要被检测的 string 值。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 原字串作为 URI 组成部分被被编码后的新字符串。 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.91 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.encodeURIComponent)"
		},
		"setInterval": {
			"name": "### setInterval(handler, timeout?, ...arguments)",
			"description": "\r\nsetInterval() 方法重复调用一个函数或执行一个代码片段，在每次调用之间具有固定的时间间隔。\r\n它返回一个 interval ID，该 ID 唯一地标识时间间隔，因此你可以稍后通过调用 clearInterval() 来移除定时器。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| handler | string \\| Function | 是 | - |\n| timeout | number | 否 | - |\n| arguments | any[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.setInterval)"
		},
		"setTimeout": {
			"name": "### setTimeout(handler, timeout?, ...arguments)",
			"description": "\r\n全局的 setTimeout() 方法设置一个定时器，一旦定时器到期，就会执行一个函数或指定的代码片段。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| handler | string \\| Function | 是 | - |\n| timeout | number | 否 | - |\n| arguments | any[\\] | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| number | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.setTimeout)"
		},
		"clearInterval": {
			"name": "### clearInterval(id)",
			"description": "\r\nclearInterval() 方法可取消先前通过 setInterval() 设置的重复定时任务。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| id | number \\| undefined | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.clearInterval)"
		},
		"clearTimeout": {
			"name": "### clearTimeout(id)",
			"description": "\r\nclearTimeout() 方法取消了先前通过调用setTimeout()建立的定时器",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| id | number \\| undefined | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | 4.0 |\n",
			"itemType": "method",
			"tutorial": "\n**参见** \n\n [相关 Bug](https://issues.dcloud.net.cn/?mid=uts.timerMethods.clearTimeout)"
		}
	},
	"UTSAndroid": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.platformObject.UTSAndroid)",
		"onAppConfigChange": {
			"name": "### onAppConfigChange(callback)",
			"description": "\r\n监听 App配置发生变化, 对应 android原生 onAppConfigChange",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | (res:UTSJSONObject)=>void | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"offAppConfigChange": {
			"name": "### offAppConfigChange(callback?)",
			"description": "\r\nonAppConfigChange 对应的反注册函数",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | (res:UTSJSONObject)=>void | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"onAppTrimMemory": {
			"name": "### onAppTrimMemory(callback?)",
			"description": "\r\n注册监听 App 内存不足时的系统回调函数 对应原生的API: onTrimMemory",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | (res:Number)=>void | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"offAppTrimMemory": {
			"name": "### offAppTrimMemory(callback?)",
			"description": "\r\nonAppTrimMemory 对应的反注册函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | (res:Number)=>void | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"onAppActivityPause": {
			"name": "### onAppActivityPause(callback)",
			"description": "\r\n注册监听 activity onPause事件",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | ()=>void | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"offAppActivityPause": {
			"name": "### offAppActivityPause(callback?)",
			"description": "\r\nonAppActivityPause 对应的反注册函数",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | ()=>void | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"onAppActivityResume": {
			"name": "### onAppActivityResume(callback)",
			"description": "\r\n注册监听 activity onResume事件",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | ()=>void | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"offAppActivityResume": {
			"name": "### offAppActivityResume(callback?)",
			"description": "\r\nonAppActivityResume 对应的反注册函数",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | ()=>void | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"onAppActivityDestroy": {
			"name": "### onAppActivityDestroy(callback)",
			"description": "\r\n注册监听 activity onDestroy事件",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | ()=>void | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"offAppActivityDestroy": {
			"name": "### offAppActivityDestroy(callback?)",
			"description": "\r\nonAppActivityDestroy 对应的反注册函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | ()=>void | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"onAppActivityResult": {
			"name": "### onAppActivityResult(callback)",
			"description": "\r\n注册监听 activity onAppActivityResult 函数",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | (requestCode: Int, resultCode: Int, data: Intent?)=>void | 是 | 用于监听的响应函数 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"offAppActivityResult": {
			"name": "### offAppActivityResult(callback?)",
			"description": "\r\nonAppActivityResult 对应的反注册函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | (requestCode: Int, resultCode: Int, data: Intent?)=>void | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"onAppActivityBack": {
			"name": "### onAppActivityBack(callback)",
			"description": "\r\n注册监听 activity onAppActivityBack 函数",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | ()=>void | 是 | 用于监听的响应函数 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"offAppActivityBack": {
			"name": "### offAppActivityBack(callback?)",
			"description": "\r\n取消注册监听 activity onAppActivityBack 函数",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| callback | ()=>void | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"getAppContext": {
			"name": "### getAppContext()",
			"description": "\r\n获取当前应用Application上下文，对应android平台 Context.getApplicationContext 函数实现",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Context \\| null | 当前应用程序 上下文实例对象 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"getUniActivity": {
			"name": "### getUniActivity()",
			"description": "\r\n获取当前应用 栈顶的 Activity实例，对应android平台 getActivity 函数实现",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Activity \\| null | 当前应用栈顶的 Activity实例 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"getTopPageActivity": {
			"name": "### getTopPageActivity()",
			"description": "\r\n获取与当前页面绑定的activity对象，需要注意的是:当页面对象未与activity建立绑定关系时，可能为null",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Activity \\| null | 当前页面绑定的activity示例 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 4.0 | x | - |\n",
			"itemType": "method"
		},
		"getResourcePath": {
			"name": "### getResourcePath(resourceName)",
			"description": "\r\n获取H5资源文件的原生路径。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| resourceName | string | 是 | H5资源文件相对于工程的绝对路径, 如：“/static/logo.png” |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 该资源在原生目录下的路径 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | x | x | - |\n",
			"itemType": "method"
		},
		"getJavaClass": {
			"name": "### getJavaClass(input)",
			"description": "\r\n获取对象的jvm class实例",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| input | any | 是 | 任意不为空对象 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Class | 传入对象所对应的class实例 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 4.0 | x | - |\n",
			"itemType": "method"
		},
		"getAppCachePath": {
			"name": "### getAppCachePath()",
			"description": "\r\n获取app 临时目录。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string \\| null | 返回app临时目录路径。存放在该文件可能会在应用退出后被清理 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.99 | x | - |\n",
			"itemType": "method"
		},
		"exit": {
			"name": "### exit()",
			"description": "\r\n退出当前应用",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"getDispatcher": {
			"name": "### getDispatcher(threadName)",
			"description": "\r\n获取一个任务分发器实例",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| threadName | string | 是 | 任务组名称，可能为：main: ui thread / dom: 仅uni-app x环境生效，uni-app 环境会自动切换到 ui / io : io thread 匿名线程 / '': 来源线程，如果来源线程不支持任务分发，则会在当前线程执行执行. 这个场景下要求第一个参数必须是线程环境 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| [UTSTaskDispatcher](#utstaskdispatcher-values) | \n\n\n\n##### UTSTaskDispatcher 的方法 @utstaskdispatcher-values \n\n##### async(action, param?) @async\n\r\n在当前任务分发器 异步执行任务\n##### 参数 \n\n| 名称 | 类型 | 必填 | 默认值 | 描述 |\n| :- | :- | :- | :- | :- |\n| action | (action?: any \\| null) => void | 是 | - | 任务函数 |\n| param | any \\| null | 否 | - |  |\n\n\n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"getAppId": {
			"name": "### getAppId()",
			"description": "\r\n获取当前运行的app的AppId。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 当前运行的app的AppId。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"getOsTheme": {
			"name": "### getOsTheme()",
			"description": "\r\n获取当前系统主题样式",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 系统主题样式 \"dark\":暗色模式  \"light\":亮色模式 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"isUniMp": {
			"name": "### isUniMp()",
			"description": "\r\n获取当前运行环境是否是unimp。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 是否是unimp。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"getAppName": {
			"name": "### getAppName()",
			"description": "\r\n获取manifest.json 中配置的应用名称",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 应用名称。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"getAppVersion": {
			"name": "### getAppVersion()",
			"description": "\r\n获取manifest.json 中配置的应用版本信息",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UTSJSONObject | 应用版本信息 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"getInnerVersion": {
			"name": "### getInnerVersion()",
			"description": "\r\n获取引擎版本号。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 引擎版本号。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"isUniAppX": {
			"name": "### isUniAppX()",
			"description": "\r\n获取当前是否是uniapp x 环境",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | uniapp x 环境 true, uniapp 环境： false。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"rpx2px": {
			"name": "### rpx2px(rpx)",
			"description": "\r\nrpx单位 转换为 逻辑像素px单位",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| rpx | number | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 返回对应的逻辑像素值 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"rpx2px_1": {
			"name": "### rpx2px(rpx)",
			"description": "\r\n页面的rpx像素转换为页面的px像素",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| rpx | number | 是 | 待转换的rpx |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 转换后的px | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.95 | x | - |\n",
			"itemType": "method"
		},
		"isPrivacyAgree": {
			"name": "### isPrivacyAgree()",
			"description": "\r\n当前应用是否已取得用户同意隐私协议",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | true 用户已同意 false 用户未同意 | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | - |\n",
			"itemType": "method"
		},
		"setPrivacyAgree": {
			"name": "### setPrivacyAgree(state)",
			"description": "\r\n设置当前应用是否已取得用户同意隐私协议",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| state | boolean | 是 | true 用户已同意 false 用户未同意 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | - |\n",
			"itemType": "method"
		},
		"resetPrivacyAgree": {
			"name": "### resetPrivacyAgree()",
			"description": "\r\n重置当前应用至用户未同意隐私协议",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.9 | x | - |\n",
			"itemType": "method"
		},
		"requestSystemPermission": {
			"name": "### requestSystemPermission(context, requestPermission, success, fail)",
			"description": "\r\n请求系统权限",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| context | Activity | 是 | - |\n| requestPermission | Array\\<string> | 是 | 期望请求的权限 |\n| success | (allRight:boolean, grantedList:Array\\<string>)=>void | 是 | - |\n| fail | (doNotAskAgain:boolean, grantedList:Array\\<string>)=>void | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"checkSystemPermissionGranted": {
			"name": "### checkSystemPermissionGranted(context, requestPermission)",
			"description": "\r\n检查当前应用是否已经具备指定权限",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| context | Activity | 是 | - |\n| requestPermission | Array\\<string> | 是 | 期望具备的权限 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 请求的权限列表中是否已经具备 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"gotoSystemPermissionActivity": {
			"name": "### gotoSystemPermissionActivity(context, requestPermission)",
			"description": "\r\n跳转至系统权限手动设备列表",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| context | Activity | 是 | - |\n| requestPermission | Array\\<string> | 是 | 期望请求的权限 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"getSystemPermissionDenied": {
			"name": "### getSystemPermissionDenied(context, requestPermission)",
			"description": "\r\n获取当前应用不具备的权限列表",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| context | Activity | 是 | - |\n| requestPermission | Array\\<string> | 是 | 期望请求的权限 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Array\\<string> | 请求的权限列表中已经被禁用的部分 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9 | x | - |\n",
			"itemType": "method"
		},
		"devicePX2px": {
			"name": "### devicePX2px(devicePX)",
			"description": "\r\n物理像素转换为页面的px像素",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| devicePX | number | 是 | 待转换的物理像素 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| number | 转换后的页面px | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.95 | x | - |\n",
			"itemType": "method"
		},
		"convert2AbsFullPath": {
			"name": "### convert2AbsFullPath(inputPath)",
			"description": "\r\n将文件的项目相对地址转换为 运行期对应的绝对地址\r\neg.\r\n   'static/logo.png' -> '/storage/sdcard/0/apps/com.xxxx/files/logo.png'\r\n",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| inputPath | string | 是 | 待转换的资源相对路径 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 转换后文件绝对路径 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.9x | x | - |\n",
			"itemType": "method"
		},
		"getFileProviderUri": {
			"name": "### getFileProviderUri(file)",
			"description": "\r\n将应用的私有文件 通过内置的FileProvider转换为外部应用可以访问的Uri\r\n",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| file | File | 是 | 待转换的私有文件 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Uri | 转换后的Uri | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| 4.4 | 3.99 | x | - |\n",
			"itemType": "method"
		}
	},
	"UTSiOS": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.platformObject.UTSiOS)",
		"getCurrentViewController": {
			"name": "### getCurrentViewController()",
			"description": "\r\n获取当前 app 显示的 UIViewController。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UIViewController | 当前 app 显示的 UIViewController | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getKeyWindow": {
			"name": "### getKeyWindow()",
			"description": "\r\n获取当前app的keyWindow。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UIWindow | 当前app的keyWindow. | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"colorWithString": {
			"name": "### colorWithString(value)",
			"description": "\r\n获取指定的颜色。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| value | string | 是 | 需要转换的代表色值的字符串，支持一下格式：精简写法的十六进制 如：#f00，十六进制 如：#ff0000，RGB 如：rgb(255, 0, 0)，RGBA 如:rgba(255, 0, 0, 0.5)，色值关键字，如： red |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| UIColor | UIColor 实例对象 注：如转换失败 默认会返回 黑色 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getResourcePath": {
			"name": "### getResourcePath(resourceName)",
			"description": "\r\n获取H5资源文件的原生路径。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| resourceName | string | 是 | H5资源文件相对于工程的绝对路径, 如：“/static/logo.png” |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 该资源在原生目录下的路径 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"isSimulator": {
			"name": "### isSimulator()",
			"description": "\r\n是否是模拟器。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 当前是模拟器 true, 当前是真机：false | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getDeviceId": {
			"name": "### getDeviceId()",
			"description": "\r\n获取设备 deviceId。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 当前设备的 deviceId | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getModel": {
			"name": "### getModel()",
			"description": "\r\n获取设备型号。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| string | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getUserAgent": {
			"name": "### getUserAgent()",
			"description": "\r\n获取当前应用的 UserAgent。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 当前应用的 UserAgent。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getAppId": {
			"name": "### getAppId()",
			"description": "\n获取当前运行的app的AppId。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 当前运行的app的AppId。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getDataPath": {
			"name": "### getDataPath()",
			"description": "\n获取当前运行app的dataPath",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 当前运行app的dataPath。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"isUniMp": {
			"name": "### isUniMp()",
			"description": "\n获取当前运行环境是否是unimp。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 是否是unimp。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getAppName": {
			"name": "### getAppName()",
			"description": "\n获取manifest.json 中配置的应用名称",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 应用名称。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getAppVersion": {
			"name": "### getAppVersion()",
			"description": "\n获取manifest.json 中配置的应用版本名称。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 应用版本名称。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getAppVersionCode": {
			"name": "### getAppVersionCode()",
			"description": "\n获取manifest.json 中配置的应用版本号。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 应用版本号。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getOsLanguage": {
			"name": "### getOsLanguage()",
			"description": "\n获取操作系统设置的语言。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | os language。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getAppWgtVersion": {
			"name": "### getAppWgtVersion()",
			"description": "\n获取应用资源（wgt）的版本名称。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 应用资源（wgt）的版本名称。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getHostLanguage": {
			"name": "### getHostLanguage()",
			"description": "\n获取小程序宿主语言。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 小程序宿主语言。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getHostVersion": {
			"name": "### getHostVersion()",
			"description": "\n获取小程序宿主版本。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 小程序宿主版本。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getHostName": {
			"name": "### getHostName()",
			"description": "\n获取小程序宿主名称。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 小程序宿主名称。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getHostPackageName": {
			"name": "### getHostPackageName()",
			"description": "\n获取小程序宿主包名。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 小程序宿主包名。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getHostTheme": {
			"name": "### getHostTheme()",
			"description": "\n获取系统当前主题，取值为light或dark。微信小程序全局配置\"darkmode\":true时才能获取，否则为 undefined （不支持小游戏）。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 系统当前主题。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getInnerVersion": {
			"name": "### getInnerVersion()",
			"description": "\n获取引擎版本号。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| string | 引擎版本号。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"getSystemSetting": {
			"name": "### getSystemSetting()",
			"description": "\n获取系统设置信息。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| Map\\<string, any> | 系统设置信息。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"isBaseIpa": {
			"name": "### isBaseIpa()",
			"description": "\n获取当前是否是基座环境。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 基座环境 true, 线上环境： false。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		}
	},
	"UTSiOSHookProxy": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.platformObject.UTSiOSHookProxy)",
		"onCreate": {
			"name": "### onCreate()",
			"description": "\r\nuts 插件创建时的回调。\n此回调的准确时机对应于 OC 类的 load() 函数调用时机。",
			"param": "",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"applicationDidFinishLaunchingWithOptions": {
			"name": "### applicationDidFinishLaunchingWithOptions(application?, launchOptions?)",
			"description": "\r\n应用正常启动时 (不包括已在后台转到前台的情况)的回调函数。\n可以在此回调函数做一些初始化操作，比如初始依赖的SDK等。注意：不要在此回调函数里做耗时操作，以免影响 app 的启动速度。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| application | UIApplication | 否 | App 的 UIApplicationDelegate 对象。 |\n| launchOptions | Map\\<UIApplication.LaunchOptionsKey, any> | 否 | 启动参数。默认值为 null (用户通过点击 push 通知启动应用时，该参数内会包含通知的信息) |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 返回一个 boolean 值，正常返回true。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"didRegisterForRemoteNotifications": {
			"name": "### didRegisterForRemoteNotifications(deviceToken?)",
			"description": "\r\n远程通知注册成功时的回调函数。\n可以在此函数里将 deviceToken 发送给服务端。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| deviceToken | Data | 否 | 设备的推送令牌 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"didFailToRegisterForRemoteNotifications": {
			"name": "### didFailToRegisterForRemoteNotifications(error?)",
			"description": "\r\n远程通知注册失败时的回调函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| error | NSError | 否 | 失败的原因。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"didReceiveRemoteNotification": {
			"name": "### didReceiveRemoteNotification(userInfo?)",
			"description": "\r\n应用收到远程通知时的回调函数。\n当应用在前台运行中，收到远程通知时(不会弹出系统通知界面)，会回调这个方法；当应用在后台状态时，点击push消息启动应用，也会回调这个方法；当应用完全没有启动时，点击push消息启动应用，就不会回调这个方法。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| userInfo | Map\\<AnyHashable, any> | 否 | 收到的远程通知信息。 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"didReceiveLocalNotification": {
			"name": "### didReceiveLocalNotification(notification?)",
			"description": "\r\n应用收到本地通知时的回调函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| notification | UILocalNotification | 否 | 接收到的本地通知 |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"applicationHandleOpenURL": {
			"name": "### applicationHandleOpenURL(application?, url?)",
			"description": "\r\n通过 url scheme 方式唤起 app 时的回调函数。(iOS9 之前的系统回调此方法，iOS9 之后的系统请使用 applicationOpenURLOptions)",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| application | UIApplication | 否 | App 的 UIApplicationDelegate 对象。 |\n| url | URL | 否 | 要打开的URL资源。该资源可以是网络资源或文件。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果成功处理请求，则为true;如果尝试打开URL资源失败，则为false。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"applicationOpenURLOptions": {
			"name": "### applicationOpenURLOptions(app?, url?, options?)",
			"description": "\r\n通过 url scheme 方式唤起 app 时的回调函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| app | UIApplication | 否 | - |\n| url | URL | 否 | 要打开的URL资源。该资源可以是网络资源或文件。 |\n| options | Map\\<UIApplication.OpenURLOptionsKey, any> | 否 | URL处理选项的字典, 默认值为 null 。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | 如果成功处理请求，则为true;如果尝试打开URL资源失败，则为false。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"applicationWillResignActive": {
			"name": "### applicationWillResignActive(application?)",
			"description": "\n当应用从活动状态主动变为非活动状态的时的回调函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| application | UIApplication | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"applicationDidBecomeActive": {
			"name": "### applicationDidBecomeActive(application?)",
			"description": "\n应用完全激活时的回调函数。\n应用程序冷启动或者从后台转到前台后都会完全激活应用程序。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| application | UIApplication | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"applicationDidEnterBackground": {
			"name": "### applicationDidEnterBackground(application?)",
			"description": "\n应用程序进入后台时的回调函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| application | UIApplication | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"applicationWillEnterForeground": {
			"name": "### applicationWillEnterForeground(application?)",
			"description": "\n当应用在后台状态，将要进入到前台运行时的回调函数。\n应用程序冷启动时不会回调此方法。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| application | UIApplication | 否 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"applicationMain": {
			"name": "### applicationMain(argc, argv)",
			"description": "\n应用程序的 main 函数。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| argc | Int32 | 是 | - |\n| argv | UnsafeMutablePointer\\<UnsafeMutablePointer\\<CChar> \\| null> | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		},
		"applicationContinueUserActivityRestorationHandler": {
			"name": "### applicationContinueUserActivityRestorationHandler(application?, userActivity?, restorationHandler?)",
			"description": "\n当应用程序接收到与用户活动相关的数据时调用此方法，例如，当用户使用 Universal Link 唤起应用时。",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| application | UIApplication | 否 | App 的 UIApplicationDelegate 对象。 |\n| userActivity | NSUserActivity | 否 | 包含与用户正在执行的任务相关联的数据的活动对象。使用这些数据来继续用户在iOS应用中的活动。 |\n| restorationHandler | ((res ?: [any\\]) => void) | 否 | 需要执行的回调，该回调是可选的，默认值为 null。 |",
			"returnValue": "**返回值** \n\n| 类型 | 描述 |\n| :- | :- |\n| boolean | true表示你的应用处理了这个活动，false表示让iOS知道你的应用没有处理这个活动。 | \n",
			"compatibility": "**兼容性** \n\n| Android 系统版本 | Android | iOS | web |\n| :- | :- | :- | :- |\n| x | x | x | - |\n",
			"itemType": "method"
		}
	},
	"UTSAndroidHookProxy": {
		"tutorial": "\n### 参见\n[相关 Bug](https://issues.dcloud.net.cn/?mid=uts.platformObject.UTSAndroidHookProxy)",
		"onCreate": {
			"name": "### onCreate(application)",
			"description": "\r\nuts 插件创建时的回调。\r\n对应原生 Application onCreate 函数",
			"param": "**参数** \n\n| 名称 | 类型 | 必填 | 描述 |\n| :- | :- | :- | :- |\n| application | Application | 是 | - |",
			"returnValue": "**返回值** \n\n| 类型 |\n| :- |\n| void | \n",
			"compatibility": "**兼容性** \n\n| Android | iOS | web |\n| :- | :- | :- |\n| 3.97 | x | - |\n",
			"itemType": "method"
		}
	}
}