python继承方式是基于原型吗_js原型链，继承和promis的基本理解

List itemweb

1、原型链

开局一张图

promise

prototype

每一个函数都有一个prototype属性，被称为显示原型

2._ proto _

每一个实例对象都会有_ proto _属性,其被称为隐式原型app

每个实例对象的隐式原型_ proto _属性指向自身构造函数的显式原型prototype异步

constructor

每一个prototype原型都有一个constructor属性，指向它关联的构造函数。svg

原型链

获取对象属性时，若是对象自己没有这个属性，那就会去他的原型__proto__上去找，若是还查不到，就去找原型的原型，一直找到最顶层(Object.prototype)为止。Object.prototype对象也有__proto__属性值为null。函数

2、继承

一、原型链继承

重点：让新实例的原型等于父类的实例。

特色：一、实例可继承的属性有：实例的构造函数的属性，父类构造函数属性，父类原型的属性。(新实例不会继承父类实例的属性！)

缺点：一、新实例没法向父类构造函数传参。

二、继承单一。

三、全部新实例都会共享父类实例的属性。(原型上的属性是共享的，一个实例修改了原型属性，另外一个实例的原型属性也会被修改！)

二、借用构造函数继承

重点：用.call()和.apply()将父类构造函数引入子类函数(在子类函数中作了父类函数的自执行(复制))

特色：一、只继承了父类构造函数的属性，没有继承父类原型的属性。

二、解决了原型链继承缺点一、二、3。

三、能够继承多个构造函数属性(call多个)。

四、在子实例中可向父实例传参。

缺点：一、只能继承父类构造函数的属性。

二、没法实现构造函数的复用。(每次用每次都要从新调用)

三、每一个新实例都有父类构造函数的副本，臃肿。学习

三、组合继承(组合原型链继承和借用构造函数继承)(经常使用)

重点：结合了两种模式的优势，传参和复用

特色：一、能够继承父类原型上的属性，能够传参，可复用。

二、每一个新实例引入的构造函数属性是私有的。

缺点：调用了两次父类构造函数(耗内存)，子类的构造函数会代替原型上的那个父类构造函数。this

四、原型式继承

重点：用一个函数包装一个对象，而后返回这个函数的调用，这个函数就变成了个能够随意增添属性的实例或对象。object.create()就是这个原理。

特色：相似于复制一个对象，用函数来包装。

缺点：一、全部实例都会继承原型上的属性。

二、没法实现复用。(新实例属性都是后面添加的)

五、寄生式继承

重点：就是给原型式继承外面套了个壳子。

优势：没有建立自定义类型，由于只是套了个壳子返回对象(这个)，这个函数瓜熟蒂落就成了建立的新对象。

缺点：没用到原型，没法复用。

六、寄生组合式继承(经常使用)

寄生：在函数内返回对象而后调用

组合：一、函数的原型等于另外一个实例。二、在函数中用apply或者call引入另外一个构造函数，可传参

重点：修复了组合继承的问题es5

继承这些知识点与其说是对象的继承，更像是函数的功能用法，如何用函数作到复用，组合，这些和使用继承的思考是同样的。上述几个继承的方法均可以手动修复他们的缺点，但就是多了这个手动修复就变成了另外一种继承模式。

这些继承模式的学习重点是学它们的思想，否则你会在coding书本上的例子的时候，会以为明明能够直接继承为何还要搞这么麻烦。就像原型式继承它用函数复制了内部对象的一个副本，这样不只能够继承内部对象的属性，还能把函数(对象，来源内部对象的返回)随意调用，给它们添加属性，改个参数就能够改变原型对象，而这些新增的属性也不会相互影响。

ES6中的 class继承:

父类(基类)spa

子类

extends 关键字

//class 至关于es5中构造函数

//class中定义方法时，先后不能加function，所有定义在class的protopyte属性中

//class中定义的全部方法是不可枚举的

//class中只能定义方法，不能定义对象，变量等

//class和方法内默认都是严格模式

//es5中constructor为隐式属性

//父类

class People{

constructor(name='wang',age='27'){

this.name = name;

this.age = age;

}

eat(){

console.log(`${this.name} ${this.age} eat food`)

}

}

//子类 经过extends 继承父类

class Woman extends People{

constructor(name = 'ren',age = '27'){

//继承父类属性

super(name, age);

}

eat(){

//继承父类方法

super.eat()

}

}

let wonmanObj=new Woman('xiaoxiami');

wonmanObj.eat();

3、promise

通常来说，有如下的名词约定：

promise(首字母小写)对象指的是“Promise实例对象”

Promise首字母大写且单数形式，表示“Promise构造函数”

Promises首字母大写且复数形式，用于指代“Promises规范”

什么是Promise？

Promise，简单说就是一个容器，里面保存着某个将来才会结束的事件(一般是一个异步操做)的结果。

从语法上说，promise 是一个对象，从它能够获取异步操做的的最终状态(成功或失败)。

Promise是一个构造函数，对外提供统一的 API，本身身上有all、reject、resolve等方法，原型上有then、catch等方法。

Promise的两个特色

Promise对象的状态不受外界影响

1)pending 初始状态

2)fulfilled 成功状态

3)rejected 失败状态

Promise 有以上三种状态，只有异步操做的结果能够决定当前是哪种状态，其余任何操做都没法改变这个状态

Promise的状态一旦改变，就不会再变，任什么时候候均可以获得这个结果，状态不能够逆，只能由 pending变成fulfilled或者由pending变成rejected

使用 new 来建立一个promise对象。

Promise接受一个「函数」做为参数，该函数的两个参数分别是resolve和reject。这两个函数就是就是「回调函数」

resolve函数的做用：在异步操做成功时调用，并将异步操做的结果，做为参数传递出去；

reject函数的做用：在异步操做失败时调用，并将异步操做报出的错误，做为参数传递出去。

const promise = new Promise((resolve, reject) => {

// do something here ...

if (success) {

resolve(value); // fulfilled

} else {

reject(error); // rejected

}

});

resolve做用是，将Promise对象的状态从“未完成”变为“成功”(即从 pending 变为 resolved)，在异步操做成功时调用，并将异步操做的结果，做为参数传递出去；

reject做用是，将Promise对象的状态从“未完成”变为“失败”(即从 pending 变为 rejected)，在异步操做失败时调用，并将异步操做报出的错误，做为参数传递出去。

promise有三个状态：

一、pending[待定]初始状态

二、fulfilled[实现]操做成功

三、rejected[被否决]操做失败

当promise状态发生改变，就会触发then()里的响应函数处理后续步骤；

promise状态一经改变，不会再变。

Promise对象的状态改变，只有两种可能：

从pending变为fulfilled

从pending变为rejected。

.then()

一、接收两个函数做为参数，分别表明fulfilled(成功)和rejected(失败)

二、.then()返回一个新的Promise实例，因此它能够链式调用

三、当前面的Promise状态改变时，.then()根据其最终状态，选择特定的状态响应函数执行

四、状态响应函数能够返回新的promise，或其余值，不返回值也能够咱们能够认为它返回了一个null；

五、若是返回新的promise，那么下一级.then()会在新的promise状态改变以后执行

六、若是返回其余任何值，则会当即执行下一级.then()

.then()里面有.then()的状况

一、由于.then()返回的仍是Promise实例

二、会等里面的then()执行完，再执行外面的