Cómo iniciar una nueva clase de TStal manera (ejemplo C#para mostrar lo que quiero):

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

[editar]
Cuando escribía esta pregunta, era un desarrollador puro de .NET sin mucho conocimiento de JS. También TypeScript era algo completamente nuevo, anunciado como un nuevo superconjunto de JavaScript basado en C #. Hoy veo cuán estúpida fue esta pregunta.

De todos modos, si alguien todavía está buscando una respuesta, consulte las posibles soluciones a continuación.

Lo primero a tener en cuenta es que en TS no deberíamos crear clases vacías para los modelos. La mejor manera es crear una interfaz o tipo (según las necesidades). Buen artículo de Todd Motto: https://ultimatecourses.com/blog/classes-vs-interfaces-in-typescript

SOLUCIÓN 1:

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

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

SOLUCIÓN 2:

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

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

SOLUCIÓN 3 (cuando realmente necesitas una clase):

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('', '');

Por supuesto, en ambos casos, es posible que no necesite tipos de conversión manualmente porque se resolverán a partir del tipo de retorno de función / método.

Actualizar

Desde que escribí esta respuesta, han surgido mejores formas. Vea las otras respuestas a continuación que tienen más votos y una mejor respuesta. No puedo eliminar esta respuesta ya que está marcada como aceptada.

Vieja respuesta

Hay un problema en el codeplex de TypeScript que describe esto: Soporte para inicializadores de objetos .

Como se indicó, ya puede hacerlo mediante el uso de interfaces en TypeScript en lugar de clases:

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

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

Actualizado el 12/07/2016: Typecript 2.1 presenta Tipos mapeados y proporciona Partial<T>, lo que le permite hacer esto ...

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"}),
];

Respuesta original

Mi enfoque es definir una fieldsvariable separada que pase al constructor. El truco consiste en redefinir todos los campos de clase para este inicializador como opcional. Cuando se crea el objeto (con sus valores predeterminados) simplemente asigna el objeto inicializador 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 hacerlo manualmente (un poco más seguro):

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

uso:

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
]; 

y salida de consola:

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 }   

Esto le brinda seguridad básica e inicialización de la propiedad, pero todo es opcional y puede estar fuera de servicio. Si no pasa un campo, obtiene los valores predeterminados de la clase solo.

También puede mezclarlo con los parámetros de constructor requeridos: pegue fieldsal final.

Creo que lo más parecido al estilo C # que vas a conseguir ( se rechazó la sintaxis real field-init ). Prefiero el iniciador de campo apropiado, pero no parece que suceda todavía.

A modo de comparación, si utiliza el enfoque de conversión, su objeto de inicialización debe tener TODOS los campos para el tipo al que está enviando, además de no obtener ninguna función específica de clase (o derivaciones) creada por la clase misma.

A continuación se muestra una solución que combina una aplicación más corta Object.assignpara modelar más de cerca el original.C# patrón .

Pero primero, revisemos las técnicas ofrecidas hasta ahora, que incluyen:

1. Copie los constructores que aceptan un objeto y aplíquelo a Object.assign
2. Un listo Partial<T> truco dentro del constructor de copias
3. Uso de "casting" contra un POJO
4. Apalancamiento en Object.createlugar deObject.assign

Por supuesto, cada uno tiene sus pros / contras. Modificar una clase de destino para crear un constructor de copia puede no ser siempre una opción. Y "casting" pierde las funciones asociadas con el tipo de destino. Object.createparece menos atractivo ya que requiere un mapa descriptor de propiedades bastante detallado.

La respuesta más breve de uso general

Entonces, aquí hay otro enfoque que es algo más simple, mantiene la definición de tipo y los prototipos de funciones asociadas, y modela más de cerca el C#patrón deseado :

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

Eso es. La única adición sobre el C#patrón es Object.assignjunto con 2 paréntesis y una coma. Consulte el siguiente ejemplo de trabajo para confirmar que mantiene los prototipos de función del tipo. No se requieren constructores, ni trucos ingeniosos.

Ejemplo de trabajo

Este ejemplo muestra cómo inicializar un objeto usando una aproximación de un C#inicializador de 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() );

Puede afectar a un objeto anónimo lanzado en su tipo de clase. Bonificación : en Visual Studio, te beneficiarás de intellisense de esta manera :)

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

Editar:

ADVERTENCIA Si la clase tiene métodos, la instancia de su clase no los obtendrá. Si AClass tiene un constructor, no se ejecutará. Si utiliza instancia de AClass, obtendrá falso.

En conclusión, debe usar la interfaz y no la clase . El uso más común es para el modelo de dominio declarado como Objetos antiguos simples. De hecho, para el modelo de dominio, debería usar mejor la interfaz en lugar de la clase. Las interfaces se utilizan en el momento de la compilación para la verificación de tipos y, a diferencia de las clases, las interfaces se eliminan por completo durante la compilación.

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

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

Sugiero un enfoque que no requiere Typecript 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();

puntos clave:

• Mecanografiado 2.1 no requerido, Partial<T>no requerido
• Admite funciones (en comparación con la aserción de tipo simple que no admite funciones)

Estaría más inclinado a hacerlo de esta manera, usando (opcionalmente) propiedades automáticas y valores predeterminados. No ha sugerido que los dos campos son parte de una estructura de datos, por eso elegí de esta manera.

Puede tener las propiedades en la clase y luego asignarlas de la manera habitual. Y, obviamente, pueden o no ser necesarios, por lo que también es otra cosa. Es solo que este es un azúcar sintáctico tan agradable.

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

En algunos escenarios, puede ser aceptable usar Object.create . La referencia de Mozilla incluye un polyfill si necesita compatibilidad con versiones anteriores o si desea implementar su propia función de inicializador.

Aplicado a tu ejemplo:

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

Escenarios útiles

• Pruebas unitarias
• Declaración en línea

En mi caso, encontré esto útil en pruebas unitarias por dos razones:

1. Cuando pruebo las expectativas, a menudo quiero crear un objeto delgado como expectativa
2. Los marcos de prueba de unidad (como Jasmine) pueden comparar el prototipo de objeto ( __proto__) y fallar la prueba. Por ejemplo:

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

El resultado de la falla de la prueba de la unidad no dará una pista sobre lo que no coincide.

3. En las pruebas unitarias, puedo ser selectivo sobre los navegadores que soporto

Finalmente, la solución propuesta en http://typescript.codeplex.com/workitem/334 no admite la declaración en línea de estilo json. Por ejemplo, lo siguiente no se compila:

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

Quería una solución que tuviera lo siguiente:

• Todos los objetos de datos son obligatorios y deben ser completados por el constructor.
• No es necesario proporcionar valores predeterminados.
• Puede usar funciones dentro de la clase.

Aquí está la forma en que lo hago:

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();

Todas las propiedades en el constructor son obligatorias y no pueden omitirse sin un error del compilador.

Depende de OnlyDataque se filtre fuera getFullName()de las propiedades requeridas y se define así:

// 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>;

Limitaciones actuales de esta manera:

• Requiere TypeScript 2.8
• Clases con captadores / setters

Esta es otra solución:

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

Podría tener una clase con campos opcionales (marcados con?) Y un constructor que recibe una instancia de la misma clase.

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" }),
];

En este caso, no podrá omitir los campos obligatorios. Esto le brinda un control detallado sobre la construcción del objeto.

Puede usar el constructor con el tipo Parcial como se indica en otras respuestas:

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

El problema es que todos los campos se vuelven opcionales y no es deseable en la mayoría de los casos.

La forma más fácil de hacerlo es con el tipo de conversión.

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

Si está utilizando una versión anterior de mecanografiado <2.1, puede usar una similar a la siguiente, que básicamente es la conversión de cualquier objeto tipeado:

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

NOTA: El uso de este método solo es bueno para los modelos de datos, ya que eliminará todos los métodos del objeto. Básicamente es lanzar cualquier objeto a un objeto escrito

si desea crear una nueva instancia sin establecer el valor inicial cuando la instancia

1- tienes que usar clase no interfaz

2- tienes que establecer el valor inicial al crear la clase

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


student: IStudentDTO = new IStudentDTO();