// 基本用法
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參數(shù)（修改this指向）
const receiver = {
  name: '李四',
  age: 25
};
const fullNameWithReceiver = Reflect.get(obj, 'fullName', receiver);
console.log('使用receiver的全名:', fullNameWithReceiver); // 輸出: 使用receiver的全名: 李四 (年齡: 25)

// 數(shù)組示例
const arr = [10, 20, 30];
console.log('數(shù)組元素:', Reflect.get(arr, 1)); // 輸出: 數(shù)組元素: 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參數(shù)
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

// 數(shù)組示例
const arr = [1, 2, 3];
console.log('數(shù)組是否有索引0:', Reflect.has(arr, '0'));       // 輸出: 數(shù)組是否有索引0: true
console.log('數(shù)組是否有l(wèi)ength屬性:', Reflect.has(arr, 'length')); // 輸出: 數(shù)組是否有l(wèi)ength屬性: true

// 使用Object.create創(chuàng)建的對象
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）

// 刪除數(shù)組元素
const arr = [10, 20, 30];
const deleteElement = Reflect.deleteProperty(arr, '1');
console.log('刪除數(shù)組元素結果:', deleteElement); // 輸出: 刪除數(shù)組元素結果: true
console.log('刪除后數(shù)組:', arr); // 輸出: 刪除后數(shù)組: [ 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（未改變）

// 定義構造函數(shù)
function Person(name, age) {
  this.name = name;
  this.age = age;
  console.log('Person構造函數(shù)被調用');
}

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

// 使用Reflect.construct創(chuàng)建實例
const person = Reflect.construct(Person, ['張三', 30]);
console.log('創(chuàng)建的實例:', person); // 輸出: 創(chuàng)建的實例: Person { name: '張三', age: 30 }
console.log('實例方法調用:', person.sayHello()); // 輸出: 實例方法調用: Hello, 我是張三
console.log('是否是Person實例:', person instanceof Person); // 輸出: 是否是Person實例: true

// 使用newTarget參數(shù)（創(chuàng)建另一個類型的實例）
function Student(name, age, grade) {
  this.grade = grade;
  console.log('Student構造函數(shù)被調用');
}

Student.prototype.study = function() {
  return `${this.name}在${this.grade}年級學習`;
};

// 使用Person構造函數(shù)，但創(chuàng)建Student實例
const student = Reflect.construct(Person, ['李四', 15], Student);
console.log('創(chuàng)建的student實例:', student); // 輸出: 創(chuàng)建的student實例: Student { name: '李四', age: 15, grade: undefined }
console.log('是否是Student實例:', student instanceof Student); // 輸出: 是否是Student實例: true
console.log('是否是Person實例:', student instanceof Person);   // 輸出: 是否是Person實例: false

// 注意: Person構造函數(shù)被調用，但返回的是Student實例
// grade屬性未定義，因為Student構造函數(shù)沒有被調用

// 普通函數(shù)
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); // 輸出: 調用對象方法結果: 你好, 我是張三!

// 調用內置函數(shù)
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('原數(shù)組是否被修改:', numbers); // 輸出: 原數(shù)組是否被修改: [ 1, 1, 3, 4, 5, 9 ]（sort會修改原數(shù)組）

// 調用匿名函數(shù)
const result3 = Reflect.apply(function(a, b) {
  return a * b;
}, null, [5, 6]);
console.log('調用匿名函數(shù)結果:', result3); // 輸出: 調用匿名函數(shù)結果: 30

// 創(chuàng)建一個普通對象
const target = {
  name: '張三',
  age: 30,
  address: '北京'
};

// 創(chuàng)建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);

// 創(chuàng)建一個用戶對象
const user = {
  name: '張三',
  age: 30,
  email: 'zhangsan@example.com'
};

// 創(chuàng)建帶驗證和日志的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}`);
    
    // 數(shù)據(jù)驗證
    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;
      // 可以添加更多屬性的驗證規(guī)則
    }
    
    // 驗證通過，設置屬性
    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));
  }
}

// 創(chuàng)建觀察者實例
const observer = new Observer();

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

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

// 創(chuàng)建被觀察對象
const target = {
  name: '張三',
  age: 30
};

// 創(chuàng)建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;
  }
});

// 修改屬性，觸發(fā)通知
console.log('修改name屬性:');
observableTarget.name = '李四';

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

console.log('\n設置相同的值:');
observableTarget.age = 31; // 不會觸發(fā)通知

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);

// 數(shù)組示例
const arr = [1, 2, 3];
const arrDesc = Reflect.getOwnPropertyDescriptor(arr, 'length');
console.log('數(shù)組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

// 創(chuàng)建普通對象
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屬性');

// 創(chuàng)建對象
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' ]

// 數(shù)組示例
const arr = [10, 20, 30];
console.log('數(shù)組的自有鍵:', Reflect.ownKeys(arr)); // 輸出: 數(shù)組的自有鍵: [ '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) => {
    // 如果中間屬性不存在，創(chuàng)建一個空對象
    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('獲取數(shù)組元素:', getDeepProperty(data, 'scores.1')); // 輸出: 獲取數(shù)組元素: 85

// 安全設置屬性
console.log('設置存在的深層屬性:', setDeepProperty(data, 'user.address.street', '創(chuàng)新路')); // 輸出: 設置存在的深層屬性: true
console.log('設置后的值:', data.user.address.street); // 輸出: 設置后的值: 創(chuàng)新路

console.log('設置不存在的深層屬性:', setDeepProperty(data, 'user.contact.phone', '123456789')); // 輸出: 設置不存在的深層屬性: true
console.log('設置后的新屬性:', data.user.contact.phone); // 輸出: 設置后的新屬性: 123456789

console.log('設置到非對象上:', setDeepProperty(data, 'scores.0.name', '語文')); // 輸出: 設置到非對象上: false

// 通用對象復制函數(shù)
function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }
  
  // 處理日期
  if (obj instanceof Date) {
    return new Date(obj);
  }
  
  // 處理數(shù)組
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item));
  }
  
  // 創(chuàng)建新對象，復制原型
  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); // 數(shù)組應該是新數(shù)組

// 定義一個基礎類
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);
    
    // 模擬保存到數(shù)據(jù)庫
    console.log(`[${className}] 保存數(shù)據(jù):`, this);
    return { success: true, id };
  }
  
  // 靜態(tài)方法：通過ID加載
  static load(id) {
    const className = this.name;
    console.log(`[${className}] 加載ID為${id}的數(shù)據(jù)`);
    
    // 模擬從數(shù)據(jù)庫加載
    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;
  }
}

// 產(chǎn)品模型
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();

// 加載數(shù)據(jù)
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) {
    // 參數(shù)與Reflect.get完全一致
    return Reflect.get(target, prop, receiver);
  }
});