TypeScript快速入門

一：Typescript簡介

維基百科： TypeScript是一種由微軟開發的自由和開源的編程語言。它是JavaScript的一個嚴格超集，並添加了可選的靜態類型和基於類的面向對象編程。C#的首席架構師以及Delphi和Turbo Pascal的創始人安德斯•海爾斯伯格參與了TypeScript的開發。Typescript是ES6的超集。添加了可選的靜態類型（注意並非強類型）和基於類的面向對象編程。（若是對ES6熟悉那麼能夠只關注類、裝飾器部分的內容。）

中文官網：https://www.tslang.cn/。

特色：微軟開發，javascript超集，遵循ES6標準，任何js語法均可以直接在ts裏編寫運行。Angular2框架是用Typescript開發的，背景是谷歌和微軟，有多是將來的前端腳本語言發展的主流方向。優勢：支持ES6規範，學到的typescript語法將來是客戶端腳本語言的主流語法。強大的IDE支持：  一、類型檢查。 二、語法提示。  三、重構（修改方法名稱的時候會自動把引用的地方都重構）是Angular2的首選開發語言。

二：環境搭建

主要是安裝Typescript的代碼編譯器。

在線環境：http://www.typescriptlang.org...

本地環境：1、安裝好nodeJS環境。2、npm install -g typescript。3、tsc --version。

三：Typescript特性

1. 字符串特性

1.1多行字符串

使用``包裹跨行的字符串，示例：

var html = `<div>

<span></span>

</div>`

1.2：字符串模板

能夠在多行字符串中使用模板，示例：
var names = 'daocheng';
function getImg() {
  return '<i></i>'
}

var html = `<div>${names}
<span>${getImg()}</span>
<div>
`

1.3：自動拆分字符串

function getData(template, name, age) {
    console.log(template);
    console.log(name);
    console.log(age);
}

var names = 'daocheng';
var age = 23;
getData`你好，個人名字是${names}，我今年${age}歲了`

2. 參數新特徵

2.1：參數類型

Typescript中的參數類型包括：boolean/number/string/array/tuple/enum/any/（null和undefined）/ void /never。其中元祖（tuple）、枚舉、任意值、void類型和never是有別於Javascript的特有類型。

2.2：類型聲明與默認參數

在Typescritpt中聲明變量，須要加上類型聲明，如boolean或string等。經過靜態類型約束，在編譯時執行類型檢查，這樣能夠避免一些類型混用的低級錯誤。示例：

var names = 'daocheng';
function getData(name: stirng, age: number): boolean {
    return true
}

Typescript還支持初始化默認參數。若是函數的某個參數設置了默認值，當該函數被調用時，若是沒有給這個參數傳值或者傳值爲undefined時，這個參數的值就是設置的默認值。示例：

function max(x: number, y: number = 4): number {
    return x > y ? x : y;
}
let result1 = max(2); //正常
let result2 = max(2, undefined); //正常
let result3 = max(2, 4, 7); //報錯
let result4 = max(2, 7); //正常

2.3： 可選參數

在javascript裏，被調用函數的每一個函數都是可選的，而在typescript中，被調用的每一個函數的每一個參數都是必傳的。在編譯時，會檢查函數每一個參數是否傳值。簡而言之，傳遞給一個函數的參數個數必須和函數定義的參數個數一致。可是實際開發中常常須要根據實際需求來確認參數，這時能夠添加？來定義可選參數。示例：

function max(x: number, y: number) {
    if(y){
        return x > y ? x : y;
    } else {
        return x
    }
}
let result1 = max(2);
let result2 = max(2, 4, 7); //報錯
let result3 = max(2, 4);
//注意：可選參數必須放在默認參數後面

3：函數特性

3.1：剩餘參數

上面介紹的必選參數、默認參數以及可選參數共同點是隻能表示某一個參數。當須要同時操做多個參數，或者並不知道會有多少參數傳遞進來時，就須要用到Typescript 裏的剩餘參數。示例：

function sum(x: number, ...restOfNumber: number[]){
    let result = x;
    restOfNumber.forEach(value => result += value);
    return result;
}
let result1 = sum(1, 2, 3, 4, 5, 6);
console.log(result1);

let result2 = sum(2);
console.log(result2);

let result3 = sum(2, 5);
console.log(result3);

3.2: generator函數

控制函數的執行過程，能夠手動的干預函數執行。示例：

function getPrice(stock) {
    while (1) {
        yield Math.random() * 100;
    }
}
var priceGenerator = getPrice('dcc');
var limitPrice = 51;
var price = 100;
while (price > limitPrice) {
    price = priceGenerator.next().value;
    console.log(`this generator return ${price}`);
}
console.log(`buying at ${price}`);

3.3: 析構表達式

析構表達式又稱解構，是ES6的一個重要特性，Typescript在1.5版本中開始增長了對結構的支持，所謂結構，就是將聲明的一組變量與相同結構的數組或者對象的元素數值一一對應。分數組解構（[]）和對象解構（{}）兩種。

數組解構示例:

let imput = [1, 2];
let [first, second] = input;
console.log(first); //至關於inputp[0]
console.log(second); //至關於input[1]
function f([first, second]) {
    console.log(first + second)
}
f{[1, 3]}   //結果是4

let [first, ...rest] = [1, 2, 3, 4];
console.log(first); //1
console.log(second); //[2,3,4]

對象解構示例：

let test = {
    x: 0,
    y: 0,
    width: 15,
    heights: {
        height1: 10,
        height2: 20
    }
};
let { x, y: myY, width, heights: {height2} } = test;
console.log(x, myY, width, height2); //輸出：0,10,15,20

4: 箭頭表達式

用來聲明匿名函數，消除傳統匿名函數的this指針問題。示例：

function Test1(names: string) {
    this.names = names;
    setInterval(function() {
        console.log('my name is ' + this.names);
    }, 1000)
}
function Test2(names: string) {
    this.names = names;
    setInterval(() => {
        console.log('my names is ' + this.names)
    }, 1000)
}

var a = new Test1('daocheng'); //undefined
var b = new Test2('daocheng'); //daocheng

5: 循環

typescritpt中涉及三種高級循環方式：forEach()、for in、for of

forEach示例：

var myArray = [1, 2, 3, 4];
myArray.name = 'daocheng';

myArray.forEach(value => console.log(value)); //結果爲1,2,3,4
//特色：不支持break，會忽略(name)

for in 示例：

var myArray = [1, 2, 3, 4];
myArray.name = 'daocheng';

for (var n in myArray ) {
    console.log(n)
}   //結果爲1,2,3,4
//特色： 循環的結果是對象或者數組的鍵值。能夠break

for of 示例：

var myArray = [1, 2, 3, 4];
myArray.name = 'daocheng';

for (var n of myArray) {
    console.log(n)
}   //結果是1,2,3,4
//特色：忽略屬性，能夠打斷。當循環爲字符串時，會把字符串中每一個字符打出來

6：類

傳統的JavaScript程序使用函數和基於原型（Prototype）繼承來建立可重用的「類」，這對於習慣了面向對象編程的開發者來講不是很友好，Typescript中能夠支持基於類（class）的面向對象編程

6.1: 類的聲明

class Car {
    engine: string,
    constructor(engine: string) { 
        this.engine = engine;
    }
    drive(distanceInMeters: number = 0) { 
        console.log(`aaa is running` + this.engine)
    }
}

let car = new Car('petrol');
car.drive(100)

6.2: 類的封裝、繼承、多態
封裝、繼承、多態是面向對象的三大特性。上面的例子把汽車的行爲寫到一個類中，即所謂的封裝。在Typescript中，使用extends關鍵字能夠方便的實現.

繼承。示例：

class Car {
    engine: string;
    constructor(engine: string) {
        this.engine = engine;
    }
    drive(distanceInMeter: number = 0){
        console.log(`A car runs ${distanceInMeter}m
        powered by` + this.engine)
    }
}

class MotoCar extends Car {
    constructor(engine: string) {
        super(engine)
    }
}

let tesla = new MotoCar('electricity');
tesla.drive();
//其中子類MotoCar的實例對象tesla調用了父類Car的drive()方法。

多態示例：

class Car {
    engine: string;
    constructor(engine: string) {
        this.engine = engine;
    }
    drive(distanceInMeter: number = 0){
        console.log(`A car runs ${distanceInMeter}m
        powered by` + this.engine)
    }
}

class Jeep extends Car {
    constructor(engine: string) {
        super(engine)
    }
    drive(distanceInMeters: number = 100) {
        console.log('jeep...')
        return super.drive(distanceInMeters);
    }
}
let landRover: Car = new Jeep('petrol'); //實現多態
> Jeep子類中的drive()方法重寫了Car的drive()方法，這樣drive()方法在不一樣的類中就具備不一樣的功能，這就是多態。注意：子類和派生類的構造函數中必須調用super()，它會實現父類構造方法。

6.3： 修飾符

在類中的修飾符能夠分爲公共（public）、私有（private）、和受保護（protected）三種類型。在Typescript裏，每一個成員默認爲public，能夠被自由的訪問。

私有修飾符示例：

class Car {
    private engine: string;
    constructor(engine: string) {
        this.engine = engine;
    }
}
new Car('petrol').engine; //報錯，私有屬性沒法在類的外部訪問

受保護修飾符示例：

class Car {
    engine: string;
    constructor(engine: string) {
        this.engine = engine;
    }
    protected drive() {
        console.log('drving')
    }
}

class MotoCar extends Car {
    constructor(engine: string) {
        super(engine)
    }
    moToDrive() {
        super.drive()
    }
}

let tesla = new MoToCar('electricity');
tesla.drive(); // 報錯，受保護成員只有子類訪問，實例對象不可
tesla,moToDrive()

6.4: 參數屬性

參數屬性是經過給構造函數的參數添加一個訪問限定符來聲明。參數屬性能夠方便地讓咱們在一個地方定義並初始化類成員。咱們來改造6.1中的例子：

class Car {
    constructor(public engine: string) {}
    drive() { }
}

6.5: 抽象類

Typescript有抽象類的概念，它是供其餘類繼承的基類，不能直接被實例化。不一樣於接口，抽象類必須包含一些抽象方法，同時也能夠包含非抽象的成員。抽象類中的抽象方法必須在派生類中實現。

abstract class Person {
    abstract speak(): void;
    walking(): void {
        console.log('walking');
    }
}

class Male extends Person {
    speak(): void {
        console.log('man wakling')
    }
}

6.6: 接口

接口在面向對象設計中具備極其重要的做用，在Gof的23種設計模式中，基本上均可見到接口的身影。長期以來，接口模式一直是Javascript這類弱類型語言的軟肋，Typescript接口的使用方式相似於Java。
在Typescript中接口有屬性類型、函數類型、可索引類型、類類型這幾種，在Angular的開發中主要使用類類型接口，咱們使用interface關鍵字定義接口並用implements關鍵字實現接口。

類類型接口示例：

interfance Animal {
    name: string;
    setName();
}

class Dog implements Animal {
    name: string;
    setName() {
        console.log(this.name)
    }
    constructor() { }
}
//接口更注重功能的設計，抽象類更注重結構內容的體現

6.7: 模塊

ES6中引入了模塊的概念，在TypeScript中也支持模塊的使用。使用import和export關鍵字來創建兩個模塊之間的聯繫。懂點node都知道模塊是什麼了，不BB了。

7：裝飾器

裝飾器（Decorators）是一種特殊類型的聲明，它能夠被附加到類聲明、方法、屬性或參數上。裝飾器有@符號緊接一個函數名稱，如：@expression，expression求職後必須是一個函數，在函數執行的時候裝飾器的聲明方法會被執行。裝飾器是用來給附着的主題進行裝飾，添加額外的行爲。（裝飾器屬於ES7規範）

在Typescript的源碼中，官方提供了方法裝飾器、類裝飾器、參數裝飾器、屬性裝飾器等幾種每種裝飾器類型傳入的參數大不相同。這裏我演示兩種裝飾器。

複合使用的例子：

function Component(component) {
    console.log('selector: ' + component.selector);
    console.log('template: ' + component.template);
    console.log('component init');
    return (target: any) => {
        console.log('component call');
        return target;
    }
}

function Directive() {
    console.log('directive init');
    return (target: any) => {
        console.log('directive call');
        return target;
    }
}

@Component({
    selector: 'person',
    template: 'person.html'
})
@Directive()
export class Person {}

let p = new Person();
//看不懂不要緊，知道有這麼個東西就能夠了，Angular框架在依賴注入、組件等部分中有多個複合裝飾器應用的場景.畢竟裝飾器是ES7的草案標準。

8：泛型

參數化的類型，通常用來限制集合的內容。
示例：

class MinHeap<T> {
    list: T[] = [];
    
    add(element: T): void {
        //這裏進行大小比較，並將最小值放在數組頭部，功能代碼省略。
    }
    min(): T {
        return this.list.length ? this.list[0] : null
    }
}

let heap = new MinHeap<number>();
heap.add(3);
heap.add(5);
console.log(heap.min())

9：聲明文件

聲明文件也稱爲類型定義文件，當咱們項目中要使用第三方的Javascript庫如jQuery、lodash等就須要用聲明文件，聲明文件是以.d.ts爲後綴的形式存在的，其做用是描述一個Javascript模塊文件全部導出的接口類型信息。

例如使用jquery:npm install –save @types/jquery