JS的原型、原型链始终是比拟难了解的内容，不少初学者甚至有肯定教训的老鸟都不肯定能齐全说分明，更多的"很可能"是只知其一;不知其二，而这部分内容又是JS的核心内容，想要技术进阶的话必定不能对这个概念只知其一;不知其二，碰到问题靠“猜”，却不了解它的规定！
prototype
只有函数有prototype属性
let a = {}let b = function () { }console.log(a.prototype) // undefinedconsole.log(b.prototype) // { constructor: function(){...} }Object.prototype怎么解释？
其实Object是一个全局对象，也是一个构造函数，以及其余根本类型的全局对象也都是构造函数：
function outTypeName(data, type) { let typeName = Object.prototype.toString.call(data) console.log(typeName)}outTypeName(Object) //[object Function]outTypeName(String) // [object Function]outTypeName(Number) // [object Function]为什么只有函数有prototype属性
JS通过new来生成对象，然而仅靠构造函数，每次生成的对象都不一样。
有时候须要在两个对象之间共享属性，因为JS在设计之初没有类的概念，所以JS应用函数的prototype来解决这部分须要被共享的属性，通过函数的prototype来模仿类：
当创立一个函数时，JS会主动为函数增加prototype属性，值是一个有constructor的对象。
以下是共享属性prototype的栗子：
function People(name) { this.name = name}People.prototype.age = 23 // 岁数// 创立两个实例let People1 = new People('OBKoro1')let People2 = new People('扣肉')People.prototype.age = 24 // 长大了一岁console.log(People1.age, People2.age) // 24 24为什么People1和People2能够拜访到People.prototype.age？
起因是：People1和People2的原型是People.prototype，答案在下方的：构造函数是什么以及它做了什么。
原型链
__proto__和Object.getPrototypeOf(target)： 对象的原型
__proto__是对象实例和它的构造函数之间建设的链接，它的值是：构造函数的`prototype。
也就是说：__proto__的值是它所对应的原型对象，是某个函数的prototype
Object.getPrototypeOf(target)全等于__proto__。
它是ES6的规范，兼容IE9，支流浏览器也都反对，MDN，本文将以Object.getPrototypeOf(target)指代__proto__。
不要再应用__proto__:
本段摘自阮一峰-ES6入门，具体解析请点击链接查看
__proto__属性没有写入 ES6 的注释，而是写入了附录。- 起因是它实质上是一个外部属性，而不是一个正式的对外的 API，只是因为浏览器广泛支持，才被退出了 ES6。
- 规范明确规定，只有浏览器必须部署这个属性，其余运行环境不肯定须要部署，而且新的代码最好认为这个属性是不存在的。
- 所以无论从语义的角度，还是从兼容性的角度，都不要应用这个属性，应该应用：
Object.getPrototypeOf(target)（读操作）、Object.setPrototypeOf(target)（写操作）、Object.create(target)（生成操作）代替
构造函数是什么、它做了什么
出自《你不晓得的js》：在js中, 实际上并不存在所谓的'构造函数'，只有对于函数的'结构调用'。
上文始终提到构造函数，所谓的构造函数，实际上就是通过关键字new来调用的函数：
let newObj = new someFn() // 结构调用函数结构/new调用函数的时候做了什么：
- 创立一个全新的对象。
- 这个新对象的原型(
Object.getPrototypeOf(target))指向构造函数的prototype对象。 - 该函数的this会绑定在新创建的对象上。
- 如果函数没有返回其余对象，那么new表达式中的函数调用会主动返回这个新对象。
- 咱们称这个新对象为构造函数的实例。
原型继承就是利用结构调用函数的个性：
SubType.prototype = new SuperType(); // 原型继承：SubType继承SuperTypeSubType.prototype.constructor = SubType // 从新指定constructor指向 不便找到构造函数// 挂载SuperType的this和prototype的属性和办法到SubType.prototype上- 结构调用的第二点：将新对象的
Object.getPrototypeOf(target)指向函数的prototype - 结构调用的第三点：该函数的this会绑定在新创建的对象上。(所以父类
this申明的属性被所有子类实例共享) - 新对象赋值给
SubType.prototype
原型链是什么
来看个例子：
function foo() { }const newObj = new foo() // 结构调用foo 返回一个新对象const newObj__proto__ = Object.getPrototypeOf(newObj) // 获取newObj的原型对象newObj__proto__ === foo.prototype // true 验证newObj的原型指向fooconst foo__proto__ = Object.getPrototypeOf(foo.prototype) // 获取foo.prototype的原型foo__proto__ === Object.prototype // true foo.prototype的原型是Object.prototype如果用以前的语法，从newObj查找foo的原型，是这样的：
newObj.__proto__.__proto__ // 这种关系就是原型链能够用以下三句话来了解原型链：
- 每个对象都领有一个原型对象:
newObj的原型是foo.prototype。 - 对象的原型可能也是继承其余原型对象的:
foo.prototype也有它的原型Object.prototype。 - 一层一层的，以此类推，这种关系就是原型链。
一个对象是否在另一个对象的原型链上
如果一个对象存在另一个对象的原型链上，咱们能够说：它们是继承关系。
判断形式有两种，但都是依据构造函数的prototype是否在原型链上来判断的：
instanceof: 用于测试构造函数的prototype属性是否呈现在对象的原型链中的任何地位
语法：object instanceof constructor
let test = function () { }let testObject = new test();testObject instanceof test // true test.prototype在testObject的原型链上 testObject instanceof Function // false Function.prototype 不在testObject的原型链上testObject instanceof Object // true Object.prototype在testObject的原型链上isPrototypeOf：测试一个对象是否存在于另一个对象的原型链上
语法：prototypeObj.isPrototypeOf(object)
let test = function () { }let testObject = new test();test.prototype.isPrototypeOf(testObject) // true test.prototype在testObject的原型链上Object.prototype.isPrototypeOf(testObject) // true Object.prototype在testObject的原型链上原型链的起点: Object.prototype
Object.prototype是原型链的起点，所有对象都是从它继承了办法和属性。
Object.prototype没有原型对象：
const proto = Object.getPrototypeOf(Object.prototype) // null上面是两个验证例子，有疑虑的同学多写几个测试用例印证一下。
字符串原型链的起点：Object.prototype
let test = '由String函数结构进去的'let stringPrototype = Object.getPrototypeOf(test) // 字符串的原型stringPrototype === String.prototype // true 字符串的原型是String对象Object.getPrototypeOf(stringPrototype) === Object.prototype // true String对象的原型是Object对象函数原型链的起点:Object.prototype
let test = function () { }let fnPrototype = Object.getPrototypeOf(test)fnPrototype === Function.prototype // true test的原型是Function.prototypeObject.getPrototypeOf(Function.prototype) === Object.prototype // true原型链用来做什么？
属性查找：
如果试图拜访对象(实例instance)的某个属性,会首先在对象外部寻找该属性,直至找不到,而后才在该对象的原型(instance.prototype)里去找这个属性，以此类推
参考视频解说：进入学习
咱们用一个例子来形象阐明一下：
let test = '由String函数结构进去的'let stringPrototype = Object.getPrototypeOf(test) // 字符串的原型stringPrototype === String.prototype // true 字符串的原型是String对象Object.getPrototypeOf(stringPrototype) === Object.prototype // true String对象的原型是Object对象当你拜访test的某个属性时，浏览器会进行以下查找：
- 浏览器首先查找
test自身 - 接着查找它的原型对象：
String.prototype - 最初查找
String.prototype的原型对象：Object.prototype - 一旦在原型链上找到该属性，就会立刻返回该属性，进行查找。
- 原型链上的原型都没有找到的话，返回
undefiend
这种查找机制还解释了字符串为何会有自带的办法: slice/split/indexOf等。
精确的说：
- 这些属性和办法是定义在
String这个全局对象/函数上的。 - 字符串的原型指向了
String函数的prototype。 - 之后通过查找原型链，在String函数的
prototype中找到这些属性和办法。
回绝查找原型链：
hasOwnProperty: 批示对象本身属性中是否具备指定的属性
语法：obj.hasOwnProperty(prop)
参数: prop 要查找的属性
返回值: 用来判断某个对象是否含有指定的属性的Boolean。
let test ={ 'OBKoro1': '扣肉' }test.hasOwnProperty('OBKoro1'); // truetest.hasOwnProperty('toString'); // false test自身没查找到toString 这个API是挂载在object.prototype上，所有对象都能够应用，API会疏忽掉那些从原型链上继承到的属性。
扩大：
实例的属性
你晓得构造函数的实例对象上有哪些属性吗？这些属性别离挂载在哪个中央？起因是什么？
function foo() { this.some = '222' let ccc = 'ccc' foo.obkoro1 = 'obkoro1' foo.prototype.a = 'aaa'}foo.koro = '扣肉'foo.prototype.test = 'test'let foo1 = new foo() // `foo1`上有哪些属性,这些属性别离挂载在哪个中央foo.prototype.test = 'test2' // 从新赋值下面这道是考查JS根底的题，很多人都没说对，起因是没有彻底把握this、原型链、函数。
想一下再看解析：
想一下再看解析：
想一下再看解析：
想一下再看解析：
想一下再看解析：
this.some：foo1对象的属性
通过结构调用foo的this指向foo1，所以this.some挂载在foo1对象下。
属性查找: foo1.some
foo1.some间接读取foo1的属性。
foo1.test、foo1.a：foo1对象的原型
依据上文提到的：结构/new调用函数的时候会创立一个新对象(foo1)，主动将foo1的原型(Object.getPrototypeOf(foo1))指向构造函数的prototype对象。
结构调用会执行函数，所以foo.prototype.a = 'aaaaa'也会执行，单就赋值这个层面来说写在foo里面和写在foo外面是一样的。
属性查找：foo1.test、foo1.a
foo1自身没有找到,持续查找foo1的原型Object.getPrototypeOf(foo1)上找到了a和test，返回它们，进行查找。foo1.obkoro1和foo1.koro：返回undefined
动态属性: foo.obkoro1、foo.koro
函数在JS中是一等公民，它也是一个对象, 用来模仿类。
这两个属性跟foo1没有关系，它是对象foo上的两个属性(相似函数的:arguments/prototype/length等属性)，称为动态属性。
它们只能通过foo.obkoro1和foo.koro来拜访。
原型对象扭转，原型链上游获取的值也会扭转
下面那个例子中的foo1.test的值是什么？
foo.prototype.test = 'test'let foo1 = new foo() // `foo1`上有哪些属性,这些属性别离挂载在哪个中央foo.prototype.test = 'test2' // 从新赋值foo1.test的值是test2，起因是：foo1的原型对象是Object.getPrototypeOf(foo1)存的指针，指向foo.prototype的内存地址，不是拷贝，每次读取的值都是以后foo.prototype的最新值。
打印foo1：
小结
写了好几天，之前网上很多图文博客，那些线指来指去，就我集体看来还是比拟难以了解的，所以本文纯文字的模式来形容这些概念，置信认真看完的同学必定都有所播种，如果没看懂的话，倡议多看几遍，这部分概念真的很重要！