Object.getOwnPropertyNames vs Object.keys

Was ist der Unterschied zwischen Object.getOwnPropertyNamesund Object.keysin Javascript? Auch einige Beispiele wären willkommen.

Es gibt einen kleinen Unterschied. Object.getOwnPropertyNames(a)Gibt alle eigenen Eigenschaften des Objekts zurück a. Object.keys(a)gibt alle aufzählbaren zurück eigenen Eigenschaften zurück. Wenn Sie Ihre Objekteigenschaften definieren, ohne einige davon enumerable: falsezu erstellen, erhalten Sie mit diesen beiden Methoden das gleiche Ergebnis.

Es ist einfach zu testen:

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

Wenn Sie eine Eigenschaft definieren, ohne einen Eigenschaftsattributdeskriptor anzugeben (dh, Sie verwenden ihn nicht Object.defineProperties), zum Beispiel:

a.test = 21;

dann wird eine solche Eigenschaft automatisch zu einer Aufzählung und beide Methoden erzeugen dasselbe Array.

Ein weiterer Unterschied besteht darin, dass im Falle einer Array- Object.getOwnPropertyNamesMethode eine zusätzliche Eigenschaft zurückgegeben wird length.

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

Literale Notation gegen Konstruktor beim Erstellen eines Objekts. Hier ist etwas, das mich erwischt hat.

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";
    }
}

In meinem Fall foofunktionierte die Funktion also nicht, wenn ich ihr Objekte vom Typ cat2 gab.

Es gibt andere Möglichkeiten, Objekte zu erstellen, sodass auch andere Knicke auftreten können.

Gibt, .keyswie bereits erläutert, keine aufzählbaren Eigenschaften zurück.

In Bezug auf Beispiele ist einer der Fallstricke ein ErrorObjekt: Einige seiner Eigenschaften sind aufzählbar.
Also, während console.log(Object.keys(new Error('some msg')))Renditen [], console.log(Object.getOwnPropertyNames(new Error('some msg')))Renditen["stack", "message"]

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

Ein weiterer Unterschied ist, dass (zumindest bei nodejs) die Funktion "getOwnPropertyNames" keine Schlüsselreihenfolge garantiert. Deshalb verwende ich normalerweise die Funktion "keys":

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