Enumeración y propietarios de propiedades

Esta traducción está incompleta. Por favor, ayuda a traducir este artículo del inglés.

Las propiedades enumerables son aquellas que pueden ejecutarse repetidamente en un ciclo ciclo for..in.

El propietario de las propiedades se determina de acuerdo a si la propiedad pertenece al objeto directamente y no a su cadena de prototipos.

Las propiedades de un objeto también pueden recuperarse en total.

Hay varios medios incorporados para  detectar, iterar/enumerar, y recuperar propiedades de objetos, en los que el cuadro muestra aquellos disponibles. Y, a continuación del mismo, hay un código de muestra para saber cómo obtener las categorías que faltan.

 

Enumerabilidad y propietario de una propiedad, métodos incorporados de detección, recupero e iteración
Funcionalidad Objeto propio Objeto propio y su cadena de prototipos Sólo cadena de prototipos
Detección
Enumerable No enumerable Enumerable y  No enumerable
propertyIsEnumerable hasOwnProperty y no propertyIsEnumerable hasOwnProperty
No disponible sin código extra No disponible sin código extra
Recupero
Enumerable No enumerable Enumerable  y no nenumerable
Object.keys getOwnPropertyNames se filtra para incluir propiedades cuando no se pasa propertyIsEnumerable getOwnPropertyNames
No disponible sin código extra No disponible sin código extra
Iteración
Enumerable No enumerable Enumerable  y no enumerable
Iterar las Object.keys Iterar los getOwnPropertyNames se filtra para incluir propiedades cuando no se pasa propertyIsEnumerable Iterar los getOwnPropertyNames
Enumerable No enumerable Enumerable y No enumerable
for..in No disponible sin código extra No disponible sin código extra
No disponible sin código extra

   

Obetener propiedades por enumeración /propiedad

// Obseva que este no es el algoritmo más eficiente para todos los casos, pero es útil para una rápida demostración
// La detección puede ocurrir por SimplePropertyRetriever.theGetMethodYouWant(obj).indexOf(prop) > -1
// La iteración puede ocurrir por SimplePropertyRetriever.theGetMethodYouWant(obj).forEach(function (value, prop) {}); // O usar filter(), map(), etc.

var SimplePropertyRetriever = {
    getOwnEnumerables: function (obj) {
        return this._getPropertyNames(obj, true, false, this._enumerable); // O podría usar for..in filtrado con hasOwnProperty o sólo esto: return Object.keys(obj);
    },
    getOwnNonenumerables: function (obj) {
        return this._getPropertyNames(obj, true, false, this._notEnumerable);
    },
    getOwnEnumerablesAndNonenumerables: function (obj) {
        return this._getPropertyNames(obj, true, false, this._enumerableAndNotEnumerable); // Or just use: return Object.getOwnPropertyNames(obj);
    },
    getPrototypeEnumerables: function (obj) {
        return this._getPropertyNames(obj, false, true, this._enumerable);
    },
    getPrototypeNonenumerables: function (obj) {
        return this._getPropertyNames(obj, false, true, this._notEnumerable);
    },
    getPrototypeEnumerablesAndNonenumerables: function (obj) {
        return this._getPropertyNames(obj, false, true, this._enumerableAndNotEnumerable);
    },
    getOwnAndPrototypeEnumerables: function (obj) {
        return this._getPropertyNames(obj, true, true, this._enumerable); // O prdría usar for..in sin filtrar
    },
    getOwnAndPrototypeNonenumerables: function (obj) {
        return this._getPropertyNames(obj, true, true, this._notEnumerable);
    },
    getOwnAndPrototypeEnumerablesAndNonenumerables: function (obj) {
        return this._getPropertyNames(obj, true, true, this._enumerableAndNotEnumerable);
    },
    // Devoluciones de llamada al verificador de la propiedad privada estática
    _enumerable : function (obj, prop) {
        return obj.propertyIsEnumerable(prop);
    },
    _notEnumerable : function (obj, prop) {
        return !obj.propertyIsEnumerable(prop);
    },
    _enumerableAndNotEnumerable : function (obj, prop) {
        return true;
    },
    // Inspirado por http://stackoverflow.com/a/8024294/271577
    _getPropertyNames : function getAllPropertyNames(obj, iterateSelfBool, iteratePrototypeBool, includePropCb) {
        var props = [];

        do {
            if (iterateSelfBool) {
                Object.getOwnPropertyNames(obj).forEach(function (prop) {
                    if (props.indexOf(prop) === -1 && includePropCb(obj, prop)) {
                        props.push(prop);
                    }
                });
            }
            if (!iteratePrototypeBool) {
                break;
            }
            iterateSelfBool = true;
        } while (obj = Object.getPrototypeOf(obj));

        return props;
    }
};

Tabla de detecciones

  in for..in hasOwnProperty propertyIsEnumerable in Object.keys in Object.getOwnPropertyNames
Enumerable verdadero verdadero verdadero verdadero verdadero verdadero
No enumerable verdadero falso verdadero falso falso verdadero
Enumerable heredado verdadero verdadero falso falso falso falso
No enumerable heredado verdadero falso falso falso falso falso

Ver también

Etiquetas y colaboradores del documento

 Colaboradores en esta página: teoli, LeoHirsch
 Última actualización por: teoli,