From 825e808fc2b469e208f6f21e5e600420e912263a Mon Sep 17 00:00:00 2001 From: wanganxp Date: Sun, 20 Nov 2022 04:35:07 +0800 Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E5=96=84uts=E8=AF=AD=E6=B3=95?= =?UTF-8?q?=E6=96=87=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/tutorial/syntax-uts.md | 337 +++++++++++++++++++++++------------- 1 file changed, 213 insertions(+), 124 deletions(-) diff --git a/docs/tutorial/syntax-uts.md b/docs/tutorial/syntax-uts.md index 2fb43582d..2ded0435a 100644 --- a/docs/tutorial/syntax-uts.md +++ b/docs/tutorial/syntax-uts.md @@ -34,6 +34,8 @@ let str: string = "hello"; // 声明一个字符串变量 str = "hello world"; // 重新赋值 ``` +类型除了 string 之外，更多类型[见下](#基本类型) + 2. const 声明一个只读常量，只能为其赋值一次。语法 `const [变量名] : [类型] = 值;`。 @@ -510,7 +512,7 @@ try { ``` -## 函数 +## 函数（function） 函数是 uts 中的基本组件之一。 一个函数是 uts 过程 — 一组执行任务或计算值的语句。要使用一个函数，你必须将其定义在你希望调用它的作用域内。 @@ -666,199 +668,192 @@ const a3 = arr.map((s): number => s.length); console.log(a3); // logs [ 8, 6, 7, 9 ] ``` -## 类 +## 类（class） + +uts 中使用关键字 class 声明类。 -uts 中使用关键字 class 声明类 +类声明由类名以及由花括号包围的类体构成。 ```ts +// 定义Person Class class Person { - /*……*/ + } ``` -类声明由类名以及由花括号包围的类体构成。 - -### 构造函数 +### 基本概念 -constructor 是一种用于创建和初始化 class 创建的对象的特殊方法。 +类是对象化的概念，有属性、方法、构造函数。 +- 属性：是一个简单的值，可以是字符串、数字、布尔或另一个class。可以用 `对象.属性名` 的访问，也可以通过 `对象.属性名=xxx` 的方式赋值。 +- 方法：是一段代码的集合，有入参、有返回值（均可选）。可以用 `对象.方法名(参数)` 的方式访问。 +- 构造函数：用于初始化实例。详[见下](#constructor) -- 语法： +下面的示例中，定义了一个 Person 的 class，它有一个属性 name，有一个构造函数 constructor（名称不可改），还有一个方法 getNameLength。 ```ts -constructor([arguments]) { ... } +// 定义Person Class +class Person { + name:string = ""; // 属性name + constructor(newname:string) { // 构造函数，参数newname + console.log("开始实例化"); + this.name = newname; + } + getNameLength():number{ // 方法getNameLength + return this.name.length + } +} ``` -- 描述： - -在一个类中只能有一个名为 “constructor” 的特殊方法。 一个类中出现多次构造函数 (constructor)方法将会抛出一个 SyntaxError 错误。 +定义了class后，需要实例化（通过new关键字）。定义一个实例后，即可使用该实例对象的属性和方法。 -在一个构造方法中可以使用 super 关键字来调用一个父类的构造方法。 +一个class可以被多次实例化为不同的实例，互不影响。 -如果没有显式指定构造方法，则会添加默认的 constructor 方法。 +```ts +//实例化上面定义的class并调用其属性方法 +let p = new Person("tom"); // 使用 new 关键字实例化对象时，会自动触发构造函数 +console.log(p.name); // 访问p这个对象的属性name，返回值tom +console.log(p.getNameLength()); // 调用p这个对象的方法getNameLength，返回值3 -如果不指定一个构造函数(constructor)方法, 则使用一个默认的构造函数(constructor)。 +let p2 = new Person("jerry"); // 使用 new 关键字再实例化一个新对象 +console.log(p2.name); //jerry +console.log(p2.getNameLength()); //5 -- 示例： - -```ts -class Polygon { - constructor() { - this.name = "Polygon"; - } -} -class Square extends Polygon { - constructor() { - super(); - } -} ``` -### 继承 +### 构造函数（constructor）@constructor -uts 允许使用继承来扩展现有的类。 +构造函数 constructor ，在创建新对象时（new的时候）会自动执行，用于初始化对象属性。 - 语法： ```ts -class ChildClass extends ParentClass { ... } +constructor([arguments]) { ... } ``` - 描述： -extends 关键字用来创建一个类的子类。 +你可以不写构造函数。如果没有显式指定构造函数，运行环境会自动添加默认的 constructor 方法。 + +在一个类中只能有一个名为 “constructor” 的特殊方法。一个类中出现多次构造函数 (constructor)方法将会抛出一个 SyntaxError 错误。 - 示例： ```ts -class Polygon {} +class Person { + name:string = ""; + constructor(newname:string) { + this.name = newname; + } +} -class Square extends Polygon {} +let person = new Person("tom"); // 使用 new 关键字创建对象时，会自动触发构造函数 +console.log(person.name); // tom ``` -#### 覆盖方法 - -uts 对于可覆盖的成员以及覆盖后的成员需要显式修饰符： - +在一个构造函数中可以使用 super 关键字来调用一个父类的构造函数。这涉及继承的概念。如不了解继承可[见下](#extends) ```ts class Polygon { - name(): string { - return "Polygon"; + constructor() { + this.name = "Polygon"; } } class Square extends Polygon { - override name(): string { - return "Square"; - } -} -``` - -Square.name 函数上必须加上 override 修饰符。如果没写，编译器会报错。 - -#### 覆盖属性 - -属性与方法的覆盖机制相同。在超类中声明然后在派生类中重新声明的属性必须以 override 开头，并且它们必须具有兼容的类型。 - -```ts - class Shape { - vertexCount: Int = 0 -} - -class Rectangle extends Shape { - override vertexCount = 4 -} -``` - -#### 调用超类实现 - -派生类中的代码可以使用 super 关键字调用其超类的函数实现： - -```ts -class Rectangle { - draw() {} -} -class FilledRectangle extends Rectangle { - override draw() { - super.draw(); + constructor() { + super(); } } - ``` ### 实例属性 -uts 中实例属性存在于类的每一个实例中。 +class 有实例属性和静态属性。uts 中实例属性存在于类的每一个实例中。 #### 声明实例属性 uts 可以在类中声明属性，默认可读，可写。 ```ts -class Address { - city: String = "beijing"; +class Person { + name:string = ""; // 声明实例属性name + city:string = "beijing" // 声明实例属性city + constructor(newname:string) { + this.name = newname; // 在构造函数中对name重新赋值 + } } -``` - -使用一个实例属性，以类实例引用它即可： -```ts -function copyAddress(address: Address): Address { - const result = new Address(); - result.city = address.city; // 访问 city 属性 - return result; -} +let person1 = new Person("tom"); // 使用 new 关键字创建对象时，会自动触发构造函数 +console.log(person1.name); //tom +console.log(person1.city); //beijing +let person2 = new Person("jerry"); // 使用 new 关键字创建对象时，会自动触发构造函数 +console.log(person2.name); //jerry +console.log(person2.city); //beijing ``` #### Getter 与 Setter -uts 支持通过 getters/setters 来截取对对象成员的访问。 它能帮助你有效的控制对对象成员的访问。 +uts 支持通过 getters/setters 来截取对对象属性的访问。它可以理解为属性的读取/写入的拦截器。 + +下面的例子中，针对 person对象提供了name的get和set的拦截，paascode不正确时无法修改name的值。 ```ts const passcode = "secret passcode"; -class Employee { - private _fullName: string = ""; - - get fullName(): string { - return this._fullName; - } - - set fullName(newName: string) { - if (passcode === "secret passcode") { - this._fullName = newName; - } else { - console.log("Error: Unauthorized update of employee!"); - } - } +class Person { + private _name: string = ""; // private是私有的，外部不能访问 + get name(): string { // 读取name会触发此拦截器 + console.log("start to get person.name"); + return this._name; + } + set name(newName: string) { // 给name赋值会触发此拦截器 + console.log("start to set person.name"); + if (passcode === "secret passcode") { // 校验是否有权修改name的值，这里的条件可以修改以方便测试 + this._name = newName; + } else { + console.log("Error: set person.name fail"); + } + } } +let p = new Person() +p.name = "tom" // 会打印"start to set person.name" +console.log(p.name); // 先打印"start to get person.name"，然后打印"tom" ``` #### readonly -uts 可以使用 readonly 关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。 +uts 可以使用 readonly 关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。 ```ts -class Octopus { - readonly name: string; - readonly numberOfLegs: number = 8; - constructor (theName: string) { - this.name = theName; - } +class Person { + readonly name: string; + readonly age: number = 0; + constructor (theName: string) { + this.name = theName; + } } -let dad = new Octopus("Man with the 8 strong legs"); -dad.name = "Man with the 3-piece suit"; // 错误! name 是只读的. +let p = new Person("tom"); +console.log(p.name); +p.name = "jerry"; // 错误! name 是只读的 +p.age = 1 // 错误！ age 是只读的 ``` -### 静态属性 +但 readonly 更多是一种开发环境的语法校验。在运行时，该值往往可以改变。 + +### 静态属性（static） 使用关键字 static 来将一个属性声明为静态属性。静态属性不会在实例中被调用，而只会被类本身调用。 ```ts -class ClassWithStaticField { - static staticField = "static field"; +class Person { + static age:number = 10; // age是静态属性。不能在实例p中访问，但可以通过类Person访问 + getAge():number{ + return Person.age + } } - -console.log(ClassWithStaticField.staticField); +console.log(Person.age); //10 +let p = new Person(); //新建一个实例 +console.log(p.age); //undefined +console.log(p.getAge()); //10 ``` ### 实例方法 @@ -869,6 +864,8 @@ uts 中实例方法存在于类的每一个实例中。 uts 可以在类中声明实例方法。 +下面定义一个通过高度乘以宽度计算面积的类。 + ```ts class Rectangle { private height:number; @@ -887,10 +884,10 @@ class Rectangle { ```ts const square = new Rectangle(10, 10); -square.calcArea(); +square.calcArea(); // 100 ``` -### 静态方法 +### 静态方法（static） 使用关键字 static 来将一个方法声明为静态方法。静态方法不会在实例中被调用，而只会被类本身调用。它们经常是工具函数，比如用来创建或者复制对象。 @@ -900,10 +897,100 @@ class ClassWithStaticMethod { return "static method has been called."; } } -ClassWithStaticMethod.staticMethod(); +ClassWithStaticMethod.staticMethod(); // 不实例化，直接调用class的方法 +``` + +### 继承（extends）@extends + +uts 允许使用继承来扩展现有的类。扩展的派生类继承了父类的属性方法，但又可以添加自己独有的属性方法，以及复写父类定义的属性方法。 + +被继承的类称为父类（如果是顶级类也称为超类），新扩展的类称为派生类（也称为子类）。 + +- 语法： + +```ts +class ChildClass extends ParentClass { ... } +``` + +- 描述： + +extends 关键字用来创建一个类的派生类。 + +- 示例： + +```ts +// 定义父类 +class Person { + name:string = ""; + constructor(newname:string) { + this.name = newname; + } + } +// 定义派生类 +class Developer extends Person{ + likeLanguage:string = "ts" +} + +let d = new Developer("tom"); // 实例化。由于派生类没有声明和复写自己的构造函数，所以默认继承了父类的构造函数 +console.log(d.name); // tom +console.log(d.likeLanguage); // ts +``` + +- 如果要控制父类中某些属性方法不被子类继承，可使用可见性修饰符（private、protected等），具体[见下](#modifier) +- 多重继承：子类还可以被孙类继承 + +#### 覆盖方法（override） + +uts 对于可覆盖的成员以及覆盖后的成员需要显式修饰符： + +```ts +class Polygon { + name(): string { + return "Polygon"; + } +} + +class Square extends Polygon { + override name(): string { + return "Square"; + } +} +``` + +Square.name 函数上必须加上 override 修饰符。如果没写，编译器会报错。 + +#### 覆盖属性 + +属性与方法的覆盖机制相同。在超类中声明然后在派生类中重新声明的属性必须以 override 开头，并且它们必须具有兼容的类型。 + +```ts +class Shape { + vertexCount: Int = 0 +} + +class Rectangle extends Shape { + override vertexCount = 4 +} +``` + +#### 调用超类实现 + +派生类中的代码可以使用 super 关键字调用其超类的函数实现： + +```ts +class Rectangle { + draw() {} +} +class FilledRectangle extends Rectangle { + override draw() { + super.draw(); + } +} + ``` -### 可见性修饰符 + +### 可见性修饰符@modifier 类的方法与属性都可以有可见性修饰符。 @@ -1012,6 +1099,8 @@ test.test() ## 内置对象 +uts 有一批内置对象。不管将 uts 编译为 js/kotlin/swfit，这些内置对象都可以跨平台使用。 + ### console #### debug @@ -2056,7 +2145,7 @@ clearInterval(timer) - `default` * 与 `switch` 搭配，匹配不存在时做的事情，也可以用于 `export` 语句。 - `delete` - * 在 `Javascript` 平台，用于删除对象的某个属性；如果没有指向这个属性的引用，那它最终会被释放。 + * 用于删除对象的某个属性；如果没有指向这个属性的引用，那它最终会被释放。（目前仅支持 `Javascript` 平台） - `do` * 创建一个执行指定语句的循环，直到condition值为 false。在执行statement 后检测condition，所以指定的statement至少执行一次。 - `else` @@ -2094,7 +2183,7 @@ clearInterval(timer) - `try` ] * 捕获一个异常。 - `typeof` - * 在 `Javascript` 平台，返回一个字符串，表示未经计算的操作数的类型。 + * 返回一个字符串，表示未经计算的操作数的类型。（目前仅支持 `Javascript` 平台） - `var` * 声明一个变量，不建议使用。 - `void` @@ -2102,9 +2191,9 @@ clearInterval(timer) - `while` * 在某个条件表达式为真的前提下，循环执行指定的一段代码，直到那个表达式不为真时结束循环。 - `with` - * 在 `Javascript` 平台，扩展一个语句的作用域链。 + * 扩展一个语句的作用域链。（目前仅支持 `Javascript` 平台） - `yield` - * 在 `Javascript` 平台，用来暂停和恢复一个生成器函数。 + * 用来暂停和恢复一个生成器函数。（目前仅支持 `Javascript` 平台） - `enum` - `implements` - `interface` -- GitLab