TypeScript 是由微軟開發的自由和開源的編程語言，是 JavaScript 的一個超集，支持 ECMAScript 6 標準，其設計目標是開發大型應用，它可以編譯成純 JavaScript，編譯出來的 JavaScript 可以運行在任何瀏覽器上，

為什么學習typescript

目前主流的前端框架（react、vue）都使用ts的語法進行開發，typescript也是JavaScript的超集，相對于JavaScript來說更加嚴謹，
使用typescript可以撰寫出更加健壯的前端代碼，

typescript無法直接在瀏覽器中執行，需要編譯成JavaScript之后才能執行，

typescript靜態型別

在JavaScript中

let a = 123;
a = '123'

js不會報錯，代碼可以正常執行（在JavaScript中變數的型別是動態型別，即變數的型別是可以改變的）

在typescript中

以下代碼會報錯，因為在typescript中，變數是靜態型別，變數的型別不能改變（同時變數所屬型別的方法跟隨確定，例如定義了變數
為number型別，則該變數就會有number型別的方法和屬性），vs-code執行示例：

以下代碼不會報錯，因為在typescript中，變數是靜態型別，變數重新賦值時，變數型別不改變，不會提示錯誤，vs-code執行示例如下：

let a = 123; 
// 完整的typescript寫法為
let a:number = 123;
// 對a重新賦值時，只要型別不變，就不會提示錯誤，例如：
a = 456;

typescript的資料型別

在typescript中希望各個變數、屬性以及函式引數都有自己的變數型別

	// String 型別
	// 一個保存字串的文本，型別宣告為 string，可以發現型別宣告可大寫也可小寫，后文同理，
	let str: string = 'abcd';
	
	// Boolen 型別
	// boolean是 true 或 false 的值
	// 所以 let isBool3: boolean = new Boolean(1) 就會編譯報錯，因為 new Boolean(1) 生成的是一個 Bool 物件，
	let isBool: boolean = false;
	
	// Number 型別
	let number: number = 10;
	
	// Any 型別
	// any 是默認的型別，其型別的變數允許任何型別的值，
	let any: any = 10;
	
	// Void 型別
	// JavaScript 沒有空值 Void 的概念，在 TypeScirpt 中，可以用 void 表示沒有任何回傳值的函式，
	let sym1 = Symbol();
	let sym2 = Symbol("key"); // 可選的字串key
　　// 需要注意的是，Symbols是不可改變且唯一的，
	let sym2 = Symbol("key"); // 可選的字串key
	let sym3 = Symbol("key");
	console.log(sym2 === sym3); // false, symbols是唯一的
　　// 通過同樣的方式生成兩個symbol也是不同的，因為symbol是唯一的，因此sym2和sym3無論如何都不會相等
	
	// Symbol 型別
	// TypeScript中的Symbol的用法跟JavaScript一致，Symbols是不可改變且唯一的，
	function alertName(): void {
	    console.log('My name is changdong');
	}
	
	// Null 和 Undefined
	// TypeScript里，undefined和null兩者各自有自己的型別分別叫做undefined和null， 
	// 和void相似，它們的本身的型別用處不是很大，
	let u: undefined = undefined;
	let n: null = null;
	> 	// 默認情況下null和undefined是所有型別的子型別， 就是說你可以把null和undefined賦值給number型別的變數，
	> 	let num: number; 	
	> 	num = 1; // 運行正確 	
	> 	num = undefined;    // 運行正確 	
	> 	num = null;    // 運行正確 	
	> 	// 然而，當你指定了--strictNullChecks標記，null和undefined只能賦值給void和它們各自，這能避免很多常見的問題，  	
	> 	// 啟用 --strictNullChecks
	> 	//（啟用strictNullChecks可以在專案中的tsconfig.json中配置{strictNullChecks: true}，如下圖所示） 	
	> 	let num: number; 	
	> 	num = 1;	// 運行正確 	
	> 	num = undefined;	// 運行錯誤 	
	> 	num = null;	// 運行錯誤
	> 	// 如果想傳入一個string或null或undefined，你可以使用聯合型別string | null | undefined，
	> 	// 啟用 --strictNullChecks 	
	>	let num2: number | null | undefined; 	
	>	num2 = 1; // 運行正確 	
	>	num2 = undefined;    // 運行正確 	
	>	num2 = null;    // 運行正確

	
	// Never 型別
	// never 是其它型別（包括 null 和 undefined）的子型別，代表從不會出現的值，
	// 這意味著宣告為 never 型別的變數只能被 never 型別所賦值，在函式中它通常表現為拋出例外或無法執行到終止點（例如無限回圈)，
	let a: never;
	let b: number;
	// a = 123; // 運行錯誤，數字型別不能轉為 never 型別
	a = (() => { throw new Error('never')})(); // 運行正確，never 型別可以賦值給 never型別
	b = (()=>{ throw new Error('exception')})(); // 運行正確，never 型別可以賦值給 數字型別
	// 回傳值為 never 的函式可以是拋出例外的情況
	function error(message: string): never {
	    throw new Error(message);
	}
	// 回傳值為 never 的函式可以是無法被執行到的終止點的情況
	function loop(): never {
	    while (true) {}
	}
	// Object 型別
	// object表示非原始型別，也就是除number，string，boolean，symbol，null或undefined之外的型別，
	// 使用object型別，就可以更好的表示像Object.create這樣的API
	declare function create(o: object | null): void;
	create({ prop: 0 }); // OK
	create(null); // OK
	// create(42); // Error
	// create("string"); // Error
	// create(false); // Error
	// create(undefined); // Error
	
	// Array 型別
	// 陣列是 Array 型別，然而，因為陣列是一個集合，我們還需要指定在陣列中的元素的型別，
	// 我們通過 Array<type> or type[] 語法為陣列內的元素指定型別
	let arr: number[] = [1, 2, 3, 4, 5];
	let arr2: Array<number> = [1, 2, 3, 4, 5];
	
	let arr3: string[] = ['1', '2', '3'];
	let arr4: Array<string> = ['1', '2', '3'];
	
	// Tuple 型別
	// 元組型別允許表示一個已知元素數量和型別的陣列，各元素的型別不必相同，
	// 比如，你可以定義一對值分別為string和number型別的元組，
	let x: [string, number];
	x = ['hello', 10]; // OK
	// x = [10, 'hello']; // Error
	
	// Enums 型別
	// 列舉型別用于定義數值集合，
	// 列出所有可用值，一個列舉的默認初始值是0，你可以調整一開始的范圍，后續的數值比前一個大 1 ，
	enum People {Student = 3, Teacher, Doctor};
	let role1: People = People.Student;
	let role2: People = People.Teacher;
	let role3: People = People.Doctor;
	console.log(role1, role2, role3) // 3 4 5
	// 可以自己轉換成js代碼 之后列印一下People

啟用 --strictNullChecks

typescript型別注解

在ts中，我們可以告訴ts，宣告的變數是什么型別，叫做型別注解，例如：

	let a:number = 123；
	let b:string = 'typescript'

如果沒有告訴ts變數的型別，ts會自動判斷變數的型別，叫做型別推斷（如果ts可以判斷變數型別，就不需要額外操縱，
但是如果ts不能判斷變數型別，就需要使用型別注解，例如：）

	function getResult(a, b) { return a + b;}
	const result = getResult(1, 2)
	// 上述方法中的a、b、result，ts無法自動推斷出其變數型別，就需要手動添加型別注解

在typescript中，我們也可以定義函式的回傳值型別（對函式做型別注解），例如：

	function getNumber():number{}	// 指定函式回傳值為number
	function getNumber():void{}		// 表示沒有任何回傳值的函式
	function getNumber():number｜string{}	// 指定函式回傳值為number或者string
	// ... 可以定義多種型別
	// 解構型別引數的型別注解
	function getNumber({a, b}: {a:number, b:number}){return a + b}
	const result = getNumber({a: 1, b: 3}) // ts會自動判斷result的型別為number

typescript型別注解的優勢

使用typescript開發程序中，typescipt的型別檢測可以提示代碼撰寫程序的一些潛在錯誤，提升開發效率（在js中，以下代碼只有在執行的時候才會提示錯誤）

使用typescript開發時，代碼提示很友好（ts會對傳入函式的資料屬性進行提示）

型別宣告

interface	// 可以宣告一個型別（只能表示物件型別）
type			// 可以宣告一個型別，可以表示物件型別和基本型別
在typescript中能用interface（介面）表示型別的時候就用interface，除此之外也可以使用型別變數（boolean、string等），使用如下：

interface Person {}
type Person = {}

typescript—interface

interface Person {
	readonly name: string,
	age?:number
}
// readonly表示name屬性只讀，不可修改； ?表示age屬性可有可無

typescript中，宣告變數形式傳遞引數時，函式會對引數進行校驗，只要符合要求即可，如果傳入方法中的是自變數物件時，
就會進行強校驗，要求引數必須符合要求

如果傳入的自變數引數不符合，可以使用如下寫法

interface User {
	name: string,
	age?:number,
	[propName: string]: any
}
// [propName: string]: any 表示字串型別的key，值可以為任何型別，這樣就不會提示錯誤了

interface宣告的介面，Class類可以使用 implements 關鍵字應用宣告的介面，其他宣告出來的介面可以使用 extends 關鍵字繼承當前介面
interface還可以定義一個函式的型別介面，如下：

interface SayHello {
	(str:string):string
}
// 表示該介面函式接受一個字串型別的引數，回傳一個字串型別的值，使用如下
const sayHello:SayHello = (str:string) => {return str}

typescript—類

跟JavaScript中一樣，可以使用class 關鍵字宣告一個類，類可以繼承父類的屬性和方法，也可以重寫覆寫父類的方法，當我們重寫父類的
方法之后需要呼叫父類的方法是，可以使用 super[父類方法] 的形式獲取父類的方法和屬性

// class類的訪問型別 public、private、protected
class Info {
	name: 'user',
	sayHi(){
		console.log('Hi')
	}
}
// public		允許物件的屬性和方法在類的內部和外部被呼叫
// private		允許物件的屬性和方法在類的內部被呼叫
// protected	允許物件的屬性和方法在類的內部和繼承的子類中使用 （new 關鍵字實體化的物件不能訪問）

typescript基礎語法學習結束，繼續學習