js如何实现原型链的过滤查找

function findPropertiesInPrototypeChain(obj, filterFn) {
    let currentProto = obj;
    const foundProperties = [];

    while (currentProto !== null) {
        // 获取当前原型对象的所有自有属性名（包括不可枚举和Symbol）
        const ownKeys = Reflect.ownKeys(currentProto);

        for (const key of ownKeys) {
            // 获取属性描述符，可能过滤条件需要用到
            const descriptor = Object.getOwnPropertyDescriptor(currentProto, key);

            // 应用过滤函数
            if (filterFn(key, currentProto[key], currentProto, descriptor)) {
                foundProperties.push({
                    key: key,
                    value: currentProto[key],
                    source: currentProto, // 标记这个属性是在哪个原型上找到的
                    descriptor: descriptor
                });
            }
        }
        // 向上追溯
        currentProto = Object.getPrototypeOf(currentProto);
    }
    return foundProperties;
}

// 示例用法：
class Animal {
    constructor(name) {
        this.name = name;
    }
    walk() { return `${this.name} walks.`; }
    static species = 'mammal'; // 静态属性不走原型链
}

class Dog extends Animal {
    constructor(name, breed) {
        super(name);
        this.breed = breed;
    }
    bark() { return `${this.name} barks!`; }
    // 故意定义一个与父类同名的属性，看是否能被区分
    static species = 'canine'; 
    #privateField = 'secret'; // 私有字段不会被Reflect.ownKeys获取
}

const myDog = new Dog('Buddy', 'Golden Retriever');

// 过滤查找所有值为函数的属性
const functionsFound = findPropertiesInPrototypeChain(myDog, (key, value) => typeof value === 'function');
console.log('所有函数属性:', functionsFound.map(p => `${String(p.key)} from ${p.source.constructor.name || 'Object'}`));
/* 预期输出类似：
所有函数属性: [
  'bark from Dog',
  'walk from Animal',
  'constructor from Dog',
  'constructor from Animal',
  'constructor from Object'
]
*/

// 过滤查找所有可枚举的非函数属性
const enumerableNonFunctions = findPropertiesInPrototypeChain(myDog, (key, value, proto, desc) => 
    desc && desc.enumerable && typeof value !== 'function'
);
console.log('可枚举的非函数属性:', enumerableNonFunctions.map(p => `${String(p.key)}: ${p.value} from ${p.source.constructor.name || 'Object'}`));
/* 预期输出类似：
可枚举的非函数属性: [
  'name: Buddy from Dog',
  'breed: Golden Retriever from Dog'
]
*/

function* iteratePropertiesInPrototypeChain(obj, filterFn) {
    let currentProto = obj;
    while (currentProto !== null) {
        const ownKeys = Reflect.ownKeys(currentProto);
        for (const key of ownKeys) {
            const descriptor = Object.getOwnPropertyDescriptor(currentProto, key);
            if (filterFn(key, currentProto[key], currentProto, descriptor)) {
                yield {
                    key: key,
                    value: currentProto[key],
                    source: currentProto,
                    descriptor: descriptor
                };
            }
        }
        currentProto = Object.getPrototypeOf(currentProto);
    }
}

// 示例用法：
const myDog = new Dog('Buddy', 'Golden Retriever'); // 沿用之前的Dog类

// 查找第一个值为函数的属性
const firstFunction = iteratePropertiesInPrototypeChain(myDog, (key, value) => typeof value === 'function');
const firstMatch = firstFunction.next().value;
console.log('找到的第一个函数属性:', firstMatch ? `${String(firstMatch.key)} from ${firstMatch.source.constructor.name || 'Object'}` : '未找到');

// 迭代所有函数属性
console.log('迭代所有函数属性:');
for (const prop of iteratePropertiesInPrototypeChain(myDog, (key, value) => typeof value === 'function')) {
    console.log(`- ${String(prop.key)} from ${prop.source.constructor.name || 'Object'}`);
}