JavaScript 面向对象 (prototype 原型模式)
一、 JavaScript 设计思想
1994年,网景公司(Netscape)发布了Navigator浏览器0.9版。这是历史上第一个比较成熟的网络浏览器,轰动一时。但是,这个版本的浏览器只能用来浏览,不具备与访问者互动的能力。比如,如果网页上有一栏"用户名"要求填写,浏览器就无法判断访问者是否真的填写了,只有让服务器端判断。如果没有填写,服务器端就返回错误,要求用户重新填写,这太浪费时间和服务器资源了。
因此,网景公司急需一种网页脚本语言,使得浏览器可以与网页互动。工程师_Brendan Eich_负责开发这种新语言。他觉得,没必要设计得很复杂,这种语言只要能够完成一些简单操作就够了,比如判断用户有没有填写表单。
1994年正是面向对象编程(object-oriented programming)最兴盛的时期,C++是当时最流行的语言,而Java语言的1.0版即将于第二年推出,Sun公司正在大肆造势。
Brendan Eich无疑受到了影响,Javascript里面所有的数据类型都是对象(object),这一点与Java非常相似。但是,他随即就遇到了一个难题,到底要不要设计"继承"机制呢?
如果真的是一种简易的脚本语言,其实不需要有"继承"机制。但是,Javascript里面都是对象,必须有一种机制,将所有对象联系起来。所以,Brendan Eich最后还是设计了"继承"。
但是,他不打算引入"类"(class)的概念,因为一旦有了"类",Javascript就是一种完整的面向对象编程语言了,这好像有点太正式了,而且增加了初学者的入门难度。
他考虑到,C++和Java语言都使用new命令,生成实例。
C++的写法是: ClassName *object = new ClassName(param);Java的写法是:Foo foo = new Foo();
因此,他就把new命令引入了Javascript,用来从原型对象生成一个实例对象。但是,Javascript没有"类",怎么来表示原型对象呢?
这时,他想到C++和Java使用new命令时,都会调用"类"的构造函数(constructor)。他就做了一个简化的设计,在Javascript语言中,new命令后面跟的不是类,而是构造函数。
例:
现在有一个叫做DOG的构造函数,表示狗对象的原型。
function DOG(name){this.name = name;}
对这个构造函数使用new,就会生成一个狗对象的实例。
var dogA = new DOG('大毛');alert(dogA.name); // 大毛
注意构造函数中的this关键字,它就代表了新创建的实例对象。
new运算符的缺点
用构造函数生成实例对象,有一个缺点,那就是无法共享属性和方法。
比如:
在DOG对象的构造函数中,设置一个实例对象的共有属性species
function DOG(name){this.name = name;this.species = '犬科';}
然后,生成两个实例对象:
var dogA = new DOG('大毛');var dogB = new DOG('二毛');
这两个对象的species属性是独立的,修改其中一个,不会影响到另一个。
dogA.species = '猫科';alert(dogB.species); // 弹出的值为"犬科",它不受 dogA 的影响
每一个实例对象,都有自己的属性和方法的副本。这不仅无法做到数据共享,也是极大的资源浪费。
二、prototype属性的引入
Brendan Eich 为构造函数设置一个prototype属性。
这个属性包含一个对象(以下简称"prototype对象"),所有实例对象需要共享的属性和方法,都放在这个对象里面;那些不需要共享的属性和方法,就放在构造函数里面。
实例对象一旦创建,将自动引用prototype对象的属性和方法。也就是说,实例对象的属性和方法,分成两种,一种是本地的,另一种是引用的。
例:
function DOG(name){this.name = name;}DOG.prototype = { species : '犬科' };var dogA = new DOG('大毛');var dogB = new DOG('二毛');alert(dogA.species); // 犬科alert(dogB.species); // 犬科
现在,species属性放在prototype对象里,是两个实例对象共享的。只要修改了prototype对象,就会同时影响到两个实例对象。
DOG.prototype.species = '猫科';alert(dogA.species); // 猫科alert(dogB.species); // 猫科
三、Prototype原型模式
原型对象实际上就是构造函数的一个实例对象,和普通的实例对象没有本质上的区别。可以包含特定类型的所有实例的共享属性或者方法。 这个prototype的属性值是一个对象(属性的集合),默认的只有一个叫做constructor的属性,指向这个函数本身。
比如我们简单定义一个SuperType名字的函数
function SuperType(){}
里面什么属性也没有在函数内部是这个样子的
从上图我们看到,函数里面虽然什么都没有,但是有一个默认的prototype属性,它是一个对象,它指向的是自己的地址,而prototype这个对象本身里面又有一个属性constructor,而这个属性,又指向了函数本身
alert(SuperType.prototype) //objectalert(SuperType.prototype.constructor) //弹出函数本身function SuperType(){}
1、基本原型
function Person(){ } Person.prototype.name = "Nicholas"; Person.prototype.age = 29; Person.prototype.job = "Software Engineer"; Person.prototype.sayName = function(){ alert(this.name); };
这种方式只是说明原型的道理,实际使用中很少把属性写在原型中
2、 更简单的方式
function Person(){ } Person.prototype = { name : "Nicholas", age : 29, job: "Software Engineer", sayName : function () { alert(this.name); } };
这种方式只是上面方式的简单写法,通过对象字面量直接写完所有属性。效果和上面的写法是一样的,只是写法不一样。
但是直接全部把属性和方法全部写在原型中,这并不现实,看下面的列子:
function Person(){ }Person.prototype = { constructor: Person, name : "Nicholas", age : 29, job : "Software Engineer", friends : ["Shelby", "Court"], sayName : function () { alert(this.name); } }; var person1 = new Person(); var person2 = new Person(); person1.friends.push("Van"); alert(person1.friends); //"Shelby,Court,Van" alert(person2.friends); //"Shelby,Court,Van" alert(person1.friends === person2.friends); //true
上面的列子很容易看出,将属性写在原型中的问题,列子中的friends是个数组,引用数据类型在person1中修改了friends,添加了一个条数据之后,可以看到person1和person2对象的friends都发生了改变,这其实很好理解,因为prototype对象本身就是共享的,数组又是属于引用类型,改变了一个,其他的都会发生改变。
所以,在实际中使用的更多的方法是构造函数与原型结合的方式
3、 构造函数与原型结合的方式
function Person(name, age, job){ this.name = name; this.age = age; this.job = job; this.friends = ["Shelby", "Court"]; } Person.prototype = { constructor : Person, //记得写这句代码,作用是防止内存泄露 sayName : function(){ alert(this.name); } } var person1 = new Person("Nicholas", 29, "Software Engineer"); var person2 = new Person("Greg", 27, "Doctor"); person1.friends.push("Van"); alert(person1.friends); //"Shelby,Count,Van" alert(person2.friends); //"Shelby,Count" alert(person1.friends === person2.friends); //false alert(person1.sayName === person2.sayName); //true
这里就可以看到,friends的属性在两个对象中就算改变了其中一个,并不会对另外一个产生影响。这种构造函数加原型的混成模式,是目前使用率,认可率最高的一种自定义类型的方式,所以,一般情况下,我们定义自定义类型默认都使用这种模式
4、 动态原型模式
这种模式只是上面模式的变种,对于一些习惯书写面向对象语言的程序员来说,一个类要分开两个部分来写,是非常不习惯的,所以,就有了动态原型模式,其实无非就是,把之前分开两部分写的内容,全部提到函数中,加上判断就行了
function Person(name, age, job){ //属性 this.name = name; this.age = age; this.job = job; //方法 if (typeof this.sayName != "function"){ Person.prototype.sayName = function(){ alert(this.name); }; } } var friend = new Person("Nicholas", 29, "Software Engineer"); friend.sayName();
注意上面的判断,这种方式只有在sayName函数不存在的情况下,才会将它添加到原型中,如果sayName函数已经存在,那么这段代码就不会再运行,而且就算有很多方法的话,if语句也不用全部判断,只是需要判断一个就行了。
这样的写法,对于java或者C#程序员相对来说感官上比较容易接受,而且写法也没有任何缺陷。但是,有一点不算是缺陷的缺点,javascript是一门动态语言,也就是说,属性和方法是随时可以添加的,如果全部写在构造函数里面去,反而看起来不是那么的灵活。所以,一般情况下,还是该使用构造函数与原型的混合模式
四、 Prototype模式的验证方法
为了配合prototype属性,Javascript定义了一些辅助方法
1、 isPrototypeOf() : 这个方法用来判断,某个proptotype对象和某个实例之间的关系。
function Cat(name,color){this.name = name;this.color = color;}Cat.prototype.type = "猫科动物";Cat.prototype.eat = function(){alert("吃老鼠")}; var cat1 = new Cat("大毛","黄色");var cat2 = new Cat("二毛","黑色"); alert(Cat.prototype.isPrototypeOf(cat1)); //true 判断 cat1 对象是否是 prototype原型 alert(Cat.prototype.isPrototypeOf(cat2)); //true 判断 cat2 对象是否是 prototype 原型
2、 hasOwnProperty() :用来判断某一个属性到底是本地属性,还是继承自prototype对象的属性。
function Cat(name,color){this.name = name;this.color = color;}Cat.prototype.type = "猫科动物"; alert(cat1.hasOwnProperty("name")); // true name属性是本地属性 alert(cat1.hasOwnProperty("type")); // false type 属性是继承prototype对象的属性
3、 in运算符
in运算符可以用来判断,某个实例是否含有某个属性,不管是不是本地属性。
alert("name" in cat1); // truealert("type" in cat1); // true
in运算符还可以用来遍历某个对象的所有属性。
for(var prop in cat1) { alert("cat1["+prop+"]="+cat1[prop]); }
五、 JavaScript高级程序设计书中对与原型的描述和说明
function Person(){ } //创建Person构造函数Person.prototype.name = "Nicholas"; //创建共享属性name Person.prototype.age = 29; //创建共享属性age Person.prototype.job = "Software Engineer"; //创建共享属性job Person.prototype.sayName = function(){ //创建共享函数sayNamealert(this.name); }//分别创建了person1和person2,里面都有sayName函数,并且弹出的值都是一样var person1 = new Person(); person1.sayName(); //"Nicholas" var person2 = new Person();person2.sayName(); //"Nicholas" alert(person1.sayName == person2.sayName); //true
通过上面的图,可以看到,person1和person2,他们内部都有一个指向Person.prototype的指针,可以通过原型的isPrototype方法测试一下
alert(Person.prototype.isPrototypeOf(person1)); //truealert(Person.prototype.isPrototypeOf(person2)); //true function User(){};var person3 = new User();alert(Person.prototype.isPrototypeOf(person3)); //false 不是prototype原型对象alert(User.prototype.isPrototypeOf(person3)); //true 是prototype原型对象
数组操作的很多方法(比如concat、join、push)应该也是在prototype属性中定义的。
实际上,JavaScript所有的固有数据类型都具有只读的prototype属性(这是可以理解的:因为如果修改了这些类型的prototype属性,则哪些预定义的方法就消失了), 但是我们可以向其中添加自己的扩展方法。
// 向JavaScript固有类型Array扩展一个获取最小值的方法Array.prototype.min = function() {var min = this[0];for (var i = 1; i < this.length; i++) {if (this[i] < min) {min = this[i];}}return min;};// 在任意Array的实例上调用min方法console.log([1, 56, 34, 12].min()); // 1
注意:这里有一个陷阱,向Array的原型中添加扩展方法后,当使用for-in循环数组时,这个扩展方法也会被循环出来。
下面的代码说明这一点(假设已经向Array的原型中扩展了min方法):
var arr = [1, 56, 34, 12];var total = 0;for (var i in arr) {total += parseInt(arr[i], 10);}console.log(total); // NaN
解决方法也很简单:
var arr = [1, 56, 34, 12];var total = 0;for (var i in arr) {if (arr.hasOwnProperty(i)) {total += parseInt(arr[i], 10);}}console.log(total); // 103
六、 constructor
constructor始终指向创建当前对象的构造函数。
例:
// 等价于 var foo = new Array(1, 56, 34, 12);var arr = [1, 56, 34, 12];console.log(arr.constructor === Array); // true// 等价于 var foo = new Function();var Foo = function() { };console.log(Foo.constructor === Function); // true// 由构造函数实例化一个obj对象var obj = new Foo();console.log(obj.constructor === Foo); // true// 将上面两段代码合起来,就得到下面的结论console.log(obj.constructor.constructor === Function); // true
当constructor遇到prototype时,每个函数都有一个默认的属性prototype,而这个prototype的constructor默认指向这个函数。
例:
function Person(name) {this.name = name;};Person.prototype.getName = function() {return this.name;};var p = new Person("红红");console.log(p.constructor === Person); // trueconsole.log(Person.prototype.constructor === Person); // true// 将上两行代码合并就得到如下结果console.log(p.constructor.prototype.constructor === Person); // true
当我们重新定义函数的prototype时 (注意:和上例的区别,这里不是修改而是覆盖) ,constructor 的行为就有点奇怪了,
例:
function Person(name) {this.name = name;};Person.prototype = {getName: function() {return this.name;}};var p = new Person("ZhangSan");console.log(p.constructor === Person); // falseconsole.log(Person.prototype.constructor === Person); // falseconsole.log(p.constructor.prototype.constructor === Person); // false
出现上面代码结果的原因是因为覆盖Person.prototype时,等价于进行如下代码操作:
Person.prototype = new Object({getName: function() {return this.name;}});
而constructor始终指向创建自身的构造函数,所以此时Person.prototype.constructor === Object,即是:
function Person(name) {this.name = name;};Person.prototype = {getName: function() {return this.name;}};var p = new Person("红红");console.log(p.constructor === Object); // trueconsole.log(Person.prototype.constructor === Object); // trueconsole.log(p.constructor.prototype.constructor === Object); // true
下面是修改这种问题的方法,很简单,就是重新覆盖Person.prototype.constructor :
function Person(name) {this.name = name;};Person.prototype = new Object({getName: function() {return this.name;}});Person.prototype.constructor = Person; //让它重新在指向自身的构造函数var p = new Person("ZhangSan");console.log(p.constructor === Person); // trueconsole.log(Person.prototype.constructor === Person); // trueconsole.log(p.constructor.prototype.constructor === Person); // true
七、 对象的 __proto__ 隐式原型
上面我们创建了两个对象,person1和person2,这两个对象,也都指向了Person构造函数的原型,这是因为每个对象都有一个隐藏的属性“__proto__”,这个属性引用了创建这个对象的函数的prototype。 即:person1.__proto__ === Person.prototype
这个__proto__是一个隐藏的属性,javascript不希望开发者用到这个属性值,有的低版本浏览器甚至不支持这个属性值。
用它的代码如下:
console.log(Object.prototype);var obj = new Object();console.log(obj.__proto__);
你会发现打印了相同的内容:
obj这个对象本质上是被Object函数创建的,因此obj.__proto__=== Object.prototype。可以用一个图来表示。
转载于:https://www.cnblogs.com/Waiting-for-you/p/4106169.html
JavaScript 面向对象 (prototype 原型模式)相关推荐
- JavaScript为什么使用原型模式而不是类模式
导言: 作为JavaScript初学者的本菜鸡而言,刚一开始接触这门语言我就被他的原型模式给吓到了.并且在相当长的一段时间之内,我都完全不能理解或者不能接受这个模式.直到最近经过多方调查和思考才有所明 ...
- Prototype原型模式(创建型模式)
1.原型模式解决的问题 现在有一个抽象的游戏设施建造系统,负责构建一个现代风格和古典风格的房屋和道路. 前提:抽象变化较慢,实现变化较快(不稳定) 整个抽象的游戏设施建造系统相对变化较慢,本例中只有一 ...
- Prototype 原型模式
一.意图:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.(Specify the kinds of objects to create using a prototypical in ...
- 面向对象设计模式纵横谈:Prototype 原型模式(笔记记录)
有一段时间没写东西了,今天继续把没写完的设计模式写完,今天这堂课是创建型设计模式的最后一堂课,原型设计模式,它同样也是解决了对象在创建的过程中的解耦合的情况,面对变化使代码更稳定,更准确的说是使 ...
- 有关javaScript面向对象和原型笔记
javaScript是一种比较特殊的语言,ECMAScript中没有类的概念,跟其他面向对象的语言有一定的区别,它的对象也与基于类的语言中的对象有所不同,严格来说,javascript对象是一组没有特 ...
- JavaScript面向对象及原型 及setTimeout
JavaScript面向对象 最笨的写法: function Foo(n) { this.name = n; this.sayName = function() { c ...
- JavaScript --- [学习笔记] 原型模式
说明 接JavaScript - > [学习笔记]观察者模式 & 理解对象 & 工厂模式 & 构造函数模式 上一篇构造函数模式创建的实例,不同实例的同一个方法是不相等的, ...
- JavaScript面向对象和原型函数
对象,是javascript中非常重要的一个梗,是否能透彻的理解它直接关系到你对整个javascript体系的基础理解,说白了,javascript就是一群对象在搅..(哔!). 常用的几种对象创建模 ...
- 设计模式(7)[JS版]-JavaScript设计模式之原型模式如何实现???
目录 1.什么是原型模式 2 参与者 3 实例讲解 4 使用 Object.create实现原型模式 4.1 Object.create()的用法 4.2 用 Object.create实现继承 4. ...
最新文章
- R语言基于机器学习算法进行特征筛选(Feature Selection)
- python代码转成java_如何实现Java代码转换成python代码
- 机器学习算法加强——决策树和随机森林实践
- 大学 University
- 【移动端vue ui框架学习】vue项目如何使用基于vue的UI框架mint ui
- Java实现生产消费模型的5种方式
- php辅助框架,【PHP开发框架】Laravel框架中辅助函数:optional ()函数的介绍
- catkin_make
- 修复完整运营版-苹果cms影视电影小程序源码
- [.net 面向对象程序设计进阶] (9) 序列化(Serialization) (一) 二进制流序列化
- 程序员面试问题资源经验
- linux sql 语句菜鸟,sql语句
- Netch游戏加速器自建(糖豆人Free就是研究的动力)
- 计算器代码编程c#语言,C#计算器编写代码
- AutoCAD将DWG图纸转为PNG图片
- 【知识图谱】OpenKG开源系列 | 海洋鱼类百科知识图谱(浙江大学)
- linux 中gnu的含义是,GNU是什么意思
- 7-4 查询水果价格 PTA
- python输出二进制数_Python计算二进制数及输出补码
- 2021年美国对中国货物出口情况:美对中的出口额达到1492亿美元,同比增长21.30% [图]
热门文章
- php windows应用开发,开发老手谈Windows平台的PHP应用开发
- html监听页面关闭事件,JS针对浏览器窗口关闭事件的监听方法集锦
- 2021年春季学期-信号与系统-第十五次作业参考答案-第一小题参考答案
- 第十六届全国大学生智能车汽车竞赛第二次扩大会议
- 第十六届智能车竞赛创意组比赛-筹划初稿
- 新车模、新舵机、新体验
- 多媒体-设备的名称已被此应用程序用作别名,请使用唯一的别名
- html 一条线两种颜色,HTML5/CSS3超酷进度条 不同进度多种颜色
- bad cpu type in executable_【简讯】Intel将每5年重新开发一次CPU架构;华为EMUI 11曝光…...
- c语言常量类型转换,c语言基础教程常量变量和类型转换,免费版.doc