js进阶笔记之原型，原型链

最新推荐文章于 2025-08-29 16:55:38 发布

诗霖雪

最新推荐文章于 2025-08-29 16:55:38 发布

阅读量839

点赞数 5

CC 4.0 BY-SA版权

分类专栏： js笔记文章标签：笔记 javascript 前端

本文链接：https://blog.csdn.net/m0_56713342/article/details/134534460

js笔记专栏收录该内容

28 篇文章

订阅专栏

本文详细介绍了JavaScript中原型对象的概念、constructor属性的作用、原型链的工作原理、instanceof的检测机制以及原型继承的实现方式，重点讲解了面向对象编程中的封装和共享逻辑的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、原型对象

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候再一个一个的依次调用就可以了。

面向对象是把事务分解成为一个个对象，然后由对象之间分工与合作。

面向过程开发(关注具体实现步骤)

面向对象开发(分析涉及的对象，指挥对象完成）----- 封装、继承、多态

原型为了共享公共的成员 prototype
原型:JS为每个构造函数提供一个属性prototype(原型)，它的值是一个对象,prototype也叫原型对象

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

JavaScript 规定，每一个构造函数都有一个 prototype 属性，指向另一个对象，所以我们也称为原型对象
这个对象可以挂载函数，对象实例化不会多次创建原型上函数，节约内存
我们可以把那些不变的方法，直接定义在 prototype 对象上，这样所有对象的实例就可以共享这些方法。
构造函数和原型对象中的this 都指向实例化的对象

    <script>
      // 面向过程开发(关注具体实现步骤)
      // 面向对象开发(分析涉及的对象，指挥对象完成任务) - 封装、继承、多态
      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)
    </script>

constructor 属性

constructor 属性，原型对象的属性---->原型对象的构造函数

 <script>
      // 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
    </script>

访问成员的查找原则

访问对象成员的原则:先查找自己身上有没有，有的话就使用，没有去原型查找

  <script>
      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)
    </script>

对象原型

对象都会有一个属性__proto__ 指向构造函数的 prototype 原型对象，之所以我们对象可以使用构造函数 prototype

__proto__ 对象原型里面也有一个 constructor属性，指向创建该实例对象的构造函数

三者关系

构造函数原型原型对象

每个对象都有一个_proto_属性（非标准属性->ES6标准属性），指向原型对象，它与[[Prototype]]等价

2、原型链

   对象访问成员的机制

   1、首先查找自身有没有，有就就近原则使用
   2、自身没有该成员，通过_proto_找到原型对象，看原型对象上有没有，有就执行
   3、假如原型对象上也没有，再找原型对象的_proto__，一直找到0bject.prototype
   4、一直找到Object. prototype,找不到就undefined

3、instanceof

typeof 检测数据类型不能精准的检测引用类型
instanceof 实例对象 instanceof 构造函数
判断构造函数的原型对象是不是在实例对象的原型链上

<script>
      //  // 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
    </script>

4、原型继承

继承方式：构造函数继承、原型继承、组合继承、。。。。

   原型继承-----> 儿子的原型指向父实例对象，这样父实例对象的成员就可以实现继承

   缺点：继承的引用类型属性就一份

    <script>
      // 继承
      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)
    </script>