摘要：訪問(wèn)越界的元素，使用聯(lián)合類(lèi)型替代。構(gòu)造函數(shù)不能聲明返回類(lèi)型。在子類(lèi)中運(yùn)行構(gòu)造函數(shù)式繼承實(shí)現(xiàn)對(duì)父類(lèi)的構(gòu)造函數(shù)繼承。的核心原則之一是對(duì)值所具有的進(jìn)行類(lèi)型檢查。外部模塊則稱之為模塊語(yǔ)法通過(guò)關(guān)鍵字，將模塊的方法屬性暴露出來(lái)。

介紹

TypeScript是JavaScript的超集，為JavaScript的生態(tài)增加了類(lèi)型機(jī)制，并最終將代碼編譯為純粹的JavaScirpt代碼。

編譯

瀏覽器加載文件編譯

注意，編譯的TypeScript文件需要放在編譯文件之前

自動(dòng)化構(gòu)架工具

1：fis

fis插件：fis-parser-typescript

var fis = require("fis3");

var typescirpt = require("fis3-parser-typescript");

fis.match("**.ts", {
    parser: fis.plugin("typescript"),
    rExt: ".js"
});

2: gulp
使用gulp插件：gulp-typescript

var gulp = require("gulp");

var ts = require("gulp-typescript");

gulp.task("compileTs", function () {
    
    gulp.src("**.ts")
        .pipe(ts())
        .pipe(gulp.dest("dist"));
    
});

gulp.task("default", ["compileTs"]);

基礎(chǔ)類(lèi)型

typescript囊括了所有JavaScript基本類(lèi)型

基本類(lèi)型

number 數(shù)字類(lèi)型

string 字符串類(lèi)型

boolean 布爾類(lèi)型

any 任意一種

數(shù)組

定義數(shù)組
兩部分：前面一部分表示數(shù)組成員的類(lèi)型，后面一部分表示告知是一個(gè)數(shù)組。

let arr:number[] = [12, 23];

let colors:any[] = [12, "cyan", "pink"];  // 數(shù)組任意類(lèi)型

let list:Array = [1, 2, 3]; // 數(shù)組泛型

元組

Tuple
元組類(lèi)型允許表示一個(gè)已知元素?cái)?shù)據(jù)和類(lèi)型的數(shù)組，各元素的類(lèi)型不必相同。

let x: [string, number] = ["cyan", 10];

訪問(wèn)越界的元素，使用聯(lián)合類(lèi)型替代。

枚舉

定義：enum colors { red, green, blue }
表義一種可以一一列舉的數(shù)據(jù)

特點(diǎn)：

通過(guò)索引值訪問(wèn)定的數(shù)據(jù)。

通過(guò)定義的數(shù)據(jù)訪問(wèn)索引值。

對(duì)枚舉類(lèi)型的數(shù)據(jù)添加起始索引值。

enum color {
    red = 10, // 默認(rèn)索引值從0 開(kāi)始， 可以指定索引值
    green,
    blue
}
// 編譯之后： Object {10: "red", 11: "green", 12: "blue", red: 10, green: 11, blue: 12}

空值

void 類(lèi)型 像是 與 any 類(lèi)型相反，它表示沒(méi)有任何類(lèi)型。 當(dāng)一個(gè)函數(shù)沒(méi)有返回值時(shí)， 要指定 void 類(lèi)型。

void 類(lèi)型 只能賦值： undefiend 和 null。

let unvoid: void = null;
let unvoid1: void = undefined;

undefiend和null

undefeind和null兩者有各自的類(lèi)型： undefined和null。 和void相似。

let u: undefined = undefined;
let n: null = null;

默認(rèn)情況下null 和undefined 是所有類(lèi)型的子類(lèi)型。
可以把null 和undefined賦值給number類(lèi)型的變量。

類(lèi)型斷言

類(lèi)型斷言，類(lèi)似其它語(yǔ)言里的類(lèi)型轉(zhuǎn)換。但是不進(jìn)行特殊的數(shù)據(jù)檢查和解構(gòu)。 沒(méi)有運(yùn)行時(shí)的影響，只是在編譯階段其作用。

尖括號(hào)<>語(yǔ)法

let someValue: any = "colors"; 

let strlength: number = (someValue).length;

console.log(strlength);

變量聲明 let&const

const 是對(duì)let的一個(gè)增強(qiáng)，能阻止對(duì)一個(gè)變量再次賦值。

let 和 const 的區(qū)別：
所有變量除了計(jì)劃要去修改的都應(yīng)該使用const。
基本原則就是如果一個(gè)變量不需要對(duì)它寫(xiě)入，那么其它使用這些代碼的人也不能夠?qū)懭胨鼈儭?br>使用const可以更容易推測(cè)數(shù)據(jù)的流動(dòng)性。

解構(gòu)

解構(gòu)數(shù)組

不需要指定類(lèi)型

let input = [1, 2];

let [fisrt, second] = input;

console.log(fisrt, second); // 1 ,2 

對(duì)象結(jié)構(gòu)

let o = {
    a: "foo",
    b: 12,
    c: "bar"
}

let {a, b} = o;

console.log( a, b );

函數(shù)

TypeScript函數(shù)可以創(chuàng)建有名字的函數(shù)和匿名函數(shù)
TypeScript函數(shù)執(zhí)行返回值需要定義數(shù)據(jù)類(lèi)型，如果沒(méi)有結(jié)果則要定義為void。
TypeScript函數(shù)，參數(shù)需要定義類(lèi)型，在調(diào)用的時(shí)候，傳遞的參數(shù)一定要跟定義時(shí)的參數(shù)個(gè)數(shù)一樣。否則編譯報(bào)錯(cuò)。

function add (a:number, b:number):number {
    return a + b;
}

let sum = add(10, 20);

console.log( sum );

// 定義void返回值

setProperty();

function setProperty (): void {
    
    console.log("success");
    
}

可選參數(shù)和默認(rèn)參數(shù)

在TypeScript中可以在參數(shù)名旁邊使用 ? 實(shí)現(xiàn)可選參數(shù)

function count (str1: string, str2?: string): string {
    
    return str1 + "--" + str2;
    
}

let reslut = count("xixi");

console.log( reslut );

剩余參數(shù)

剩余參數(shù)會(huì)被當(dāng)作個(gè)數(shù)不限的可選參數(shù)?？梢砸粋€(gè)都沒(méi)有，同樣也可以有任意個(gè)。
語(yǔ)法：...nameProperty

function builName (numa1: string, ...restOfName: string[]) { // 剩余參數(shù)保存在數(shù)組中
    
}

Class

在TypeScript中，可以通過(guò)Class來(lái)定義一個(gè)類(lèi)。在編譯之后，會(huì)編譯成JavaScript一個(gè)閉包函數(shù)類(lèi)。

語(yǔ)法： class className {}

成員方法，成員屬性

在類(lèi)中添加的屬性會(huì)編譯到構(gòu)造函數(shù)中，該屬性如果不賦值，則不會(huì)被編譯.
在類(lèi)中添加的方法會(huì)編譯到構(gòu)造函數(shù)的Prototype上。

class Price {
    
    price: number = 10;
    
    fn( num: number ): string {
        return num * 2;
    }
    
}

編譯之后的結(jié)果：

//Compiled TypeScript
var Price = (function () {
    function Price() {
        this.price = 10;
    }
    Price.prototype.fn = function (num) {
        return num * 2;
    };
    return Price;
})();

靜態(tài)屬性，靜態(tài)方法

靜態(tài)屬性：通過(guò)static關(guān)鍵字定義，定義的該屬性，在 類(lèi)中訪問(wèn)不到， 因?yàn)槎x在類(lèi)上。
靜態(tài)方法：通過(guò)static關(guān)鍵字定義，定義的該方法，在類(lèi)中是訪問(wèn)不到(不能通過(guò)this訪問(wèn))，因?yàn)樵摲椒ǘx在類(lèi)上。

class Person {
    
    static name: string = "time";
    
    static fn(num: number): void {
        
        console.log("success");
        
    }
    
}
let p1: Peson  = new Person(); // 實(shí)例化

編譯之后：

var Person = (function () {
    function Person() {
    }
    Person.fn = function (num) {
        console.log("success");
        console.log(Peson.name);
    };
    Person.name = "time";
    return Person;
})();
var p1 = new Person();

構(gòu)造函數(shù)

在實(shí)例化的時(shí)候被調(diào)用
構(gòu)造函數(shù)中定義的語(yǔ)句會(huì)編譯到JavaScript的構(gòu)造函數(shù)中。
構(gòu)造函數(shù)不能聲明返回類(lèi)型。
類(lèi)定義的屬性(賦值的屬性)會(huì)被編譯到JavaScirpt的構(gòu)造函數(shù)中。

class Book {
    
    name: string;
    
    page: number = 400;
    
    constructor(bookName: string) {
        
        this.name = bookName;
        
        console.log(bookName);
        
    }
    
}

let p1: Book = new Book("莊子");

編譯之后：

var Book = (function () {
    function Book(bookName) {
        this.page = 400;
        this.name = bookName;
        console.log(bookName);
    }
    return Book;
})();
var p1 = new Book("莊子");

繼承

語(yǔ)法：子類(lèi) extends 父類(lèi)

class Base {
    
    press: string = "one";    
        
}

class Book extends Base {
    
    name: string = "老子";
    
    sayName(): string {
        return this.name;
    }
    
}

let b: Book = new Book();

let bookname = b.sayName();

console.log(bookname);

編譯之后：
通過(guò)的是混合式繼承

var __extends = this.__extends || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    __.prototype = b.prototype;
    d.prototype = new __();
};
var Base = (function () {
    function Base() {
        this.press = "one";
    }
    return Base;
})();
var Book = (function (_super) {
    __extends(Book, _super);
    function Book() {
        _super.apply(this, arguments);
        this.name = "老子";
    }
    Book.prototype.sayName = function () {
        return this.name;
    };
    return Book;
})(Base);
var b = new Book();
var bookname = b.sayName();
console.log(bookname);

——extends(); 方法

var __extends = this.__extends || function (d, b) { // b 父類(lèi)
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    __.prototype = b.prototype;
    d.prototype = new __();
};
    

目的, 實(shí)現(xiàn)只繼承 父類(lèi)的原型對(duì)象。 從原型對(duì)象入手
1，function __() {}創(chuàng)建一個(gè)空函數(shù)， 目的：空函數(shù)進(jìn)行中轉(zhuǎn)，把父類(lèi)的模板屏蔽掉， 父類(lèi)的原型取到。
2，__.prototype = b.prototype實(shí)現(xiàn)空函數(shù)的原型對(duì)象 和 超類(lèi)的原型對(duì)象轉(zhuǎn)換
3，d.prototype = new __()原型繼承

使用for-in循環(huán)，子類(lèi)繼承父類(lèi)的靜態(tài)屬性或方法。(通過(guò)一個(gè)函數(shù)中轉(zhuǎn)，實(shí)現(xiàn)，只實(shí)例化一次，且繼承了一次父類(lèi)的原型對(duì)象)
通過(guò)寄生類(lèi)繼承父類(lèi)原型上的屬性或方法。
在子類(lèi)中運(yùn)行構(gòu)造函數(shù)式繼承實(shí)現(xiàn)對(duì)父類(lèi)的構(gòu)造函數(shù)繼承。

super()
在包含constructor函數(shù)的子類(lèi)中必須調(diào)用super().它會(huì)執(zhí)行基類(lèi)的構(gòu)造方法。

傳遞給super()方法就是實(shí)現(xiàn)構(gòu)造函數(shù)繼承屬性
子類(lèi)構(gòu)造函數(shù)中添加屬性。
繼承父類(lèi)構(gòu)造函數(shù)中的屬性，如果子類(lèi)定義構(gòu)造函數(shù)就必須繼承。

class Base {
    
    press: string = "one";
    name: string;
    constructor ( bookName: string ) {
        this.name = bookName;
    }
        
}

class Book extends Base {
    
    price: number;
//    name: string = "老子";
    
    constructor(bookName: string, price: number) {
        // 父類(lèi)繼承屬性
        super(bookName); // 會(huì)執(zhí)行父類(lèi)的 constructor
        
        this.price = price;
        
    }
    
    sayName(): string {
        return this.name;
    }
    
}

let b: Book = new Book("老子", 40);

let bookname = b.sayName();

console.log(bookname);

接口

在TypeScript中，接口的作用：為這些類(lèi)型命名和為你的代碼或第三方代碼定義契約。
TypeScript的核心原則之一是：對(duì)值所具有的shape進(jìn)行類(lèi)型檢查。
定義一種數(shù)據(jù)格式，來(lái)約束變量的類(lèi)型。
接口中定義的每個(gè)接口，都可以當(dāng)作一種類(lèi)型來(lái)使用。
可選實(shí)現(xiàn)成員，可以在后面添加?.

語(yǔ)法：interface names {};

接口定義對(duì)象

// 定義接口
interface Person {
    name: string;
    age: number;
    sex: string;
    hobby?: any;
}

// 使用接口
function getName (person: Person): string {
    
    return person.name;
    
}

// 實(shí)現(xiàn)接口
var n: string = getName({
    name: "one",
    age: 23,
    sex: "nv"
});

console.log(n);

接口函數(shù)

語(yǔ)法：interface name {}
定義函數(shù)格式.通過(guò)()來(lái)定義參數(shù)個(gè)數(shù)，并聲明函數(shù)返回值類(lèi)型。

作用：限制了定義該函數(shù)類(lèi)型的規(guī)范。

// 定義抽象類(lèi)
interface Add {
    (num1: number, num2: number): number;
}

// 使用接口 
let fn:Add;

// 實(shí)現(xiàn)接口
fn = function ( num1: number, num2: number ): number {
    
    return num1 + num2;
    
}

var  reslut: number = fn(10 , 20);

console.log(reslut);

類(lèi)的接口定義

語(yǔ)法：

interface className {
    key: type;
    fn(arg: type): type;    
}

實(shí)現(xiàn)接口：

class Times implements Base {}

作用：保證代碼的安全性

"use strict";

// 時(shí)間接口
interface Base {
    current: string;
    getCurrentDate(): string;
}


// 使用接口
class Times implements Base {
    
    current: string;
    
    constructor( d: string ){
        this.current = d;
    }
    
    getCurrentDate (): string {
        return this.current;
    }
    
}

let d: Times = new Times(new Date().toString());

console.log(d);

模塊

在TypeScript1.5中：內(nèi)部模塊 是說(shuō)所的命名空間。 外部模塊則稱之為模塊

語(yǔ)法：

module name {}

通過(guò) export關(guān)鍵字， 將模塊的方法屬性暴露出來(lái)。
在模塊的外部訪問(wèn)模塊，需要通過(guò)模塊名稱，點(diǎn)語(yǔ)法調(diào)用模塊內(nèi)部暴露的接口

"use strict";

// 定義模塊

module startModuel {
    
    let info: string = "colors";
    
    // 暴露一個(gè)class
    export class Satrt {
        
        name: string;
        
        constructor(name: string) {
            
            this.name = name;
            
        }
        
        getName(): string {
            
            return this.name;
            
        }
        
    }
    
}


// 實(shí)例化模塊中暴露的接口
let satr:startModuel.Satrt = new startModuel.Satrt("cyan");

console.log( satr );

console.log(satr.getName());

模塊在其自身的作用域里執(zhí)行，而不是在全局作用域里。
一個(gè)模塊里的比那兩，函數(shù)，類(lèi)等等在模塊外部是不可見(jiàn)的，需要通過(guò)export形式向外暴露。
如果一個(gè)模塊想使用其它模塊導(dǎo)出的變量，函數(shù)，類(lèi)，接口等。需要使用import形成引入。

模塊是自聲明的。兩個(gè)模塊之間的關(guān)系是通過(guò)在文件級(jí)別上使用imports和 exports 建立聯(lián)系的。

導(dǎo)出

導(dǎo)出聲明

export interface StringValidator {
    
    isAcce(s: string): boolean;
    
}

export const numberRegExp = /^[0-9]+$/;

導(dǎo)出語(yǔ)句

export class ZipCode implements  StringValidator {
    
    isAcce(s: string) {
        return s.length === 5 && numberRegExp.test(s);
    }
    
}

// 導(dǎo)出語(yǔ)句
export { ZipCode }

導(dǎo)入

使用關(guān)鍵字：import 來(lái)導(dǎo)入其它模塊中的導(dǎo)出內(nèi)容

import { ZipCode } form "./ZipCode";

let myValid = new ZipCode();

// 對(duì)導(dǎo)入的內(nèi)容重新命名
import {ZipCode as ZVC } form ""./ZipCode;

let  myValid = new ZVC();

默認(rèn)導(dǎo)出

每個(gè)?？於加幸粋€(gè)defalut導(dǎo)出。 默認(rèn)導(dǎo)出使用default 關(guān)鍵字標(biāo)記。
例如：JQuery的類(lèi)庫(kù)有一個(gè)默認(rèn)導(dǎo)出JQuery或$.

let $:jQuery;     
export default $;

import $ from "JQuery";

模塊路徑解析

TypeScript存在兩種路徑解析方式： Node和Classic（原本TypeScirpt路徑解析規(guī)則，為了向后兼容）

TypeScript是模范Node運(yùn)行時(shí)解析策略來(lái)編譯階段定義模塊文件。
TypeScript在Node解析邏輯基礎(chǔ)上增加了TypeScript源文件的擴(kuò)展名(.ts,.tsx,.d.ts).

命名空間

命名空間是位于全局命名空間下的一個(gè)普通的帶有名字的JavaScript對(duì)象

使用關(guān)鍵字：namespace

namescope Valiation {
    export interface StringValidator {
        isAcce(s: string): boolean;
    }
    
    const lettesRegExp = /^[A-Za-z]+$/;
    
}

多文件的命名空間

不同的文件，但是仍是同一個(gè)命名空間，并且在使用的時(shí)候，就如同他們?cè)谝粋€(gè)文件中定義的一樣。 因?yàn)椴煌募g存在依賴關(guān)系，所以加入了引用標(biāo)簽來(lái)告知編譯器文件之間的關(guān)聯(lián)。

namescope Valiation {
    export interface StringValidator {
        isAcce(s: string): boolean;
    }
}

namescope Valiation {
    const lettesRegExp = /^[A-Za-z]+$/;
    expots class LetterOnly implements StringValidator {
        isAcce(s: string): boolean {
            return s.length && lettesRegExp.test(s);
        }
    }
}

// 測(cè)試
/// 
/// 

let strings = ["Hello", "98052"];

let validators: { [s: string]: Validation.StringValidator; } = {};

validators["ZIP code"] = new Validation.ZipCodeValidator();
validators["Letters only"] = new Validation.LettersOnlyValidator();

strings.forEach(s => {
    for (let name in validators) {
        console.log(""" + s + "" " + (validators[name].isAcce(s) ? " matches " : " does not match ") + name);
    }
});

編譯方式：

把所有輸入的文件編譯一個(gè)輸出文件，需要使用--outFile標(biāo)記

tsc --outFile sample.js Test.ts
變異其會(huì)根據(jù)源碼中引用標(biāo)簽自動(dòng)的對(duì)輸出進(jìn)行排序。
可以多帶帶指定每個(gè)文件
tsc --outFile sample.js Validation.ts LettersOnlyValidator.ts ZipCodeValidator.ts Test.ts

可以編譯成每一個(gè)文件(默認(rèn)方式),每個(gè)源文件都會(huì)對(duì)應(yīng)生成一個(gè)JavaScript文件。然后，在頁(yè)面上通過(guò)