Comment faire pour lancer le type d'exécution dans TypeScript?

Actuellement je travaille sur un tapuscrit projet et je suis vraiment profiter de l'inférence de type qui Tapuscrit apporte à la table. Toutefois - lorsque vous obtenez des objets à partir de l'adresse HTTP appels - je peux jeter le type désiré, obtenir la complétion de code et des fonctions d'appel sur leur moment de la compilationmais ceux-ci résultent d'erreurs runtime

Exemple:

class Person{
    name: string;

    public giveName() {
        return this.name;
    }

    constructor(json: any) {
        this.name = json.name;
    }
}

var somejson = { 'name' : 'John' }; //Typically from AJAX call
var john = <Person>(somejson);      //The cast

console.log(john.name);       //'John'
console.log(john.giveName()); //'undefined is not a function'

Bien que cette compile très bien - et intellisense me suggère d'utiliser la fonction, il donne une exception d'exécution. Une solution pourrait être:

var somejson = { 'name' : 'Ann' };
var ann = new Person(somejson);

console.log(ann.name);        //'Ann'
console.log(ann.giveName());  //'Ann'

Mais qui va m'obliger à créer les constructeurs de tous mes types. En particulière, lorsque vous traitez avec des arbres tels que les types et/ou avec des collections en provenance de l'AJAX à l'appel, on aurait pu faire une boucle sur tous les éléments et les nouvelles en place d'une instance pour chaque.

Donc ma question: est-il une façon plus élégante de le faire? C'est, en fonte d'un type et d'avoir le prototype des fonctions disponibles immédiatement?

source d'informationauteur Jochen van Wylick

typescript

6

Prendre un coup d'oeil à l'compilé en JavaScript et vous verrez le type d'assertion (casting) disparaît parce que c'est seulement pour la compilation. Maintenant, vous dire au compilateur que la somejson objet est de type Person. Le compilateur croit que vous, mais dans ce cas ce n'est pas vrai.

Afin que ce problème est un moteur d'exécution JavaScript problème.

L'objectif principal pour obtenir que cela fonctionne est-à-dire en quelque sorte JavaScript quelle est la relation entre les classes. Alors...
1. Trouver un moyen de décrire la relation entre les classes.
2. Créer quelque chose automatiquement la carte au format json pour les classes en fonction de cette relation de données.
Il y a de nombreuses façons de le résoudre, mais je vous en offre un exemple dans le haut de ma tête. Cela devrait aider à décrire ce qui doit être fait.

Dire que nous avons de cette classe:
```
class Person {
    name: string;
    child: Person;

    public giveName() {
        return this.name;
    }
}
```
Et c'données json:
```
{ 
    name: 'John', 
    child: {
        name: 'Sarah',
        child: {
            name: 'Jacob'
        }
    }
}
```
À la carte automatiquement pour être des instances de Personnous avons besoin de dire le JavaScript de la manière dont les types sont liés. Nous ne pouvons pas utiliser le fichier d'enregistrement des informations de type, car nous lâche qu'une fois qu'il est compilé. Une façon de le faire, c'est d'avoir une propriété statique sur le type qui décrit cette. Par exemple:
```
class Person {
    static relationships = {
        child: Person
    };

    name: string;
    child: Person;

    public giveName() {
        return this.name;
    }
}
```
Alors voici un exemple de réutilisables fonction qui gère la création d'objets pour nous à partir de cette relation de données:
```
function createInstanceFromJson<T>(objType: { new(): T; }, json: any) {
    const newObj = new objType();
    const relationships = objType["relationships"] || {};

    for (const prop in json) {
        if (json.hasOwnProperty(prop)) {
            if (newObj[prop] == null) {
                if (relationships[prop] == null) {
                    newObj[prop] = json[prop];
                }
                else {
                    newObj[prop] = createInstanceFromJson(relationships[prop], json[prop]);
                }
            }
            else {
                console.warn(`Property ${prop} not set because it already existed on the object.`);
            }
        }
    }

    return newObj;
}
```
Maintenant le code suivant fonctionne:
```
const someJson = { 
        name: 'John', 
        child: {
            name: 'Sarah',
            child: {
                name: 'Jacob'
            }
        }
    };
const person = createInstanceFromJson(Person, someJson);

console.log(person.giveName());             //John
console.log(person.child.giveName());       //Sarah
console.log(person.child.child.giveName()); //Jacob
```
Aire de jeux

Idéalementle meilleur moyen serait d'utiliser quelque chose qui lit le fichier d'enregistrement de code et crée un objet qui contient le lien entre les classes. De cette façon, nous n'avons pas besoin de maintenir manuellement les relations et de se soucier des changements de code. Par exemple, la refactorisation de code est un peu le risque avec ce type de configuration. Je ne suis pas sûr que quelque chose comme ce qui existe à l'heure actuelle, mais il est certainement possible.

Solution Alternative

Je viens de réaliser que j'ai déjà répondu à une question similaire, avec un peu différente de la solution (qui n'implique pas de données imbriquées). Vous pouvez le lire ici pour plus d'idées:

JSON à Tapuscrit instance de la classe?

Le prototype de la classe peuvent être dynamiquement affectée à l'objet:

function cast<T>(obj: any, cl: { new(...args): T }): T {
  obj.__proto__ = cl.prototype;
  return obj;
}

var john = cast(/* somejson */, Person);

Voir la documentation de __proto__ ici.

Vous devez vous connecter pour publier un commentaire.