JS 构造函数 原型混合方式定义类

Question

        var POBJ = new Object();
        POBJ.Show = function()
        {
            alert("Hello World!");  
        };        function MyClass()
        {   
            if(typeof(MyClass._initialized)== "undefined")
            {
                //放在此处就不行了。
                  //MyClass.prototype = POBJ; 
                
                /*
                  这是方式也行，不过要是方法多的话，
                    直接定义好一个对象，然后一赋值更方便一些
                  MyClass.prototype.Show = function()
                {
                    alert("Hello World!");
                }
                */
                MyClass._initialized = true;
            }
        }
        //放在此处就行了
         MyClass.prototype = POBJ;    
        
        var obj = new MyClass();
        obj.Show();
怎么在类定义里面 把原型对象赋给该类呢？望高手指点！
十分感谢！

Answer 1

你这个问题与http://topic.csdn.net/u/20090107/18/405a6f4f-9bb0-44e1-ac63-193de48e40f5.html这个是同一个问题你可以看看
主要是MyClass的prototype链问题

Answer 2

谢谢你给的链接
可能是因为易惯于C#代码的风格吧，看着那种方式不是很爽可能是我刚入门吧，总觉得那种不够简洁，思路也比较乱。
return function()
{
    this.initialize.apply(this, arguments);
}
这些代码不知道干什么的（返回一个对arguments初始化的对象么？汗~），一会查查去。高人能否让我上面的代码工作起来呢？
在构造函数内把原型给赋上就行。实在不行的话，多敲几行代码也能工作了，不能一下赋一个对象，只好一个方法一个方法的写了。或者用工厂方式加原型混合去实现

Answer 3

如果你要在里面的话，只能是如此方式
var POBJ = new Object();
        POBJ.Show = function()
        {
            alert("Hello World1!");  
        };        function MyClass()
        {   
            if(typeof(MyClass._initialized)== "undefined")
            {
                //放在此处，格式得如下。
                 MyClass.prototype.Show =  POBJ.Show; 
                
                /*
                  这是方式也行，不过要是方法多的话，
                    直接定义好一个对象，然后一赋值更方便一些
                  MyClass.prototype.Show = function()
                {
                    alert("Hello World!");
                }
                */
                MyClass._initialized = true;
            }
        }
        //放在此处就行了
        // MyClass.prototype = POBJ;    
        
        var obj = new MyClass();
        obj.Show();

Answer 4

效果？
具体的效果没有，只是学习而已。
我想实现的就是 
if(typeof(MyClass._initialized)== "undefined")
在这个代码块里面 用JSON的形式定义一个对象
然后最后把这个对象设置为这个类的原型对象，仅此而已。
也就是不象写N多个
MyClass.prototype.F0
MyClass.prototype.F1
...
MyClass.prototype.Fnvar obj={F0:function(){},...,Fn:function(){}};
这种方式应该比上面少敲些MyClass.prototype吧，见笑了。

Answer 5

谢谢你热情的帮助新手！MyClass.prototype.Show =  POBJ.Show; 
跟一个方法一个方法的写，貌似没有啥区别。汗~
难道在内部就不能MyClass.prototype赋个对象么？

Answer 6

哦
那我先去研究研究。上面这个问题　解决不了么？
在构造函数里面直接给prototype赋对象?

Answer 7

这样做是不合理的阿,prototype相当于类的模板，构造函数是构造函数，本身就是分开的。如果在构造的时候可以随便改类的模板那岂不是全乱了

Answer 8

function MyClass()
{
}
MyClass.prototype = { Show: function() { alert("Hello World!"); }}  var obj = new MyClass();
obj.Show();这个放在外面的状态
正常放在里面的话执行顺序就相当于这样function MyClass()
{
}var obj = new MyClass();
MyClass.prototype = { Show: function() { alert("Hello World!"); }}  
obj.Show();出错了
为什么呢
再看function MyClass()
{
}
MyClass.prototype = { Show: function() { alert("Hello World!"); }} var obj = new MyClass();
obj.Show();MyClass.prototype = { Show: function() { alert("2"); }}  
obj.Show();Hello World!提示了两次
但我在第二次明明已经重新设置了prototype的啊
再看function MyClass()
{
}
MyClass.prototype = { Show: function() { alert("Hello World!"); }} var obj = new MyClass();
obj.Show();MyClass.prototype = { Show: function() { alert("2"); }}  var obj2 = new MyClass();
obj2.Show();第一次是Hello World!
第二次是2其实在实例化o（new f）的时候原型链pa就已经形成并连接o=>pa
在f里面设置prototype 或实例化之后再设置prototype 
就相对于给f重新设置一个原型链pb但o已经连接了pa
也就是说无聊f的prototype 改成什么都不会影响o=>pa这个关系

Answer 9

上面可能说的有点乱
其实根本原因就是MyClass的prototype被重新赋值了
但new的时候用的是原来的prototype
那解决方法就很清楚了，不要重新赋值就行了
例如
function MyClass()
{
}var obj = new MyClass();
MyClass.prototype.Show = function() { alert("Hello World!"); }
obj.Show();
或者
function MyClass()
{
MyClass.prototype.Show = function() { alert("Hello World!"); }
}var obj = new MyClass();
obj.Show();
都可以了对于lz的情况想直接定义好一个对象
可以参考使用
Object.extend
就可以了

Answer 10

一觉醒来，头脑清醒了不少．
昨天晚上从书上看到一句话＂在对象生成的时候，会把原型的各个属性赋给新对象＂，大致意思是这，记不清了．
今天早上来到一看cloudgamer的仔细分析，顿时又清析了不少．这个问题的关键就是：
在 new 的时候　原型链已经确定！
在调用构造函数时，
例如 new MyClass();
此时已经会确定原型对象，然后再接着执行　构造函数内的代码．
对于上面的问题，问题简化如下：function MyClass()
{
    if(typeof MyClass._initialized == "undefined")
    {
        MyClass.prototype = 
        {
            "Show":function()
            {
                alert("Hello World!");
            }
        };
        MyClass._initialized = true;
    }
}
//第一次执行构造函数时，还没有为MyClass指定原型，所以此时原型默认为Object
//执行构造函数内if(typeof MyClass._initialized == "undefined")代码块
//为MyClass赋原型(只有第一次调用构造函数才会执行)
var obj = new MyClass();
//obj.Show();
//此时MyClass的原型已指向那个定义的对象
var obj2 = new MyClass();
obj2.Show();//正常
function MyClass()
{
    if(typeof MyClass._initialized == "undefined")
    {
MyClass.prototype.Show = function() 
{
    alert("Hello World!");
};
    }
    MyClass._initialized = true;
}
var obj = new MyClass();
obj.Show();MyClass.prototype.Show = function(){alert("Hello World!");}
这种方式一句话概括就是
动态的为原型对象添加了一个方法而已不知道以上解答是否正确！

Answer 11

还想再问题一些问题：
在new过之后，新对象到底怎么找到原型对象的一,新对象什么也不存,通过类找到原型对象
二,新对象存了一个指针指向原型对象
三,还是象那本书上所言,先拿原型对象的各个属性去初始化新对象,然后再执行构造函数内的代码还望两位高人再指点指点!
谢谢!(自己先研究研究去,汗~)

Answer 12

在o = new f的时候o的原型就已经定了pa
当你在f里面再设置prototype为pb的时候，虽然f的prototype是改变了
但o的原型依然是pa跟pb是无关的了

Answer 13

function MyClass()
{
}MyClass.prototype.Show = function(){alert("原型方法1");};
var obj1 = new MyClass();
obj1.Show();//原型方法1MyClass.prototype.Show = function(){alert("原型方法2");};
var obj2 = new MyClass();
obj2.Show();//原型方法2obj1.Show();//原型方法2
obj2.Show();//原型方法2
从以上代码我猜测,新对象并没有存任何东西,而是通过类来找的.貌似某本书说的有问题,汗~.
(难道是我看错了,下班回去之后再仔细看看)不知道是不是这回事,期待高人们的精彩解答!

Answer 14

object->p1
fun1->p2
onew的时候o的原型链就是O->p2->p1这样链在一起了这条链是没有object和fun1的

Answer 15

18楼那个是修改了prototype的Show 没什么问题阿

Answer 16

刚才又犯糊涂了~
貌似下面的代码才是正确的.
唉,得好好看看书了~
var pobj1 = {Show:function(){alert("原型方法1");}}
var pobj2 = {Show:function(){alert("原型方法2");}}function MyClass()
{
}MyClass.prototype = pobj1;
var obj1 = new MyClass();
obj1.Show();MyClass.prototype = pobj2;
var obj2 = new MyClass();
obj2.Show();obj1.Show();
obj2.Show();

Answer 17

23楼的就是修改prototype本身了

Answer 18

修改方法和修改prototype本身是不一样的书中应该还有这么一句话，你回去仔细看是不是这样：
在使用原型链继承时，一定要注意任何为子类添加的方法或属性，应该出现在prototype属性被赋值以后。因为在prototype赋值之前，所有子类的方法或属性都会被删除或覆盖

Answer 19

你所说的修改方法是不是这种MyClass.prototype.Show
不就是动态的给原型对象添加属性或方法吗?而修改prototype本身就是指向的一个对象(我把它理解成一个指针,应该没错吧)JS类继承方面暂时还没学习到~
先把类定义给搞明白再说吧.
谢谢了.
回去再好好翻翻书.不谈继承的情况下var pobj1 = {Show:function(){alert("原型方法1");}}function MyClass()
{
    this.Show = function()
    {
alert("对象公有方法!");
    }
}MyClass.prototype = pobj1;
var obj1 = new MyClass();obj1.Show();//对象公有方法.delete obj1.Show;obj1.Show();//原型方法1
pobj1.Show = function()
{
    alert("修改后的原型方法1");
}obj1.Show();//修改后的原型方法
根据上面的代码我猜测,产生新对象,只是存了一个指向原型对象的引用在 "成员" 查找上,我现在的理解是(不一定对),原型作用域里面包含类作用域,
调用对象的成员时,先找类作用域,如果找不到"成员",再找原型作用域,一级一级往上找.{
//原型对象的原型作用域
{
//原型作用域
{
//类作用域
}
}
}不知道理解的对否?

Answer 20

这个问题提的，很到位。
我后来也测试了一下，你可以做一个这样的操作，在
 var obj = new MyClass();
后面，这样写:
alert(MyClass.prototype.Show);
以及 
MyClass.prototype.Show(); 你就可以看到，其实这个 Show 的结构是在 prototype 之中的！
但是为什么在直接调用 
obj.Show() 的时候会说找不到 Show() 方法呢？

Answer 21

看来lz学的不少
但有个理解有问题
function MyClass()
{
    this.Show = function()
    {
    alert("对象公有方法!");
    }
}
这里的Show不是公有而是私有
prototype的才是公有私有才到公有这是一般规律（自己没有了才拿公有的）里面的this就是obj1其实是给obj1加一个Show方法

Answer 22

var BasePO = { Say:function(){alert("Hello World!");}};function MyPOBJ()
{
    var ID = 1;
    var TS = function()
    {
alert("原型对象的私有方法");
    }    this.Name = "LG";
    this.Show = function()
    {
alert("原型对象公有方法!");
    }
}
MyPOBJ.prototype = BasePO;
var pobj1 = new MyPOBJ();function MyClass()
{
}
MyClass.prototype = pobj1;
var obj1 = new MyClass();alert(obj1.Name); //LGalert(obj1.ID);   //undefinedobj1.Show();      //原型对象公有方法!//obj1.TS();      //不支持该方法obj1.Say();       //Hello World!
我觉得是哪个对象的成员,就是哪个对象的成员.
造成共享的原因,就是查找顺序的原因(不知道实质上的原理是啥,暂时这样理解的)或者说,在查找公有成员(无论是函数成员,还是数据成员)时,先查找其自身的.
如果查不到,则在其原型链上逐级"向外"查找,直到查到为止.
(对象的作用域在最内层,不知道这样理解对不对.)

Answer 23

object->p1 
fun1->p2 
o 上面说过这样的原型链O->p2->p1
这个就是查找顺序
当Show在o没有就找p2的，p2也没有就找p1的

Answer 24

"LZ学的不少"就免了吧 汗!
在你们面前,我就是小儿科了~
听人说,一个JS对象就是一个哈希表! 我也是这样理解的/*
function MyObject()
{
    var ID = 0;
    this.Name = "LG";
}
*/var obj = 
{
    Show:function(){alert("Hello World!");}
};obj.Say1 = function(){alert("Hello!");};obj["Say2"] = function(){alert("hi!");};obj.Show(); //Hello World!obj.Say1(); //Hello!obj.Say2(); //hi!还听人说,JS对象实质上是没有"私有"成员的!
我也是这么认为的.好象是用"闭包"来实现的,没研究过ECMA262
所以完全不懂!
在网上找过中文版的,没找到,英语又很弱! 狂汗~~~我把那种{"...":"..."}定义对象的方式叫,JSON定义对象的方式
不知道对不对?另外,用这种方式, 怎么给对象加 "私有"成员呢?

Answer 25

"回复太快！如果你是恶意刷楼，将会受到严厉惩罚！"
郁闷... ...
第一次调用之前不是new MyClass()吗,这个时候obj的原型指向的是默认的Object
所以找不到,我是这么认为的,不知道对不对.

Answer 26

参考一下
var pobj1 = {Show:function(){alert("原型方法1");}}function MyClass(x)
{
    this.ShowX = function()
    {
     alert(x);
    }
}MyClass.prototype = pobj1;
var obj1 = new MyClass("1");
obj1.ShowX();
obj1.Show();var obj2 = new MyClass("2");
obj2.ShowX();
obj2.Show();

Answer 27

我觉得这段代码并不能说明上面的代码似乎跟原型没有太多联系
看下面的代码var pobj1 = {};function MyClass(x)
{
    //var x = "LG";
    this.ShowX = function()
    {
alert(x);
    }
}
MyClass.prototype = pobj1;
var obj1 = new MyClass("1");//遍历对象,并不能找到1
for(var key in obj1)
{
    alert(key + ":" + obj1[key]);
}//遍历原型对象,也不能找到1
for(var key in pobj1)
{
    alert(key + ":" + pobj1[key]);
}obj1.ShowX();//这里能够输出1
/*
    上面为什么能够输出1呢?
    我的理解是:var obj1 = new MyClass("1");
    执行这一句时,构造了如下作用域
    {
构造函数列表作用域,那个1,在这里面存着呢
x只是一个标识而已,
{
    //构造函数内作用域
    {
//方法内的作用域
    }
}
    }
    
    假如说这样
    //var x = "LG";把该句注释去掉的话
    输出的就是LG了,因为 构造函数内作用域优先级高
    已经找到x就不再继续向"外"找了.
*/var obj2 = new MyClass("2");
obj2.ShowX();

Answer 28

作用域这个就比较深了
建议还是不要考虑这个
lz也没理解我的意思
其实
这样吧
var pobj1 = {Show:function(){alert("原型方法1");}} function MyClass(x) 
{ 
    this.ShowX=x; 
} MyClass.prototype = pobj1; 
var obj1 = new MyClass("1"); 
alert(obj1.ShowX); 
obj1.Show(); var obj2 = new MyClass("2"); 
alert(obj2.ShowX); 
obj2.Show(); ShowX是私人属性（各个实例都不相同）
Show是公共方法性（各个实例都调用的都是同一个，除非已经有私人的Show）

Answer 29

至于
prototype的才是公有 私有才到公有这是一般规律（自己没有了才拿公有的） 
意思就是
var pobj1 = {Show:function(){alert("原型方法1");}} function MyClass() 
{ 
} MyClass.prototype = pobj1; var obj1 = new MyClass(); 
obj1.Show(); 
obj1.Show = function(){alert("这是我自己的");}
obj1.Show(); 

Answer 30

跟
var pobj1 = {Show:function(){alert("原型方法1");}} function MyClass() 
{ 
this.Show = function(){alert("这是我自己的");}
} MyClass.prototype = pobj1; var obj1 = new MyClass(); 
obj1.Show(); 
这个是一样的

Answer 31

这个贴子的目的我想已经达到了，结贴
var POBJ = new Object();
POBJ.Name = "LG";
POBJ.Show = function(){ alert("Hello World!");};function MyClass(){};
MyClass.prototype = POBJ;    var obj = new MyClass();for(var key in obj)
{
    alert(key + ":" + obj[key]);
}POBJ.Name = "Liuguang";
POBJ.Show = function(){ alert("prototype function changed");};for(var key in obj)
{
    alert(key + ":" + obj[key]);
}
尚未弄明白原型的机理，此时研究还有些早吧，等过段时间再研究。
如果书中所说无误，那么当对象创建时，新对象里也只是存的原型对象的各个成员的引用吧。
（从上面代码貌似可以看出）
至于对象各个成员的“公有”，“私有”
和各个对象对于原型成员的“公有”，“私有”就是那个意思了~OK，有什么问题了，再来请教！最后感谢一下各位！

Answer 32

不理解底层的东西
只能从表面上猜测
这是件很痛苦的事情!http://www.cn-cuckoo.com/2007/08/01/understand-javascript-closures-72.html
这篇文单相当不错.

Answer 33

倒，我给你的那句话你都没理解透：
对象实例化时，所有的属性都是单一对象私有的，而方法是所有对象公有的
function MyClass()
{
    this.Show = function()
    {
    alert("对象公有方法!");
    }
}
在你这里的show是属于MyClass的属性