精华内容
参与话题
问答
  • prototype

    2016-05-30 14:25:53
    prototype:显示原型。每一个函数对象都有一个显示的prototype属性,它代表了对象的原型(Function.prototype函数对象是个例外,没有prototype属性)。 __proto__:隐式原型。每个对象都有一个名为__proto__的内部隐藏...

       prototype:显示原型。每一个函数对象都有一个显示的prototype属性,它代表了对象的原型(Function.prototype函数对象是个例外,没有prototype属性)。
            __proto__:隐式原型。每个对象都有一个名为__proto__的内部隐藏属性,指向于它所对应的原型对象(chrome、firefox中名称为__proto__,并且可以被访问到)。原型链正是基于__proto__才得以形成(注:不是基于函数对象的属性prototype)。


    一些自己的练习。

    1.

    function A(){ };

    A.prototype.aa = 10;
    A.prototype.setOneName = function(oneName){
    this.aa = oneName;
    }

    A.prototype.setOneName("fanfan");

    var one = new A();
    console.log("one : " , one);
    console.log("one.aa : ", one.aa);
    console.log("A.prototype.aa : ",A.prototype.aa);

    输出结果如下:

    one.aa的值应该是从原型上找到的值,而不是它自己的属性。


    2.

    function A(){ };

    A.prototype.aa = 10;
    A.prototype.setOneName = function(oneName){
    this.aa = oneName;
    }

    A.prototype.setOneName("fanfan");

    var one = new A();
    console.log("one : " , one);
    console.log("one.aa : ", one.aa);
    console.log("A.prototype.aa : ",A.prototype.aa);


    one.setOneName("jingjing");
    console.log("one : ",one);
    console.log("one.aa : ", one.aa);
    console.log("A.prototype.aa : ",A.prototype.aa);

    输出结果如下:


    可见,在one没有setOneName之前,one.aa输出的是原型中的aa。在one.setOneName("jingjing");执行之后,one.aa已经改变,但是原型中的并没有改变。但是第一次输出的aa也是“jingjing”,我觉得是因为第二次设置了之后就已经改变了它的值,所以第一次输出的时候就有了这个值。


    3.

    function A(){ };

    A.prototype.aa = 10;
    A.prototype.setOneName = function(oneName){
    this.aa = oneName;
    }

    A.prototype.setOneName("fanfan");

    var one = new A();
    console.log("one : " , one);
    console.log("one.aa : ", one.aa);
    console.log("A.prototype.aa : ",A.prototype.aa);

    one.setOneName("jingjing");
    console.log("one : ",one);
    console.log("one.aa : ", one.aa);
    console.log("A.prototype.aa : ",A.prototype.aa);

    A.prototype.setOneName("haha");
    console.log("one : ",one);
    console.log("one.aa : ", one.aa);
    console.log("A.prototype.aa : ",A.prototype.aa);

    输出结果如下:


    有一个问题,


    为什么这部分一直是一样的?

    原型中的aa的值是一样的,但是输出的时候却不是一样的。



    4.

    function A(){ };

    A.prototype.aa = 10;
    A.prototype.setOneName = function(oneName){
    this.aa = oneName;
    }

    A.prototype.setOneName("fanfan");

    var one = new A();
    console.log("one : " , one);
    console.log("one.aa : ", one.aa);
    console.log("A.prototype.aa : ",A.prototype.aa);

    one.setOneName("jingjing");
    A.prototype.setOneName("haha");


    console.log("-----------------------");
    var another = new A();
    another.setOneName("aaa");
    console.log("one : ",one);
    console.log("one.aa : ", one.aa);
    console.log("A.prototype.aa : ",A.prototype.aa);
    console.log("another : ",another);
    console.log("another.aa : ", another.aa);
    console.log("A.prototype.aa : ",A.prototype.aa);

    输出结果如下:


    设置another的aa的值并没有更改one.aa的值。


    5.原型链

    function A(){ };

    A.prototype.aa = 10;
    A.prototype.setOneName = function(oneName){
    this.aa = oneName;
    }

    A.prototype.setOneName("fanfan");

    var one = new A();

    console.log("one.__proto__ === A.prototype  :  ", one.__proto__ === A.prototype) //true
    console.log("A.prototype.__proto__ === Object.prototype  :  ", A.prototype.__proto__ === Object.prototype) //true
    console.log("Object.prototype.__proto__  :  ", Object.prototype.__proto__) //null

    输出结果如下:



    展开全文
  • Prototype

    2016-08-19 19:07:44
    Prototype 描述 Prototype 提供的函数可使 HTML DOM 编程更容易。 与 jQuery 类似,Prototype 也有自己的 $() 函数。 $() 函数接受 HTML DOM 元素的 id 值(或 DOM 元素),并会向 DOM 对象添加新的功能。 与 jQuery...
    Prototype 描述
    Prototype 提供的函数可使 HTML DOM 编程更容易。
    与 jQuery 类似,Prototype 也有自己的 $() 函数。
    $() 函数接受 HTML DOM 元素的 id 值(或 DOM 元素),并会向 DOM 对象添加新的功能。
    与 jQuery 不同,Prototype 没有用以取代 window.onload() 的 ready() 方法。相反,Prototype 会向浏览器及 HTML DOM 添加扩展。
    在 JavaScript 中,您可以分配一个函数以处理窗口加载事件:
    JavaScript 方式:
    function myFunction()
    {
    var obj=document.getElementById("h01");
    obj.innerHTML="Hello Prototype";
    }
    οnlοad=myFunction;

    等价的 Prototype 是不同的:

    Prototype 方式:
    function myFunction()
    {
    $("h01").insert("Hello Prototype!");
    }
    Event.observe(window,"load",myFunction);
    Event.observe() 接受三个参数:
    您希望处理的 HTML DOM 或 BOM(浏览器对象模型)对象
    您希望处理的事件
    您希望调用的函数
    与 jQuery 相同,Prototype 允许链式语法。
    链接(Chaining)是一种在同一对象上执行多个任务的便捷方法。
    展开全文
  • 原型模式主要用于对象的复制,它的核心是就是类图中的原型类PrototypePrototype类需要具备以下两个条件: 实现Cloneable接口。在java语言有一个Cloneable接口,它的作用只有一个,就是在运行时通知虚拟机可以安全...

    用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。

     

    原型模式主要用于对象的复制,它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件:

    • 实现Cloneable接口。在java语言有一个Cloneable接口,它的作用只有一个,就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中,只有实现了这个接口的类才可以被拷贝,否则在运行时会抛出CloneNotSupportedException异常。
    • 重写Object类中的clone方法。Java中,所有类的父类都是Object类,Object类中有一个clone方法,作用是返回对象的一个拷贝,但是其作用域protected类型的,一般的类无法调用,因此,Prototype类需要将clone方法的作用域修改为public类型。

            原型模式是一种比较简单的模式,也非常容易理解,实现一个接口,重写一个方法即完成了原型模式。在实际应用中,原型模式很少单独出现。经常与其他模式混用,他的原型类Prototype也常用抽象类来替代。

    运用场景

    • 资源优化场景
    • 类初始化需要消化非常多的资源,这个资源包括数据、硬件资源等。
    • 性能和安全要求的场景
    • 通过new产生一个对象需要非常繁琐的数据准备或访问权限,则可以使用原型模式。
    • 一个对象多个修改者的场景
    • 一个对象需要提供给其他对象访问,而且各个调用者可能都需要修改其值时,可以考虑使用原型模式拷贝多个对象供调用者使用。

    在实际项目中,原型模式很少单独出现,一般是和工厂方法模式一起出现,通过clone的方法创建一个对象,然后由工厂方法提供给调用者。原型模式已经与Java融为浑然一体,大家可以随手拿来使用。

    实现代码:

    class Prototype implements Cloneable {  
        public Prototype clone(){  
            Prototype prototype = null;  
            try{  
                prototype = (Prototype)super.clone();  
            }catch(CloneNotSupportedException e){  
                e.printStackTrace();  
            }  
            return prototype;   
        }  
    }  
      
    class ConcretePrototype extends Prototype{  
        public void show(){  
            System.out.println("原型模式实现类");  
        }  
    }  
      
    public class Client {  
        public static void main(String[] args){  
            ConcretePrototype cp = new ConcretePrototype();  
            for(int i=0; i< 10; i++){  
                ConcretePrototype clonecp = (ConcretePrototype)cp.clone();  
                clonecp.show();  
            }  
        }  
    }  

    原型模式的优点及适用场景

           使用原型模式创建对象比直接new一个对象在性能上要好的多,因为Object类的clone方法是一个本地方法,它直接操作内存中的二进制流,特别是复制大对象时,性能的差别非常明显。

           使用原型模式的另一个好处是简化对象的创建,使得创建对象就像我们在编辑文档时的复制粘贴一样简单。

           因为以上优点,所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个循环体内创建对象,假如对象创建过程比较复杂或者循环次数很多的话,使用原型模式不但可以简化创建过程,而且可以使系统的整体性能提高很多。

    原型模式的注意事项

    • 使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的,它直接在内存中复制数据,因此不会调用到类的构造方法。不但构造方法中的代码不会执行,甚至连访问权限都对原型模式无效。还记得单例模式吗?单例模式中,只要将构造方法的访问权限设置为private型,就可以实现单例。但是clone方法直接无视构造方法的权限,所以,单例模式与原型模式是冲突的,在使用时要特别注意。
    • 深拷贝与浅拷贝。Object类的clone方法只会拷贝对象中的基本的数据类型,对于数组、容器对象、引用对象等都不会拷贝,这就是浅拷贝。如果要实现深拷贝,必须将原型模式中的数组、容器对象、引用对象等另行拷贝。例如:
    public class Prototype implements Cloneable {  
        private ArrayList list = new ArrayList();  
        public Prototype clone(){  
            Prototype prototype = null;  
            try{  
                prototype = (Prototype)super.clone();  
                prototype.list = (ArrayList) this.list.clone();  
            }catch(CloneNotSupportedException e){  
                e.printStackTrace();  
            }  
            return prototype;   
        }  
    }  

            由于ArrayList不是基本类型,所以成员变量list,不会被拷贝,需要我们自己实现深拷贝,幸运的是Java提供的大部分的容器类都实现了Cloneable接口。所以实现深拷贝并不是特别困难。

    深拷贝与浅拷贝问题中,会发生深拷贝的有java中的8中基本类型以及他们的封装类型,另外还有String类型。其余的都是浅拷贝。

          浅拷贝: 对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象.

       深拷贝: 对值类型的成员变量进行值的复制,对引用类型的成员变量也进行引用对象的复制.

    展开全文
  • Design Pattern - Prototype(C#)

    万次阅读 多人点赞 2019-02-02 17:29:01
    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!... Definition Specify the kind of objects to create using a prototypical instance, and create new objects by ...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net 

    Definition

    Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prototype.

    Participants

        The classes and/or objects participating in this pattern are:

    • Prototype (ColorPrototype)
      • Declares an interface for cloning itself
    • ConcretePrototype (Color)
      • Implements an operation for cloning itself
    • Client (ColorManager)
      • Creates a new object by asking a prototype to clone itself

    Sample Code in C#


    This structural code demonstrates the Prototype pattern in which new objects are created by copying pre-existing objects (prototypes) of the same class.

    /*
     * Structural Prototype Design Pattern.
     */
    
    namespace Prototype.Sample
    {
        using System;
    
        /// <summary>
        /// Startup class for Structural Prototype Design Pattern.
        /// </summary>
        internal static class Program
        {
            #region Methods
    
            /// <summary>
            /// Entry point into console application.
            /// </summary>
            private static void Main()
            {
                // Create two instances and clone each.
                var p1 = new ConcretePrototype1("I");
                var c1 = (ConcretePrototype1) p1.Clone();
                Console.WriteLine("Cloned: {0}", c1.Id);
                var p2 = new ConcretePrototype2("II");
                var c2 = (ConcretePrototype2) p2.Clone();
                Console.WriteLine("Cloned: {0}", c2.Id);
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'Prototype' abstract class.
        /// </summary>
        internal abstract class Prototype
        {
            #region Constructors and Destructors
    
            /// <summary>
            /// Initializes a new instance of the <see cref="Prototype"/> class.
            /// </summary>
            /// <param name="id">
            /// The id.
            /// </param>
            protected Prototype(string id)
            {
                Id = id;
            }
    
            #endregion
    
            #region Public Properties
    
            /// <summary>
            /// Gets the id.
            /// </summary>
            public string Id { get; }
    
            #endregion
    
            #region Public Methods and Operators
    
            /// <summary>
            /// Clone.
            /// </summary>
            /// <returns>
            /// The <see cref="Prototype"/>.
            /// </returns>
            public abstract Prototype Clone();
    
            #endregion
        }
    
        /// <summary>
        /// A 'ConcretePrototype' class.
        /// </summary>
        internal class ConcretePrototype1 : Prototype
        {
            #region Constructors and Destructors
    
            /// <summary>
            /// Initializes a new instance of the <see cref="ConcretePrototype1"/> class.
            /// </summary>
            /// <param name="id">
            /// The id.
            /// </param>
            public ConcretePrototype1(string id)
                : base(id)
            {
            }
    
            #endregion
    
            #region Public Methods and Operators
    
            /// <summary>
            /// Clone.
            /// Returns a shallow copy.
            /// </summary>
            /// <returns>
            /// The <see cref="Prototype"/>.
            /// </returns>
            public override Prototype Clone()
            {
                return (Prototype) MemberwiseClone();
            }
    
            #endregion
        }
    
        /// <summary>
        /// A 'ConcretePrototype' class.
        /// </summary>
        internal class ConcretePrototype2 : Prototype
        {
            #region Constructors and Destructors
    
            /// <summary>
            /// Initializes a new instance of the <see cref="ConcretePrototype2"/> class.
            /// </summary>
            /// <param name="id">
            /// The id.
            /// </param>
            public ConcretePrototype2(string id)
                : base(id)
            {
            }
    
            #endregion
    
            #region Public Methods and Operators
    
            /// <summary>
            /// Clone.
            /// Returns a shallow copy.
            /// </summary>
            /// <returns>
            /// The <see cref="Prototype"/>.
            /// </returns>
            public override Prototype Clone()
            {
                return (Prototype) MemberwiseClone();
            }
    
            #endregion
        }
    }
    
    // Output:
    /*
    Cloned: I
    Cloned: II
    
    */

    This real-world code demonstrates the Prototype pattern in which new Color objects are created by copying pre-existing, user-defined Colors of the same type.

    /*
     * Real-World Prototype Design Pattern.
     */
    
    namespace Prototype.RealWorld
    {
        using System;
        using System.Collections.Generic;
    
        /// <summary>
        /// Startup class for Real-World Prototype Design Pattern.
        /// </summary>
        internal static class Program
        {
            #region Methods
    
            /// <summary>
            /// Entry point into console application.
            /// </summary>
            private static void Main()
            {
                var colorManager = new ColorManager
                {
                    ["red"] = new Color(255, 0, 0),
                    ["green"] = new Color(0, 255, 0),
                    ["blue"] = new Color(0, 0, 255),
                    ["angry"] = new Color(255, 54, 0),
                    ["peace"] = new Color(128, 211, 128),
                    ["flame"] = new Color(211, 34, 20)
                };
    
                // User clones selected colors.
                var color1 = colorManager["red"].Clone() as Color;
                var color2 = colorManager["peace"].Clone() as Color;
                var color3 = colorManager["flame"].Clone() as Color;
            }
    
            #endregion
        }
    
        /// <summary>
        /// The 'Prototype' abstract class.
        /// </summary>
        internal abstract class Prototype
        {
            #region Public Methods and Operators
    
            /// <summary>
            /// Clone.
            /// </summary>
            /// <returns>
            /// The <see cref="Prototype"/>.
            /// </returns>
            public abstract Prototype Clone();
    
            #endregion
        }
    
        /// <summary>
        /// The 'ConcretePrototype' class.
        /// </summary>
        internal class Color : Prototype
        {
            #region Fields
    
            /// <summary>
            /// The blue.
            /// </summary>
            private readonly int _blue;
    
            /// <summary>
            /// The green.
            /// </summary>
            private readonly int _green;
    
            /// <summary>
            /// The red.
            /// </summary>
            private readonly int _red;
    
            #endregion
    
            #region Constructors and Destructors
    
            /// <summary>
            /// Initializes a new instance of the <see cref="Color"/> class.
            /// </summary>
            /// <param name="red">
            /// The red.
            /// </param>
            /// <param name="green">
            /// The green.
            /// </param>
            /// <param name="blue">
            /// The blue.
            /// </param>
            public Color(int red, int green, int blue)
            {
                _red = red;
                _green = green;
                _blue = blue;
            }
    
            #endregion
    
            #region Public Methods and Operators
    
            /// <summary>
            /// Clone.
            /// </summary>
            /// <returns>
            /// The <see cref="Prototype"/>.
            /// </returns>
            public override Prototype Clone()
            {
                Console.WriteLine("Cloning color RGB: {0,3},{1,3},{2,3}", _red, _green, _blue);
                return MemberwiseClone() as Prototype;
            }
    
            #endregion
        }
    
        /// <summary>
        /// Prototype manager.
        /// </summary>
        internal class ColorManager
        {
            #region Fields
    
            /// <summary>
            /// The colors.
            /// </summary>
            private readonly Dictionary<string, Prototype> _colors = new Dictionary<string, Prototype>();
    
            #endregion
    
            #region Public Indexers
    
            /// <summary>
            /// This.
            /// </summary>
            /// <param name="key">
            /// The key.
            /// </param>
            /// <returns>
            /// The <see cref="Prototype"/>.
            /// </returns>
            public Prototype this[string key]
            {
                get { return _colors[key]; }
    
                set { _colors.Add(key, value); }
            }
    
            #endregion
        }
    }
    
    // Output:
    /*
    Cloning color RGB: 255,  0,  0
    Cloning color RGB: 128,211,128
    Cloning color RGB: 211, 34, 20
    
    */

     

    展开全文
  •   作为一名前端工程师,必须搞懂JS中的prototype、__proto__与constructor属性,相信很多初学者对这些属性存在许多困惑,容易把它们混淆,本文旨在帮助大家理清它们之间的关系并彻底搞懂它们。这里说明一点,__...
  • JS 中prototype 的问题

    2011-12-27 10:23:32
    Object.prototype.inObj = 1; //定义A类; function A(){ //给属性设置值为2; this.inA = 2; } //给A类的inAproto属性设置为3; A.prototype.inAProto = 3; //这下面两句是什么意思? B.prototype = ...
  • Uncaught TypeError: Cannot read property ‘prototype’ of undefined 代码如下 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>品牌管理<...
  • 但问题是,我在看spring文档是,看到这一句话[color=red]“清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源,都是客户端代码的职责。”[/color] 我就想问一下,什么叫“[color=red]清除...
  • A.prototype = new B(); var a = new A(); console.log(a); a.display();//弹出 A display a.show();//弹出 B show /*--------------(2)---------------*/ function _A(){ this....
  • ">我们知道,spring有singleton和prototype作用域,而且从spring2.0开始,又增加了三种作用域,request、session、global session。session、global session的作用域是HTTP session和全局session。对于request和...
  • javascript prototype问题

    2015-09-30 06:53:40
    MyClass.prototype = null; var myClass = new MyClass(); alert(myClass.toString()); 我这自己定义了一个构造函数 ,并将函数的prototype 设为null 但是为什么我用这个构造函数实例化一个对象之后, 这个...
  • <bean id="userLoginInfo" class="com.user.vo.UserLoginInfo" scope="prototype"/> ``` action的配置: ``` ``` 实在不知道错在哪了,明显已经配置了scope="prototype" ,为什么就是...
  • Object.prototype=[] console.log(Object.prototype); 为什么无法改变Object.prototype? 我想执行如下效果 var numbers = ['zero','one','two','three','four','five','six','seven','eight','nine'];...
  • JavaScript prototype 属性

    千次阅读 2014-03-08 21:06:19
    一、JavaScript prototype 属性定义和用法prototype 属性使您有能力向对象添加属性和方法。语法object.prototype.name=value实例在本例中,我们将展示如何使用 prototype 属性来向对象添加属性:&lt;script...
  • JavaScript prototype详解

    千次阅读 2015-08-25 22:02:37
    用过JavaScript的同学们肯定都对prototype如雷贯耳,但是这究竟是个什么东西却让初学者莫衷一是,只知道函数都会有一个prototype属性,可以为其添加函数供实例访问,其它的就不清楚了,最近看了一些 JavaScript高级...
  • Prototype-oriented的语言对这种模式提供了语言级别的支持,即所有"类"的定义都是通过指定该类的一个原型来实现的(Class-Based Programming是通过类结构声明来描述一类对象,meta-class则是通过构造一个"类对象"来描
  • Javascript Prototype
  • Prototype 学习——Prototype对象

    千次阅读 2009-07-11 18:40:00
    环境:Prototype Version: 1.6.1_rc3 Aptana Studio, build: 1.2.5.023247 IE7FF2.0.0.4Opera 10 beta =============================================================var Prototype = { Ver
  • console.log(Object.prototype.toString.call(name)); // [object String] 按理说这里应该也是[object Object],可以使为啥不是呢? console.log(Object.prototype.toString.call({sex: '女'})); // [object ...
  • d.prototype.obj=function(){ alert(this.a); } var obj=new d("1","2"); obj.obj(); 上面的可以运行,但是把函数名换成do()就不行,谁知道为什么?难道do这个函数比较特殊? function do(a,b){ this.a=a; this.b=...
  • JavaScript函数及其prototype

    千次阅读 2015-05-10 22:24:16
    一、定义 函数可以通过声明定义,也可以是一个表达式。 (1)函数声明式: 分号是用来分隔可执行JavaScript语句,由于函数声明不是一个可执行语句,所以不以分号结束。 function a(){ console.log('bbb');...
  • Js中的prototype

    2016-07-23 22:50:45
    最近新入职了一家公司,周五看代码的时候,发现... javascript中的每个对象都有prototype属性,js中对象的prototype属性的解释是,返回对象类型原型的引用。 A.prototype=new B(); 理解prototype不应把它和继承混淆

空空如也

1 2 3 4 5 ... 20
收藏数 70,832
精华内容 28,332
关键字:

prototype