Angular 2 instantiate class with empty values

Question

How do you instantiate the members as class with empty values?

Plunkr

I instantiate with

public members = new MemberClass();

Answer 1

Use interfaces ;) And this is a way you can create an Array with an empty object of type Member with properties set. I don't know the use case, at least I do not set the properties for empty objects/arrays of models, but here we go :)

So first your interfaces, which are:

export interface Member {
    Id: string;
    Name: string;
    Cases: Case[];
}
export interface History {
    Id: string;
    CaseNumber: string;
}
export interface Case {
    History: History[];
}

Then you create 3 functions to set the properties:

export function createMember(Id?:string,Name?:string, Cases?:Case[]): Member {
  return {
    Id,
    Name,
    Cases[createCase()]       
  }
}

export function createCase(History?:History[]): Case {
  return {
    History[createHistory()]
  }
}

export function createHistory(Id?: string,CaseNumber?:string): History {
  return {
    Id,
    CaseNumber
  }
}

And now in your component you can call the function createMember, that then calls the two other functions:

members = [createMember()];

PS, according to your models, the following is not the model of Member-array, they name and build doesn't match, but I have created the above, based on the models you have provided.

Answer 2

Keep in mind that you're using Interfaces there, not classes. In Typescript, as in Javascript, an empty object is just {}

So, to do what you're looking for, try this: let history: History = { Id:"", CaseNumber:""};

If you try to leave out any of those properties, you'll get an error that they're required. If you want properties of an interface to be optional when instantiating, update your interface like this: CaseNumber?: string;

Find more in the handbook.

To further clarify: a class is a concrete type that you can instantiate and use as you would in any language. If you need a constructor or default values on your properties, you should use export class MyType {}.

However, in my experience, I've found interfaces in Typescript to be more useful than classes in many cases. The reason for this is that you can code against them at dev-time, but they aren't included in your bundles when you ship (N.B. this ENTIRELY depends on your use-case).