Javascript 从类函数中删除类变量

我正在创建一个将被多次重新创建的类，为了节省内存，我需要彻底删除它。基本上，如果可能的话，我需要访问它的包含变量

下面是一个例子：

function example(){
  this.id=0;
  this.action=function(){alert('tost');}
  this.close=function(){ delete this;}
}

var foo=new example();

我的问题是：

---

如何从示例函数中访问foo变量，以便将其删除？

窗口。foo

将访问该全局变量

this.close=function(){ delete window.foo; }

但是，我记得有，所以您可能希望使用其他方法，只需使用

window.foo=null例如

如果要访问在另一个函数中定义的变量，则需要读取的答案

因为您想要的是允许垃圾收集器释放该对象，所以需要确保没有对该对象的引用。这可能非常棘手（即不可能），因为操作对象的代码可以通过全局和局部变量以及属性对其进行多个引用

您可以通过创建一个代理来访问对象，从而阻止对对象的直接引用，不幸的是javascript不太支持动态getter和setter（也称为catch-all）（在某些浏览器上，您可能实现了这一点），因此您无法轻松地重定向所有字段和方法（反正只是字段）访问基础对象，尤其是在基础对象中添加了许多字段并从中动态删除的情况下（即
this.anewfield=anewvalue
）

下面是一个smiple代理（上的代码）：

它的工作原理是返回一个函数，当使用单个参数调用时，该函数在包装对象上获取一个字段，当使用两个参数调用时，该函数设置一个字段。它的工作原理是确保对heavyobject的唯一引用是
代理
函数中的
对象
局部变量

heavyobject中的代码决不能泄漏
this
（决不能返回它，决不能返回包含对
var=this
的引用的函数，决不能将其存储到另一个变量的字段中），否则可能会创建一些指向heavyobject的外部引用，从而阻止删除它

如果heavyobject的构造函数从构造函数内部（或从构造函数调用的函数）调用
destroyself（）

另一个更简单的代理，它将为您提供一个空对象，您可以在该对象上添加字段、读取字段和调用方法。我很确定，有了这个，没有任何外部引用可以逃脱

代码（另请参阅）：

下面是一个链接，指向有关JavaScript删除操作符的一些非常详细的信息

事实是，在Javascript中，不能删除对象

然后使用delete操作符，它只接受某个对象的属性。
因此，当您使用delete时，通常必须向它传递类似于
obj.p
的内容。然后只传递一个变量名，实际上这意味着“全局对象的属性”，并且
delete p
与
delete window.p
相同。不确定在
删除此
时内部会发生什么，但作为结果，浏览器只需跳过它

现在，我们用
delete
实际删除了什么？我们正在删除对对象的引用。这意味着对象本身仍然存在于内存中。要消除它，必须删除对具体对象的所有引用。从其他对象，从闭包，从事件处理程序，链接数据，所有这些。但对象本身并没有关于所有这些引用的信息，所以无法从对象本身删除对象。
请看以下代码：

但使用这种方法，您必须记住，引用可能位于非常难以理解的地方。例如：

引用存储在
result
函数的closure中，当您有对
result
somethere的引用时，obj将保留在内存中

很难想象物体本身很重，这是最现实的场景——它里面有一些数据。在这种情况下，您可以向对象添加一个清理函数，该函数将清理此数据。假设您有一个gigant缓冲区（例如数字数组）作为对象的属性，如果您想释放内存，您可以清除这个缓冲区，该缓冲区内存中仍有几十个字节的对象。记住将您的函数放到原型中，以保持实例较小

但如果它不是一个全局变量？这对我没有帮助，因为变量foo可以用许多名称定义，例如：var foo=new example；var test=新示例（）；在您的情况下，我无法关闭测试变量这是一个解决方案，但这样称呼它有点不方便，所以我想出了一个更简单的解决方案。只要我将变量定义为全局变量，我就可以通过window['foo']访问它，所以我要做的是检查作用域上的所有变量，以及它们是否有window[i].id和window[i]行动我删除了它们这张纸条似乎每次使用时都会重新创建对象，这意味着在对象更改中，例如更改id不会粘住，以及创建动态对象（例如移动元素）将是一个问题。我认为您误解了如何使用它。为了创建对象，只需调用一次
代理
或
唯一引用对象
，然后访问如下字段：
o（fieldname）
读取字段值，
o（fieldname，value）
写入字段。
对象
局部变量在调用同一个
代理
或
唯一引用对象
调用创建的对象时是相同的。据说delete不能删除函数，所以我需要访问foo变量来删除它。这就是我想知道怎么做的原因
function heavyobject(destroyself, param1, param2) {
    this.id=0;
    this.action=function(){alert('tost ' + param1 + "," + param2);};
    this.close=function(){ destroyself(); }
}

function proxy(param1, param2) {
    object = null;
    // overwrites object, the only reference to
    // the heavyobject, with a null value.
    destroyer = function() { object = null; };
    object = new heavyobject(destroyer, param1, param2);
    return function(fieldname, setvalue) {
        if (object != null) {
            if (arguments.length == 1)
                return object[fieldname];
            else
                object[fieldname] = setvalue;
        }
    };
}
var foo = proxy('a', 'b');
alert(foo("action")); // get field action
foo("afield", "avalue"); // set field afield to value avalue.
foo("action")(); // call field action
foo("close")(); // call field close
alert(foo("action")); // get field action (should be 'undefined').

function uniquelyReferencedObject() {
    object = {};
    f = function(field, value) {
        if (object != null) {
            if (arguments.length == 0)
                object = null;
            else if (arguments.length == 1)
                return object[field];
            else
                object[field] = value;
        }
    };
    f.destroy = function() { f(); }
    f.getField = function(field) { return f(field); }
    f.setField = function(field, value) { f(field, value); }
    return f;
}
// Using function calls
o = uniquelyReferencedObject();
o("afield", "avalue");
alert(o("afield")); // "avalue"
o(); // destroy
alert(o("afield")); // undefined
// Using destroy, getField, setField
other = uniquelyReferencedObject();
other.setField("afield", "avalue");
alert(other.getField("afield")); // "avalue"
other.destroy();
alert(other.getField("afield")); // undefined

var obj = <our object>;
var someAnother = {
       ...
       myObjRef: obj
       ...
 }
var someAnotherAnother = {
       ...
       secondRef : obj
       ...
}

  var x = new obj; //now our object is created and referenced
  x = null;// now our object **obj** still im memory 
  //but doest have a references to it 
  //and after some milliseconds obj is killed by GC...

  //also you can do delete for properties
  delete x.y; //where x an object and x.y = obj

  function func() {
     var x= new obj;// our heavy object
     ...
     return function result() {
         ...some cool stuff..
     }
  }