如何防止Javascript对象丢失数组/对象引用

我编写了一个dictionary对象或map对象，这是您喜欢的名称，但在创建第二个对象后，我遇到了一个问题，即不能丢失对该对象的引用。
例如，我想拿一个有书和摘要的物品，还有一个有汽车和它们的成本。结果以两个贴图都设置为第二个贴图值结束

function Dictionary() {
    var _size = 0;
    var _dict = new Object();
    var _keys = new Array();
    var _values = new Array();
    var _firstKey = "";
    var _lastKey = "";

    Dictionary.prototype.put = function () {
        if (_size == 0)
            _firstKey = arguments[0];

        _keys.push(arguments[0]);
        _values.push(arguments[1]);
        _dict[arguments[0]] = arguments[1];
        _lastKey = arguments[0];
        _size++;
    };

    Dictionary.prototype.firstKey = function () {
        return _firstKey;
    };

    Dictionary.prototype.lastKey = function () {
        return _lastKey;
    };

    Dictionary.prototype.get = function () {
        return _dict[arguments[0]];
    };

    Dictionary.prototype.size = function () {
        return _size;
    };

    Dictionary.prototype.entrySet = function () {
        return _dict;
    };

    Dictionary.prototype.key = function () {
        return _keys;
    };

    Dictionary.prototype.vaules = function () {
        return _values;
    };

    Dictionary.prototype.clear = function () {
        _size = 0;
        _dict = new Object();
        _keys = new Array();
        _values = new Array();
        _firstKey = "";
        _lastKey = "";
    };

    Dictionary.prototype.remove = function () {
        var keyIndex;
        if (_size >= 1) {
            for (var i = 0; i < _keys.length; i++) {
                if (arguments[0] == _keys[i])
                    keyIndex = i;
            }

            if (keyIndex === undefined)
                return undefined

            _dict = removeItemObject(_dict, arguments[0]);
            _keys = removeItemArray(_keys, keyIndex);
            _values = removeItemArray(_values, keyIndex);

            if (_keys.length > 0 && _keys.length == keyIndex) {
                _lastKey = _keys[keyIndex - 1];
            }

            if (_keys.length == 0)
                _lastKey = undefined;

            if (0 == keyIndex) {
                if (_keys.length > 1)
                    _firstKey = _keys[1];

                else if (_keys.length > 0)
                    _firstKey = _keys[0];

                else if (_keys.length == 0)
                    _firstKey = undefined;
            }

            _size--;

        }
    };

    Dictionary.prototype.serialize = function () {
        var serializedFJSON = "{";
        serializedFJSON += "\"size\"" + ":" + _size + ",";
        serializedFJSON += "\"dict\"" + ":" + JSON.stringify(_dict) + ",";
        serializedFJSON += "\"keys\"" + ":" + JSON.stringify(_keys) + ",";
        serializedFJSON += "\"values\"" + ":" + JSON.stringify(_values) + ",";
        serializedFJSON += "\"firstKey\"" + ":" + "\"" + _firstKey + "\"" + ",";
        serializedFJSON += "\"lastKey\"" + ":" + "\"" + _lastKey + "\"" + "";
        serializedFJSON += "}";
        return serializedFJSON;
    };

    Dictionary.prototype.deserialize = function () {
        var DictionaryClone = JSON.parse(arguments[0]);
        _size = DictionaryClone.size;
        _dict = DictionaryClone.dict;
        _keys = DictionaryClone.keys;
        _values = DictionaryClone.values;
        _firstKey = DictionaryClone.firstKey;
        _lastKey = DictionaryClone.lastKey;
    };

    function removeItemArray(arrayName, key) {
        var x;
        var tmpArray = new Array();
        for (x in arrayName) {
            if (x != key) { tmpArray[x] = arrayName[x]; }
        }
        return tmpArray;
    };

    function removeItemObject(arrayName, key) {
        var x;
        var tmpArray = new Object();
        for (x in arrayName) {
            if (x != key) { tmpArray[x] = arrayName[x]; }
        }
        return tmpArray;
    };
}

var m = new Dictionary();
m.put("Lord Of The Rings", "Not One Book But, Three");
m.put("Curious George", "I Don't Know Something About a Guy In A Rain Coat");

var k = new Dictionary();
k.put("Scion FRS", "24955");
k.put("Toyota Camry", "22055");

k.remove("Toyota Camry");

for (items in m.entrySet()) {
    alert(items + " " + m.entrySet()[items]);
}

函数字典（）{
var_size=0；
var_dict=新对象（）；
var_keys=新数组（）；
var_values=新数组（）；
var_firstKey=“”；
var _lastKey=“”；
Dictionary.prototype.put=函数（）{
如果（_size==0）
_firstKey=arguments[0]；
_按键（参数[0]）；
_push（参数[1]）；
_dict[arguments[0]]=参数[1]；
_lastKey=参数[0]；
_大小++；
};
Dictionary.prototype.firstKey=函数（）{
返回_firstKey；
};
Dictionary.prototype.lastKey=函数（）{
返回_lastKey；
};
Dictionary.prototype.get=函数（）{
返回_dict[参数[0]]；
};
Dictionary.prototype.size=函数（）{
返回大小；
};
Dictionary.prototype.entrySet=函数（）{
返回命令；
};
Dictionary.prototype.key=函数（）{
返回键；
};
Dictionary.prototype.vaules=函数（）{
返回_值；
};
Dictionary.prototype.clear=函数（）{
_尺寸=0；
_dict=新对象（）；
_keys=新数组（）；
_值=新数组（）；
_firstKey=“”；
_lastKey=“”；
};
Dictionary.prototype.remove=函数（）{
var指数；
如果（_size>=1）{
对于（变量i=0；i<\u keys.length；i++）{
if（参数[0]==\u键[i]）
keyIndex=i；
}
if（keyIndex==未定义）
返回未定义
_dict=removitemObject（_dict，参数[0]）；
_keys=removietemarray（_keys，keyIndex）；
_values=removietemarray（_值，keyIndex）；
如果（_keys.length>0&&u keys.length==keyIndex）{
_lastKey=_keys[keyIndex-1]；
}
如果（_keys.length==0）
_lastKey=未定义；
if（0==keyIndex）{
如果（_keys.length>1）
_firstKey=_键[1]；
否则如果（_keys.length>0）
_firstKey=_键[0]；
else如果（_keys.length==0）
_firstKey=未定义；
}
_大小--；
}
};
Dictionary.prototype.serialize=函数（）{
var serializedFJSON=“{”；
serializedFJSON+=“\”大小“+”：“+”大小+”，“；
serializedFJSON+=“\”dict\“+”：“+JSON.stringify（\u dict）+”，”；
serializedFJSON+=“\”键\+”：“+JSON.stringify（_键）+”，”；
serializedFJSON+=“\”值“+”：“+JSON.stringify（_值）+”，”；
serializedFJSON+=“\”firstKey\+”：“+”\”+“\”+\u firstKey+“\”+”，“；
serializedFJSON+=“\”lastKey\+”：“+”\”+“lastKey+”\”；
序列化DFJSON+=“}”；
返回JSON；
};
Dictionary.prototype.deserialize=函数（）{
var=JSON.parse（参数[0]）；
_尺寸=旋风分离器尺寸；
_dict=旋风分离器。dict；
_keys=旋风分离器。keys；
_数值=旋风分离器数值；
_firstKey=clone.firstKey；
_lastKey=旋风分离器。lastKey；
};
函数removeItemArray（arrayName，键）{
var x；
var tmpArray=新数组（）；
用于（arrayName中的x）{
如果（x！=key）{tmpArray[x]=arrayName[x]；}
}
返回tmpArray；
};
函数removeItemObject（arrayName，键）{
var x；
var tmpArray=新对象（）；
用于（arrayName中的x）{
如果（x！=key）{tmpArray[x]=arrayName[x]；}
}
返回tmpArray；
};
}
var m=新字典（）；
m、 put（“指环王”，“不是一本书，而是三本书”）；
m、 put（“好奇的乔治”，“我不知道一个穿雨衣的家伙的事”）；
var k=新字典（）；
k、 put（“Scion FRS”、“24955”）；
k、 出售（“丰田凯美瑞”、“22055”）；
k、 移除（“丰田凯美瑞”）；
对于（m.entrySet（）中的项）{
警报（items+“”+m.entrySet（）[items]）；
}

这是因为您在方法上使用了

Dictionary.prototype

。将它们替换为

此

，它将起作用：

this.put = function()

this.firstKey = function()

this.lastKey = function()

...

使用

this

关键字，您将方法分配给

字典

[排序]类。您只是将函数公开。如果查看函数，如

removitemarray（）

，则这些函数是私有的，只能从对象内部访问

原型的工作原理不同。这是一段很好的引语，引自对原型的回答：

原型是用于 构造所有新实例，并将对所有已有实例进行动态修改 构造对象，因为Javascript对象中保留指向 原型

prototype的目的是提供在运行时向对象添加方法的能力。如果您来自经典的OOP语言，这似乎是一个陌生的概念，在传统的OOP语言中，您会预先定义一个类及其方法

---

看看这个问题中的其他答案，它们很好地解释了prototype。

这是因为您在方法上使用了

字典。prototype

。将它们替换为

此

，它将起作用：

this.put = function()

this.firstKey = function()

this.lastKey = function()

...

使用

this

关键字，您将方法分配给

字典

[排序]类。您只是将函数公开。如果查看函数，如

removitemarray（）

，则这些函数是私有的，只能从对象内部访问

<