精华内容
下载资源
问答
  • 构造函数模式

    2019-02-28 15:38:16
    一、什么是构造函数模式? 根据javascript高级程序设计第3版中的定义: ECMAScript中的构造函数可用来创建特定类型的对象。 二、为什么需要构造函数模式? 三、什么叫实例? 构造函数是使用new操作符来创建一...

    一、什么是构造函数模式?

    根据javascript高级程序设计第3版中的定义:

    ECMAScript中的构造函数可用来创建特定类型的对象。

     

    二、为什么需要构造函数模式? 

    三、什么叫实例? 

    构造函数是使用new操作符来创建一个新对象。

    所以,实例是一个新的对象。

    四、构造函数的执行

    1、构造函数与其他函数的唯一区别,就在于调用它们的方式不同。任何函数,只要通过new操作符来调用,那它就可以作为构造函数; 而任何函数,如果不通过new操作符来调用,那它跟普通函数也不会有什么两样。

    不过,构造函数毕竟也是函数,不存在定义构造函数的特殊语法。

    // 当做构造函数使用
    var person = new Person("hello", 29);
    person.sayHello();     // "hello"
    
    // 当做普通函数调用
    Person("world", 28);  // 添加到window
    window.sayHello();    // "world"

    这个例子中的前两行代码展示了构造函数的典型用法,即使用new操作符来创建一个新对象。

    因为构造函数本身也是函数,只不过可以用来创建对象而已。 

    构造函数最大的作用,就是可以用来创建一个新对象。

    五、创建一个数组

    var ary = [];   // 字面量方式
    var ary = new Array();   // 实例创建的方式,也是构造函数模式执行的方式

     

    展开全文
  • 组合使用构造函数模式和原型模式 ——使用广泛、认同度高的一种创建自 定义类型的方法 构造函数模式用于定义实例属性, 原型模式用于定义方法和共享的属性。 结果,每个实例都会有自己的一份实例属性的副本, 但同时...

    组合使用构造函数模式和原型模式

    ——使用广泛、认同度高的一种创建自 定义类型的方法

    构造函数模式用于定义实例属性
    原型模式用于定义方法和共享的属性

    结果,每个实例都会有自己的一份实例属性的副本, 但同时又共享着对方法的引用,大限度地节省了内存。另外,这种混成模式还支持向构造函数传递参 数;可谓是集两种模式之长。

    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 
    
    1. 动态原型模式
      在这里插入图片描述
    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()方法不存在的情况下,才会将它添加到原 型中
    这段代码只会在初次调用构造函数时才会执行。此后,原型已经完成初始化

    采用这种模式创建的对象,还可以使 用 instanceof 操作符确定它的类型。

    使用动态原型模式时,不能使用对象字面量重写原型。前面已经解释过了,如果 在已经创建了实例的情况下重写原型,那么就会切断现有实例与新原型之间的联系

    1. 寄生构造函数模式

    通常,在前述的几种模式都不适用的情况下,可以使用寄生(parasitic)构造函数模式

    这种模式 的基本思想是创建一个函数,该函数的作用仅仅是封装创建对象的代码,然后再返回新创建的对象;但 从表面上看,这个函数又很像是典型的构造函数

    function Person(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 friend = new Person("Nicholas", 29, "Software Engineer");
    // 工厂模式:var friend = Person("Nicholas", 29, "Software Engineer");
    friend.sayName(); //"Nicholas" 
    

    除了使用 new 操作符并把使用的包装函数叫做构造函数之外,这个模式跟工厂模式其实 是一模一样的

    构造函数在不返回值的情况下,默认会返回新对象实例。而通过在构造函数的末尾添加一个 return 语句,可以重写调用构造函数时返回的值

    这个模式可以在特殊的情况下用来为对象创建构造函数。假设我们想创建一个具有额外方法的特殊 数组。由于不能直接修改 Array 构造函数,因此可以使用这个模式。

    function SpecialArray(){
     	//创建数组
     	var values = new Array();
     	//添加值
     	values.push.apply(values, arguments);
     	//添加方法
     	values.toPipedString = function(){
     		return this.join("|");
     	};
    
     	//返回数组
     	return values;
    }
    var colors = new SpecialArray("red", "blue", "green");
    alert(colors.toPipedString()); //"red|blue|green" 
    

    push()方法(用构造函数接收到的所有参数)初始化了数组的值

    返回的 对象 与 构造函数 或者与 构造函数的原型属性 之间没有关系;也就是说,构造函数返回的对象与在构造函数外部创建的对象没有什么不同。为此, 不能依赖 instanceof 操作符来确定对象类型。
    由于存在上述问题,我们建议在可以使用其他模式的情 况下,不要使用这种模式。

    1. 稳妥构造函数模式

    道格拉斯·克罗克福德(Douglas Crockford)发明了 JavaScript中的 稳妥对象(durable objects) 这 个概念。

    所谓稳妥对象,指的是没有公共属性,而且其方法也不引用 this 的对象
    稳妥对象适合在 一些安全的环境中(这些环境中会禁止使用 this 和 new),或者在防止数据被其他应用程序(如 Mashup 程序)改动时使用

    稳妥构造函数遵循与寄生构造函数类似的模式,但有两点不同:
    一是新创建对象的 实例方法不引用 this;
    二是不使用 new 操作符调用构造函数

    function Person(name, age, job){
    	//创建要返回的对象
     	var o = new Object();
    	//可以在这里定义私有变量和函数
     	//添加方法
     	o.sayName = function(){
     		alert(name);
     	};
     	//返回对象
     	return o;
    } 
    

    在以这种模式创建的对象中,除了使用 sayName()方法之外,没有其他办法访问 name 的值。 可以像下面使用稳妥的 Person 构造函数

    var friend = Person("Nicholas", 29, "Software Engineer");
    friend.sayName(); //"Nicholas" 
    

    变量 friend 中保存的是一个稳妥对象,而除了调用 sayName()方法外,没有别的方式可 以访问其数据成员。

    即使有其他代码会给这个对象添加方法或数据成员,但也不可能有别的办法访问传 入到构造函数中的原始数据。稳妥构造函数模式提供的这种安全性,使得它非常适合在某些安全执行环 境——例如,ADsafe(www.adsafe.org)和 Caja(http://code.google.com/p/google-caja/)提供的环境—— 下使用。

    与寄生构造函数模式类似,使用稳妥构造函数模式创建的对象与构造函数之间也 没有什么关系,因此 instanceof 操作符对这种对象也没有意义

    展开全文
  • 承接上一篇,在JS中组合使用构造函数模式与原型模式创建对象,今天接着说剩下几种模式: 动态原型模式 寄生构造函数模式(parasitic) 稳妥构造函数模式(durable) 动态原型模式 动态原型模式把所有信息都封装到...

    承接上一篇,在JS中组合使用构造函数模式与原型模式创建对象,今天接着说剩下几种模式:

    动态原型模式
    寄生构造函数模式(parasitic)
    稳妥构造函数模式(durable)
    动态原型模式

    动态原型模式把所有信息都封装到构造函数中,而通过在构造函数中初始化原型(仅在必要的条件下),又保持了同时使用构造函数和原型的优点。即可以检查某个应该存在的方法是否有效,来决定是否需要初始化原型,看下面:

    function Person(name,age,gender){
        this.name = name;
        this.age = age;
        this.gender = gender;

        if(typeof this.sayName != "function"){
            Person.prototype.sayName = function(){
                alert(this.name);
            };
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    这里需要说明的是if里代码只会在初次调用构造函数时才会执行,当然了,下次调用构造函数时,this.sayName已经存在嘛,而且if里对原型所在的修改会立即在所有实例中得到反映,这里可能就是体现其动态的所在之处。同样,这里要记住不能使用对象字面量重写原型,上篇中已提到过,如果在已经创建了实例的情况下重写原型,那么就会切断现有实例与新原型之间的联系。

    寄生构造函数模式

    先看下面的代码:

    function SpecialArray(){
        var array = new Array();
        array.push.apply(array,arguments);
        array.toPipedString = function(){
            return this.join("|");
        };
        return array;
    }
    var colors = new SpecialArray("red","green","pink");
    alert(colors.toPipedString());// red|green|pink
    alert(colors instanceof SpecialArray); // false 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    详细说明下,我们知道当我们自定义一个构造函数后,使用new的方式来创建一个对象时,默认会返回一个新对象实例,构造函数中是没有return 语句的。而这里所谓的寄生构造函数,基本思想是创建一个函数,这个函数的作用仅仅是为了某一个特定的功能而添加一些代码,最后再将这个对象返回,除了使用了new操作符并把包装的函数叫做构造函数外,这个模式跟工厂模式没有任何区别。另外,这个SpecialArray()返回的对象,与SpecialArray()构造函数或者与构造函数的原型对象之间没有任何关系,就像你在SpecialArray()外面创建的其他对象一样,所以如果用instanceof操作符来检测的话,结果只能是false咯。所以这是它的问题

    稳妥构造函数模式

    先说稳妥二字,别人定义了一个稳妥对象,即没有公共属性,而且其方法也不引用this对象,这种模式适应于一些安全环境中(禁止使用this和new),或防止数据被其他应用程序改动,像下面这样:

    function Person(name,age,gender){
        var obj = new Object();
        obj.sayName = function(){
            alert(name);
        };
        return obj;
    }
    var person = Person("Stan",0000,"male"); // 这里没有使用new操作符
    person.sayName(); // Stan
    alert(person instanceof Person); // false
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    说明一下,这里person中保存了一个稳妥对象,除了调用sayName()方法外,没有别的方式可以访问其数据成员。即使有其他代码会给这个对象添加方法或属性,但也不可能有别的办法访问传入到构造函数中的原始数据 。同样与寄生函数模式类似,使用稳妥构造函数模式创建的对象与构造函数之间也没有任何关系.
    --------------------- 
    作者:Stangor 
    来源:CSDN 
    原文:https://blog.csdn.net/stanxl/article/details/51111129 
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • 寄生构造函数模式 这种模式的基本思想是创建一个函数,该函数的作用仅仅是封装创建对象的代码,然后再返回新创建的对象,跟工厂模式很像,但是这里是使用 new 操作符并把使用的包装函数叫做构造函数 function ...

    寄生构造函数模式

    这种模式的基本思想是创建一个函数,该函数的作用仅仅是封装创建对象的代码,然后再返回新创建的对象,跟工厂模式很像,但是这里是使用 new 操作符并把使用的包装函数叫做构造函数

        function Person(name, age, job) {
            var o=new Object();
            o.name = name;
            o.age = age;
            o.job = job;
            o.getName=function(){
                console.log(this.name);
            }
            return o;
        }
        var per=new Person("zw",21,"student");
        per.getName();//zw

    这个模式可以在特殊的情况下用来为对象创建构造函数。假设我们想创建一个具有额外方法的特殊数组,由于不能直接修改 Array 构造函数,因此可以使用这个模式。

       function SpecialArray(){
            //创建数组
            var values=new Array();
            //添加值
            values.push.apply(values,arguments);
            //添加方法
            values.toPipedString=function(){
                return this.join("|");
            };
            return values;
        }
        var colors=new SpecialArray("blue","red","black");
        console.log(colors.toPipedString());//blue|red|black

    构造函数返回的对象与在构造函数外部创建的对象没有什么不同。为此,不能依赖 instanceof 操作符来确定对象类型。

     console.log(colors instanceof SpecialArray);//false

    稳妥构造函数模式

    稳妥对象: 没有公共属性,而且其方法也不引用 this 的对象。

    稳妥对象最适合在一些安全的环境中(这些环境中会禁止使用 this 和 new ),或者在防止数据被其他应用程序(如 Mashup
    程序)改动时使用。

    稳妥构造函数遵循与寄生构造函数类似的模式,但有两点不同:

             1.新创建对象的实例方法不引用 this

              2.不使用 new 操作符调用构造函数

       function Person(name,age,job) { 
            var o=new Object();
            o.name=name;
            o.age=age;
            o.job=job;
            o.getName=function(){
                console.log(name);
            };
            return o;
        }
        var per=Person("zw",20,"student");
        per.getName();//zw

    在以这种模式创建的对象中,除了使用 getName() 方法之外,没有其他办法访问 name 的值。

    与寄生构造函数模式类似,使用稳妥构造函数模式创建的对象与构造函数之间也没有什么关系,因此 instanceof 操作符对这种对象也没有意义。

     

    展开全文
  • 看这两名字,都带构造函数,一个寄生一个稳妥。那么,先来回忆一下构造函数模式: 在这里插入代码片
  • js-—动态原型模式、寄生构造函数模式、稳妥构造函数模式 1.动态原型模式(要new): 举例: function Model(name,age,hobby){ this.name = name; this.age = age; this.hobby = hobby; //...
  • 本文实例讲述了JavaScript设计模式之构造函数模式。分享给大家供大家参考,具体如下: 一、构造函数模式概念 构造函数用于创建特定类型的对象——不仅声明了使用过的对象,构造函数还可以接受参数以便第一次创建对象...
  • 主要介绍了javascript组合使用构造函数模式和原型模式的方法,通过一个简单实例分析了javascript构造函数模式与原型模式的使用方法,需要的朋友可以参考下
  • chuangjian自定义类型的最常见方式就是组合使用构造函数模式与原型模式,构造函数模式用于定义实力属性,原型模式定义方法和共享的属性。 寄生构造函数: 原来的写法 var array1 = ['1','2'];var array2 = ['1','...
  • Javascript 设计模式之构造函数模式.zip
  • 寄生构造函数模式和稳妥构造函数模式
  • 1.构造函数模式 1)构造函数可以用来创建特定类型的对象,能够识别对象 function Person(name,age,job){ this.name=name; this.age-age; this.job=job; this.sayName=function(){ alert(this.name); }; } ...
  • 构造函数模式 构造函数用于创建特定类型的对象,不仅声明了使用的对象,构造函数还可以接受参数以便第一次创建对象的时候设置对象的成员值。你也可以自定义自己的构造函数,然后在里面声明自定义类型对象的属性或...
  • prototype就是通过调用构造函数而创建的那个对象实例的原型对象,使用原型对象的好处是可以让所有对象实例共享包含的属性和方法。 什么叫让所有对象实例共享包含的属性和方法 直接在对象实例上定义方法的缺点是,...
  • 2》构造函数模式 1.和工厂模式区别: 构造函数中,不需要在内部创建对象(更不需要给这个对象添加属性、方法,也不用return 对象) 2.如果要写构造函数模式,函数的首字母需要大写 new Array() new String() new ...
  • 寄生构造函数模式

    2018-07-12 21:20:58
    当在构造函数模式,原型模式,组合使用构造函数模式与原型模式、动态原型模式这几种模式都不适用的情况下可以shiyong这种模式基本思想四创建一个函数,该函数的作用仅仅是fnegxhaunfunction Person(name,age,job){ ...
  • 为什么要让稳妥构造函数模式中的方法不引用this的对象呢?能稍微说下稳妥构造函数吗?
  • 本文主要对javascript工厂模式和构造函数模式创建对象方法进行解析,具有一定的参考价值,下面跟着小编一起来看下吧
  • 一、构造函数模式概念 构造函数用于创建特定类型的对象——不仅声明了使用过的对象,构造函数还可以接受参数以便第一次创建对象的时候设置对象的成员值。你可以自定义自己的构造函数,然后在里面声明自定义类型对象...
  • 在本文中,我会描述 7 种常用的创建自定义类型的模式:工厂模式、构造函数模式、原型模式、组合使用构造函数模式、动态原型模式、寄生构造函数模式、稳妥构造函数模式。分别给出他们的示例代码,并分析他们的利弊,...
  • 6.2.2 构造函数模式

    2018-01-05 15:34:17
    ES中的构造函数可以用来创建特定类型的对象;像Object跟Array这样的原生构造函数,再运行时会自动出现在执行环境中;此外,也可以创建自定义...(1)构造函数模式: 工厂模式: (2)二者的对比:(二者都有参数
  • 创建自定义类型最常见的就是组合使用构造函数模式和原型模式。构造函数模式用于定义实例的属性。而原型模式我们上节了解到,主要是用于定义公用的属性和方法。 首先看一下构造函数模式创建js对象.1. 构造函数模式 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,089
精华内容 6,835
关键字:

构造函数模式