// 普通接口里面有泛型函数, 接口里的函数是泛型函数
// 函数参数和函数返回类型,泛型函数在函数的括号前加<T>
// Array<T>
interface TestObj1 {
<T>(arg:T):T,
}
// 泛型函数
function testFunction1<T>(arg: T): T {
return arg;
}
let usage1 : TestObj1 = testFunction1;
// 另一种写法
interface TestObj2 {
b: <T>(arg:T) => T
}
function testFunction2<T>(arg: T): T {
return arg;
}
let obj = { b: testFunction2}
let usage2 : TestObj2 =obj;
// 泛型接口
interface TestObj3<T> {
<T>(arg:T):T,
}
function testFunction3<T>(arg: T): T {
return arg;
}
let usage3 : TestObj3<number> = testFunction3;
// 泛型类
class TestObj4<T> {
add!: (x:T, y:T) => T;
zeroValue!:T;
constructor() {}
}
let usage4 = new TestObj4<number>();
usage4.add = (x:number, y: number) => x + y;
usage4.zeroValue = 0;
// 泛型约束
interface TestObj5 {
length:number;
}
function testFunction5<T extends TestObj5>(arg: T): T {
return arg;
}
//Error
testFunction5(2);
// 一定要传规定的testObj5的结构,这个就、叫约束
testFunction5({ length:2, value:2});
可索引的类型
interface IndexInterfaceTest {
[index: number]: string;
}
let indexUsage: IndexInterfaceTest = ['a', 'b'];
// 'a'
console.log(indexUsage[0]);
// 'b'
console.log(indexUsage[1]);
let indexUsage2: IndexInterfaceTest = {0: 'c',1: 'd'}
// 'c'
console.log(indexUsage2[0]);
// 'd'
console.log(indexUsage2[1]);
interface Obj {
name: string;
age: number;
}
interface IndexInterfaceTest2 {
[index: string]: Array<Obj>;
}
let values:IndexInterfaceTest2 = {'student': [{name: 'lvxin', age: 18}], 'student2':[]}
// []
console.log(values['student2']);
// ['student', 'student2']
let attrs: Array<keyof IndexInterfaceTest2> = Object.keys(values);
console.log(attrs);