TypeScript Class Initialization and Field Initializers

By the end of this page, you will understand how TypeScript initializes class instances, why C#-style object initializers do not exist in the same form, and which TypeScript patterns to use instead. You will see practical approaches using constructors, parameter objects, and Object.assign() to set fields clearly and safely.

TypeScript classes look similar to classes in C# or Java, but object creation works differently.

In C#, you can write an object initializer like this:

new MyClass { Field1 = "ASD", Field2 = "QWE" }

That syntax creates an instance and then assigns properties in one expression.

In TypeScript, there is no direct equivalent for class instances using that exact syntax. Instead, developers usually use one of these patterns:

• Constructor parameters
• A constructor that accepts an object
• Object.assign() after creating the instance
• Plain object literals when a full class is not necessary

This matters because initialization is one of the most common parts of application code. Good initialization patterns make code:

• easier to read
• safer to use
• easier to validate
• easier to maintain as classes grow

TypeScript also adds type checking, so the way you initialize fields affects how much help you get from the compiler.

Think of a class like a blueprint for building an object.

• In C# object initializer syntax, you say: “Build the object, and while doing that, fill these labeled slots.”
• In TypeScript, you usually either:
  • hand the values to the constructor when building it, or
  • build the object first and then copy values into it.

A simple analogy:

• Constructor approach: ordering a sandwich by listing ingredients when you place the order.
• Object.assign() approach: getting the sandwich first, then adding ingredients afterward.

Both work, but the constructor approach is usually clearer when some values are required.

Common TypeScript patterns

1. Use a constructor with parameters

class MyClass {
  field1: string;
  field2: string;

  constructor(field1: string, field2: string) {
    this.field1 = field1;
    this.field2 = field2;
  }
}

const item = new MyClass("ASD", "QWE");

This is the most direct TypeScript version when the fields are required.

2. Use parameter properties for shorter syntax

class MyClass {
  constructor(
    public field1: string,
    public field2: string
  ) {}
}

const item = new MyClass("ASD", "QWE");

Consider this example:

class MyClass {
  field1 = "";
  field2 = "";
}

const item = Object.assign(new MyClass(), {
  field1: "ASD",
  field2: "QWE"
});

Here is what happens step by step:

1. class MyClass defines a blueprint for objects.
2. field1 = "" gives every new instance a default empty string.
3. field2 = "" does the same for field2.
4. new MyClass() creates a fresh instance:

{ field1: "", field2: "" }

1. Object.assign(..., { field1: "ASD", field2: "QWE" }) copies the provided values into that instance.
2. The final result stored in item becomes:

TypeScript class initialization appears in many real applications.

API response models

class User {
  constructor(
    public id: number,
    public name: string
  ) {}
}

const user = new User(1, "Alice");

Used when turning raw API data into structured objects.

Configuration objects

class AppConfig {
  constructor(
    public apiUrl: string,
    public timeoutMs: number
  ) {}
}

const config = new AppConfig("/api", 5000);

Useful when an application needs required settings at startup.

Form or UI state containers

class  {
  () {}
}

In real projects, developers usually choose initialization style based on how strict the data should be.

Common patterns

Constructor for required fields

Use this when an instance is invalid without certain values.

class Product {
  constructor(
    public id: number,
    public name: string
  ) {}
}

This ensures every Product has an id and name.

Parameter object for readability

When there are many options, positional constructor arguments become hard to read.

type ProductData = {
  id: number;
  name: string;
  inStock: boolean;
};

class Product {
  id: number;
  name: string;
  inStock: boolean;

  () {
    . = data.;
    . = data.;
    . = data.;
  }
}

1. Trying to use C# syntax directly

This does not work in TypeScript:

class MyClass {
  field1 = "";
  field2 = "";
}

const item = new MyClass { field1: "ASD", field2: "QWE" };

Why it fails:

• TypeScript does not support that object initializer syntax for classes.

Use this instead:

const item = Object.assign(new MyClass(), {
  field1: "ASD",
  field2: "QWE"
});

2. Forgetting to initialize required fields

class MyClass {
  field1: string;
  field2: string;
}

Depending on compiler settings, this can cause errors because the fields are declared but not initialized.

Better options:

// 1. Standard constructor
class MyClass {
  field1: string;
  field2: string;

  constructor(field1: string, field2: string) {
    this.field1 = field1;
    this.field2 = field2;
  }
}

const a = new MyClass("ASD", "QWE");

// 2. Short TypeScript constructor syntax
class MyClass {
  constructor(
    public field1: string,
    public field2: string
  ) {}
}

// 3. Object-style initialization through constructor
class MyClass {
  constructor(public data: { field1: ; field2:  }) {}
}

Is there a direct equivalent to C# object initializer syntax in TypeScript?

No. TypeScript does not support new MyClass { ... } syntax. Use a constructor, an object parameter, or Object.assign() instead.

What is the closest TypeScript alternative to C# field initialization?

Object.assign(new MyClass(), { ... }) is the closest in style, because it creates an instance and then copies properties onto it.

Should I use a constructor or Object.assign()?

Use a constructor when fields are required or validation matters. Use Object.assign() when you have default values and want a quick override pattern.

Can I pass an object to a TypeScript constructor?

Yes. This is a common pattern:

new MyClass({ field1: "ASD", field2: "QWE" })

It is especially useful when there are many fields.

Do I always need a class in TypeScript?

No. If you only need to store data, a plain object or a type/interface is often enough.

Why does TypeScript complain about properties not being initialized?

With strict compiler settings, TypeScript wants proof that class properties are assigned. You can fix this by:

• Constructors — Constructors are the main way to initialize class instances in TypeScript.
• Class properties — Field declarations and default values are part of class initialization.
• Parameter properties — A TypeScript shortcut for declaring and assigning fields in the constructor.
• Object literals — Often a simpler alternative when you only need data.
• Object.assign() — Common for copying initialization data into an instance.
• Interfaces and type aliases — Useful for describing the shape of initialization objects.
• Default values — Important when fields should start with known values.
• Validation — Often added during construction to prevent invalid objects.