Javascript object memory management when using delete on property

Question

I'm currently writing a node.js/socket.io application but the question is general to javascript.

I have an associative array that store a color for each client connection. Consider the following:

var clientColors = new Array();

//This execute each new connection
socket.on('connection', function(client){   
clientColors[client.sessionId] = "red";

    //This execute each time a client disconnect
    client.on('disconnect', function () {
        delete clientColors[client.sessionId];
    });
});

If I use the delete statement, I fear that it will make a memory leak as the property named after client.sessionId value(associative arrays are objects) won't be deleted, its reference to its value will be gonne but the property will still exist in the object.

Am I right?

This looks all good to me. It will delete the clientColors entry of client.sessionId. — neeebzz
– neeebzz, Commented Apr 21, 2011 at 20:16

Raynos · Accepted Answer · 2011-04-21 20:14:24Z

12

delete clientColors[client.sessionId];

This will remove the reference to the object on object clientColors. The v8 garbage collector will pick up any objects with zero references for garbage collection.

Now if you asked whether this created a memory leak in IE4 then that's a different question. v8 on the other hand can handle this easily.

Seeing as you deleted the only reference the property will also be gone. Also note that objects are not "associative arrays" in javascript since ordering is implementation specific and not garantueed by the ES specification.

answered Apr 21, 2011 at 20:14

Raynos

170k57 gold badges359 silver badges399 bronze badges

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

Comments

user123444555621 · Accepted Answer · 2011-04-21 22:02:46Z

5

Since clientColors[client.sessionId] is a primitive value (a string) in this case, it will be cleared immediately.

Let's consider the more complicated case of foo[bar] = o with o being a non-primitive (some object). It's important to understand that o is not stored "inside" foo, but somewhere in an arbitrary memory location. foo merely holds a pointer to that location. When you call delete foo[bar], that pointer is cleared, and it's up to the garbage collector to free the memory taken by o.

BTW: You shouldn't use Array when you want an associative array. The latter is called Object in Javascript and is usually instantiated using the short-hand quasi-literal {}

answered Apr 21, 2011 at 22:02

user123444555621

154k27 gold badges118 silver badges126 bronze badges

Comments

Ian Mbae · Accepted Answer · 2017-05-04 18:59:34Z

-1

If you are using the V8 engine or nodejs/io, it may not lead to a leak but it is always advisable to prevent leaks.

Just delete it

delete clientColors[client.sessionId];

Or set it to null

clientColors[client.sessionId] = null;

Which will also cascade to any prototypically inherited objects.

This way there is almost no probability of starting a leak.

edited May 4, 2017 at 18:59

answered Jul 21, 2015 at 11:21

Ian Mbae

1461 gold badge2 silver badges14 bronze badges

1 Comment

M.Babcock Over a year ago

I assume you mean to delete before assigning the array element to null, otherwise you're not deleting anything because the clientColors[client.sessionId] reference will be null. Or am I misunderstanding your intent here?

Collectives™ on Stack Overflow

Javascript object memory management when using delete on property

3 Answers 3

Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related