JS设计原则 —— 里式替换原则（LSP）

什么是里式替换原则

Functions that use pointers of references to base classes must be able to use objects of derived classes without konwing it.
大概意思就是在程序中子类可以替换父类，而且不会产生任何错误。但是父类不能替换子类。

符合里式替换原则的代码是什么样的呢？通过一个例子来看一下。

class Retry {
  public async call(fn) {
    for(let attemptNumber = 1;; attemptNumber++) {
      try{
        const response = await fn();
      } catch(error) {
        throw Error('error');
      }

      if (response.code < 500) {
        return response;
      }
    }
  }
}

class BaseRetry extends Retry{
  public async call(fn) {
    for(let attemptNumber = 1;; attemptNumber++) {
      try{
        const response = await fn();
      } catch(error) {
        throw Error('error');
      }

      if (response.code < 500) {
        response.attemptNumber = attemptNumber;
        return response;
      }
    }
  }
}

上面是一个接口重试的例子（当然这里实现非常的简洁，只是通过它来看一下LSP），如果返回的code值小于500就返回结果，否则继续重试。子类BaseRetry对返回的结果做了增强，用它来替换new Retry().call()的运行完全没有问题。但如果反过来，BaseRetry是父类，Retry是子类，Retry替换BaseRetry就可能引起异常，因为子类Retry中取不到attemptNumber，子类对父类的返回值做了删减。

LSP跟多态有何区别

首先来看一下什么是多态：

多态是指子类可以替换父类，在程序运行中调用子类的方法。多态也是利用继承来实现。

如果从定义和代码实现上来看，多态和里式替换原则很相似。但他们关注的角度是不一样的。从名称上来看，里式替换是一种设计原则，是来指导继承关系中子类是如何设计的。而多态是面向对象编程的一大特性，是一种代码实现的思路。

遵从里式替换原则的子类在实现时有更多的约束条件，它必须要保证在替换父类的时候不会破坏程序的正确性。还是刚才的例子，把子类改造一下，它还是能够利用多态替换父类，但是却违反了LSP。

改造后：
class BaseRetry extends Retry{
  public async call(fn) {
    if(typeof fn !== 'function') {
      throw Error('fn must be a function');
    }
    for(let attemptNumber = 1;; attemptNumber++) {
      try{
        const response = await fn();
      } catch(error) {
        throw Error('error');
      }

      if (response.code < 500) {
        return response;
      }
    }
  }
}

改造后的BaseRetry检验了参数类型，不是函数的话就抛出错误，子类替换父类之后有可能报错。子类的实现违背了父类的约定，所以不符合LSP。

什么样的代码违背了LSP

满足LSP的子类在设计的时候有哪些要求呢？

• 子类可以增加自己特有的属性和方法
• 子类在覆写父类方法的时候，输入输出必须遵从父类的约定。输入相同或者更宽松，输出相同或者更严格。比如子类参数的类型包含父类参数的类型。

那什么样的代码明显违背了LSP？

• 子类实现的功能与父类不一样。
• 子类违背父类对输入、输出、异常的约定。比如父类在输入为空的时候不做处理，子类在输入为空的时候抛出异常；父类输出的时候把整个数组返回，子类输出的时候截取部分返回等。

如果随着项目的演进，新实现的子类已经不能满足父类的约定，那就可以拆成新的类，制定新的约定。

LSP的意义是什么

里式替换原则可以降低继承带来的复杂度。

对于父类中的方法，如果在其子类中有不同的含义，而项目中又较多的使用了多态，那程序出错的可能性就大大增加。同时也增加了类管理的难度。