Suppression de toutes les propriétés d'un objet

Question

J'ai cet objet Javascript.

req.session

Dans mon code, j'ajoute des propriétés à cet objet. Ces propriétés peuvent être d'autres objets, des tableaux, ou simplement des chaînes de caractères.

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

Si je veux ensuite effacer toutes les propriétés ajoutées à cet objet, quelle est la manière la plus simple/meilleure ?

Il doit y avoir une meilleure manière que celle-ci ?

// Supprimer toutes les valeurs de session
delete req.session.savedDoc;
delete req.session.errors;
delete req.session.message;

Answer 1

J'ai fait comme ça

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

Vous pourriez l'ajouter à Object (le prototype n'est pas idéal ici) - cela sera statique.

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

Ensuite, vous pouvez effacer des objets aléatoires avec

Object.clear(yourObj);

yourObj = {} remplace la référence par un nouvel objet, le code ci-dessus supprime ses propriétés - la référence reste la même.

Answer 2

Une bonne façon de faire cela serait de boucler à travers la valeur de retour de Object.getOwnPropertyNames(). Cela capturera à la fois les propriétés énumérables et cachées, mais pas les symboles, et cela exclut déjà les propriétés héritées. À noter, cependant, est que pour supprimer une propriété en utilisant n'importe quelle méthode dans ces réponses, cette propriété doit être configurable. Si vous voulez aussi attraper les symboles, vous pouvez ajouter Object.getOwnPropertySymbols().

const obj = Object.create( Object.prototype, {
    visibleProperty: {
        value: 'visibleProperty',
        enumerable: true,
        configurable: true,
    },
    hiddenProperty: {
        value: 'hiddenProperty',
        configurable: true,
    },
    [ Symbol( 'symbolProperty' ) ]: {
        value: 'symbolProperty',
        configurable: true,
    },
    visibleMethod: {
        value: () => 'visibleMethod',
        enumerable: true,
        configurable: true,
    },
    hiddenMethod: {
        value: () => 'hiddenMethod',
        configurable: true,
    },
    [ Symbol( 'symbolMethod' ) ]: {
        value: () => 'symbolMethod',
        configurable: true,
    },
} );

for( const key of Object.getOwnPropertyNames( obj ) ) delete obj[ key ];

console.log( Object.getOwnPropertyDescriptors( obj ) );

Cela supprimera tout sauf les propriétés identifiées par des symboles, donc la dernière ligne produira la sortie suivante:

{
    [Symbol(symbolProperty)]: {
        value: 'symbolProperty',
        writable: false,
        enumerable: false,
        configurable: true
    },
    [Symbol(symbolMethod)]: {
        value: [Function: value],
        writable: false,
        enumerable: false,
        configurable: true
    }
}

Answer 3

La méthode naïve object = {} est ok pour un objet vanilla, mais elle supprime les prototypes des objets personnalisés.

Cette méthode produit un objet vide qui préserve les prototypes, en utilisant Object.getPrototypeOf() et Object.create():

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

Exemple:

class Custom extends Object {
  custom() {}
}

let custom = new Custom();
custom.foo = "bar";
console.log(custom.constructor.name, custom);
// Custom {"foo": "bar"}

// méthode naïve:
let objVanilla = {}
console.log(objVanilla.constructor.name, objVanilla);
// Object {}

// méthode sûre:
objSafe = Object.create(Object.getPrototypeOf(custom), {});
console.log(objSafe.constructor.name, objSafe);
// Custom {}

Answer 4

let obj = { a: 1, b: 2, c: 3 };

// Obtenir un tableau de toutes les clés de l'objet
let keys = Object.keys(obj);

// Parcourir les clés et supprimer chaque propriété
for (let i = 0; i < keys.length; i++) {
  delete obj[keys[i]];
}

console.log(obj); // Résultat: {}

Answer 5

Ce script supprime les propriétés de manière récursive sauf les données indiquées dans le vecteur.

Vous avez besoin de la bibliothèque lodash

-- Fonction:

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];
            }
        });
    }

Exécuter ainsi:

-- Supprime toutes les propriétés sauf le premier niveau et celles indiquées dans le vecteur :

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

-- Supprime toutes les propriétés

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

-- Exemple:

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

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

removeKeysExcept(obj, ['a.ab.aba','c.ca'], false); //Suppression du premier niveau
/*SORTIE: {
    a: {
        ab: {
            aba: 21
        }
    },
    c: {
        ca: 100,
    }
};*/

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

removeKeysExcept(obj, [], false); //Suppression du premier niveau
/*SORTIE: {};*/