typescript-基礎篇(三)

函數相關知識點梳理

// 1. 必選參數不能位於可選參數以後
function add5(x: number, y?: number){
    return x? x + y: x
}

// 2.給參數默認值；在必選參數前，默認參數是不能夠省略的；能夠明確的傳入undefind，來獲取默認值；
function add(x: number, y = 0, z: number, q = 1) {
    return x + y + z + q
}
console.log(2, undefind, 3);

// rest
function add7(x: number,...rest: number[]){
    return x + rest.reduce((pre, curl) => pre + curl)
}
add7(1, 2, 3, 4, 5)

函數重載

• 函數重載：兩個函數若是函數名相同，參數個數或者參數類型不一樣就實現了函數重載；
  • 好處：不須要爲了類似功能的函數，選用不一樣的函數名稱，加強了函數的可讀性；
• ts 函數重載：要求先定義一系列名稱相同的函數聲明,在類型最寬泛的版本中(any)實現重載；
  • ts 編譯器在處理重載的時候，會查詢一個重載的列表，而且會嘗試第一個定義，若是匹配，就使用這個定義，若是不匹配，就接着往下查找；因此要把最容易匹配的函數定義寫在最前面；

function add8(...rest: number[]): number
function add8(...rest: string[]): string
function add8(...rest: any[]): any{
    let first = rest[0]
    if(typeof first === 'string') {
        return rest.join('')
    }
    if(typeof first === 'number') {
        return rest.reduce((pre, curl) => pre + curl)
    }
}

類(1): 繼承和成員修飾符

ts 中的類覆蓋了 es6 中的類，同時也引入了其餘一些特性；

class Dog {
    // 加上了private關鍵字，既不能被實例化，也不能被繼承
 private constructor(name: string) {
    //  this.name = name;
  }
  // 不管在es仍是ts中，類成員的屬性都是實例的屬性，而不是 原型屬性；
  // 類成員的方法都是原型方法
  // ts中 ，實例的屬性必須具備初始值，或者在構造函數中被初始化，
  name: string = 'dog';
  dName?: string = 'dog';
  run() {}
  private pri(){}
  protected protect(){}
  readonly legs: number = 4;
  static food: string = "tomato"
}
let dog = new Dog('dd');
// dog.pri() 報錯
// dog.protect() 報錯
console.log('dog', dog);
console.log(Dog.prototype);
console.log(Dog.tomato)
// 報錯，console.log(dog.tomato)

類的繼承

class Huskey extends Dod {
    constructor(name:string, color: string, food: string){
        super() // 派生類的構造函數必須包含super調用，父類的實例，super代碼父類的實例；
        this.color = color;
        // this.pri() 私有成員，報錯
        this.protect()
        this.food = food
    }
    color: string
}

類的成員修飾符

• public 默認都是 public
• private
  • private,只能被類自己調用，不能被類的實例調用，也不能被類的子類調用
  • 能夠給構造函數加上私有成員屬性，這個類既不能被實例化，也不能被繼承，
• protected
  • protected 受保護成員，受保護成員只能在類或者子類中訪問，不能再類的實例中訪問；
  • 構造函數也能被聲明爲 protected，這個類不能被實例化，只能被繼承；
• static
  • 用來修飾類的靜態成員，類的靜態成員只能經過類名來調用，不能經過實例調用
  • 類的靜態成員能夠被繼承，
• readonly 聲明瞭屬性，是不能夠被更改的；只讀屬性必定要被初始化，跟實例屬性是同樣的；
• 除了類的成員能夠添加修飾符以外，構造函數的參數也能夠添加修飾符；將參數自動變成實例的屬性；

class Huskey extends Dod {
    constructor(name:string,public color: string){
        super()
        this.color = color;
    }
  //  color: string  構造函數聲明瞭color，這裏能夠省略
}

類（2）：抽象類和多態

抽象類

• 只能被繼承，不能被實例化的類；
  • 在父類中能夠定義具體的方法實現，子類能夠調用，這樣實現了方法的複用；
  • 在抽象類中也能夠不指定方法的具體實現，這就構成了一個抽象方法；
    • 抽象方法的好處就是，明知道子類能夠有其餘的實現，那麼就不必在父類中實現了；
    • 抽象類的好處是能夠抽離一些事物的共性，這樣有利於代碼的複用和擴展；另外，抽象類也能夠實現多態；

abstract class Animal {
    eat(){

    }
    abstract sleep(): void
}
// let animal = new Animal() 報錯

class Dog extends Animal{
    constructor(name: string){
        super()
        this.name = name
    }
    name: string
    run() {}
    sleep(){
        console.log('dog sleep')
    }
}

let dog1 = new Dog("dahuang");
dog1.eat()

class Cat extends Animal {
    sleep(){
        console.log('cat sleep');
    }
}
let cat = new Cat();

let animals = Animal[dog, cat];
animals.forEach(i => {
    i.sleep() // 這裏執行的時候，就會判斷是哪一個實例，就會執行對應的方法；
})

多態

就是在父類中定義一個抽象方法，在多個子類中，有對這個方法不一樣的實現；在程序運行時，會根據不一樣的對象執行不一樣的操做；這樣就實現了運行時的綁定

this 類型

• 類的成員方法能夠直接放回 this，這樣能夠很方便的實現鏈式調用；
• 在繼承的時候，this 類型也能夠表現爲多態，這裏的多態是指： this 便可以是父類型，也能夠是子類型；

class  WorkFlow{
    step1(){
        return this;
    }
       step2(){
        return this;
    }
}
new WorkFlow().step1().step2();

class MyFlow extends WorkFlow{
    next(){
        return this;
    }
}
// 這時 this能夠是子類類型，也能夠是父類類型；
new MyFlow().next().step1().next().step2()

接口和類的關係

interface Human { // new (name: string): void; 報錯 name: string; eat(): void }

// 1.類實現接口的時候，必須實現接口中聲明的全部的屬性；
// 若是類定義一個本身的屬性，這樣是能夠的
class Asian implements Human {
    constructor(name: string){
        this.name = name
    }
    name: string
  //  private name: string 報錯
    eat(){}
    sleep(){}
}
// 2. 接口只能約束類的公有成員，不能約束私有成員
// 3. 接口不能約束類的構造函數；