Jak zainicjować nową klasę w TStaki sposób (przykład, C#aby pokazać, czego chcę):

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

[edytuj]
Kiedy pisałem to pytanie, byłem czystym programistą .NET bez dużej wiedzy o JS. Również TypeScript był czymś zupełnie nowym, ogłoszonym jako nowy nadzbiór JavaScript oparty na języku C #. Dziś widzę, jak głupie było to pytanie.

W każdym razie, jeśli ktoś nadal szuka odpowiedzi, zapoznaj się z możliwymi rozwiązaniami poniżej.

Pierwszą rzeczą do odnotowania jest to, że w TS nie powinniśmy tworzyć pustych klas dla modeli. Lepszym sposobem jest utworzenie interfejsu lub typu (w zależności od potrzeb). Dobry artykuł od Todda Motto: https://ultimatecourses.com/blog/classes-vs-interfaces-in-typescript

ROZWIĄZANIE 1:

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

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

ROZWIĄZANIE 2:

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

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

ROZWIĄZANIE 3 (kiedy naprawdę potrzebujesz zajęć):

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

lub

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

Oczywiście w obu przypadkach typy rzutowania mogą nie być potrzebne ręcznie, ponieważ zostaną one usunięte z typu zwracanego przez funkcję / metodę.

Aktualizacja

Od czasu napisania tej odpowiedzi pojawiły się lepsze sposoby. Zobacz pozostałe odpowiedzi poniżej, które mają więcej głosów i lepszą odpowiedź. Nie mogę usunąć tej odpowiedzi, ponieważ jest ona oznaczona jako zaakceptowana.

Stara odpowiedź

W kodepleksie TypeScript występuje problem, który opisuje to: Obsługa inicjatorów obiektów .

Jak już wspomniano, można to zrobić już za pomocą interfejsów w TypeScript zamiast klas:

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

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

Zaktualizowano 07.12.2016: Typescript 2.1 wprowadza mapowane typy i zapewnia Partial<T>, co pozwala to zrobić ....

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

Oryginalna odpowiedź:

Moje podejście polega na zdefiniowaniu oddzielnej fieldszmiennej przekazywanej do konstruktora. Sztuką jest ponowne zdefiniowanie wszystkich pól klasy dla tego inicjalizatora jako opcjonalnych. Kiedy obiekt jest tworzony (z ustawieniami domyślnymi), po prostu przypisujesz obiekt inicjalizujący 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);
    }
}

lub zrób to ręcznie (nieco bezpieczniej):

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

stosowanie:

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

i wyjście konsoli:

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 }   

Daje to podstawową inicjalizację bezpieczeństwa i właściwości, ale wszystko jest opcjonalne i może być nieczynne. Zostaniesz pozostawiony domyślnym ustawieniom klasy, jeśli nie przejdziesz pola.

Możesz także mieszać go z wymaganymi parametrami konstruktora - trzymaj fieldssię końca.

Myślę, że mniej więcej w stylu C #, jak zamierzacie ( faktyczna składnia inicjalizacji pola została odrzucona ). Wolałbym właściwy inicjator pola, ale nie wygląda na to, żeby to się jeszcze wydarzyło.

Dla porównania, jeśli zastosujesz metodę rzutowania, twój obiekt inicjalizujący musi mieć WSZYSTKIE pola dla typu, na który rzutujesz, oraz nie może uzyskać żadnych funkcji specyficznych dla klasy (lub pochodnych) utworzonych przez samą klasę.

Poniżej znajduje się rozwiązanie, które łączy krótszą aplikację w Object.assigncelu dokładniejszego modelowania oryginalnego C#wzoru.

Najpierw jednak przejrzyjmy oferowane dotychczas techniki, które obejmują:

1. Skopiuj konstruktory, które akceptują obiekt i stosują go do Object.assign
2. Sprytna Partial<T>sztuczka w konstruktorze kopiowania
3. Zastosowanie „rzutowania” na POJO
4. Wykorzystanie Object.createzamiastObject.assign

Oczywiście, każdy ma swoje zalety / wady. Modyfikacja klasy docelowej w celu utworzenia konstruktora kopii nie zawsze może być opcją. A „rzutowanie” traci wszelkie funkcje związane z typem celu. Object.createwydaje się mniej atrakcyjna, ponieważ wymaga dość szczegółowej mapy deskryptorów właściwości.

Najkrótsza, ogólna odpowiedź

Oto kolejne podejście, które jest nieco prostsze, zachowuje definicję typu i powiązane prototypy funkcji oraz dokładniej modeluje zamierzony C#wzorzec:

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

Otóż ​​to. Jedynym dodatkiem do C#wzorca są Object.assign2 nawiasy i przecinek. Sprawdź działający przykład poniżej, aby potwierdzić, że zachowuje prototypy funkcji typu. Nie wymaga konstruktorów ani sprytnych sztuczek.

Przykład roboczy

Ten przykład pokazuje, jak zainicjować obiekt za pomocą aproksymacji C#inicjalizatora pola:

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

Możesz wpływać na anonimowy obiekt rzucony w typie swojej klasy. Bonus : W studiu wizualnym korzystasz w ten sposób z inteligencji :)

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

Edytować:

OSTRZEŻENIE Jeśli klasa ma metody, instancja klasy nie uzyska ich. Jeśli AClass ma konstruktor, nie zostanie on wykonany. Jeśli użyjesz instanceof AClass, otrzymasz fałsz.

Podsumowując, powinieneś używać interfejsu, a nie klasy . Najczęstszym zastosowaniem jest model domeny zadeklarowany jako Plain Old Objects. Rzeczywiście, w przypadku modelu domeny lepiej użyć interfejsu zamiast klasy. Interfejsy są używane w czasie kompilacji do sprawdzania typów i, w przeciwieństwie do klas, interfejsy są całkowicie usuwane podczas kompilacji.

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

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

Sugeruję podejście, które nie wymaga 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();

Kluczowe punkty:

• Maszynopis 2.1 nie jest wymagany, Partial<T> nie jest wymagany
• Obsługuje funkcje (w porównaniu z prostym asercją typu, która nie obsługuje funkcji)

Byłbym bardziej skłonny zrobić to w ten sposób, używając (opcjonalnie) automatycznych właściwości i wartości domyślnych. Nie zasugerowałeś, że dwa pola są częścią struktury danych, dlatego właśnie wybrałem tę metodę.

Możesz mieć właściwości w klasie, a następnie przypisać je w zwykły sposób. I oczywiście mogą być lub nie być wymagane, więc to także coś innego. Po prostu jest to taki miły cukier składniowy.

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

W niektórych sytuacjach użycie może być dopuszczalne Object.create. Odwołanie do Mozilli zawiera polifill, jeśli potrzebujesz kompatybilności wstecznej lub chcesz uruchomić własną funkcję inicjalizacyjną.

Dotyczy twojego przykładu:

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

Przydatne scenariusze

• Testy jednostkowe
• Deklaracja wbudowana

W moim przypadku uznałem to za przydatne w testach jednostkowych z dwóch powodów:

1. Podczas testowania oczekiwań często chcę stworzyć cienki obiekt jako oczekiwanie
2. Frameworki testów jednostkowych (takie jak Jasmine) mogą porównywać prototyp obiektu ( __proto__) i zawieść test. Na przykład:

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

Wynik niepowodzenia testu jednostkowego nie dostarczy pojęcia o tym, co jest niezgodne.

3. W testach jednostkowych mogę selektywnie wybierać obsługiwane przeglądarki

Wreszcie rozwiązanie zaproponowane na stronie http://typescript.codeplex.com/workitem/334 nie obsługuje wbudowanej deklaracji typu json. Na przykład nie można skompilować:

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

Chciałem rozwiązania, które miałoby następujące:

• Wszystkie obiekty danych są wymagane i muszą zostać wypełnione przez konstruktora.
• Nie trzeba podawać wartości domyślnych.
• Może korzystać z funkcji wewnątrz klasy.

Oto jak to robię:

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

Wszystkie właściwości konstruktora są obowiązkowe i nie można ich pominąć bez błędu kompilatora.

To zależy od tego, OnlyDataktóry filtrujegetFullName() wymagane właściwości i jest zdefiniowane w następujący sposób:

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

Obecne ograniczenia tego sposobu:

• Wymaga TypeScript 2.8
• Zajęcia z pobierającymi / ustawiającymi

To jest inne rozwiązanie:

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

Możesz mieć klasę z opcjonalnymi polami (oznaczonymi?) I konstruktor, który odbiera instancję tej samej klasy.

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

W takim przypadku nie będzie można pominąć wymaganych pól. Zapewnia to precyzyjną kontrolę nad konstrukcją obiektu.

Możesz użyć konstruktora z typem Częściowym, jak zauważono w innych odpowiedziach:

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

Problem polega na tym, że wszystkie pola stają się opcjonalne i w większości przypadków nie jest pożądane.

Najłatwiej to zrobić za pomocą rzutowania typu.

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

Jeśli używasz starej wersji maszynopisu <2.1, możesz użyć podobnej do poniższej, która polega na rzutowaniu dowolnego na wpisany obiekt:

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

UWAGA: Użycie tej metody jest dobre tylko w przypadku modeli danych, ponieważ spowoduje usunięcie wszystkich metod w obiekcie. Zasadniczo polega to na rzutowaniu dowolnego obiektu na wpisany obiekt

jeśli chcesz utworzyć nowe wystąpienie bez ustawiania wartości początkowej, gdy wystąpienie

1- musisz użyć klasy, a nie interfejsu

2- musisz ustawić wartość początkową podczas tworzenia klasy

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


student: IStudentDTO = new IStudentDTO();