Início / coding / Perguntas / 79554134
Accepted
Anton
Asked: 2025-04-04 06:34:36 +0800 CST

Construtor Typescript abreviado para parâmetros nomeados [duplicado]

  • 772

Já faz um tempo desde que o construtor abreviado foi introduzido, e ele é realmente útil. Agora eu posso escrever isto:

class Dog {
  constructor(
    public age: number,
    public weight: number,
  ) {}
}

em vez disso:

class Dog {
  public age: number
  public weight: number

  constructor(
    age: number,
    weight: number,
  ) {
    this.age = age
    this.weight = weight
  }
}

E funciona ainda melhor para classes mais complexas.

Gostaria de saber se há alguma abreviação para construtor de classe com parâmetros nomeados (usando destruição de objeto)? Acho que new Dog({age: 3, weight: 8})é muito mais claro do que new Dog(3, 8). Não há chance de perder as posições dos argumentos. Mas a definição de classe para isso parece realmente feia:

class Dog {
  // 1. declare properties
  public age: number
  public weight: number

  constructor({
    // 2. object destructing
    age,
    weight,
  }: {
    // 3. declare object type
    age: number,
    weight: number,
  }) {
    // 4. assign values
    this.age = age
    this.weight = weight
  }
}
// x4 duplicates, no DRY at all
typescript

4 respostas

  1. Não, não há e provavelmente nunca haverá.

    As definições de propriedade no nível do construtor são chamadas de Propriedades de parâmetro .

    Essas propriedades de parâmetros são um desses desvios em que o TypeScript não apenas digita sobre JS, mas também gera algum código.

    class Dog {
  constructor(
    public age: number,
    public weight: number,
  ) {}
}

    gera o seguinte JS

    class Dog {
    age;
    weight;
    constructor(age, weight) {
        this.age = age;
        this.weight = weight;
    }
}

    O que você está pedindo new Dog({age: 3, weight: 8})é new Dog(3, 8)totalmente diferente.

    Um é um objeto que não tem significado em JS e o outro é o que acontece em tempo de execução.

    Com algumas exceções, o TS não foi criado para gerar código para você.

    • 2

  2. Como sabemos, JS, e portanto TS também , não suporta parâmetros nomeados.

    Citações: Usando parâmetros nomeados em JavaScript (com base em TypeScript)

    Portanto, o padrão de atribuição de desestruturação de objetos pode ser uma solução alternativa útil para nomear parâmetros. No entanto, usar tipos de objetos para o propósito de nomear parâmetros pode ter impacto no uso de Propriedades de Parâmetros .

    As Propriedades de Parâmetros têm uma sintaxe especial prefixando parâmetros construtores com um dos modificadores de visibilidade public, private, protected ou readonly . No entanto, modificadores de visibilidade não têm permissão para uso com membros do tipo objeto.

    A sintaxe a seguir gerará o erro 'public' modifier cannot appear on a type member .

    class Dog {
  constructor({
    age,
    weight,
  }: {
   public age: number,
   public weight: number,
  }) {
  }
}

    Uma solução alternativa :

    A solução alternativa a seguir usa uma função de fábrica na qual o parâmetro é digitado com o respectivo tipo de objeto. Isso permite o fornecimento de parâmetros nomeados. Em seguida, ele invoca o construtor privado por meio da palavra-chave new. Este construtor foi definido com propriedades Parameter.

     class Dog {

  static GetObject({
        age,
        weight,
      }: {
        age: number,
        weight: number,
      }){

    return new Dog(age,weight)

  }
     private constructor(
        public age : number,
        public weigth :  number,
) {}
}

const obj = Dog.GetObject({age:1, weight:2})
    • 1
  3. Best Answer

    Não há sintaxe para isso, mas você pode criar um DRY introduzindo uma interface e mesclá-la na classe:

    Parque infantil

    interface DogProps {
    age: number,
    weight: number,
}
interface Dog extends DogProps {}
class Dog {
    constructor(props: DogProps){
        Object.assign(this, props);
    }
    feed(){
        console.log('Thank you, my Snack Lord');
    }
}

const dog = new Dog({age: 3, weight: 20});
dog.age // number
    • 1

  4. Outras respostas abordam diretamente sua pergunta e oferecem soluções alternativas mais complexas, mas eu queria sugerir algumas maneiras mais simples de DESANIFICAR seu código:

    1. Os tipos de campos de classe podem ser inferidos da constructorimplementação de , então você pode remover duas anotações de tipo ( playground ):

      class Dog {
  public age
  public weight

  constructor({
    age,
    weight,
  }: {
    age: number,
    weight: number,
  }) {
    this.age = age
    this.weight = weight
  }
}

    2. A menos que no seu código real a constructorimplementação de 's seja longa/complexa (o que é seu próprio cheiro de código), não acho que desestruturar o parâmetro faça seu trabalho. Em vez disso, você pode acessar ageand weightcomo propriedades ( playground ):

      class Dog {
  public age
  public weight

  constructor(attributes: {
    age: number,
    weight: number,
  }) {
    this.age = attributes.age
    this.weight = attributes.weight
  }
}

    Ainda é um pouco repetitivo, mas é melhor do que era no seu playground original.

    • 1

relate perguntas