TypeScript

為何 TypeScript

1. 有一定的學習成本,需要理解接口(Interfaces)、泛型(Generics)、
優:
1. 增加可讀性和可維護性
2. 可以在寫的階段就發現大部分錯誤,比在執行的時候才發現錯誤好
3. TypeScript 是 JavaScript 的超集,.js 文件可以直接重命名爲 .ts 即可
4. 使用 ES6 規範,也支持部分 ESNext 草案的規範
5. 即使 plugin 不是用 TypeScript 寫的,也可以編寫單獨的類型文件
供 TypeScript 讀取
1. 有一定的學習成本,需要理解接口(Interfaces)、泛型(Generics)、

安裝 TypeScript

// 自動掃描所有 .ts 結尾的檔案並且產出 JS 檔案
// 生成 tsconfig.json 檔案
$ npm install -g typescript

安裝 TypeScript

// 自動掃描所有 .ts 結尾的檔案並且產出 JS 檔案
function showMsg(something) {
// 生成 tsconfig.json 檔案

安裝 TypeScript

// 自動掃描所有 .ts 結尾的檔案並且產出 JS 檔案
function showMsg(something) {

新增一個 index.ts 檔案

// 自動掃描所有 .ts 結尾的檔案並且產出 JS 檔案

將 TypeScript 編譯成 JavaScript

原始型別 Primitive Types

  • number
  • string
  • boolean
  • undefined
  • null
  • symbol(ES6)
  • void
let myName = 'Maxwell';
let myName: string = 'Maxwell';
let age = 20;
let hasPet = false;

型別推論(Type Inference)

let myName: string = 'Maxwell';
let age = 20;

型別推論(Type Inference)

TypeScript 會自行推斷出型別

any 型別很容易造成混亂 只有極少數狀況會用到
let nothing = undefined;
let nothingLiterally = null;
let nothingLiterally: any = null;

Nullable Types

any 型別很容易造成混亂 只有極少數狀況會用到
let nothingLiterally: any = null;

任意型別 any

TypeScript 會判別為 any 型別

any 型別很容易造成混亂 只有極少數狀況會用到
let nothingLiterally: any = null;

任意型別 any

被視為 any 型別的變數可以隨便的使用

let nothing: undefined = undefined;
any 型別很容易造成混亂 只有極少數狀況會用到

任意型別 any

let nothing: undefined = undefined;
any 型別很容易造成混亂 只有極少數狀況會用到

Nullable Types

為 undefined 與 null 的變數做型別註記

let canBeNullString: string;
// Temporal Dead Zone
let myString = canBeNullString;
canBeNullString = 'hello';

具有型別但是預設為空值

let canBeNullString: string | null;
// Temporal Dead Zone
let myString = canBeNullString;

具有型別但是預設為空值

報錯:變數 'canBeNullString' 已在指派之前使用

let canBeNullString: string | null;
// Temporal Dead Zone

聯合型別(Union Types)

具有型別 但也希望值能夠被清空時

let myFavoriteNumber: string | number;
let canBeNullString: string | null;
// Temporal Dead Zone

聯合型別(Union Types)

具有型別 但也希望值能夠被清空時

let myFavoriteNumber: string | number;
console.log(myFavoriteNumber.length); // 編譯時報錯
// Temporal Dead Zone

聯合型別(Union Types)

聯合型別的其他用法

console.log(myFavoriteNumber.length); // 編譯時報錯
// Temporal Dead Zone

聯合型別(Union Types)

聯合型別在被賦值時 會根據型別推論的規則推斷出自己的型別

型別註記的目的

  • 註記最大的好處,除了讓開發者明確知道變數是哪個型別外,TS 也可以不用猜就知道該變數的型別
  • 避免 any 造成各種混亂
  • 型別推論是 TS 在開始寫程式碼的時候,就會主動監控;而型別註記則是開發者必須手動宣告給 TS 看的

物件型別 Object Types

  • 基礎物件型別:Object, Array, Class
  • TypeScript 擴充型別:Enum, Tuple
  • 函式型別 Function Types
knows: undefined,
const info = {
name: 'Maxwell',
age: 20,
hasPet: false,
// Nullable Type 在 Object 中得到應該被推論出來的型別 而非 any
knows: undefined,
identity: null,
};

物件型別的型別推論

knows: undefined,
// Nullable Type 在 Object 中得到應該被推論出來的型別 而非 any

物件型別的型別註記

TypeScript 中使用介面(Interfaces)來定義物件的型別

const Maxwell: info = {
// 報錯:物件常值只可指定已知的屬性
interface info {
name: string;
age: number;
hasPet: boolean;
};

使用物件型別

定義一個變數 Maxwell 型別是 info

const Maxwell: info = {
// 報錯:物件常值只可指定已知的屬性

使用物件型別

定義一個變數 Maxwell 型別是 info

const Maxwell: info = {
// 報錯:物件常值只可指定已知的屬性

使用物件型別

TypeScript 定義好的物件 是不允許少掉屬性的

const Maxwell: info = {
// 報錯:物件常值只可指定已知的屬性

使用物件型別

也不能多出其他屬性

const Maxwell: info = {
// 報錯:物件常值只可指定已知的屬性
interface info {
name: string;
age: number;
hasPet?: boolean;
};

物件型別的可選屬性

有時我們希望不要完全符合一個物件的 key 那麼可以使用可選屬性

const Maxwell: info = {
// 報錯:物件常值只可指定已知的屬性

物件型別的可選屬性

有時我們希望不要完全符合一個物件的 key 那麼可以使用可選屬性

const Maxwell: info = {
// 報錯:物件常值只可指定已知的屬性

物件型別的可選屬性

但仍不允許新增未定義的屬性

interface info {
name: string;
[propName: string]: string;
};

物件型別的任意屬性

有時候我們希望一個 interface 允許有任意屬性

[propName: string]: string;
};

物件型別的任意屬性

使用 [propName: string] 定義任意屬性為 string 型別的值

// 報錯:類型 '{ name: string; age: number; gender: string; }'
interface info {
name: string;
age?: number;
// 報錯:類型 'number | undefined' 的屬性
// 'age' 不可指派給字串類型 'string'
[propName: string]: string;
};

物件型別的任意屬性

一旦定義了任意屬性 那麼自訂屬性和可選屬性的型別都必須是它型別的子集

// 報錯:類型 '{ name: string; age: number; gender: string; }'

物件型別的任意屬性

一旦定義了任意屬性 那麼自訂屬性和可選屬性的型別都必須是它型別的子集

interface info {
readonly id: number;
name: string;
age?: number;
[propName: string]: any;
};
// 報錯:因為 'id' 為唯讀屬性,所以無法指派至 'id'

物件型別的唯讀屬性

有時候我們希望物件中的一些欄位只能在建立的時候被賦值

[propName: string]: any;
// 報錯:因為 'id' 為唯讀屬性,所以無法指派至 'id'

物件型別的唯讀屬性

有時候我們希望物件中的一些欄位只能在建立的時候被賦值

// 報錯:因為 'id' 為唯讀屬性,所以無法指派至 'id'

物件型別的唯讀屬性

使用 readonly 定義的屬性 id 初始化後 不能被重複賦值

let justAnObject: object = { hello: 'hi', };
// 以上全員 Pass

型別註記為 Object 的物件

let justAnObject: object = { hello: 'hi', };
// 以上全員 Pass

物件型別的唯讀屬性

Object 型別完全覆寫是可以被 TypeScript 接受的

let justAnObject: object = { hello: 'hi', };
justAnObject = function () { console.log('ohhhh !?!?!?'); };
// 以上全員 Pass

物件型別的唯讀屬性

以原始型態覆寫會出錯

justAnObject = function () { console.log('ohhhh !?!?!?'); };
// 以上全員 Pass

物件型別的唯讀屬性

除了很明顯的原始型別不是物件外 全員一致 Pass

// 全部都是數字
const numbers = [1, 2, 3, 4, 5];
​
// 全部都是字串
const strings = ['hi', 'how are you', 'goodbye'];
const strings: string[] = ['hi', 'how are you', 'goodbye'];

陣列型別 Array Types

// 全部都是數字
const numbers: Array<number> = [1, 2, 3, 4, 5];
const strings: string[] = ['hi', 'how are you', 'goodbye'];

陣列型別 Array Types

陣列型別的型別註記

// 全部都是數字
const numbers: number[] = [1, 2, 3, 4, 5];
const numbers: Array<number> = [1, 2, 3, 4, 5];

陣列型別 Array Types

陣列型別的型別註記

const numberAndString = [1, '2', 3, '安安'];
// 全部都是數字
const numbers: number[] = [1, 2, 3, 4, 5];

陣列型別 Array Types

以上都是會出錯的用法

const numberAndString = [1, '2', 3, '安安'];
const numberAndString: (string | number)[] = [1, '2', 3, '安安'];
// 全部都是數字

陣列型別 Array Types

TypeScript 對混合型陣列的型別推論

let emptyArray = [];
const numberAndString: (string | number)[] = [1, '2', 3, '安安'];
// 全部都是數字

陣列型別 Array Types

用複合型別解決

let emptyArray = [];
let emptyArray: any[] = [];
// 全部都是數字

陣列型別 Array Types

空陣列的型別推論

let emptyArray: any[] = [];
// 全部都是數字

陣列型別 Array Types

空陣列的型別推論

)
let objectsArray1 = [
{ message: 'Hello' },
{ message: 'Hi' },
{ message: 'Goodbye' }
];

陣列型別 Array Types

特殊陣列型別註記的方式

)
{ message: 123456789 },
{ message: 'Goodbye' }

陣列型別 Array Types

特殊陣列型別註記的方式

)
{ message: 123456789 },

陣列型別 Array Types

特殊陣列型別註記的方式

)
{ message: 'Hi', revolt: true },
{ message: 123456789 },

陣列型別 Array Types

特殊陣列型別註記的方式

)
{ message: 'Hi', revolt: true },

陣列型別 Array Types

特殊陣列型別註記的方式

)
{ message: 'Hi', revolt: true },

陣列型別 Array Types

特殊陣列型別註記的方式

)
... 後面實在是太複雜了 之後再說
{ message: 'Hi', revolt: true },

陣列型別 Array Types

這種型態其實可以被簡化成

(集合 S 裡所有型別 "union" 的結果)[]
... 後面實在是太複雜了 之後再說

陣列型別 Array Types

[true, false, true, false],
)
(集合 S 裡所有型別 "union" 的結果)[]

陣列型別 Array Types

至少到這裡 大概知道陣列型別的推論規則

[true, false, true, false],
S = { number[], string[], boolean[] }
)

陣列型別 Array Types

S = { number[], string[], boolean[] }
)

陣列型別 Array Types

S 型別的集合 這時會包含三種不同的型別

[true, false, 123, null],
S = { number[], string[], boolean[] }
)

陣列型別 Array Types

S 型別的集合 這時會包含三種不同的型別

       自己慢慢解 ㄏ
[true, false, 123, null],
)

陣列型別 Array Types

       自己慢慢解 ㄏ

陣列型別 Array Types

    左邊是輸入型別,需要用括號括起來
// 函式宣告(Function Declaration)
function testFunction() {
console.log('Hi!');
};
​
// 函式表示式(Function Expression)
const testFunction = function() {
console.log('Hi!');
};

函式型別 Function Types

函式型別的型別註記

    左邊是輸入型別,需要用括號括起來
const testFunction = function() {

函式型別 Function Types

函式型別的型別註記

    左邊是輸入型別,需要用括號括起來
const testFunction = function() {

函式型別 Function Types

函式型別的型別註記

    左邊是輸入型別,需要用括號括起來
const testFunction = function(): void {
const testFunction = function() {

函式型別 Function Types

函式型別的型別註記

    左邊是輸入型別,需要用括號括起來
const testFunction() => void = function() {
const testFunction = function(): void {

函式型別 Function Types

對等號右側的匿名函式進行了型別註記

    左邊是輸入型別,需要用括號括起來
const testFunction() => void = function() {

函式型別 Function Types

手動給 const testFunction 做型別註記

    左邊是輸入型別,需要用括號括起來

函式型別 Function Types

       函式輸入的參數型別 會影響輸出值的型別
const addition = function (num1, num2) {
// 報錯:參數 'num1', 'num2' 隱含了 'any' 類型
return num1 + num2;
};

函式型別 Function Types

函式型別加上參數後

const addition = function (num1: any, num2: any) {
// 報錯:應有 2 個引數,但得到 1 個
       函式輸入的參數型別 會影響輸出值的型別

函式型別 Function Types

const addition = function (num1: number, num2: number) {
const addition = function (num1: any, num2: any) {
// 報錯:應有 2 個引數,但得到 1 個

函式型別 Function Types

強制將參數註記為 any 的話 TypeScript 就不會理你了

let addition = function (num1: number, num2: number) {
const addition = function (num1: number, num2: number) {
// 報錯:應有 2 個引數,但得到 1 個

函式型別 Function Types

如果用正確的型別註記參數 TypeScript 就能夠自動推論出輸出的型別

let addition = function (num1: number, num2: number) {
// 報錯:應有 2 個引數,但得到 1 個

函式型別 Function Types

函式型別是可以被覆寫的

let addition = function (num1: number, num2: number) {
// 報錯:應有 2 個引數,但得到 1 個

函式型別 Function Types

函式型別是可以被覆寫的

let addition = function (num1: number, num2: number) {
// 報錯:應有 2 個引數,但得到 1 個

函式型別 Function Types

但輸出型別不能被改變

const addition = function (num1: number, num2: number) {
let addition = function (num1: number, num2: number) {
// 報錯:應有 2 個引數,但得到 1 個

函式型別 Function Types

定義的函式不回傳值的話 不管有沒有註記 型別推論都會被認定為 void

const addition = function (num1: number, num2: number) {
// 報錯:應有 2 個引數,但得到 1 個

函式型別 Function Types

輸入多餘或少於定義的參數 都會報錯

const addition = function (num1: number, num2: number) {
// 報錯:應有 2 個引數,但得到 1 個

函式型別 Function Types

輸入多餘或少於定義的參數 都會報錯

function buildName(firstName?: string, lastName: string) {
function buildName(firstName: string, lastName?: string) {
if (lastName) {
return firstName + ' ' + lastName;
} else {
return firstName;
}
}
const tomcat = buildName('Tom', 'Cat');
const tom = buildName('Tom');

函式型別 Function Types

定義可選參數

function buildName(firstName: string, lastName: string = 'Cat') {
function buildName(firstName?: string, lastName: string) {
}

函式型別 Function Types

可選參數後面不能再接必要參數

function buildName(firstName: string, lastName: string = 'Cat') {
}

函式型別 Function Types

設定參數的預設值

function buildName(firstName: string, lastName: string = 'Cat') {
}

函式型別 Function Types

TypeScript 會將設定了預設值的參數識別為可選參數

function buildName(firstName: string, lastName: string = 'Cat') {
}

函式型別 Function Types

此時就不受「可選參數必須接在必需參數後面」的限制

function push(array: any[], ...items: any[]) {
function push(array, ...items) {
items.forEach(function(item) {
array.push(item);
});
}
// rest 引數只能是最後一個引數 其他用法詳見ES6
​
let a = [];
push(a, 1, 2, 3);

函式型別 Function Types

用 ES6 解構的方式定義剩餘的參數

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

函式型別 Function Types

items 是一個 array 可以用陣列的型別來定義它

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('');
}
}

函式型別 Function Types

使用 Union 的方式註記函式型別

return Number(x.toString().split('').reverse().join(''));
}

函式型別 Function Types

可以用更精確的方式註記

function getLength(something: string | number): number {
}
             <型別>值
            值 as 型別

型別斷言(Type Assertion)

function getLength(something: string | number): number {
}

型別斷言(Type Assertion)

當使用 Union 聯合型別時

function getLength(something: string | number): number {
}

型別斷言(Type Assertion)

在還不確定型別的時候 就使用其中一個型別的屬性或方法

function getLength(something: string | number): number {
}

型別斷言(Type Assertion)

此時可以使用型別斷言 將 something 斷言成 string

function getLength(something: string | number): number {
}

型別斷言(Type Assertion)

此時可以使用型別斷言 將 something 斷言成 string

function getLength(something: string | number): number {
}

型別斷言(Type Assertion)

型別斷言不是型別轉換 不能定義成一個連合型別中不存在的型別

其他內建物件

document.addEventListener('click', function(e: MouseEvent) {
// Do something
let b: Boolean = new Boolean(1);
let e: Error = new Error('Error occurred');
let d: Date = new Date();
let r: RegExp = /[a-z]/;

JavaScript 的內建物件

document.addEventListener('click', function(e: MouseEvent) {
// Do something

DOM 和 BOM 的內建物件

其他還有很多內建型別 可以參考:

MDN 的文件TypeScript 核心函式庫的定義檔案
​
TypeScript 也還有其他很多很多很多方法
* 介面(Interfaces)與實現(Implements)
​
         之後再說ㄌ
* 介面(Interfaces)與實現(Implements)
​
            >> to be continued...
         之後再說ㄌ
​
            >> to be continued...