27

In C++ I can define a constructor and destructor explicitly, and then cout << "C or D Called" from with in the constructor/destructor function, to know exactly where.

However in JavaScript how do I know when an object is destructed. The example below is the case that concerns me.

I'm calling an internal function on a timeout and I'm wondering if the object stays alive as long as the timer is running, waiting to call next again.

User Click calls Control

// Calls  Control

Control calls Message

var message_object = new Message( response_element );

Message calls Effects

new Effects().fade( this.element, 'down', 4000 );
message_object.display( 'empty' );

Effects

/**
 *Effects - build out as needed
 *  element - holds the element to fade
 *  direction - determines which way to fade the element
 *  max_time - length of the fade
 */

var Effects = function(  ) 
{
    this.fade = function( element, direction, max_time ) 
    {
        element.elapsed = 0;
        clearTimeout( element.timeout_id );
        function next() 
        {
            element.elapsed += 10;
            if ( direction === 'up' )
            {
                element.style.opacity = element.elapsed / max_time;
            }
            else if ( direction === 'down' )
            {
                element.style.opacity = ( max_time - element.elapsed ) / max_time;
            }
            if ( element.elapsed <= max_time ) 
            {
                element.timeout_id = setTimeout( next, 10 );
            }
        }
        next();
    }
};
Improve this question
5
  • 6
    JavaScript Garbage Collection - stackoverflow.com/q/864516/402706 Commented Apr 11, 2012 at 19:34
  • In general yes, see the above link for discussion on the specific conditions for deallocating objects. Commented Apr 11, 2012 at 19:35
  • Which object are you worried about the lifespan of? Commented Apr 11, 2012 at 19:42
  • No, you're thinking in the opposite direction. Control has a reference to Message, but not necessarily the reverse. Unless Effects has some way of accessing Message -- which it doesn't unless Message invoked it or passed a reference to itself to it -- Message goes away. Yes, this.element stays, but the object around it disappears. Commented Apr 11, 2012 at 21:11
  • See also something like stackbased objects in c++ for javascript Commented Apr 2, 2014 at 14:49

5 Answers 5

Reset to default
28

This notion that object destruction is reducible to garbage collection for memory strikes me as dangerously misleading, as the problem isn't reducible to freeing memory.

Destructors are responsible for releasing other resources, such as file descriptors or event listeners, which aren't dealt with automagically by garbage collection. In such cases destructors are absolutely required to unwind state before memory is released, or you will leak resources.

In such cases it's a problem that destructors aren't a first-class notion, whether they need to be called explicitly or can be called implicitly after an object becomes unreachable.

The best way to deal with this is to document your modules appropriately if they need destructors to be used and to underline resource leak scenarios failing such use.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

This is such an important answer. Literally every reference to javascript destruction revolves around memory management, which it simply should not. I'd like to upvote this to the font page of google for javascript destruction.
Much better than my answer from when I was an overconfident junior.
27

Edit 2020: This answer from @BuffyG is much more accurate and useful than my old answer below. Object destruction is about more than memory leaks, and modern JavaScript has none of the patterns I mentioned.

JS objects don't have destructors per se.

JavaScript objects (and primitives) are garbage collected when they become inaccessible, meaning when there is no possible reference to them in the current execution context. The JavaScript runtime has to continuously monitor for this. So unless you use the delete keyword to remove something, then its destruction is sort of under the hood. Some browsers are bad at detecting references left in closure scope (I'm looking at you, Redmond) and that's why you often see objects being set to null at the end of functions--to make sure that memory is freed in IE.

Improve this answer

14 Comments

JS objects get GCed after they become inaccessible (you have no control over when). It's in C++ that objects are destroyed when they become inaccessible.
@Gabe In C++ objects are destroyed when you explicitly delete them, regardless of whether or not they are accessible elsewhere (in fact, technically, they must be accessible for you to delete them). They are not automatically destroyed when (or after) they become inaccessible.
@JasonC: Sorry, I was talking about C++'s "automatic" memory management, with RAII, autoptr, and such.
@JasonC They are if you don’t use new (like any sane C++ programmer). See stackoverflow.com/questions/388242/….
delete does not remove anything from memory!
|
4

There is no dynamic memory managment in ECMAscript at all. A Garbage Collector will take care of anything that required memory in your script. So actually the question should be more like,

"How does the Garbage Collector know when it can free memory for objects"

Simply spoken, most GC's look if there are any active references. That might be due to parent context object, prototype chains or any direct access to a given object. In your particular instance, anytime setTimeout gets executed, it'll call next() which closes over the .fade() parent context and the .face() function in turn holds a closure to the Effects function( context ).

That means, as long as there are calls to setTimeout, that whole construct is held in memory.

You can help old'ish GC implementations sometimes a little bit, by nulling variables-/references to it is able to collect some stuff earlier or at all, but modern implementatios are pretty smart about this stuff. You actually don't have to care about things like "Object/Reference live times".

Improve this answer

1 Comment

Garbage-collection is expensive, so the interpreter is often "lazy" about actually doing it. Abandoned data might sit around in memory for quite some time before the garbage-collector finally runs. When it runs, it "touches" lots of data and might therefore cause many page-faults which must be handled by the OS's virtual memory manager. (Different implementations have taken different approaches to mitigate this side-effect.)
0

There is an experimental Firefox and Chrome function window.requestIdleCallback() that calls back when the browser is idle. This could be used to simulate a class instance destructor.

Almost the same effect can be obtained from the following code:

setTimeout(function()
    {
    // Simulate destructor here
    },0);

This sets an automatically-dismissed timeout that completes when the current JavaScript script completes (and the main event loop resumes).

Improve this answer

Comments

0

Another important consideration is circular references in data structures: "A refers to B, and B refers to A, and no one anymore refers to either of them." Theoretically this could cause both A and B to be seen as uncollectible, hence a memory-leak.

The topic has been discussed here, with some fairly recent updates:

Is it possible to create a "weak reference" in javascript?

The strategy therein discussed is to "weaken" one of the references between A and B so that the garbage-collector knows it can be broken, thus leading to them eventually being reaped ... or maybe stolen in an out-of-memory situation.

Of course it's also possible to benefit from discipline. If you know you're not going to use something anymore, write a routine that sets its various reference-fields to Null before you abandon it to the garbage collector ... "Be tidy."

Garbage collection strategies in JavaScript have advanced considerably since their earliest implementations since the language has become so important. When you are studying texts on this topic, be sure that they are recent.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.