提交 825e808f 编写于 作者: W wanganxp

完善uts语法文档

上级 fbaede71
......@@ -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`
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册