JS进阶-原型

最新推荐文章于 2024-08-04 16:33:59 发布
最新推荐文章于 2024-08-04 16:33:59 发布
阅读量1.1k 收藏 7
点赞数 20
分类专栏： JS进阶 文章标签： javascript 原型模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64105917/article/details/140336019
版权

学习目标：

  • 掌握原型

学习内容：

  1. 原型
  2. constructor属性
  3. 对象原型
  4. 原型继承
  5. 原型链
  6. 综合案例

原型：

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

JavaScript规定，每一个构造函数都有一个prototype属性，指向另一个对象，所以我们也称为原型对象。

这个对象可以挂载函数，对象实例化不会多次创建原型上函数，节约内存。

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

构造函数和原型对象中的this都指向 实例化的对象。

在这里插入图片描述

<title>原型</title>
</head>

<body>
  <script>
    // 构造函数  公共的属性和方法 封装到 Star 构造函数里面了
    // 1.公共的属性写到 构造函数里面
    function Star(uname, age) {
      this.uname = uname
      this.age = age
      // this.sing = function () {
      //   console.log('唱歌')
      // }
    }
    // 2. 公共的方法写到原型对象身上   节约了内存
    Star.prototype.sing = function () {
      console.log('唱歌')
    }
    const ldh = new Star('刘德华', 55)
    const zxy = new Star('张学友', 58)
    ldh.sing() //调用
    zxy.sing() //调用
    // console.log(ldh === zxy)  // false
    console.log(ldh.sing === zxy.sing)

    // console.dir(Star.prototype)
  </script>

</body>

在这里插入图片描述

  • 小结
  1. 原型是什么？

一个对象，我们也称为prototype为原型对象。

  1. 原型的作用是什么？

共享方法。
可以把那些不变的方法，直接定义在prototype对象上。

  1. 构造函数和原型里面的this指向谁？

实例化的对象。

  • 原型-this指向

构造函数和原型对象中的this指向 实例化的对象。

<title>构造函数和原型的this指向</title>
</head>

<body>
  <script>
    let that
    function Star(uname) {
      // that = this
      // console.log(this)
      this.uname = uname
    }
    // 原型对象里面的函数this指向的还是 实例对象 ldh
    Star.prototype.sing = function () {
      that = this
      console.log('唱歌')
    }
    // 实例对象 ldh   
    // 构造函数里面的 this 就是  实例对象  ldh
    const ldh = new Star('刘德华')
    ldh.sing()
    console.log(that === ldh)  //true
  </script>

</body>
  • 练习
 <title>练习-给数组扩展方法</title>
</head>

<body>
  <script>
    //自己定义 数组扩展方法 求和  和  最大值
    //1.我们定义的这个方法，任何一个数组实例对象都可以使用
    //2.自定义的方法写到 数组.prototype 身上
    //1.最大值
    const arr = [1, 2, 3]
    Array.prototype.max = function () {
      //展开运算符
      return Math.max(...this)
      //原型函数里面的this指向谁？  实例对象  arr
    }

    //2.最小值
    Array.prototype.min = function () {
      //展开运算符
      return Math.min(...this)
      //原型函数里面的this指向谁？  实例对象  arr
    }
    console.log(arr.max())
    console.log([2, 5, 9].max())
    console.log(arr.min())

    // const arr = new Array(1,2)
    // console.log(arr)

    //3.求和方法
    Array.prototype.sum = function () {
      return this.reduce((prev, item) => prev + item, 0)
    }
    console.log([1, 2, 3].sum())
    console.log([11, 21, 31].sum())

  </script>

</body>

constructor属性：

每个原型对象里面都有个constructor属性（constructor 构造函数）。

作用：该属性指向该原型对象的构造函数，简单理解，就是指向我的爸爸，我是有爸爸的孩子。
在这里插入图片描述

  • 使用场景

如果有多个对象的方法，我们可以给原型对象采取对象形式赋值。

但是这样就会覆盖构造函数原型对象原来的内容，这样修改后的原型对象constructor就不再指向当前构造函数了。

此时，我们可以在修改后的原型对象中，添加一个constructor指向原来的构造函数。

 <title>constructor属性</title>
</head>
<body>
  <script>
      // constructor  单词 构造函数
 
    // Star.prototype.sing = function () {
    //   console.log('唱歌')
    // }
    // Star.prototype.dance = function () {
    //   console.log('跳舞')
    // }
    function Star() {
    }
    // console.log(Star.prototype)
    Star.prototype = {
      // 从新指回创造这个原型对象的 构造函数
      constructor: Star,
      sing: function () {
        console.log('唱歌')
      },
      dance: function () {
        console.log('跳舞')
      },
    }
    console.log(Star.prototype)
    // console.log(Star.prototype.constructor)
 
    // const ldh = new Star()
    // console.log(Star.prototype.constructor === Star) //true
  </script>
  
</body>
  • 小结
  1. constructor 属性的作用是什么？

指向该原型对象的构造函数。

对象原型：

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

原型对象的属性和方法，就是因为对象有_proto_原型的存在。
在这里插入图片描述

  • 注意
  1. _proto_是JS非标准属性。
  2. [[_proto_]]和_proto_意义相同。
  3. 用来表明当前实例对象指向哪个原型对象prototype。
  4. _proto_对象原型里面也有一个constructor属性，指向创建该实例对象的构造函数。
 <title>对象原型</title>
</head>

<body>
  <script>
    function Star() {

    }
    const ldh = new Star()
    // 对象原型__proto__ 指向 改构造函数的原型对象
    console.log(ldh.__proto__)
    // console.log(ldh.__proto__ === Star.prototype)  //true
    // 对象原型里面有constructor 指向 构造函数 Star
    console.log(ldh.__proto__.constructor === Star)  //true
  </script>

</body>
  • 小结
  1. prototype是什么？哪里来的？

原型（原型对象）。
构造函数都自动有原型。

  1. constructor属性在哪里？作用干啥的？

prototype原型和对象原型_proto_里面都有。
都指向创建实例对象/原型的构造函数。

  1. _proto_属性在哪里？指向谁？

在实例对象里面。
指向原型prototype。

  • 练习
function Star() {

    }
    const ldh = new Star()
    // 对象原型__proto__ 指向 改构造函数的原型对象
    console.log(ldh.__proto__)
    // console.log(ldh.__proto__ === Star.prototype)  //true
    // 对象原型里面有constructor 指向 构造函数 Star
    console.log(ldh.__proto__.constructor === Star)  //true

在这里插入图片描述

原型继承：

继续是面向对象编程的另一个特征，通过继承进一步提升代码封装的程度，JavaScript中大多是借助原型对象实现继承的特性。

<title>原型继承</title>
</head>

<body>
  <script>
    //继续抽取  公共的部分放到原型上
    // const Person = {
    //   eyes: 2,
    //   head: 1
    // }
    //构造函数 new出来的对象  结构一样，但是对象不一样
    function Person() {
      this.eyes = 2
      this.head = 1
    }


    //女人  构造函数  继承  想要继承Person
    function Woman() {
      this.eyes = 2
      this.head = 1
    }
    //Woman 通过原型来继承 Person
    // 父构造函数（父类）   子构造函数（子类）
    // 子类的原型 =  new 父类  
    Woman.prototype = new Person()  // {eyes: 2, head: 1} 
    //指回原来的构造函数
    Woman.prototype.constructor = Woman

    //给女人添加一个方法  来姨妈
    Woman.prototype.yuejing = function () {
      console.log('来姨妈')
    }
    const red = new Woman()
    console.log(red)
    // console.log(Woman.prototype)



    //男人 构造函数  继承  想要继承Person
    function Man() {
      this.eyes = 2
      this.head = 1
    }
    //Man 通过原型来继承 Person
    Man.prototype = new Person()
    //指回原来的构造函数
    Man.prototype.constructor = Man
    const blue = new Man()
    console.log(blue)
    // console.log(Man.prototype)
  </script>

</body>

原型链：

基于原型对象的继承使得不同构造函数的原型对象关联在一起，并且这种关联的关系是一种链状的结构，我们将原型对象的链状结构关系称为原型链。
在这里插入图片描述

<title>原型链</title>
</head>

<body>
  <script>
    // function Objetc() {}
    console.log(Object.prototype)
    console.log(Object.prototype.__proto__) //null

    function Person() {

    }
    const ldh = new Person()
    // console.log(ldh.__proto__ === Person.prototype) //true
    // console.log(Person.prototype.__proto__ === Object.prototype)  //true
    console.log(ldh instanceof Person) //true
    console.log(ldh instanceof Object) //true
    console.log(ldh instanceof Array)  //false
    console.log([1, 2, 3] instanceof Array) //true
    console.log(Array instanceof Object) //true
  </script>

</body>

在这里插入图片描述

  • 原型链-查找规则
  1. 当访问一个对象的属性（包括方法）时，首先查找这个对象自身有没有该属性。
  2. 如果没有就查找它的原型（也就是__proto__指向的prototype原型对象）。
  3. 如果还没有就查找原型对象的原型（Object的原型对象）。
  4. 依次类推一直找到Object为止（null）。
  5. __proto__对象原型的意义就在于为对象成员查找机制提供一个方向，或者说一条路线。
  6. 可以使用instanceof运算符用于检测构造函数的prototype属性是否出现在某个实例对象的原型链上。

综合案例：

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>综合案例-消息提示对象封装</title>
  <style>
    .modal {
      width: 300px;
      min-height: 100px;
      box-shadow: 0 0 10px rgba(0, 0, 0, 0.2);
      border-radius: 4px;
      position: fixed;
      z-index: 999;
      left: 50%;
      top: 50%;
      transform: translate3d(-50%, -50%, 0);
      background-color: #fff;
    }

    .modal .header {
      line-height: 40px;
      padding: 0 10px;
      position: relative;
      font-size: 20px;
    }

    .modal .header i {
      font-style: normal;
      color: #999;
      position: absolute;
      right: 15px;
      top: -2px;
      cursor: pointer;
    }

    .modal .body {
      text-align: center;
      padding: 10px;
    }

    .modal .footer {
      display: flex;
      justify-content: flex-end;
      padding: 10px;
    }

    .modal .footer a {
      padding: 3px 8px;
      background: #ccc;
      text-decoration: none;
      color: #fff;
      border-radius: 2px;
      margin-right: 10px;
      font-size: 14px;
    }

    .modal .footer a.submit {
      background-color: #369;
    }
  </style>
</head>

<body>
  <button id="delete">删除</button>
  <button id="login">登录</button>

  <!-- <div class="modal">
      <div class="header">温馨提示 <i>x</i></div>
      <div class="body">您没有删除权限操作</div>
    </div> -->
  <script>
    //1.Modal 构造函数封装 - 模态框
    function Modal(title = '', message = '') {
      // console.log(title, message)
      //创建 modal模态框盒子
      //1.1创建div标签
      this.modalBox = document.createElement('div')
      //1.2给div标签添加类名为modal
      this.modalBox.className = 'modal'
      //1.3 modal 盒子内部填充2个div标签并且修改文字内容
      this.modalBox.innerHTML = `
      <div class="modal">
      <div class="header">${title} <i>x</i></div>
      <div class="body">${message}</div>
    </div>
      
      `
      console.log(this.modalBox)


    }

    // new Modal('温馨提示', '您没有删除权限操作')
    // new Modal('友情提示', '您还没有登录呢')

    //2.给构造函数原型对象挂载 open 方法
    Modal.prototype.open = function () {
      //先来判断页面中是否有modal盒子，如果有先删除，否则继续添加
      const box = document.querySelector('.modal')
      box && box.remove()
      //注意这个方法不要用箭头函数
      //把刚才创建的modalBox 显示到页面body中
      document.body.append(this.modalBox)

      //要等着盒子显示出来，就可以绑定点击事件了
      this.modalBox.querySelector('i').addEventListener('click', () => {
        //这个地方需要用到箭头函数
        //这个this指向  实例对象
        this.close()
      })
    }

    //3.给构造函数原型对象挂载 close方法
    Modal.prototype.close = function () {
      this.modalBox.remove()
    }




    //测试一下 点击 删除按钮
    document.querySelector('#delete').addEventListener('click', () => {
      //先调用 Modal 构造函数
      const del = new Modal('温馨的提示', '您没有删除权限操作')
      //实例对象调用open方法
      del.open()
    })

    //测试一下 点击 删除按钮
    document.querySelector('#login').addEventListener('click', () => {
      //先调用 Modal 构造函数
      const login = new Modal('友情的提示', '您还没有登录呢')
      //实例对象调用open方法
      login.open()
    })
  </script>

</body>

</html>
雪碧bibi是我的好大二
关注
专栏目录
JS进阶--原型链
小小鹏的小小博客
06-29 229
作用域和作用域链 全局作用域： 整个JS执行环境是一个全局作用域，在全局声明变量相当于给window添加属性 局部作用域： 函数内部构成一个局部作用域 作用域链： 全局为 0 级链，下面有 1 2 3 4…级 作用域在代码书写完了之后就确定了，与代码执行无关 访问变量时，先在自己的作用域查找，找不到就往上一级找 赋值的时候也是逐级向上找，如果在全局也没找到，则会自动在全局创建...
JavaScript进阶基础-3
12-20
【JavaScript进阶基础-3】 在JavaScript中，进阶基础涉及到很多重要的概念，尤其是面向对象、前后端交互、Cookie以及JSONP。以下是对这些概念的详细解析： **面向对象基础** 面向对象是一种编程范式，它关注的是...
JavaScript - js进阶 - 原型 prototype
Henry_ID的博客
08-23 136
原型 prototype 原型上存放函数 原型解释 原型的单词是 prototype, 原型的这个名字是行业内共同认可的名字。 原型本质是一个对象，理解为 JavaScript 自动帮我们添加的 原型是 JavaScript 自动帮我们在定义构造函数的时候添加的 所有构造函数的实例，共享一个原型 原型上一般是挂载函数 原型 proto 实例的 proto 属性 等于 构造函数的 prototype p1.__proto__ === Person.prototype // true 不过由于不
javascript进阶-1-原型
m0_45080379的博客
07-13 228
1 原型基本概念 Javascript 规定，每一个函数都有一个 prototype`属性，指向另一个对象。 这个对象的所有属性和方法，都会被构造函数的实例继承。 这也就意味着，我们可以把所有对象实例需要共享的属性和方法直接定义在 prototype对象上。 function Person (name, age) { this.name = name ...
js进阶笔记--原型prototype
weixin_63800850的博客
10-18 65
所以在这样的情况下，出现了prototype，可以把prototype理解为一种用来装函数方法的盒子，但是这个prototype是装载到Star这个构造函数身上的。上图是关于Star这个对象的构建，明星是他的实例，但是这样去写构造函数的话，如果有其他实力出现的话，会再一次产生内存去存储另一个实例的sing事件，对于有很多实例出现的情况是几位不友好的。2.面向对象的主要表现形式就是在js里对对象的书写的表现形式是对构造函数的构建。面向对象就是把东西分成几份，每一份都很详细，再把需要的东西拼到一起，组成实体。
JS进阶-对原型链的理解
qq_53593492的博客
09-07 51
本质：子类的方法查找规则
前端进阶 - 原型
zhqi9277的博客
07-27 76
原型在 JavaScript 中是一个非常重要的概念，它为对象和继承提供了基础。在实际应用中，我们可以看到 jQuery 和 Zepto 这样的库广泛使用原型，通过在原型上添加方法和属性，提供了强大的功能和拓展性。在面试中，除了原型的概念，面试官可能会进一步深入询问原型链和继承的相关知识。理解这些概念和应用，可以帮助我们更好地掌握 JavaScript 编程。作的库。它提供了一个入口函数$()，用于选取 DOM 元素，并返回一个 jQuery 对象，该对象包含了选中的 DOM 元素以及一系列实用的方法。
JavaScript - js进阶 - ES5原型继承及创建元素
Henry_ID的博客
08-28 103
ES5原型继承 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge" /> <meta name="viewport" content="width=device-width, initial-scale=1
【js进阶】-原型/原型链
Ronychen的博客
12-21 720
一、构造函数创建对象 我们先使用构造函数创建一个对象，先来认识下构造函数 function Person() { } var person1 = new Person(); person1.name = '张三'; console.log(person1.name) // 张三 在这个例子中，Person 就是一个构造函数，我们使用 new 创建了一个实例对象 person1 prototype 每个函数都有一个 prototype 属性，它指向的是一个对象，既然它是一个对象，我们就手动给上面例子中的Pe
JS进阶系列 --- 原型
帕尼尼的博客
02-28 994
非常感谢你能看到这篇文章，也希望你能继续看下去…… 何为原型 以一段简单的代码为例: function Dog(param){ this.name = param.name; this.age = param.age; this.bark = function(){ console.log("汪汪汪!!!"); }; } var wc ...
js进阶知识-知识点-demo演示
09-14
本文将重点探讨“js进阶知识-知识点-demo演示”中的关键概念，包括Promise，以及其他相关的编程技巧。 首先，我们来讨论Promise。Promise是JavaScript中处理异步操作的重要工具，它解决了回调地狱的问题，使代码更...
js基础-高级-进阶学习
12-20
"js基础-高级-进阶学习"这个主题涵盖了JavaScript的基础语法、高级特性、jQuery库的应用，以及Bootstrap和Swiper这两个流行的框架。下面我们将逐一深入探讨这些知识点。 1. **JavaScript基础语法**： JavaScript是...
JavaScript经典进阶系列-Effective JavaScript英文原版
04-14
在JavaScript的世界里，进阶学习意味着不仅要掌握基础语法，还要理解其动态类型、原型链、闭包、异步编程等复杂概念。本书通过68个条目，将这些关键知识点逐一展开，帮助读者深入理解JavaScript的核心机制。 1. **...
JavaScript进阶（四）原型与原型链用法实例分析
10-15
JavaScript中的原型和原型链是理解JavaScript面向对象编程的关键概念。原型是JavaScript中实现对象继承的一种方式，它是一个JavaScript对象，可以存储方法和其他属性，供构造函数创建的实例对象共享和引用。原型对象...
牛客JS题（二十一）数组扁平化
最新发布
不起眼小菜菜的博客
08-04 617
注释很详细，直接上代码……
Vue3中的pinia的使用及组合写法与普通写法的区别
m0_62626838的博客
07-30 257
1、首先pinia可以自己后面按需安装，也可在项目创建时去勾选安装（这里我使用的是项目创建时自动安装的，吃了点亏，忘记这里是组合写法了）按照这个写法是不需要添加pinia核心（state、actions、getters），但需要return！store文件夹中的counter.ts （名字任起）在组件中直接使用即可，如下图。2、自定义安装pinia。3、在组件中使用，如下图。
VUE3自定义指令防止重复点击多次提交
MadSnail00的博客
07-30 330
vue3连续点击按钮重复提交，vue3自定义指令防止重复提交
【分享】前端程序员-技术网站推荐
一位前行者的博客
07-30 955
对于前端开发人员来说，以下是一些推荐的技术网站，这些网站提供了丰富的资源和知识，可以帮助你提升前端开发技能：收集一些 、、 的网站 vite 官方中文文档 element-plus 官方中文文档 pinia 官方中文文档 vue-router 官方中文文档 Tailwind CSS 官方文档 vitest 官方中文文档 es6 中文文档 axios 官方中文文档 vxetable 官方中文文档 lodash 中文文档 echarts 官方中文文档 animat
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值