TS系列之類型

基礎

安裝TS

npm install -g typescript

編譯

tsc hello.ts

類型

boolean、number、string、void、null、undefined、any、tuple、enum、never、symbol

boolean

let isDone: boolean = false;

number

let decLiteral: number = 6;
let hexLiteral: number = 0xf00d;
// ES6 中的二進制表示法
let binaryLiteral: number = 0b1010;
// ES6 中的八進制表示法
let octalLiteral: number = 0o744;
let notANumber: number = NaN;
let infinityNumber: number = Infinity;

string

let name: string = `Gene`;
let sentence: string = `Hello, my name is ${ name }.

Void

• void類型表示沒有任何類型
• 只能爲它賦予undefined和null

null 和 undefined

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

any

用來表示容許賦值爲任意類型。

• 若是是一個普通類型，在賦值過程當中改變類型是不被容許的，但若是是 any 類型，則容許被賦值爲任意類型。
• 聲明一個變量爲任意值以後，對它的任何操做，返回的內容的類型都是任意值。
• 變量若是在聲明的時候，未指定其類型，那麼它會被識別爲任意值類型。

let something;          //let something: any;
something = 'seven';
something = 7;

tuple

元組表示一個已知元素數量和類型的數組，各元素的類型沒必要相同。

let x: [string, number];
x = ['hello', 10];        // OK
x = [10, 'hello'];        // Error

enum

枚舉成員默認會被賦值爲從 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[1] === "Mon"); // true
console.log(Days[2] === "Tue"); // true

數字枚舉

enum Direction {
    Up,
    Down,
    Left,
    Right,
}
// Up的值爲 0， Down的值爲 1等等

enum Direction {
    Up = 1,
    Down,
    Left,
    Right
}
// Up使用初始化爲 1，其他的成員會從 1開始自動增加。

字符串枚舉

在一個字符串枚舉裏，每一個成員都必須用字符串字面量，或另一個字符串枚舉成員進行初始化。

enum Direction {
    Up = "UP",
    Down = "DOWN",
    Left = "LEFT",
    Right = "RIGHT",
}

never

never類型表示的是那些永不存在的值的類型。

function error(message: string): never {
    throw new Error(message);
}

never類型是任何類型的子類型，也能夠賦值給任何類型；然而，沒有類型是never的子類型或能夠賦值給never類型（除了never自己以外）。 即便 any也不能夠賦值給never。

symbol

symbol類型的值是經過Symbol構造函數建立的。

let sym1 = Symbol();
let sym2 = Symbol("key"); 

let sym2 = Symbol("key");
let sym3 = Symbol("key");
sym2 === sym3; // false, symbols是惟一的

symbol是不可改變且惟一的。
symbol也能夠被用作對象屬性的鍵

let sym = Symbol();
let obj = {
    [sym]: "value"
};
console.log(obj[sym]); // "value"

array、function

array

//類型[]
let fibonacci: number[] = [1, 1, 2, 3, 5];
//數組泛型 Array<類型>
let fibonacci: Array<number> = [1, 1, 2, 3, 5];

function

一個函數有輸入和輸出，要在 TypeScript 中對其進行約束，須要把輸入和輸出都考慮到。

function add(x: number, y: number): number {
    return x + y;
}

輸入多餘的（或者少於要求的）參數，是不被容許的

//可選參數
function buildName(firstName: string, lastName = "Smith", fullName?: string) {
    return firstName + " " + lastName;
}

可選參數必須接在必需參數後面。換句話說，可選參數後面不容許再出現必須參數了。

函數表達式

let mySum = function (x: number, y: number): number {
    return x + y;
};

這是能夠經過編譯的，不過事實上，上面的代碼只對等號右側的匿名函數進行了類型定義，而等號左邊的 mySum，是經過賦值操做進行類型推論而推斷出來的。若是須要咱們手動給 mySum 添加類型，則應該是這樣:

let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
    return x + y;
};

注意不要混淆了 TypeScript 中的 => 和 ES6 中的 =>。
在 TypeScript 的類型定義中，=> 用來表示函數的定義，左邊是輸入類型，須要用括號括起來，右邊是輸出類型。

剩餘參數(...rest)

function push(array: any[], ...items: any[]) {
    items.forEach(function(item) {
        array.push(item);
    });
}

let a = [];
push(a, 1, 2, 3);

重載

重載容許一個函數接受不一樣數量或類型的參數時，做出不一樣的處理。

function reverse(x: number): number;
function reverse(x: string): string;
function reverse(x: number | string): number | string {
    if (typeof x === 'number') {
        return Number(x.toString().split('').reverse().join(''));
    } else if (typeof x === 'string') {
        return x.split('').reverse().join('');
    }
}

TypeScript 會優先從最前面的函數定義開始匹配，因此多個函數定義若是有包含關係，須要優先把精確的定義寫在前面。