Pouvez-vous étendre dynamiquement un type en tapuscrit?

En javascript, vous pouvez le faire:

function Test() {
  this.id = 1;
};

Test.prototype.customize = function(key, callback) {
  this[key] = callback;
};

var callback = function() { alert(this.id); };
var x = new Test();
x.customize('testing', callback);
x.testing();

Pouvez-vous faire quelque chose de similaire à la machine?

En particulier, je suis intéressé à avoir une classe comme:

class Socket {
  ...
}

class Sockets {

  public addChannel(name:string):void {
    this[name] = new Socket(); 
  }

  ...
}

data = new Sockets();
data.addChannel('video');
data.addChannel('audio');

...

var audio = data.audio.read();
var video = data.video.read();
etc.

Le compilateur se plaint qu'il n'y a pas de "audio" ou "vidéo" sur "Sockets", et ne compile pas. Est-il un moyen de contourner cela sans avoir à définir manuellement les propriétés de la classe container?

Je sais que ce genre de marches de côté les règles de typage statique, mais je le trouve de temps en temps utiles pour les API de la gentillesse pour avoir quelque chose comme cela.

edit: Voir l'exemple de réponse que j'ai posté ci-dessous; quelque chose fonctionne comme ça. Je vais tout de même accepter toute réponse intelligente qui me permet en quelque sorte de gérer de compiler quelque chose qui fait quelque chose d'utile sur la base de l'objet lui-même.

source d'informationauteur Doug

typescript

11

Mise à jour: Il semble que vous êtes après véritablement comportement dynamique lors de l'exécution... c'est à dire que vous ne connaissez pas, il sera videoaudio ou certains autres valeurs. Dans ce cas, où vous avez une dynamique de nom de la chaîne à partir d'une source quelconque, vous devez utiliser [] de la syntaxe, mais il y a encore quelques
```
var channel = 'video;'

var data = new Sockets();
data.addChannel(channel);

//Totally dynamic /unchecked
var media = data[channel].read();

//Or

interface IChannel {
    read(): { /* You could type this */ };
}

//Dynamic call, but read method and media variable typed and checked
var media = (<IChannel>data[channel]).read();
```
Réponse précédente... utile pour toute personne lisant cette question qui n'est pas après complet sur le comportement dynamique (mais assez inutile pour Doug, désolé!)

Si vous souhaitez étendre une classe existante, vous pouvez utiliser l'héritage:
```
class ClassOne {
    addOne(input: number) {
        return input + 1;
    }
}

//...

class ClassTwo extends ClassOne {
    addTwo(input: number) {
        return input + 2;
    }
}

var classTwo = new ClassTwo();
var result = classTwo.addTwo(3); //5
```
Si vous voulez faire ce vraiment dynamiquement, par exemple, vous voulez juste ajouter quelque chose à une instance, vous pouvez le faire aussi - mais l'héritage de vous donner beaucoup plus pour votre argent.
```
class ClassOne {
    addOne(input: number) {
        return input + 1;
    }
}

//...

var classOne = new ClassOne();

classOne['addTwo'] = function (input: number) {
    return input + 2;
};

var result = (<any>classOne).addTwo(3); //5

//or (nasty 'repeat the magic string version')

result = classOne['addTwo'](3);
```
Si vous êtes ensemble mort sur la dynamique de l'itinéraire, un modèle commun dans le Tapuscrit est de représenter la structure d'une interface, pas une classe. (Interfaces et modules, et les énumérations) sont ouverts, de sorte qu'ils peuvent être prolongés sur plusieurs blocs. Vous devez assurer votre interface et de mise en œuvre ont été également étendus. C'est la technique que vous utilisez pour étendre les objets intégrés.
```
//NodeList is already declared in lib.d.ts - we are extending it
interface NodeList {
    sayNodeList(): void;
}

NodeList.prototype.sayNodeList = function () {
    alert('I say node, you say list... NODE');
}
```
Cela vous donne le plein d'auto-complétion et la vérification de type.
3

Vous n'êtes pas à l'extension de la type dans votre exemple... vous êtes juste ajouter dynamiquement une propriété de l'objet. À la Machine, vous ne pouvez pas ajouter dynamiquement une propriété à un objet contenant les propriétés de différents types, à moins que vous lancez à any (qui, à mon avis, devrait être évité).

Je vous suggère d'ajouter une propriété à Sockets qui est contraint d'avoir des propriétés qui sont de type Socket comme suit:
```
class Sockets {
    channels: { [index: string]: Socket; } = {};
    public addChannel(name:string):void {
        this.channels[name] = new Socket(); 
    }
}

var data = new Sockets();
data.addChannel('audio');

//audio will be the return type of read... so you don't lose type
var audio = data.channels['audio'].read();
```
En faisant cela, vous n'avez pas à vous rappeler de le convertir l'objet de Socket et vous obtenez toutes les joies de sécurité de type.
1

Ce n'est pas encore possible mais il y a une discussion active se passe entre le Tapuscrit de la communauté.

https://github.com/Microsoft/TypeScript/issues/9

//Basic type
type a = {
  prop1: string
}

//Extended type
type b = a & {
  prop2: number
}

//Demo instance
let myExtendedObject: b = {
  prop1: 'text',
  prop2: 99
}

0
```
class Blah {
  public channels:any = {};

  public addChan(name:string):void {
    this.channels[name] = new Channel();
  }
}

var b = new Blah();
b.channel('hello');
b.channels.hello.read(1024, () => { ... });
```
Par défaut, il semble tout attribut d'un "tout" le temps est aussi "tout", et vous n'avez pas à obtenir tout type de sécurité sans un plâtre, mais si vous êtes à la rédaction d'un manuscrit de la bibliothèque de consommer en javascript, il n'est pas vraiment un gros problème.

Vous devez vous connecter pour publier un commentaire.