inicializar - Combinando la taquigrafía de las propiedades de los parámetros con la destrucción en TypeScript

typescript integer

Question

EDITAR

Registré un problema en el repositorio Github de TypeScript y están aceptando relaciones públicas para implementarlo.

En TypeScript, cuando deseamos crear automáticamente propiedades en nuestra clase a partir de la definición del constructor, podemos aprovechar la taquigrafía de propiedades de parámetros, por ejemplo:

class Person {
    constructor(public firstName : string, public lastName : number, public age : number) {

    }
}

Y luego, el Javascript transpilado será:

var Person = (function () {
    function Person(firstName, lastName, age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }
    return Person;
})();

Pero si queremos recibir un objeto en nuestro constructor, sería algo como:

interface IPerson {
    firstName : string,
    lastName : string,
    age: number
}

class Person {
    constructor(person : IPerson) {
        this.firstName = person.firstName;
        this.lastName = person.lastName;
        this.age = person.age;
    }
}

Desde TypeScript 1.5, podemos aprovechar la desestructuración, por ejemplo:

class Person {
    constructor({firstName, lastName, age} : {firstName: string, lastName: string, age: number}) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }
}

Pregunta : ¿Cómo combinar la abreviatura de las propiedades de los parámetros y la destrucción en TypeScript?

He intentado definir el public antes de la definición del objeto, por ejemplo:

class Person {
    constructor(public {firstName, lastName, age} : {firstName: string, lastName: string, age: number}) {

    }
}

Intenté definirlo antes de cada variable, por ejemplo:

class Person {
    constructor({public firstName, public lastName, public age} : {firstName: string, lastName: string, age: number}) {

    }
}

Pero no tuve éxito. ¿Alguna idea?

Answer 1

Actualmente no hay una manera de hacer esta mano corta, por lo que lo más cerca que puede acercarse es declarar las propiedades a mano y asignar las variables de la asignación de desestructuración:

class Person {
    firstName: string;
    lastName: string;
    age: number;

    constructor({firstName, lastName, age} : {firstName: string, lastName: string, age: number}) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }
}

Si está haciendo eso ... es probable que solo decida aceptar una IPerson y asignar sus miembros sin usar la desestructuración en el constructor.

Answer 2

Otra estrategia es usar la capacidad de asignar a una variable de un nombre diferente. Esto reduce una repetición en el constructor.

class Person {
    firstName: string;
    lastName: string;
    age: number;

    constructor(args: { firstName: string, lastName: string, age: number, }) {
        ({
            firstName: this.firstName,
            lastName: this.lastName,
            age: this.age,
        } = args);
    }
}

También puede mover una de las definiciones en el constructor a una interfaz.

interface PersonConstructorArgs {
    firstName: string;
    lastName: string;
    age: number;
}
class Person {
    firstName: string;
    lastName: string;
    age: number;

    constructor(args: PersonConstructorArgs) {
        ({
            firstName: this.firstName,
            lastName: this.lastName,
            age: this.age,
        } = args);
    }
}

Esto será útil cuando tengas una jerarquía.

interface PersonConstructorArgs {
    firstName: string;
    lastName: string;
    age: number;
}
class Person {
    firstName: string;
    lastName: string;
    age: number;

    constructor(args: PersonConstructorArgs) {
        ({
            firstName: this.firstName,
            lastName: this.lastName,
            age: this.age,
        } = args);
    }
}
interface EmployeeConstructorArgs extends PersonConstructorArgs {
    manager: Person;
}
class Employee extends Person {
    manager: Person;

    constructor(args: EmployeeConstructorArgs) {
        super(args);
        ({
            manager: this.manager,
        } = args);
    }
}

Answer 3

Si tienes acceso a Object.assign , esto funciona:

class PersonData {
  firstName: string
  constructor(args : PersonData) {
    Object.assign(this, args)
  }
}

class Person extends PersonData{}

Pero tenga en cuenta que las nuevas instancias se rellenarán con cualquier cosa en los argumentos: no puede eliminar solo las claves que desea usar.