JavaScript中Reflect的常用方法及注意事项

// 基本用法
const obj = {
  name: '张三',
  age: 30,
  get fullName() {
    return this.name + ' (年龄: ' + this.age + ')';
  }
};

// 获取普通属性
const name = Reflect.get(obj, 'name');
console.log('姓名:', name); // 输出: 姓名: 张三

// 获取不存在的属性
const address = Reflect.get(obj, 'address');
console.log('地址:', address); // 输出: 地址: undefined

// 获取getter属性
const fullName = Reflect.get(obj, 'fullName');
console.log('全名:', fullName); // 输出: 全名: 张三 (年龄: 30)

// 使用receiver参数（修改this指向）
const receiver = {
  name: '李四',
  age: 25
};
const fullNameWithReceiver = Reflect.get(obj, 'fullName', receiver);
console.log('使用receiver的全名:', fullNameWithReceiver); // 输出: 使用receiver的全名: 李四 (年龄: 25)

// 数组示例
const arr = [10, 20, 30];
console.log('数组元素:', Reflect.get(arr, 1)); // 输出: 数组元素: 20

const obj = {
  name: '张三',
  age: 30,
  set setAge(value) {
    this.age = value;
  }
};

// 设置普通属性
const setNameResult = Reflect.set(obj, 'name', '李四');
console.log('设置姓名结果:', setNameResult); // 输出: 设置姓名结果: true
console.log('设置后的姓名:', obj.name); // 输出: 设置后的姓名: 李四

// 设置新属性
const setAddressResult = Reflect.set(obj, 'address', '北京');
console.log('设置地址结果:', setAddressResult); // 输出: 设置地址结果: true
console.log('设置后的地址:', obj.address); // 输出: 设置后的地址: 北京

// 调用setter
const setAgeResult = Reflect.set(obj, 'setAge', 35);
console.log('设置年龄结果:', setAgeResult); // 输出: 设置年龄结果: true
console.log('设置后的年龄:', obj.age); // 输出: 设置后的年龄: 35

// 使用receiver参数
const receiver = { age: 0 };
Reflect.set(obj, 'setAge', 20, receiver);
console.log('receiver的年龄:', receiver.age); // 输出: receiver的年龄: 20
console.log('原对象的年龄:', obj.age); // 输出: 原对象的年龄: 35（未改变）

// 冻结对象后设置属性
const frozenObj = Object.freeze({ name: '冻结对象' });
const setFrozenResult = Reflect.set(frozenObj, 'name', '修改冻结对象');
console.log('设置冻结对象结果:', setFrozenResult); // 输出: 设置冻结对象结果: false（操作失败）

const obj = {
  name: '张三',
  age: 30
};

// 自有属性
console.log('是否有name属性:', Reflect.has(obj, 'name')); // 输出: 是否有name属性: true
console.log('是否有age属性:', Reflect.has(obj, 'age'));   // 输出: 是否有age属性: true

// 不存在的属性
console.log('是否有address属性:', Reflect.has(obj, 'address')); // 输出: 是否有address属性: false

// 继承的属性
console.log('是否有toString方法:', Reflect.has(obj, 'toString')); // 输出: 是否有toString方法: true

// 数组示例
const arr = [1, 2, 3];
console.log('数组是否有索引0:', Reflect.has(arr, '0'));       // 输出: 数组是否有索引0: true
console.log('数组是否有length属性:', Reflect.has(arr, 'length')); // 输出: 数组是否有length属性: true

// 使用Object.create创建的对象
const proto = { inherited: '继承属性' };
const objWithProto = Object.create(proto);
objWithProto.own = '自有属性';

console.log('是否有自有属性:', Reflect.has(objWithProto, 'own'));         // 输出: 是否有自有属性: true
console.log('是否有继承属性:', Reflect.has(objWithProto, 'inherited')); // 输出: 是否有继承属性: true

const obj = {
  name: '张三',
  age: 30,
  address: '北京'
};

// 删除存在的属性
const deleteAge = Reflect.deleteProperty(obj, 'age');
console.log('删除age结果:', deleteAge); // 输出: 删除age结果: true
console.log('删除后obj:', obj); // 输出: 删除后obj: { name: '张三', address: '北京' }

// 删除不存在的属性
const deleteGender = Reflect.deleteProperty(obj, 'gender');
console.log('删除gender结果:', deleteGender); // 输出: 删除gender结果: true（删除不存在的属性返回true）

// 删除数组元素
const arr = [10, 20, 30];
const deleteElement = Reflect.deleteProperty(arr, '1');
console.log('删除数组元素结果:', deleteElement); // 输出: 删除数组元素结果: true
console.log('删除后数组:', arr); // 输出: 删除后数组: [ 10, <1 empty item>, 30 ]

// 删除不可配置的属性
const nonConfigurableObj = {};
Object.defineProperty(nonConfigurableObj, 'id', {
  value: 1,
  configurable: false // 不可配置
});

const deleteNonConfigurable = Reflect.deleteProperty(nonConfigurableObj, 'id');
console.log('删除不可配置属性结果:', deleteNonConfigurable); // 输出: 删除不可配置属性结果: false

const obj = {};

// 定义新属性
const defineName = Reflect.defineProperty(obj, 'name', {
  value: '张三',
  writable: true,
  configurable: true,
  enumerable: true
});
console.log('定义name属性结果:', defineName); // 输出: 定义name属性结果: true
console.log('定义后obj.name:', obj.name); // 输出: 定义后obj.name: 张三

// 定义getter属性
const defineGetter = Reflect.defineProperty(obj, 'upperName', {
  get() {
    return this.name.toUpperCase();
  }
});
console.log('定义upperName getter结果:', defineGetter); // 输出: 定义upperName getter结果: true
console.log('obj.upperName:', obj.upperName); // 输出: obj.upperName: 张三

// 重复定义属性（修改）
const redefineName = Reflect.defineProperty(obj, 'name', {
  value: '李四'
});
console.log('重新定义name属性结果:', redefineName); // 输出: 重新定义name属性结果: true
console.log('重新定义后obj.name:', obj.name); // 输出: 重新定义后obj.name: 李四

// 定义不可配置的属性
Reflect.defineProperty(obj, 'id', {
  value: 1001,
  configurable: false
});

// 尝试删除不可配置属性
const deleteId = Reflect.deleteProperty(obj, 'id');
console.log('删除不可配置属性结果:', deleteId); // 输出: 删除不可配置属性结果: false

// 尝试修改不可配置属性（失败）
const redefineId = Reflect.defineProperty(obj, 'id', {
  value: 1002
});
console.log('修改不可配置属性结果:', redefineId); // 输出: 修改不可配置属性结果: false
console.log('obj.id:', obj.id); // 输出: obj.id: 1001（未改变）

// 定义构造函数
function Person(name, age) {
  this.name = name;
  this.age = age;
  console.log('Person构造函数被调用');
}

Person.prototype.sayHello = function() {
  return `Hello, 我是${this.name}`;
};

// 使用Reflect.construct创建实例
const person = Reflect.construct(Person, ['张三', 30]);
console.log('创建的实例:', person); // 输出: 创建的实例: Person { name: '张三', age: 30 }
console.log('实例方法调用:', person.sayHello()); // 输出: 实例方法调用: Hello, 我是张三
console.log('是否是Person实例:', person instanceof Person); // 输出: 是否是Person实例: true

// 使用newTarget参数（创建另一个类型的实例）
function Student(name, age, grade) {
  this.grade = grade;
  console.log('Student构造函数被调用');
}

Student.prototype.study = function() {
  return `${this.name}在${this.grade}年级学习`;
};

// 使用Person构造函数，但创建Student实例
const student = Reflect.construct(Person, ['李四', 15], Student);
console.log('创建的student实例:', student); // 输出: 创建的student实例: Student { name: '李四', age: 15, grade: undefined }
console.log('是否是Student实例:', student instanceof Student); // 输出: 是否是Student实例: true
console.log('是否是Person实例:', student instanceof Person);   // 输出: 是否是Person实例: false

// 注意: Person构造函数被调用，但返回的是Student实例
// grade属性未定义，因为Student构造函数没有被调用

// 普通函数
function sum(a, b, c) {
  console.log(`this值:`, this);
  return a + b + c;
}

// 基本用法
const result1 = Reflect.apply(sum, null, [1, 2, 3]);
console.log('sum结果:', result1); // 输出: sum结果: 6

// 指定this值
const obj = { name: '计算对象' };
const result2 = Reflect.apply(sum, obj, [4, 5, 6]);
console.log('指定this的sum结果:', result2); // 输出: 指定this的sum结果: 15

// 调用对象方法
const person = {
  name: '张三',
  age: 30,
  greet(greeting, punctuation) {
    return `${greeting}, 我是${this.name}${punctuation}`;
  }
};

const greeting = Reflect.apply(person.greet, person, ['你好', '!']);
console.log('调用对象方法结果:', greeting); // 输出: 调用对象方法结果: 你好, 我是张三!

// 调用内置函数
const numbers = [3, 1, 4, 1, 5, 9];
const sorted = Reflect.apply(Math.sort, numbers, []);
console.log('排序结果:', sorted); // 输出: 排序结果: [ 1, 1, 3, 4, 5, 9 ]
console.log('原数组是否被修改:', numbers); // 输出: 原数组是否被修改: [ 1, 1, 3, 4, 5, 9 ]（sort会修改原数组）

// 调用匿名函数
const result3 = Reflect.apply(function(a, b) {
  return a * b;
}, null, [5, 6]);
console.log('调用匿名函数结果:', result3); // 输出: 调用匿名函数结果: 30

// 创建一个普通对象
const target = {
  name: '张三',
  age: 30,
  address: '北京'
};

// 创建Proxy
const proxy = new Proxy(target, {
  // 获取属性值
  get(target, prop, receiver) {
    console.log(`获取属性: ${prop}`);
    
    // 使用Reflect调用默认行为
    return Reflect.get(target, prop, receiver);
  },
  
  // 设置属性值
  set(target, prop, value, receiver) {
    console.log(`设置属性: ${prop} = ${value}`);
    
    // 使用Reflect调用默认行为并返回结果
    return Reflect.set(target, prop, value, receiver);
  },
  
  // 删除属性
  deleteProperty(target, prop) {
    console.log(`删除属性: ${prop}`);
    
    // 使用Reflect调用默认行为并返回结果
    return Reflect.deleteProperty(target, prop);
  },
  
  // 判断属性是否存在
  has(target, prop) {
    console.log(`判断属性是否存在: ${prop}`);
    
    // 使用Reflect调用默认行为并返回结果
    return Reflect.has(target, prop);
  }
});

// 使用Proxy
console.log('姓名:', proxy.name); // 获取属性
proxy.age = 31; // 设置属性
console.log('年龄:', proxy.age);
console.log('是否有address属性:', 'address' in proxy); // 判断属性是否存在
delete proxy.address; // 删除属性
console.log('删除后是否有address属性:', 'address' in proxy);

// 创建一个用户对象
const user = {
  name: '张三',
  age: 30,
  email: 'zhangsan@example.com'
};

// 创建带验证和日志的Proxy
const validatedUser = new Proxy(user, {
  get(target, prop, receiver) {
    console.log(`[LOG] 获取属性: ${prop}`);
    
    // 检查属性是否存在
    if (!Reflect.has(target, prop)) {
      console.warn(`[WARN] 属性 ${prop} 不存在`);
      return undefined;
    }
    
    return Reflect.get(target, prop, receiver);
  },
  
  set(target, prop, value, receiver) {
    console.log(`[LOG] 设置属性: ${prop} = ${value}`);
    
    // 数据验证
    switch (prop) {
      case 'age':
        if (typeof value !== 'number' || value < 0 || value > 120) {
          console.error(`[ERROR] 无效的年龄值: ${value}`);
          return false; // 设置失败
        }
        break;
      case 'email':
        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        if (!emailRegex.test(value)) {
          console.error(`[ERROR] 无效的邮箱格式: ${value}`);
          return false; // 设置失败
        }
        break;
      // 可以添加更多属性的验证规则
    }
    
    // 验证通过，设置属性
    return Reflect.set(target, prop, value, receiver);
  },
  
  deleteProperty(target, prop) {
    console.log(`[LOG] 尝试删除属性: ${prop}`);
    
    // 保护核心属性不被删除
    const protectedProps = ['name'];
    if (protectedProps.includes(prop)) {
      console.error(`[ERROR] 不能删除核心属性: ${prop}`);
      return false; // 删除失败
    }
    
    return Reflect.deleteProperty(target, prop);
  }
});

// 使用代理对象
console.log('姓名:', validatedUser.name);
console.log('不存在的属性:', validatedUser.address);

// 设置有效属性
validatedUser.age = 31;
validatedUser.email = 'new-email@example.com';
console.log('更新后的年龄:', validatedUser.age);
console.log('更新后的邮箱:', validatedUser.email);

// 设置无效属性
validatedUser.age = 150; // 无效的年龄
validatedUser.email = 'invalid-email'; // 无效的邮箱格式

// 尝试删除属性
delete validatedUser.email; // 可以删除
console.log('删除后邮箱是否存在:', 'email' in validatedUser);
delete validatedUser.name; // 不能删除核心属性

// 观察者类
class Observer {
  constructor() {
    this.observers = [];
  }
  
  // 添加观察者
  subscribe(callback) {
    this.observers.push(callback);
  }
  
  // 通知所有观察者
  notify(data) {
    this.observers.forEach(callback => callback(data));
  }
}

// 创建观察者实例
const observer = new Observer();

// 添加观察者
observer.subscribe((data) => {
  console.log('观察者1收到变化:', data);
});

observer.subscribe((data) => {
  console.log('观察者2收到变化:', data);
});

// 创建被观察对象
const target = {
  name: '张三',
  age: 30
};

// 创建Proxy，当属性变化时通知观察者
const observableTarget = new Proxy(target, {
  set(target, prop, value, receiver) {
    const oldValue = Reflect.get(target, prop, receiver);
    
    // 如果值没有变化，不通知
    if (oldValue === value) {
      return true;
    }
    
    // 设置新值
    const result = Reflect.set(target, prop, value, receiver);
    
    // 通知观察者
    if (result) {
      observer.notify({
        prop,
        oldValue,
        newValue: value,
        timestamp: new Date()
      });
    }
    
    return result;
  }
});

// 修改属性，触发通知
console.log('修改name属性:');
observableTarget.name = '李四';

console.log('\n修改age属性:');
observableTarget.age = 31;

console.log('\n设置相同的值:');
observableTarget.age = 31; // 不会触发通知

const obj = {
  name: '张三',
  age: 30
};

// 定义getter属性
Object.defineProperty(obj, 'fullInfo', {
  get() {
    return `${this.name}, ${this.age}岁`;
  },
  enumerable: false
});

// 获取普通属性描述符
const nameDesc = Reflect.getOwnPropertyDescriptor(obj, 'name');
console.log('name属性描述符:', nameDesc);

// 获取getter属性描述符
const infoDesc = Reflect.getOwnPropertyDescriptor(obj, 'fullInfo');
console.log('fullInfo属性描述符:', infoDesc);

// 获取不存在的属性描述符
const addressDesc = Reflect.getOwnPropertyDescriptor(obj, 'address');
console.log('address属性描述符:', addressDesc);

// 数组示例
const arr = [1, 2, 3];
const arrDesc = Reflect.getOwnPropertyDescriptor(arr, 'length');
console.log('数组length属性描述符:', arrDesc);

// 定义原型对象
const animalProto = {
  eat() {
    return `${this.name}在吃东西`;
  }
};

// 定义对象
const cat = {
  name: '小猫'
};

// 获取原型
let proto = Reflect.getPrototypeOf(cat);
console.log('默认原型:', proto === Object.prototype); // 输出: 默认原型: true

// 设置原型
const setResult = Reflect.setPrototypeOf(cat, animalProto);
console.log('设置原型结果:', setResult); // 输出: 设置原型结果: true

// 获取新原型
proto = Reflect.getPrototypeOf(cat);
console.log('新原型:', proto === animalProto); // 输出: 新原型: true

// 使用原型方法
console.log('调用原型方法:', cat.eat()); // 输出: 调用原型方法: 小猫在吃东西

// 尝试设置不可扩展对象的原型
const obj = Object.preventExtensions({});
const setProtoResult = Reflect.setPrototypeOf(obj, animalProto);
console.log('设置不可扩展对象原型结果:', setProtoResult); // 输出: 设置不可扩展对象原型结果: false

// 创建普通对象
const obj = { name: '测试对象' };

// 判断是否可扩展
console.log('初始是否可扩展:', Reflect.isExtensible(obj)); // 输出: 初始是否可扩展: true

// 添加属性
obj.age = 30;
console.log('添加属性后:', obj); // 输出: 添加属性后: { name: '测试对象', age: 30 }

// 阻止扩展
const preventResult = Reflect.preventExtensions(obj);
console.log('阻止扩展结果:', preventResult); // 输出: 阻止扩展结果: true

// 再次判断是否可扩展
console.log('阻止后是否可扩展:', Reflect.isExtensible(obj)); // 输出: 阻止后是否可扩展: false

// 尝试添加新属性（失败）
obj.address = '北京';
console.log('尝试添加新属性后:', obj); // 输出: 尝试添加新属性后: { name: '测试对象', age: 30 }（address属性未添加）

// 密封对象和冻结对象也是不可扩展的
const sealedObj = Object.seal({});
console.log('密封对象是否可扩展:', Reflect.isExtensible(sealedObj)); // 输出: 密封对象是否可扩展: false

const frozenObj = Object.freeze({});
console.log('冻结对象是否可扩展:', Reflect.isExtensible(frozenObj)); // 输出: 冻结对象是否可扩展: false

// 定义symbol属性
const symbolProp = Symbol('symbol属性');

// 创建对象
const obj = {
  name: '张三',
  age: 30
};
obj[symbolProp] = 'symbol值'; // 添加symbol属性
Object.defineProperty(obj, 'id', { // 添加不可枚举属性
  value: 1001,
  enumerable: false
});

// 获取所有自有键
const keys = Reflect.ownKeys(obj);
console.log('所有自有键:', keys); // 输出: 所有自有键: [ 'name', 'age', 'id', Symbol(symbol属性) ]

// 对比Object.keys（只返回可枚举的自有字符串键）
const objectKeys = Object.keys(obj);
console.log('Object.keys结果:', objectKeys); // 输出: Object.keys结果: [ 'name', 'age' ]

// 数组示例
const arr = [10, 20, 30];
console.log('数组的自有键:', Reflect.ownKeys(arr)); // 输出: 数组的自有键: [ '0', '1', '2', 'length' ]

// 不可枚举属性也会被返回
console.log('是否包含不可枚举属性id:', keys.includes('id')); // 输出: 是否包含不可枚举属性id: true
// Symbol属性也会被返回
console.log('是否包含symbol属性:', keys.includes(symbolProp)); // 输出: 是否包含symbol属性: true

// 安全地获取深层属性
function getDeepProperty(obj, path) {
  return path.split('.').reduce((current, prop) => {
    if (current === null || current === undefined) return undefined;
    return Reflect.get(current, prop);
  }, obj);
}

// 安全地设置深层属性
function setDeepProperty(obj, path, value) {
  const parts = path.split('.');
  const lastProp = parts.pop();
  
  const target = parts.reduce((current, prop) => {
    // 如果中间属性不存在，创建一个空对象
    if (current === null || current === undefined) {
      current = {};
    }
    
    // 如果当前属性不是对象，无法设置深层属性
    if (typeof current !== 'object') {
      return undefined;
    }
    
    return Reflect.get(current, prop);
  }, obj);
  
  if (target === undefined) return false;
  
  return Reflect.set(target, lastProp, value);
}

// 测试对象
const data = {
  user: {
    name: '张三',
    address: {
      city: '北京',
      street: '科技路'
    }
  },
  scores: [90, 85, 95]
};

// 安全获取属性
console.log('获取存在的深层属性:', getDeepProperty(data, 'user.address.city')); // 输出: 获取存在的深层属性: 北京
console.log('获取不存在的属性:', getDeepProperty(data, 'user.address.zipcode')); // 输出: 获取不存在的属性: undefined
console.log('获取数组元素:', getDeepProperty(data, 'scores.1')); // 输出: 获取数组元素: 85

// 安全设置属性
console.log('设置存在的深层属性:', setDeepProperty(data, 'user.address.street', '创新路')); // 输出: 设置存在的深层属性: true
console.log('设置后的值:', data.user.address.street); // 输出: 设置后的值: 创新路

console.log('设置不存在的深层属性:', setDeepProperty(data, 'user.contact.phone', '123456789')); // 输出: 设置不存在的深层属性: true
console.log('设置后的新属性:', data.user.contact.phone); // 输出: 设置后的新属性: 123456789

console.log('设置到非对象上:', setDeepProperty(data, 'scores.0.name', '语文')); // 输出: 设置到非对象上: false

// 通用对象复制函数
function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }
  
  // 处理日期
  if (obj instanceof Date) {
    return new Date(obj);
  }
  
  // 处理数组
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item));
  }
  
  // 创建新对象，复制原型
  const newObj = Object.create(Reflect.getPrototypeOf(obj));
  
  // 复制所有自有属性（包括不可枚举和Symbol属性）
  const keys = Reflect.ownKeys(obj);
  
  for (const key of keys) {
    const desc = Reflect.getOwnPropertyDescriptor(obj, key);
    
    // 如果是访问器属性
    if (desc.get || desc.set) {
      Reflect.defineProperty(newObj, key, {
        get: desc.get,
        set: desc.set,
        enumerable: desc.enumerable,
        configurable: desc.configurable
      });
    } else {
      // 递归复制值
      newObj[key] = deepClone(desc.value);
    }
  }
  
  return newObj;
}

// 测试对象
const original = {
  name: '测试对象',
  age: 30,
  [Symbol('secret')]: '秘密属性',
  get fullInfo() {
    return `${this.name}, ${this.age}岁`;
  },
  hobbies: ['阅读', '运动']
};

// 添加不可枚举属性
Object.defineProperty(original, 'id', {
  value: 1001,
  enumerable: false
});

// 克隆对象
const cloned = deepClone(original);

// 验证克隆结果
console.log('原始对象:', original);
console.log('克隆对象:', cloned);
console.log('克隆对象fullInfo:', cloned.fullInfo);
console.log('克隆对象secret属性:', cloned[Symbol('secret')]);
console.log('克隆对象id属性:', cloned.id);
console.log('原型是否相同:', Reflect.getPrototypeOf(original) === Reflect.getPrototypeOf(cloned));
console.log('是否是深克隆:', original.hobbies !== cloned.hobbies); // 数组应该是新数组

// 定义一个基础类
class BaseModel {
  constructor(data) {
    // 使用Reflect设置属性
    if (data) {
      for (const [key, value] of Object.entries(data)) {
        Reflect.set(this, key, value);
      }
    }
  }
  
  // 通用的保存方法
  save() {
    const className = this.constructor.name;
    const id = Reflect.get(this, 'id') || Date.now();
    Reflect.set(this, 'id', id);
    
    // 模拟保存到数据库
    console.log(`[${className}] 保存数据:`, this);
    return { success: true, id };
  }
  
  // 静态方法：通过ID加载
  static load(id) {
    const className = this.name;
    console.log(`[${className}] 加载ID为${id}的数据`);
    
    // 模拟从数据库加载
    return new this({ id, loadedAt: new Date() });
  }
}

// 用户模型
class User extends BaseModel {
  constructor(data) {
    super(data);
    // 设置默认角色
    if (!Reflect.has(this, 'role')) {
      Reflect.set(this, 'role', 'user');
    }
  }
  
  // 用户登录方法
  login(password) {
    console.log(`用户${this.username}尝试登录`);
    // 简单的密码验证
    return Reflect.get(this, 'password') === password;
  }
}

// 产品模型
class Product extends BaseModel {
  constructor(data) {
    super(data);
    // 设置默认价格
    if (!Reflect.has(this, 'price')) {
      Reflect.set(this, 'price', 0);
    }
  }
  
  // 获取折扣价格
  getDiscountPrice(discount) {
    const price = Reflect.get(this, 'price');
    return price * (1 - discount);
  }
}

// 使用User模型
const user = new User({
  username: 'zhangsan',
  password: '123456',
  email: 'zhangsan@example.com'
});
console.log('用户角色:', user.role); // 使用默认角色
console.log('登录结果:', user.login('123456')); // 登录成功
const saveResult = user.save();
console.log('保存结果:', saveResult);

// 使用Product模型
const product = new Product({
  name: 'Vue教程',
  price: 89
});
console.log('折扣价格:', product.getDiscountPrice(0.1)); // 9折
product.save();

// 加载数据
const loadedUser = User.load(saveResult.id);
console.log('加载的用户:', loadedUser);

// 错误用法
new Reflect(); // TypeError: Reflect is not a constructor
Reflect();     // TypeError: Reflect is not a function

// 正确用法
Reflect.get(obj, 'prop');

// 错误用法
const r = Reflect;
r.get(obj, 'prop'); // 虽然可以工作，但不推荐这样使用

// 错误示例
Reflect.get(null, 'prop'); // TypeError: Reflect.get called on non-object
Reflect.set(undefined, 'prop', 1); // TypeError: Reflect.set called on non-object

const proxy = new Proxy(obj, {
  get(target, prop, receiver) {
    // 参数与Reflect.get完全一致
    return Reflect.get(target, prop, receiver);
  }
});