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

我心飞翔 分类: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
 

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

当创建实例对象时,对于简单的数据类型,直接赋值就可以,对于复杂数据类型,当创建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

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

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)
 

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

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

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

8,原型链

JS中的构造函数、原型、原型链
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的指向不同,一般指向我们的调用者

JS中的构造函数、原型、原型链
改变函数内部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)
 

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

回复

我来回复
  • 暂无回复内容