typescript

一、基础类型

主要包括以下：number、string、undefined、null、boolean、symbol等

默认情况下null、undefined是所有类型的子类型，可以把null、undefined赋值给number类型的变量，但是当指定了--strictNullChecks标记，null、undefined只能赋值给void和自己

let isDone: boolean = false;

let decLiteral: number = 6;

let name: string = "bob";

let u: undefined = undefined;

let n: null = null;

let s:symbol = Symbol(111);

数组

// 定义数组有两种方式

1、let arr:number[] = [1, 2, 3];

2、let arr:Array<number> = [1, 2, 3];

元组

let x: [string, number, boolean];

x = ['hello', 2, false];

x[4] = false; // 可以赋值给(string | number | boolean)联合类型

x[5] = undefined;  // Error 不可以赋值给 (string | number | boolean)类型

枚举

// 默认情况下，从0开始编号
enum Color {Red, Green, Yellow};

let c:Color = Color.Red;   // 0

// 也可以主动为其赋值
enum Color {Red='red', Green='green', Yellow='yellow'};
let c:Color = Color.Red;   // red

Any

可以为其赋值任何类型的数据

let notSure: any = 4;
notSure = "maybe a string instead";

Void

某种程度上，void和any效果一样，当函数没有返回值时，可以的设置返回值类型为void。

function fun():void{
    console.log('console message');
}

Object

let o:object = {a: 1};

类型断言

类型断言有两种方式：

尖括号”语法
let someValue:any = 'string';

const num:number = (<string>someValue).length;

as语法

let someValue:any = 'string';

const num:number = (someValue as string).length;

当在typescript中使用jsx时，只能as语法能使用

二、interface接口

描述对象拥有的各种属性的外形，也可以描述函数类型

interface animal {
    name: string,
    age?: number,  // 可以选择参数
    readonly color: 'string', // 只读参数   
    (name:string, age:number): boolean,  // 函数类型
}

接口继承，并且可同时集成多个接口。

interface Shape {
    color: string;
}
interface PenStroke {
    penWidth: number;
}

interface Square extends Shape, PenStroke  {
    sideLength: number;
}

接口继承类

当接口继承了一个类类型时，它会继承类的成员，但不包括其实现，

class Control {
    private state: any;
}

interface SelectableControl extends Control {
    select(): void;
}

三、类

class Animal {
    move(distanceInMeters: number = 0) {
        console.log(`Animal moved ${distanceInMeters}m.`);
    }
}

// 类继承
class Dog extends Animal {
    bark() {
        console.log('Woof! Woof!');
    }
}

private 

当成员被标记成private时，它就不能在声明它的类的外部访问，

class Animal {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}

new Animal("Cat").name; // 错误: 'name' 是私有的.

protected

protected和private修饰符相似，但有一点不同，protected成员在派生类中仍然可以访问。

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

class Employee extends Person {
    private department: string;

    constructor(name: string, department: string) {
        super(name)
        this.department = department;
    }

    public getElevatorPitch() {
        // 在派生类中可以访问
        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
    }
}

let howard = new Employee("Howard", "Sales");
console.log(howard.getElevatorPitch());
console.log(howard.name); // 错误   外部访问不了

四、泛型

泛型即就是在定义时，不确定参数的类型，泛型通过<>形式表述，

function returnItem<T>(para: T): T {
    return para
}

多个类型参数

function swap<T, U>(tuple: [T, U]): [U, T] {
    return [tuple[1], tuple[0]];
}
swap([7, 'seven']);

五、类型推断

类型推断是在初始化变量和成员时，设置默认参数值和决定函数返回值时。

六、高级类型

交叉类型是将多个类型合并为一个类型，包含了所需的所有类型的特性，用&分隔，

例如：A & B & C

Person & Serializable & Loggable同时是 Person 和 Serializable 和 Loggable。

就是说这个类型的对象同时拥有了这三种类型的成员。

联合类型表示一个值可以是几种类型之一，用数显（ | ）分隔每个类型， number | string