简单介绍一下js中的构造函数、原型对象prototype、对象原型__proto_

简单介绍一下js中的构造函数、原型对象prototype、对象原型__proto__、原型链

构造函数

	function Star (uname, age){this.uname = unamethis.age = agethis.sing = function(){ log('唱歌~') }}let xzq = new Star('薛之谦', 30)let ldh = new Star('刘德华', 20)log(ldh) // { uname: '刘德华', age: 20, sing: f }ldh.sing() // 唱歌~log(ldh.sing === xzq.sing) // false

# 实例成员：构造函数内部，通过this添加的成员，如上面的：uname、age、sing实例成员，只能通过实例化的对象来访问，如：ldh.sing()才行，Star.sing()就不行# 静态成员：在构造函数本身上，添加的成员，如：Star.sex = '男'静态成员只能通过构造函数访问，如：log(Star.sex) // 男不能通过实例化对象来访问（ldh.sex就不行）# 构造函数 new 的执行过程1、new构造函数，可以在内存中创建一个空的对象2、this就会指向刚才创建的空对象3、执行构造函数里面的代码，就给这个空对象添加属性、方法4、返回这个对象（所以构造函数里面不用return）

prototype 原型对象

# js规定，每一个构造函数都有一个prototype属性，这个prototype就是一个对象所以，我们可以把'公共的方法'添加到这个'原型对象prototype上'（原型对象prototype的作用就是共享方法）所以：公共的属性，定义到，构造函数里面公共的方法，定义到，原型对象prototype上

	function Star (uname, age){this.uname = unamethis.age = age}Star.prototype.sing = function(){ log('唱个歌') }let ldh = new Star('刘德华', 20)let xzq = new Star('薛之谦', 30)log(ldh.sing === xzq.sing) // true# console.log( ldh ) // 系统会自动，在对象的身上，添加一个'__proto__'，指向构造函数的原型对象# prototypeconsole.log( ldh.__proto__ === Star.prototype ) // true

方法的查找规则：

	首先看`ldh对象`，它身上是否有sing()方法，如果有，就执行它的这个方法如果没有这个方法，但因为`__proto__`存在，就去`构造函数的原型对象prototype上`去找这个sing()方法

proto：对象原型

	每个对象身上都有一个`__proto__`对象原型，指向`指向构造函数的原型对象prototype`之所以，对象可以使用`构造函数的原型对象prototype`上的属性、方法是因为，对象有`__proto__(对象原型)`的存在`__proto__对象原型` 和 `构造函数的原型对象prototype`是等价的`__proto__对象原型`的意义：在于为对象的查找机制提供一个方向，或者说一条线路，但它是一个非标准属性，因此实际开发中，不可用使用这个属性，它只是内部指向原型对象prototype

原型链

	function Star(uname, age){this.uname = unamethis.age = age}let ldh = new Start('刘德华', 123)log( ldh.__proto__ === Star.prototype ) // truelog( Star.prototype.__proto__ === Object.prototype ) // truelog( Star.prototype.__proto__ ) // null

在这里插入图片描述

原型链的查找规则

	当访问一个对象的属性(方法)时，首先看这个对象本身有没有该属性，如果没有，就查找它的原型（也就是`__proto__对象原型`，指向的是，`prototype原型对象`）如果还没有，就查找，原型对象的原型(Object的原型对象)依次类推，直到找到Object为止（null）`_proto_对象原型`的意义：在于为对象的查找机制提供一个方向，或者说一条路线，但是它是一个非标准属性，因此实际开发中，不可以使用这个属性，它只是内部指向原型对象prototype

可以通过原型对象，为JavaScript的（原来的）内置对象，进行扩展自定义的方法

如下：通过数组的原型对象，添加求和的方法

	Array.prototype.sum = function(){console.log(this) // 指向它的调用者let sum = 0for(let i=0; i<this.length; i++){sum += this[i]}return sum}let arr = [1, 2, 3] // let arr = new Array(1,2,3)console.log(arr.sum()) // 6

constructor 指回原来的原型对象


// 定义一个构造函数Starfunction Star(uname, age) {this.uname = unamethis.age = age}Star.prototype.sing = function () {console.log('唱歌~~')}// 对象.xxx：这样是向对象添加xxx属性，并不会覆盖这个对象Star.prototype.song = function () {console.log("我会唱歌")}Star.prototype.dance = function () {console.log("我会跳舞")}// 对象 = {}：这样是重新给对象赋值，会把原来的对象覆盖掉// 其实这里就是把 构造函数Star 的原型对象prototype 覆盖了，但是并不会影响uname、age在构造函数中定义的属性Star.prototype = {aaa() { console.log("我会唱歌aa") },bbb() { console.log("我会唱歌bbb") },// ....// ....// ....}// 手动用 constructor 指回原来的原型对象Star.prototype = {constructor: Star, // 指回原来的原型对象ccc() { console.log("我会唱歌ccc") },ddd() { console.log("我会唱歌ddd") },// ....// ....// ....}let ldh = new Star('刘德华', 123)console.log('ldh=', ldh) // ldh= Star {uname: '刘德华', age: 123}console.log('ldh.uname=', ldh.uname) // ldh.uname= 刘德华console.log('ldh.age=', ldh.age) // ldh.age= 123// ldh.sing() // Uncaught TypeError: ldh.sing is not a functionldh.song() // Uncaught TypeError: ldh.song is not a function// ldh.aaa() // Uncaught TypeError: ldh.aaa is not a function// ldh.bbb() //  Uncaught TypeError: ldh.bbb is not a functionldh.ccc() // 我会唱歌ccc.ldh.ddd() // 我会唱歌ddd