什么是里式替换原则
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的意义是什么
里式替换原则可以降低继承带来的复杂度。
对于父类中的方法，如果在其子类中有不同的含义，而项目中又较多的使用了多态，那程序出错的可能性就大大增加。同时也增加了类管理的难度。
