索引签名

    例如：

    我们在键 下保存了一个字符串 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 对这些概念更优雅的处理。

    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]）。
      如下所示：

    TIP

    TypeScript 的索引签名必须是 或者 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 };
    5. // Error:
    6. // `{ b: 1, c: 2, d: 3 }` 不能分配给 'FromIndex'
    7. // 对象字面量只能指定已知类型，'d' 不存在 'FromIndex' 类型上
    8. const bad: FromIndex = { b: 1, c: 2, d: 3 };

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

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

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

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

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

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