Come avviare una nuova classe in TSmodo tale (esempio in C#per mostrare ciò che voglio):

// ... some code before
return new MyClass { Field1 = "ASD", Field2 = "QWE" };
// ...  some code after

[modifica]
Quando stavo scrivendo questa domanda, ero un puro sviluppatore .NET senza molta conoscenza di JS. Anche TypeScript era qualcosa di completamente nuovo, annunciato come nuovo superset di JavaScript basato su C #. Oggi vedo quanto sia stata stupida questa domanda.

Comunque, se qualcuno è ancora alla ricerca di una risposta, per favore, guarda le possibili soluzioni di seguito.

La prima cosa da notare è che in TS non dovremmo creare classi vuote per i modelli. Il modo migliore è creare un'interfaccia o un tipo (a seconda delle esigenze). Buon articolo da Todd Motto: https://ultimatecourses.com/blog/classes-vs-interfaces-in-typescript

SOLUZIONE 1:

type MyType = { prop1: string, prop2: string };

return <MyType> { prop1: '', prop2: '' };

SOLUZIONE 2:

type MyType = { prop1: string, prop2: string };

return { prop1: '', prop2: '' } as MyType;

SOLUZIONE 3 (quando hai davvero bisogno di una lezione):

class MyClass {
   constructor(public data: { prop1: string, prop2: string }) {}
}
// ...
return new MyClass({ prop1: '', prop2: '' });

o

class MyClass {
   constructor(public prop1: string, public prop2: string) {}
}
// ...
return new MyClass('', '');

Ovviamente in entrambi i casi potrebbe non essere necessario eseguire manualmente i tipi di cast perché verranno risolti dal tipo restituito da funzione / metodo.

Aggiornare

Da quando ho scritto questa risposta, sono emersi modi migliori. Si prega di vedere le altre risposte di seguito che hanno più voti e una risposta migliore. Non riesco a rimuovere questa risposta poiché è contrassegnata come accettata.

Vecchia risposta

C'è un problema nel codeplex TypeScript che descrive questo: Supporto per inizializzatori di oggetti .

Come detto, puoi già farlo utilizzando le interfacce in TypeScript anziché le classi:

interface Name {
    first: string;
    last: string;
}
class Person {
    name: Name;
    age: number;
}

var bob: Person = {
    name: {
        first: "Bob",
        last: "Smith",
    },
    age: 35,
};

Aggiornato il 07/12/2016: Typescript 2.1 introduce i tipi mappati e fornisce Partial<T>, che ti consente di farlo ....

class Person {
    public name: string = "default"
    public address: string = "default"
    public age: number = 0;

    public constructor(init?:Partial<Person>) {
        Object.assign(this, init);
    }
}

let persons = [
    new Person(),
    new Person({}),
    new Person({name:"John"}),
    new Person({address:"Earth"}),    
    new Person({age:20, address:"Earth", name:"John"}),
];

Risposta originale:

Il mio approccio è definire una fieldsvariabile separata che passi al costruttore. Il trucco è ridefinire tutti i campi di classe per questo inizializzatore come facoltativo. Quando viene creato l'oggetto (con i suoi valori predefiniti) è sufficiente assegnare l'oggetto inizializzatore su this;

export class Person {
    public name: string = "default"
    public address: string = "default"
    public age: number = 0;

    public constructor(
        fields?: {
            name?: string,
            address?: string,
            age?: number
        }) {
        if (fields) Object.assign(this, fields);
    }
}

o fallo manualmente (un po 'più sicuro):

if (fields) {
    this.name = fields.name || this.name;       
    this.address = fields.address || this.address;        
    this.age = fields.age || this.age;        
}

utilizzo:

let persons = [
    new Person(),
    new Person({name:"Joe"}),
    new Person({
        name:"Joe",
        address:"planet Earth"
    }),
    new Person({
        age:5,               
        address:"planet Earth",
        name:"Joe"
    }),
    new Person(new Person({name:"Joe"})) //shallow clone
]; 

e uscita console:

Person { name: 'default', address: 'default', age: 0 }
Person { name: 'Joe', address: 'default', age: 0 }
Person { name: 'Joe', address: 'planet Earth', age: 0 }
Person { name: 'Joe', address: 'planet Earth', age: 5 }
Person { name: 'Joe', address: 'default', age: 0 }   

Questo ti dà la sicurezza di base e l'inizializzazione della proprietà, ma è tutto opzionale e può essere fuori servizio. Le impostazioni predefinite della classe vengono lasciate sole se non si passa un campo.

Puoi anche mischiarlo con i parametri costruttori richiesti - attacca fieldsalla fine.

Penso che sia il più vicino allo stile C # che hai intenzione di pensare ( la sintassi del field-init reale è stata respinta ). Preferirei di gran lunga l'inizializzatore di campo corretto, ma non sembra che accadrà ancora.

Per fare un confronto, se usi l'approccio di casting, il tuo oggetto inizializzatore deve avere TUTTI i campi per il tipo in cui stai lanciando, inoltre non ottenere alcuna funzione (o derivazione) specifica della classe creata dalla classe stessa.

Di seguito è una soluzione che combina un'applicazione più breve Object.assignper modellare più da vicino il modello originale C#.

Ma prima, esaminiamo le tecniche offerte finora, che includono:

1. Copia i costruttori che accettano un oggetto e applicalo a Object.assign
2. Un Partial<T>trucco intelligente nel costruttore di copie
3. Uso del "casting" contro un POJO
4. Sfruttando Object.createinvece diObject.assign

Naturalmente, ognuno ha i suoi pro / contro. La modifica di una classe di destinazione per creare un costruttore di copie potrebbe non essere sempre un'opzione. E il "casting" perde tutte le funzioni associate al tipo di destinazione. Object.createsembra meno attraente poiché richiede una mappa descrittore di proprietà piuttosto dettagliata.

Risposta più breve e generica

Quindi, ecco ancora un altro approccio che è un po 'più semplice, mantiene la definizione del tipo e i prototipi di funzione associati e modella più da vicino il C#modello previsto :

const john = Object.assign( new Person(), {
    name: "John",
    age: 29,
    address: "Earth"
});

Questo è tutto. L'unica aggiunta al C#modello è Object.assigninsieme a 2 parentesi e una virgola. Dai un'occhiata all'esempio di lavoro che segue per confermare che mantiene i prototipi di funzione del tipo. Non sono richiesti costruttori e nessun trucco intelligente.

Esempio di lavoro

Questo esempio mostra come inizializzare un oggetto usando un'approssimazione di un C#inizializzatore di campo:

class Person {
    name: string = '';
    address: string = '';
    age: number = 0;

    aboutMe() {
        return `Hi, I'm ${this.name}, aged ${this.age} and from ${this.address}`;
    }
}

// typescript field initializer (maintains "type" definition)
const john = Object.assign( new Person(), {
    name: "John",
    age: 29,
    address: "Earth"
});

// initialized object maintains aboutMe() function prototype
console.log( john.aboutMe() );

Puoi influenzare un oggetto anonimo lanciato nel tuo tipo di classe. Bonus : in Visual Studio, beneficerai dell'intellisense in questo modo :)

var anInstance: AClass = <AClass> {
    Property1: "Value",
    Property2: "Value",
    PropertyBoolean: true,
    PropertyNumber: 1
};

Modificare:

AVVERTIMENTO Se la classe ha dei metodi, l'istanza della tua classe non li otterrà. Se AClass ha un costruttore, non verrà eseguito. Se usi l'istanza di AClass, otterrai false.

In conclusione, dovresti usare l'interfaccia e non la classe . L'uso più comune è per il modello di dominio dichiarato come vecchi oggetti semplici. In effetti, per il modello di dominio dovresti usare meglio l'interfaccia invece della classe. Le interfacce vengono utilizzate al momento della compilazione per il controllo del tipo e, diversamente dalle classi, le interfacce vengono completamente rimosse durante la compilazione.

interface IModel {
   Property1: string;
   Property2: string;
   PropertyBoolean: boolean;
   PropertyNumber: number;
}

var anObject: IModel = {
     Property1: "Value",
     Property2: "Value",
     PropertyBoolean: true,
     PropertyNumber: 1
 };

Suggerisco un approccio che non richiede Typescript 2.1:

class Person {
    public name: string;
    public address?: string;
    public age: number;

    public constructor(init:Person) {
        Object.assign(this, init);
    }

    public someFunc() {
        // todo
    }
}

let person = new Person(<Person>{ age:20, name:"John" });
person.someFunc();

punti chiave:

• Dattiloscritto 2.1 non richiesto, Partial<T>non richiesto
• Supporta funzioni (rispetto a un'asserzione di tipo semplice che non supporta funzioni)

Sarei più propenso a farlo in questo modo, usando (facoltativamente) proprietà e valori predefiniti automatici. Non hai suggerito che i due campi facciano parte di una struttura di dati, quindi è per questo che ho scelto in questo modo.

Potresti avere le proprietà sulla classe e quindi assegnarle nel solito modo. E ovviamente potrebbero essere richiesti o meno, quindi anche questo è qualcos'altro. È solo che questo è così bello zucchero sintattico.

class MyClass{
    constructor(public Field1:string = "", public Field2:string = "")
    {
        // other constructor stuff
    }
}

var myClass = new MyClass("ASD", "QWE");
alert(myClass.Field1); // voila! statement completion on these properties

In alcuni scenari potrebbe essere accettabile l'utilizzo Object.create. Il riferimento Mozilla include un polyfill se è necessaria la retrocompatibilità o si desidera eseguire il rollback della propria funzione di inizializzazione.

Applicato al tuo esempio:

Object.create(Person.prototype, {
    'Field1': { value: 'ASD' },
    'Field2': { value: 'QWE' }
});

Scenari utili

• Test unitari
• Dichiarazione in linea

Nel mio caso l'ho trovato utile nei test unitari per due motivi:

1. Quando collaudo le aspettative, desidero spesso creare un oggetto sottile come aspettativa
2. I framework di unit test (come Jasmine) possono confrontare l'oggetto prototipo ( __proto__) e fallire il test. Per esempio:

var actual = new MyClass();
actual.field1 = "ASD";
expect({ field1: "ASD" }).toEqual(actual); // fails

L'output del fallimento del test unitario non fornirà un indizio su ciò che non corrisponde.

3. Nei test unitari posso essere selettivo su quali browser io supporti

Infine, la soluzione proposta su http://typescript.codeplex.com/workitem/334 non supporta la dichiarazione in stile json in linea. Ad esempio, non viene compilato quanto segue:

var o = { 
  m: MyClass: { Field1:"ASD" }
};

Volevo una soluzione che avrebbe avuto il seguente:

• Tutti gli oggetti dati sono richiesti e devono essere compilati dal costruttore.
• Non è necessario fornire i valori predefiniti.
• Può usare le funzioni all'interno della classe.

Ecco come lo faccio:

export class Person {
  id!: number;
  firstName!: string;
  lastName!: string;

  getFullName() {
    return `${this.firstName} ${this.lastName}`;
  }

  constructor(data: OnlyData<Person>) {
    Object.assign(this, data);
  }
}

const person = new Person({ id: 5, firstName: "John", lastName: "Doe" });
person.getFullName();

Tutte le proprietà nel costruttore sono obbligatorie e non possono essere omesse senza un errore del compilatore.

Dipende da OnlyDataciò che filtra fuori getFullName()dalle proprietà richieste ed è definito in questo modo:

// based on : https://medium.com/dailyjs/typescript-create-a-condition-based-subset-types-9d902cea5b8c
type FilterFlags<Base, Condition> = { [Key in keyof Base]: Base[Key] extends Condition ? never : Key };
type AllowedNames<Base, Condition> = FilterFlags<Base, Condition>[keyof Base];
type SubType<Base, Condition> = Pick<Base, AllowedNames<Base, Condition>>;
type OnlyData<T> = SubType<T, (_: any) => any>;

Limitazioni attuali di questo modo:

• Richiede TypeScript 2.8
• Classi con getter / setter

Questa è un'altra soluzione:

return {
  Field1 : "ASD",
  Field2 : "QWE" 
} as myClass;

Potresti avere una classe con campi opzionali (contrassegnati con?) E un costruttore che riceve un'istanza della stessa classe.

class Person {
    name: string;     // required
    address?: string; // optional
    age?: number;     // optional

    constructor(person: Person) {
        Object.assign(this, person);
    }
}

let persons = [
    new Person({ name: "John" }),
    new Person({ address: "Earth" }),    
    new Person({ age: 20, address: "Earth", name: "John" }),
];

In questo caso, non sarai in grado di omettere i campi richiesti. Questo ti dà un controllo accurato sulla costruzione dell'oggetto.

È possibile utilizzare il costruttore con il tipo Parziale come indicato nelle altre risposte:

public constructor(init?:Partial<Person>) {
    Object.assign(this, init);
}

Il problema è che tutti i campi diventano opzionali e non è auspicabile nella maggior parte dei casi.

Il modo più semplice per farlo è con il tipo casting.

return <MyClass>{ Field1: "ASD", Field2: "QWE" };

Se stai usando una vecchia versione di dattiloscritto <2.1 allora puoi usare qualcosa di simile al seguente che fondamentalmente sta lanciando qualsiasi oggetto tipizzato:

const typedProduct = <Product>{
                    code: <string>product.sku
                };

NOTA: l'utilizzo di questo metodo è valido solo per i modelli di dati in quanto rimuoverà tutti i metodi nell'oggetto. Fondamentalmente sta lanciando qualsiasi oggetto su un oggetto tipizzato

se si desidera creare una nuova istanza senza impostare il valore iniziale quando istanza

1- devi usare la classe non l'interfaccia

2- devi impostare il valore iniziale quando crei la classe

export class IStudentDTO {
 Id:        number = 0;
 Name:      string = '';


student: IStudentDTO = new IStudentDTO();