Prototype原型对象

1、prototype原型对象

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

我们可以把那些不变的方法定义在prototype对象上,其实所有对象的实例就可以共享这些方法。

话不多说,上代码。

  <script>
    function Person(name,age){
      this.name=name
      this.age=age
      this.hobby=function(){
        console.log("唱歌")
      }
    }
    var xm=new Person('小明','10')
    var xh=new Person('小红','12')
    console.log(xm.hobby===xh.hobby)  //输出false    
    xm.hobby()//唱歌
    xh.hobby()//唱歌
  </script>

es6之前是把方法写在构造函数里面,每个对象都会去开辟一个函数的内存空间,所以xm.hobby===xh.hobby比较会返回false,如果有多个对象,这样做会存在浪费内存空间,下面建议用prototype对象

  <script>
    function Person(name,age){
      this.name=name
      this.age=age
    }
    Person.prototype.hobby=function(){
        console.log("唱歌")
      }
    var xm=new Person('小明','10')
    var xh=new Person('小红','12')
    console.log(xm.hobby===xh.hobby)  //输出true
    xm.hobby()//唱歌
    xh.hobby()//唱歌
  </script>

此时hobby为同一个方法,所以xm.hobby===xh.hobby返回true

一般来说,公共属性定义在构造函数里面,公共方法定义在原型对象身上

2、_proto_对象原型

其实在每个对象中会有一个_proto_属性指向我们的构造函数的原型对象prototype

<script>
    function Person(name,age){
      this.name=name
      this.age=age
    }
    Person.prototype.hobby=function(){
        console.log("唱歌")
      }
    var xm=new Person('小明','10')
    var xh=new Person('小红','12')
    console.log(xm._proto_===Person.prototype)  //输出true
  </script>

hobby()方法的查找规则:首先看看xm对象身上是否有hobby方法,如果有就执行它,如果没有,因为有_proto_的存在,就会去构造函数原型对象prototype身上去查找。

3、原型constructor构造函数

 <script>
    function Person(name,age){
      this.name=name
      this.age=age
    }
    Person.prototype={//如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用constructor指回原来的构造函数。
      constructor:Star,
      hobby1:function(){
          console.log("唱歌")
        }
      hobby2:function(){
          console.log("跳舞")
        }
    }
    var xm=new Person('小明','10')
    var xh=new Person('小红','12')
    console.log(xm.prototype.constructor)
    console.log(Star.prototype.constructor)  
  </script>

查看更多内容

<think>嗯,用户想了解JavaScript中的prototype原型概念,以及它在面向对象编程中的用法。之前我参考了站内三篇关于原型对象的引用资料,它们都强调了原型链机制和共享属性的特点。用户可能是个前端开发者,正在学习JS核心概念。从ta提问的方式看,ta已经知道prototype和面向对象有关联,但需要系统性的梳理。特别要注意用户上次其实是在确认引用资料的有效性,这次才是真正的概念咨询。需要重点讲清楚这几个维度:原型对象的存在意义(解决什么问题)、函数prototype属性和实例__proto__的区别、原型链的查找机制、构造函数模式的应用示例。引用资料里提到Object.getPrototypeOf()这些方法很适合作为补充说明。考虑到用户是概念学习,第一优先级是把原型的存在价值讲透——为什么JS需要原型而不是用类继承。那个Foo构造函数的例子很经典,准备展示prototype如何实现所有实例共享sayHi方法。还要注意区分用户可能的混淆点:prototype属性本身是个普通对象,它被所有实例通过__proto__指向。最后面向实践的部分,用户可能需要知道如何应用原型做继承。会简要带过组合继承的例子,但避免引入太多新概念以免偏离主线。结尾的验证题可以检测用户对引用类型的理解深度。</think> 好的,让我们深入理解 JavaScript 中的 `prototype`(原型)概念及其在面向对象编程(OOP)中的应用。这是 JavaScript 核心且独特的特性。 **核心概念:`prototype` 是什么?** 1. **`prototype` 是一个对象:** 在 JavaScript 中,**每个函数**(除了箭头函数和一些内置函数)在创建时都会自动获得一个名为 `prototype` 的属性。这个属性指向一个**对象**(我们称之为原型对象)。 * 这个 `prototype` 对象本身也是一个普通的 JavaScript 对象。 * 它的**核心目的**是**让由该函数(作为构造函数)创建的所有对象实例共享方法和属性**。 * *示例:* ```javascript function Foo() {} // 声明一个函数(也可以作为构造函数使用) // 函数 Foo 自动获得一个 prototype 属性,指向一个对象 console.log(typeof Foo.prototype); // 'object' (函数调用) console.log(Foo.prototype); // 输出: {} (一个空对象) ``` [^1][^2] 2. **实例与 `[[Prototype]]` (或 `__proto__`):** 当你使用 `new` 关键字调用一个函数(此时它是一个构造函数)创建一个实例时,会发生一件关键的事情: * JavaScript 会在内部为新创建的实例对象(我们称之为 `instance`)设置一个**内部链接**,通常标记为 `[[Prototype]]`(在 ES6 规范中)。许多浏览器环境提供了非标准的 `__proto__` 属性来访问这个内部链接。 * **这个 `[[Prototype]]` 链接指向该实例的构造函数的 `prototype` 对象。** * *示例:* ```javascript const myFoo = new Foo(); // 用 new 调用 Foo,创建实例 myFoo // myFoo 的内部 [[Prototype]] 指向了 Foo.prototype console.log(Object.getPrototypeOf(myFoo) === Foo.prototype); // true (标准方式) console.log(myFoo.__proto__ === Foo.prototype); // true (非标准,但普遍支持) ``` [^3][^1] 3. **原型链(Prototype Chain)与属性查找:** 这是原型机制的**核心**。当你尝试访问一个对象的属性(比如 `obj.property`)或方法(比如 `obj.method()`)时: 1. JavaScript 引擎首先在**对象实例本身**上查找该属性(在其自有属性中查找)。 2. 如果在实例本身没找到,引擎就会沿着该实例的 `[[Prototype]]` 链接**向上查找**(去它的构造函数的 `prototype` 对象上找)。 3. 如果在该 `prototype` 对象上还没找到,引擎会继续沿着 *那个对象* 的 `[[Prototype]]` 链接向上查找(通常是 `Object.prototype`),直到到达原型链的末端(`null`)。 4. 如果直到 `null` 还没找到,则返回 `undefined`。 * *示例:* ```javascript function Foo() { this.instanceProp = "I'm on the instance"; // 实例自身的属性 } // 在 Foo 的 prototype 对象上添加一个共享的方法 Foo.prototype.sharedMethod = function() { return "I'm shared by all instances via the prototype"; }; const foo1 = new Foo(); const foo2 = new Foo(); // 访问实例自有属性 console.log(foo1.instanceProp); // "I'm on the instance" (来自实例自身) // 访问共享方法 - 在实例自身找不到 => 沿着 [[Prototype]] 到 Foo.prototype 上找到 console.log(foo1.sharedMethod()); // "I'm shared..." (来自原型) console.log(foo2.sharedMethod()); // "I'm shared..." (也来自原型) // 证明 foo1 自身没有 sharedMethod 属性 console.log(foo1.hasOwnProperty('sharedMethod')); // false ``` [^2][^1][^3] **`prototype` 在 JavaScript 面向对象编程(OOP)中的用法** JavaScript 利用原型链来实现类似传统基于类的语言中的“继承”和“共享行为”的概念。 1. **属性/方法共享:** 如上例所示,这是最基础也最重要的用法。将通用的属性和方法定义在构造函数的 `prototype` 对象上,可以让所有实例通过原型链访问它们,**避免了在每个实例中重复创建副本,节省内存,提升效率**。 2. **模拟类继承:** 通过设置子类构造函数的 `prototype` 为父类的一个实例(或直接使用 `Object.create()`),可以建立原型链继承关系。 * 假设 `Child` 需要继承 `Parent`: ```javascript // 父类构造函数 function Parent(name) { this.name = name; } Parent.prototype.greet = function() { console.log(`Hello, I'm ${this.name}`); }; // 子类构造函数 function Child(name, toy) { Parent.call(this, name); // 1. 调用父构造函数,初始化自有属性(类似 super) this.toy = toy; } // **关键步骤:设置 Child.prototype 的原型链指向 Parent.prototype** // 方法1:使用 Object.create - 推荐(ES5+) Child.prototype = Object.create(Parent.prototype); // 方法2:使用过时的__proto__ (不推荐) // Child.prototype.__proto__ = Parent.prototype; // 修复构造函数指针(此时 Child.prototype.constructor 应该是 Child,但被设置为 Parent) Child.prototype.constructor = Child; // 在子类原型上添加子类特有方法 Child.prototype.play = function() { console.log(`Playing with ${this.toy}`); }; // 测试 const child = new Child('Billy', 'Ball'); child.greet(); // "Hello, I'm Billy" (从 Parent.prototype 继承) child.play(); // "Playing with Ball" (Child.prototype 上) ``` [^1][^2] `Object.create()` 是建立原型继承链的标准且可靠方法。 3. **理解内置对象的构造:** JavaScript 的所有内置对象(如 `Array`, `Object`, `Function`, `String`, `Date` 等)都使用了原型机制。例如: * 当你创建一个数组 `const arr = [1, 2, 3]` 时,相当于 `new Array(1, 2, 3)`。 * `arr` 的 `[[Prototype]]` 指向 `Array.prototype`。这就是为什么所有数组实例都能使用 `push()`, `pop()`, `map()` 等方法的原因——它们都定义在 `Array.prototype` 上。 * `Array.prototype` 自身的 `[[Prototype]]` 又指向 `Object.prototype`,这就是为什么数组实例也能使用 `toString()` 或 `hasOwnProperty()` 的原因(虽然数组通常重写了 `toString` 的行为)。 * `Object.prototype` 是大多数对象原型链的终点,它的 `[[Prototype]]` 是 `null`。它提供了 `toString()`, `valueOf()`, `hasOwnProperty()` 等最基础的方法。 [^3][^1] 4. **扩展内置对象(谨慎使用):** 理论上,你可以给内置对象的原型添加自定义方法(如 `Array.prototype.myCustomMethod = ...`)。但**这种做法通常非常不推荐**,因为它可能污染全局命名空间、引发命名冲突、影响兼容性、导致代码难以维护。在极少数需要时(如为非常老的环境提供 polyfill),应极其小心并充分兼容处理。 **总结关键点** * **`prototype` 属于构造函数**:是一个属性,指向一个对象原型对象)。 * **`[[Prototype]]` 或 `__proto__` 属于实例对象**:是一个内部链接(可通过 `Object.getPrototypeOf()` 读取/`Object.setPrototypeOf()` 设置),指向**创建该实例的构造函数的 `prototype` 对象**。 * **原型链**:是 `[[Prototype]]` 指针形成的链条(`实例 -> 构造函数.prototype -> ... -> Object.prototype -> null`)。 * **查找规则**:查找属性/方法时,沿着原型链从实例自身向上查找。 * **核心作用**:**实现高效的方法和属性共享**,是 JavaScript 实现继承和多态的基石。 * **面向对象的意义**:使 JavaScript 能够以一种独特但功能强大的方式实现基于原型的面向对象编程模式,支持继承、代码复用和对象行为的扩展。 理解 `prototype`、`[[Prototype]]` 和原型链是深入掌握 JavaScript 的关键一步。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

地裡小白菜

如果可以的话,老铁们打个赏。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值