如何以TS这种方式初始化新类（示例C#以显示我想要的内容）：

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

[edit]
当我写这个问题时，我是一个纯粹的.NET开发人员，没有太多的JS知识。TypeScript也是全新的东西，它是基于C＃的JavaScript的超集。今天，我看到这个问题多么愚蠢。

无论如何，如果有人仍在寻找答案，请查看以下可能的解决方案。

首先要注意的是在TS中，我们不应为模型创建空类。更好的方法是创建接口或类型（取决于需求）。来自Todd Motto的好文章：https : //ultimatecourses.com/blog/classes-vs-interfaces-in-typescript

解决方案1：

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

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

解决方案2：

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

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

解决方案3（当您确实需要上课时）：

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

要么

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

当然，在两种情况下，您可能都不需要手动转换类型，因为它们将从函数/方法返回类型中解析。

更新资料

自编写此答案以来，出现了更好的方法。请查看下面的其他投票，它们有更多的票数和更好的答案。由于此答案已被标记为接受，因此无法删除。

旧答案

TypeScript Codeplex上有一个问题对此进行了描述：支持对象初始化器。

如前所述，您已经可以通过使用TypeScript中的接口代替类来做到这一点：

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

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

2016年7月12日更新：Typescript 2.1引入了Mapped Types并提供Partial<T>，可以让您执行此操作。

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

原始答案：

我的方法是定义一个单独的fields变量，该变量传递给构造函数。技巧是重新定义此初始化程序的所有类字段为可选。创建对象（使用默认值）后，您只需将初始化程序对象分配给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);
    }
}

或手动执行（更加安全）：

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

用法：

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

和控制台输出：

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 }   

这为您提供了基本的安全性和属性初始化，但是所有初始化都是可选的，并且可能是乱序的。如果不传递字段，则将剩下班级的默认值。

您也可以将其与必需的构造函数参数混合使用-坚持fields到底。

我认为，这与C＃风格差不多（实际的field-init语法被拒绝）。我非常希望使用适当的字段初始化程序，但看起来还不会发生。

为了进行比较，如果使用强制转换方法，则初始化程序对象必须具有要转换为的类型的所有字段，并且不要获取由类本身创建的任何特定于类的函数（或派生类）。

下面是一个解决方案，结合了较短的应用程序Object.assign以更紧密地建模原始C#模式。

但是首先，让我们回顾一下到目前为止提供的技术，其中包括：

1. 复制接受对象的构造函数并将其应用于 Object.assign
2. Partial<T>复制构造函数中的一个巧妙技巧
3. 对POJO使用“广播”
4. 利用Object.create而不是Object.assign

当然，每个人都有其优点/缺点。修改目标类以创建复制构造函数可能并不总是一种选择。并且“广播”失去了与目标类型相关的任何功能。 Object.create似乎不太吸引人，因为它需要相当冗长的属性描述符映射。

最短的通用答案

因此，这是另一种稍微简单一些的方法，它可以维护类型定义和关联的函数原型，并可以更紧密地建模所需的C#模式：

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

而已。C#模式上唯一的加法是Object.assign加上2个括号和一个逗号。查看下面的工作示例，以确认它维护该类型的函数原型。不需要构造函数，也不需要聪明的技巧。

工作实例

本示例说明如何使用C#字段初始化程序的近似值来初始化对象：

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

您可以影响以您的类类型转换的匿名对象。 奖励：在Visual Studio中，您可以通过以下方式从智能感知中受益：)

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

编辑：

警告如果类具有方法，则您的类的实例将无法获取它们。如果AClass具有构造函数，则不会执行该构造函数。如果使用instanceof AClass，则将得到false。

总之，您应该使用interface而不是class。最常见的用途是声明为“普通旧对象”的域模型。实际上，对于域模型，您最好使用接口而不是类。接口在编译时用于类型检查，与类不同，接口在编译过程中被完全删除。

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

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

我建议一种不需要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();

关键点：

• 打字稿2.1不需要，Partial<T>不需要
• 它支持函数（与不支持函数的简单类型断言相比）

我会更倾向于使用这种方式，使用（可选）自动属性和默认值。您没有建议这两个字段是数据结构的一部分，所以这就是我选择这种方式的原因。

您可以在类上具有属性，然后按常规方式分配它们。显然，它们可能是必需的，也可能不是必需的，所以这也是另一回事。只是这是一个很好的语法糖。

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

在某些情况下，可以接受使用Object.create。如果您需要向后兼容或想滚动自己的初始化函数，则Mozilla参考资料包括一个polyfill。

应用于您的示例：

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

有用的场景

• 单元测试
• 内联声明

就我而言，我发现它在单元测试中很有用，原因有两个：

1. 测试期望时，我经常想创建一个苗条的对象作为期望
2. 单元测试框架（例如Jasmine）可能会比较对象原型（__proto__）并导致测试失败。例如：

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

单元测试失败的输出不会提供有关不匹配项的线索。

3. 在单元测试中，我可以选择支持哪些浏览器

最后，在http://typescript.codeplex.com/workitem/334上提出的解决方案不支持内联json样式声明。例如，以下内容不会编译：

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

我想要一个具有以下优点的解决方案：

• 所有数据对象都是必需的，并且必须由构造函数填充。
• 无需提供默认值。
• 可以在类内部使用函数。

这是我的操作方式：

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

构造函数中的所有属性都是强制性的，如果没有编译器错误，则不得省略。

它依赖于OnlyData过滤掉getFullName()所需属性的属性，其定义如下：

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

这种方式的当前局限性：

• 需要TypeScript 2.8
• 带吸气剂/吸气剂的课程

这是另一个解决方案：

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

您可能有一个带有可选字段的类（标记为？），并且有一个接收相同类实例的构造函数。

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

在这种情况下，您将无法省略必填字段。这使您可以对对象构造进行细粒度的控制。

您可以将构造函数与Partial类型一起使用，如其他答案所述：

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

问题在于所有字段都变为可选字段，在大多数情况下不希望这样做。

最简单的方法是使用类型转换。

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

如果您使用的旧版打字稿<2.1，则可以使用类似于以下内容的方法，该方法基本上是将任何类型的对象强制转换为：

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

注意：使用此方法仅对数据模型有用，因为它将删除对象中的所有方法。基本上是将任何对象强制转换为类型化对象

如果要创建新实例而不设置实例初始值

1-您必须使用类而不是接口

2-创建类时必须设置初始值

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


student: IStudentDTO = new IStudentDTO();