从 object 中删除所有属性

Question

I have this Javascript object.

req.session

In my code I add properties to this object. These properties can be other objects, arrays, or just plain strings.

req.session.savedDoc = someObject; 
req.session.errors = ['someThing', 'anotherThing', 'thirdThing'];
req.session.message = 'someString'

If I later would like to erase all added properties of this object, what is the easiest/best way?

There must be a better way than this?

// Delete all session values
delete req.session.savedDoc;
delete req.session.errors;
delete req.session.message;

Answer 1

@VisioN's answer works if you want to clear that specific reference, but if you actually want to clear an object I found that this works:

for (var variableKey in vartoClear){
    if (vartoClear.hasOwnProperty(variableKey)){
        delete vartoClear[variableKey];
    }
}

Answer 2

Simply assign an empty object:

req.session = {};

... and the garbage collector will do the rest automatically.

---

UPDATE: Since this answer is disputable, I would like to provide some more details on the point.

The solution given above will do the job for the author in the current situation, as well as any other valid solution provided in this question. It mainly depends on the way how the developer wants to manipulate the deprecated data.

Session object may contain data that is linked by different variable, and setting a new empty object to req.session will not break the reference to the old data, so the old data will be available where it is still required. Although the correct way to keep old data is to clone the initial object, real life scenarios can be different. Let's look at the following example:

req.session.user = { name: 'Alexander' };  // we store an object in the session
var session = req.session;                 // save reference to the session in a variable
console.log( req.session, session );       // {user: Object}, {user: Object}

req.session = {};                          // let's replace session with a new object
console.log( req.session, session );       // {}, {user: Object}

We still can fetch old data from session variable but req.session is empty: here setting a new object works as sort of alternative to deep cloning. The garbage collector will not remove data from old req.session object as it is still referenced by session variable.

Deep cleaning of the object with method provided by @Dave or shorter via Object.keys (which ignores properties in the prototype chain and doesn't require any shims for node.js ):

Object.keys(object).forEach(function(key) { delete object[key]; });

... will explicitly remove all values from the req.session object and, since session variable is linked to the same object, session will become empty as well. Let's see how it works:

req.session.user = { name: 'Alexander' };  // we store an object in the session
var session = req.session;                 // save reference to the session in a variable
console.log( req.session, session );       // {user: Object}, {user: Object}

Object.keys(req.session).forEach(function(key) { delete req.session[key]; });
console.log( req.session, session );       // {}, {}

As you can see now, in both cases we get empty objects.

From speed and memory perspectives setting new empty object will be much faster than cleaning the old object property by property, however memory-wise if old data is still referenced somewhere, the new object approach won't free up memory that old data is consuming.

It's quite obvious that choosing the approach to take is mostly up to your coding scenario, but in most cases req.session = {}; will do the job: it is fast and short. However, if you keep references to the original object in other variables, you may consider using deep implicit object properties deletion.

Answer 3

I can see only one correct solution for removing own properties from object:

for (var x in objectToClean) if (objectToClean.hasOwnProperty(x)) delete objectToClean[x];

If you want to use it more than once, you should create a cleaning function:

function deleteProperties(objectToClean) {
  for (var x in objectToClean) if (objectToClean.hasOwnProperty(x)) delete objectToClean[x];
}

For your case the usage would be:

deleteProperties(req.session);

This solution removes properties from the object wherever it's referenced and keeping the old reference.
Example:
Using empty object assignment:

var x = {a: 5};
var y = x;
x = {};    // x will be empty but y is still {a: 5}, also now reference is gone: x !== y

Using cleaning method:

var x = {a: 5};
var y = x;
deleteProperties(x);  // x and y are both empty and x === y

Answer 4

如果您想删除所有属性而不触及方法，您可以使用：

for(var k in req.session) if(!req.session[k].constructor.toString().match(/^function Function\(/)) delete req.session[k];

Answer 5

I've done it like this

var 
    i,
    keys = Object.keys(obj);
for(i = 0; i < keys.length; i++){
    delete obj[keys[i]];
}

You could add it to Object (prototype's not ideal here) - will be static.

Object.defineproperties(Object, {
    'clear': function(target){
        var 
            i,
            keys = Object.keys(target);
        for(i = 0; i < keys.length; i++){
            delete target[keys[i]];
        }
    }
});

Then you can clear random objects with

Object.clear(yourObj);

yourObj = {} replaces the reference to a new object, the above removes it's properties - reference is the same.

Answer 6

This script removes property recursively except for the data reported in vector.

You need the lodash library

-- Function:

function removeKeysExcept(object, keysExcept = [], isFirstLevel = true) {
        let arrayKeysExcept = [],
            arrayNextKeysExcept = {};
        _.forEach(keysExcept, (value, i) => {
            let j = value.split('.');
            let keyExcept = j[0];
            arrayKeysExcept.push(keyExcept);
            j.shift();
            if (j.length) {
                j = j.join('.');
                if (!arrayNextKeysExcept[keyExcept]) {
                    arrayNextKeysExcept[keyExcept] = [];
                }
                arrayNextKeysExcept[keyExcept].push(j);
            }
        })
        _.forEach(arrayNextKeysExcept, (value, key) => {
            removeKeysExcept(object[key], value, false);
        });
        if (isFirstLevel) {
            return;
        }
        Object.keys(object).forEach(function (key) {
            if (arrayKeysExcept.indexOf(key) == -1) {
                delete object[key];
            }
        });
    }

Run so:

-- Removes all properties except the first level and reported in the vector:

removeKeysExcept(obj, ['department.id','user.id']);

-- Removes all properties

removeKeysExcept(obj, ['department.id','user.id'], false);

-- Example:

let obj = {
    a: {
        aa: 1,
        ab: {
            aba: 21
        }
    },
    b: 10,
    c: {
        ca: 100,
        cb: 200
    }
};

removeKeysExcept(obj, ['a.ab.aba','c.ca']);
/*OUTPUT: {
    a: {
        ab: {
            aba: 21
        }
    },
    b: 10,
    c: {
        ca: 100,
    }
};*/

removeKeysExcept(obj, ['a.ab.aba','c.ca'], false); //Remove too firt level
/*OUTPUT: {
    a: {
        ab: {
            aba: 21
        }
    },
    c: {
        ca: 100,
    }
};*/

removeKeysExcept(obj);
/*OUTPUT: {b:10};*/

removeKeysExcept(obj, [], false); //Remove too firt level
/*OUTPUT: {};*/

Answer 7

The naive object = {} method is okay for vanilla Object, but it deletes prototypes of custom objects.

This method produces an empty object that preserves prototypes , using Object.getPrototypeOf() and Object.create() :

    emptyObj = Object.create(Object.getPrototypeOf(obj), {});

Example:

 class Custom extends Object { custom() {} } let custom = new Custom(); custom.foo = "bar"; console.log(custom.constructor.name, custom); // Custom {"foo": "bar"} // naive method: let objVanilla = {} console.log(objVanilla.constructor.name, objVanilla); // Object {} // safe method: objSafe = Object.create(Object.getPrototypeOf(custom), {}); console.log(objSafe.constructor.name, objSafe); // Custom {}

Answer 8

You can use a map instead if you care about performance like so

const map = new Map()
map.set("first", 1)
map.set("second", 1)
map.clear()

This is a O(1) operation, so even if you have a huge object you do not need to iterate x times to delete the entries.