ts从入门到进阶—3-9接口（一）

今天药忘吃喽~ 2023-08-17 15:58 143阅读 0赞

### 接口（一）快速入门 ###

**接口初探（只关注值的外形）**

interface LabelledValue {
      label: string;
    }
    
    function printLabel(labelledObj: LabelledValue) {
      console.log(labelledObj.label);
    }
    
    let myObj = {size: 10, label: "Size 10 Object"};
    printLabel(myObj);

**可选属性（**只在可选属性名字定义的后面加一个`?`符号。**）**

interface SquareConfig {
      color?: string;
      width?: number;
    }

**只读属性（**一些对象属性只能在对象刚刚创建的时候修改其值。 在属性名前用 `readonly`来指定只读。赋值之后不能再改变**）**

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

ReadonlyArray

let a: number[] = [1, 2, 3, 4];
    let ro: ReadonlyArray<number> = a;
    ro[0] = 12; // error!
    ro.push(5); // error!
    ro.length = 100; // error!
    a = ro; // error!

**`readonly` vs `const`**

做为变量使用的话用 `const`，做为属性则使用`readonly`。

**额外的属性检查**

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

如果 `SquareConfig`带有上面定义的类型的`color`和`width`属性，**并且*还会*带有任意数量的其它属性**，那么我们可以这样定义它：

**（真的很常用）**

interface SquareConfig {
        color?: string;
        width?: number;
        [propName: string]: any;
    }

**函数类型**

对于函数类型的类型检查来说，函数的参数名不需要与接口里**定义的名字相匹配**。

interface SearchFunc {
      (source: string, subString: string): boolean;
    }
    
    let mySearch: SearchFunc;
    mySearch = function(source: string, subString: string) {
      let result = source.search(subString);
      return result > -1;
    }

**可索引的类型**

TypeScript支持两种索引签名：字符串和数字

描述了对象索引的类型，还有相应的索引返回值类型。

interface StringArray {
      [index: number]: string;
    }
    
    let myArray: StringArray;
    myArray = ["Bob", "Fred"];
    
    let myStr: string = myArray[0];

**类类型**

实现接口

你也可以在接口中描述一个方法，在类里实现它

interface ClockInterface {
        currentTime: Date;
        setTime(d: Date);
    }
    
    class Clock implements ClockInterface {
        currentTime: Date;
        setTime(d: Date) {
            this.currentTime = d;
        }
        constructor(h: number, m: number) { }
    }

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

当一个类实现了一个接口时，只对其实例部分进行类型检查（ constructor存在于类的静态部分）

好复杂

interface ClockConstructor {
        new (hour: number, minute: number): ClockInterface;
    }
    interface ClockInterface {
        tick();
    }
    
    function createClock(ctor: ClockConstructor, hour: number, minute: number): ClockInterface {
        return new ctor(hour, minute);
    }
    
    class DigitalClock implements ClockInterface {
        constructor(h: number, m: number) { }
        tick() {
            console.log("beep beep");
        }
    }
    class AnalogClock implements ClockInterface {
        constructor(h: number, m: number) { }
        tick() {
            console.log("tick tock");
        }
    }
    
    let digital = createClock(DigitalClock, 12, 17);
    let analog = createClock(AnalogClock, 7, 32);

**继承接口**

let strLength: number = (<string>someValue).length; 类型断言

interface Shape {
        color: string;
    }
    
    interface Square extends Shape {
        sideLength: number;
    }
    
    let square = <Square>{};
    square.color = "blue";
    square.sideLength = 10;

**混合类型**

**先回忆一下这个（**\[propName: string\]: any;带有任意数量的其它属性）

interface SquareConfig \{  
    color?: string;  
    width?: number;  
    \[propName: string\]: any;  
\}

然后看这个（(start: number): string;代表一个函数）

interface Counter {
        (start: number): string;
        interval: number;
        reset(): void;
    }

下来看混合类型

一个对象可以同时做为函数和对象使用，并带有额外的属性。

interface Counter {
        (start: number): string;
        interval: number;
        reset(): void;
    }
    
    function getCounter(): Counter {
        let counter = <Counter>function (start: number) { };
        counter.interval = 123;
        counter.reset = function () { };
        return counter;
    }
    
    let c = getCounter();
    c(10);
    c.reset();
    c.interval = 5.0;

**接口继承类（这个太复杂了，后面再看）**

当接口继承了一个类类型时，它会继承类的成员但不包括其实现。

这意味着当你创建了一个接口继承了一个拥有私有或受保护的成员的类时，这个接口类型只能被这个类或其子类所实现（implement）。

\-----------------------------------------------------------------------------------------------------------------

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

### 1.接口初探 ###

**注意事项**

1）接口定义的字段，传的参数必须有并且符合规定。（也就是接口定义了几个字段，你必须传几个）

> 比如说下面会报错
> 
>     interface config {
>         label: string;
>         size: number;
>     }
>     
>     function printLabel(labelledObj: config) {
>         console.log(labelledObj.label);
>       }
>       
>     printLabel({label: '你好'});//错误，传的参数不够
> 
>

2）在满足了上面1）的条件后，传一些不相干的字段会报错

>     interface config {
>         label: string;
>         size: number;
>     }
>     
>     function printLabel(labelledObj: config) {
>         console.log(labelledObj.label);
>       }
>       
>     //报错类型“{ label: string; size: number; other: string; }”的参数不能赋给类型“config”的//参数。对象文字可以只指定已知属性，并且“other”不在类型“config”中。ts(2345)
>     printLabel({ label: '你好', size: 12, other: '12' });
> 
>

3)但是，假如把要传的参数提出来成一个myobj变量，执行的地方不能报错，但是在函数里面不能去使用，会报错。所以安全起见。你的接口定义几个字段，传几个。

interface config {
        label: string;
    }
    
    function printLabel(labelledObj: { label: string }) {
        console.log(labelledObj.label);
        console.log(labelledObj.size);//此处报错。类型“{ label: string; }”上不存在属性“size”。ts(2339)
      }
      
    let myObj = { size: 10, label: "Size 10 Object" };
    printLabel(myObj);//无报错

## 接口初探
    
    下面通过一个简单示例来观察接口是如何工作的：
    
    ```typescript
    function printLabel(labelledObj: { label: string }) {
      console.log(labelledObj.label)
    }
    
    let myObj = { size: 10, label: 'Size 10 Object' }
    printLabel(myObj)
    ```
    
    类型检查器会查看 `printLabel` 的调用。`printLabel` 有一个参数，并要求这个对象参数有一个名为 `label` 类型为 `string` 的属性。 需要注意的是，我们传入的对象参数实际上会包含很多属性，但是编译器只会检查那些必需的属性是否存在，以及其类型是否匹配。 然而，有些时候 TypeScript  却并不会这么宽松，我们下面会稍做讲解。
    
    下面我们重写上面的例子，这次使用接口来描述：必须包含一个`label` 属性且类型为 `string`：
    
    ```typescript
    interface LabelledValue {
      label: string
    }
    
    function printLabel(labelledObj: LabelledValue) {
      console.log(labelledObj.label)
    }
    
    let myObj = {size: 10, label: 'Size 10 Object'}
    printLabel(myObj)
    ```
    
    `LabelledValue` 接口就好比一个名字，用来描述上面例子里的结构。 它代表了有一个 `label` 属性且类型为`string` 的对象。 需要注意的是，我们在这里并不能像在其它语言里一样，说传给 `printLabel` 的对象实现了这个接口。我们只会去关注值的外形。 只要传入的对象满足上面提到的必要条件，那么它就是被允许的。
    
    还有一点值得提的是，类型检查器不会去检查属性的顺序，只要相应的属性存在并且类型也是对的就可以。

### 2.可选属性 ###

**注意事项**

*  可选属性就是有些是只在某些条件下存在，或者根本不存在
 *  好处之一是可以对可能存在的属性进行预定义
 *  好处之二是可以捕获引用了不存在的属性时的错误

个人理解，预定义这个没毛病，官网说的好处之二是可以捕获引用了不存在的属性时的错误，其实就算不是可选属性，当你引用了不存在的属性依然会报错，见**接口初探**的2）

## 可选属性
    
    接口里的属性不全都是必需的。 有些是只在某些条件下存在，或者根本不存在。例如给函数传入的参数对象中只有部分属性赋值了。
    
    ```typescript
    interface Square {
      color: string,
      area: number
    }
    
    interface SquareConfig {
      color?: string
      width?: number
    }
    
    function createSquare (config: SquareConfig): Square {
      let newSquare = {color: 'white', area: 100}
      if (config.color) {
        newSquare.color = config.color
      }
      if (config.width) {
        newSquare.area = config.width * config.width
      }
      return newSquare
    }
    
    let mySquare = createSquare({color: 'black'})
    ```
    
    带有可选属性的接口与普通的接口定义差不多，只是在可选属性名字定义的后面加一个 `?` 符号。
    
    可选属性的好处之一是可以对可能存在的属性进行预定义，好处之二是可以捕获引用了不存在的属性时的错误。 比如，我们故意将 `createSquare` 里的 `color` 属性名拼错，就会得到一个错误提示：
    
    ```typescript
    interface Square {
      color: string,
      area: number
    }
    
    interface SquareConfig {
       color?: string;
       width?: number;
    }
     
    function createSquare(config: SquareConfig): Square {
       let newSquare = {color: 'white', area: 100}
       if (config.clor) {
         // Error: 属性 'clor' 不存在于类型 'SquareConfig' 中
         newSquare.color = config.clor
       }
       if (config.width) {
         newSquare.area = config.width * config.width
       }
       return newSquare
     }
     
     let mySquare = createSquare({color: 'black'})
    ```

### 3.只读属性 ###

## 只读属性
    
    一些对象属性只能在对象刚刚创建的时候修改其值。 你可以在属性名前用 `readonly` 来指定只读属性:
    
    ```typescript
    interface Point {
      readonly x: number
      readonly y: number
    }
    ```
    
    你可以通过赋值一个对象字面量来构造一个 `Point`。 赋值后，`x` 和 `y` 再也不能被改变了。
    
    ```typescript
    let p1: Point = { x: 10, y: 20 }
    p1.x = 5 // error!
    ```
    
    TypeScript 具有 `ReadonlyArray<T>` 类型，它与 `Array<T>` 相似，只是把所有可变方法去掉了，因此可以确保数组创建后再也不能被修改：
    
    ```typescript
    let a: number[] = [1, 2, 3, 4]
    let ro: ReadonlyArray<number> = a
    ro[0] = 12 // error!
    ro.push(5) // error!
    ro.length = 100 // error!
    a = ro // error!
    ```
    
    上面代码的最后一行，可以看到就算把整个 `ReadonlyArray` 赋值到一个普通数组也是不可以的。 但是你可以用类型断言重写：
    
    ```typescript
    a = ro as number[]
    ```
    
    ### readonly vs const
    
    最简单判断该用 `readonly` 还是 `const` 的方法是看要把它做为变量使用还是做为一个属性。 做为变量使用的话用 `const`，若做为属性则使用 `readonly`。

### 4.额外的属性检查 ###

所谓额外的属性检查，就是**传入`{ size: number; label: string; }`到仅期望得到`{ label: string; }`的函数里，这肯定是会报错的。**这个问题在上面也讨论过。看下面的例子

interface SquareConfig {
        color?: string;
        width?: number;
    }
    
    function createSquare(config: SquareConfig): { color: string; area: number } {
        // ...
    }
    
    // error: 'colour' not expected in type 'SquareConfig'
    let mySquare = createSquare({ colour: "red", width: 100 });

但是在实际开发过程中，确实会难免有这样的场景，如何解决这几个问题呢？可以用以下几种方式。

1）使用类型断言

let mySquare = createSquare({ colour: "red", width: 100 }as SquareConfig);

但是这种方式有弊端，虽然在调用的时候不会报错，但是当你的函数里面调用不存在的属性colour的时候，依然会报错，比如

interface SquareConfig {
        color?: string;
        width?: number;
      }
      
      function createSquare(config: SquareConfig): { color: string; area: number } {
        let newSquare = {color: "white", area: 100};
        // 属性“colour”在类型“SquareConfig”上不存在。你是否指的是“color”?ts(2551)
        if (config.colour) {
          newSquare.color = config.colour;
        }
        if (config.width) {
          newSquare.area = config.width * config.width;
        }
        return newSquare;
      }
      
    let mySquare = createSquare({ colour: "red", width: 100 }as SquareConfig);

2）添加一个字符串索引签名。前提是你能够确定这个对象可能具有某些做为特殊用途使用的额外属性。 如果 `SquareConfig`带有上面定义的类型的`color`和`width`属性，并且*还会*带有任意数量的其它属性，那么我们可以这样定义它：

interface SquareConfig {
        color?: string;
        width?: number;
        [propName: string]: any;
    }

这种方式好的原因就是不会出现1）出现的问题，在函数中可以去调用

interface SquareConfig {
        color?: string;
        width?: number;
        [propName: string]: any;
    }
    
    // 以下无任何报错
    function createSquare(config: SquareConfig): { color: string; area: number } {
        let newSquare = { color: "white", area: 100 };
        if (config.colour) {
            newSquare.color = config.colour;
        }
        if (config.width) {
            newSquare.area = config.width * config.width;
        }
        return newSquare;
    }
    
    let mySquare = createSquare({ colour: "red", width: 100 } as SquareConfig);

3）它就是将这个对象赋值给一个另一个变量： 因为 `squareOptions`不会经过额外属性检查，所以编译器不会报错。

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

但是这种依然在函数调用的时候会报错

interface SquareConfig {
        color?: string;
        width?: number;
    }
    
    // 以下无任何报错
    function createSquare(config: SquareConfig): { color: string; area: number } {
        let newSquare = { color: "white", area: 100 };
        // 属性“colour”在类型“SquareConfig”上不存在。你是否指的是“color”?ts(2551)
        if (config.colour) {
            newSquare.color = config.colour;
        }
        if (config.width) {
            newSquare.area = config.width * config.width;
        }
        return newSquare;
    }
    
    let squareOptions = { colour: "red", width: 100 };
    let mySquare = createSquare(squareOptions);

## 额外的属性检查
    
    我们在第一个例子里使用了接口，TypeScript 让我们传入 `{ size: number; label: string; }` 到仅期望得到 `{ label: string; }` 的函数里, 并且我们已经学过了可选属性。
    
    然而，天真地将这两者结合的话就会像在 JavaScript 里那样搬起石头砸自己的脚。 比如，拿 `createSquare` 例子来说：
    
    ```typescript
    interface SquareConfig {
        color?: string;
        width?: number;
    }
    
    function createSquare (config: SquareConfig): { color: string; area: number } {
      let newSquare = {color: 'white', area: 100}
      if (config.color) {
        newSquare.color = config.color
      }
      if (config.width) {
        newSquare.area = config.width * config.width
      }
      return newSquare
    }
    
    
    let mySquare = createSquare({ colour: 'red', width: 100 })
    ```
    
    注意传入 `createSquare` 的参数拼写为 `colour` 而不是 `color`。 在 JavaScript 里，这会默默地失败。
    
    你可能会争辩这个程序已经正确地类型化了，因为 `width` 属性是兼容的，不存在 `color` 属性，而且额外的 `colour` 属性是无意义的。
    
    然而，TypeScript 会认为这段代码可能存在 bug。 对象字面量会被特殊对待而且会经过额外属性检查，当将它们赋值给变量或作为参数传递的时候。 如果一个对象字面量存在任何“目标类型”不包含的属性时，你会得到一个错误。
    
    ```typescript
    // error: 'colour' 不存在于类型 'SquareConfig' 中
    let mySquare = createSquare({ colour: 'red', width: 100 })
    ```
    
    绕开这些检查非常简单。 最简便的方法是使用类型断言：
    
    ```typescript
    let mySquare = createSquare({ width: 100, opacity: 0.5 } as SquareConfig)
    ```
    
    然而，最佳的方式是能够添加一个字符串索引签名，前提是你能够确定这个对象可能具有某些做为特殊用途使用的额外属性。 如果 `SquareConfig` 带有上面定义的类型的 `color` 和 `width` 属性，并且还会带有任意数量的其它属性，那么我们可以这样定义它：
    
    ```typescript
    interface SquareConfig {
      color?: string
      width?: number
      [propName: string]: any
    }
    ```
    
    我们稍后会讲到索引签名，但在这我们要表示的是`SquareConfig` 可以有任意数量的属性，并且只要它们不是 `color` 和 `width`，那么就无所谓它们的类型是什么。
    
    还有最后一种跳过这些检查的方式，这可能会让你感到惊讶，它就是将这个对象赋值给一个另一个变量： 因为 `squareOptions` 不会经过额外属性检查，所以编译器不会报错。
    
    ```typescript
    let squareOptions = { colour: 'red', width: 100 }
    let mySquare = createSquare(squareOptions)
    ```
    
    要留意，在像上面一样的简单代码里，你可能不应该去绕开这些检查。 对于包含方法和内部状态的复杂对象字面量来讲，你可能需要使用这些技巧，但是大多数额外属性检查错误是真正的bug。也就是说你遇到了额外类型检查出的错误，你应该去审查一下你的类型声明。 在这里，如果支持传入 `color` 或 `colour` 属性到 `createSquare`，你应该修改 `SquareConfig` 定义来体现出这一点。

### 5.函数类型 ###

## 函数类型
    
    接口能够描述 JavaScript 中对象拥有的各种各样的外形。 除了描述带有属性的普通对象外，接口也可以描述函数类型。
    
    为了使用接口表示函数类型，我们需要给接口定义一个调用签名。它就像是一个只有参数列表和返回值类型的函数定义。参数列表里的每个参数都需要名字和类型。
    
    ```typescript
    interface SearchFunc {
      (source: string, subString: string): boolean
    }
    ```
    
    这样定义后，我们可以像使用其它接口一样使用这个函数类型的接口。 下例展示了如何创建一个函数类型的变量，并将一个同类型的函数赋值给这个变量。
    
    ```typescript
    let mySearch: SearchFunc
    mySearch = function(source: string, subString: string): boolean {
      let result = source.search(subString);
      return result > -1
    }
    ```
    
    对于函数类型的类型检查来说，函数的参数名不需要与接口里定义的名字相匹配。 比如，我们使用下面的代码重写上面的例子：
    
    ```typescript
    let mySearch: SearchFunc
    mySearch = function(src: string, sub: string): boolean {
      let result = src.search(sub);
      return result > -1
    }
    ```
    
    函数的参数会逐个进行检查，要求对应位置上的参数类型是兼容的。 如果你不想指定类型，TypeScript 的类型系统会推断出参数类型，因为函数直接赋值给了  `SearchFunc` 类型变量。 函数的返回值类型是通过其返回值推断出来的（此例是 `false` 和 `true`）。 如果让这个函数返回数字或字符串，类型检查器会警告我们函数的返回值类型与 `SearchFunc` 接口中的定义不匹配。
    
    ```typescript
    let mySearch: SearchFunc
    mySearch = function(src, sub) {
      let result = src.search(sub)
      return result > -1
    }
    ```

6.可索引的类型

## 可索引的类型
    
    与使用接口描述函数类型差不多，我们也可以描述那些能够“通过索引得到”的类型，比如 `a[10]` 或 `ageMap['daniel']`。 可索引类型具有一个 索引签名，它描述了对象索引的类型，还有相应的索引返回值类型。 让我们看一个例子：
    
    ```typescript
    interface StringArray {
      [index: number]: string
    }
    
    let myArray: StringArray
    myArray = ['Bob', 'Fred']
    
    let myStr: string = myArray[0]
    ```
    
    上面例子里，我们定义了 `StringArray` 接口，它具有索引签名。 这个索引签名表示了当用 `number` 去索引 `StringArray` 时会得到 `string` 类型的返回值。
    
    TypeScript 支持两种索引签名：字符串和数字。 可以同时使用两种类型的索引，但是数字索引的返回值必须是字符串索引返回值类型的子类型。 这是因为当使用 `number` 来索引时，JavaScript 会将它转换成`string` 然后再去索引对象。 也就是说用 `100`（一个 `number`）去索引等同于使用`'100'`（一个 `string` ）去索引，因此两者需要保持一致。
    
    ```typescript
    class Animal {
      name: string
    }
    class Dog extends Animal {
      breed: string
    }
    
    // 错误：使用数值型的字符串索引，有时会得到完全不同的Animal!
    interface NotOkay {
      [x: number]: Animal
      [x: string]: Dog
    }
    ```
    
    字符串索引签名能够很好的描述 `dictionary` 模式，并且它们也会确保所有属性与其返回值类型相匹配。 因为字符串索引声明了 `obj.property` 和 `obj['property']` 两种形式都可以。 下面的例子里， `name` 的类型与字符串索引类型不匹配，所以类型检查器给出一个错误提示：
    
    ```typescript
    interface NumberDictionary {
      [index: string]: number;
      length: number;    // 可以，length是number类型
      name: string       // 错误，`name`的类型与索引类型返回值的类型不匹配
    }
    ```
    
    最后，你可以将索引签名设置为只读，这样就防止了给索引赋值：
    
    ```typescript
    interface ReadonlyStringArray {
      readonly [index: number]: string;
    }
    let myArray: ReadonlyStringArray = ['Alice', 'Bob'];
    myArray[2] = 'Mallory'; // error!
    ```