JavaScript面向对象进阶

一、call、apply、bind
（1） call
call：在调用执行函数时，可以修改函数内部this指向，同时给函数传递序列数据

// 对象1
var tom = {
  name: "汤姆",
  eat: function(food1, food2) {
    console.log(this.name + "吃饭了：", food1, food2)
  }
}
// 对象2
var jerry = {
  name: "杰瑞"
}
// 正常调用函数
tom.eat("烤全羊", "小龙虾")
// jerry对象借用tom对象的eat()函数
// call的第一个参数：修改this指向
// call的后面的参数：传递给函数需要实际参数
tom.eat.call(jerry, "烧烤", "扎啤")

Object.prototype.toString.call(null) // [object Null]

（2） apply
apply：在调用执行函数时，修改函数内部this指向，同时传递给函数包装成数组的实际参数

// 对象1
var tom = {
  name: "汤姆",
  eat: function(food1, food2) {
    console.log(this.name + "吃饭了：", food1, food2)
  }
}
// 对象2
var jerry = {
  name: "杰瑞"
}
// 正常调用函数
tom.eat("烤全羊", "小龙虾")
// jerry对象借用tom对象的eat()函数
// apply第一个参数：修改this指向的实际对象
// apply第二个参数：数组，包含了要传递给函数执行的所有数据
tom.eat.apply(jerry, ["大闸蟹", "帝王蟹"])

Math.max.apply(null, [1,3,4,56,7,7,32,2,4]) // 56

（3） bind
bind：在调用执行函数的时候，修改函数内部this指向，并不立即执行函数而是返回了函数的应用；可以让开发人员后续调用执行函数

// 对象1
var tom = {
  name: "汤姆",
  eat: function(food1, food2) {
    console.log(this.name + "吃饭了：", food1, food2)
  }
}
// 对象2
var jerry = {
  name: "杰瑞"
}
// 正常调用函数
tom.eat("烤全羊", "小龙虾")
// jerry对象借用tom对象的eat()函数
// bind第一个参数；修改了this指向的对象
// bind后面的参数：传递给函数需要的实际参数
// 注意：bind不会让函数立即执行，返回函数声明的引用，让开发人员可以延迟执行函数
// var fn = tom.eat.bind(jerry, "小龙虾", "啤酒")
// fn()
tom.eat.bind(jerry, "小龙虾", "啤酒")()

(4)call、apply、bind函数的区别
call/apply/bind都是辅助函数，可以用来修改正在执行的函数内部this指向

call修改this指向，通过数据序列传递给函数实际参数，如tom.eat.call(jerry, '数据a', '数据b')

apply修改this指向，通过数组方式传递个函数实际参数，如tom.eat.apply(jerry, ['数据a', '数据b'])
bind修改this指向，通过数据序列方式传递给函数实际参数，同时返回函数的声明，让开发人员可以延迟或者立即调用，扩展了使用范围，如：tom.eat.bind(jerry, '数据a', '数据b')()
二、面向对象进阶
（1） 面向对象
面向对象包含三大特征：

• 封装：将代码中的零散的数据统一管理起来，对数据的保护性和安全性得到了提升
• 继承：通过类型和类型之间的继承/关联关系，可以让类型中代码的复用性得到提升
• 多态：通过对象在不同场景中的数据类型的体现，可以让同一个对象满足多种应用场景，对功能的扩展性较好
  （2） 封装
  开发一个博客网站，需要处理文章数据，原始的文章数据管理方式：
• 表示一个文章对象，使用到了多个变量
• 如果描述多个文章对象，对于文章数据的维护就会变得非常繁琐

var title = "标题"
var content = "文章内容"
var publish = new Date() // 发表时间
var read_cnt = 0    // 浏览次数
var liked_cnt = 0   // 点赞次数
var collect_cnt = 0 // 收藏次数

面向对象中，我们可以通过构造函数(声明类型)的方式对需要的数据进行封装管理，方便后期对文章对象数据的使用

function Article(title, content, publish, read_cnt, liked_cnt, collect_cnt) {
  this.title = title
  this.content = content
  this.publish = publish
  this.read_cnt =read_cnt
  this.liked_cnt = liked_cnt
  this.collect_cnt = collect_cnt
}
// 创建一个新的文章
var article = new Article('标题', '内容', new Date(), 0, 0, 0)
// 需要再发表一篇文章
var article2 = new Article('标题2', '内容2', new Date(), 0, 0, 0)
// 将文章数据通过构造函数封装起来，方便使用和维护

(3)继承

// 1、创建两个对象
var tom = new Object()
tom.name = "汤姆"
tom.play = function() {
  console.log(this.name, "正在游戏中...")
}
var jerry = new Object()
jerry.name = "杰瑞"
// 2、使用对象的属性和方法
// console.log(tom.name)
// console.log(jerry.name)
// tom.play()
// jerry.play()
// 3、如果想让一个数据或者函数，被当前类型所有对象使用
// 可以将属性或者函数，挂载到类型的原型对象上
// 通过Object创建的对象，都可以访问原型上的数据和方法
Object.prototype.maxAge = 120
Object.prototype.study = function() {
  console.log("goodgoodsstudy daydayup")
}
console.log(tom.name, tom.maxAge)
console.log(jerry.name, jerry.maxAge)
tom.study()
jerry.study()
// -------------------------------
// 4、构造函数创建对象
function Student(name, age) {
  this.name = name // 当前对象的成员属性，独立属性
  this.age = age
}
// 原型对象上挂载公共数据
Student.prototype.classRoom = "1701教室"
Student.prototype.study =  function() {
  console.log("..............")
}
var shuke = new Student("舒克", 28)
var beita = new Student("贝塔", 22)
console.log(shuke.name, shuke.age, shuke.classRoom)
console.log(beita.name, beita.age, beita.classRoom)

（4） 原型继承
原型继承，基于原型对象的继承，子类和父类在原型链上就存在继承关系；存在的问题是子类在创建对象时无法直接修改父类的属性数据，必须在创建的对象上通过访问属性的方式进行修改，让编码变得复杂；开发中一般很少独立使用

function Person() {}
function Student() {}
// 原型继承
Student.prototype = new Person()

（5） 冒充继承
冒充继承，基于call()辅助函数修改this指向的功能，在子类中通过调用父类构造函数的call()方法，完成子类可以使用父类构造函数内部属性和方法的使用；存在的问题是首先在原型链上没有真实继承关系，所以子类无法继承父类在原型对象上的数据和函数

function Person(name) {...}
function Student(name, age) {
    // 冒充继承，可以直接修改父类属性
Person.call(this, name)
this.age = age
}

（6） 组合继承
组合继承，结合了原型继承和冒充继承，通过原型继承让子类可以使用父类原型对象上的属性和函数，通过冒充继承可以让子类直接访问父类属性，优化操作语法；存在的问题是两种继承方式都访问了父类的构造函数，继承过程中造成父类构造函数的多次调用存在一定的性能问题；如果性能没有太高要求的情况下，可以通过组合继承的方式进行实现

function Person(name) {...}
function Student(name, age) {
// 冒充继承
Person.call(this, name)
this.age = age
}
// 原型继承
Student.prototype = new Person('')

（7） 寄生组合继承
寄生组合继承，对组合继承的一种升级，将父类原型对象进行了复制得到一个空对象，子类在冒充继承的继承上，实现原型继承时继承这个空对象，就不需要让父类的构造函数再次调用，这个空对象的创建和调用性能消耗较低，对性能上有一定的优化提升；项目中如果出现了对继承关系的频繁使用，建议可以将寄生组合继承进行封装使用，优化项目性能

function Person(name) {...}
function Student(name, age) {
// 冒充继承
Person.call(this, name)
this.age = age
}
// 寄生函数
function inherit(Parent, Child) {
var Temp = function() {} // 寄生构造函数|空函数
Temp.prototype = Parent.prototype   // 复制 原型对象
Child.prototype = new Temp()        // 原型继承(空构造函数，性能优化)
Child.prototype.constructor = Child  // 指定自己构造函数
}
// 寄生继承：让Student继承自Parent类型
inherit(Person, Student)

（8） 多态
多态：描述了一个对象在使用过程中状态和行为的变化；一般开发中慢慢体验！

类比生活：状态的改变，tom在公司-员工、回家到儿子-爸爸、到父亲-儿子，这样角色状态的变化，就是一种多态

行为的改变，交通工具有一个移动的行为，自行车移动-骑行行为、公交车移动-驾驶行为、飞机移动-飞行行为