TypeScript学习记录

直接对着官方文档敲了一遍

// 基础类型
// 通过指定类型 or 指定初始值

let isDone: boolean = false
let flag = true
let str: string = 'bob'
str = `test ${isDone}`
let age: number = 40
let list: number[] = [1, 2, 3]

// let list2 = Array<number> = [1,2,3]
let x: [string, number]
x = ['hi', 20]

console.log(x[0].substr(1))
enum Color { Red, Green, Blue }
let c: Color = Color.Green
let getCity
getCity = function () {
    console.log(getCity);
}
// 函数解构没什么变化
function test({ test = '我是测试' } = {}) {
    console.log(test)
    return test
}
// 接口
interface sTest {
    label: string // 必备属性
    width?: number // 可选属性
    readonly read?: boolean // 只读属性
    [propName: string]: any // 允许其他属性
}
function printLabel(labelObj: sTest) {
    console.log(labelObj.label);
    // labelObj.read = !labelObj.read
}
printLabel({ label: 'sad', read: true, test: 'asd', ete: false })

let stest: sTest = { label: 'label', read: false }
// stest.read = true
stest.label = 'test'

// 只读数组
let a: ReadonlyArray<number> = [1, 2, 3]
// a[0] = 5 
// a.push(5)

// 函数类型
interface Sfun {
    // 参数类型 & 返回值类型
    (url: string, name?: boolean): boolean
}
let myFun: Sfun
// 使用预设值
myFun = function (ul, sds = false) {
    return ul && sds
}
myFun('123', Boolean(12))
myFun('123')
// 不使用接口
let myF
myF = function (name: string, age?: number): Date {
    return new Date()
}
myFun('abc')
// 可索引的类型
interface StringArr {
    [index: number]: string
}
let myArr: StringArr
myArr = ['ABC', 'cde']
let myStr: string = myArr[0]

interface NumberDict {
    readonly [index: string]: number
    length: number
    // name: string
}
let myObj: NumberDict = {
    index: 12,
    length: 13
}
myObj.length = 15
// myObj.length = '12'

// 类类型
interface ClockInter {
    endTime: Date
    getTime(): Date
}
class Clock implements ClockInter {
    endTime: Date
    constructor(start: Date, step: number) {
        this.endTime = start
    }
    getTime() {
        return this.endTime
    }
}
// 继承接口
interface An {
    name: string
}
interface Cat extends An {
    color: string
}
interface 变异 {
    height: number
}
interface 老虎 extends Cat, 变异 {
    称号: string
}
let blackCat: 老虎 = {
    name: '',
    color: 'red',
    height: 50,
    称号: '森林之猫'
}

// 混合类型
interface Counter {
    (start: number): string
    interval: number
    reset(): void
}
function getCounter(): Counter {
    let counter = <Counter>function (start: number) { };
    counter.interval = 123
    counter.reset = function () { }
    return counter
}
// 类
class Greeter {
    greeting: string
    constructor(message: string){
        this.greeting = message
    }
    greet (): string{
        return `HI  ${this.greeting}`
    }
}
let greeter = new Greeter('Z').greet()
// 类的继承 父与子
class 动物 {
    private 目: string
    constructor(name = '食肉目') {
        this.目 = name
    }
    移动(距离: number = 0){
        console.log(`${this.目}动物移动 ${距离} 米`)
    }
    叫声(特征: string = 's'){
        console.log(`动物叫声 ${特征}`)
    }
}
class 狗 extends 动物{
    constructor(name = '食肉目 犬科 狗'){
        super(name)
    }
    移动(距离 = 10){
        console.log('狗开始移动')
        super.移动(距离)
    }
    叫声(){
        super.叫声('汪汪')
    }
}
class 猫 extends 动物 {
    移动(距离 = 15){
        console.log('猫开始移动')
        super.移动(距离)
    }
    private 介绍(){
        // 无法访问其他类的私有属性
        // console.log(`${super.目}`)
    }
}
class 植物 {
    private 目: string
    constructor(name = '管状花目 旋花科 红薯') {
        this.目 = name
    }
}
let cuteDog = new 狗
let cuteCat = new 猫
let cuteAnimal = new 动物('可爱的动物')
let eatPlant = new 植物

cuteAnimal = cuteDog
cuteAnimal = cuteCat
/** 如果其中一个类型里包含一个 private成员，那么只有当另外一个类型中也存在这样一个 private成员， 并且它们都是来自同一处声明时，我们才认为这两个类型是兼容的。 */
// cuteCat = cuteDog 不兼容
// cuteAnimal = eatPlant 不兼容