Oop typescript中泛型的实际使用

我不知道typescirpt中泛型的实际用途是什么

interface ICustomer
{
  name: string;
  age: number;
}


function CalcAverageAge<c extends ICustomer>(cust1: c, cust2: c): number
{
  return (cust1.age + cust2.age)/2;
}


resNumber = CalcAverageCustomerAge({name: "Peter", age: 62},
                                   {name: "Jason", age: 33});

你能给出一个泛型真正有用的实例吗

我将向您解释我需要使用泛型的场景

interface t1{
a:String
b:number

}
interface t2 {
a:String
b:number
c:number
}
interface t3 {
a:String
b:number
d:number
}

class base<T extends t1> {
    constructor( input : T, type:string ){

        //some common code for both derived1 and derived2
        if(type==="derived1"){
        console.log(input.c);// will throw error because t1 doesn't contains c
        } else if ( type==="derived2"){
            console.log(input.d);// will throw error because t1 doesn't contains d
        }
    }
}

class derived1 extends<t2>{
constructor(){
var temp = {a:"11",b:2,c:3}
super(temp,"derived1");
}
class derived2 extends<t3>{
constructor(){
var temp = {a:"11",b:2,d:3}
super(temp,"derived2");
}
}

接口t1{
a:字符串
b:号码
}
接口t2{
a:字符串
b:号码
c:号码
}
接口t3{
a:字符串
b:号码
d:号码
}
阶级基础{
构造函数（输入：T，类型：string）{
//derived1和derived2的一些常见代码
如果（类型==“derived1”）{
console.log（input.c）；//将抛出错误，因为t1不包含c
}else if（类型==“derived2”）{
console.log（input.d）；//将抛出错误，因为t1不包含d
}
}
}
派生的类1扩展{
构造函数（）{
var temp={a:11'，b:2，c:3}
超级（临时，“衍生1”）；
}
派生的类2扩展{
构造函数（）{
var temp={a:11'，b:2，d:3}
超级（临时，“衍生2”）；
}
}

我们能用generice做到这一点吗

---

如果不是，那么避免重复代码的最佳实现方式是什么。

在您的示例中，接口就是您所需要的全部

泛型是一种很有用的东西，当你想使某个东西成为泛型时；有时它可能是如此的泛型以至于你甚至不需要一个接口。你举的例子不仅是泛型，它还限制了泛型在接口中的外观

泛型可以用于的其他示例是可以包含任何类型项的集合。typescript中的数组类型就是一个示例-

var a=new array（）

-例如

但假设您想创建一个比较两个项目的函数，如下所示：

interface IValue { value: number; }

function max(a: IValue, b: IValue): IValue {
    return a.value > b.value ? a : b;
}

interface IValue { value: number; }

function max<T extends IValue>(a: T, b: T): T {
    return a.value > b.value ? a : b;
}

在这种情况下，

max

函数会以

IValue

的形式返回其结果。在大多数情况下，这不是您想要的。您想要的是这样的：

interface IValue { value: number; }

function max(a: IValue, b: IValue): IValue {
    return a.value > b.value ? a : b;
}

interface IValue { value: number; }

function max<T extends IValue>(a: T, b: T): T {
    return a.value > b.value ? a : b;
}

interface-IValue{value:number；}
函数max（a:T，b:T）：T{
返回a.value>b.value？a:b；
}

---

这里，

max

的返回类型是泛型类型

T

的任何类型，这更有用。

这个例子足够酷，可以理解泛型。但是你会同意我的观点，当你在一个大型项目中工作时，你很少会遇到这样简单的功能（max）。你能给我一个大规模的例子吗？我已经编辑了这个问题，请看一看。请删除这个观点。这是一个错误。在你编辑的问题中，不清楚你想要实现什么。这个架构的目标是什么？

.c

和

.d

将无法访问，因为你没有给类

base

任何表明这些属性存在的信息。如果您希望这些属性可以访问，那么这是错误的设计，我们需要更多关于您实际想要做什么的信息，以便能够给您一个关于如何实现它的合理答案。