类型别名
type stringName = string;
const a:stringName;
type Name = string;
type NameFn = ()=> string;
// 函数:左侧输入的是任意类型,右侧返回一个string类型
type NameOrNameFn = Name | NameFn;
function fn(n:NameOrNameFn):Name{
if(typeof n === 'string'){
return n
}else{
return n()
}
}
使用type创建别名
类型别名常用于联合类型。
字符串字面量类型
type EventsName = 'click'|'mousemove'|'scroll';
function EventFn(ele:Element,event:EventsName){
// do sometings
}
EventFn(document.getElementById('hello'),'click'); // ok
EventFn(document.getElementById('hello'),'dbclick');
// 报错,event不能为'dbclick',只能取3种中的一种
注意,类型别称和字面量类型都是使用type
来进行定义
元组
数组合并了相同类型的对象,而元组合并了不同类型的对象。
元组起源于函数编程语言如(F#),这些语言中会频繁使用元组
简单例子
let s = [string,number] = ['213',123];
当赋值或访问一个已知索引的元素时,会得到正确的类型
let tom: [string, number];
tom[0] = 'Tom';
tom[1] = 25;
tom[0].slice(1);
tom[1].toFixed(2);
也可以只赋值其中一项
let tom: [string, number];
tom[0] = 'Tom';
但是当直接对元组类型的变量进行初始化或者赋值的时候,需要提供所有元组类型中指定的项
let tom: [string, number];
tom = ['Tom', 25];
let tom: [string, number];
tom = ['Tom'];
// Property '1' is missing in type '[string]' but required in type '[string, number]'.
越界的元素
当添加越界的元素时,它的类型会被限制为元组中每个类型的联合类型
let tom: [string, number];
tom = ['Tom', 25];
tom.push('male');
tom.push(true);
// Argument of type 'true' is not assignable to parameter of type 'string | number'.
枚举
简单的例子
枚举使用enum
关键字来定义
enum Days {
sum,Mon,Thu,Fri,Sat};
枚举成员会被赋值为从0开始递增的数字,同时也会对枚举值到枚举名进行反射映射:
enum Days {
Sun, Mon, Tue, Wed, Thu, Fri, Sat};
console.log(Days["Sun"] === 0); // true
console.log(Days["Mon"] === 1); // true
console.log(Days["Tue"] === 2); // true
console.log(Days["Sat"] === 6); // true
console.log(Days[0] === "Sun"); // true
console.log(Days[1] === "Mon"); // true
console.log(Days[2] === "Tue"); // true
console.log(Days[6] === "Sat"); // true
事实上,上面的例子会被编译为:
var Days;
(function (Days) {
Days[Days["Sun"] = 0] = "Sun";
Days[Days["Mon"] = 1] = "Mon";
Days[Days["Tue"] = 2] = "Tue";
Days[Days["Wed"] = 3] = "Wed";
Days[Days["Thu"] = 4] = "Thu";
Days[Days["Fri"] = 5] = "Fri";
Days[Days["Sat"] = 6] = "Sat";
})(Days || (Days = {
}));
手动赋值
我们也可以给枚举项手动赋值
enum Days{
Sun=7,Mon=1};
console.log(Days['Sun']===7);
未手动赋值的枚举项会接着上一个枚举项递增
enum Days{
Sun=3,Mon=1,Two,Wed}
console.log(Days['Sun']===3) // true
console.log(Days[3]==='Sun') // false
console.log(Days[3]==='Wed') // true
递增到3与前面的Sum的值重复了,导致覆盖了。
手动赋值的枚举项可以不是数字,此时需要使用类型断言来让 tsc 无视类型检查 (编译出的 js 仍然是可用的):
enum Days = {
Sun=4,Mon,Tue,Wed,Sat=<any>"s"};
常数项和计算所得项
枚举项有两种类型:常数项和计算所得项
enum Color{Red,Greem.Blue ="blue".length};
上面的例子中,"blue".length
就是一个计算所得项
上面的例子不会报错,但是如果紧接在计算所得项后面的是未手动赋值的项,那么它就会因为无法获得初始值而报错
enum Color {Red = "red".length, Green, Blue};
// index.ts(1,33): error TS1061: Enum member must have initializer.
// index.ts(1,40): error TS1061: Enum member must have initializer.
当满足以下条件时,枚举成员被当作是常数:
- 不具有初始化函数并且之前的枚举成员是常数。在这种情况下,当前枚举成员的值为上一个枚举成员的值加
1
。但第一个枚举元素是个例外。如果它没有初始化方法,那么它的初始值为0
。 - 枚举成员使用常数枚举表达式初始化。常数枚举表达式是 TypeScript 表达式的子集,它可以在编译阶段求值。当一个表达式满足下面条件之一时,它就是一个常数枚举表达式:
- 数字字面量
- 引用之前定义的常数枚举成员(可以是在不同的枚举类型中定义的)如果这个成员是在同一个枚举类型中定义的,可以使用非限定名来引用
- 带括号的常数枚举表达式
+
,-
,~
一元运算符应用于常数枚举表达式+
,-
,*
,/
,%
,<<
,>>
,>>>
,&
,|
,^
二元运算符,常数枚举表达式做为其一个操作对象。若常数枚举表达式求值后为 NaN 或 Infinity,则会在编译阶段报错
所有其它情况的枚举成员被当作是需要计算得出的值。
常数枚举
常数枚举是使用const enum
定义的枚举类型
const enum Directions{
up,
down,
left,
right
};
let dir = [Directions.up,Directions.down,Directions.left,Directions,right];
常数枚举会在编译阶段销毁,不能包含计算成员。
上例编辑的结果是:
var dir = [0,1,2,3]
假如包含了计算成员
const enum Color{
Blue,
Red,
Green:'green'.length
}
// index.ts(1,38): error TS2474: In 'const' enum declarations member initializer must be constant expression.
外部枚举
外部枚举是使用了declare enum 来定义的
declare enum Color{
Blue,
Green,
Yellow
}
let color= [Color.Blue,Color.Green,Color.Yellow]
之前提到过,declare
定义的类型只会用于编译时的检查,编译结果中会被删除。
上例的编译结果是:
var directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right];
类
传统方式中,JavaScript通过构造函数实现类的概念,通过原型链的方式实现了继承。而在ES6中,终于迎来了class
类的概念
- 类(Class):定义了一件事物的抽象特定,包含它的属性和方法。
- 对象(Object):类的实例,通过
new
生成 - 面对对象(OOP):封装,继承,多态
- 继承:子类继承父类,方法属性,子类除了拥有父类的特性外,还有一些更具体的特性
- 多态:由继承产生相关的不同的类,比如Cat和Dog都继承animal,但是分别实现了不同的eat方法,针对与某一个实例,我们无需知道它是dog还是cat,就可以直接调用eat方法,因为程序内部会自动判断。
- 封装:将对数据的操作细节隐藏起来,只暴露对外的接口,外界在调用端不需要知道细节,就能通过对外提供的接口访问该对象,同时也保证了外界无法更改对象内部的数据。
- 存储器(getter& setter):用以改变属性的读取和赋值行为。
- 修饰符:用来修饰一些关键字,用来限定成员的属性或类型的性质。比如
pulic
表示公由属性或方法 - 抽象类: :抽象类是供其他类继承的基类,抽象类不允许被实例化。抽象类中的抽象方法必须在子类中被实现
- 接口: 不同类之间公有的属性或方法,可以抽象成一个接口。接口可以被类实现(implements)。一个类只能继承自另一个类,但是可以实现多个接口
ES6中类的用法
属性和方法
使用class
定义类,使用constructor
定义构造函数。
通过new
生成新的实例的时候,会自动调用构造函数。
class Animal {
public name;
constructor(name:string){
this.name = name;
}
sayHi():string{
return `My name is ${this.name}`;
}
}
let a = new Animal('Jack');
console.log(a.sayHi()) // My name is Jack
类的继承
使用 extends
关键字实现继承,子类中使用 super
关键字来调用父类的构造函数和方法。
class Dog extends Animal {
constructor(name:string){
super(name); // 调用父类的constructor(name)
console.log(name)
}
sayHi():string{
return 'Meow'+super.sayHi()
}
}
存取器
使用 getter 和 setter 可以改变属性的赋值和读取行为:
class Animal {
constructor(name:string){
this.name = name;
}
get name(){
return 'jack';
}
set name(value){
console.log('setter:'+value)
}
}
静态方法
使用 static
修饰符修饰的方法称为静态方法,它们不需要实例化,而是直接通过类来调用:
class Animal {
static isAnimal(a) {
return a instanceof Animal;
}
}
let a = new Animal('Jack');
Animal.isAnimal(a); // true
a.isAnimal(a); // TypeError: a.isAnimal is not a function
ES7中类的用法
实例属性
ES6 中实例的属性只能通过构造函数中的 this.xxx
来定义,ES7 提案中可以直接在类里面定义
class Animal {
name = 'Jack';
constructor() {
// ...
}
}
let a = new Animal();
console.log(a.name); // Jack
静态属性
ES7 提案中,可以使用 static
定义一个静态属性:
class Animal {
static num = 42;
constructor() {
// ...
}
}
console.log(Animal.num); // 42
TypeScript中类的用法
public private和protected
TypeScript中可以使用三种访问修饰符,分别是public private和protected。
- public 修饰的属性或方法是公有的,可以在任何地方被访问到,默认所有的属性和方法都是
public
的 - private 修饰的属性或方法是私有的,不能在声明它的类的外部访问
- protected 修饰的属性或方法是受保护的,它和 private 类似,区别是它在子类中也是允许被访问的
下面举一些例子:
class Animal {
public name;
public constructor(name) {
this.name = name;
}
}
let a = new Animal('Jack');
console.log(a.name); // Jack
a.name = 'Tom';
console.log(a.name); // Tom
上面的例子中,name
被设置为了 public
,所以直接访问实例的 name
属性是允许的。
很多时候,我们希望有的属性是无法直接存取的,这时候就可以用 private
了:
class Animal {
private name;
public constructor(name) {
this.name = name;
}
}
let a = new Animal('Jack');
console.log(a.name);
a.name = 'Tom';
// index.ts(9,13): error TS2341: Property 'name' is private and only accessible within class 'Animal'.
// index.ts(10,1): error TS2341: Property 'name' is private and only accessible within class 'Animal'.
需要注意的是,TypeScript 编译之后的代码中,并没有限制 private
属性在外部的可访问性。
上面的例子编译后的代码是:
var Animal = (function () {
function Animal(name) {
this.name = name;
}
return Animal;
})();
var a = new Animal('Jack');
console.log(a.name);
a.name = 'Tom';
使用 private
修饰的属性或方法,在子类中也是不允许访问的:
class Animal {
private name;
public constructor(name) {
this.name = name;
}
}
class Cat extends Animal {
constructor(name) {
super(name);
console.log(this.name);
}
}
// index.ts(11,17): error TS2341: Property 'name' is private and only accessible within class 'Animal'.
而如果是用 protected
修饰,则允许在子类中访问:
class Animal {
protected name;
public constructor(name) {
this.name = name;
}
}
class Cat extends Animal {
constructor(name) {
super(name);
console.log(this.name);
}
}
当构造函数修饰为 private
时,该类不允许被继承或者实例化:
class Animal {
public name;
private constructor(name) {
this.name = name;
}
}
class Cat extends Animal {
constructor(name) {
super(name);
}
}
let a = new Animal('Jack');
// index.ts(7,19): TS2675: Cannot extend a class 'Animal'. Class constructor is marked as private.
// index.ts(13,9): TS2673: Constructor of class 'Animal' is private and only accessible within the class declaration.
当构造函数修饰为 protected
时,该类只允许被继承:
class Animal {
public name;
protected constructor(name) {
this.name = name;
}
}
class Cat extends Animal {
constructor(name) {
super(name);
}
}
let a = new Animal('Jack');
// index.ts(13,9): TS2674: Constructor of class 'Animal' is protected and only accessible within the class declaration.
参数属性
修饰符和readonly
还可以使用构造函数参数中,等同于类中定义该属性同时给该属性赋值,使代码更简洁
class Animal{
// public name:string;
constructor(pubilc name:string){
// this.name = name;
}
}
readonly
只读属性关键字,只允许出现在属性声明或索引签名或构造函数中
class Animal {
readonly name;
public constructor(name) {
this.name = name;
}
}
let a = new Animal('Jack');
console.log(a.name); // Jack
a.name = 'Tom';
// index.ts(10,3): TS2540: Cannot assign to 'name' because it is a read-only property.
注意如果 readonly
和其他访问修饰符同时存在的话,需要写在其后面。
class Animal {
// public readonly name;
public constructor(public readonly name) {
// this.name = name;
}
}
抽象类
abstract
用于定义抽象类和其他的抽象方法
什么是抽象类?
首先,抽象类是不允许被实例化的:
abstract class Animal {
public name;
public constructor(name) {
this.name = name;
}
public abstract sayHi();
}
let a = new Animal('Jack');
// index.ts(9,11): error TS2511: Cannot create an instance of the abstract class 'Animal'.
上面的例子中,我们定义了一个抽象类 Animal
,并且定义了一个抽象方法 sayHi
。在实例化抽象类的时候报错了。
其次,抽象类中的抽象方法必须被子类实现
abstract class Animal {
public name;
public constructor(name) {
this.name = name;
}
public abstract sayHi();
}
class Cat extends Animal {
public eat() {
console.log(`${
this.name} is eating.`);
}
}
let cat = new Cat('Tom');
// index.ts(9,7): error TS2515: Non-abstract class 'Cat' does not implement inherited abstract member 'sayHi' from class 'Animal'.
上面的例子中,我们定义了一个类 Cat
继承了抽象类 Animal
,但是没有实现抽象方法 sayHi
,所以编译报错了
下面是一个正确使用抽象类的例子:
abstract class Animal {
public name;
public constructor(name) {
this.name = name;
}
public abstract sayHi();
}
class Cat extends Animal {
public sayHi() {
console.log(`Meow, My name is ${
this.name}`);
}
}
let cat = new Cat('Tom');
上面的例子中,我们实现了抽象方法 sayHi
,编译通过了。
需要注意的是,即使是抽象方法,TypeScript 的编译结果中,仍然会存在这个类,上面的代码的编译结果是:
var __extends =
(this && this.__extends) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
};
var Animal = (function () {
function Animal(name) {
this.name = name;
}
return Animal;
})();
var Cat = (function (_super) {
__extends(Cat, _super);
function Cat() {
_super.apply(this, arguments);
}
Cat.prototype.sayHi = function () {
console.log('Meow, My name is ' + this.name);
};
return Cat;
})(Animal);
var cat = new Cat('Tom');
类的类型
给类加上 TypeScript 的类型很简单,与接口类似:
class Animal {
name: string;
constructor(name: string) {
this.name = name;
}
sayHi(): string {
return `My name is ${
this.name}`;
}
}
let a: Animal = new Animal('Jack');
console.log(a.sayHi()); // My name is Jack
类与接口
之前学习过,接口(Interfaces)可以用于对「对象的形状(Shape)」进行描述。
这一章主要介绍接口的另一个用途,对类的一部分行为进行抽象。
类实现接口
实现(implements)是面向对象中的一个重要概念。一般来讲,一个类只能继承自另一个类,有时候不同类之间可以有一些共有的特性,这时候就可以把特性提取成接口(interfaces),用 implements
关键字来实现。这个特性大大提高了面向对象的灵活性。
举例来说,门是一个类,防盗门是门的子类。如果防盗门有一个报警器的功能,我们可以简单的给防盗门添加一个报警方法。这时候如果有另一个类,车,也有报警器的功能,就可以考虑把报警器提取出来,作为一个接口,防盗门和车都去实现它
interface Alarm{
alert():void
}
class Door {
}
class SecurityDoor extends Door implements Alarm{
alert(){
console.log('Car')
}
}
class Car implements Alarm {
alert(){
console.log('Alart')
}
}
一个类可以实现多个接口
interface Alarm {
alert():void
}
interface Light{
lightOut():void
lightOff():void
}
class Car implements Alarm,Light{
alert(){
console.log('Alert')
}
lightOut(){
console.log('LightOut')
}
lightOff(){
console.log("lightOff")
}
}
上例中,Car
实现了 Alarm
和 Light
接口,既能报警,也能开关车灯。
接口继承接口
接口与接口之间可以是继承关系:
interface Alarm {
alert():void
}
interface Right extends Alarm{
lightOn(): void;
lightOff(): void;
}
这很好理解,Right 继承了 Alarm,除了拥有 alert
方法之外,还拥有两个新方法 lightOn
和 lightOff
。
接口继承类
常见的面向对象语言中,接口是不能继承类的,但是在 TypeScript 中却是可以的
class Point {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
interface Point3d extends Point {
z: number;
}
let point3d: Point3d = {
x: 1, y: 2, z: 3};
为什么 TypeScript 会支持接口继承类呢?
实际上,当我们在声明 class Point
时,除了会创建一个名为 Point
的类之外,同时也创建了一个名为 Point
的类型(实例的类型)
所以我们既可以将 Point
当做一个类来用(使用 new Point
创建它的实例)
class Point {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
const p = new Point(1, 2);
也可以将 Point
当做一个类型来用(使用 : Point
表示参数的类型):
class Point {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
function printPoint(p: Point) {
console.log(p.x, p.y);
}
printPoint(new Point(1, 2));
这个例子实际上可以等价于
class Point {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
interface PointInstanceType {
x: number;
y: number;
}
function printPoint(p: PointInstanceType) {
console.log(p.x, p.y);
}
printPoint(new Point(1, 2));