索引签名

可以用字符串访问 JavaScript 中的对象（TypeScript 中也一样），用来保存对其他对象的引用。

例如：

  1. let foo: any = {};
  2. foo['Hello'] = 'World';
  3. console.log(foo['Hello']); // World

我们在键 Hello 下保存了一个字符串 World，除字符串外，它也可以保存任意的 JavaScript 对象，例如一个类的实例。

  1. class Foo {
  2.   constructor(public message: string) {}
  3.   log() {
  4.     console.log(this.message);
  5.   }
  6. }
  8. let foo: any = {};
  9. foo['Hello'] = new Foo('World');
  10. foo['Hello'].log(); // World

当你传入一个其他对象至索引签名时，JavaScript 会在得到结果之前会先调用 .toString 方法：

  1. let obj = {
  2.   toString() {
  3.     console.log('toString called');
  4.     return 'Hello';
  5.   }
  6. };
  8. let foo: any = {};
  9. foo[obj] = 'World'; // toString called
  10. console.log(foo[obj]); // toString called, World
  11. console.log(foo['Hello']); // World

TIP

只要索引位置使用了 obj，toString 方法都将会被调用。

数组有点稍微不同，对于一个 number 类型的索引签名，JavaScript 引擎将会尝试去优化（这取决于它是否是一个真的数组、存储的项目结构是否匹配等）。因此，number 应该被考虑作为一个有效的对象访问器（这与 string 不同），如下例子：

  1. let foo = ['World'];
  2. console.log(foo[0]); // World

因此，这就是 JavaScript。现在让我们看看 TypeScript 对这些概念更优雅的处理。

TypeScript 索引签名

JavaScript 在一个对象类型的索引签名上会隐式调用 toString 方法，而在 TypeScript 中，为防止初学者砸伤自己的脚（我总是看到 stackoverflow 上有很多 JavaScript 使用者都会这样。），它将会抛出一个错误。

  1. const obj = {
  2.   toString() {
  3.     return 'Hello';
  4.   }
  5. };
  7. const foo: any = {};
  9. // ERROR: 索引签名必须为 string, number....
  10. foo[obj] = 'World';
  12. // FIX: TypeScript 强制你必须明确这么做：
  13. foo[obj.toString()] = 'World';

强制用户必须明确的写出 toString() 的原因是：在对象上默认执行的 toString 方法是有害的。例如 v8 引擎上总是会返回 [object Object]

  1. const obj = { message: 'Hello' };
  2. let foo: any = {};
  4. // ERROR: 索引签名必须为 string, number....
  5. foo[obj] = 'World';
  7. // 这里实际上就是你存储的地方
  8. console.log(foo['[object Object]']); // World

当然，数字类型是被允许的，这是因为：

  • 需要数组／元组的支持；
  • 即使你在数组里使用一个 obj，这个默认被调用的 toString 方法，被实现的很好（不是 [object Object]）。
    如下所示：
  1. console.log((1).toString()); // 1
  2. console.log((2).toString()); // 2

因此，我们有以下结论：

TIP

TypeScript 的索引签名必须是 string 或者 number。

symbols 也是有效的，TypeScript 支持它。在接下来我们将会讲解它。

声明一个索引签名

在上文中，我们通过使用 any 来让 TypeScript 允许我们可以做任意我们想做的事情。实际上，我们可以明确的指定索引签名。例如：假设你想确认存储在对象中任何内容都符合 { message: string } 的结构，你可以通过 [index: string]: { message: string } 来实现。

  1. const foo: {
  2.   [index: string]: { message: string };
  3. } = {};
  5. // 储存的东西必须符合结构
  6. // ok
  7. foo['a'] = { message: 'some message' };
  9. // Error, 必须包含 `message`
  10. foo['a'] = { messages: 'some message' };
  12. // 读取时，也会有类型检查
  13. // ok
  14. foo['a'].message;
  16. // Error: messages 不存在
  17. foo['a'].messages;

TIP

索引签名的名称（如：{ [index: string]: { message: string } } 里的 index ）除了可读性外，并没有任何意义。例如：如果有一个用户名，你可以使用 { username: string}: { message: string }，这有利于下一个开发者理解你的代码。

number 类型的索引也支持：{ [count: number]: 'SomeOtherTypeYouWantToStoreEgRebate' }。

所有成员都必须符合字符串的索引签名

当你声明一个索引签名时，所有明确的成员都必须符合索引签名：

  1. // ok
  2. interface Foo {
  3.   [key: string]: number;
  4.   x: number;
  5.   y: number;
  6. }
  8. // Error
  9. interface Bar {
  10.   [key: string]: number;
  11.   x: number;
  12.   y: string; // Error: y 属性必须为 number 类型
  13. }

这可以给你提供安全性，任何以字符串的访问都能得到相同结果。

  1. interface Foo {
  2.   [key: string]: number;
  3.   x: number;
  4. }
  6. let foo: Foo = {
  7.   x: 1,
  8.   y: 2
  9. };
  11. // 直接
  12. foo['x']; // number
  14. // 间接
  15. const x = 'x';
  16. foo[x]; // number

使用一组有限的字符串字面量

一个索引签名可以通过映射类型来使索引字符串为联合类型中的一员，如下所示：

  1. type Index = 'a' | 'b' | 'c';
  2. type FromIndex = { [k in Index]?: number };
  4. const good: FromIndex = { b: 1, c: 2 };
  6. // Error:
  7. // `{ b: 1, c: 2, d: 3 }` 不能分配给 'FromIndex'
  8. // 对象字面量只能指定已知类型，'d' 不存在 'FromIndex' 类型上
  9. const bad: FromIndex = { b: 1, c: 2, d: 3 };

这通常与 keyof/typeof 一起使用，来获取变量的类型，在下一章节中，我们将解释它。

变量的规则一般可以延迟被推断：

  1. type FromSomeIndex<K extends string> = { [key in K]: number };

同时拥有 string 和 number 类型的索引签名

这并不是一个常见的用例，但是 TypeScript 支持它。

string 类型的索引签名比 number 类型的索引签名更严格。这是故意设计，它允许你有如下类型：

  1. interface ArrStr {
  2.   [key: string]: string | number; // 必须包括所用成员类型
  3.   [index: number]: string; // 字符串索引类型的子级
  5.   // example
  6.   length: number;
  7. }

设计模式：索引签名的嵌套

TIP

添加索引签名时，需要考虑的 API。

在 JavaScript 社区你将会见到很多滥用索引签名的 API。如 JavaScript 库中使用 CSS 的常见模式：

  1. interface NestedCSS {
  2.   color?: string; // strictNullChecks=false 时索引签名可为 undefined
  3.   [selector: string]: string | NestedCSS;
  4. }
  6. const example: NestedCSS = {
  7.   color: 'red',
  8.   '.subclass': {
  9.     color: 'blue'
  10.   }
  11. };

尽量不要使用这种把字符串索引签名与有效变量混合使用。如果属性名称中有拼写错误，这个错误不会被捕获到：

  1. const failsSilently: NestedCSS = {
  2.   colour: 'red' // 'colour' 不会被捕捉到错误
  3. };

取而代之，我们把索引签名分离到自己的属性里，如命名为 nest（或者 children、subnodes 等）：

  1. interface NestedCSS {
  2.   color?: string;
  3.   nest?: {
  4.     [selector: string]: NestedCSS;
  5.   };
  6. }
  8. const example: NestedCSS = {
  9.   color: 'red',
  10.   nest: {
  11.     '.subclass': {
  12.       color: 'blue'
  13.     }
  14.   }
  15. }
  17. const failsSliently: NestedCSS {
  18.   colour: 'red'  // TS Error: 未知属性 'colour'
  19. }

索引签名中排除某些属性

有时，你需要把属性合并至索引签名（虽然我们并不建议这么做，你应该使用上文中提到的嵌套索引签名的形式），如下例子：

  1. type FieldState = {
  2.   value: string;
  3. };
  5. type FromState = {
  6.   isValid: boolean; // Error: 不符合索引签名
  7.   [filedName: string]: FieldState;
  8. };

TypeScript 会报错，因为添加的索引签名，并不兼容它原有的类型，使用交叉类型可以解决上述问题：

  1. type FieldState = {
  2.   value: string;
  3. };
  5. type FormState = { isValid: boolean } & { [fieldName: string]: FieldState };

请注意尽管你可以声明它至一个已存在的 TypeScript 类型上，但是你不能创建如下的对象：

  1. type FieldState = {
  2.   value: string;
  3. };
  5. type FormState = { isValid: boolean } & { [fieldName: string]: FieldState };
  7. // 将它用于从某些地方获取的 JavaScript 对象
  8. declare const foo: FormState;
  10. const isValidBool = foo.isValid;
  11. const somethingFieldState = foo['something'];
  13. // 使用它来创建一个对象时，将不会工作
  14. const bar: FormState = {
  15.   // 'isValid' 不能赋值给 'FieldState'
  16.   isValid: false
  17. };

原文: https://jkchao.github.io/typescript-book-chinese/typings/indexSignatures.html