Appliquer le type des membres indexés d'un objet Typescript?

Je voudrais stocker un mappage de chaîne -> chaîne dans un objet Typescript, et imposer que toutes les clés mappent sur des chaînes. Par exemple:

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

Existe-t-il un moyen pour moi d'imposer que les valeurs doivent être des chaînes (ou tout autre type ..)?

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

Ici, l'interface AgeMapapplique les clés sous forme de chaînes et les valeurs sous forme de nombres. Le mot-clé namepeut être n'importe quel identifiant et doit être utilisé pour suggérer la syntaxe de votre interface / type.

Vous pouvez utiliser une syntaxe similaire pour imposer qu'un objet possède une clé pour chaque entrée d'un type d'union:

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

Vous pouvez bien sûr en faire également un type générique!

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

Mise à jour du 10.10.2018: Découvrez la réponse de @ dracstaxi ci-dessous - il y a maintenant un type intégré Recordqui fait la plupart de cela pour vous.

Mise à jour 1.2.2020: j'ai entièrement supprimé les interfaces de mappage prédéfinies de ma réponse. La réponse de @ dracstaxi les rend totalement hors de propos. Si vous souhaitez toujours les utiliser, consultez l'historique des modifications.

Une mise à jour rapide: depuis Typescript 2.1, il existe un type intégré Record<T, K>qui agit comme un dictionnaire.

Un exemple de documents:

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

Documentation TypeScript 2.1 sur Record<T, K>

Le seul inconvénient que je vois à utiliser ceci {[key: T]: K}est que vous pouvez encoder des informations utiles sur le type de clé que vous utilisez à la place de "clé" {[prime: number]: yourType}.

Voici une expression régulière que j'ai écrite pour aider à ces conversions. Cela ne convertira que les cas où l'étiquette est "clé". Pour convertir d'autres étiquettes, changez simplement le premier groupe de capture:

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

Remplacer: Record<$2, $3>

La réponse de @Ryan Cavanaugh est totalement correcte et toujours valable. Il vaut toujours la peine d'ajouter qu'à partir de l'automne 2016, lorsque nous pouvons affirmer que ES6 est pris en charge par la majorité des plates-formes, il est presque toujours préférable de s'en tenir à Map chaque fois que vous avez besoin d'associer certaines données à une clé.

Quand on écrit let a: { [s: string]: string; } nous devons nous rappeler qu'après la compilation du typage, il n'y a pas de données de type, elles ne sont utilisées que pour la compilation. Et {[s: chaîne]: chaîne; } sera compilé en {} seulement.

Cela dit, même si vous écrivez quelque chose comme:

class TrickyKey  {}

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

Cela ne compilera tout simplement pas (même pour target es6 , vous obtiendrezerror TS1023: An index signature parameter type must be 'string' or 'number'.

Donc, pratiquement, vous êtes limité avec une chaîne ou un nombre comme clé potentielle, il n'y a donc pas beaucoup de sens à appliquer la vérification de type ici, surtout en gardant à l'esprit que lorsque js essaie d'accéder à la clé par numéro, il la convertit en chaîne.

Il est donc tout à fait sûr de supposer que la meilleure pratique consiste à utiliser Map même si les clés sont des chaînes, alors je m'en tiendrai à:

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

Définir l'interface

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

Appliquer la clé comme clé spécifique de l'interface des paramètres

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

En s'appuyant sur la réponse de @ shabunc, cela permettrait d'appliquer la clé ou la valeur - ou les deux - à tout ce que vous souhaitez appliquer.

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

Devrait également fonctionner en utilisant enumau lieu d'une typedéfinition.