Aplicando o tipo dos membros indexados de um objeto Typecript?

Gostaria de armazenar um mapeamento de string -> string em um objeto TypeScript e impor que todas as chaves sejam mapeadas para strings. Por exemplo:

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

Existe uma maneira de impor que os valores devem ser cadeias (ou qualquer outro 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'.
};

Aqui, a interface AgeMapimpõe chaves como seqüências de caracteres e valores como números. A palavra-chave namepode ser qualquer identificador e deve ser usada para sugerir a sintaxe da sua interface / tipo.

Você pode usar uma sintaxe semelhante para impor que um objeto tenha uma chave para cada entrada em um tipo de união:

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

Obviamente, você também pode fazer deste um tipo genérico!

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

Atualização 10.10.2018: Confira a resposta de @ dracstaxi abaixo - agora há um tipo interno Recordque faz a maior parte disso para você.

Atualização 1.2.2020: removi completamente as interfaces de mapeamento pré-fabricadas da minha resposta. A resposta de @ dracstaxi os torna totalmente irrelevantes. Se você ainda deseja usá-los, verifique o histórico de edições.

Uma atualização rápida: desde o Typescript 2.1, existe um tipo incorporado Record<T, K>que age como um dicionário.

Um exemplo dos documentos:

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

Documentação do TypeScript 2.1 em Record<T, K>

A única desvantagem que vejo ao usar isso {[key: T]: K}é que você pode codificar informações úteis sobre o tipo de chave que está usando no lugar de "chave" {[prime: number]: yourType}.

Aqui está um regex que escrevi para ajudar nessas conversões. Isso converterá apenas casos em que o rótulo é "chave". Para converter outros rótulos, basta alterar o primeiro grupo de captura:

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

Substituir: Record<$2, $3>

A resposta de @Ryan Cavanaugh é totalmente correta e continua válida. Ainda assim, vale a pena acrescentar que, no outono de 16, quando podemos afirmar que o ES6 é suportado pela maioria das plataformas, quase sempre é melhor seguir o Map sempre que você precisar associar alguns dados a alguma chave.

Quando escrevemos let a: { [s: string]: string; }, precisamos lembrar que, depois da compilação do texto datilografado, não existem dados do tipo, eles são usados ​​apenas para compilar. E {[s: string]: string; } será compilado para apenas {}.

Dito isto, mesmo se você escrever algo como:

class TrickyKey  {}

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

Isso simplesmente não será compilado (mesmo que target es6você obtenhaerror TS1023: An index signature parameter type must be 'string' or 'number'.

Portanto, praticamente você está limitado a uma string ou um número como chave potencial, portanto não há muito senso de impor a verificação de tipo aqui, especialmente tendo em mente que quando js tenta acessar a chave pelo número, ele a converte em string.

Portanto, é bastante seguro supor que a melhor prática é usar o Map, mesmo que as chaves sejam string, então eu continuaria com:

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

Definir interface

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

Aplicar chave para ser uma chave específica da interface Configurações

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

Com base na resposta de @ shabunc, isso permitiria impor a chave ou o valor - ou ambos - para qualquer coisa que você queira impor.

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

Também deve funcionar usando em enumvez de uma typedefinição.