TypeScript的初学习（1）

命令：tsc greeter.ts 可将ts文件转换成js文件

1. 基础类型

布尔值、数字、字符串（可使用模板字符串）、数组（数组泛型 --------let list: Array<number> = [1, 2, 3];）、

元组Tuple:元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同。let x: [string, number]    ----越界的元素，使用联合类型替代。

枚举：enum Color {Red = 1, Green = 2, Blue = 4} let c: Color = Color.Green;

Any: 不确定类型的时候定义，可以调用其对应类型的方法。

Void:表示没有任何类型，只能赋予undefined和null。

Null  Undefined 默认情况下，是所有类型的子类型。

Never永远不存在的值的类型，是任何类型的子类型，也可以赋值给任何类型，一般用于报错的时候。

Object除上述类型之外的类型

类型断言：<string>someValue  someValue as string（jsx中只允许使用）

2.变量类型

let 块级作用域：包含他们的块，for循环之外不能使用

不能在声明之前读或写，let之前是暂时性死区

重定义及屏蔽：var不在乎你声明多少次，你只会得到1个，但是let定义严格，不能重复定义。

const常量：被赋值后不能被改变。

3.接口

interface LabelledValue {
  label: string;  //可选属性 color?:string  
//只读属性 readonly x: number;
}

function printLabel(labelledObj: LabelledValue) {
  console.log(labelledObj.label);
}

let myObj = {size: 10, label: "Size 10 Object"};
printLabel(myObj);

readonly与const的区别：变量使用const,属性使用readonly

传入没有的属性，类型检查则会报错。

函数类型：

interface SearchFunc {
  (source: string, subString: string): boolean;
}
//函数的参数名不需要与接口里定义的名字相匹配
let mySearch: SearchFunc; mySearch = function(source: string, subString: string) { let result = source.search(subString); return result > -1; }

可索引的类型：用于描述能够通过索引得到的类型，比如a[10]

interface StringArray {
  [index: number]: string;
}

let myArray: StringArray;
myArray = ["Bob", "Fred"];

let myStr: string = myArray[0]; //'Bob'

支持两种索引签名：数字和字符串。可以同时使用，但是数字索引会转换成字符串，后字符串与字符串索引应一样。

继承接口

混合类型：一个对象可以同时作为函数和对象使用，并带有额外的属性。

接口继承类：接口可以继承类中的私有属性和公共属性。

接口中定义的方法，只能在类里实现它。

4.类

class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

let greeter = new Greeter("world");

继承：使用继承来扩展现有的类。

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

class Snake extends Animal {   //派生类
    constructor(name: string) { super(name);    //super(),在构造函数中访问this}
    move(distanceInMeters = 5) {
        console.log("Slithering...");
        super.move(distanceInMeters);   
    }
}

class Horse extends Animal {
    constructor(name: string) { super(name); }
    move(distanceInMeters = 45) {
        console.log("Galloping...");
        super.move(distanceInMeters);   //重写了类中的方法，根据不同的类调用不同的方法
    }
}

let sam = new Snake("Sammy the Python"); //子类或者超类
let tom: Animal = new Horse("Tommy the Palomino");

sam.move();    
tom.move(34);
//

Slithering...
Sammy the Python moved 5m.
Galloping...
Tommy the Palomino moved 34m.

公有、私有与受保护的修饰符

• public(默认)：在成员中都可以访问的。
• private:不能在声明它的类的外部访问。---------当两个或者多个类中存在相同的private成员，声明在不同的地方，则不兼容。
• protected: 与私有变量不同的是，protected成员在派生类中仍然可以访问。只是能访问。---------如果一个类的构造函数被保护，则不能被实例化，但是可以被派生类继承，访问而已。

readonly修饰符

参数属性：

class Octopus {
    readonly name: string;
    readonly numberOfLegs: number = 8;
    constructor (theName: string) {
        this.name = theName;
    }
}

class Octopus {
    readonly numberOfLegs: number = 8;
    constructor(readonly name: string) {
    }
   //readonly 根据后边的值的类型进行赋值，也可以是public或protected
}

存取器：get set 

静态属性：这些属性只存在类本身上，但是不是在类的实例上。--------访问静态属性的方法：.

抽象类：

abstract class Department {

    constructor(public name: string) {
    }

    printName(): void {
        console.log('Department name: ' + this.name);
    }

    abstract printMeeting(): void; // 必须在派生类中实现与接口的方法类似。
}

class AccountingDepartment extends Department {

    constructor() {
        super('Accounting and Auditing'); // 在派生类的构造函数中必须调用 super()
    }

    printMeeting(): void {
        console.log('The Accounting Department meets each Monday at 10am.');
    }

    generateReports(): void {
        console.log('Generating accounting reports...');
    }
}

let department: Department; // 允许创建一个对抽象类型的引用
department = new Department(); // 错误: 不能创建一个抽象类的实例
department = new AccountingDepartment(); // 允许对一个抽象子类进行实例化和赋值
department.printName();
department.printMeeting();
department.generateReports(); // 错误: 方法在声明的抽象类中不存在

高级技巧：

构造函数

class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

let greeter: Greeter;  //Greeter类的实例类型是Greeter
greeter = new Greeter("world");
console.log(greeter.greet());

把类当作接口使用