L'utilisation réelle de générique dans tapuscrit

Question

Je ne comprends pas ce que l'utilisation réelle des génériques dans 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}); 

Dans l'exemple ci-dessus, nous passons l'interface c pour fonctionner CalcAverageAge. Mais sans utiliser l'extension ICustomer, nous ne pouvons pas utiliser l'âge et le nom à l'intérieur de cette classe.

Ensuite, à quoi sert de passer le modèle (c) dans la fonction. Nous pouvons écrire directement le code ci-dessous au format

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

Pouvez-vous donner un exemple concret où les médicaments génériques est vraiment utile?

Je vais vous expliquer mon scénario où j'ai besoin d'utiliser des génériques.

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"); 
} 
} 

Peut-on y parvenir avec generice?

Si ce n'est pas ce qui serait le meilleur moyen de mise en œuvre en évitant les codes en double.

Answer 1

Dans votre exemple, il est correct que l'interface est tout ce dont vous avez besoin. Les génériques sont quelque chose qui est utile quand vous voulez faire quelque chose générique; parfois, il peut être si générique que vous n'avez même pas besoin d'une interface. L'exemple que vous présentez n'est pas seulement générique, il limite aussi ce à quoi le générique peut ressembler avec une interface.

D'autres exemples de ce qu'un générique peut être utilisé est une collection qui peut contenir n'importe quel type d'élément. Le type de tableau de type est un exemple de cela - var a = new Array<number>() - par exemple.

Mais dire que vous voulez créer une fonction qui compare deux éléments, quelque chose comme ceci:

interface IValue { value: number; } 

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

Dans ce cas, vous avez la question que la fonction max retourne son résultat comme IValue Dans la plupart des cas ce n'est pas ce que tu veux. Ce que vous voulez est quelque chose comme ceci:

interface IValue { value: number; } 

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

Voici le type de retour de max est quel que soit le type générique est T, ce qui est plus utile.