เป็นไปได้หรือไม่ที่จะได้รับชื่อคุณสมบัติที่สืบทอดมาซึ่งไม่สามารถระบุได้ของวัตถุ?

ใน JavaScript เรามีสองสามวิธีในการรับคุณสมบัติของวัตถุขึ้นอยู่กับสิ่งที่เราต้องการได้รับ

1) Object.keys()ซึ่งส่งคืนคุณสมบัติที่นับได้ของอ็อบเจ็กต์ทั้งหมดเป็นของตัวเองวิธี ECMA5

2) for...inลูปซึ่งส่งคืนคุณสมบัติที่นับได้ทั้งหมดของอ็อบเจกต์ไม่ว่าจะเป็นคุณสมบัติของตัวเองหรือสืบทอดมาจากโซ่ต้นแบบ

3) Object.getOwnPropertyNames(obj)ซึ่งส่งคืนคุณสมบัติของตัวเองทั้งหมดของวัตถุแจกแจงได้หรือไม่

นอกจากนี้เรายังมีวิธีการเช่นhasOwnProperty(prop)ให้เราตรวจสอบว่าทรัพย์สินนั้นสืบทอดมาหรือเป็นของวัตถุนั้นจริงหรือไม่และpropertyIsEnumerable(prop)ตามที่ชื่อแนะนำช่วยให้เราตรวจสอบว่ามีการแจกแจงคุณสมบัติหรือไม่

ด้วยตัวเลือกทั้งหมดนี้ไม่มีทางที่จะได้รับคุณสมบัติที่ไม่สามารถระบุได้และไม่ใช่ของตัวเองซึ่งเป็นสิ่งที่ฉันต้องการทำ มีวิธีใดบ้างที่จะทำเช่นนี้? กล่าวอีกนัยหนึ่งฉันจะได้รับรายการคุณสมบัติที่ไม่สามารถนับได้ที่สืบทอดมาได้หรือไม่?

ขอขอบคุณ.

เนื่องจากgetOwnPropertyNamesคุณจะได้รับคุณสมบัติที่ไม่สามารถนับได้คุณจึงสามารถใช้และรวมกับการเดินขึ้นไปตามห่วงโซ่ต้นแบบได้

function getAllProperties(obj){
    var allProps = []
      , curr = obj
    do{
        var props = Object.getOwnPropertyNames(curr)
        props.forEach(function(prop){
            if (allProps.indexOf(prop) === -1)
                allProps.push(prop)
        })
    }while(curr = Object.getPrototypeOf(curr))
    return allProps
}

ฉันทดสอบบน Safari 5.1 และได้รับ

> getAllProperties([1,2,3])
["0", "1", "2", "length", "constructor", "push", "slice", "indexOf", "sort", "splice", "concat", "pop", "unshift", "shift", "join", "toString", "forEach", "reduceRight", "toLocaleString", "some", "map", "lastIndexOf", "reduce", "filter", "reverse", "every", "hasOwnProperty", "isPrototypeOf", "valueOf", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "propertyIsEnumerable", "__lookupSetter__"]

อัปเดต:ปรับโครงสร้างโค้ดใหม่เล็กน้อย (เพิ่มช่องว่างและวงเล็บปีกกาและปรับปรุงชื่อฟังก์ชัน):

function getAllPropertyNames( obj ) {
    var props = [];

    do {
        Object.getOwnPropertyNames( obj ).forEach(function ( prop ) {
            if ( props.indexOf( prop ) === -1 ) {
                props.push( prop );
            }
        });
    } while ( obj = Object.getPrototypeOf( obj ) );

    return props;
}

โซลูชันที่สะอาดกว่าโดยใช้การเรียกซ้ำ:

function getAllPropertyNames (obj) {
    const proto     = Object.getPrototypeOf(obj);
    const inherited = (proto) ? getAllPropertyNames(proto) : [];
    return [...new Set(Object.getOwnPropertyNames(obj).concat(inherited))];
}

แก้ไข

ฟังก์ชั่นทั่วไปเพิ่มเติม:

function walkProtoChain (obj, callback) {
    const proto     = Object.getPrototypeOf(obj);
    const inherited = (proto) ? walkProtoChain(proto, callback) : [];
    return [...new Set(callback(obj).concat(inherited))];
}

function getOwnNonEnumPropertyNames (obj) {
    return Object.getOwnPropertyNames(obj)
        .filter(p => !obj.propertyIsEnumerable(p));
}

function getAllPropertyNames (obj) {
    return walkProtoChain(obj, Object.getOwnPropertyNames);
}

function getAllEnumPropertyNames (obj) {
    return walkProtoChain(obj, Object.keys);
}

function getAllNonEnumPropertyNames (obj) {
    return walkProtoChain(obj, getOwnNonEnumPropertyNames);
}

สามารถใช้เทมเพลตเดียวกันนี้ได้โดยใช้Object.getOwnPropertySymbolsฯลฯ

การใช้ประโยชน์จากชุดจะนำไปสู่โซลูชันที่ค่อนข้างสะอาดกว่า IMO

const own = Object.getOwnPropertyNames;
const proto = Object.getPrototypeOf;

function getAllPropertyNames(obj) {
    const props = new Set();
    do own(obj).forEach(p => props.add(p)); while (obj = proto(obj));
    return Array.from(props);
}

การทำซ้ำแบบตรงไปตรงมาใน ES6:

function getAllPropertyNames(obj) {
    let result = new Set();
    while (obj) {
        Object.getOwnPropertyNames(obj).forEach(p => result.add(p));
        obj = Object.getPrototypeOf(obj);
    }
    return [...result];
}

ตัวอย่างการรัน:

function getAllPropertyNames(obj) {
  let result = new Set();
  while (obj) {
    Object.getOwnPropertyNames(obj).forEach(p => result.add(p));
    obj = Object.getPrototypeOf(obj);
  }
  return [...result];
}

let obj = {
  abc: 123,
  xyz: 1.234,
  foobar: "hello"
};

console.log(getAllPropertyNames(obj));

หากต้องการรับคุณสมบัติหรือวิธีการที่สืบทอดมาทั้งหมดสำหรับบางกรณีคุณสามารถใช้สิ่งนี้ได้

var BaseType = function () {
    this.baseAttribute = "base attribute";
    this.baseMethod = function() {
        return "base method";
    };
};

var SomeType = function() {
    BaseType();
    this.someAttribute = "some attribute";
    this.someMethod = function (){
        return "some method";
    };
};

SomeType.prototype = new BaseType();
SomeType.prototype.constructor = SomeType;

var instance = new SomeType();

Object.prototype.getInherited = function(){
    var props = []
    for (var name in this) {  
        if (!this.hasOwnProperty(name) && !(name == 'constructor' || name == 'getInherited')) {  
            props.push(name);
        }  
    }
    return props;
};

alert(instance.getInherited().join(","));

นี่คือวิธีแก้ปัญหาที่ฉันคิดขึ้นขณะศึกษาเรื่องนี้ หากต้องการรับคุณสมบัติที่ไม่ใช่ของตัวเองที่ไม่สามารถนับได้ทั้งหมดให้objทำgetProperties(obj, "nonown", "nonenum");

function getProperties(obj, type, enumerability) {
/**
 * Return array of object properties
 * @param {String} type - Property type. Can be "own", "nonown" or "both"
 * @param {String} enumerability - Property enumerability. Can be "enum", 
 * "nonenum" or "both"
 * @returns {String|Array} Array of properties
 */
    var props = Object.create(null);  // Dictionary

    var firstIteration = true;

    do {
        var allProps = Object.getOwnPropertyNames(obj);
        var enumProps = Object.keys(obj);
        var nonenumProps = allProps.filter(x => !(new Set(enumProps)).has(x));

        enumProps.forEach(function(prop) {
            if (!(prop in props)) {
                props[prop] = { own: firstIteration, enum_: true };
            }           
        });

        nonenumProps.forEach(function(prop) {
            if (!(prop in props)) {
                props[prop] = { own: firstIteration, enum_: false };
            }           
        });

        firstIteration = false;
    } while (obj = Object.getPrototypeOf(obj));

    for (prop in props) {
        if (type == "own" && props[prop]["own"] == false) {
            delete props[prop];
            continue;
        }
        if (type == "nonown" && props[prop]["own"] == true) {
            delete props[prop];
            continue;
        }

        if (enumerability == "enum" && props[prop]["enum_"] == false) {
            delete props[prop];
            continue;
        }
        if (enumerability == "nonenum" && props[prop]["enum_"] == true) {
            delete props[prop];
        }
    }

    return Object.keys(props);
}

function getNonEnumerableNonOwnPropertyNames( obj ) {
    var oCurObjPrototype = Object.getPrototypeOf(obj);
    var arReturn = [];
    var arCurObjPropertyNames = [];
    var arCurNonEnumerable = [];
    while (oCurObjPrototype) {
        arCurObjPropertyNames = Object.getOwnPropertyNames(oCurObjPrototype);
        arCurNonEnumerable = arCurObjPropertyNames.filter(function(item, i, arr){
            return !oCurObjPrototype.propertyIsEnumerable(item);
        })
        Array.prototype.push.apply(arReturn,arCurNonEnumerable);
        oCurObjPrototype = Object.getPrototypeOf(oCurObjPrototype);
    }
    return arReturn;
}

ตัวอย่างการใช้:

function MakeA(){

}

var a = new MakeA();

var arNonEnumerable = getNonEnumerableNonOwnPropertyNames(a);

หากคุณกำลังพยายามบันทึกคุณสมบัติที่ไม่สามารถนับได้ของอ็อบเจ็กต์พาเรนต์เช่น โดยค่าเริ่มต้นวิธีการที่กำหนดไว้ภายในคลาสใน es6 จะถูกตั้งค่าบนต้นแบบ แต่ถูกตั้งค่าเป็นไม่สามารถระบุได้

Object.getOwnPropertyNames(Object.getPrototypeOf(obj));

การใช้งานในความชอบส่วนตัวของฉัน :)

function getAllProperties(In, Out = {}) {
    const keys = Object.getOwnPropertyNames(In);
    keys.forEach(key => Object.defineProperty(In, key, {
        enumerable: true
    }));
    Out = { ...In, ...Out };

    const Prototype = Object.getPrototypeOf(In);
    return Prototype === Object.prototype ? Out : getAllProperties(Proto, Out);
}