JavaScript中模拟MongoDB的find()方法：深度查找嵌套对象

const invalidDataStructure = {
  length: 1, // 误导性的length属性
  people: {
        // 注意：在JavaScript对象中，键必须是唯一的。
        // 这里的'person'键重复定义，只有最后一个会生效。
        // 此外，'first name'等带有空格的键需要用引号包裹。
        person: { 'first name': 'rafa', 'last name': 'rivas', age: 20 },
        person: { 'first name': 'miguel', 'last name': 'blades', age: 23 },
        person: { 'first name': 'mario', 'last name': 'perez', age: 93 },
    }
};

// 尝试使用Array.prototype.find()
// Array.prototype.find.call(invalidDataStructure, (x) => x);
// 结果将是 undefined。因为 invalidDataStructure[0] 是 undefined，
// 且 predicate (x) => x 对 undefined 返回 false。
// 它不会深入到 'people' 属性中。

const complexData = {
    metadata: {
        version: "1.0",
        lastUpdated: "2023-10-27"
    },
    people: [ // 使用数组存储多个person对象
        {
            firstName: 'rafa',
            lastName: 'rivas',
            age: 20,
            address: {
                city: 'New York',
                zip: '10001'
            }
        },
        {
            firstName: 'miguel',
            lastName: 'blades',
            age: 23,
            hobbies: ['reading', 'coding']
        },
        {
            firstName: 'mario',
            lastName: 'perez',
            age: 93
        },
    ],
    settings: {
        theme: 'dark',
        notifications: {
            email: true,
            sms: false
        }
    }
};

/**
 * 在嵌套对象或数组中深度查找第一个满足条件的项。
 *
 * @param {any} collection 要搜索的集合（对象或数组）。
 * @param {function(any): boolean} predicate 一个测试函数，对每个项执行，返回true表示匹配。
 * @returns {any | undefined} 找到的第一个匹配项，如果未找到则返回undefined。
 */
function deepFind(collection, predicate) {
    // 1. 如果当前项满足条件，则直接返回当前项
    if (predicate(collection)) {
        return collection;
    }

    // 2. 如果当前项是对象且非空，则继续深入
    if (typeof collection === 'object' && collection !== null) {
        // 3. 如果是数组，遍历其元素
        if (Array.isArray(collection)) {
            for (let i = 0; i < collection.length; i++) {
                const result = deepFind(collection[i], predicate);
                if (result !== undefined) {
                    return result; // 找到则立即返回
                }
            }
        } else { // 4. 如果是普通对象，遍历其属性
            for (const key in collection) {
                // 确保只遍历对象自身的属性，不包括原型链上的属性
                if (Object.prototype.hasOwnProperty.call(collection, key)) {
                    const result = deepFind(collection[key], predicate);
                    if (result !== undefined) {
                        return result; // 找到则立即返回
                    }
                }
            }
        }
    }

    // 5. 未找到匹配项
    return undefined;
}

const rafa = deepFind(complexData, item =>
    typeof item === 'object' && item !== null && item.firstName === 'rafa'
);
console.log("找到 'rafa':", rafa);
// 输出: 找到 'rafa': { firstName: 'rafa', lastName: 'rivas', age: 20, address: { city: 'New York', zip: '10001' } }

const oldPerson = deepFind(complexData, item =>
    typeof item === 'object' && item !== null && item.age > 90
);
console.log("找到年龄大于90岁的人:", oldPerson);
// 输出: 找到年龄大于90岁的人: { firstName: 'mario', lastName: 'perez', age: 93 }

const personInNY = deepFind(complexData, item =>
    typeof item === 'object' && item !== null && item.address && item.address.city === 'New York'
);
console.log("找到居住在纽约的人:", personInNY);
// 输出: 找到居住在纽约的人: { firstName: 'rafa', lastName: 'rivas', age: 20, address: { city: 'New York', zip: '10001' } }

const coder = deepFind(complexData, item =>
    typeof item === 'object' && item !== null && Array.isArray(item.hobbies) && item.hobbies.includes('coding')
);
console.log("找到爱好是编程的人:", coder);
// 输出: 找到爱好是编程的人: { firstName: 'miguel', lastName: 'blades', age: 23, hobbies: [ 'reading', 'coding' ] }

const emailNotificationSetting = deepFind(complexData, item =>
    typeof item === 'boolean' && item === true && typeof deepFind(complexData.settings, s => s === item) !== 'undefined'
);
// 更直接的方式是查找父对象，或者直接查找值
const emailEnabled = deepFind(complexData, item => item === true && typeof item === 'boolean' && deepFind(complexData.settings.notifications, n => n === item));
console.log("邮件通知是否启用:", emailEnabled);
// 输出: 邮件通知是否启用: true

// 查找包含特定键值对的对象
const notificationConfig = deepFind(complexData, item =>
    typeof item === 'object' && item !== null && item.email === true && item.sms === false
);
console.log("找到通知配置:", notificationConfig);
// 输出: 找到通知配置: { email: true, sms: false }

// 示例：循环引用
const objA = {};
const objB = {};
objA.b = objB;
objB.a = objA;

// deepFind(objA, item => item === 123); // 这会导致栈溢出