从JavaScript数组添加和删除值

Question

I have a JavaScript array of numbers. My array is defined like this:

var customerIds = [];

I have a function that is responsible for inserting and removing ids to/from this array. Basically, my function looks like this:

function addOrRemove(shouldAdd, customerId) {
  if (shouldAdd) {
    if (customerIds.contains(customerId) === false) {
      customerIds.push(customerId);
    }
  } else {
    customerIds.remove(customerId);
  }
}

This function is basically pseudocode. A JavaScript array does not have a contains or remove function. My question is, is there any elegant way of tackling this problem? The best I can come up with is always looping through the array myself and tracking the index of the first item found.

Thank you for any insights you can provide.

Answer 1

1. The contains can be achieved with Array.prototype.indexOf , like this

    if (customerIds.indexOf(customerId) === -1) { 

   indexOf function returns -1 , if it couldn't find the parameter in the array, otherwise the first index of the match. So, if the result is -1 , it means that customerIds doesn't contain customerId .

2. The remove can be achieved with Array.prototype.indexOf and Array.prototype.splice , like this

    var index = customerIds.indexOf(customerId); if (index !== -1) { customerIds.splice(index, 1); } 

   Similarly, indexOf function returns -1 , if it couldn't find the parameter in the array, otherwise the first index of the match. So, if the result is -1 , we skip deleteing, otherwise splice 1 element starting from the position index .

Answer 2

Use indexOf and splice

function addOrRemove(shouldAdd, customerId) {
    if (shouldAdd) {
        if (customerIds.indexOf(customerId) == -1) {
            customerIds.push(customerId);
        }
    } else {
        var index = customerIds.indexOf(customerId)
        customerIds.splice(index, 1);
    }
}

Answer 3

You can extend the Array method like below after that you are free to use 'contains' and 'remove'

if (!Array.contains)
    Array.prototype.contains = function(a) {
        for (var i in this) {
            if (this[i] == a) return true;
        }
        return false
    }
if (!Array.remove)
    Array.prototype.remove = function(a) {
        for (var i in this) {
            if (this[i] == a) {
                this.splice(i, 1);
            }
        }
    }

Answer 4

You could definitely use the splice and indexOf as stated by @thefourtheye, yet I would like to provide another approach.

Instead of using an array you could use an object .

var customerIds = {};
//This could also be stated as: var customerIds = new Object(); this is just shorthand

function addOrRemove(shouldAdd, customerId)
{
    if(shouldAd)
    {
        if(!customerIds[customerId])
        {
            customerIds[customerId] = new Object();
            customerIds[customerId].enabled = true;
        }
    }
    else
    {
        if(customerIds[customerId])
        {
            customerIds[customerId].enabled = false;
        }
    }
}

You now can query against the customerIds object for a specific customerId

if(customerIds[customerId].enabled)

Using this method not only provides you with the capability of attaching multiple attributes to a given customerId , but also allows you to keep records of all customerIds after disabling (removing).

Unfortunately, in order to truely remove the customerId , you would need to loop through the object and append each property of the object to a new object except for the one you do not want. The function would look like this:

function removeId(customerId)
{
    var n_customerIds = new Object();

    for(var key in customerIds)
    {
        if(key != customerId)
        {
            n_customerIds[key] = customerIds[key];
        }
    }

    customerIds = n_customerIds;
}

In no way am I stating that this would be the proper approach for your implementation, but I am just providing another method of achieving your goal. There are many equivalent ways to solve your dilemma, and it is solely decided by you which method will best suit your projects functionality. I have personally used this method in many projects, as well as I have used the methods posted by others in many other projects. Each method has their pros and cons.

If you do wish to use this method, I would only suggest doing so if you are not collecting many customerIds and do want a lot of customerData per each customerId , or, if you are collecting many customerIds and do not want a lot of customerData per each customerId . If you store a lot of customerData for a lot of customerIds , you will consume a very large amount of memory.