Object.getOwnPropertyNames vs Object.keys

Quelle est la différence entre Object.getOwnPropertyNameset Object.keysen javascript? Quelques exemples seraient également appréciés.

Il y a une petite différence. Object.getOwnPropertyNames(a)renvoie toutes les propriétés propres de l'objet a. Object.keys(a)renvoie toutes les propriétés propres énumérables . Cela signifie que si vous définissez vos propriétés d'objet sans en créer certaines, enumerable: falseces deux méthodes vous donneront le même résultat.

C'est facile à tester:

var a = {};
Object.defineProperties(a, {
    one: {enumerable: true, value: 'one'},
    two: {enumerable: false, value: 'two'},
});
Object.keys(a); // ["one"]
Object.getOwnPropertyNames(a); // ["one", "two"]

Si vous définissez une propriété sans fournir de descripteur d'attributs de propriété (ce qui signifie que vous n'utilisez pas Object.defineProperties), par exemple:

a.test = 21;

alors cette propriété devient automatiquement un énumérable et les deux méthodes produisent le même tableau.

Une autre différence est dans le cas où la Object.getOwnPropertyNamesméthode tableau retournera une propriété supplémentaire qui est length.

var x = ["a", "b", "c", "d"];
Object.keys(x);  //[ '0', '1', '2', '3' ]
Object.getOwnPropertyNames(x);  //[ '0', '1', '2', '3', 'length' ]

Notation littérale vs constructeur lors de la création d'un objet. Voici quelque chose qui m'a attiré.

const cat1 = {
    eat() {},
    sleep() {},
    talk() {}
};

// here the methods will be part of the Cat Prototype
class Cat {
    eat() {}
    sleep() {}
    talk() {}
}

const cat2 = new Cat()

Object.keys(cat1) // ["eat", "sleep", "talk"]
Object.keys(Object.getPrototypeOf(cat2)) // []

Object.getOwnPropertyNames(cat1) // ["eat", "sleep", "talk"]
Object.getOwnPropertyNames(Object.getPrototypeOf(cat2)) // ["eat", "sleep", "talk"]

cat1 // {eat: function, sleep: function, talk: function}
cat2 // Cat {}

// a partial of a function that is used to do some magic redeclaration of props
function foo(Obj) {
    var propNames = Object.keys(Obj);

    // I was missing this if
    // if (propNames.length === 0) {
    //     propNames = Object.getOwnPropertyNames(Obj);
    // }

    for (var prop in propNames) {
        var propName = propNames[prop];

        APIObject[propName] = "reasign/redefine or sth";
    }
}

Donc, dans mon cas, la foofonction ne fonctionnait pas si je lui donnais des objets de type cat2.

Il existe d'autres façons de créer des objets afin qu'il puisse y avoir d'autres défauts.

Comme cela a déjà été expliqué, .keysne renvoie pas de propriétés énumérables.

En ce qui concerne les exemples, l'un des cas de piège est un Errorobjet: certaines de ses propriétés sont énumérables.
Donc, alors que les console.log(Object.keys(new Error('some msg')))rendements [], les console.log(Object.getOwnPropertyNames(new Error('some msg')))rendements["stack", "message"]

console.log(Object.keys(new Error('some msg')));
console.log(Object.getOwnPropertyNames(new Error('some msg')));

Une autre différence est que (au moins avec nodejs) la fonction "getOwnPropertyNames" ne garantit pas l'ordre des clés, c'est pourquoi j'utilise généralement la fonction "clés":

    Object.keys(o).forEach(function(k) {
      if (!o.propertyIsEnumerable(k)) return;
      // do something...
    });