Merge branch 'master' of https://gitcode.net/dcloud/unidocs-zh

52b3a78b · lizhongyi_ · eeb8b87f · b44f4124 · 52b3a78b · 52b3a78b
9 changed file
--- a/docs/.vuepress/utils/cssJson.json
+++ b/docs/.vuepress/utils/cssJson.json
--- a/docs/plugin/uts-plugin.md
+++ b/docs/plugin/uts-plugin.md
@@ -611,18 +611,7 @@ export function getPluginVersion(): UTSJSONObject{
 }
 ```

-3 JSONObject

-```ts
-// JSONObject 示例
-export function getPluginVersion(): JSONObject{
-	
-	var retJson = new JSONObject()
-	retJson["version"] = "1.2.0"
-	retJson["versionNum"] = 120
-	return retJson
-}
-```

 uni-app向UTS环境传值，支持下列类型：

@@ -681,6 +670,43 @@ postUserInfo({

 ```

+遗留问题：
+
+有些场景，我们需要参数对象包含对象数组，比如
+```json
+{
+	"name": "zhangsan",
+	"teacher": [{
+			"id": "1",
+			"name": "kongzi"
+		},
+		{
+			"id": "2",
+			"name": "mengzi"
+		}
+	]
+}
+```
+目前在uni-app 1.0 环境下，复杂参数的传递是存在一定的缺陷。我们不能将teacher 声明为具体的类型数组，需要声明为any数组：
+
+
+```uts
+type Param{
+	name:string,
+	// 不能声明为 Teacher[]
+	teacher: any[];
+}
+```
+访问数组元素时，通过 UTSJSONObjct 包装访问
+```uts
+// 循环遍历
+list1.forEach((item : any) => {
+    const utsItem = new UTSJSONObject(item)
+})
+```
+
+这个问题，我们稍后会改进。
+

 ## 4 前端使用插件


--- a/docs/uni-app-x/_sidebar.md
+++ b/docs/uni-app-x/_sidebar.md
@@ -3,6 +3,7 @@
 * [编译器](compiler/README.md)
 * [manifest.json](manifest.md)
 * 组件
+  * [公共属性和事件](component/common.md)
  * [view](component/view.md)
  * [scroll-view](component/scroll-view.md)
  * [list-view](component/list-view.md)
@@ -112,9 +113,6 @@
  * [INode](dom/inode.md)  
  * [CSSStyleDeclaration](dom/cssstyledeclaration.md)  
  * [DrawableContext](dom/drawablecontext.md)  
-* 事件event
-  * [事件系统概述](dom/event.md)
-  <!-- * [通用事件](event-common.md) -->
 * [性能](performance.md)
 <!-- * [新建项目]()
  * [1. 通过 HBuilderX 可视化界面](quickstart-hx.md)

--- a/docs/uni-app-x/dom/event.md
+++ b/docs/uni-app-x/dom/event.md
-## Event事件系统
+# 组件的公共属性和事件

-uvue 支持事件冒泡。
+每个组件都有属性和事件。有些属性和事件，是所有组件都支持的。

-### 简述
+## 组件公共属性
+
+<!-- 自动生成 -->
+
+## 组件公共事件
+
+<!-- 自动生成 -->
+
+### 冒泡事件系统

 DOM事件主要有三个阶段：捕获阶段、目标阶段和冒泡阶段。

@@ -15,9 +23,9 @@ DOM事件主要有三个阶段：捕获阶段、目标阶段和冒泡阶段。

 我们一般使用默认的事件注册机制，将事件注册到冒泡阶段，相对来说，大多数处理情况都在冒泡阶段。

-uvue 目前暂时不支持事件的捕获阶段。
+uvue 目前暂不支持事件的捕获阶段。

-### 阻止冒泡
+#### 阻止冒泡

 在事件回调中，可以通过调用`event.stopPropagation`方法阻止事件冒泡。

@@ -28,7 +36,7 @@ handleClick (event : MouseEvent) {
 }
 ```

-### 阻止默认行为
+#### 阻止默认行为

 在事件回调中，可以通过调用`event.preventDefault`方法阻止默认行为。`event.preventDefault`仅处理默认行为，事件冒泡不会被阻止。


--- a/docs/uni-app-x/readme.md
+++ b/docs/uni-app-x/readme.md
@@ -112,6 +112,7 @@ uni-app x 一期，只包括基本的组件和API。
 - [x] switch
 - [x] slider
 - [x] picker-view
+- [x] navigator
 - [x] progress
 - [x] webview
 - [x] video 暂不支持全屏后放置子组件

--- a/docs/uts/README.md
+++ b/docs/uts/README.md
@@ -115,7 +115,7 @@ vue 选项式开发时，冒号被用于赋值，无法通过let、const和冒
 				s1 : "abc", // 根据字面量推导为string
 				n1 : 0 as number, // 这里其实可以根据字面量自动推导，as number写不写都行
 				n2, // 不合法，必须指定类型
-				n3 as number, // 不合法，uts不支持undefined，必须初始化
+				n3 as undefined, // 不合法，uts不支持undefined，必须初始化
 				n4 : null as number | null // 合法。定义为可为null的数字，初始值是null，但在使用n4前必须为其赋值数字
 				year: date.getFullYear() as number, // 在data里，目前无法通过变量类型推导data项的类型，需使用 as 显式声明
 			}

--- a/docs/uts/data-type.md
+++ b/docs/uts/data-type.md
 # 类型@data-type

 强类型语言的特点，是数据类型要求严格。它带来2个好处：
-1. 高性能：明确的类型有更大的优化空间，在iOS和Android等os上可以节省内存、提高运算速度；web端由于仍编译为js，不具有类型性能优化。
-2. 安全的代码：强类型代码编写虽然没有弱类型自由，但类型检查、非空检查...各种检查可以提升代码的健壮性。
+1. 高性能：明确的类型有更大的优化空间，在iOS和Android等OS上可以节省内存、提高运算速度；web端由于仍编译为js，不具有类型性能优化。
+2. 安全的代码：强类型代码编写虽然没有弱类型自由，但类型检查、非空检查...等各种检查可以提高代码的健壮性。

 如果您是js开发者，那么需要一定的学习过程来掌握 UTS 的类型系统。总体原则是你将牺牲一些代码的灵活性，来换取代码的健壮性和高性能。

@@ -11,8 +11,8 @@
 比如 `"abc"`和`"你好"`，都属于字符串string，所有string类型有相同的方法、属性，比如`.length`属性获取字符串长度。

 UTS 的类型有：
- 基础类型：boolean、number、string、any、null，都是小写，前3个typeof返回类型名称，null的typeof是object，any的typeof是运行时值的类型。
- 对象类型：Date、Array、Map、Set、USTJSONObject，首字母大写，typeof返回"object"，判断准确类型需使用 instanceof 
+- 基础类型：boolean、number、string、any、null，都是小写。前3个typeof返回类型名称，null的typeof是object，any的typeof是运行时值的类型。
+- 对象类型：Date、Array、Map、Set、UTSJSONObject，首字母大写。typeof返回"object"，判断准确类型需使用 instanceof 
 - 使用 type 来自定义类型
 - 特殊类型：function、class、error。
 - 平台专有类型：Int、Float、Double、NSString、kotlin.Array...
@@ -30,7 +30,7 @@ let c:boolean // 定义类型但定义时未赋值
 c = true // 后续为变量赋值字面量
 ```

-注意：
+**注意：**
 - 在js里，true == 1、 false == 0。但在其他强类型语言里，`1`和`0`是数字类型，无法和布尔类型相比较。
 - 注意 boolean 不要简写成 bool

@@ -112,8 +112,8 @@ number本身的使用很简单，但混入了平台专有数字类型后，会
 - Swift 中 Int 类型是根据平台动态的，在 32 位设备下等同于 Int32, 在64位设备下等同于 Int64。因此建议整型使用 Int, 除非必要，且在保证不会溢出的场景下才使用 Int32、Int64。
 - 同样，Swift 中的 UInt 类型也是根据平台动态的，在 32 位设备下等同于 UInt32, 在64位设备下等同于 UInt64。建议使用 UInt，非必要不使用 UInt32、UInt64。
 - Float16 在 iOS14.0 及以上系统上才能使用，使用时注意做系统版本号判断。[参考](../plugin/uts-uni-api.md#设备)
- Float32 是 Float 的 typealise, 两者等价。
- Float64 是 Double 的 typealise, 两者等价。
+- Float32 是 Float 的类型别名, 两者等价。
+- Float64 是 Double 的类型别名, 两者等价。

 #### 专有数字类型的定义方式

@@ -188,8 +188,8 @@ let a:Int = 1  // 类型为Int
 但`let b:Int = 1/10` 会在 HBuilderX 3.9+起报错，原因见下面第二条规则。

 再澄清下规则1：
-	* 如果定义变量时已经显式声明了类型，和规则1无关
-	* 如果不是定义变量，和规则1无关
+  * 如果定义变量时已经显式声明了类型，和规则1无关
+  * 如果不是定义变量，和规则1无关

 也就是如下代码中，`60`这个字面量的处理，和规则1无关，不会把这个`60`改为number类型

@@ -218,7 +218,7 @@ test(1/10) // 报错，类型不匹配。需要number而传入Int

 这里的`纯数字字面量的除法`，指除法表达式中除了数字和运算符，不包括任何其他东西：
 - 比如变量：`let a:Int=1;let b:Int= a/1`
- 比如被as过：`(1 as Int)/10`
+- 比如使用 as 断言：`(1 as Int)/10`
 以上除法表达式，都不是“纯数字字面量的除法”，都不会被推导为number。

 但是这条规则，也会导致一个**向下兼容问题**。
@@ -251,19 +251,19 @@ test((1.0 as Double)/10) //表达式中任意一个数字as一下，都不会走

 所有的 number 都支持下列方法进行转换（部分类库API使用java编写，其要求的java类型与下列kotlin类型完全一致，可以直接使用

-	* toByte(): Byte
-	* toShort(): Short
-	* toInt(): Int
-	* toLong(): Long
-	* toFloat(): Float
-	* toDouble(): Double
+  * toByte(): Byte
+  * toShort(): Short
+  * toInt(): Int
+  * toLong(): Long
+  * toFloat(): Float
+  * toDouble(): Double

 另外 number 还具备下列函数进行整型的无符号转换，这部分API 在jvm上没有对应的原始数据类型，主要的使用场景是 色值处理等专业计算场景的`多平台拉齐`

-	* toUByte(): UByte
-	* toUShort(): UShort
-	* toUInt(): UInt
-	* toULong(): ULong
+  * toUByte(): UByte
+  * toUShort(): UShort
+  * toUInt(): UInt
+  * toULong(): ULong

 ```ts
 let a:number = 3
@@ -711,60 +711,62 @@ let kotlinArray = utsArr.toTypedArray()

 #### iOS 平台专有数组类型

-	UTS 中的 Array 对应到 Swift 中就是 Array, 方法是通用的，无需转换。一般情况下，使用 Array 即可。
-	但是，某些系统或者三方库 API 可能会要求 OC 的 NSArray、NSMutableArray 类型的数组，这个时候就需要进行转换。
-	
+>UTS 中的 Array 对应到 Swift 中就是 Array, 方法是通用的，无需转换。一般情况下，使用 Array 即可。
+>
+>但是，某些系统或者三方库 API 可能会要求 OC 的 NSArray、NSMutableArray 类型的数组，这个时候就需要进行转换。
+
 - 专有数组类型清单
 	* NSArray
 	* NSMutableArray
-	
+
 - 专有数组类型定义方式

 1. 创建 NSArray
-   NSArray 是 OC 中的不可变数组，顾名思义，数组创建完成之后就不可以再添加或者删除元素。因此，创建 NSArray 对象时就应该完成数组的初始化。
-   可以通过以下方式创建 NSArray:
-   
-```ts
-	// 方式一： 创建一个空数组，注意数组创建后就不可改变，不能再添加或者删除元素，应避免使用该方式。
-	let a: NSArray = NSArray()  
-	
-	// 方式二： 用一个数组创建一个 NSArray, 推荐使用。同样，创建完成后数组不可变。
-	let b: NSArray = NSArray(array=[1, 2, 3, 4]) // 等价于 any[]，注意：不是等价于 number[]
-	
-	// 方式三: 用一个元素定义 NSArray, 不推荐使用
-	let c: NSArray = NSArray(object=1)
-	
-	// 方式四：用不定长元素定义 NSArray, 可以使用
-	let d: NSArray = NSArray(objects=1, "2", false, "ok")

-```
+	> NSArray 是 OC 中的不可变数组，顾名思义，数组创建完成之后就不可以再添加或者删除元素。因此，创建 NSArray 对象时就应该完成数组的初始化。可以通过以下方式创建 NSArray:
+
+	```ts
+		// 方式一： 创建一个空数组，注意数组创建后就不可改变，不能再添加或者删除元素，应避免使用该方式。
+		let a: NSArray = NSArray()  
+		
+		// 方式二： 用一个数组创建一个 NSArray, 推荐使用。同样，创建完成后数组不可变。
+		let b: NSArray = NSArray(array=[1, 2, 3, 4]) // 等价于 any[]，注意：不是等价于 number[]
+		
+		// 方式三: 用一个元素定义 NSArray, 不推荐使用
+		let c: NSArray = NSArray(object=1)
+		
+		// 方式四：用不定长元素定义 NSArray, 可以使用
+		let d: NSArray = NSArray(objects=1, "2", false, "ok")
+
+	```

 2. 创建 NSMutableArray
-   NSMutableArray 是 OC 中的可变数组，其是 NSArray 的子类，可变数组创建后可以增加或者删除元素。NSArray 的所有创建方式也都适用于 NSMutableArray
-   
-   ```ts
-   	// 方式一： 创建一个空数组，其类型等价于 any[]
-   	let a: NSMutableArray = NSMutableArray()  
-	a.add(1) 	//添加一个元素
-	a.add("22") //添加一个元素
-	a.add(false) //添加一个元素
-	a.remove(1) //移除一个元素
-	a.removeObject(at=2) //移除一个指定下标的元素
-	a.removeAllObjects() //移除全部元素
-	a.removeLastObject() //移除最后一个元素
-   	
-   	// 方式二： 用一个数组创建一个 NSMutableArray, 推荐使用。
-   	let b: NSMutableArray = NSMutableArray(array=[1, 2, 3, 4]) // 等价于 any[]，注意：不是等价于 number[]
-   	
-   	// 方式三: 用一个元素定义 NSMutableArray
-   	let c: NSMutableArray = NSMutableArray(object=1)
-   	
-   	// 方式四：用不定长元素定义 NSMutableArray
-   	let d: NSMutableArray = NSMutableArray(objects=1, "2", false, "ok")
-   
-   ```
-	
+
+   - NSMutableArray 是 OC 中的可变数组，其是 NSArray 的子类，可变数组创建后可以增加或者删除元素。NSArray 的所有创建方式也都适用于 NSMutableArray
+      
+   		```ts
+   		// 方式一： 创建一个空数组，其类型等价于 any[]
+   		let a: NSMutableArray = NSMutableArray()  
+   		a.add(1) 	//添加一个元素
+   		a.add("22") //添加一个元素
+   		a.add(false) //添加一个元素
+   		a.remove(1) //移除一个元素
+   		a.removeObject(at=2) //移除一个指定下标的元素
+   		a.removeAllObjects() //移除全部元素
+   		a.removeLastObject() //移除最后一个元素
+
+   		// 方式二： 用一个数组创建一个 NSMutableArray, 推荐使用。
+   		let b: NSMutableArray = NSMutableArray(array=[1, 2, 3, 4]) // 等价于 any[]，注意：不是等价于 number[]
+
+   		// 方式三: 用一个元素定义 NSMutableArray
+   		let c: NSMutableArray = NSMutableArray(object=1)
+
+   		// 方式四：用不定长元素定义 NSMutableArray
+   		let d: NSMutableArray = NSMutableArray(objects=1, "2", false, "ok")
+
+   		```
 	
+
 - 专有数组类型 转 Array

 ```ts
@@ -797,11 +799,11 @@ let a3: NSMutableArray = NSMutableArray(array= a)

 ```

- 注意： 
-	+ 无论是 NSArray 还是 NSMutableArray 对象创建后都等价于 any[] 类型的数组，此时 Swift 不再有类型推导，可以往可变数组中添加任意类型的非空元素。
-	+ NSArray 和 NSMutableArray 类型的数组不接受空值 null, 任何情况下不要往这两种类型中注入 null。 否则，在运行时可能会引起应用闪退。
-	+ Array 类型不能通过 as 方式转换成 NSMutableArray 类型。 但是可以通过 as 方式 转换成 NSArray 类型。
-	+ Swift 中的 Array 是值类型，其和 TS 中 Array 的一点区别是 可以通 == 判断两个数组是否相等，只要两个数组的类型和元素一样，判等的结果就是 true。
+**注意：** 
+  + 无论是 NSArray 还是 NSMutableArray 对象创建后都等价于 any[] 类型的数组，此时 Swift 不再有类型推导，可以往可变数组中添加任意类型的非空元素。
+  + NSArray 和 NSMutableArray 类型的数组不接受空值 null, 任何情况下不要往这两种类型中注入 null。 否则，在运行时可能会引起应用闪退。
+  + Array 类型不能通过 as 方式转换成 NSMutableArray 类型。 但是可以通过 as 方式 转换成 NSArray 类型。
+  + Swift 中的 Array 是值类型，其和 TS 中 Array 的一点区别是 可以通 == 判断两个数组是否相等，只要两个数组的类型和元素一样，判等的结果就是 true。


 ### 更多API
@@ -820,7 +822,7 @@ Map 是一种 key value 形式的数据类型。
 //定义一个map1，key为string类型，value也是string类型
 const map1: Map<string,string> = new Map(); 
 map1.set('key1', "abc");
-console.log(map1.get('key1') //返回 abc
+console.log(map1.get('key1')) //返回 abc

 //定义一个map1，key为number类型，value是Map类型
 const map2: Map<number,Map<string,string>> = new Map(); 
@@ -831,7 +833,9 @@ console.log(map2.get(1)?.get("key1")); //返回 abc。因为名为1的key不一

 注意在HBuilderX中console.log一个Map时，返回内容格式如下：

+```sh
 [Object] Map(3) {"sex":0,"name":"zhangsan","age":12}  at pages/index/index.uvue:60
+```

 开头的[Object]代表其typeof的类型，Map代表它的实际类型，(3)是map的size，{...} 是Map的内容。

@@ -855,7 +859,7 @@ console.log(map1 instanceof Map); //返回 true

 Map对象还有很多API，delete、clear等，[详见](buildin-object-api/map.md)

-## USTJSONObject@ustjsonobject
+## UTSJSONObject@utsjsonobject

 json 在 js 中并非一个独立的类型，对一个 json 对象 typeof 返回的是 object。

@@ -864,13 +868,13 @@ json 在 js 中用起来很自由，但在强类型语言中，不管kotlin、sw
 1. json对象里的每个属性，都需要定义类型
 2. 每个可为空的属性，都需要加`?.`，才能安全读写

-一般其他强类型语言的用法，是把json数据内容，转为class、interface或type。然后就可以`.`了。
+一般其他强类型语言的用法，是把json数据内容，转为class、interface或type。然后就可以使用`.`来访问了。

 在 uts 中使用 JSON，有3种方式：

 1. 把 json数据转 type，变成一个自定义类型。这不是本章节的内容，详见 [type](#type)
 2. uts 新增了 UTSJSONObject 对象，可以把 json数据通过字面量赋值 或 JSON.parse()方式，赋值给 uts 内置的 UTSJSONObject 对象。
-3. 由于 USTJSONObject有toMap()方法，所以也可以转为Map后使用json数据。
+3. 由于 UTSJSONObject有toMap()方法，所以也可以转为Map后使用json数据。

 UTSJSONObject，是一个类型，可以在变量的冒号后面使用，本节的重点就是介绍UTSJSONObject。

@@ -934,7 +938,7 @@ let jo2 = {

 关于属性名是否需要使用引号包围的规则：
 1. 如果是对象字面量赋值，普通属性名称无需使用引号包围，但使用也没问题
-2. 如果是对象字面量赋值，且属性名包括`-`，则必须两侧加引号包围。
+2. 如果是对象字面量赋值，且属性名包括特殊符号，如：`-`，则必须两侧加引号包围。
 3. 如果是JSON.parse()方法入参需要的字符串，则属性名必须使用双引号包围（web端规则也是如此）

 如果开发者不想搞明白这些细节，可以简单粗暴的都给属性名都加上引号。
@@ -1011,14 +1015,14 @@ let rect = {

 以上述 rect 为例，访问 UTSJSONObject 中的数据，有如下3种方式：

-1. `.`操作符
+1. `.` 操作符
 	即 `rect.x`、`rect.size.width`。
 	
 	这种写法比较简单，和js习惯一致，但在 UTS 中限制较多。它的使用有如下前提：
 	- 仅限于web和Android，在iOS上swift不支持`.`操作符。
 	- 在Android上也只支持字面量定义json（因为类型可推导）。如果是`JSON.parse()`转换的，则不能使用。
 	
-2. [""]下标属性
+2. `[""]` 下标属性
 	即 `rect["x"]`。
 	
 	这是一种通用的方式，不管通过字面量定义的 UTSJSONObject，还是通过 `JSON.parse()`，不管是 web、Android、iOS 哪个平台，都可以使用下标方式访问 UTSJSONObject 属性。
@@ -1066,17 +1070,19 @@ console.log(listArr[0]["title"]); //第一组

 多层级下标访问时需要使用 as 转换为 UTSJSONObject  
 ```ts
-var j = {"test":{
-	"a-b": 1
-}}
+var j = {
+	"test":{
+		"a-b": 1
+	}
+}
 console.log((j['test'] as UTSJSONObject)['a-b']);
 ```

-3. 通过 keyPath 访问 UTSJSONObject 数据
+1. 通过 keyPath 访问 UTSJSONObject 数据

 在 `HBuilderX` 3.9.0 之后的版本，UTSJSONObject 提供了另外一种属性访问方式，keyPath。如果你了解 XPath、JSONPath 的话，这个概念类似。

-kyepath是把`.`操作符作为一个字符串传入了UTSJSONObject的一个方法中，比如`utsObj.getString("address.detailInfo.street")`
+keypath是把`.`操作符作为一个字符串传入了UTSJSONObject的一个方法中，比如`utsObj.getString("address.detailInfo.street")`

 相对于受限制`.`和需要经常as的下标，更推荐使用keyPath方式来操作UTSJSONObject。

@@ -1246,14 +1252,15 @@ console.log(personList[1].age); //null
 ### 嵌套

 json对象往往有嵌套，即子对象。比如
+
 ```json
 {
-	id: 1, 
-	name: "zhangsan", 
-	age: 18，
-	address: {
-		city: "beijing",
-		street: "dazhongsi road"
+	"id": 1, 
+	"name": "zhangsan", 
+	"age": 18,
+	"address": {
+		"city": "beijing",
+		"street": "dazhongsi road"
 	}
 }
 ```
@@ -1263,9 +1270,9 @@ json对象往往有嵌套，即子对象。比如
 ```ts
 type PersonType = {
 	id: number,
-    name: string,
+	name: string,
 	age: number,
-    address: { // 错误，这里的address需要单独声明类型
+		address: { // 错误，这里的address需要单独声明类型
 		city : string,
 		street : string
 	}
@@ -1276,14 +1283,14 @@ type PersonType = {

 ```ts
 type PersonAddressType = {
-    city: string,
+	city: string,
 	street: string
 }
 type PersonType = {
 	id: number,
-    name: string,
+	name: string,
 	age: number,
-    address: PersonAddressType // 把address定义为PersonAddress类型
+	address: PersonAddressType // 把address定义为PersonAddress类型
 }
 ```

@@ -1292,14 +1299,14 @@ type PersonType = {
 那么嵌套的完整写法例子：
 ```ts
 type PersonAddressType = {
-    city: string,
+	city: string,
 	street: string
 }
 type PersonType = {
 	id: number,
-    name: string,
+	name: string,
 	age: number,
-    address: PersonAddressType // 把address定义为PersonAddress类型
+	address: PersonAddressType // 把address定义为PersonAddress类型
 }
 let person = {
 	id: 1, 
@@ -1346,12 +1353,20 @@ console.log(person?.name);  // 返回zhangsan。由于person可能为null，pars

 注意上述代码中，如果`let person`时，想使用冒号定义类型，需要考虑parse失败的情况，要这么写：
 ```ts
+type PersonType = {
+	id: number,
+	name: string
+}
 let person:PersonType|null = JSON.parse<PersonType>(jsonString)
 console.log(person?.name); // 返回zhangsan
 ```

 或者如果你确保jsonString的值一定是合法的、parse一定可以成功，那么也可以在定义的末尾!号断言，告诉编译器肯定没有问题，那么此后就可以不使用`?.`了
 ```ts
+type PersonType = {
+	id: number,
+	name: string
+}
 let person:PersonType = JSON.parse<PersonType>(jsonString)!
 console.log(person.name); // 返回zhangsan
 ```
@@ -1373,11 +1388,11 @@ HBuilderX 3.9起内置了一个json转type工具，在`json编辑器`中选择
 ### 为vue的data中的json定义类型

 uvue文件中data中的json数据也涉及类型定义。此时注意：type定义必须放在`export default {}`前面。
-```ts
+```html
 <script>
 	type PersonType = {
 		id: number,
-	    name: string
+		name: string
 	}
 	export default {
 		data() {
@@ -1405,7 +1420,7 @@ uvue文件中data中的json数据也涉及类型定义。此时注意：type定
 	// 注意给data定义type，要写在export default的上面
 	type PersonType = {
 		id: number,
-	    name: string,
+		name: string,
 		age: number,
 	}
 	export default {

--- a/docs/uts/literal.md
+++ b/docs/uts/literal.md
@@ -160,7 +160,7 @@ const coffees = ["French Roast", "Colombian", "Kona"]

 在JS中，对象字面值是封闭在花括号对`{}`中的一个对象的零个或多个“属性名—值”对的（元素）列表。

-在uts中，对象字面量赋值给变量，默认会被推导为[UTSJSONObject](data-type.md#USTJSONObject)类型。
+在uts中，对象字面量赋值给变量，默认会被推导为[UTSJSONObject](data-type.md#UTSJSONObject)类型。

 ```ts
 // 创建对象

--- a/docs/uts/operator.md
+++ b/docs/uts/operator.md
@@ -191,10 +191,10 @@ uts 中算数运算符在大部分场景下和 ts 中的行为一致，但是在
 | ^^				      			   | let a: Int = 2; a / 10.0 				  	  | 结果为 0.2 Double               |编译失败，Int / Double 不合法 需使用 a / Int(10.0)	|
 | 专有类型变量 + 字面量                   | let a: Int = 2; a + 10				  		  | 结果为 12 Int                   |结果为12 Int                          	  |
 | ^^				      			   | let a: Int = 2; a + 3.14 				  	  | 结果为 5.14 Double              |编译失败, 需要 a + Int(3.14) = 5	          |
-| 相同的专有类型变量相加                   | let a: Int = 1； let b: Int = 2; a + b		  | 结果为 3 Int                    |结果为3 Int                          	  |
+| 相同的专有类型变量相加                   | let a: Int = 1; let b: Int = 2; a + b		  | 结果为 3 Int                    |结果为3 Int                          	  |
 | ^^				      			   | let a: Double = 1.0; let b: Double = 2.0; a + b | 结果为 3.0 Double            |结果为 3.0 Double	          			  |
-| 不同的专有类型变量相加                   | let a: Int = 1； let b: Float = 3.14.toFloat()； a + b	  | 结果为4.14, Float   |编译失败，不同类型变量不能操作                 |
-| ^^				      			   | let a: Float = 1.0.toFloat()； let b: Double = 3.14； a + b| 结果为4.14，Double |编译失败，不同类型变量不能操作          		  |
+| 不同的专有类型变量相加                   | let a: Int = 1; let b: Float = 3.14.toFloat(); a + b	  | 结果为4.14, Float   |编译失败，不同类型变量不能操作                 |
+| ^^				      			   | let a: Float = 1.0.toFloat(); let b: Double = 3.14; a + b| 结果为4.14，Double |编译失败，不同类型变量不能操作          		  |

 ## 比较运算符的跨数字类型注意@comparisondifftype

@@ -215,8 +215,8 @@ uts 中比较运算符在大部分场景下和 ts 中的行为一致，但是在
 | 变量 > number				           | let a: Int = 1; a > number 				  | 结果为 true or false            |结果为 true or false  	  				  |
 | 字面量 > 字面量   			           | 3.14 > 1 				  					  | 结果为 true                     |结果为 true                          	  |
 | 专有类型变量 > 字面量                   | let a: Int = 2; a > 3.14				  	  | 结果为 false                    |结果为 false                          	  |
-| 相同的专有类型变量比较                   | let a: Int = 2； let b: Int = 1; a > b		  | 结果为 true                     |结果为 true                         	      |
-| 不同的专有类型变量比较                   | let a: Int = 1； let b: Float = 3.14.toFloat()； a > b	  | 结果为false         |编译失败，不同类型变量不能比较                 |
+| 相同的专有类型变量比较                   | let a: Int = 2; let b: Int = 1; a > b		  | 结果为 true                     |结果为 true                         	      |
+| 不同的专有类型变量比较                   | let a: Int = 1; let b: Float = 3.14.toFloat(); a > b	  | 结果为false         |编译失败，不同类型变量不能比较                 |


 ### 比较运算符 == != === !==
@@ -301,7 +301,7 @@ a as string // 正常
 1.0 as number

 // 对象字面量也可以as为USTJSONObject或某个type
-{"id":1} as USTJSONObject
+{"id":1} as UTSJSONObject

 type t = {
 	id:number