JavaScript深层对象查找：实现类似MongoDB的查询功能

const arrayLikeObject = {
  length: 3, // 误导性的length属性
  0: 'apple',
  1: 'banana',
  // 没有2: 'cherry'
  fruit: 'orange'
};

// 尝试使用Array.prototype.find.call()
console.log(Array.prototype.find.call(arrayLikeObject, (item) => item === 'apple')); // 输出: "apple" (因为0:'apple'存在)
console.log(Array.prototype.find.call(arrayLikeObject, (item) => item === 'cherry')); // 输出: undefined (因为索引2不存在，且find不会遍历非数字键)
console.log(Array.prototype.find.call(arrayLikeObject, (item) => item === 'orange')); // 输出: undefined (因为'fruit'不是数字索引)

const nestedObject = {
  length: 1, // 同样是误导性的
  people: {
    person1: { firstName: 'rafa', age: 20 },
    person2: { firstName: 'miguel', age: 23 }
  }
};
console.log(Array.prototype.find.call(nestedObject, (x) => x)); // 输出: undefined

/**
 * 在嵌套对象或数组中查找包含特定值的第一个对象。
 * 该函数会深度遍历数据结构，并返回直接包含 targetValue 作为其某个属性值的最内层对象。
 *
 * @param {any} data 要搜索的数据（对象或数组）。
 * @param {any} targetValue 要查找的目标值。
 * @returns {object|null} 包含目标值的第一个对象，如果未找到则返回null。
 */
function findContainingObject(data, targetValue) {
    // 基本情况：如果数据不是对象或为空，则无法进一步搜索
    if (typeof data !== 'object' || data === null) {
        return null;
    }

    // 遍历当前对象/数组的属性或元素
    for (const key in data) {
        // 确保属性是自身的，而不是原型链上的
        if (Object.prototype.hasOwnProperty.call(data, key)) {
            const value = data[key];

            // 检查当前属性值是否等于目标值
            if (value === targetValue) {
                return data; // 找到目标值，返回包含它的当前对象
            }

            // 如果当前值是另一个对象或数组，则递归搜索
            if (typeof value === 'object' && value !== null) {
                const result = findContainingObject(value, targetValue);
                if (result) {
                    return result; // 递归调用找到结果，立即返回
                }
            }
        }
    }

    return null; // 在当前层级及其子层级中都未找到
}

const nestedData = {
  id: 'root',
  metadata: {
    version: 1.0,
    status: 'active'
  },
  users: [
    {
      userId: 'user1',
      profile: {
        firstName: 'Alice',
        lastName: 'Smith',
        age: 30
      },
      roles: ['admin', 'editor']
    },
    {
      userId: 'user2',
      profile: {
        firstName: 'Bob',
        lastName: 'Johnson',
        age: 25
      },
      roles: ['viewer']
    },
    {
      userId: 'user3',
      profile: {
        firstName: 'Charlie',
        lastName: 'Brown',
        age: 40
      },
      details: {
        department: 'HR',
        startDate: '2020-01-15'
      }
    }
  ],
  settings: {
    theme: 'dark',
    notifications: {
      email: true,
      sms: false
    }
  }
};

// 查找包含值为 'Alice' 的对象
const aliceProfile = findContainingObject(nestedData, 'Alice');
console.log('包含 "Alice" 的对象:', aliceProfile);
// 预期输出: { firstName: 'Alice', lastName: 'Smith', age: 30 }

// 查找包含值为 25 的对象
const bobProfile = findContainingObject(nestedData, 25);
console.log('包含 25 的对象:', bobProfile);
// 预期输出: { firstName: 'Bob', lastName: 'Johnson', age: 25 }

// 查找包含值为 'admin' 的对象
const adminRoles = findContainingObject(nestedData, 'admin');
console.log('包含 "admin" 的对象:', adminRoles);
// 预期输出: ['admin', 'editor']

// 查找包含值为 true 的对象
const emailSettings = findContainingObject(nestedData, true);
console.log('包含 true 的对象:', emailSettings);
// 预期输出: { email: true, sms: false }

// 查找一个不存在的值
const notFound = findContainingObject(nestedData, 'NonExistentValue');
console.log('未找到的值:', notFound);
// 预期输出: null