Object.getOwnPropertyNames vs Object.keys

Qual è la differenza tra Object.getOwnPropertyNamese Object.keysin javascript? Anche alcuni esempi sarebbero apprezzati.

C'è una piccola differenza Object.getOwnPropertyNames(a)restituisce tutte le proprietà dell'oggetto a. Object.keys(a)ritorna tutto enumerabile proprietà proprie . Significa che se definisci le proprietà del tuo oggetto senza crearne alcune, enumerable: falsequesti due metodi ti daranno lo stesso risultato.

È facile testare:

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

Se si definisce una proprietà senza fornire il descrittore degli attributi di proprietà (nel senso che non si utilizza Object.defineProperties), ad esempio:

a.test = 21;

quindi tale proprietà diventa automaticamente enumerabile ed entrambi i metodi producono lo stesso array.

Un'altra differenza è nel caso in cui il Object.getOwnPropertyNamesmetodo array restituisca una proprietà aggiuntiva length.

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

Notazione letterale vs costruttore durante la creazione di un oggetto. Ecco qualcosa che mi ha preso.

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

Quindi nel mio caso il foo funzione non ha funzionato se gli ho dato oggetti di tipo cat2.

Esistono altri modi per creare oggetti in modo che possano esserci anche altri nodi.

Come già spiegato, .keysnon restituisce proprietà enumerabili.

Per quanto riguarda gli esempi, uno dei casi di trappola è un Erroroggetto: alcune delle sue proprietà sono enumerabili.
Quindi, mentre console.log(Object.keys(new Error('some msg')))cede [], console.log(Object.getOwnPropertyNames(new Error('some msg')))cede["stack", "message"]

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

Un'altra differenza è che (almeno con nodejs) la funzione "getOwnPropertyNames" non garantisce l'ordine delle chiavi, ecco perché di solito uso la funzione "chiavi":

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