Javascript中同一变量上的“new"没有“delete"
这样可以吗?:
function mygetTime()
{
var d = new Date();
return(d.getTime());
}
function wasteSomeMemory()
{
var temp;
for(var count = 0; count < 1000000; count += 1)
{
temp = mygetTime();
}
}
调用 wasteSomeMemory() 会导致内存泄漏吗?
Will calling wasteSomeMemory() cause a memory leak?
这个呢:
function wasteSomeMemory2()
{
var temp;
for(var count = 0; count < 1000000; count += 1)
{
temp = new Date();
}
}
调用 wasteSomeMemory2() 会导致内存泄漏吗?我应该在 for 循环的末尾使用 delete temp; 吗?
Will calling wasteSomeMemory2() cause a memory leak? Should I use delete temp; at the end of the for-loop?
function wasteSomeMemory2()
{
var temp;
for(var count = 0; count < 1000000; count += 1)
{
temp = new Date();
delete temp;
}
}
推荐答案
new 和 delete 在 JavaScript 中彼此没有任何关系(尽管它们与其他语言中完全不同的结构).不要担心在没有明确清理的情况下创建对象(new)，这是垃圾收集器的工作.
new and delete have nothing whatsoever to do with each other in JavaScript (despite their confusing similarity to completely different constructs in other languages). Don't worry about creating objects (new) without explicitly cleaning them up, that's the garbage collector's job.
new 用于通过构造函数创建对象.另一方面，delete 用于从对象中删除属性.它与从内存中删除对象无关，除了作为副作用(例如，如果对该对象的唯一未完成引用来自您删除的属性).
new is for creating objects via constructor functions. delete, on the other hand, is for removing properties from objects. It has nothing to do with removing an object from memory, other than as a side effect (e.g., if the only outstanding reference to that object was from the property that you removed).
delete的正确使用示例:
var obj = {};
obj.foo = "bar"; // Now `obj` has a property called `foo`
delete obj.foo; // Now it doesn't
您的 getmyTime 功能非常好.Date 对象将有资格在函数返回后立即被回收(是否被回收完全取决于实现).它不会导致内存泄漏，除非有错误的实现.
Your getmyTime function is perfectly fine. The Date object will become eligible to be reclaimed immediately upon function return (whether it is reclaimed is completely down to the implementation). It does not cause a memory leak, except on a buggy implementation.
您的 wasteSomeMemory2 同样不会导致内存泄漏，实际上您不能调用 delete temp; —你只能删除属性，不能删除变量.
Your wasteSomeMemory2 similarly doesn't cause a memory leak, and in fact you can't call delete temp; — you can only delete properties, not vars.
有 次您必须帮助垃圾收集器，但这些通常(根据我的经验)与对象属性无关，因此不涉及 delete.它们只有在您创建函数实例时才会真正出现(如果您正在设置事件处理程序或计时器函数等，这很常见).例如，考虑:
There are times when you have to help the garbage collector out, but those usually don't (in my experience) have to do with object properties and so don't involve delete. They only really come up when you're creating function instances (which is fairly often, if you're setting up event handlers or timer functions, etc.). For instance, consider:
function foo() {
var listOfThings = /* ...get a list of things... */;
// ...do something with `listOfThings`...
setInterval(function() {
// ...do something that *doesn't* need `listOfThings`...
}, 1000);
}
因为您通过 setInterval 分配给计时器的匿名函数将在函数调用中继续存在，它会保持对该函数调用期间范围内所有内容的实时引用(无论它是否使用它)或不).这会将 listOfThings 指向的事物列表保存在内存中.如果计时器功能不需要该列表，那是一个问题.如果您知道该函数不需要它，则可以通过分配 undefined 或 null 或其他任何内容来释放 listOfThings 指向的列表listOfThings 完成后:
Because your anonymous function you've assigned to a timer via setInterval will survive the function call, it keeps a live reference to everything that was in-scope during that function call (whether it uses it or not). This keeps the list of things that listOfThings points to in memory. If the timer function doesn't need that list, that's a concern. You can release the list that listOfThings points to if you know that the function doesn't need it, by assigning undefined or null or whatever to listOfThings when you're done with it:
function foo() {
var listOfThings = /* ...get a list of things... */;
// ...do something with `listOfThings`...
listOfThings = undefined; // Done with it <== The new bit
setInterval(function() {
// ...do something that *doesn't* need `listOfThings`...
}, 1000);
}
事件处理函数等也是如此.每当您创建一个函数时，它都会关闭"(保持对它的定义范围内的任何内容的实时引用).因此，如果您不需要这些东西，您可以通过清除对它们的引用来确保它们不会保留在内存中.(更多:闭包并不复杂)
The same is true for event handler functions, etc. Whenever you create a function, it "closes over" (keeps a live reference to) anything in scope where it was defined. So if you don't need those things, you can ensure they're not kept in memory by clearing the references to them. (More: Closures are not complicated)
相关文章