TypeScript之类

基础说明

先来看个例子:

class Person {
 name: string;
 constructor(name: string) {
 this.name = name;
 }
 say() {
 return "你好,我是" + this.name;
 }
}

这样,我们就定义了一个类,包含一个属性用于保存名称,一个构造器用于创建的时候设置名称,方法say用于获取名称描述:

let person = new Person("小强");
console.log(person.say());

打印的结果就是:“你好,我是小强”。

公共,私有与受保护的修饰符

也就是定义属性、方法等的访问权限,下面来具体说明。

public

默认访问权限就是public,你可以自由的访问程序里定义的成员,比如上面的例子和下面的代码是等价的:

class Person {
 public name: string;
 public constructor(name: string) {
 this.name = name;
 }
 public say() {
 return "你好,我是" + this.name;
 }
}

private

当成员被标记成 private时,它就不能在声明它的类的外部访问,比如我们对上面的例子进行改造:

class Person {
 private name: string;
 constructor(name: string) {
 this.name = name;
 }
 say() {
 return "你好,我是" + this.name;
 }
}
var person = new Person('小明');

可以看见,name现在是私有属性了,那么下面代码依旧是可以的:

person.say();

而下面的代码就不行:

// Property 'name' is private and only accessible within class 'Person'.
person.name;
温馨提示:两个类如果所有的成员的类型都是兼容的,我们就认为它们的类型是兼容的,可是,比较带有private或protected成员类型的时候,不只是类型需要相同,并且还需要来自同一份声明。

protected

和private类似,唯一不同的是,除了可以在声明它的类的内部访问,还可以在派生类中访问:

class Person {
 protected name: string;
 constructor(name: string) {
 this.name = name;
 }
}
 
class ChinaPerson extends Person {
 constructor(name: string) {
 super(name);
 }
 say() {
 return "你好,我是" + this.name + ",我来自中国";
 }
}
let chinaPerson = new ChinaPerson("小茜");

那么,下面代码也是可行的:

chinaPerson.say();

readonly修饰符

也就是标记只读,只读的属性只能声明时或构造函数里被初始化,例如:

class Person {
 readonly name: string = "小灰灰";
}
 
let person = new Person();

那么,读取是可以的:

person.name;

而下面当我们尝试修改就会出错:

// Cannot assign to 'name' because it is a read-only property.
person.name = "大灰灰";

参数属性

如果只读属性希望通过构造函数初始化,可以这样:

class Person {
 readonly name: string;
 constructor(name: string) {
 this.name = name;
 }
}

而更简单的写法是:

class Person {
 constructor(readonly name: string) {
 this.name = name;
 }
}

静态属性

也就是那些归属类而不是对象的属性或方法,例如:

class Person {
 static age: number;
}

直接使用类即可访问:

Person.age = 10;

而对象则无法访问:

// Property 'age' does not exist on type 'Person'. 
// Did you mean to access the static member 'Person.age' instead?ts(2576)
new Person().age = 10;

存取器

比如我们现在有一个场景:

class Person {
 name: string;
}

那么,我们创建好对象后就可以很容易的设置和获取属性name值:

let person = new Person();
person.name = "阿肥";
console.log(person.name);

可是现在有一个问题,name值在设置的时候必须满足一定规则。怎么办?我们就可以把上面的类改写成使用 getter 和 setter 来实现:

class Person {
 private _name: string;
 
 get name(): string {
 return this._name;
 }
 
 set name(name: string) {
 if (name.length > 4) {
 this._name = name;
 }
 }
}

名称设置名称的时候,长度必须大于4,不然会设置失败。

继承

比如狗是动物,那么狗就可以继承动物上面的一些内容:

class Animal {
 eat() {
 console.log("我会吃饭");
 }
}
 
class Dog extends Animal {
 bark() {
 console.log("我会狗叫");
 }
}

动物的实例上就有eat方法,而狗除了eat还可以bark。

抽象类

和接口类似,只不过可以包含成员的实现细节,abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法:

abstract class Dog {
 abstract bark(): void;
 run(): void {
 console.log("我在跑");
 }
}
作者:zxl20070701原文地址:https://segmentfault.com/a/1190000043336186

%s 个评论

要回复文章请先登录注册