本文给大家 js 创建对象的模式包括对象字面量,工厂模式,构造函数模式,原型模式,结合构造函数和原型模式,原型动态模式 ,感兴趣的朋友参考下
Javascript 是一种由 Netscape 的 LiveScript 发展而来的原型化继承的基于对象的动态类型的区分大小写的客户端脚本语言,主要目的是为了解决服务器端语言,比如 Perl,遗留的速度问题,为客户提供更流畅的浏览效果。
JavaScript 中创建对象的模式汇总
**JavaScript 创建对象模式:
对象字面量
工厂模式
构造函数模式
原型模式
结合构造函数和原型模式
原型动态模式
**
面向对象的语言大都有一个类的概念,通过类可以创建多个具有相同方法和属性的对象。虽然从技术上讲,javascript 是一门面向对象的语言,但是 javascript 没有类的概念,一切都是对象。任意一个对象都是某种引用类型的实例,都是通过已有的引用类型创建;引用类型可以是原生的,也可以是自定义的。
1、对象字面量
- var person = {
- name : 'Nicholas';
- age : '22';
- job :"software Engineer"
- sayName: function() {
- alter(this.name);
- }
- }
例子中创建一个名为 person 的对象,并为它添加了三个属性(name,age,job)和一个方法(sayName()),其中,sayName() 方法用于显示 this.name(被解析为 person.name) 的值。
对象字面量可以用来创建单个对象,但这个方法有个明显的缺点:使用同一个接口创建很多对象,会产生大量重复的代码。
2、工厂模式
工厂模式是软件工程领域中一种广为人知的设计模式,工厂模式抽象了创建具体对象的过程,用函数来封装以特定的接口创建对象的细节。
- function createPerson(name,age,job){
- var o = new object{};
- o.name=name;
- o.age=age;
- o.job=job;
- o.sayName=function(){
- alert(this.name);
- };
- return o;
- }
- var person1=creatPerson("Nicholas",22,"software Engineer");
- var person2=creatPerson("Greg",24,"student");
函数 creatPerson{} 能够根据接受的参数构建一个包含所有必要信息的 Person 对象。可以无数次的调用这个函数,每次都会返回一个包含三个属性一个方法的对象。
工厂模型虽然解决了创建多个相似对象的问题,却没有解决对象识别的问题(即怎么知道一个对象的类型)。
3、构造函数模式
- function Person(name, age, job) {
- this.name = name;
- this.age = age;
- this.job = job;
- this.sayName = function() {
- alert(this.name);
- }
- }
- //通过new操作符创建Person的实例
- var person1 = new Person("Nicholas", 22, "software Engineer");
- var person2 = new Person("Greg", 24, "student");
- person1.sayName(); //Nicholas
- person2.sayName(); //Greg
与工厂模式不同的是
没有显示的创建对象
直接将属性和方法赋给了 this 对象
没有 return 语句
创建 Person 的新实例,必须使用 new 操作符。调用构造函数的 4 个步骤:
创建一个新对象
将构造函数的作用域赋给新对象(this 指向了这个新对象)
执行构造函数中的代码
返回新对象
这个例子中创建的所有对象既是 Object 的实例,也是 Person 实例。可以通过 instanceof 操作符验证。
- alert(person1 instanceof Object); //true
构造函数模式也有自己的问题,实际上,sayName 方法在每个实例上都会被重新创建一次,需要注意的是,通过实例化创建的方法并不相等,以下代码可以证明
- alert(person1.sayName == person2.sayName); //false
可以将方法移到构造器的外部作为全局函数来解决这个问题。
- function Person(name,age,job) {
- this.name = name;
- this.age = age;
- this.job = job;
- }
- function sayName() {
- alert(this.name);
- }
在全局下创建的全局函数实际上只能被经由 Person 创建的实例调用,这就有点名不副实了;如果对象需要定义很对方法,那么就要定义很多个全局函数,缺少封装性。
4、原型模式
JavaScript 中创建的每个函数都有一个 prototype(原型)属性,它是一个指针,指向一个对象,包含了可以由特定类型的所有实例共享的属性和方法(让所有的对象实例共享它的属性和方法)
- function Person() {}
- Person.prototype.name = "Nicholas";
- Person.prototype.age = 22;
- Person.prototype.job = "software Engineer";
- Person.prototype.sayName() {
- alert(this.name);
- };
- var person1 = new Person();
- person1.sayName(); //Nicholas
- alert(person1.sayName == person2.sayName); //true
以上代码做了这几件事情:
定义了一个构造函数 Person,Person 函数自动获得一个 prototype 属性,该属性默认只包含一个指向 Person 的 constructor 属性
通过 Person.prototype 添加三个属性,和一个方法
创建一个 Person 的实例,随后在实例上调用了 sayName() 方法
使用 Person 构造函数和 Person.prototype 创建实例的代码为例,展示个对象之间的关系
使用 Person 构造函数和 Person.prototype 创建实例的代码为例,展示个对象之间的关系
图中展示了 Person 构造函数、Person 的原型属性以及 Person 的两个实例,之间的关系。Person.prototype 指向了原型对象,Person.prototype.constructor 有指回了 Person。原型对象中除了包含 constructor 属性,还包含后来添加的其他属性和方法,Person 的两个实例 person1 和 person2 都包含一个内部属性,该属性仅指向 Person.prototype。
sayName() 方法的调用过程:
在 person1 实例上查找 logName() 方法,发现没有这个方法,于是追溯到 person1 的原型
在 person1 的原型上查找 sayame() 方法,有这个方法,于是调用该方法
基于这样一个查找过程,我们可以通过在实例上定义原型中的同名属性,来阻止该实例访问原型上的同名属性,需要注意的是,这样做并不会删除原型上的同名属性,仅仅是阻止实例访问。
- function Person() {}
- Person.prototype.name ="Nicholas";
- Person.prototype.age = 22;
- Person.prototype.job = "software Engineer";
- Person.prototype.sayName(){
- alert(this.name);
- };
- var person1 = new Person();
- var person2 = new Person();
- person1.name="Greg"
- alert(person1.name) //Greg 来自实例
- alert(person2.name) //Nicholas 来自原型
使用 delete 操作符可以完全删除实例属性
- delete person1.name;
- alert(person1.name) //Nicholas 来自原型
使用 hasOwnProperty() 方法可以检测一个属性是存在于实例还是原型中
- function Person() {}
- Person.prototype.name ="Nicholas";
- Person.prototype.age = 22;
- Person.prototype.job = "software Engineer";
- Person.prototype.sayName(){
- alert(this.name);
- };
- var person1 = new Person();
- var person2 = new Person();
- alert(person1,hasOwnProperty("name"));//false
- person1.name="Greg"
- alert(person1.name) //Greg 来自实例
- alert(person1,hasOwnProperty("name"));//true
- alert(person2.name) //Nicholas 来自原型
- alert(person2,hasOwnProperty("name"));//false
- delete person1.name;
- alert(person1.name) //Nicholas 来自原型
- alert(person1,hasOwnProperty("name"));//false
下图展示了在不同情况下实例与原型之间的关系
简单的原型语法
- function Person() {}
- Person.prototype = {
- name:"Nicholas",
- age:22,
- job:"software Engineer",
- sayName:
- function() {
- alert(this.name);
- }
- };
在上面的代码中 constructor 属性不再指向 Person 了,通过 constructor 无法确定对象的类型了。可以像下面这样特意将他设置回适当的值
- function Person() {}
- Person.prototype = {
- constructor: Person,
- name:"Nicholas",
- age:22,
- job:"software Engineer",
- sayName:
- function() {
- alert(this.name);
- }
- };
重设 constructor 属性会导致它的 [[Enumerable]] 特性被设置为 true,默认情况,原生的 constructor 属性是不可枚举的,可以使用 Object.defineProperty()方法来改变
- Object.defineProperty(Person.prototype,"constructor",{
- enumerable:false,
- value:Person
- });
原型中查找值的过程是一次搜索,原型对象所做的任何修改都能从实例上立即反应出来
- var friend=new Person();
- Person.prototype.sayHi=function(){
- alert("hi);
- }
- friend,sayHi();//"hi"(没有问题)
person 实例是在添加新方法之前创建的,但仍可以访问新添加的方法,原因是实例与原型之间的松散连接关系
重写原型对象后的情况
- function Person() {}
- var friend = new Person();
- Person.prototype = {
- name:"Nicholas",
- age:22,
- job:"software Engineer",
- sayName:
- function() {
- alert(this.name);
- }
- };
- friend.sayName(); //error
调用 friend.sayName() 时发生错误的原因是,friend 指向的原型中不包含以该字段命名的属性,如下图。
原型对象的问题
原型对象省略了为构造函数传递初始化参数这一环节,所有势力在默认情况下都取得相同的属性值。原型模型最大的问题是有其共享本性所导致的。当原型模型包含引用类型的属性来说,问题就比较严重了。来看下面的例子。
- function Person() {}
- Person.prototype = {
- constructor: Person,
- name:"Nicholas",
- age:22,
- job:"software Engineer",
- friends: ["Shelby", "Court"],
- sayName:
- function() {
- alert(this.name);
- }
- };
- var person1 = new Person();
- var person2 = new Person();
- person1.friend.push("Van");
- alert(person1.friends); //"Shelby,Court,Van"
- alert(person2.friends); //"Shelby,Court,Van"
- alert(person1.friends == person2.friends); //true
5、组合使用构造函数模式和原型模式
组合使用构造函数模式和原型模式中,构造函数用于定义实例属性,原型模型用于定义方法和共享的属性。这样每个实例都会有自己的一份实例属性的副本,同时也可以共享对方法的引用,最大限度的节省了内存。
- 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", 22, "software Engineer");
- var person2 = new Person("Greg", 24, "student");
- person1.friend.push("Van");
- alert(person1.friends); //"Shelby,Court,Van"
- alert(person2.friends); //"Shelby,Court"
- alert(person1.friends == person2.friends); //false
- alert(person1.sayName == person2.sayName); //true
6、动态原型模式
原型动态模式将需要的所有信息都封装到构造函数中,通过 if 语句判断原型中的某个属性是否存在,若不存在(在第一次调用这个构造函数的时候),执行 if 语句内部的原型初始化代码。
- function Person(name, age) {
- 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', '22', 'Software Engineer'); //初次调用构造函数,此时修改了原型
- var person2 = new Person('amy', '21'); //此时sayName()方法已经存在,不会再修改原型
推荐阅读:
来源: http://www.phperz.com/article/17/0401/266254.html