精华内容
下载资源
问答
  •   与其它的语言相比,JavaScript 中的“对象”总是显得不是那么合群。一些新人在学习 JavaScript 面向对象时,往往也会有疑惑:为什么 JavaScript(直到 ES6)有对象的概念,但是却没有像其他的语言那样,有类的...

      本文章转载自程劭非(winter)在极客时间专栏「重学前端」中讲解的JavaScript的部分。

      与其它的语言相比,JavaScript 中的“对象”总是显得不是那么合群。一些新人在学习 JavaScript 面向对象时,往往也会有疑惑:为什么 JavaScript(直到 ES6)有对象的概念,但是却没有像其他的语言那样,有类的概念呢?为什么在 JavaScript 对象里可以自由添加属性,而其他的语言却不能呢?

      甚至一些争论中,有人强调,JavaScript 并非“面向对象的语言”,而是“基于对象的语言”,这个说法一度流传甚广,而事实上,我至今遇到的持有这一说法的人中,无一能够回答“如何定义面向对象和基于对象”这个问题。

      实际上,基于对象和面向对象两个形容词都出现在了 JavaScript 标准的各个版本当中。我们可以先看看 JavaScript 标准对基于对象的定义,这个定义的具体内容是:“语言和宿主的基础设施由对象来提供,并且 ECMAScript 程序即是一系列互相通讯的对象集合”。这里的意思根本不是表达弱化的面向对象的意思,反而是表达对象对于语言的重要性。

      那么,在本篇文章中,我会尝试让你去理解面向对象和 JavaScript 中的面向对象究竟是什么。

    什么是对象?

      我们先来说说什么是对象,因为翻译的原因,中文语境下我们很难理解“对象”的真正含义。事实上,Object(对象)在英文中,是一切事物的总称,这和面向对象编程的抽象思维有互通之处。中文的“对象”却没有这样的普适性,我们在学习编程的过程中,更多是把它当作一个专业名词来理解。

      但不论如何,我们应该认识到,对象并不是计算机领域凭空造出来的概念,它是顺着人类思维模式产生的一种抽象(于是面向对象编程也被认为是:更接近人类思维模式的一种编程范式)。

      那么,我们先来看看在人类思维模式下,对象究竟是什么。

      对象这一概念在人类的幼儿期形成,这远远早于我们编程逻辑中常用的值、过程等概念。在幼年期,我们总是先认识到某一个苹果能吃(这里的某一个苹果就是一个对象),继而认识到所有的苹果都可以吃(这里的所有苹果,就是一个类),再到后来我们才能意识到三个苹果和三个梨之间的联系,进而产生数字“3”(值)的概念。

      在《面向对象分析与设计》这本书中,Grady Booch 替我们做了总结,他认为,从人类的认知角度来说,对象应该是下列事物之一:

    • 一个可以触摸或者可以看见的东西;
    • 人的智力可以理解的东西;
    • 可以指导思考或行动(进行想象或施加动作)的东西。

      有了对象的自然定义后,我们就可以描述编程语言中的对象了。在不同的编程语言中,设计者也利用各种不同的语言特性来抽象描述对象,最为成功的流派是使用“类”的方式来描述对象,这诞生了诸如 C++、Java 等流行的编程语言。而 JavaScript 早年却选择了一个更为冷门的方式:原型。这是我在前面说它不合群的原因之一。

      然而很不幸,因为一些公司政治原因,JavaScript 推出之时受管理层之命被要求模仿 Java,所以,JavaScript 创始人 Brendan Eich 在“原型运行时”的基础上引入了 new、this 等语言特性,使之“看起来更像 Java”。

      在 ES6 出现之前,大量 JavaScript 程序员试图在原型体系的基础上,把 JavaScript 变得更像是基于类的编程,进而产生了很多所谓的“框架”,比如 PrototypeJS、Dojo。事实上,它们成为了某种 JavaScript 的古怪方言,甚至产生了一系列互不相容的社群,显然这样做的收益远远小于损失。

      如果我们从运行时角度来谈论对象,就是在讨论 JavaScript 实际运行中的模型,这是由于任何代码执行都必定绕不开运行时的对象模型,不过,幸运的是,从运行时的角度看,可以不必受到这些“基于类的设施”的困扰,这是因为任何语言运行时类的概念都是被弱化的。

      首先我们来了解一下 JavaScript 是如何设计对象模型的。

    JavaScript 对象的特征

      在我看来,不论我们使用什么样的编程语言,我们都先应该去理解对象的本质特征(参考 Grandy Booch《面向对象分析与设计》)。总结来看,对象有如下几个特点。

    • 对象具有唯一标识性:即使完全相同的两个对象,也并非同一个对象。
    • 对象有状态:对象具有状态,同一对象可能处于不同状态下。
    • 对象具有行为:即对象的状态可能因为它的行为产生变迁。

      我们先来看第一个特征,对象具有唯一标识性。一般而言,各种语言的对象唯一标识性都是用内存地址来体现的,所以,JavaScript 程序员都知道,任何不同的 JavaScript 对象其实是互不相等,我们可以看下面的代码,o1 和 o2 初看是两个一模一样的对象,但是打印出来的结果却是 false。

    var o1 = { a: 1 };
    var o2 = { a: 1 };
    console.log(o1 == o2); // false
    

      关于对象的第二个和第三个特征“状态和行为”,不同语言会使用不同的术语来抽象描述它们,比如 C++ 中称它们为“成员变量”和“成员函数”,Java 中则称它们为“属性”和“方法”。

      在 JavaScript 中,将状态和行为统一抽象为“属性” , 考虑到 JavaScript 中将函数设计成一种特殊对象(关于这点,我会在后文中详细讲解,此处先不用细究),所以 JavaScript 中的行为和状态都能用属性来抽象。

      下面这段代码其实就展示了普通属性和函数作为属性的一个例子,其中 o 是对象,d 是一个属性,而函数 f 也是一个属性,尽管写法不太相同,但是对 JavaScript 来说,d 和 f 就是两个普通属性。

    var o = { 
     d: 1,
     f() {
     console.log(this.d);
     } 
    };
    

      所以,总结一句话来看,在 JavaScript 中,对象的状态和行为其实都被抽象为了属性。如果你用过 Java,一定不要觉得奇怪,尽管设计思路有一定差别,但是二者都很好地表现了对象的基本特征:标识性、状态和行为。

      在实现了对象基本特征的基础上, 我认为,JavaScript 中对象独有的特色是: 对象具有高度的动态性,这是因为 JavaScript 赋予了使用者在运行时为对象添改状态和行为的能力。

      我来举个例子,比如,JavaScript 允许运行时向对象添加属性,这就跟绝大多数基于类的、静态的对象设计完全不同。如果你用过 Java 或者其它别的语言,肯定会产生跟我一样的感受。

      下面这段代码就展示了运行时如何向一个对象添加属性,一开始我定义了一个对象 o,定义完成之后,再添加它的属性 b,这样操作,是完全没问题的。这一点你要理解。

    var o = { a: 1 };
    o.b = 2;
    console.log(o.a, o.b); //1 2
    

      为了提高抽象能力,JavaScript 的属性被设计成比别的语言更加复杂的形式,它提供了数据属性和访问器属性(getter/setter)两类。

    JavaScript 对象的两类属性

      对 JavaScript 来说,属性并非只是简单的名称和值,JavaScript 用一组特征(attribute)来描述属性(property)。

      先来说第一类属性,数据属性 。它比较接近于其它语言的属性概念。数据属性具有四个特征。

    • value:就是属性的值。
    • writable:决定属性能否被赋值。
    • enumerable:决定 for in 能否枚举该属性。
    • configurable:决定该属性能否被删除或者改变特征值。 在大多数情况下,我们只关心数据属性的值即可。

      第二类属性是访问器(getter/setter)属性 ,它也有四个特征。

    • getter:函数或 undefined,在取属性值时被调用。
    • setter:函数或 undefined,在设置属性值时被调用。
    • enumerable:决定 for in 能否枚举该属性。
    • configurable:决定该属性能否被删除或者改变特征值。

      访问器属性使得属性在读和写时执行代码,它允许使用者写入和读出属性时得到完全不同的值,它可以视为一种函数的语法糖。

      我们通常用于定义属性的代码会产生数据属性,其中的 writable、enumerable、configurable 都默认为 true。我们可以使用内置函数 Object.getOwnPropertyDescripter 来查看,如以下代码所示:

    var o = { a: 1 };
    o.b = 2;
    //a 和 b 皆为数据属性
    Object.getOwnPropertyDescriptor(o,"a") // {value: 1, writable: true, enumerable: true, configurable: true}
    Object.getOwnPropertyDescriptor(o,"b") // {value: 2, writable: true, enumerable: true, configurable: true}
    

      我们在这里使用了两种语法来定义属性,定义完属性后,我们用 JavaScript 的 API 来查看这个属性,我们可以发现,这样定义出来的属性都是数据属性,writeable、enumerable、configurable 都是默认值为 true。

      如果我们要想改变属性的特征,或者定义访问器属性,可以使用 Object.defineProperty,示例如下:

    var o = { a: 1 };
    Object.defineProperty(o, "b", {value: 2, writable: false, enumerable: false, configurable: true});
    //a 和 b 都是数据属性,但特征值变化了
    Object.getOwnPropertyDescriptor(o,"a"); // {value: 1, writable: true, enumerable: true, configurable: true}
    Object.getOwnPropertyDescriptor(o,"b"); // {value: 2, writable: false, enumerable: false, configurable: true}
    o.b = 3;
    console.log(o.b); // 2
    

      这里我们使用了 Object.defineProperty 来定义属性,这样定义属性可以改变属性的 writable 和 enumerable,我们同样用Object.getOwnPropertyDescriptor 来查看,发现确实改变了 writable 和 enumerable 特征。因为 writable 特征为 false,所以我们重新对 b 赋值,b 的值不会发生变化。

      在创建对象时,也可以使用 get 和 set 关键字来创建访问器属性,代码如下所示:

    var o = { get a() { return 1 } };
     
    console.log(o.a); // 1
    

      访问器属性跟数据属性不同,每次访问属性都会执行 getter 或者 setter 函数。这里我们的 getter 函数返回了 1,所以 o.a 每次都得到 1。

      这样,我们就理解了,实际上 JavaScript 对象的运行时是一个“属性的集合”,属性以字符串或者 Symbol 为 key,以数据属性特征值或者访问器属性特征值为 value。对象是一个属性的索引结构(索引结构是一类常见的数据结构,我们可以把它理解为一个能够以比较快的速度用 key 来查找 value 的字典)。我们以上面的对象 o 为例,你可以想象一下“a”是 key。

      这里{writable:true,value:1,configurable:true,enumerable:true}是 value。我们在前面的类型课程中,已经介绍了 Symbol 类型,能够以 Symbol 为属性名,这是 JavaScript 对象的一个特色。

      讲到了这里,如果你理解了对象的特征,也就不难理解我开篇提出来的问题。

      你甚至可以理解为什么会有“JavaScript 不是面向对象”这样的说法:JavaScript 的对象设计跟目前主流基于类的面向对象差异非常大。而事实上,这样的对象系统设计虽然特别,但是 JavaScript 提供了完全运行时的对象系统,这使得它可以模仿多数面向对象编程范式(下一节课我们会给你介绍 JavaScript 中两种面向对象编程的范式:基于类和基于原型),所以它也是正统的面向对象语言。

      JavaScript 语言标准也已经明确说明,JavaScript 是一门面向对象的语言,我想标准中能这样说正因为 JavaScript 的高度动态性的对象系统。

      所以,我们应该在理解其设计思想的基础上充分挖掘它的能力,而不是机械地模仿其它语言。

    结语

      要想理解 JavaScript 对象,必须清空我们脑子里“基于类的面向对象”相关的知识,回到人类对对象的朴素认知和面向对象的语言无关基础理论,我们就能够理解 JavaScript 面向对象设计的思路。

    很多人在思考 JavaScript 对象时,会带着已有的“对象”观来看问题,最后的结果当然就是“剪不断理还乱”了。

    展开全文
  • JS基于对象语言的特性

    千次阅读 2018-05-23 19:16:52
    当然,在web前端开发过程中主要用到的JavaScript语言并不是严格意义的面向对象语言,和传统的强类型的面向对象语言有一定的差异。 面向对象语言具有三大特征: 1.继承性:通俗的说,一个对象不具有另一个对象的...

    主流的编程语言中,以C语言为代表的面向过程类型语言,和以C++(Java)等为代表的面向对象类型语言形成两种编程范式。当然,在web前端开发过程中主要用到的JavaScript语言并不是严格意义的面向对象语言,和传统的强类型的面向对象语言有一定的差异。

    面向对象语言具有三大特征:

    1.继承性:通俗的说,一个对象不具有另一个对象的属性和方法,可以通过原型继承等方式获得另一个对象的属性和方法。这一点JS具有良好的继承性。

    2.封装性:将常见的属性和对象封装到一个函数中,进一步封装到一个对象中。这个特性在JS中也可以得到良好的实现。同时需要注意的一点:在Java中可以通过类class直接定义一个对象,之后进行对象的实例化。在JS中ECMA3版本中没有明确类(class)的定义,class作为保留字可能在后续的开发中进行使用。所以JS中的对象通常使用构造函数进行创建。这也是JS特殊的地方之一。封装性可以减少变量污染全局环境,同时提高代码的复用率。

    3.多态性:在Java中,子类可以访问父类的属性和方法,父类不能访问到子类的属性和方法,叫做面向对象的多态性。然而,在JavaScript中不具有这个特征。所以说JS和严格意义的面向对象编程语言还存在差距。

    面向对象和面向过程实际上各有优缺点。之前接触了一点点C语言的皮毛,感觉以C语言为代表的面向过程语言博大精深,非一日之功不能掌握其精髓。当然,面向对象语言java在另一些领域可以得到更广泛的应用。根据最新的2018年编程语言排行榜,这两个主流语言的市场占有率仍然很高(行业有所不同,C语言等偏重底层开发,Java等偏重于应用)。Javascript使用也在前十,稳中有进。当然,Python和Go等语言的市场份额在不断扩大。相信将来编程语言会进一步完善!期待中!

     

    2019-3-3 更新

    现在ES6的普及已经使得JS的面向对象属性增加,使用 class 类创建对象已经取代了构造函数创建对象的方式。其他ES6中的新特性,例如解构赋值、箭头函数等等新内容已经很常用。目前ES8已经问世,相信一段时间后将会取代早期的规范和方法。现在需要巩固基础,了解新特性。

    展开全文
  • 基于对象语言

    2014-01-01 11:25:31
    所谓的基于对象语言:指的是在程序的内部已经为用户提供好若干个对象,用户直接使用这些对象即可。如:javascript
    所谓的基于对象语言:指的是在程序的内部已经为用户提供好若干个对象,用户直接使用这些对象即可。如:javascript
    展开全文
  • 基于对象语言--JS

    千次阅读 2017-09-16 19:04:45
    JS是一门基于对象、事件驱动编程的客户端脚本语言。为什么JS不是面向对象的语言?因为面向对象包括三大特征:封装、继承、多态。JS中只有封装,继承也只是模拟继承,谈不上面向对象。所有说,在JS中,一切都是对象,...

    基于对象?面向对象?

    JS是一门基于对象、事件驱动编程的客户端脚本语言。为什么JS不是面向对象的语言?因为面向对象包括三大特征:封装、继承、多态。JS中只有封装,继承也只是模拟继承,谈不上面向对象。所有说,在JS中,一切都是对象,属性、数组、函数等等都是对象。

    JS中没有重载

    <!DOCTYPE html>
    <html>
        <head>
            <meta charset="UTF-8">
            <title></title>
            <script type="text/javascript">
    //          function test () {
    //              alert('test');
    //          }
    //          
    //          
    //          function test (x) {
    //              alert(x);
    //          }
    //          
    //          function test (x,y) {
    //              alert('x='+x+',y='+y);
    //              alert(x,y);
    //          }
    
                //不写形参占位符,直接用arguments[]访问传过来的实参
                function test () {
                    alert(arguments[0]);
                }
                test(10);
            </script>
        </head>
        <body>
        </body>
    </html>
    

    JS中没有重载,后面定义的同名函数会把前面的函数覆盖掉,永远只调用最后一个,而且JS中的形参只是占位符,定义两个形参,可以只传一个参数,只是为了方便程序员传来的实参。不写形参时,实参不能方便使用占位符,这时使用隐式形参arguments[0]来访问第一个实参,arguments[1]访问第二个实参 等等。

    使用函数模拟类

    一般类的名称首字母大写,1.定义类时同时有了构造函数,2.方法的属性值是函数。
    示例:

    <script type="text/javascript">
                function Student (sno,sname,age) {
                    this.sno = sno;
                    this.sname = sname;
                    this.age = age;
                    this.study  = function(){
                        alert('我是'+this.sname+',我在学习')
                    }
                }
    
                var stu = new Student(1,'xiaoming',20);
                stu.study();
    
            </script>

    二、使用Object类创建即时对象
    delete stu.name;//可以删除属性
    示例:

    <script type="text/javascript">
                var stu = new Object();
                stu.sno = 1;
                stu.sname = 'xiaoming';
                stu.age = 20;
                stu.study = function(){
                    alert('我是'+this.sname+',我在学习');
                }
    
                stu.study();
            </script>

    三、使用JSON来创建对象
    JSON(JavaScript Object Notation),类似于XML,是一种数据交换格式。
    方式1:
    //1.创建对象
    // var stu = {
    // “sno”:1,
    // “name”:’xiaoming’,
    // “study”:function(){
    // alert(this.name+’在学习’)
    // }
    // }
    // stu.study();
    方式2:
    var student=[
    {“sno”:1,
    “name”:’xiaoming’,
    “study”:function(){
    alert(this.name+’在学习’)
    }
    },
    {
    “sno”:2,
    “name”:’xiaomi’,
    “study”:function(){
    alert(this.name+’在学习’)
    }
    },
    {
    “sno”:3,
    “name”:’xiaom’,
    “study”:function(){
    alert(this.name+’在学习’)
    }
    }];

        student[0].study();
    

    减少全局变量的污染

    我们写程序时,应尽量减少使用全局变量,同名容易冲突,这叫做全局变量的污染。例如:js和jQuery同时定义全局变量a,都引入页面中,后者会覆盖前者。

    <!DOCTYPE html>
    <html>
        <head>
            <meta charset="UTF-8">
            <title></title>
            <script src="../A.js" type="text/javascript" charset="utf-8"></script>
            <script src="../B.js" type="text/javascript" charset="utf-8"></script>
            <script type="text/javascript">
                alert(myJs.a);
                alert(myJQuery.a)
            </script>
        </head>
        <body>
        </body>
    </html>
    
    A.js
    
    var myJs={};
    myJs.a='A';
    
    B.js
    
    var myJQuery={};
    myJQuery.a='B';

    最好的方式,一个程序中,只定义一个全局变量,使用JSON,如上。

    闭包

    目的:使用闭包实现信息隐蔽,减少全局变量的污染,实现模块化开发。
    1.在函数中定义函数,通过闭包放大了全局变量的作用域。new外部函数的对象,运行函数,内部函数的作用域就放大了。
    2.在函数中定义JSON对象,返回这个对象,对象内部定义方法。

    示例:

    第一种方式:
    <script type="text/javascript">
    
                function outer () {
    
                    var a = 10;
    
                    function inner () {
                        alert(a++);
                    }
    
                    return inner;
                }//a 的作用域到这
    
    
                var test = outer();
    
                test();//使用闭包放大了 a 的作用域  
                test();//使用闭包放大了 a 的作用域  
                test();//使用闭包放大了 a 的作用域  
    
    
            </script>
    第二种方式:
    <script src="bibao2.js" type="text/javascript" charset="utf-8"></script>
            <script type="text/javascript">
    //          User.add();
    //          Category.add();
    
                //
    //          jQuery.add();//另起的名字
    //          $.add();
    //          document.write(User);
            </script>
    
    bibao2.js
    
    var User = (function(winObj){//还可以把整个window对象传进来
        var i = 111;//区分各个工程,避免全局变量的污染
        var jsonObj = winObj.jQuery = winObj.$ ={
            "add":function () {
                alert("增加用户"+i);//+i 区分工程
            },
            "update":function () {
                alert("更改用户");
            },
            "delete":function () {
                alert("删除用户");
            }
        }
    
    //  return i;
        return jsonObj;
    })(window);
    
    var Category=(function () {
        var i = 222;//同名,因为闭包,两个i互不影响
        return{ //直接return jsonObj
            "add":function(){
                alert('增加商品数量'+i);
            },
            "update":function(){
                alert('更改商品数量');
            },
            "delete":function(){
                alert('删除商品');
            }
        };
    
    })();
    

    模拟继承

    一、使用call()函数来模拟继承

    <!DOCTYPE html>
    <html>
        <head>
            <meta charset="UTF-8">
            <title></title>
            <script type="text/javascript">
                function Person (name,age) {
                    this.name = name;
                    this.age = age;
                    this.eat = function(){
                        alert('姓名:'+this.name+",年龄:"+this.age+",我在吃饭");
                    }
                }
    
                function Student(sno,name,age){
                    Person.call(this,name,age);//相当于super(name,age)
                    this.sno = sno;
                    this.study = function(){
                        alert('学号:'+this.sno+',姓名:'+this.name+",年龄"+this.age+",我在学习");
                    }
                }
    
                var stu = new Student(1,'xiaoming',22);
                stu.eat();
                stu.study();
            </script>
        </head>
        <body>
        </body>
    </html>
    

    二、使用apply()函数来模拟继承

    <!DOCTYPE html>
    <html>
        <head>
            <meta charset="UTF-8">
            <title></title>
            <script type="text/javascript">
                function Person (name,age) {
                    this.name = name;
                    this.age = age;
                    this.eat = function(){
                        alert('姓名:'+this.name+",年龄:"+this.age+",我在吃饭");
                    }
                }
    
                function Student(sno,name,age){
                    Person.apply(this,[name,age]);//相当于super(name,age)
                    this.sno = sno;
                    this.study = function(){
                        alert('学号:'+this.sno+',姓名:'+this.name+",年龄"+this.age+",我在学习");
                    }
                }
    
                var stu = new Student(1,'xiaoming',22);
                stu.eat();
                stu.study();
            </script>
        </head>
        <body>
        </body>
    </html>
    

    三、使用原型prototype模拟继承

    <!DOCTYPE html>
    <html>
        <head>
            <meta charset="UTF-8">
            <title></title>
            <script type="text/javascript">
                function Person (name,age) {
                    this.name = name;
                    this.age = age;
                    this.eat = function(){
                        alert('姓名:'+this.name+",年龄:"+this.age+",我在吃饭");
                    }
                }
    
                function Student(sno,name,age){
    
                    this.sno = sno;
                    this.name = name;
                    this.age = age;
                    this.study = function(){
                        alert('学号:'+this.sno+',姓名:'+this.name+",年龄"+this.age+",我在学习");
                    }
                }
    
                //1.创建父类对象
                var person = new Person();
                //2.子类.prototype = person;
                Student.prototype = person;
                //把父类的原型赋值给子类的原型,原型一致,模拟实现了继承。
    
                //但是会丢失子类的属性值,全变成了undefined,即使new 对象时加上了,也不起作用
                //打脸,xiaoming既吃饭也学习
                var stu = new Student(1,'xiaoming',20);
    
                //动态的添加方法,即使在new对象之前没有这个方法
                Student.prototype.test = function() {
                    alert('test动态添加方法');
                }
                stu.eat();
                stu.study();
                stu.test();
    
            </script>
        </head>
        <body>
        </body>
    </html>
    

    通过类的prototype属性,可以获知该类有那些属性和方法。
    //1.创建父类对象
    var person = new Person();
    //2.子类.prototype = 父类对象
    Student.prototype = person ;
    //把父类的原型赋值给子类对象的原型,原型一致,模拟实现了继承。

    这里写图片描述

    展开全文
  • Js基于对象还是面向对象的一、什么叫做面向对象二、什么叫做基于对象三: Js的特性四:js通过原型链等来模拟出和面向对象很类似的功能。五:总结 一、什么叫做面向对象 面向对象的三大特点(封装,继承,多态)...
  • JavaScript语言是基于对象的(Object-Based),而不是面向对象的(object-oriented)。之所以说它是一门基于对象的语言,主要是因为它没有提供象抽象、继承、重载等有关面向对象语言的许多功能。而是把其它语言所...
  • 基于对象Js语言

    2006-09-26 19:41:00
    基于对象Js语言 作者:unknow 来源:网上转载 更新日期:2005-11-11 浏览次数: 301
  • 基于对象JavaScript语言 JavaScript语言是基于对象的(Object-Based),而不是面向对象的(object-oriented)。之所以说它是一门基于对象的语言,主要是因为它没有提供象抽象、继承、重载等有关面向对象语言的...
  • Javascript基于对象基础

    千次阅读 2015-12-24 12:47:17
    JavaScript设计者想把JavaScript语言设计成基于对象(object-based)的语言,他想把这个与面向对象(object-oriented)语言区分开来。但是实际上,可以将基于对象看作是面向对象。   原型对象和类的区别 在JavaScript中...
  • JavaScript语言是基于对象的(Object-Based),而不是面向对象的(object-oriented)。之所以说它是一门基于对象的语言,主要是因为它没有提供象抽象、继承、重载等有关面向对象语言的许多功能。而是把其它语言所...
  • JavaScript--基于对象的脚本语言学习笔记(一) 第一部分 js基本语法、面向对象编程
  • JavaScript是“基于对象”的语言,这种说法基本上是正确的,但是,另一些人坚持JavaScript是“面向对象”的,而这个看法,应该说是更加准确的。不过需要注意,“基于对象”和“面向对象”是两个不同层次的概念。 ...
  • 参考链接 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Details_of_the_Object_Model
  • 学习JavaScript对象,当然会看看JavaScript标准对基于对象的定义,这个定义的内容是:“语言和宿主的基础设施由对象来提供,并且JavaScript程序即是一系列相互通讯的对象集合”。这听起来多么晦涩,至少我很难从中...
  • JavaScript--基于对象的脚本语言学习笔记(三) 事件处理器
  • JavaScript基于对象实现字典

    千次阅读 2018-12-25 09:53:07
    JavaScript基于对象实现字典 程序设计 数组-集合-字典是几乎编程语言都会默认提供的数据类型. 在Javascript中默认提供了数组, 但没有提供集合和字典(ES6中增加了), 本章, 我们基于对象实现一下字典 ...
  • 你好,我是前阿里手淘...一些新人在学习JavaScript面向对象时,往往也会有疑惑:为什么JavaScript(直到ES6)有对象的概念,但是却没有像其他的语言那样,有类的概念呢?为什么在JavaScript对象里可以自由添加属性...
  • 这也是所有面对对象语言所拥有的共同点。有这样几个面向对象术语: 一、对象  ECMA-262把对象(object)定义为“属性的无序集合,每个属性存放一个原始值、对象或函数”。严格来说,这意味着对象是无特定顺序的值的...
  •   我们知道在JavaScript中一切(引用类型)都是对象,对象是属性的集合,但是JavaScript中的对象到底是怎么创建的呢?...JavaScript基于原型的面向对象语言,在原型编程思想中,类并不是必需的,对象未必...
  • JavaScript(下面简称JS)是一种基于对象和事件驱动的语言。所谓基于对象,这和我们常说的面向对象语言是有所不同的。 面向对象,简单而言就是用户可以自己定义设计类。 JavaScript(下面简称JS)是一种基于对象和...
  • 这也是所有面对对象语言所拥有的共同点。有这样几个面向对象术语:  对象  ECMA-262把对象(object)定义为“属性的无序集合,每个属性存放一个原始值、对象或函数”。严格来说,这意味 着对象是无特定顺序的值的...
  • 作为一门面向对象语言,继承自然是它的一大特性,尽管javascript的面向对象的实现机制和和c#和java这样典型的面向对象不同,但是继承的基本特点还是具有的,简单的说就是获得父级的方法和属性,下面是一段简单的...
  • javascript-基于对象or面向对象?

    千次阅读 热门讨论 2013-07-24 09:01:23
     JavaScript是一种基于对象和事件驱动并具有相对安全性的客户端脚本语言。同时也是一种广泛用于客户端Web开发的脚本语言,常用来给HTML网页添加动态功能,比如响应用户的各种操作。 维基百科:   ...
  • 2 一些评价说javascript不是真正面向对象的因为它不能提供信息的隐藏。也就是,对象不能有私有变量和私有方法:所有的成员都是公共的。但随后有人证明了javaScript对象可以拥有私有变量和私有方法。另外还有批评说...
  • Javascript是一种面向(基于)对象的动态脚本语言,是一种基于对象(Object)和事件驱动(EventDriven)并具有安全性能的脚本语言。他具有面向对象语言所持有的各种特性,比如封装、继承及多态等。但对于大多数人来...
  • JavaScript基于类 vs 基于原型的语言

    千次阅读 2017-03-04 16:35:42
    基于类的面向对象语言,比如 Java 和 C++,是构建在两个不同实体的概念之上的:即类和实例。 类(class):定义了所有用于具有某一组特征对象的属性(可以将 Java 中的方法和变量以及 C++ 中的成员都视作属性)。类...
  • JSHOL 代表 Javascript HTML 对象语言。 JSHOL 是 JSON 的一个子集,用作使用 JSON 对象创建 HTML5 文档的领域特定语言。 这个项目的灵感来自 SCSS/SASS 和 HAML。 虽然我认为 HAML 是防止我再次使用 HTML 的一个...
  • 虽然javascript一直容易被人长期误解,但其确确实实的是面向对象的编程语言。 很多人可能觉得只有像java, c++这样的编程语言才能称之为面向对象,这个认知比较先入为主,让我们从面向对象的概念开始理解。 什么是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 168,333
精华内容 67,333
关键字:

js是基于对象的语言