Pesquisa de site

typescript - É possível inicializar um objeto dentro da inicialização de outro objeto sem construtores?

O que eu preciso é bastante simples, eu só quero inicializar um objeto que é filho de outro objeto que estou inicializando. Em C# seria algo assim:

var car = new Car { 
serialNumber = 25,
engine = new Engine {
    horsePower = 500
    }
}

Neste código de exemplo, estou inicializando o tipo Engine dentro da inicialização do tipo Car. Ao tentar fazer isso com TypeScript, não importa o que eu tente, eu recebo erros de sintaxe.

Aqui está o meu código TypeScript:

var car: Car = new Car({
serialNumber: 25,
    engine: new Engine({ 
        horsePower: 500
    })
});

Este bloco de código simplesmente não funciona, e todas as classes usadas no código aqui estão obviamente importadas.

Será que realmente um recurso básico como este não é suportado no TypeScript?

EDITAR: Não há construtor nessas classes. Aqui está como elas se parecem:

export class Car { 
    serialNumber: number;
    engine: Engine;
}

Resposta #1

Você certamente pode fazer isso, você só precisa passar os argumentos corretos para o construtor.

O código que você escreveu passa um único objeto de argumento de construtor com chaves. Então suas classes deveriam se parecer com algo assim:

class Car {
    constructor(args: { serialNumber: number; engine: Engine; }) { }
}

class Engine {
    constructor(args: { horsePower: number; }) { }
}

Se, no entanto, suas classes usarem vários argumentos de construtor nomeados, como este:

class Car {
    constructor(serialNumber: number, engine: Engine) { }
}

class Engine {
    constructor(horsePower: number) { }
}

Então você simplesmente precisa passar os argumentos do seu construtor corretamente:

const car: Car = new Car(25, new Engine(500));

EDITAR

isso exigiria que eu criasse um construtor, o que é meio irritante

Estou um pouco confuso... seu código original usa classes, então você já deveria ter um construtor, a menos que você esteja adicionando cada propriedade usando uma atribuição. Por favor, poste um exemplo completo.

Se você está apenas tentando criar uma estrutura de objeto literal aninhado, você só precisa de uma interface, depois crie o objeto usando a notação normal de objeto literal do JS:

interface Car {
  serialNumber: number;
  engine: Engine;
}

interface Engine {
  horsePower: number;
}

const car: Car = {
  serialNumber: 25,
  engine: { 
    horsePower: 500
  }
};

Se você está tentando atribuir um literal de objeto a um tipo de classe, então você está fazendo isso errado. :)

EDIÇÃO 2

Então, você tem uma classe com propriedades e sem construtor. Isso significa que você não pode instanciá-la com propriedades, nem aninhadas nem uma de cada vez. Você poderia escrever uma função auxiliar genérica para instanciar uma classe e atribuir propriedades:

function create<T>(constructor: new() => T, props: Partial<T>): T {
    let instance = new constructor();
    for (let key in props) {
        instance[key] = props[key];
    }
    return instance;
}

E então crie um objeto de classe aninhada assim:

const car = create(Car, {
    serialNumber: 123,
    engine: create(Engine, {
        horsePower: 456
    })
});

Mas se suas classes realmente têm apenas propriedades, eu acho que você estaria melhor apenas usando interfaces e literais de objeto (como no meu exemplo anterior).

Resposta #2

Sua resposta é definitivamente que você pode. Mas sua sintaxe tem um problema.

var car = new Car(
       serialNumber: 25,
      engine: new Engine{ 
      horsePower: 500
     }
 );

e a classe Car deve ser assim:

public class Car(int serialNumber, Engine engine) {

 .....
}

Artigos relacionados