Home / Questions / 22186
Accepted
Jose Hermosilla Rodrigo
Asked: 2020-09-01 09:35:22 +0800 CST 2020-09-01 09:35:22 +0800 CST

Constructor overloading in TypeScript

  • 772

I am trying to make a class in TypeScript, like this:

It can receive Array<Array<string>>only one or it can receive several parameters ( ancho : number, blanco : string, trozo : string)

The implementation suggests me to use the sobrecarga de constructores, but this is a problem since in TypeScript the constructors created must be compatible , so we must implement the constructors with all the class variables even if they are not explicitly needed in that constructor, although they can be declared optional ( In fact one constructor is implemented that is compatible with all the others, the other constructors are simply declared):

PLUNK

class Piramide {
    public array :  Array<Array<String>> | Array<any>;
    public ancho : number;
    public blanco : string;
    public trozo : string;

    constructor(array : Array<Array<String>> | Array<any>, ancho? : number, blanco? : string, trozo? : string);
    constructor(array :  Array<Array<String>> | Array<any>, ancho : number, blanco : string, trozo : string){

        if(!array){
            this.ancho = ancho;
            this.blanco = blanco;
            this.trozo = trozo;
            this.array = [];
        }
        else 
            this.array = array;
            this.ancho = array.length;
            ...
    }

    ...
}

Is there a way to make this more understandable and readable?

typescript

3 Answers

  1. Best Answer

    The following form seems clean and simple to me:

    class Piramide {

    constructor(
        public array?: string[][] | Array<any>,
        public ancho?: number,
        public blanco?: string,
        public trozo?: string
    ) {
        if(!array){
            this.ancho = ancho;
            this.blanco = blanco;
            this.trozo = trozo;
            this.array = [];
        }
        else
            this.ancho = array.length;
            ...
    }

    ...
}
    • 5

  2. You could simulate a "constructor overload" by checking the data type in the constructor.

    interface IUser {
  name: string;
  lastName: string;
}

interface IUserRaw {
  UserName: string;
  UserLastName: string;
}

function isUserRaw(user): user is IUserRaw {
  return !!(user.UserName && user.UserLastName);
}

class User {
  name: string;
  lastName: string;

  constructor(data: IUser | IUserRaw) {
    if (isUserRaw(data)) {
      this.name = data.UserName;
      this.lastName = data.UserLastName;
    } else {
      this.name = data.name;
      this.lastName = data.lastName;
    }
  }
}
    • 1

  3. You can use an interface, which is more flexible when declaring optional parameters. It can be used both as a parameter that the constructor receives, and as a prototype of the class that implements it:

    PLUNK

    interface IPiramide {
    array? : Array<Array<string>>,
    ancho? : number,
    blanco? : string,
    trozo?  : string
}

class Piramide implements IPiramide {

    constructor(piramide : IPiramide){

        if(piramide.array){
            this.array = piramide.array;
            this.ancho = piramide.array.length;
        }
        else {
            this.array = [];
            this.ancho = piramide.ancho;
            this.blanco = piramide.blanco;
            this.trozo = piramide.trozo;
        }

    }
}
    • 0