CODEWITHSUNDEEP
ooptypescript
user7131571
user7131571

Reputation: 289

Real use of generic in typescript

I don't get what is the actual use of generics in 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});

In the above example we are passing interface c to function CalcAverageAge.

But without using extends ICustomer we can't use age and name inside that class.

Then what is the use of passing template( c ) in the function. We can directly write the code in below format

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

Can you give a real example where generics is really useful?

I will explain you my scenario where I need to use generics.

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

Can we achieve this with generice?

If not what would be the best way of implementation avoiding duplicate codes.

Upvotes: 3

Views: 419

Answers (1)

Nypan
Nypan

Reputation: 7246

In your example it is correct that the interface is all you need.

Generics is something that is useful when you want to make something generic; sometimes it might be so generic that you do not even need an interface. The example you bring up is not only a generic, it also limits what the generic can look like with an interface.

Other examples of what a generic can be used for is a collection that can contain any type of item. The array type in typescript is an example of that - var a = new Array<number>() - for example.

But say that you want to create a function that compares two items, something like this: 

interface IValue { value: number; }

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

In this case you have the issue that the max function returns its result as an IValue In most cases this is not what you want. What you want is something like this: 

interface IValue { value: number; }

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

Here the return type of max is whatever the generic type T is, and this is more useful.

Upvotes: 2

Related Questions