JS中的构造函数、原型、原型链

吐槽君发布于 3年前分类：javascript

JS中的构造函数、原型、原型链

在典型的OOP的语言中(如Java)，都存在类的概念，类就是对象的模板，对象就是类的实例，但在ES6之前，JS并没有类的概念

1,创建对象可以通过三种方式：

1，对象字面量

let obj = {}

2,new Object()

let obj = new Object()

3,自定义构造函数

function person (name, age) {
  this.name = name
  this.age = age
  this.sayName = function () {
    console.log(this.name)
  }
}
let p1 = new person('Jerry', 18)

2,构造函数

构造函数是一种特殊的函数，主要用来初始化对象，即为对象成员变量赋初始值，它总与new一起使用。我们可以把对象中一些公共的属性和方法抽取出来，然后封装到这个函数里面。

使用构造函数时注意：

1，构造函数用于创建某一类对象，其首字母大写

2，构造函数要和new一起使用

new在执行时会做以下4件事：

1，在内存中创建一个新的空对象

2，让this指向这个新的对象

3，执行构造函数里面的代码，给这个新对象添加属性和方法

4，返回这个新对象（所以构造函数里不需要return）

构造函数中可以添加一些成员，可以在构造函数本身上添加，也可以在构造函数内部的this上添加，通过两种方式添加的成员，就分别成为静态成员和实例成员

静态成员：在构造函数本身上添加的成员，只能由构造函数本身来访问
实例成员：在构造函数内部创建的对象成员，只能由实例化的对象来访问

function Person(name, age) {
  this.name = name
  this.age = age
  this.sayName = function () {
    console.log(this.name)
  }
}
// 实例成员就是构造函数内部通过this添加的成员：name、age、sayName就是实例成员，实例成员只能通过实例化的对象来访问
let p1 = new Person('Jerry', 18)
Person.gender = 'male' // 静态成员，在否早函数本身上添加的成员gender就是静态成员
console.log(Person.gender)  //male => 静态成员只能通过构造函数来访问率
console.log(p1.gender)  // undefined => 不能通过对象来访问

3，构造函数的问题

构造函数方法很好用，但是存在浪费内存的问题

function Person(name, age) {
  this.name = name
  this.age = age
  this.sayName = function () {
    console.log(this.name)
  }
}
let p1 = new Person('Jerry', 18)
let p2 = new Person('Jack', 19)
console.log(p1.sayName === p2.sayName) // false

当创建实例对象时，对于简单的数据类型，直接赋值就可以，对于复杂数据类型，当创建p1这个实例对象时，会单独开辟一块空间来存放复杂数据类型sayName这个方法，创建p2对象时，也会开辟一块空间存放sayName方法。开辟了两个空间来存放同一个函数

我们希望所有的对象使用同一个函数，这样比较节省内存，该怎么做呢？

4，构造函数原型prototype

构造函数通过原型分配的函数是所有对象共享的

js规定，每一个构造函数都有一个prototype属性，指向另一个对象。prototype就是一个对象，这个对象的所有属性和方法都会被构造函数所拥有。

function Person(name, age) {
  this.name = name
  this.age = age
}
Person.prototype.sayName = function () {
  console.log(this.name)
}
let p1 = new Person('Jerry', 18)
let p2 = new Person('Jack', 19)
console.log(p1.sayName()) // Jerry
console.log(p2.sayName()) // Jack
console.log(p1.sayName === p2.sayName)  // true
p1.__proto__ === Person.prototype // true

一般情况下，公共的属性定义到构造函数里，公共的方法放在原型对象身上。

原型是什么：一个对象，我们也成为prototype为原型对象

原型的作用是什么：共享方法

5，对象原型proto

对象都会有一个属性__proto__指向构造函数的prototype原型对象，对象可以使用构造函数prototype原型对象的属性和方法，就是因为对象有__proto__原型的存在

__proto__对象原型和原型对象prototype是等价的
__proto__对象原型的意义就在于为对象的查找机制提供一个方向，或者说一条路线，但是他是一个非标准属性，因此实际开发中，不可以使用这个属性，它只是内部指向原型对象prototype

6,constructor构造函数

对象原型(proto)和构造函数(prototype)原型对象里面都有一个属性constructor属性，constructor我们成为构造函数，因为它指构造函数本身

contructor主要用于记录该对象引用于哪个构造函数，它可以让原型对象重新指向原来的构造函数

function Person(name, age) {
  this.name = name
  this.age = age
}
Person.prototype = {
// 如果修改了原来的原型对象，给原型对象赋值的是一个对象，则必须手动利用constructor指回原来的构造函数
  constructor: Person,
  sayName: function () {

  }
}
let p1 = new Person('Jerry', 18)
let p2 = new Person('Jack', 20)
console.log(Person.prototype.constructor)
console.log(p1.__proto__.constructor)

一般情况下，对象的方法都在构造函数的原型对象中设置，如果多个对象的方法，我们可以给原型对象采取对象形式赋值，但是这样就会覆盖构造函数原型对象原来的内容，这样修改后的原型对象constructor就不再指向当前构造函数了。此时，我们可以在修改后的原型对象中，添加一个constructor指向原来的构造函数

7，构造函数、实例、原型对象三者之间的关系

8，原型链

1，只要是对象就有__proto__原型，指向原型对象

2，Person原型对象里面的__proto__原型指向的是Object.prototype

3,Object.prototype原型里的__proto__原型指向为null, 只要是对象，它里面都有一个原型__proto__，它指向的是原型对象prototype,原型对象里也有一个__proto__，它指向的是Object原型对象prototype， Object原型对象里也有一个__proto__,它指向的是null

简单来说就是，每个对象都有一个原型，每一个原型又是一个对象，所以原型又有自己的原型，这样一环扣一环形成一条链，就叫原型链

9，Js的成员查找机制（规则）

1，当访问一个对象的属性(包括方法)时，首先查找这个对象自身有没有该属性

2，如果没有就查找它的原型(也就是__proto__指向的prototype原型对象)

3，如果还没有就查找原型对象的原型(Object的原型对象)

4，依次类推一直找到Object为止(null)

5，__proto__对象原型的意义就在于为对象成员查找机制提供一个方向，或者说一条路线

10，原型对象this指向

构造函数中的this指向实例对象

原型对象里面放的是方法，这个方法里面的this指向的是这个方法的调用者，也就是这个实例对象，调用方式的不同决定了this的指向不同，一般指向我们的调用者

改变函数内部this主席昂，常用的方法：bind()、call()、apply()
1，call()方法：调用一个对象，即调用函数的方式，改变函数的this指向。主要作用实现继承

foo.call(thisArg, arg1,arg2,....)

2,apply()方法：调用一个函数，即调用函数的方式，改变函数的this指向

foo.apply(thisArg, [argArray])

thisArg：在foo函数运行时指定的this值

argArray: 传递的值，必须包含在数组里

返回值就是函数的返回值，因为他就是调用函数

// 利用apply借助于数学内置对象求最大最小值
var arr = [1,20,30,60]
var max = Math.max.apply(Math, arr)
max //  60

3,bind()方法不会调用函数，但是能改变函数内部this指向

foo.bind(thisArg, arg1, arg2,.....)

thisArg: 在foo函数运行时指定的this值

arg1, arg2：传递的其他参数

返回由指定的this值和初始化参数改造的原函数拷贝，即原函数改变this之后产生的新函数

var btn = document.querySelector('button');
btn.onclick = function() {
  this.diabled = true; //这个 this 指向 btn 按钮
  // var that = this;
  setTimeout(function() { //定时器里面的 this 指向的是 window
      // that.disabled = false;
      this.disabled = false;
  }.bind(this), 3000); //这个 this 指向 btn 这个对象
}

总结：

call()经常做继承
apply()经常跟数组有关系
bind()不立即调用函数，如果有的函数我们不需要立即调用，但是又想改变这个函数内部this指向，此时用bind()

11, 内置对象

可以通过原型对象，对原来的内置对象进行扩展自定义的方法，比如给数组增加自定义求偶数和的功能

Array.prototype.sum = function () {
  let sum = 0
  for (let i = 0; i < this.length; i++) {
    sum += this[i]
  }
  return sum
}
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
console.log(arr.sum())
console.log(Array.prototype)

注意: 数组和字符串内置对象不能给原型对象覆盖操作Array.prototype = {}, 只能是Array.prototype.xxx = function (){}的方式。

我来回复

暂无回复内容

JS中的构造函数、原型、原型链