{
	"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"
		}
	}
}