Applicare il tipo di membri indicizzati di un oggetto Typescript?

Vorrei archiviare una mappatura di stringa -> stringa in un oggetto Typescript e imporre che tutte le chiavi siano mappate su stringhe. Per esempio:

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

Esiste un modo per imporre che i valori debbano essere stringhe (o qualunque tipo ...)?

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'.
};

Qui, l'interfaccia AgeMapimpone chiavi come stringhe e valori come numeri. La parola chiave namepuò essere qualsiasi identificatore e deve essere utilizzata per suggerire la sintassi della tua interfaccia / tipo.

È possibile utilizzare una sintassi simile per imporre che un oggetto abbia una chiave per ogni voce in un tipo di unione:

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",
};

Naturalmente puoi anche rendere questo un tipo generico!

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,
};

Aggiornamento del 10.10.2018: dai un'occhiata alla risposta di @ dracstaxi qui sotto: ora c'è un tipo integrato Recordche fa la maggior parte di questo per te.

Aggiornamento 1.2.2020: ho completamente rimosso le interfacce di mappatura pre-create dalla mia risposta. La risposta di @ dracstaxi li rende totalmente irrilevanti. Se desideri comunque usarli, controlla la cronologia delle modifiche.

Un rapido aggiornamento: da Typescript 2.1 esiste un tipo incorporato Record<T, K>che si comporta come un dizionario.

Un esempio dai documenti:

// 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 }

Documentazione di TypeScript 2.1 su Record<T, K>

L'unico svantaggio che vedo di utilizzare questo corso {[key: T]: K}è che è possibile codificare informazioni utili su che tipo di chiave che si sta utilizzando al posto di "chiave" per esempio se l'oggetto aveva solo le chiavi principali si potrebbe accennare a quel modo: {[prime: number]: yourType}.

Ecco una regex che ho scritto per aiutare con queste conversioni. Questo convertirà solo i casi in cui l'etichetta è "chiave". Per convertire altre etichette basta cambiare il primo gruppo di acquisizione:

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

Sostituire: Record<$2, $3>

La risposta di @Ryan Cavanaugh è totalmente ok e comunque valida. Vale comunque la pena aggiungere che a partire dall'autunno 16, quando possiamo affermare che ES6 è supportato dalla maggior parte delle piattaforme, è quasi sempre meglio attenersi a Map ogni volta che è necessario associare alcuni dati a una chiave.

Quando scriviamo, let a: { [s: string]: string; }dobbiamo ricordare che dopo la compilazione di dattiloscritto non esistono dati di tipo, ma vengono utilizzati solo per la compilazione. E {[s: string]: string; } verrà compilato in solo {}.

Detto questo, anche se scriverai qualcosa del tipo:

class TrickyKey  {}

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

Questo non si compila (anche per target es6, otterraierror TS1023: An index signature parameter type must be 'string' or 'number'.

Quindi praticamente sei limitato con stringa o numero come chiave potenziale, quindi non c'è molto senso di forzare il controllo del tipo qui, soprattutto tenendo presente che quando js tenta di accedere a chiave per numero, la converte in stringa.

Quindi è abbastanza sicuro supporre che la migliore pratica sia usare Map anche se le chiavi sono stringhe, quindi dovrei attenermi a:

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

Definire l'interfaccia

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

Imponi chiave come chiave specifica dell'interfaccia Impostazioni

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

Basandosi sulla risposta di @ shabunc, ciò consentirebbe di applicare la chiave o il valore - o entrambi - per essere tutto ciò che si desidera applicare.

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>();

Dovrebbe funzionare anche usando enuminvece di una typedefinizione.