TypeScript的核心原则之一是对值所具有的结构进行类型检查。 它有时被称做“鸭式辨型法”或“结构性子类型化”。 在TypeScript里，接口的作用就是为这些类型命名和为你的代码或第三方代码定义契约。

接口初探

LabelledValue接口就好比一个名字，用来描述上面例子里的要求。 它代表了有一个label属性且类型为string的对象。 需要注意的是，我们在这里并不能像在其它语言里一样，说传给printLabel的对象实现了这个接口。我们只会去关注值的外形。 只要传入的对象满足上面提到的必要条件，那么它就是被允许的。
还有一点值得提的是，类型检查器不会去检查属性的顺序，只要相应的属性存在并且类型也是对的就可以。
注意: myObj比接口 LabelledValue多一个 size参数 , 这会带来什么问题? 稍会儿对比. 

  1. interface LabelledValue {
  2.   label: string;
  3. }
  5. function printLabel(labelledObj: LabelledValue) {
  6.   console.log(labelledObj.label);
  7. }
  9. let myObj = {size: 10, label: "Size 10 Object"};
  10. printLabel(myObj);

只读属性

一些对象属性只能在对象刚刚创建的时候修改其值。 你可以在属性名前用readonly来指定只读属性:
readonly vs const
最简单判断该用readonly还是const的方法是看要把它做为变量使用还是做为一个属性。 做为变量使用的话用const，若做为属性则使用readonly。

  1. interface Point {
  2.     readonly x: number;
  3.     readonly y: number;
  4. }
  5. let p1: Point = { x: 10, y: 20 };
  6. p1.x = 5; // error!

可选属性

接口里的属性不全都是必需的。 有些是只在某些条件下存在，或者根本不存在。 可选属性在应用“option bags”模式时很常用，即给函数传入的参数对象中只有部分属性赋值了。
带有可选属性的接口与普通的接口定义差不多，只是在可选属性名字定义的后面加一个?符号。
可选属性的好处之一是可以对可能存在的属性进行预定义，好处之二是可以捕获引用了不存在的属性时的错误。 比如，我们故意将createSquare里的color属性名拼错，就会得到一个错误提示：

  1. interface SquareConfig {
  2.   color?: string;
  3.   width?: number;
  4. }
  6. function createSquare(config: SquareConfig): {color: string; area: number} {
  7.   let newSquare = {color: "white", area: 100};
  8.   if (config.color) {
  9.     newSquare.color = config.color;
  10.   }
  11.   if (config.width) {
  12.     newSquare.area = config.width * config.width;
  13.   }
  14.   return newSquare;
  15. }
  17. let mySquare = createSquare({color: "black"});

额外的属性检查

我们在第一个例子里使用了接口，TypeScript让我们传入{ size: number; label: string; }到仅期望得到{ label: string; }的函数里。
在之前的例子里,一切都是正常. 但在这里,多余的属性 colour会被检测出来,并提示错误.

  1. interface SquareConfig {
  2.     color?: string;
  3.     width?: number;
  4. }
  6. function createSquare(config: SquareConfig): { color: string; area: number } {
  7.     // ...
  8. }
  10. let mySquare = createSquare({ colour: "red", width: 100 });

对象字面量会被特殊对待而且会经过额外属性检查，当将它们赋值给变量或作为参数传递的时候。 如果一个对象字面量存在任何“目标类型”不包含的属性时，你会得到一个错误。

  1. // error: 'colour' not expected in type 'SquareConfig'
  2. let mySquare = createSquare({ colour: "red", width: 100 });

解决方法1:
绕开这些检查非常简单。 最简便的方法是使用类型断言：

  1. let mySquare = createSquare({ width: 100, opacity: 0.5 } as SquareConfig);

解决方法2:
添加一个字符串索引签名:
SquareConfig可以有任意数量的属性，并且只要它们不是color和width，那么就无所谓它们的类型是什么。

  1. interface SquareConfig {
  2.     color?: string;
  3.     width?: number;
  4.     [propName: string]: any;
  5. }

解决方法3:
回到”接口初探“部分,发现如果将这个对象赋值给一个另一个变量,可以跳过这些检查: 因为squareOptions不会经过额外属性检查，所以编译器不会报错。

  1. let squareOptions = { colour: "red", width: 100 };
  2. let mySquare = createSquare(squareOptions);

要留意，在像上面一样的简单代码里，你可能不应该去绕开这些检查。 对于包含方法和内部状态的复杂对象字面量来讲，你可能需要使用这些技巧，但是大部额外属性检查错误是真正的bug。 就是说你遇到了额外类型检查出的错误，比如“option bags”，你应该去审查一下你的类型声明。

函数类型

接口能够描述JavaScript中对象拥有的各种各样的外形。 除了描述带有属性的普通对象外，接口也可以描述函数类型。
为了使用接口表示函数类型，我们需要给接口定义一个调用签名。 它就像是一个只有参数列表和返回值类型的函数定义。参数列表里的每个参数都需要名字和类型。

  1. // 函数接口
  2. interface SearchFunc {
  3.   (source: string, subString: string): boolean;
  4. }
  5. // 
  6. let mySearch: SearchFunc;
  7. mySearch = function(source: string, subString: string) {
  8.   let result = source.search(subString);
  9.   return result > -1;
  10. }

对于函数类型的类型检查来说，函数的参数名不需要与接口里定义的名字相匹配。 比如，我们使用下面的代码重写上面的例子：

  1. let mySearch: SearchFunc;
  2. mySearch = function(src: string, sub: string): boolean {
  3.   let result = src.search(sub);
  4.   return result > -1;
  5. }

可索引的类型

暂时不处理.

类类型

实现接口

与C#或Java里接口的基本作用一样，TypeScript也能够用它来明确的强制一个类去符合某种契约。

  1. interface ClockInterface {
  2.     currentTime: Date;
  3.     setTime(d: Date);
  4. }
  6. class Clock implements ClockInterface {
  7.     currentTime: Date;
  8.     setTime(d: Date) {
  9.         this.currentTime = d;
  10.     }
  11.     constructor(h: number, m: number) { }
  12. }

类静态部分与实例部分的区别

暂时不处理.

继承接口

接口可以继承:

  1. interface Shape {
  2.     color: string;
  3. }
  5. interface Square extends Shape {
  6.     sideLength: number;
  7. }
  9. let square = <Square>{};
  10. square.color = "blue";
  11. square.sideLength = 10;

接口可以多继承

  1. interface Shape {
  2.     color: string;
  3. }
  5. interface PenStroke {
  6.     penWidth: number;
  7. }
  9. interface Square extends Shape, PenStroke {
  10.     sideLength: number;
  11. }
  13. let square = <Square>{};
  14. square.color = "blue";
  15. square.sideLength = 10;
  16. square.penWidth = 5.0;

混合类型

暂时不处理.

接口继承类

暂时不处理.