Should I bother cleaning array in node.js?

Question

In one of my script, I make extensive use of array to temporary store data. The problem I m facing is that I have a lot of code handling the array just so I make economic use of the space.

Should I even bother since Node.js array are associative array?

My current solution is:

//Get the minimum empty id in array
function get_id(callback) {
    var i = 0;
    while(array[i] != null) {
        i = i + 1;
    }
    array[i] = 0;
    callback(i);
}


get_id(function (i) {
    array[i] = {large object};
    //...
    array[i] = null;
});

But I feel it is wrong and bug prone.

Can I just do:

array[i] = {large object};
i = i + 1;
//...
array[i] = null;

Or would it lead to large consumption of memory?

array is a global variable of the module using it.

Cut down code (I ve removed all computing not linked to the array player.active_mission):

var player = {},
    missions = [{time: 1000}];

function end_mission(mission, squad, mission_log, callback) {
    //Make all the computing of the mission to know if the player won...
    callback(mission_log);
}

function get_ami(callback) {
    var i = 0;
    while(player.active_mission[i] != null) {
        i = i + 1;
    }
    player.active_mission[i] = 0;
    callback(i);
}

function wait_mission(mission, squad, mission_log, i, time, callback) {
    setTimeout(function () {
        console.log('End of mission');
        player.active_mission[i] = null;
        end_mission(mission, squad, mission_log, callback);
    }, time);
}

function start_mission(mission, squad, callback) {
    var mission_log = {mission: mission, time_start: new Date(), completed: false, read: false};

    //Verify if the player can start the mission...

    console.log('start_mission');
    get_ami(function (i) {
        player.active_mission[i] = {mission: mission, squad: squad, mission_log: mission_log}
        wait_mission(mission, squad, mission_log, i, missions[mission].time, callback);
    });
}

player.active_mission = [];

//This part is inside get request, after sanitizing all input
start_mission(0, [0, 1], function (r) {
    //r.id = req.session.player_id;
    if(r.error) {
        console.log('start: error: ' + r.error);
    } else {
        console.log('start: Success: ' + r.result);
    }
});

player.active_mission hold all uncompleted request of the player, and need to be saved if the player quit before completion. My problem is just if I should try to keep it with small id, or just go on with .push() and get the id with .length()?

In short: If a array have nothing but null for the 1000 first id, and start having data only at array[1000]`, am I wasting memory?

Answer 1

NodeJS has a garbage collector to destroy unreachable object/array/variable.

So when you do array[i] = {large object};, the large object will be in the memory and it will stay here. When you do array[i] = null;, the garbage collector will erase the large object (only if there's no other reference to this object of course).

So yes, it is always good to remove references to useless objects to let the garbage collector clean it.

The impact on the memory of an array of 1000 null (or undefined) will not be very big.

If you want to preserve your memory, you should use an object instead of an array. You can use it with this syntax :

var obj = {};
obj[id] = {large object};

// Free the id
delete obj[id];

Answer 2

Can I just do:

i = i + 1;
array[i] = null;

Or would it lead to large consumption of memory?

Yes, considering that array is a global variable and won't get garbage-collected itself, filling it constantly with values (even if only null ones) will eventually let you run out of memory.

Your get_id approach that recycles unused ids does work, but is horribly inperformant - it requires linear time to find a new id. So it'll work for few users with few concurrent missions, but it won't scale.

You'll rather want to use an object and delete keys from it, then you don't get into problems when just counting up:

var count = 0;
var missions = {};

function somethingThatNeedsTheStore() {
    var id = count++;
    missions[id] = …;
    // later
    delete missions[id];
}
// repeatedly call somethingThatNeedsTheStore()

Or actually, on recent node versions, you should consider using a Map instead:

var count = 0;
var missions = new Map;

function somethingThatNeedsTheStore() {
    var id = count++;
    missions.set(id, …);
    // later
    missions.delete(id);
}
// repeatedly call somethingThatNeedsTheStore()