typescript_基礎

tsc

$ tsc --outDir dirName
$ tsc --outDir dirName compileName # 指定輸出輸入位置
$ tsc --init # tsconfig.json
$ tsc -w # 動態監視
$ ts-node file # 直接運行ts文件

---

$ npm bin -g # 查看-g命令目錄
$ tsc file -d # 生成.d.ts文件 

type

變量使用前要定義

// let/var 變量名:變量類型 = 默認值

變量類型

number: 數值類型
string: 字符串類型
boolean: 布爾類型
symbol: 符號類型，標識唯一對象
any: 任意類型
object: 對象類型(數組，元祖，類，接口，函數等)

var,let 區別

• 限定變量的作用範圍
• 防止變量的重複定義

常量

用處：

• 系統配置文件路徑
• 數據庫連接串
• 公司名稱，電話，郵件地址
• 畫面表示信息（登錄失敗，系統出錯）

const name:type = initial_value

const DATA:number[] = [10, 20, 30]

數組

let name:type[] = initial_value

let name:type[][] = [
    [], [], []
]

枚舉

枚舉類型，可以增加代碼的可讀性。ls

enum name { name1, name2, name3 }

enum Sex {
    MALE,
    FEMALE,
    UNKNOWN
}

聯合類型

let a: number | null | undefined

function

function run(a: string): string {
    return ''
}
let s = function (a: number): string {}

let t1 = (x, y) => x + y
let t2 = (x, y) => { return x + y }
let t3:(a: number, b: string) => void = function (a: number, b: string): void {}

interface P {
    (a: number, b: string): void
}
let add: P = function (a: number, b: string): void {}

函數重載

通過爲同一個函數（同名函數）提供多個函數類型定義來實現多種功能的目的。

class

靜態屬性，靜態方法

class Person {
    public name: string
    static age: number
    constructor (name: string) {
        this.name = name
    }
    public run () {
        console.log('run')
    }
    static work () { // 靜態方法裏沒方法調用成員方法
        console.log('work')
    }
}

let p = new Person('s')

抽象類，多態

多態：父類定義一個方法不去實現，讓繼承的子類去實現，每一個子類有不同的表現。

class Animal {
    protected name: string
    constructor (name: string) {
        this.name = name
    }
    public eat () {
        console.log(this.name + ' eat')
    }
}

class Dog extends Animal {
    constructor (name: string) {
        super(name)
    }
    public eat () {
       console.log(this.name + ' eat') 
    }
}

class Pig extends Animal {
    constructor (name: string) {
        super(name)
    }
    public eat () {
        console.log(this.name + ' eat')
    }
    public hoho () {
        console.log('hoho')
    }
}

let d = new Dog('dog')
d.eat()

let p = new Pig('pig')
p.hoho()

---

// 抽象類： 定義一種標準

abstract class Animal {
    abstract eat (): void
    abstract name: string
}

class Dog extends Animal {
    public name = 'dog'
    constructor () {
        super()
    }
    public eat () {}
}

interface

類型註解:

class Person {}
type {}
interface {}

接口是規範的定義。

// 屬性類型接口
interface Color {
    firstName: string
    name: string
}

let a: Color = { // 對象約束
    name: 'tan',
    firstName: 'pink'
}

---

// 函數類型接口
interface encrypt {
    (key: string, val: string): string
}

let md5: encrypt = (key, val): string => {}

// 可索引的接口：數據，對象的約束