使用另一个数组通过索引删除数组中的对象

Question

I have an array of objects:

{ key : "value", key2 : "value2", key3 : "value3", key4 : "value4", key5 : "value5" }

I also have an standard array:

[1, 3, 5]

How would I delete the objects in the first array, using the values in the second array so I would end up with this:

{ key2 : "value2", key4 : "value4" }

Thanks!

Answer 1

This proves to be a non-trivial answer, as the keys don't have a consistent convention within your object.

The first one has no index ( key ) and the rest have 1-based indexes ( key2 , key3 , key4 ...) , unlike regular Javascript arrays.

The best way to get around that, is to use the ES5 Object.keys method and remember that we need to subtract 1 to account for the 1-based indexing.

Object.keys returns all the keys ( as an array from whatever was passed as the first argument.

var obj = { hello: 0, world: 1 };
Object.keys(obj); // ['hello', 'world']

We can use this list of keys with the indexes you provide for deleting keys.

var deletion = [1, 3, 5];
var object = { key : "value", key2 : "value2", key3 : "value3", key4 : "value4", key5 : "value5" };
var keys = Object.keys(object);

object[keys[1]] // key2
object[keys[3]] // key4
object[keys[5]] // undefined

Nearly, but we haven't corrected the indexes. 1 should in fact relate to the first element of the array, but Javascript uses 0 instead.

object[keys[1 - 1]] // key
object[keys[3 - 1]] // key3
object[keys[5 - 1]] // key5

Finally, as Javascript supports reflection we can use these keys to actually modify the object on the fly.

Seeing as you want to remove them from the object, we'll need the delete operator.

The delete operator removes a property from an object.

Put it all together and you get:

var object = { key : "value", key2 : "value2", key3 : "value3", key4 : "value4", key5 : "value5" };
var deletion = [1, 3, 5];

var keys = Object.keys(object);

deletion.forEach(function(index) {
  delete object[keys[index - 1]];
});

---

EDIT: However, as @adeneo pointed out in the comments

there's no guarantee of any order in Object.keys it could return the keys in any order it wants to, it's "implementation dependent". However, all browsers will generally return the keys in order, but that shouldn't be relied on

This means you may end up deleting completely the wrong keys which could end up being a disastrous bug.

It's possible to circumvent this behaviour in a slightly less robust way.

var object = { key : "value", key2 : "value2", key3 : "value3", key4 : "value4", key5 : "value5" };
var deletion = [1, 3, 5];

function indexToKey(index) {
  return 'key' + (index > 1 ? index : '');
}

deletion.forEach(function(index) {
  delete object[indexToKey(index)];
});

This implementation is less robust because it inherently ties the implementation to your key naming structure.

Answer 2

A simple way:

 var obj = { key: "value", key2: "value2", key3: "value3", key4: "value4", key5: "value5" }; var indices = [1,3,5]; var result = removeKeys(indices, obj); alert(JSON.stringify(result, null, 4)); 

 <script> function removeKeys(indices, obj) { var index = createKeyIndex(indices); return removeIndex(index, obj); } function removeIndex(index, obj) { var keys = Object.keys(obj); var length = keys.length; var result = {}; var i = 0; while (i < length) { var key = keys[i++]; if (!index.hasOwnProperty(key)) result[key] = obj[key]; } return result; } function createKeyIndex(indices) { var length = indices.length; var index = {}; var i = 0; while (i < length) { var n = indices[i++]; var key = "key" + (n === 1 ? "" : n); index[key] = true; } return index; } </script> 

The createKeyIndex function returns an index object of an array of keys. It allows you to test whether the input array has a given key in O(1) time. For an array of length n it takes O(n) time to create the index.

For example, createKeyIndex([1,3,5]) results in { key:true, key3:true, key5:true } .

The removeKeys function creates an index object of the given indices array and then adds only those keys which are not in the given indices array. For an object of length m it takes O(n) + O(m) time to remove the non-required keys. The O(n) time is for creating the index object.