Déclarer et initialiser un Dictionnaire en caractères d'imprimerie

Je suis d'accord avec thomaux que l'initialisation de la vérification du type d'erreur est un Tapuscrit de bug. Cependant, je voulais trouver une façon de déclarer et initialiser un Dictionnaire dans un rapport simple avec le bon type de vérification. Cette mise en œuvre est plus longue, toutefois, il ajoute des fonctionnalités supplémentaires comme un containsKey(key: string) et remove(key: string) méthode. Je soupçonne que cela pourrait être simplifiée, une fois les médicaments génériques sont disponibles dans la version 0.9.

Nous avons d'abord déclarer la base du Dictionnaire de classe et d'Interface. L'interface est nécessaire pour l'indexeur car les classes ne peuvent pas les mettre en œuvre.

interface IDictionary {
add(key: string, value: any): void;
remove(key: string): void;
containsKey(key: string): bool;
keys(): string[];
values(): any[];
}
class Dictionary {
_keys: string[] = new string[];
_values: any[] = new any[];
constructor(init: { key: string; value: any; }[]) {
for (var x = 0; x < init.length; x++) {
this[init[x].key] = init[x].value;
this._keys.push(init[x].key);
this._values.push(init[x].value);
}
}
add(key: string, value: any) {
this[key] = value;
this._keys.push(key);
this._values.push(value);
}
remove(key: string) {
var index = this._keys.indexOf(key, 0);
this._keys.splice(index, 1);
this._values.splice(index, 1);
delete this[key];
}
keys(): string[] {
return this._keys;
}
values(): any[] {
return this._values;
}
containsKey(key: string) {
if (typeof this[key] === "undefined") {
return false;
}
return true;
}
toLookup(): IDictionary {
return this;
}
}

Maintenant nous déclarer la Personne de type spécifique et Dictionnaire/Dictionnaire d'interface. Dans le PersonDictionary notez comment nous remplacer values() et toLookup() pour retourner les types appropriés.

interface IPerson {
firstName: string;
lastName: string;
}
interface IPersonDictionary extends IDictionary {
[index: string]: IPerson;
values(): IPerson[];
}
class PersonDictionary extends Dictionary {
constructor(init: { key: string; value: IPerson; }[]) {
super(init);
}
values(): IPerson[]{
return this._values;
}
toLookup(): IPersonDictionary {
return this;
}
}

Et ici est une simple initialisation et exemple d'utilisation:

var persons = new PersonDictionary([
{ key: "p1", value: { firstName: "F1", lastName: "L2" } },
{ key: "p2", value: { firstName: "F2", lastName: "L2" } },
{ key: "p3", value: { firstName: "F3", lastName: "L3" } }
]).toLookup();
alert(persons["p1"].firstName + " " + persons["p1"].lastName);
//alert: F1 L2
persons.remove("p2");
if (!persons.containsKey("p2")) {
alert("Key no longer exists");
//alert: Key no longer exists
}
alert(persons.keys().join(", "));
//alert: p1, p3

Si vous souhaitez ignorer une propriété, le marquer comme option en ajoutant un point d'interrogation:

interface IPerson {
firstName: string;
lastName?: string;
}

Maintenant, il y a une bibliothèque qui fournit fortement typées, queryable collections en caractères d'imprimerie.

Les collections sont:

• Liste
• Dictionnaire

La bibliothèque est appelée ts-générique-collections.

Le code Source sur GitHub:

https://github.com/VeritasSoftware/ts-generic-collections

Avec cette bibliothèque, vous pouvez créer des collections (comme List<T>) et de les interroger comme indiqué ci-dessous.

    let owners = new List<Owner>();
let owner = new Owner();
owner.id = 1;
owner.name = "John Doe";
owners.add(owner);
owner = new Owner();
owner.id = 2;
owner.name = "Jane Doe";
owners.add(owner);    
let pets = new List<Pet>();
let pet = new Pet();
pet.ownerId = 2;
pet.name = "Sam";
pet.sex = Sex.M;
pets.add(pet);
pet = new Pet();
pet.ownerId = 1;
pet.name = "Jenny";
pet.sex = Sex.F;
pets.add(pet);
//query to get owners by the sex/gender of their pets
let ownersByPetSex = owners.join(pets, owner => owner.id, pet => pet.ownerId, (x, y) => new OwnerPet(x,y))
.groupBy(x => [x.pet.sex])
.select(x =>  new OwnersByPetSex(x.groups[0], x.list.select(x => x.owner)));
expect(ownersByPetSex.toArray().length === 2).toBeTruthy();
expect(ownersByPetSex.toArray()[0].sex == Sex.F).toBeTruthy();
expect(ownersByPetSex.toArray()[0].owners.length === 1).toBeTruthy();
expect(ownersByPetSex.toArray()[0].owners.toArray()[0].name == "John Doe").toBeTruthy();
expect(ownersByPetSex.toArray()[1].sex == Sex.M).toBeTruthy();
expect(ownersByPetSex.toArray()[1].owners.length == 1).toBeTruthy();
expect(ownersByPetSex.toArray()[1].owners.toArray()[0].name == "Jane Doe").toBeTruthy();