TypeScript 與 JavaScript 的區別（TypeScript萬字基礎入門，了解TS，看這一篇就夠了）-有解無憂

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

TypeScript 是一種給 JavaScript 添加特性的語言擴展，增加的功能包括：

型別批注和編譯時型別檢查
型別推斷
型別擦除
介面
列舉
Mixin
泛型編程
名字空間
元組
Await

從 ECMA 2015 反向移植而來：

類
模塊
lambda 函式的箭頭語法
可選引數以及默認引數

TypeScript 與 JavaScript 的區別

TypeScript 是 JavaScript 的超集，擴展了 JavaScript 的語法，因此現有的 JavaScript 代碼可與 TypeScript 一起作業無需任何修改，TypeScript 通過型別注解提供編譯時的靜態型別檢查，

TypeScript 可處理已有的 JavaScript 代碼，并只對其中的 TypeScript 代碼進行編譯，

第一個TypeScript實體：

const greet : string = "Hello World!"
console.log(greet)

為了演示方便，本文中的例子均在vue3專案運行，

TypeScript基礎語法

第一個TypeScript程式（之后的代碼演示省略<script>標簽，也不展示控制臺截圖）

<script lang="ts">
  const greet : string = "hello world！"
  console.log(greet);
</script>

對比一下JavaScript的代碼

const greet = "hello world！"
console.log(greet);

TypeScript中的保留字與JavaScript基本一致

TypeScript 會忽略程式中出現的空格、制表符和換行符，空格、制表符通常用來縮進代碼，使代碼易于閱讀和理解，TypeScript 區分大寫和小寫字符，每行指令都是一段陳述句，你可以使用分號或不使用，分號在 TypeScript 中是可選的，建議使用，注釋與JavaScript使用一致，

TypeScript基礎型別

any（任意型別）：宣告為 any 的變數可以賦予任意型別的值，

number（數字型別）：雙精度 64 位浮點值，它可以用來表示整數和分數，

string（字串型別）：一個字符系列，使用單引號（'）或雙引號（"）來表示字串型別，反引號（`）來定義多行文本和內嵌運算式，

boolean（布爾型別）：表示邏輯值：true 和 false，

陣列型別、元組，

enum（列舉型別）：列舉型別用于定義數值集合，

void：用于標識方法回傳值的型別，表示該方法沒有回傳值，

null：表示物件值缺失，

undefined：用于初始化變數為一個未定義的值，

never：never 是其它型別（包括 null 和 undefined）的子型別，代表從不會出現的值，

Any

任意值是 TypeScript 針對編程時型別不明確的變數使用的一種資料型別，它常用于以下情況，

1、變數的值會動態改變時，比如來自用戶的輸入，任意值型別可以讓這些變數跳過編譯階段的型別檢查，示例代碼如下：

let flag: any = 1;    // 數字型別
flag = 'my name is leo';    // 字串型別
flag = true;    // 布爾型別

2、定義存盤各種型別資料的陣列時，示例代碼如下：

let list: any[] = ['leo',25,true];
list[1] = 'lion';

Null 和 Undefined

null，在 JavaScript 中 null 表示 "什么都沒有"，null是一個只有一個值的特殊型別，表示一個空物件參考，用 typeof 檢測 null 回傳是 object，

undefined，在 JavaScript 中, undefined 是一個沒有設定值的變數，typeof 一個沒有值的變數會回傳 undefined，Null 和 Undefined 是其他任何型別（包括 void）的子型別，可以賦值給其它型別，即其他型別可以轉成這兩種型別，如字串型別，此時，賦值后的型別會變成 null 或 undefined，

let num: number;
num = 1; // 運行正確
num = undefined;    // 運行正確，此時為undefined型別
num = null;    // 運行正確，此時為null型別

Never

never 是其它型別（包括 null 和 undefined）的子型別，代表從不會出現的值，這意味著宣告為 never 型別的變數只能被 never 型別所賦值，在函式中它通常表現為拋出例外或無法執行到終止點（例如無限回圈），示例代碼如下：

let n: never;
let num: number;

// 運行錯誤，數字型別不能轉為never型別
n = 123;

// 運行正確，never 型別可以賦值給never型別
n = (()=>{ throw new Error('exception')})();

// 運行正確，never 型別可以賦值給數字型別
num = (()=>{ throw new Error('exception')})();

// 回傳值為never的函式可以是拋出例外的情況
function error(message: string): never {
    throw new Error(message);
}

// 回傳值為never的函式可以是無法被執行到的終止點的情況
function loop(): never {
    while (true) {}
}

TypeScript變數宣告

TypeScript 變數的命名規則：

1、變數名稱可以包含數字和字母，

2、除了下劃線 _ 和美元 $ 符號外，不能包含其他特殊字符，包括空格，

3、變數名不能以數字開頭，

以下為四種宣告變數的方式

//var [變數名] : [型別] = 值; 宣告變數的型別及初始值
var uname:string = "leo";

//var [變數名] : [型別]; 宣告變數的型別，但沒有初始值，變數值會設定為undefined
var uname:string;

//var [變數名] = 值; 宣告變數并初始值，但不設定型別，該變數可以是任意型別
var uname = "leo";

//var [變數名]; 宣告變數沒有設定型別和初始值，型別可以是任意型別，默認初始值為undefined
var uname;

//總結：宣告時，沒有型別，型別就是any；沒有初始值，初始值就是undefined

實體：

var uname:string = "leo";
var age:number = 25;

//對應js
var uname = "leo";
var age = 25;

TypeScript 遵循強型別，如果將不同的型別賦值給變數會編譯錯誤，而JavaScript則不會，因為她是弱型別語言，如下實體：

var num:number = "leo"     // 編譯錯誤

//對應的js
var num = 100
num = "leo"     // 編譯不報錯

型別推斷

當型別沒有給出時，TypeScript 編譯器利用型別推斷來推斷型別，如果由于缺乏宣告而不能推斷出型別，那么它的型別被視作默認的動態 any 型別，

var num = 100;    // 型別推斷為 number
num = "leo";      // 編譯錯誤，相當于上例 var num:number = "leo"

變數作用域

TypeScript 有以下幾種作用域：

全域作用域 ? 全域變數定義在程式結構的外部，它可以在你代碼的任何位置使用，

類作用域 ? 這個變數也可以稱為欄位，類變數宣告在一個類里頭，但在類的方法外面，該變數可以通過類的物件來訪問，類變數也可以是靜態的，靜態的變數可以通過類名直接訪問，

區域作用域 ? 區域變數，區域變數只能在宣告它的一個代碼塊（如：方法）中使用，

如以下例子：

var global_num = 10          // 全域變數
class Person { 
   age = 18;                 // 實體變數
   static score = 100;       // 靜態變數
   eat():void { 
      var food = 'apple';    // 區域變數
   } 
}

console.log("全域變數為: " + global_num)  
console.log(Person.score)    // 靜態變數，直接通過類名訪問
var person = new Person(); 
console.log("實體變數: " + person.age)

TypeScript的運算子、條件陳述句、回圈與JavaScript基本一致，

TypeScript函式

function function_name()
{
    // 執行代碼
}

//呼叫函式
function_name()

函式回傳值

TypeScript的函式回傳值與JavaScript的函式回傳值略有不同，TypeScript的函式回傳值的格式：

function function_name():return_type { 
    // 陳述句
    return value; 
}

//與js相比，ts的函式回傳值需要指定 return_type回傳值的型別，

如下實體：

//ts
function greet():string { // 回傳一個字串
    return "Hello World！" 
}

//js
function greet() {
    return "Hello World！" 
}

帶引數函式

語法格式如下所示：

function func_name( param1 [:datatype], param2 [:datatype]) {   //datatype為引數型別
     //執行代碼  
}

實體：

//ts
function add(x: number, y: number): number {  //函式回傳值為number，引數的資料型別也為number
    return x + y;
}

//js
function add(x, y) {
    return x + y;
}

可選引數和默認引數

可選引數，在 TypeScript 函式里，如果我們定義了幾個引數，則我們必須傳入幾個引數，除非將這些引數設定為可選，可選引數使用問號標識？，

function fullName(firstName: string, lastName: string) {  //呼叫函式必須傳入兩個引數，否則報錯
    return firstName + " " + lastName;
}
 
let name1 = buildName("leo");                  // 錯誤，缺少引數
let name2 = buildName("leo", "lion", "gao");   // 錯誤，引數太多了
let name3 = buildName("leo", "lion");          // 正確

修改為可選引數之后

function fullName(firstName: string, lastName?: string) { //此時lastName為可選引數，非必傳
    if(lastName){
        return firstName + " " + lastName;
    }else {
        return firstName;
    }

}
 
let name1 = buildName("leo");                  // 正確
let name2 = buildName("leo", "lion", "gao");   // 錯誤，引數太多了
let name3 = buildName("leo", "lion");          // 正確

//ts函式設定可選引數時，只能少傳，不能多傳，相比之下，js函式的引數可以多傳，按順序取引數，

默認引數，可以設定引數的默認值，這樣在呼叫函式的時候，如果不傳入該引數的值，則使用默認引數，語法格式為：

function function_name(param1[:type],param2[:type] = default_value) {
      //執行代碼
}

//default_value為默認值，當不傳入該引數時，取默認值，

注意：引數不能同時設定為可選和默認，

以下實體函式的引數lastName設定了默認值為'lion'，呼叫該函式時如果未傳入引數則使用該默認值：

function fullName(firstName:string,lastName:string = 'lion') {  
    console.log(firstName + " " + lastName); 
}

fullName('leo')         //leo lion，lastName取默認值
fullName('leo','gao')   //leo gao

剩余引數

有一種情況，我們不知道要向函式傳入多少個引數，這時候我們就可以使用剩余引數來定義，剩余引數語法允許我們將一個不確定數量的參數作為一個陣列傳入，

function fullName(firstName: string, ...restOfName: string[]) {
    return firstName + " " + restOfName.join(" ");
}
  
let uname = fullName("leo", "lion", "ggj", "gao");

匿名函式

匿名函式是一個沒有函式名的函式，匿名函式在程式運行時動態宣告，除了沒有函式名外，其他的與標準函式一樣，我們可以將匿名函式賦值給一個變數，這種運算式就成為函式運算式，

var greet = function() {  //不帶引數的匿名函式
    return "hello world！";  
} 
console.log(msg())


var add = function(a,b) {  //帶引數的匿名函式
    return a + b;  
} 
console.log(add(2,3))

匿名函式自呼叫

(function () { 
    var str = "Hello World！";   
    console.log(str)     
 })()

建構式

TypeScript 也支持使用 JavaScript 內置的建構式 Function() 來定義函式：

var res = new Function ([arg1[, arg2[, ...argN]],] functionBody)

var myFunction = new Function("a", "b", "return a * b"); 
var x = myFunction(4, 3); 
console.log(x);

箭頭函式

( [param1, parma2,…param n] )=>statement;

var add = (x:number)=> {    
    x = 10 + x 
    console.log(x)  
} 
foo(100)

我們可以不指定函式的引數型別，通過函式內來推斷引數型別：

var func = (x)=> { 
    if(typeof x=="number") { 
        console.log(x+" 是一個數字") 
    } else if(typeof x=="string") { 
        console.log(x+" 是一個字串") 
    }  
} 
func(12) 
func("Tom")

更多例子

var display = x => {      //單個引數 () 是可選的
    console.log("輸出為 "+x) 
} 
display(12)


var disp =()=> {     //無引數時可以設定空括號
    console.log("Function invoked"); 
} 
disp();

函式多載

多載是方法名字相同，而引數不同，回傳型別可以相同也可以不同，每個多載的方法（或者建構式）都必須有一個獨一無二的引數型別串列，

//引數型別與引數數量不同
function disp(s1:string):void; 
function disp(n1:number,s1:string):void; 
 
function disp(x:any,y?:any):void { 
    console.log(x); 
    console.log(y); 
}

TypeScript中的Number、String、Array（陣列）型別語JavaScript基本一致，

TypeScript Map物件

Map 物件保存鍵值對，并且能夠記住鍵的原始插入順序，任何值(物件或者原始值) 都可以作為一個鍵或一個值，Map 是 ES6 中引入的一種新的資料結構，可以參考 ES6 Map 與 Set，

TypeScript 使用 Map 型別和 new 關鍵字來創建 Map：

let myMap = new Map();

初始化 Map，可以以陣列的格式來傳入鍵值對：

let myMap = new Map([
    ["key1", "value1"],
    ["key2", "value2"]
]);

let nameSiteMapping = new Map();
 
// 設定 Map 物件
nameSiteMapping.set("Google", 1);
nameSiteMapping.set("Runoob", 2);
nameSiteMapping.set("Taobao", 3);
 
// 獲取鍵對應的值
console.log(nameSiteMapping.get("Runoob"));     // 2
 
// 判斷 Map 中是否包含鍵對應的值
console.log(nameSiteMapping.has("Taobao"));       // true
console.log(nameSiteMapping.has("Zhihu"));        // false
 
// 回傳 Map 物件鍵/值對的數量
console.log(nameSiteMapping.size);                // 3
 
// 洗掉 Runoob
console.log(nameSiteMapping.delete("Runoob"));    // true
console.log(nameSiteMapping);
// 移除 Map 物件的所有鍵/值對
nameSiteMapping.clear();             // 清除 Map
console.log(nameSiteMapping);

使用for...of來迭代Map物件，

let nameSiteMapping = new Map();
 
nameSiteMapping.set("Google", 1);
nameSiteMapping.set("Runoob", 2);
nameSiteMapping.set("Taobao", 3);
 
// 迭代 Map 中的 key
for (let key of nameSiteMapping.keys()) {
    console.log(key);                  
}
 
// 迭代 Map 中的 value
for (let value of nameSiteMapping.values()) {
    console.log(value);                 
}
 
// 迭代 Map 中的 key => value
for (let entry of nameSiteMapping.entries()) {
    console.log(entry[0], entry[1]);   
}

TypeScript元組

我們知道陣列中元素的資料型別都一般是相同的（any[] 型別的陣列可以不同），如果存盤的元素資料型別不同，則需要使用元組，元組中允許存盤不同型別的元素，元組可以作為引數傳遞給函式，

創建元組的語法格式如下：

var tuple_name = [value1,value2,value3,…value n]

實體

//宣告一個元組并初始化
var mytuple = [10,'leo',25,true];


//也可以先宣告一個空元組，然后再初始化
var mytuple = []; 
mytuple[0] = 10
mytuple[1] = 'leo'
mytuple[2] = 25
mytuple[3] = true


//訪問元組，使用索引來訪問
tuple_name[index]

元組運算

1、push() 向元組添加元素，添加在最后面，

2、pop() 從元組中移除元素（最后一個），并回傳移除的元素，

var mytuple = [10,"Hello","World","typeScript"];

mytuple.push(25)  // [10,"Hello","World","typeScript",25]

mytuple.pop()  // [10,"Hello","World","typeScript"]

更新元組

元組是可變的，這意味著我們可以對元組進行更新操作：、

var mytuple = [10, "leo", "lion"]; // 創建一個元組
 
// 更新元組元素
mytuple[0] = 25     // [25, "leo", "lion"]

解構元組

我們也可以把元組元素賦值給變數，如下所示：

var user =[25,"leo"] 
var [age,uname] = user
console.log( age )       // 25
console.log( uname )     // 'leo'

TypeScript聯合型別

聯合型別（Union Types）可以通過管道(|)將變數設定多種型別，賦值時可以根據設定的型別來賦值，

注意：只能賦值指定的型別，如果賦值其它型別就會報錯，

Type1|Type2|Type3

實體

//宣告一個聯合型別
var flag:string|number|boolean

flag = 25
console.log("數字為 ", flag)   // 數字為 25

flag = 'leo' 
console.log("字串為 ", flag)   // 字串為 leo

flag = true 
console.log("布林值為 ", flag)   //布林值為 true

如果賦值其它型別就會報錯：

var flag:string|number

flag = true  //報錯，聯合型別不包括boolean

也可以將聯合型別作為函式引數使用：

function fullName(name:string|string[]) {  //此時引數型別可以是字串，也可以是字串陣列
    if(typeof name == "string") { 
        console.log(name) 
    } else {
        var i; 
        for(i = 0;i<name.length;i++) { 
        console.log(name[i])
        } 
    } 
}

fullName("leo")
fullName(["leo","lion","ggj","gao"])

也可以將陣列宣告為聯合型別：

var arr:number[]|string[];  //數字陣列或者字串陣列

TypeScript介面

介面是一系列抽象方法的宣告，是一些方法特征的集合，這些方法都應該是抽象的，需要由具體的類去實作，然后第三方就可以通過這組抽象方法呼叫，讓具體的類執行具體的方法，

TypeScript 介面定義如下：

interface interface_name {

}

實體

以下實體中，我們定義了一個介面 IPerson，接著定義了一個變數 customer，它的型別是 IPerson，customer 實作了介面 IPerson 的屬性和方法，

interface IPerson { 
    firstName:string, 
    lastName:string, 
    sayHi: ()=>string 
} 

//實作介面
var customer:IPerson = { 
    firstName:"Tom",
    lastName:"Hanks", 
    sayHi: ():string =>{return "Hi there"} 
}

//實作介面
var employee:IPerson = { 
    firstName:"Jim",
    lastName:"Blakes", 
    sayHi: ():string =>{return "Hello!!!"} 
}

聯合型別和介面

以下實體演示了如何在介面中使用聯合型別：

interface RunOptions { 
    program:string; 
    commandline:string[]|string|(()=>string); 
} 
 
// commandline 是字串
var options:RunOptions = {program:"test1",commandline:"Hello"}; 
console.log(options.commandline)  
 
// commandline 是字串陣列
options = {program:"test1",commandline:["Hello","World"]}; 
console.log(options.commandline[0]); 
console.log(options.commandline[1]);

介面繼承

介面繼承就是說介面可以通過其他介面來擴展自己，Typescript 允許介面繼承多個介面，繼承使用關鍵字 extends，

//單介面繼承
Child_interface_name extends super_interface_name

//多介面繼承，繼承的各個介面使用逗號 , 分隔，
Child_interface_name extends super_interface1_name, super_interface2_name,…,super_interfaceN_name

單實體繼承

interface Person { 
   age:number 
} 
 
interface Musician extends Person { 
   instrument:string 
} 
 
var drummer = <Musician>{}; 
drummer.age = 25 
drummer.instrument = "Drums" 
console.log("年齡:  "+drummer.age)
console.log("喜歡的樂器:  "+drummer.instrument)

// 年齡:  25
// 喜歡的樂器:  Drums

多實體繼承

interface IParent1 { 
    v1:number 
} 
 
interface IParent2 { 
    v2:number 
} 
 
interface Child extends IParent1, IParent2 { } 
var Iobj:Child = { v1:12, v2:23}

TypeScript類

TypeScript 是面向物件的 JavaScript，類描述了所創建的物件共同的屬性和方法，TypeScript 支持面向物件的所有特性，比如類、介面等，

TypeScript 類定義方式如下：

class class_name { 
    // 類作用域
}

定義類的關鍵字為 class，后面緊跟類名，類可以包含以下幾個模塊（類的資料成員）：

1、欄位 ? 欄位是類里面宣告的變數，欄位表示物件的有關資料，

2、建構式 ? 類實體化時呼叫，可以為類的物件分配記憶體，

3、方法 ? 方法為物件要執行的操作，

實體，創建類的資料成員：

class Car { 
    // 欄位 
    color:string; 
 
    // 建構式 
    constructor(color:string) { 
        this.color = color
    }  
 
    // 方法 
    show():void {
        console.log("顏色為 :   " + this.color) 
    } 
}

我們使用 new 關鍵字來實體化類的物件，類實體化時會呼叫建構式，例如：

var obj = new Car("blue")

類中的欄位屬性和方法可以使用 . 號來訪問：

// 訪問屬性
obj.color 

// 訪問方法
obj.show()

類的繼承

TypeScript 支持繼承類，即我們可以在創建類的時候繼承一個已存在的類，這個已存在的類稱為父類，繼承它的類稱為子類，類繼承使用關鍵字 extends，子類除了不能繼承父類的私有成員(方法和屬性)和建構式，其他的都可以繼承，TypeScript 一次只能繼承一個類，不支持繼承多個類，但 TypeScript 支持多重繼承（A 繼承 B，B 繼承 C），

實體

類的繼承：實體中創建了 Shape 類，Circle 類繼承了 Shape 類，Circle 類可以直接使用 Area 屬性：

class Shape { 
   Area:number 
   
   constructor(a:number) { 
      this.Area = a 
   } 
} 
 
class Circle extends Shape { 
   show():void { 
      console.log("圓的面積:  "+this.Area) 
   } 
}
  
var obj = new Circle(223); 
obj.show()        // 圓的面積:  223

需要注意的是子類只能繼承一個父類，TypeScript 不支持繼承多個類，但支持多重繼承，如下實體：

class Root { 
   str:string; 
} 
 
class Child extends Root {} 
class Leaf extends Child {} // 多重繼承，繼承了 Child 和 Root 類

繼承類的方法重寫

類繼承后，子類可以對父類的方法重新定義，這個程序稱之為方法的重寫，其中 super 關鍵字是對父類的直接參考，該關鍵字可以參考父類的屬性和方法，

class PrinterClass { 
   doPrint():void {
      console.log("父類的 doPrint() 方法，") 
   } 
} 
 
class StringPrinter extends PrinterClass { 
   doPrint():void { 
      super.doPrint() // 呼叫父類的函式
      console.log("子類的 doPrint()方法，")   //此處對父類方法進行重寫
   } 
}

static關鍵字

上面提到，static 關鍵字用于定義類的資料成員（屬性和方法）為靜態的，靜態成員可以直接通過類名呼叫，

class StaticMem {  
   static num:number; 
   
   static disp():void { 
      console.log("num 值為 "+ StaticMem.num) 
   } 
} 

//直接通過類名呼叫靜態屬性和方法
StaticMem.num = 12     // 初始化靜態變數
StaticMem.disp()       // 呼叫靜態方法

擴展：instanceof 運算子用于判斷物件是否是指定的型別，如果是回傳 true，否則回傳 false，

class Person { } 
var obj = new Person() 
var isPerson = obj instanceof Person;    //true

訪問控制修飾符

TypeScript 中，可以使用訪問控制符來保護對類、變數、方法和構造方法的訪問，TypeScript 支持 3 種不同的訪問權限，

1、public（默認） : 公有，可以在任何地方被訪問，

2、protected : 受保護，可以被其自身以及其子類和父類訪問，

3、private : 私有，只能被其定義所在的類訪問，

以下實體定義了兩個變數 str1 和 str2，str1 為 public，str2 為 private，實體化后可以訪問 str1，如果要訪問 str2 則會編譯錯誤，

class Encapsulate { 
   str1:string = "Hello" 
   private str2:string = "World"
}
 
var obj = new Encapsulate() 
console.log(obj.str1)     // 可訪問 
console.log(obj.str2)   // 編譯錯誤， str2 是私有屬性

類和介面

類可以實作介面，使用關鍵字 implements，并將 interest 欄位作為類的屬性使用，

以下實體紅 AgriLoan 類實作了 ILoan 介面：

interface ILoan { 
   interest:number 
} 
 
class AgriLoan implements ILoan { 
   interest:number 
   rebate:number 
   
   constructor(interest:number,rebate:number) { 
      this.interest = interest 
      this.rebate = rebate 
   } 
} 
 
var obj = new AgriLoan(10,1) 
console.log("利潤為 : "+obj.interest+"，抽成為 : "+obj.rebate )   // 利潤為 : 10，抽成為 : 1

TypeScript與JavaScript中的物件基本一致，

TypeScript命名空間

命名空間一個最明確的目的就是解決重名問題，命名空間定義了識別符號的可見范圍，一個識別符號可在多個名字空間中定義，它在不同名字空間中的含義是互不相干的，這樣，在一個新的名字空間中可定義任何識別符號，它們不會與任何已有的識別符號發生沖突，因為已有的定義都處于其他名字空間中，

TypeScript 中命名空間使用 namespace 來定義，語法格式如下：

namespace SomeNameSpaceName { 
   export interface ISomeInterfaceName {      }  
   export class SomeClassName {      }  
}

以上定義了一個命名空間 SomeNameSpaceName，如果我們需要在外部可以呼叫 SomeNameSpaceName 中的類和介面，則需要在類和介面添加 export 關鍵字，

要在另外一個命名空間呼叫語法格式為：

SomeNameSpaceName.SomeClassName;

總結：以上為TypeScript的基礎知識，可以看出TypeScript與JavaScript其中一些區別

1、TypeScript是JavaScript的超集，即你可以TypeScript在中使用原生JavaScript語法，

2、TypeScript是靜態類語言（強型別），編譯時進行型別檢查；而JavaScript是動態類語言（弱型別）在運行時進行型別判斷，相對更靈活，

3、TypeScript在JavaScript基礎型別上，增加了void、never、any、元組、列舉、以及一些高級型別，還有類、介面、命名空間與更多面向物件的內容等，

4、JavaScript沒有多載概念，TypeScript可以多載，

5、TypeScript最終仍要編譯為弱型別，基于物件的原生的JavaScript，再運行，

參考鏈接：TypeScript 教程 | 菜鳥教程

轉載請註明出處，本文鏈接：https://www.uj5u.com/qianduan/345782.html

標籤：其他

上一篇：《微信小程式》音樂播放器專案

下一篇：LaravelEloquent相同的查詢