Javascript对象返回原型

我在用Javascript编写对象构造函数时遇到问题。当我对一个实例化对象调用函数时，它总是返回实例化对象的值。流程如下：

blue = tool('blue');
blue.jDom();     // returns '[<div id="blue" class="tool">...</div>]'
red = tool('red');
red.jDom();     // returns '[<div id="red" class="tool">...</div>]'
blue.jDom();     // returns '[<div id="red" class="tool">...</div>]'

blue=工具（'blue'）；
blue.jDom（）；//返回“[…]”
红色=工具（“红色”）；
red.jDom（）；//返回“[…]”
blue.jDom（）；//返回“[…]”

我相信这是因为我在原型声明中包含了私有变量。如果我将prototype声明移动到构造函数中，一切都会正常工作，但这只是掩盖了一个事实，即我的对象似乎通过为每个对象创建新的prototype来影响原型的属性，而不是它们自己。这是我的相关代码：

function beget(oPrototype) {
    function oFunc() {};
    oFunc.prototype = oPrototype;
    return new oFunc()
};    

var tool = (function (){
        var protoTool = function(){

            var oTool = {},
                that = this,
                _bVisible = true,
                _oParentPane = 'body',
                _aoComponents,
                _sName = 'tool',
                _sSelector = '#' + _sName,
                _jDomElement;



            // this is the private tab object, needs to be refactored
                            // descend from a single prototype  
            function _tab() {

                var oTab = {},
                    _sHtml = '<li><a href="' + _sSelector + '">' + _sName + '</a></li>',
                    _jDomElement = $(_sHtml);

                function jDom() {
                    return _jDomElement;
                }

                oTab.jDom = jDom;

                return beget(oTab);
            };

            // this builds the jDom element 
            function _jBuild() {
                var sHtml = '<div id="' + _sName + '" class="tool"></div>';
                _jDomElement = $(sHtml)
                return _jDomElement;
            };

            // this returns the jQuery dom object
            function jDom() {
                if (typeof _jDomElement === 'undefined') {
                    _jBuild();
                }
                return _jDomElement;
            };

            function configure (oO){
                if (typeof oO !== 'undefined') {
                    if (typeof oO === 'string') {
                        var name = oO;
                        oO = Object();
                        oO.sName = name;
                    } 


                    _bVisible = oO.bVisible || _bVisible,
                    _oParentPane = oO.oParentPane || _oParentPane,
                    _aoComponents = oO.aoComponents || _aoComponents,
                    _sName = oO.sName || _sName,
                    _sSelector = '#' + _sName,
                    _jDomElement = undefined;
                    _oTab = _tab();

                    _oTab.jDom()
                        .appendTo(jDom())
                        .draggable({
                        revert: 'invalid',
                        containment: '#main',
                        distance: 10,
                    });
                } 

            };

            oTool.tMove = tMove;
            oTool.bVisible = bVisible;
            oTool.uOption = uOption;
            oTool.jDom = jDom;
            oTool.configure = configure;    

            return oTool;   
        }();

        var tool = function (oO) {
            that = beget(protoTool);
            that.configure(oO);
            that.configure = undefined;
            return that;
        };

        return tool;
    })();

函数开始（oPrototype）{
函数of unc（）{}；
oFunc.prototype=oPrototype；
返回新的oFunc（）
};    
var工具=（函数（）{
var protoTool=函数（）{
var-oTool={}，
那=这个，
_bVisible=true，
_oParentPane='body'，
_组件，
_sName=‘工具’，
_选择符=“#”+\u sName，
_jDomElement；
//这是私有选项卡对象，需要重构
//从一个原型下来
函数_tab（）{
var oTab={}，
_sHtml='
'，
_jDomElement=$（\u sHtml）；
函数jDom（）{
返回jdomeElement；
}
oTab.jDom=jDom；
回归生（oTab）；
};
//这将构建jDom元素
函数_jBuild（）{
var-sHtml=''；
_jdomeElement=$（sHtml）
返回jdomeElement；
};
//这将返回jQuery dom对象
函数jDom（）{
if（typeof _jdomeElement=='undefined'）{
_jBuild（）；
}
返回jdomeElement；
};
功能配置（oO）{
如果（oO的类型！==“未定义”）{
如果（oO的类型=='string'）{
var name=oO；
oO=对象（）；
oO.sName=名称；
} 
_bVisible=oO.bVisible | | | u bVisible，
_oParentPane=oO.oParentPane | | | u oParentPane，
_aoComponents=oO.aoComponents | | | aoComponents，
_sName=oO.sName | | | u sName，
_选择符=“#”+\u sName，
_jdomeElement=未定义；
_oTab=_tab（）；
_oTab.jDom（）
.appendTo（jDom（））
.拖拉({
还原：“无效”，
安全壳：“#主”，
距离：10，
});
} 
};
oTool.tMove=tMove；
oTool.bVisible=bVisible；
oTool.uOption=uOption；
oTool.jDom=jDom；
oTool.configure=配置；
回音耳；
}();
变量工具=函数（oO）{
那=beget（protoTool）；
配置（oO）；
that.configure=未定义；
归还；
};
返回工具；
})();

首先：在内部工具变量定义中，通过'that=beget（protoTool）；'您的意思必须是'var that=beget（protoTool）；'

你的代码里发生了什么
对工具定义求值是为了给工具一个值。在此评估过程中，围绕protool进行关闭。
但在本次评估过程中，此闭包只执行一次：以后对protool的所有调用（通过调用以protool为原型的“that”进行）都将更改此第一个也是唯一一个闭包的值。
这就是您看到此行为的原因：最近看到的对象将得到所有关注，因为它更新了闭包的值。
解决方案是在“工具”内部var函数定义中创建正确的闭包

但是如果可以的话，我建议大家一起使用一个经典的javascript类定义，使用新的操作符，我相信这更容易编码/理解/调试

---

在最新的javascript规范（1.8.6）中，还有一个rq:beget===Object.create

为什么要编写这么复杂的代码？构造函数分配字段，然后将外部方法分配给原型有什么困难。它会起作用的。