精华内容
下载资源
问答
  • 2010-10-09 15:50:00

    打开excel时报“不能使用对象链接和嵌入”,如下图:

     

    解决方法:

     

    1、运行“dcomcnfg”,打开 DCOM 配置程序。(或者
    开始→设置→控制面版→管理工具→组件服务→计算机→我的电脑→DCOM配置);
    2、在应用程序列表中找到“Microsoft Excel 应用程序”,点击“属性”,选择“交互式用户”或“启动用户”均可(如下图)。

    更多相关内容
  • 本篇需要提前了解的知识储备:原型和原型,以下仅概要介绍,不作详细讲解。 详细学习可参考: JavaScript——面向对象(封装):https://blog.csdn.net/qq_29493173/article/details/118404400 JavaScript——面向...

    本篇需要提前了解的知识储备:原型和原型链,以下仅概要介绍,不作详细讲解。

    详细学习可参考:
    JavaScript——面向对象(封装):https://blog.csdn.net/qq_29493173/article/details/118404400
    JavaScript——面向对象之继承(原型对象)与多态(重载、重写):https://blog.csdn.net/qq_29493173/article/details/118410075


    一、构造函数/原型/原型链

    构造函数:定义一类对象的统一结构

    原型(对象)prototype:为所有子对象保存共有的成员(属性值和方法)

    • 定义每个构造函数时都会自带一个原型对象——prototype
    • 每一个JavaScript对象(除了 null )都具有__proto__属性(私有属性),指向该对象的原型。
    • 原型对象也是一个对象!!

    在这里插入图片描述
    构造函数和原型的关系可以由上图表示:
    妈妈(构造函数):Student
    儿子(实例):student

    原型对象Student prototype既是妈妈(Student)的老公,又因为student的__proto__指向他,形成继承关系,所以他也是儿子(student)的爸爸。
    所以原型对象Student prototype,充当两个角色,既是妈妈(构造函数)的老公,又是儿子(实例)的爸爸,老公和爸爸是同一个东西,只是叫法不同。

    原型链:由各级对象的__proto__逐级向上引用形成的多级继承关系

    • 保存着一个对象可用的所有属性和方法
    • 控制着属性和方法的使用顺序:先自有再共有——就近原则!(当查询一个属性或方法时,先去找自身看是否存在,如果没有才去原型链上寻找)
      在这里插入图片描述
      Person.prototype是原型对象,原型对象也是一个对象
      所以Person.prototype原型对象的__proto__指向Object.prototype,也就是本篇即将引出的顶层原型对象,因为是顶层原型对象,它的__proto__指向null。
      图中这条蓝色的线即是原型链.

    二、顶层对象

    JS中顶级对象是Object,Object.prototype: 最顶层的原型对象

    Object.prototype.__proto__ ===  null
    

    图解

    tip:为便于理解相関概念,从一个例子入手,并用通俗的家庭关系(以儿子辈分来称呼)解释:


    图一

    先理清左半部分的原型链:
    首先有个构造函数(妈妈)Student,原型对象(爸爸)Student.prototype,有两个实例(儿子)eryayuanyuan
    Student.prototype(爸爸)是对象,故它的__proto__指向Object.prototype(爷爷),对应的构造函数Object()(奶奶)

    右半部分 obj1是一个对象,等价于new Object,所以它的__proto__直接指向Object!!
    在这里插入图片描述


    图二
    我们可以看到图二中多加了一条浅蓝色的原型继承链,而他存在是因为构造函数是函数!
    构造函数中的 function <==> new Function
    所以构造函数(妈妈)Student的__proto__应指向Function.prototype(姥爷),对应的构造函数是Funtion()(姥姥)

    但是最离谱的一件事来了!
    Function.prototype(姥爷)是一个原型对象!
    对象?那么说明它的__proto__竟然要指向Object.prototype()(爷爷)
    在这里插入图片描述

    在这里插入图片描述

    结论

    经过上面毁三观的图解之后,我们得出一些结论:

    • 在原型链中,原型链顶端一定是Object.prototypeFunction.prototype继承它而产生。
    • 一切对象继承自Object.prototype一切函数对象都继承自Function.prototype(且Function.prototype最终继承自Object.prototype)

    普通对象和函数对象的区别

    普通对象直接继承了Object.prototype,而函数对象在中间还继承了Function.prototype(参考图左右两部分原型链)

    展开全文
  • 每一个对象都有自己的原型,而原型也是对象,也会有自己的原型,以此类推形成链式结构:称之为原型(原型的终点是null) 访问原型的规则(就近原则) ** 对象先访问自己的,自己没有就找原型的,原型没有就找原型的...

    1.面向对象三大特征

    **
    1.封装:把对象放入对象的方法
    2.继承:一个对象(子对象)拥有另一个对象(父对象)所有的成员(重点)
    3.多态:一个对象在不同情况下的不同状态
    **

    原型继承:把父对象作为子对象构造函数的原型

    2.原型链

    每一个对象都有自己的原型,而原型也是对象,也会有自己的原型,以此类推形成链式结构:称之为原型链(原型链的终点是null)

    访问原型链的规则(就近原则)

    ** 对象先访问自己的,自己没有就找原型的,原型没有就找原型的原型,一直到原型链终点null.如果还找不到.属性则获取undefined, 方法则会报错 xxx is not function**
    构造函数原型函数实例化对象原型链两层关系图
    原型链关系图
    多条原型链关系图
    详解
    不同标签访问原型链的规则标签使用时的关系图
    在这里插入图片描述
    在这里插入图片描述
    构造函数关系图在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    原型链封装(主要讲解继承作用和使用场景)

    <!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.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="btn1">消息提示1</button>
      <button id="btn2">消息提示2</button>
      <button id="btn3">消息提示3</button>
      <button id="btn4">消息提示4</button>
    
      <!-- <div class="modal">
          <div class="header">提示消息 <i>x</i></div>
          <div class="footer">
            <img src="./111.jpg" alt="" width="80%">
          </div>
        </div> -->
    
    
      <script>
        // document.write()  元素.innerHtml=`字符串`    元素.appendChild  添加到页面的   
        //构造函数
        function Modal(title, message) {
          this.title = title
          this.message = message
          this.modalBox = `<div class="modal">
          <div class="header">${title} <i>x</i></div>
          <div class="footr">
            ${message}
          </div>
        </div>`
        }
        //模态框原型
        Modal.prototype.open = function () {
          //创建空标签
          let div = document.createElement('div')
          //this指向   Modal构造函数创建的函数体
          div.innerHTML = this.modalBox
          document.body.appendChild(div)
          //注册点击事件    删除
          div.querySelector('i').onclick = function () {
            document.body.removeChild(div)
          }
        }
    
        document.querySelector('#btn1').onclick = function () {
          //创建Modal实例
          let m1 = new Modal('友情提示', '登陆成功')
          console.log(m1)
          //展示模态框
          m1.open()
    
        }
        document.querySelector('#btn2').onclick = function () {
          let m2 = new Modal('提示消息', '您的订单已提交')
          console.log(m2)
          m2.open()
        }
        //图片模态框
        function ModalL(title, img) {
          this.title = title
          this.img = img
          this.modalBox = `<div class="modal">
          <div class="header">${title} <i>x</i></div>
          <div class="footer">
            <img src="${img}" alt="" width="100%">
          </div>
        </div>`
        }
        /* ModalL继承Modal的open方法 
       { 原型继承:把父对象 作为 子对象构造函数原型}}*/
        ModalL.prototype = new Modal()
        //      
    
        /*例如:    如果用Modal.pototype 那么给ModalL加函数方法时就会污染Modal
        ModalL想要添加自己的方法 
         ModalL.prototype.eat = function () {
          console.log('吃东西')
        }*/
    
        document.querySelector('#btn3').onclick = function () {
          let m2 = new ModalL('提示消息', ' ./111.jpg')
          console.log(m2)
          m2.open()
        }
        document.querySelector('#btn4').onclick = function () {
          let m2 = new ModalL('提示消息', ' ./222.jpg')
          console.log(m2)
          m2.open()
        }
      </script>
    </body>
    
    </html>
    

    面向对象编程

    <!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.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="btn1">消息提示1</button>
      <button id="btn2">消息提示2</button>
      <button id="btn3">消息提示3</button>
      <button id="btn4">消息提示4</button>
    
      <!-- <div class="modal">
          <div class="header">提示消息 <i>x</i></div>
          <div class="body">消息内容</div>
          <div class="footer">
            <a href="javascript:;" class="cancel">取消</a>
            <a href="javascript:;" class="submit">确认</a>
          </div>
        </div> -->
    
    
      <script>
        //1. 模态框构造函数
        function Modal(title, message) {
          this.title = title
          this.message = message
          this.modalBox = `<div class="modal">
            <div class="header">${this.title} <i>x</i></div>
            <div class="body">${this.message}</div>
            </div>`
        }
    
        //2. 模态框原型
        Modal.prototype.open = function () {
          //(1)创建空标签
          let div = document.createElement('div')
          //(2)设置标签内容
          div.innerHTML = this.modalBox
          //(3)添加到页面
          document.body.appendChild(div)
          //给删除按钮注册点击事件
          div.querySelector('.header i').onclick = function () {
            document.body.removeChild(div)
          }
        }
    
        //1.确认框构造函数
        function Confirm(title, message) {
          this.title = title
          this.message = message
          this.modalBox = ` <div class="modal">
            <div class="header">${this.title} <i>x</i></div>
            <div class="body">${this.message}</div>
            <div class="footer">
              <a href="javascript:;" class="cancel">取消</a>
              <a href="javascript:;" class="submit">确认</a>
            </div>
            </div>`
        }
    
        /* 为什么要继承: confirm确认框和 modal模态框 功能是一样的, 也要显示到页面,也要点击xx移除
        1.继承 :  一个对象 继承 另一个对象 所有的成员
        2.原型继承 :  把父对象 作为 子对象构造函数的原型
        */
        //Modal.prototype 不行因为在Modal加东西
        Confirm.prototype = new Modal()//父对象的原型对象
    
        //继续给Confirm的原型添加自己的方法
        Confirm.prototype.addEvent = function (confirm) {
          let modal = document.querySelector('.modal')
          modal.querySelector('.submit').onclick = function () {
            //调用函数
            confirm()
            //移除模态框parentNode 属性可返回某节点的父节点。
            // 如果指定的节点没有父节点则返回 null 。
            modal.parentNode.removeChild(modal)
          }
          modal.querySelector('.cancel').onclick = function () {
            //移除模态框
            modal.parentNode.removeChild(modal)
          }
        }
    
        //弹窗1
        document.querySelector('#btn1').onclick = function () {
          //创建模态框
          let m = new Modal('友情提示', '删除成功')
          m.open()
          console.log(m)
        }
        //弹窗2
        document.querySelector('#btn2').onclick = function () {
          //创建模态框
          let m = new Modal('提示消息', '您没有权限操作')
          m.open()
        }
    
        //弹窗3
        document.querySelector('#btn3').onclick = function () {
          //创建确认框
          let c = new Confirm('友情提示', '您确定要删除吗?')
          console.log(c)
          c.open()
          //添加确认功能
          c.addEvent(function () { alert('删除成功') })
    
        }
        //弹窗4
        document.querySelector('#btn4').onclick = function () {
          //创建确认框
          let c = new Confirm('友情提示', '您确定要下单吗?')
          c.open()
          //添加确认功能
          c.addEvent(function () {
            alert('下单成功')
          })
        }
    
      </script>
    </body>
    
    </html>
    
    展开全文
  • 原型对象、原型超详细讲解(附图解)一、函数的原型对象二、prototype(函数的原型)三、__ proto__(原型)四、constructor(构造函数)五、prototype继承六、结论1.实例对象的原型指向当前类的原型对象。2.原型...

    一、函数的原型对象

    • 原型对象中有原型链—指向最高
    • 函数的原型对象的构造函数指向本身
        var arr=new Array();
        console.log(arr);
        //一个对象的原型链指向原型对象
        //原型对象的构造函数指向本身(函数本身)
        //es5中没有类的概念,就是没有class类集合,我们把函数叫类
        //也就是自定义函数类,写类对象
        //函数的原型属性prototype===函数类的原型对象
        function myArray(){
            this.length=0;
        }
        //当前函数类的原型对象
        myArray.prototype={
            constructor:myArray,
            mysort:function(){
                //this指向当前类对象本身(实例本身)
                console.log(this);
            }
        }
        //实例化类对象
        var myarr=new myArray();
        console.log(myarr);
        myarr.mysort(); 
    

    在这里插入图片描述

       function Animal(){
       }
       //输出的是当前函数的原型对象
       console.log(Animal.prototype);
       //原型对象中有原型链---指向最高
       //函数的原型对象的构造函数指向本身
       console.log(Animal.prototype.constructor);
    

    在这里插入图片描述

    二、prototype(函数的原型)

    • 每一个javascript对象(除null外)创建的时候,就会与之关联另一个对象,这个对象就是我们所说的原型,每一个对象都会从原型中“继承”属性,原型对象上具有原型属性以及原型方法。
    • 函数才有prototype,每个函数都有一个prototype属性,这个属性指向函数的原型对象。通过prototype可以为对象在运行期间添加新的属性和方法。

    三、__ proto__(原型链)

    • 这是每个对象(除null外)都会有的属性,叫做__proto__,指向自身的构造函数的原型对象。
    • 从内置对象上可以观察到,实例化的当前对象__proto__(原型链)指向自身的构造函数的原型对象。
    <script>
       var arr = [];
       console.log(arr);
    </script>
    

    在这里插入图片描述

    四、constructor(构造函数)

    • 每个原型都有一个constructor属性,指向函数本身。

    五、prototype继承

        function Person(name,job){
            this.name=name;
            this.job=job;
            this.sex='';
        }
        Person.prototype={
            constructor:Person,
            sleep:function(){
                console.log("睡觉");
            },
            eat:function(){
                console.log("吃饭");
            }
        }
        Person.prototype.eat();
        //类在new实例化的时候,开始执行的函数的构造
        var stu=new Person('小明','学生');
        //给对象直接写属性是赋值,类似直接在对象的类中建立一个自身属性
        //stu.sex="男";
        //原型对象属性如何赋值
        stu.__proto__.sex="女";
        console.log(stu); 
    

    六、结论

    1.实例对象的原型链指向当前类的原型对象。

    	console.log(arr.__proto__ == Array.prototype);//true
    

    2.原型对象的原型链指向Object函数的原型对象

    	console.log(arr.__proto__.__proto__);//Object
    	console.log(arr.__proto__.__proto__ == Object.prototype);//true
    

    3.Object函数的原型对象的原型链指向null,Object的原型链是不存在的。

    	console.log(arr.__proto__.__proto__.__proto__);//null
    

    4.所有对象最后都会指向Object函数的原型对象。

        //子类对象的原型链指向当前函数的原型对象
        console.log(stu.__proto__ === Person.prototype);//true
        //instanceof判断两边的数据类型是否一致
        console.log(stu.__proto__ instanceof Person);//false
        console.log(typeof stu.__proto__);//object
        console.log(stu.__proto__.constructor instanceof Person);//false
        console.log(typeof stu.__proto__.constructor);//function 
    

    七、图解过程

    在这里插入图片描述

    展开全文
  • 【JavaScript】原型对象对象原型、原型及其查找规则
  • 1.1-面向对象三大特征介绍 a.封装:将某个具体功能封装在对象中,只对外部暴露指定的接口,外界在使用的时候,只考虑接 口怎么用,不用考虑内部怎么实现(前面学习的api其实就是一种封装思想) b.继承:一个对象...
  • 原型和访问对象原型的方法

    千次阅读 2018-08-27 18:09:58
    通过原型这种机制,JavaScript 中的对象从其他对象继承功能特性。 当谈到继承时,Javascript 只有一种结构:对象。每个对象都有一个内部链接到另一个对象, 称为它的原型 prototype。该原型对象有自己的原型,等等...
  • 责任模式(之前我经常称之为命令模式)是一种允许以使用分层方式”处理“对象的模式。在维基百科中的经典定义是 在面向对象设计中,责任模式是一种由命令对象源及其一系列处理对象组成的设计模式。每个处理...
  • 什么是原型对象?原型

    千次阅读 2019-03-27 22:31:08
    对象 对象基础 对象的定义 对象是一个包含相关数据和方法的集合(通常由一些变量和函数组成,我们称之为对象里面的属性和方法)。 对象有时被称之为关联数组(associative array)了——对象做了字符串到值的映射...
  • 图解js原型对象、原型

    千次阅读 2017-07-28 10:09:04
    在Javascript中,万物皆对象,所以想要理解原型对象和原型,我们首先要对对象有深刻的理解,JS中对象大致可以分为两类,即:普通对象Object 和 函数对象Function。一般而言,通过new Function产生的对象是函数...
  • js中的原型和关于原型对象属性查找规则
  • 1.构造函数,原型对象,实例对象三者之间的关系 每创建一个函数,该函数都会自动带有一个prototype属性。该属性是一个指针,指向一个对象,该对象称之为原型对象(后期我们可以使用这个原型对象帮助我们在js中实现...
  • javascript完整原型详细图解(构造函数,原型,实例化对象) 一、首先说一下什么是构造函数: 构造函数:用来在创建对象时初始化对象。特点:构造函数名一般为大写字母开头;与new运算符一起使用来实例化对象。 ...
  • 以我自己的理解来阐述一下javascript的对象,原型,原型,属性枚举javascript的对象,通常是string,array,number,function,Date,null…等等,这是我在使用javascript中经常接触到的.这些都可以看作对象。从...
  • 废话不多说,最近要期末考试了,还没预习呢,下面直接进入正题。定义:定义多个可以处理请求(承担责任)的类,并将它们连成一条,沿着该向下传递请求(责任),直到有能力解决...需要动态指定一组对象处理请求。
  • 构造函数:用来在创建对象时初始化对象。特点:构造函数名一般为大写字母开头;与new运算符一起使用来实例化对象。 举例: function Person(){} //Person构造函数 var p=new Person(); //Person构造函数创建对象,...
  • 责任模式在王者荣耀中的应用 · 一、简述 在王者荣耀商城中,玩家可以参与夺宝抽奖。夺宝抽奖分两种,一种是积分抽奖,另一种是钻石抽奖;在平常,两种夺宝抽奖方式均可以通过60钻石/积分抽奖一次,或者通过270...
  • 一、理解原型对象当创建一个新函数时,系统会根据一组特定的规则为函数创建一个prototype属性,该属性会指向一个名为原型对象对象,在默认情况下,该对象会自动生成一个构造函数(constructor),该构造函数是一个...
  • 一、首先说一下什么是对象? ES把对象定义为:“无序属性的集合,其属性可以包含基本值,对象和函数”。严格来讲,这就相当于说对象是一组没有特定顺序的值。对象的每个属性或方法都有一个名字,而每个名字都映射到...
  • JavaScript(原型对象和原型

    千次阅读 2018-08-15 11:29:18
    1.我们创建的每一个函数都有prototype属性,它指向一个对象,即原型对象。原型对象包含这个特定类型所有实例共享的属性和方法,所以原型对象可以理解为这个特定类型构造函数的实例。 function Person() { this....
  • 前端中的“两一包”:原型、作用域、闭包。 原型对象的产生由来:由一个类或者构造函数 实例化生成多个对象 他们都相同的方法,没有必要 给每个设置一份,为解决构造函数中的写方法造成的内存浪费问题,可以...
  • JS中有句话叫‘一切皆对象’,函数实际上也是对象。那基本类型也是对象吗? 首先抛出我的结论,基本数据类型不是对象,在存储形式上它被存放在栈中,但是在一定条件下会自动转为对象()就是原始类型的‘包装对象’...
  • 除了5种基本类型外,JS中剩下的就是对象 (1)对象的定义:直接定义:var test={x:1,y:1}new方式创建:var test=new Object({x:1})Object.create方式:var test=Object.create({x:1})(2)对象上的赋值与取值举例:...
  • 详解JS原型与原型

    千次阅读 多人点赞 2022-04-04 14:50:18
    4.原型 5.原型对象中的this指向 6.扩展内置对象(原型对象的应用) 在ES6之前,我们面向对象是通过构造函数实现的。我们把对象的公共属性和方法放在构造函数里 像这样: function student(uname,age) { ...
  • vs2013的项目换了一个文件夹编译,出现error LNK2011: 未链接预编译对象;映像可能不能运行
  • Packager-对象包装程序1   ㈠、“对象包装程序”概述  “对象包装程序”是一种用于创建可以插入到某个文档中的程序包的工具。  “对象包装程序”窗口有两个窗格。“外观”窗格显示代表对象包的图标。...
  • 【简述原型是什么,有什么用处?若想访问一个对象的原型,应该使用什么方法?】 每篇分享文从 【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】 八个方面...
  • 使多个对象都有机会处理请求,从而避免了请求的发送者和接受者之间耦合关系,将这些对象连成一条,并沿着这条传递该请求,直到有对象处理它为止。   责任模式的优点 最为显著的优点就是将请求和处理分开。...
  • 开篇之前对js中的原型和原型对象有所了解,每当别人问我什么是原型和原型对象时,我总是用很官方(其实自己不懂)的解释去描述。有一句话说的好:如果你不能把一个很复杂的东西用最简单的话语描述出来,那就说明...
  • 责任(Chain of Responsibility)模式

    千次阅读 2019-07-30 11:03:16
    文章目录责任(Chain of Responsibility)模式1. 意图2. 别名3. 动机4. 适用性5. 结构6. 参与者7. 协作8. 效果9. 实现10. 代码示例11. 已知应用12. 相关模式13. 设计原则口袋14. 参考文献 责任(Chain of ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,608,175
精华内容 643,270
关键字:

对象链