TLDR: TypedJSON (prova do conceito de trabalho)

A raiz da complexidade deste problema é que precisamos deserializar o JSON em tempo de execução usando Informação do tipo que só existe em tempo de compilação . Isto requer que a informação tipo seja de alguma forma disponibilizada em tempo de execução.

1. utilizar decoradores de propriedades em Propriedades sujeitas a serialização, para gravar informação de metadados e guardar essa informação algures, por exemplo no protótipo da classe
2. dê esta informação de meta-dados a um inicializador recursivo (deserializador)

Registar A Informação Do Tipo

Com uma combinação de reflectores e decoradores de propriedades, a informação do tipo pode ser facilmente registrado sobre uma propriedade. Uma implementação rudimentar desta abordagem seria:

function JsonMember(target: any, propertyKey: string) {
    var metadataFieldKey = "__propertyTypes__";

    // Get the already recorded type-information from target, or create
    // empty object if this is the first property.
    var propertyTypes = target[metadataFieldKey] || (target[metadataFieldKey] = {});

    // Get the constructor reference of the current property.
    // This is provided by TypeScript, built-in (make sure to enable emit
    // decorator metadata).
    propertyTypes[propertyKey] = Reflect.getMetadata("design:type", target, propertyKey);
}

Para uma dada propriedade, o trecho acima irá adicionar uma referência da função do construtor da propriedade à propriedade escondida {[[4]} no protótipo da classe. Por exemplo:

class Language {
    @JsonMember // String
    name: string;

    @JsonMember// Number
    level: number;
}

class Person {
    @JsonMember // String
    name: string;

    @JsonMember// Language
    language: Language;
}

Tipo De Processamento Informação

function deserialize<T>(jsonObject: any, Constructor: { new (): T }): T {
    if (!Constructor || !Constructor.prototype.__propertyTypes__ || !jsonObject || typeof jsonObject !== "object") {
        // No root-type with usable type-information is available.
        return jsonObject;
    }

    // Create an instance of root-type.
    var instance: any = new Constructor();

    // For each property marked with @JsonMember, do...
    Object.keys(Constructor.prototype.__propertyTypes__).forEach(propertyKey => {
        var PropertyType = Constructor.prototype.__propertyTypes__[propertyKey];

        // Deserialize recursively, treat property type as root-type.
        instance[propertyKey] = deserialize(jsonObject[propertyKey], PropertyType);
    });

    return instance;
}

var json = '{ "name": "John Doe", "language": { "name": "en", "level": 5 } }';
var person: Person = deserialize(JSON.parse(json), Person);

A ideia acima tem uma grande vantagem de deseralizar por os tipos esperados (para valores complexos / objectos), em vez do que está presente na JSON. Se um Person é esperado, então é uma instância Person que é criada. Com algumas medidas de segurança adicionais em vigor para tipos primitivos e arrays, esta abordagem pode ser feita segura, que resiste a qualquer JSON malicioso.

Casos Extremos

• matrizes e elementos de matriz (especialmente em matrizes aninhadas)
• polimorfismo
• classes e interfaces Abstractas
• ...

Se você não quer mexer com todos estes (eu aposto que você não), eu iria ser feliz para recomendar um trabalho experimental versão de uma prova de conceito utilizando esta abordagem, TypedJSON -- que eu criado para resolver este problema exato, um problema que eu enfrento-me diariamente.

Devido à forma como decoradores ainda estão sendo considerados experimentais, eu não recomendaria usá-lo para o uso da produção, mas até agora me serviu bem.

Você pode usar Object.assign Eu não sei quando isso foi adicionado, eu estou usando atualmente Typescript 2.0.2, e este parece ser um recurso ES6.

client.fetch( '' ).then( response => {
        return response.json();
    } ).then( json => {
        let hal : HalJson = Object.assign( new HalJson(), json );
        log.debug( "json", hal );

export class HalJson {
    _links: HalLinks;
}

export class HalLinks implements Links {
}

export interface Links {
    readonly [text: string]: Link;
}

export interface Link {
    readonly href: URL;
}

HalJson {_links: Object}
_links
:
Object
public
:
Object
href
:
"http://localhost:9000/v0/public

Então você pode ver que ele não faz a atribuição recursivamente {[[7]}

• serialização e deserialização de toda uma árvore de objectos.
• Propriedades persistentes e transitórias no mesmo objecto.
• Ganchos para personalizar a lógica de serialização (de).
• Ele pode (de)ser serializado em uma instância existente (grande para Angular) ou gerar novo instancia.
• etc.

Exemplo:

class Tree {
  @deserialize public species : string; 
  @deserializeAs(Leaf) public leafs : Array<Leaf>;  //arrays do not need extra specifications, just a type.
  @deserializeAs(Bark, 'barkType') public bark : Bark;  //using custom type and custom key name
  @deserializeIndexable(Leaf) public leafMap : {[idx : string] : Leaf}; //use an object as a map
}

class Leaf {
  @deserialize public color : string;
  @deserialize public blooming : boolean;
  @deserializeAs(Date) public bloomedAt : Date;
}

class Bark {
  @deserialize roughness : number;
}

var json = {
  species: 'Oak',
  barkType: { roughness: 1 },
  leafs: [ {color: 'red', blooming: false, bloomedAt: 'Mon Dec 07 2015 11:48:20 GMT-0500 (EST)' } ],
  leafMap: { type1: { some leaf data }, type2: { some leaf data } }
}
var tree: Tree = Deserialize(json, Tree);

Opção # 5: utilização de construtores de dactilografia e de artigos jQuery.Extender

Este parece ser o método mais possível: adicionar um construtor que toma como parâmetro a estrutura json, e extender o objecto json. Dessa forma você pode processar uma estrutura json em todo o modelo de Aplicação.

Não há necessidade de criar interfaces, ou listar propriedades no construtor.

export class Company
{
    Employees : Employee[];

    constructor( jsonData: any )
    {
        jQuery.extend( this, jsonData);

        // apply the same principle to linked objects:
        if ( jsonData.Employees )
            this.Employees = jQuery.map( jsonData.Employees , (emp) => {
                return new Employee ( emp );  });
    }

    calculateSalaries() : void { .... }
}

export class Employee
{
    name: string;
    salary: number;
    city: string;

    constructor( jsonData: any )
    {
        jQuery.extend( this, jsonData);

        // case where your object's property does not match the json's:
        this.city = jsonData.town;
    }
}

No seu callback ajax onde recebe uma empresa para calcular os salários:

onReceiveCompany( jsonCompany : any ) 
{
   let newCompany = new Company( jsonCompany );

   // call the methods on your newCompany object ...
   newCompany.calculateSalaries()
}

A 4ª opção descrita acima é uma forma simples e agradável de o fazer, que tem de ser combinada com a 2.ª opção no caso de ter de lidar com uma hierarquia de classes como, por exemplo, uma lista de membros que é qualquer uma das ocorrências de subclasses de uma super classe membro, por exemplo, o Director extende Membro ou o estudante extende Membro. Nesse caso, terá de indicar o tipo de subclasse no formato json

Por exemplo, dado este JSON:

{
  "name": "David",
  "pets": [
    {
      "name": "Smoochie",
      "species": "rhino"
    }
  ]
}

Quicktype produz a seguinte interface de tipo e o mapa do tipo:

export interface Person {
    name: string;
    pets: Pet[];
}

export interface Pet {
    name:    string;
    species: string;
}

const typeMap: any = {
    Person: {
        name: "string",
        pets: array(object("Pet")),
    },
    Pet: {
        name: "string",
        species: "string",
    },
};

Depois verificamos o resultado de JSON.parse com o tipo de mapa:

export function fromJson(json: string): Person {
    return cast(JSON.parse(json), object("Person"));
}

Deixei de fora algum código, mas você pode tentar quicktype {[8] } para os detalhes.

Talvez não seja real, mas uma solução simples:

interface Bar{
x:number;
y?:string; 
}

var baz:Bar = JSON.parse(jsonString);
alert(baz.y);

Trabalhar para dependências difíceis também!!!

var mytsobject = new mytsobject();

var newObj = {a:1,b:2};

$.extend(mytsobject, newObj); //mytsobject will now contain a & b

Outra opção utilizando fábricas

export class A {

    id: number;

    date: Date;

    bId: number;
    readonly b: B;
}

export class B {

    id: number;
}

export class AFactory {

    constructor(
        private readonly createB: BFactory
    ) { }

    create(data: any): A {

        const createB = this.createB.create;

        return Object.assign(new A(),
            data,
            {
                get b(): B {

                    return createB({ id: data.bId });
                },
                date: new Date(data.date)
            });
    }
}

export class BFactory {

    create(data: any): B {

        return Object.assign(new B(), data);
    }
}

Https://github.com/MrAntix/ts-deserialize

Usar assim

import { A, B, AFactory, BFactory } from "./deserialize";

// create a factory, simplified by DI
const aFactory = new AFactory(new BFactory());

// get an anon js object like you'd get from the http call
const data = { bId: 1, date: '2017-1-1' };

// create a real model from the anon js object
const a = aFactory.create(data);

// confirm instances e.g. dates are Dates 
console.log('a.date is instanceof Date', a.date instanceof Date);
console.log('a.b is instanceof B', a.b instanceof B);

1. mantém as aulas simples
2. injecção à disposição das fábricas para flexibilidade

Você pode fazer como abaixo

export interface Instance {
  id?:string;
  name?:string;
  type:string;
}

E

var instance: Instance = <Instance>({
      id: null,
      name: '',
      type: ''
    });

**model.ts**
export class Item {
    private key: JSON;
    constructor(jsonItem: any) {
        this.key = jsonItem;
    }
}

**service.ts**
import { Item } from '../model/items';

export class ItemService {
    items: Item;
    constructor() {
        this.items = new Item({
            'logo': 'Logo',
            'home': 'Home',
            'about': 'About',
            'contact': 'Contact',
        });
    }
    getItems(): Item {
        return this.items;
    }
}