Interfaces

An interface is a TypeScript artifact, it is not part of ECMAScript. An interface is a way to define a contract on a function with respect to the arguments and their type. Along with functions, an interface can also be used with a Class as well to define custom types.

An interface is an abstract type, it does not contain any code as a class does. It only defines the 'signature' or shape of an API. During transpilation, an interface will not generate any code, it is only used by Typescript for type checking during development.

Here is an example of an interface describing a function API:

  1. interface Callback {
  2.   (error: Error, data: any): void;
  3. }
  5. function callServer(callback: Callback) {
  6.   callback(null, 'hi');
  7. }
  9. callServer((error, data) => console.log(data));  // 'hi'
  10. callServer('hi');                                // tsc error

Sometimes JavaScript functions can accept multiple types as well as varying arguments, that is, they can have different call signatures. Interfaces can be used to specify this.

  1. interface PrintOutput {
  2.   (message: string): void;    // common case
  3.   (message: string[]): void;  // less common case
  4. }
  6. let printOut: PrintOutput = (message) => {
  7.   if (Array.isArray(message)) {
  8.     console.log(message.join(', '));
  9.   } else {
  10.     console.log(message);
  11.   }
  12. }
  14. printOut('hello');       // 'hello'
  15. printOut(['hi', 'bye']); // 'hi, bye'

Here is an example of an interface describing an object literal:

  1. interface Action {
  2.   type: string;
  3. }
  5. let a: Action = {
  6.     type: 'literal'
  7. }

原文: https://angular-2-training-book.rangle.io/handout/features/interfaces.html