目录
面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候再一个一个的依次调用就可以了。
面向对象是把事务分解成为一个个对象,然后由对象之间分工与合作。
面向过程开发(关注具体实现步骤)
面向对象开发(分析涉及的对象,指挥对象完成)----- 封装、继承、多态
原型为了共享公共的成员 prototype
原型:JS为每个构造函数提供一个属性prototype(原型),它的值是一个对象,prototype也叫原型对象
构造函数通过原型分配的函数是所有对象所 共享的。
JavaScript 规定,每一个构造函数都有一个 prototype 属性,指向另一个对象,所以我们也称为原型对象
这个对象可以挂载函数,对象实例化不会多次创建原型上函数,节约内存
我们可以把那些不变的方法,直接定义在 prototype 对象上,这样所有对象的实例就可以共享这些方法。
构造函数和原型对象中的this 都指向 实例化的对象
-
- // 面向过程开发(关注具体实现步骤)
- // 面向对象开发(分析涉及的对象,指挥对象完成任务) - 封装、继承、多态
- function Cat(name, age) {
- this.name = name
- this.age = age
- // 给实例添加eat方法,将来每一个对象都有这个eat方法,造成空间浪费
- // this.eat = function () {
- // console.log('猫吃老鼠')
- // }
- }
-
- // 给Cat原型添加公共的属性或方法,这样所有new出来的实例都可以访问
- Cat.prototype.eat = function () {
- console.log('猫吃老鼠')
- }
-
- Cat.prototype.nation = 'china'
-
- const cat1 = new Cat('加菲猫', 3) // {name: '',age: ,eat}
- const cat2 = new Cat('银渐层', 4) // {name: '',age: ,eat() {}}
- console.log(cat1.age)
- console.log(cat1.nation)
- cat1.eat()
- cat2.eat()
- console.log(cat1.eat === cat2.eat) // true
-
- // 原型为了共享公共的成员 prototype
- // 原型: JS为每个构造函数提供一个属性prototype(原型),它的值是一个对象,prototype也叫原型对象
- console.log(Cat.prototype)
- console.log(Cat.prototype.constructor === Cat) // true
-
- // function f() {}
- // console.log(f.prototype)
-
constructor 属性,原型对象的属性---->原型对象的构造函数
-
- // constructor属性,原型对象的默认属性->原型对象的构造函数
- // Array.prototype.constructor === Array
- console.log(Array.prototype.constructor === Array) // true
- const arr = [] // new Object()
- console.log(arr.constructor === Array) // true
- console.log(arr.constructor === Array.prototype.constructor) // true
- console.log(arr.constructor) // 访问arr数组对象的constructor,会到原型去访问
-
- console.log(Object.prototype.constructor) // Object ;
- const obj = {}
- console.log(obj.constructor) // Object
- const obj2 = { a: 1 }
- console.log(obj.constructor === obj2.constructor) // true
-
访问成员的查找原则
访问对象成员的原则:先查找自己身上有没有,有的话就使用,没有去原型查找
-
- function Cat(name, age) {
- // this.name = name
- this.age = age
- }
-
- Cat.prototype.eat = function () {
- console.log('猫抓老鼠')
- }
-
- Cat.prototype.name = '亚洲猫王'
- const cat = new Cat('小花', 3) // {name: '小花', age: 3}
- // 访问对象成员的原则: 先查找自己身上有没有,有的话就使用,没有去原型查找
- console.log(cat.name)
-
对象都会有一个属性__proto__ 指向构造函数的 prototype 原型对象,之所以我们对象可以使用构造函数 prototype
__proto__ 对象原型里面也有一个 constructor属性,指向创建该实例对象的构造函数
三者关系
构造函数 原型 原型对象
每个对象都有一个_proto_属性(非标准属性->ES6标准属性),指向原型对象,它与[[Prototype]]等价
对象访问成员的机制
1、首先查找自身有没有,有就就近原则使用
2、自身没有该成员,通过_proto_找到原型对象,看原型对象上有没有,有就执行
3、假如原型对象上也没有,再找原型对象的_proto__,一直找到0bject.prototype
4、一直找到Object. prototype,找不到就undefined
typeof 检测数据类型 不能精准的检测引用类型
instanceof 实例对象 instanceof 构造函数
判断构造函数的原型对象是不是在实例对象的原型链上
- // // typeof 检测数据类型
- // string number boolean
- console.log(typeof []) //'object'
- console.log(typeof {}) // 'object'
- console.log(Array.prototype) // 数组原型也提供toString(),自己原型的方法是拼接字符串
- // console.log([1, 2, 3].toString()) // [object Array]
- console.log({}.toString()) // [object Object]
- console.log(Object.prototype.toString.call([])) // call调用函数
-
- // instanceof 实例对象 instanceof 构造函数
- // 判断构造函数的原型对象是不是在实例对象的原型链上
- console.log([] instanceof Array) // true
- console.log([] instanceof Object) // true
- console.log({} instanceof Array) // false
-
继承方式:构造函数继承、原型继承、组合继承、。。。。
原型继承-----> 儿子的原型指向父实例对象,这样父实例对象的成员就可以实现继承
缺点:继承的引用类型属性就一份
-
- // 继承
- const person = {
- ears: 2,
- eat: function () {
- console.log('eating')
- },
- hobby: ['reading', 'running'],
- }
-
- function Student(name, age) {
- this.name = name
- this.age = age
- }
-
- // 让Student的原型指向person
- Student.prototype = person
- Student.prototype.constructor = Student
- Student.prototype.study = function () {
- console.log('study hard!!!')
- }
-
- /*
- {
- ears, eat, hobby,constructor, study
- }
- */
- const s1 = new Student('zs', 16)
- const s2 = new Student('zw', 24)
- console.log(s1.ears)
- s1.study()
- s1.eat()
- s2.hobby.push('coding')
- console.log(s2.hobby)
- console.log(s1.hobby)
- console.log(person)
-