Den Typ der indizierten Elemente eines Typescript-Objekts erzwingen?

Ich möchte eine Zuordnung von Zeichenfolge -> Zeichenfolge in einem Typescript-Objekt speichern und erzwingen, dass alle Schlüssel Zeichenfolgen zugeordnet werden. Beispielsweise:

var stuff = {};
stuff["a"] = "foo";   // okay
stuff["b"] = "bar";   // okay
stuff["c"] = false;   // ERROR!  bool != string

Gibt es eine Möglichkeit für mich, zu erzwingen, dass die Werte Zeichenfolgen sein müssen (oder welcher Typ auch immer ..)?

var stuff: { [key: string]: string; } = {};
stuff['a'] = ''; // ok
stuff['a'] = 4;  // error

// ... or, if you're using this a lot and don't want to type so much ...
interface StringMap { [key: string]: string; }
var stuff2: StringMap = { };
// same as above

interface AgeMap {
    [name: string]: number
}

const friendsAges: AgeMap = {
    "Sandy": 34,
    "Joe": 28,
    "Sarah": 30,
    "Michelle": "fifty", // ERROR! Type 'string' is not assignable to type 'number'.
};

Hier AgeMaperzwingt die Schnittstelle Schlüssel als Zeichenfolgen und Werte als Zahlen. Das Schlüsselwort namekann eine beliebige Kennung sein und sollte verwendet werden, um die Syntax Ihrer Schnittstelle / Ihres Typs vorzuschlagen.

Sie können eine ähnliche Syntax verwenden, um zu erzwingen, dass ein Objekt für jeden Eintrag in einem Unionstyp einen Schlüssel hat:

type DayOfTheWeek = "sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday";

type ChoresMap = { [day in DayOfTheWeek]: string };

const chores: ChoresMap = { // ERROR! Property 'saturday' is missing in type '...'
    "sunday": "do the dishes",
    "monday": "walk the dog",
    "tuesday": "water the plants",
    "wednesday": "take out the trash",
    "thursday": "clean your room",
    "friday": "mow the lawn",
};

Sie können dies natürlich auch zu einem generischen Typ machen!

type DayOfTheWeek = "sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday";

type DayOfTheWeekMap<T> = { [day in DayOfTheWeek]: T };

const chores: DayOfTheWeekMap<string> = {
    "sunday": "do the dishes",
    "monday": "walk the dog",
    "tuesday": "water the plants",
    "wednesday": "take out the trash",
    "thursday": "clean your room",
    "friday": "mow the lawn",
    "saturday": "relax",
};

const workDays: DayOfTheWeekMap<boolean> = {
    "sunday": false,
    "monday": true,
    "tuesday": true,
    "wednesday": true,
    "thursday": true,
    "friday": true,
    "saturday": false,
};

10.10.2018 Update: Schauen Sie sich die Antwort von @ dracstaxi unten an - es gibt jetzt einen integrierten Typ, Recordder das meiste für Sie erledigt.

1.2.2020 Update: Ich habe die vorgefertigten Mapping-Schnittstellen vollständig aus meiner Antwort entfernt. @ dracstaxis Antwort macht sie völlig irrelevant. Wenn Sie sie weiterhin verwenden möchten, überprüfen Sie den Bearbeitungsverlauf.

Ein schnelles Update: Seit Typescript 2.1 gibt es einen eingebauten Typ Record<T, K>, der sich wie ein Wörterbuch verhält.

Ein Beispiel aus Dokumenten:

// For every properties K of type T, transform it to U
function mapObject<K extends string, T, U>(obj: Record<K, T>, f: (x: T) => U): Record<K, U>

const names = { foo: "hello", bar: "world", baz: "bye" };
const lengths = mapObject(names, s => s.length);  // { foo: number, bar: number, baz: number }

TypeScript 2.1 Dokumentation ein Record<T, K>

Der einzige Nachteil, den ich bei der Verwendung sehe, {[key: T]: K}ist, dass Sie nützliche Informationen darüber codieren können, welche Art von Schlüssel Sie anstelle von "Schlüssel" verwenden, z. B. wenn Ihr Objekt nur Primschlüssel hatte, können Sie dies wie folgt andeuten : {[prime: number]: yourType}.

Hier ist ein regulärer Ausdruck, den ich geschrieben habe, um bei diesen Konvertierungen zu helfen. Dies konvertiert nur Fälle, in denen die Bezeichnung "Schlüssel" ist. Um andere Beschriftungen zu konvertieren, ändern Sie einfach die erste Erfassungsgruppe:

Finden: \{\s*\[(key)\s*(+\s*:\s*(\w+)\s*\]\s*:\s*([^\}]+?)\s*;?\s*\}

Ersetzen: Record<$2, $3>

@ Ryan Cavanaughs Antwort ist völlig in Ordnung und immer noch gültig. Es lohnt sich dennoch hinzuzufügen, dass es ab Herbst 16, wenn wir behaupten können, dass ES6 von den meisten Plattformen unterstützt wird, fast immer besser ist, sich an Map zu halten, wenn Sie Daten mit einem Schlüssel verknüpfen müssen.

Wenn wir schreiben let a: { [s: string]: string; }, müssen wir uns daran erinnern, dass es nach dem Kompilieren von Typoskripten keine Typdaten gibt, sondern nur zum Kompilieren. Und {[s: string]: string; } wird nur zu {} kompiliert.

Das heißt, auch wenn Sie etwas schreiben wie:

class TrickyKey  {}

let dict: {[key:TrickyKey]: string} = {}

Dies wird einfach nicht kompiliert (auch für target es6, Sie werden bekommenerror TS1023: An index signature parameter type must be 'string' or 'number'.

Praktisch sind Sie also auf eine Zeichenfolge oder eine Nummer als potenziellen Schlüssel beschränkt, sodass es nicht so sinnvoll ist, die Typprüfung zu erzwingen, insbesondere wenn js versucht, auf den Schlüssel anhand der Nummer zuzugreifen, wird diese in eine Zeichenfolge konvertiert.

Es ist also ziemlich sicher anzunehmen, dass die beste Vorgehensweise darin besteht, Map zu verwenden, auch wenn die Schlüssel Zeichenfolgen sind. Ich würde mich also an Folgendes halten:

let staff: Map<string, string> = new Map();

Schnittstelle definieren

interface Settings {
  lang: 'en' | 'da';
  welcome: boolean;
}

Erzwingen Sie, dass der Schlüssel ein bestimmter Schlüssel der Einstellungsoberfläche ist

private setSettings(key: keyof Settings, value: any) {
   // Update settings key
}

Aufbauend auf der Antwort von @ shabunc würde dies ermöglichen, dass entweder der Schlüssel oder der Wert - oder beides - alles ist, was Sie erzwingen möchten.

type IdentifierKeys = 'my.valid.key.1' | 'my.valid.key.2';
type IdentifierValues = 'my.valid.value.1' | 'my.valid.value.2';

let stuff = new Map<IdentifierKeys, IdentifierValues>();

Sollte auch mit enumanstelle einer typeDefinition funktionieren .