Búsqueda de sitios web

typescript - Propiedades de parámetros desestructurados en el constructor

Typescript permite propiedades de parámetros

class ParameterProperty {
  constructor(private member: number) {}
}

Lo anterior crea una clase con un miembro privado member, el constructor establece this.member al primer argumento del constructor.

Pero no hay un equivalente a 'parámetros nombrados' mediante desestructuración.

interface DestructedOptions {
  prefix: string;
  suffix: string;
}

class Destructed {
  constructor({private prefix, private suffix}: DestructedOptions) {}
}

Lo anterior no funciona, tienes que hacer algo como esto:

class Destructed {
  private prefix: string
  private suffix: string
  constructor({prefix, suffix}: DestructedOptions) {
    this.prefix = prefix;
    this.suffix = suffix;
  }
}

que es realmente verboso y requiere actualizaciones en tres lugares al agregar una nueva propiedad a DestructuredOptions. Intenté algo similar, usando propiedades mapeadas

class Destructed {
  private [P in keyof DestructedOptions]: T[DestructedOptions];
  constructor(opts: DestructedOptions) {
    Object.assign(this, opts)
  }
}

Solo para descubrir que las propiedades asignadas solo se pueden usar en tipos, no en interfaces o clases. De todos modos, no me gusta esta opción ya que copia todo de opts, realmente querría algo como esto:

class Destructed {
  constructor(opts: DestructedOptions) {
    for (let key in keyof DestructedOptions) {
      this[key] = opts[key];
    }
  }
}

Pero, por supuesto, TypeScript no te permite obtener valores en tiempo de ejecución a partir de los tipos.

Respuesta #1

¿Qué tal:

class Destructed {
    private prefix: string;
    private suffix: string;

    constructor(opts: DestructedOptions) {
        Object.assign(this, opts);
    }
}

Además, hay un problema abierto sobre esto: Combinar la desestructuración con las propiedades de los parámetros

Editar

Si quieres evitar reescribir las propiedades en la clase, entonces necesitarás hacer que los miembros sean públicos; en ese caso, la solución es como se muestra en el problema que enlacé:

class Destructed {
    constructor(opts: DestructedOptions) {
        Object.assign(this, opts);
    }
}

interface Destructed extends DestructedOptions { }

let destructed = new Destructed({ prefix: "prefix", suffix: "suffix" });
console.log(destructed.prefix);
console.log(destructed.suffix);
console.log(destructed.DoesntExist); // error

(código en el área de juegos)

Respuesta #2

En ECMAScript, la asignación por desestructuración da como resultado que las variables en variables (no propiedades en propiedades) reciban los valores de los componentes.

Ha habido una solicitud/sugerencia de función de TypeScript para combinar la desestructuración con las propiedades de los parámetros abierta desde octubre de 2015. Ese probablemente sería el lugar más efectivo para rastrear el estado de lo que quieres.

Artículos relacionados