结论:
type 可以修饰任何类型 (值类型和引用数据类型)
interface 只能修饰引用类型 (对象、数组、函数)
//interface 声明对象属性
interface ins {
a: string;
b?: number; //可选项
}
// interface声明函数作为对象属性的三种写法
interface ins1 {
fun: () => string;
}
interface ins2 {
fun(): string;
}
interface ins3 {
fun: { (): string };
}
let i: ins3 = {
fun: () => "444",
};
//声明独立函数
interface C {
(): string;
}
//等于
type fun = () => string;
let f: C = () => "333";
重名的 interface 自动合并,如果属性的类型冲突报错
?如果重名的 type 报错,自能声明一个
interface 通过 extends 实现
?type 通过 & 实现? (交叉类型)
interface 不支持枚举
type可以:
场景:
// server data
let mockData = {
a: "3",
b: 2,
c: {
s: 6,
j: [1, 8, 4],
},
d: [{ a: 2 }, { a: 3 }],
};
//插件 json to ts
interface RootObject {
a: string;
b: number;
c: C;
d: D[];
}
interface D {
a: number;
}
interface C {
s: number;
j: number[];
}
// component use
// import RootObject from myType.ts
type copyType = {
[k in keyof RootObject]: RootObject[k];
};
interface 可以使用,type不可以
interface C {
add(): this;
}
class ins implements C {
constructor() {}
add() {
return this;
}
}
java概念:
重写:子类对父类同名方法进行重写,返回值和形参都不能改变,当需要在子类中调用父类的被重写方法时,要使用 super 关键字。
重载:一个类可以有多个同名方法,但是方法的参数个数不能相同,实例调用时可以根据参数不同执行不同的逻辑,返回类型可以相同也可以不同。每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。
方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现,重写是父类与子类之间多态性的一种表现,重载可以理解成多态的具体表现形式。
与java不同的是:?
ts 的重载只能用 同一个方法体 实现 ,同名接口合并时,如果同名方法有不同的类型声明,那么会发生函数重载。而且,后面的定义比前面的定义具有更高的优先级。
interface A {
f(): number;
f(x: boolean): boolean;
f(x: string, y: string): string;
}
function MyFunc(): number;
function MyFunc(x: boolean): boolean;
function MyFunc(x: string, y: string): string;
function MyFunc(
x?:boolean|string, y?:string
):number|boolean|string {
if (x === undefined && y === undefined) return 1;
if (typeof x === 'boolean' && y === undefined) return true;
if (typeof x === 'string' && typeof y === 'string') return 'hello';
throw new Error('wrong parameters');
}
const a:A = {
f: MyFunc
}