Typescript from entry to mastery (XXI) generic types in classes

Generic usage in classes :

We are writing a basic class class In the constructor, you need to pass the names of a group of female characters , And then through getGirlsNmae Hair method shows the name of the female character

class GirlRole{
    
    constructor(private girls:string[]){
    }
    getGirlsNmae(index:number):string{
    
        return this.girls[index]
    }
}
let girl = new GirlRole([" The daughter of void "," Hicville "," Shadow Hunter "," Xia "])
girl.getGirlsNmae(1)
console.log(girl.getGirlsNmae(1))
// The terminal console prints the results : Hicville 

Now better protect the privacy of the role , These roles are numbered , Then our program should be modified like this

class GirlRole{
    
    constructor(private girls:string[]|number[]){
    }
    getGirlsNmae(index:number):string|number{
    
        return this.girls[index]
    }
}
let girl = new GirlRole([" The daughter of void "," Hicville "," Shadow Hunter "," Xia "])
girl.getGirlsNmae(1)
console.log(girl.getGirlsNmae(1))

Obviously, there is no problem with the above code , But not elegant enough , The code looks complex
It can be used at this time Generic To solve this problem , When we write miscellaneous code everyday Generic It's often used

class GirlRole<T>{
    
    constructor(private girls:T[]){
    }
    getGirlsNmae(index:number):T{
    
        return this.girls[index]
    }
}
let girl = new GirlRole([" The daughter of void "," Hicville "," Shadow Hunter "," Xia "])
girl.getGirlsNmae(1)
console.log(girl.getGirlsNmae(0))
// The terminal console outputs the results : The daughter of void 

We used Generic , The program also reported no errors , But you will find that we are When instantiating an object , Types are inferred
We said it was Using generics , Just It is best not to use type inference
So we can write like this

	 let girl = new GirlRole<string>([" The daughter of void "," Hicville "," Shadow Hunter "," Xia "])

Inheritance in generics :

Now the demand has changed again , The return is required to be in an object roleName, That is, the following code should be changed to this way .

getGirlsNmae(index:number):string{
    
    return this.girls[index].roleName
}

The previous code must have reported an error
But at this time, we are also required to do so , This means that the passed value must be of an object type , There's more inside roleName attribute .
At this time, inheritance is needed , I use interface to realize . Write a Role The interface of , Every interface should have roleName attribute . The code is as follows ：

interface Role{
    
    roleName:string
}

With the interface, we can use extends Keyword implements generic inheritance

class GirlRole extends Role{
    
  ...
 }

This code means that there must be one in a generic roleName attribute , Because it inherited Role Interface .
It should be a string The type is right , So the code should be changed to the following ：

interface Role{
    
    roleName:string
}

class GirlRole <T extends Role>{
    
    constructor(private girls:T[]){
    }
    getGirlsNmae(index:number):string{
    
        return this.girls[index].roleName
    }
}
let girlRole = new GirlRole([
    {
    roleName:" The daughter of void "},
    {
    roleName:" Hicville "},
    {
    roleName:" Shadow Hunter "},
    {
    roleName:" Xia "},
])
girlRole.getGirlsNmae(0)
console.log(girlRole.getGirlsNmae(0))
// Print the results ： The daughter of void 

Constraints of generics :

Now generics can be of any type , It can be the object 、 character string 、 Boolean 、 Numbers are OK .
But now it is required that this generic type must be string perhaps number type . Let's take the above example , But change the code to its original appearance .

class GirlRole <T>{
    
    constructor(private girls:T[]){
    }
    getGirlsNmae(index:number):T{
    
        return this.girls[index]
    }
}
let girl = new GirlRole([" The daughter of void "," Hicville "," Shadow Hunter "," Xia "])

Then constrain , At this time, you can still use keywords extends To constrain , Change the code to the following

class GirlRole <T extends string|number>{
    
    constructor(private girls:T[]){
    }
    getGirlsNmae(index:number):T{
    
        return this.girls[index]
    }
}
 let girl = new GirlRole([" The daughter of void "," Hicville "," Shadow Hunter "," Xia "])

The above is the basic generic explanation , In practice , The application of generics is more extensive and complex
Learning together , Come on together !!!