TypeScript经常使用知识之--兼容性和抽象类

这是我参与8月更文挑战的第8天，活动详情查看：8月更文挑战

由于Typescript的持续火爆，分享下TS的经常使用知识点，咱们一块儿学习交流，一块儿加油！

兼容性

在TS中，时候须要一个类型能被一个以上的类型赋值，因此就须要这个类型兼容其余类型

1.基本数据的兼容性

let a: string | number;
let b: number | string | boolean;
let c: number | string | boolean | null;

let str: string = "str";
let num: number = 1;
// a 既能够被赋值string 也能够支持number
a = str;
a = num;

复制代码

2.接口兼容性

接口兼容：属性只能多不能少

interface Person {
    name: string;
    age: number;
}
interface Men {
    name: string;
    age: number;
    gender: string;
}

let p: Person = {
    name: "tom",
    age: 11,
};

let m: Men = {
    name: "tom",
    age: 11,
    gender: "male",
};

// person 能够被赋值 Person 能够被赋值Men
let person: Person = p;
person = m;
复制代码

*3.函数兼容

1.函数兼容的时候 参数只能少不能多，返回值只能多不能少

2.rest 和 可选参数也是兼容的*

interface FN1 {
    (a: number, b: number): void;
}

interface FN2 {
    (a: number): void;
}
interface FN22 {
    (a?: number): void;
     }

    interface FN222 {
        (...rest: number[]): void;
}

let fn1: FN1 = (a: number, b: number): void => {};
let fn2: FN2 = (a: number): void => {};
let fn22: FN22 = (a?: number): void => {};
let fn222: FN222 = (...rest: number[]): void => {};

// 参数只能少不能多

let fnn: FN1;
fnn = fn1;
fnn = fn2;
// rest 和 可选参数也是兼容的
fnn = fn22;
fnn = fn222;

interface FN3 {
    (a: number, b: number): { a: number; b: number };
}

interface FN4 {
    (a: number, b: number): { a: number; b: number; c: string };
}

let fn3: FN3 = (a: number, b: number): { a: number; b: number } => ({
    a: number,
    b: number,
});
let fn4: FN4 = (a: number): { a: number; b: number; c: string } => ({
    a: number,
    b: number,
    c: string,
});

// 返回值只能多不能少
let fnn1: FN3;
fnn1 = fn3;
fnn1 = fn4;
复制代码

4.类的兼容性

构造函数不会被检查

class Fish {
    // 构造函数不会被检查
    constructor(public a: number, public b: number) {}
}
class Shark extends Fish {
    name: string;
    // 构造函数不会被检查
    constructor(name: string) {
        super(1, 1);
        this.name = name;
    }
}

let fish: Fish;
fish = new Fish(1, 1);
fish = new Shark("111");
复制代码

5.泛型的兼容性

interface F1<T> {
    a: T;
}

let f1: F1<string> = { a: "1" };
let f2: F1<number> = { a: 1 };
// 报错
// f1=f2

interface F2<T> {}

let f3: F2<string> = { a: "1" };
let f4: F2<number> = { a: 1 };
// 正确
f3 = f4;
复制代码

抽象类

TS 中继承了不少相似c# 和 java里面的的特性好比 抽象类

1.抽象类的值必须被实现

abstract class C {
  abstract fn1(): number;
  // 抽象类中也能够定义非抽象方法
  fn2(): number {
    return 2;
  }
}

class D extends C {
  //必须实现抽象类
  fn1(): number {
    return 1;
  }
  // 可是fn2能够不实现
}

复制代码

2.抽象类不能被实例化

// let c =new C()//报错
let b =new D()
复制代码

相关资料

• TypeScript 官网

你们喜欢的能够看看个人专栏 (TypeScript经常使用知识) 我会尽可能保持天天晚上更新，若是喜欢的麻烦帮我点个赞，十分感谢

你们若是喜欢“算法”的话，能够看看我分享的另一个专栏（前端搞算法）里面有更多关于算法的题目的分享,但愿能帮助你们更深的理解算法

文章内容目的在于学习讨论与分享学习算法过程当中的心得体会，文中部分素材来源网络，若有侵权，请联系删除，邮箱 182450609@qq.com