/**
 * 防抖函数
 * @param {Function} fn - 需要防抖的函数
 * @param {number} delay - 延迟时间（毫秒）
 * @param {boolean} immediate - 是否立即执行（可选，默认false）
 * @returns {Function} 返回防抖处理后的函数
 */
function debounce(fn, delay, immediate = false) {
  let timer = null;
  
  return function (...args) {
    const context = this;
    
    if (immediate && !timer) {
      // 立即执行：第一次触发时立即执行，然后等待delay时间内不再触发才重置
      fn.apply(context, args);
    }
    
    // 清除上一次的定时器
    if (timer) clearTimeout(timer);
    
    // 设置新的定时器
    timer = setTimeout(() => {
      if (!immediate) {
        fn.apply(context, args);
      }
      timer = null;
    }, delay);
  };
}

// --- 使用示例 ---
// const handleInput = debounce((e) => {
//   console.log('输入内容:', e.target.value);
// }, 300);
// inputEl.addEventListener('input', handleInput);

/**
 * 节流函数 - 时间戳版（立即执行）
 * @param {Function} fn - 需要节流的函数
 * @param {number} delay - 间隔时间（毫秒）
 * @returns {Function} 返回节流处理后的函数
 */
function throttle(fn, delay) {
  let lastTime = 0;
  
  return function (...args) {
    const context = this;
    const now = Date.now();
    
    if (now - lastTime >= delay) {
      fn.apply(context, args);
      lastTime = now;
    }
  };
}

/**
 * 节流函数 - 定时器版（延迟执行）
 * @param {Function} fn - 需要节流的函数
 * @param {number} delay - 间隔时间（毫秒）
 * @returns {Function} 返回节流处理后的函数
 */
function throttleTimer(fn, delay) {
  let timer = null;
  
  return function (...args) {
    const context = this;
    
    if (!timer) {
      timer = setTimeout(() => {
        fn.apply(context, args);
        timer = null;
      }, delay);
    }
  };
}

/**
 * 节流函数 - 完整版（结合时间戳和定时器，保证最后一次执行）
 * @param {Function} fn - 需要节流的函数
 * @param {number} delay - 间隔时间（毫秒）
 * @returns {Function} 返回节流处理后的函数
 */
function throttleComplete(fn, delay) {
  let lastTime = 0;
  let timer = null;
  
  return function (...args) {
    const context = this;
    const now = Date.now();
    const remaining = delay - (now - lastTime);
    
    // 如果剩余时间 <= 0，说明可以立即执行
    if (remaining <= 0) {
      if (timer) {
        clearTimeout(timer);
        timer = null;
      }
      fn.apply(context, args);
      lastTime = now;
    } else if (!timer) {
      // 否则设置一个定时器在剩余时间后执行（保证最后一次触发能执行）
      timer = setTimeout(() => {
        fn.apply(context, args);
        lastTime = Date.now();
        timer = null;
      }, remaining);
    }
  };
}

/**
 * 自定义 instanceof
 * @param {object} instance - 实例对象
 * @param {Function} constructor - 构造函数
 * @returns {boolean}
 */
function myInstanceof(instance, constructor) {
  // 基本类型直接返回 false
  if (typeof instance !== 'object' || instance === null) {
    return false;
  }
  
  // 获取实例的原型（__proto__）
  let proto = Object.getPrototypeOf(instance);
  
  // 获取构造函数的 prototype 对象
  const prototype = constructor.prototype;
  
  // 沿着原型链向上查找
  while (proto !== null) {
    if (proto === prototype) {
      return true;
    }
    proto = Object.getPrototypeOf(proto);
  }
  
  return false;
}

// --- 测试 ---
// console.log(myInstanceof([], Array));      // true
// console.log(myInstanceof({}, Object));     // true
// console.log(myInstanceof(1, Number));      // false（基本类型）

/**
 * 模拟实现 new 操作符
 * @param {Function} constructor - 构造函数
 * @param {...any} args - 参数
 * @returns {object} 实例对象
 */
function myNew(constructor, ...args) {
  // 1. 创建一个空对象，并将它的原型指向构造函数的 prototype
  const obj = Object.create(constructor.prototype);
  
  // 2. 将构造函数中的 this 指向这个新对象，并执行构造函数
  const result = constructor.apply(obj, args);
  
  // 3. 如果构造函数返回了对象（引用类型），则返回该对象；否则返回新创建的对象
  return (typeof result === 'object' && result !== null) || typeof result === 'function'
    ? result
    : obj;
}

// --- 测试 ---
// function Person(name, age) {
//   this.name = name;
//   this.age = age;
// }
// const p = myNew(Person, '张三', 18);
// console.log(p.name); // 张三

/**
 * 模拟实现 Function.prototype.call
 * @param {object|null} context - 需要绑定的 this 上下文
 * @param {...any} args - 参数列表
 * @returns {any} 函数执行结果
 */
Function.prototype.myCall = function (context, ...args) {
  // 如果 context 为 null/undefined，则指向全局对象（浏览器中是 window，Node 中是 global）
  context = context ?? globalThis;
  
  // 使用 Symbol 创建唯一键，避免属性名冲突
  const fnKey = Symbol('fn');
  
  // 将当前函数（this）作为 context 的一个属性
  context[fnKey] = this;
  
  // 执行函数并获取结果
  const result = context[fnKey](...args);
  
  // 删除添加的属性
  delete context[fnKey];
  
  return result;
};

// --- 测试 ---
// const obj = { value: 1 };
// function test(a, b) { return this.value + a + b; }
// console.log(test.myCall(obj, 2, 3)); // 6

/**
 * 模拟实现 Function.prototype.apply
 * @param {object|null} context - 需要绑定的 this 上下文
 * @param {Array} args - 参数数组
 * @returns {any} 函数执行结果
 */
Function.prototype.myApply = function (context, args) {
  context = context ?? globalThis;
  
  const fnKey = Symbol('fn');
  context[fnKey] = this;
  
  // args 可能为 null/undefined
  const result = args ? context[fnKey](...args) : context[fnKey]();
  
  delete context[fnKey];
  
  return result;
};

/**
 * 模拟实现 Function.prototype.bind
 * @param {object|null} context - 需要绑定的 this 上下文
 * @param {...any} args - 预设的参数
 * @returns {Function} 返回绑定后的新函数
 */
Function.prototype.myBind = function (context, ...args) {
  const originalFn = this;
  
  // 返回的新函数
  function boundFn(...newArgs) {
    // 如果使用 new 调用（boundFn 作为构造函数），this 指向新创建的实例
    // 此时 this instanceof boundFn 为 true
    return originalFn.apply(
      this instanceof boundFn ? this : (context ?? globalThis),
      [...args, ...newArgs]
    );
  }
  
  // 维护原型链，使 new 调用时能正确继承
  if (originalFn.prototype) {
    boundFn.prototype = Object.create(originalFn.prototype);
  }
  
  return boundFn;
};

/**
 * 深拷贝函数 - 基础版（支持对象、数组、基本类型）
 * @param {any} obj - 需要拷贝的对象
 * @returns {any} 拷贝后的对象
 */
function deepClone(obj) {
  // 基本类型或 null，直接返回
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }
  
  // 处理 Date
  if (obj instanceof Date) {
    return new Date(obj.getTime());
  }
  
  // 处理 RegExp
  if (obj instanceof RegExp) {
    return new RegExp(obj.source, obj.flags);
  }
  
  // 处理数组或对象
  const clone = Array.isArray(obj) ? [] : {};
  
  // 使用 Reflect.ownKeys 可以获取包括 Symbol 在内的所有键
  for (const key of Reflect.ownKeys(obj)) {
    clone[key] = deepClone(obj[key]);
  }
  
  return clone;
}

/**
 * 深拷贝函数 - 完整版（支持循环引用、Map、Set 等）
 * @param {any} obj - 需要拷贝的对象
 * @param {WeakMap} cache - 缓存已拷贝对象，解决循环引用
 * @returns {any} 拷贝后的对象
 */
function deepCloneComplete(obj, cache = new WeakMap()) {
  // 基本类型或 null
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }
  
  // 解决循环引用
  if (cache.has(obj)) {
    return cache.get(obj);
  }
  
  // 处理 Date
  if (obj instanceof Date) {
    return new Date(obj.getTime());
  }
  
  // 处理 RegExp
  if (obj instanceof RegExp) {
    return new RegExp(obj.source, obj.flags);
  }
  
  // 处理 Map
  if (obj instanceof Map) {
    const cloneMap = new Map();
    cache.set(obj, cloneMap);
    obj.forEach((value, key) => {
      cloneMap.set(deepCloneComplete(key, cache), deepCloneComplete(value, cache));
    });
    return cloneMap;
  }
  
  // 处理 Set
  if (obj instanceof Set) {
    const cloneSet = new Set();
    cache.set(obj, cloneSet);
    obj.forEach(value => {
      cloneSet.add(deepCloneComplete(value, cache));
    });
    return cloneSet;
  }
  
  // 处理数组或普通对象
  const clone = Array.isArray(obj) ? [] : {};
  cache.set(obj, clone);
  
  for (const key of Reflect.ownKeys(obj)) {
    clone[key] = deepCloneComplete(obj[key], cache);
  }
  
  return clone;
}

/**
 * 类的继承 - 使用 ES6 class 语法
 */
class Animal {
  constructor(name) {
    this.name = name;
  }
  
  speak() {
    return `${this.name} 发出声音`;
  }
  
  static isAnimal(obj) {
    return obj instanceof Animal;
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name); // 调用父类构造函数
    this.breed = breed;
  }
  
  speak() {
    return `${this.name}（${this.breed}）汪汪叫`;
  }
  
  fetch() {
    return `${this.name} 在捡球`;
  }
}

/**
 * 类的继承 - 简版（ES5 寄生组合式继承）
 */
function Parent(name) {
  this.name = name;
}

Parent.prototype.getName = function () {
  return this.name;
};

function Child(name, age) {
  Parent.call(this, name); // 继承属性
  this.age = age;
}

// 继承方法：Child.prototype.__proto__ = Parent.prototype
Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child;

Child.prototype.getAge = function () {
  return this.age;
};

/**
 * ES5 实现继承 - 寄生组合式继承（最优方案）
 */

// 工具函数：用于子类继承父类原型
function inherit(child, parent) {
  // 1. 创建以 parent.prototype 为原型的对象
  // 2. 将该对象赋值给 child.prototype
  child.prototype = Object.create(parent.prototype);
  // 3. 修正 constructor 指向
  child.prototype.constructor = child;
  // 4. 存储父类引用（便于访问父类方法）
  child._super = parent;
}

// 父类
function Person(name, age) {
  this.name = name;
  this.age = age;
  this.hobbies = ['读书', '运动'];
}

Person.prototype.sayHello = function () {
  return `你好，我叫${this.name}，今年${this.age}岁`;
};

Person.staticMethod = function () {
  return 'Person 静态方法';
};

// 子类
function Student(name, age, grade) {
  // 调用父类构造函数，继承实例属性
  Person.call(this, name, age);
  this.grade = grade;
  this.study = function () {
    return `${this.name} 在学习`;
  };
}

// 继承父类原型方法
inherit(Student, Person);

// 子类自己的原型方法
Student.prototype.getGrade = function () {
  return `${this.name} 在${this.grade}年级`;
};

// 继承静态属性
Student.staticMethod = Person.staticMethod;

/**
 * 实现 Promise.resolve
 * 返回一个以给定值解析后的 Promise 对象
 * - 如果值是 Promise，则返回该 Promise
 * - 如果值是 thenable 对象，则将其转换为 Promise 并执行 then
 * - 否则返回一个以该值 resolved 的 Promise
 */
Promise.myResolve = function (value) {
  // 如果已经是 Promise 实例，直接返回
  if (value instanceof Promise) {
    return value;
  }
  
  // 如果值是 thenable 对象，用 Promise 包装并执行 then
  if (value !== null && typeof value === 'object' && typeof value.then === 'function') {
    return new Promise((resolve, reject) => {
      value.then(resolve, reject);
    });
  }
  
  // 普通值，返回 resolved 的 Promise
  return new Promise(resolve => resolve(value));
};

/**
 * 实现 Promise.reject
 * 返回一个以给定原因 rejected 的 Promise 对象
 */
Promise.myReject = function (reason) {
  return new Promise((_, reject) => reject(reason));
};

/**
 * 实现 Promise.prototype.finally
 * - 无论 Promise 是 fulfilled 还是 rejected，都会执行回调
 * - 回调不接收任何参数
 * - 返回一个新的 Promise，保持状态与原始 Promise 一致
 * - 如果回调中抛出错误或返回 rejected Promise，则 finally 返回的 Promise 会以此错误 reject
 */
Promise.prototype.myFinally = function (callback) {
  return this.then(
    value => Promise.resolve(callback()).then(() => value),
    reason => Promise.resolve(callback()).then(() => { throw reason; })
  );
};

/**
 * 实现 Promise.all
 * - 接收一个 Promise 可迭代对象
 * - 所有 Promise 都成功时，返回一个包含所有结果的数组（顺序与输入一致）
 * - 任一 Promise 失败，立即 reject 该错误
 * - 空的可迭代对象返回一个 resolved 的空数组
 */
Promise.myAll = function (promises) {
  return new Promise((resolve, reject) => {
    // 将可迭代对象转为数组
    const iterable = Array.from(promises);
    if (iterable.length === 0) {
      resolve([]);
      return;
    }
    
    const results = [];
    let count = 0;
    
    iterable.forEach((item, index) => {
      // 用 Promise.resolve 包装，确保非 Promise 值也能处理
      Promise.resolve(item).then(
        value => {
          results[index] = value; // 保持顺序
          count++;
          if (count === iterable.length) {
            resolve(results);
          }
        },
        reason => {
          reject(reason); // 任一失败立即 reject
        }
      );
    });
  });
};

/**
 * 实现 Promise.allSettled
 * - 等待所有 Promise 完成（无论成功或失败）
 * - 返回每个 Promise 的结果对象：{status: 'fulfilled', value} 或 {status: 'rejected', reason}
 * - 不会因为某个 Promise 失败而 reject
 */
Promise.myAllSettled = function (promises) {
  return new Promise(resolve => {
    const iterable = Array.from(promises);
    if (iterable.length === 0) {
      resolve([]);
      return;
    }
    
    const results = [];
    let count = 0;
    
    iterable.forEach((item, index) => {
      Promise.resolve(item).then(
        value => {
          results[index] = { status: 'fulfilled', value };
        },
        reason => {
          results[index] = { status: 'rejected', reason };
        }
      ).finally(() => {
        count++;
        if (count === iterable.length) {
          resolve(results);
        }
      });
    });
  });
};

/**
 * 实现 Promise.race
 * - 返回第一个 settled 的 Promise 的结果（无论成功或失败）
 * - 空数组时 Promise 永远处于 pending 状态
 */
Promise.myRace = function (promises) {
  return new Promise((resolve, reject) => {
    const iterable = Array.from(promises);
    
    iterable.forEach(item => {
      Promise.resolve(item).then(resolve, reject);
    });
  });
};

/**
 * 简版 Promise - 包含核心功能
 * 状态：pending -> fulfilled / rejected
 */
class SimplePromise {
  constructor(executor) {
    this.status = 'pending'; // 初始状态
    this.value = undefined;  // 成功值
    this.reason = undefined; // 失败原因
    this.onFulfilledCallbacks = []; // 异步时存储成功回调
    this.onRejectedCallbacks = [];  // 异步时存储失败回调
    
    const resolve = value => {
      if (this.status === 'pending') {
        this.status = 'fulfilled';
        this.value = value;
        // 执行所有缓存的成功回调
        this.onFulfilledCallbacks.forEach(fn => fn());
      }
    };
    
    const reject = reason => {
      if (this.status === 'pending') {
        this.status = 'rejected';
        this.reason = reason;
        this.onRejectedCallbacks.forEach(fn => fn());
      }
    };
    
    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err);
    }
  }
  
  then(onFulfilled, onRejected) {
    if (this.status === 'fulfilled') {
      onFulfilled(this.value);
    }
    if (this.status === 'rejected') {
      onRejected(this.reason);
    }
    if (this.status === 'pending') {
      this.onFulfilledCallbacks.push(() => onFulfilled(this.value));
      this.onRejectedCallbacks.push(() => onRejected(this.reason));
    }
  }
}

/**
 * Promise 详细实现 - 支持链式调用
 * - 通过 then 方法返回新的 Promise 实现链式调用
 * - 处理回调返回值和 Promise 的情况
 */
class DetailedPromise {
  constructor(executor) {
    this.status = 'pending';
    this.value = undefined;
    this.reason = undefined;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    
    const resolve = value => {
      if (this.status === 'pending') {
        this.status = 'fulfilled';
        this.value = value;
        this.onFulfilledCallbacks.forEach(fn => fn());
      }
    };
    
    const reject = reason => {
      if (this.status === 'pending') {
        this.status = 'rejected';
        this.reason = reason;
        this.onRejectedCallbacks.forEach(fn => fn());
      }
    };
    
    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err);
    }
  }
  
  then(onFulfilled, onRejected) {
    // 参数可选，如果非函数则透传值
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : v => v;
    onRejected = typeof onRejected === 'function' ? onRejected : r => { throw r; };
    
    const newPromise = new DetailedPromise((resolve, reject) => {
      const handleFulfilled = () => {
        setTimeout(() => { // 保证异步执行
          try {
            const result = onFulfilled(this.value);
            resolvePromise(newPromise, result, resolve, reject);
          } catch (err) {
            reject(err);
          }
        });
      };
      
      const handleRejected = () => {
        setTimeout(() => {
          try {
            const result = onRejected(this.reason);
            resolvePromise(newPromise, result, resolve, reject);
          } catch (err) {
            reject(err);
          }
        });
      };
      
      if (this.status === 'fulfilled') {
        handleFulfilled();
      } else if (this.status === 'rejected') {
        handleRejected();
      } else {
        this.onFulfilledCallbacks.push(handleFulfilled);
        this.onRejectedCallbacks.push(handleRejected);
      }
    });
    
    return newPromise;
  }
  
  catch(onRejected) {
    return this.then(null, onRejected);
  }
}

/**
 * 解析 then 回调的返回值
 * - 如果返回值是新 Promise 自身，抛循环引用错误
 * - 如果返回值是 Promise，则等待其完成
 * - 如果返回值是 thenable 对象，执行其 then 方法
 * - 否则直接 resolve
 */
function resolvePromise(promise, result, resolve, reject) {
  if (promise === result) {
    reject(new TypeError('Chaining cycle detected for promise'));
    return;
  }
  
  if (result instanceof DetailedPromise) {
    result.then(resolve, reject);
  } else if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
    result.then(resolve, reject);
  } else {
    resolve(result);
  }
}

/**
 * 实现 promisify - 将 Node.js 回调风格转为 Promise
 * @param {Function} fn - Node.js 风格函数（最后一个参数为回调）
 * @returns {Function} 返回 Promise 风格的函数
 */
function promisify(fn) {
  return function (...args) {
    return new Promise((resolve, reject) => {
      // 追加一个回调函数作为最后一个参数
      fn.call(this, ...args, (err, ...results) => {
        if (err) {
          reject(err);
        } else {
          // 如果只有一个结果值，直接返回；多个结果以数组形式返回
          resolve(results.length === 1 ? results[0] : results);
        }
      });
    });
  };
}

/**
 * promisify 全部方法 - 将一个对象中的所有回调风格方法转为 Promise
 * @param {object} obj - 包含回调风格方法的对象
 * @returns {object} 返回新对象，所有方法都 Promise 化
 */
function promisifyAll(obj) {
  const result = {};
  for (const key of Object.keys(obj)) {
    const fn = obj[key];
    if (typeof fn === 'function') {
      result[key + 'Async'] = promisify(fn);
    }
  }
  return result;
}

/**
 * Promises/A+ 规范完整实现
 * 参考：https://promisesaplus.com/
 */

// 状态常量
const PENDING = 'pending';
const FULFILLED = 'fulfilled';
const REJECTED = 'rejected';

class PromiseA {
  constructor(executor) {
    this.status = PENDING;
    this.value = null;
    this.reason = null;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    
    const resolve = value => {
      if (this.status === PENDING) {
        this.status = FULFILLED;
        this.value = value;
        this.onFulfilledCallbacks.forEach(fn => fn(this.value));
      }
    };
    
    const reject = reason => {
      if (this.status === PENDING) {
        this.status = REJECTED;
        this.reason = reason;
        this.onRejectedCallbacks.forEach(fn => fn(this.reason));
      }
    };
    
    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err);
    }
  }
  
  then(onFulfilled, onRejected) {
    // 值穿透：onFulfilled/onRejected 如果不是函数则创建默认函数透传值
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : v => v;
    onRejected = typeof onRejected === 'function' ? onRejected : r => { throw r; };
    
    const promise2 = new PromiseA((resolve, reject) => {
      // 封装执行函数，确保异步调用
      const wrapFulfilled = () => {
        setTimeout(() => {
          try {
            const x = onFulfilled(this.value);
            this.resolvePromise(promise2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        });
      };
      
      const wrapRejected = () => {
        setTimeout(() => {
          try {
            const x = onRejected(this.reason);
            this.resolvePromise(promise2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        });
      };
      
      if (this.status === FULFILLED) {
        wrapFulfilled();
      } else if (this.status === REJECTED) {
        wrapRejected();
      } else {
        this.onFulfilledCallbacks.push(wrapFulfilled);
        this.onRejectedCallbacks.push(wrapRejected);
      }
    });
    
    return promise2;
  }
  
  catch(onRejected) {
    return this.then(null, onRejected);
  }
  
  // Promise 解析过程：Resolve(promise2, x)
  resolvePromise(promise2, x, resolve, reject) {
    // 2.3.1 如果 promise2 和 x 指向同一对象，抛出 TypeError
    if (promise2 === x) {
      reject(new TypeError('Chaining cycle detected for promise'));
      return;
    }
    
    // 2.3.2 如果 x 是 PromiseA 实例
    if (x instanceof PromiseA) {
      if (x.status === FULFILLED) {
        resolve(x.value);
      } else if (x.status === REJECTED) {
        reject(x.reason);
      } else {
        x.then(y => this.resolvePromise(promise2, y, resolve, reject), reject);
      }
      return;
    }
    
    // 2.3.3 如果 x 是对象或函数（thenable）
    if (x !== null && (typeof x === 'object' || typeof x === 'function')) {
      let called = false; // 2.3.3.3.3 确保只调用一次
      
      try {
        const then = x.then;
        
        if (typeof then === 'function') {
          // 2.3.3.3 如果 then 是函数，将 x 作为 this 调用
          then.call(
            x,
            y => {
              if (called) return;
              called = true;
              this.resolvePromise(promise2, y, resolve, reject);
            },
            r => {
              if (called) return;
              called = true;
              reject(r);
            }
          );
        } else {
          // 2.3.3.4 如果 then 不是函数，以 x 为值 resolve
          resolve(x);
        }
      } catch (e) {
        // 2.3.3.2 如果取 then 抛出异常，reject
        if (called) return;
        called = true;
        reject(e);
      }
    } else {
      // 2.3.4 如果 x 不是对象或函数，以 x 为值 resolve
      resolve(x);
    }
  }
  
  // 静态方法
  static resolve(value) {
    if (value instanceof PromiseA) return value;
    return new PromiseA(resolve => resolve(value));
  }
  
  static reject(reason) {
    return new PromiseA((_, reject) => reject(reason));
  }
  
  static all(iterable) {
    return new PromiseA((resolve, reject) => {
      const arr = Array.from(iterable);
      if (arr.length === 0) return resolve([]);
      
      const results = [];
      let count = 0;
      
      arr.forEach((item, i) => {
        PromiseA.resolve(item).then(
          val => {
            results[i] = val;
            count++;
            if (count === arr.length) resolve(results);
          },
          reject
        );
      });
    });
  }
  
  static race(iterable) {
    return new PromiseA((resolve, reject) => {
      Array.from(iterable).forEach(item => {
        PromiseA.resolve(item).then(resolve, reject);
      });
    });
  }
}

// 用于测试的 deferred 方法
PromiseA.deferred = function () {
  const result = {};
  result.promise = new PromiseA((resolve, reject) => {
    result.resolve = resolve;
    result.reject = reject;
  });
  return result;
};

// module.exports = PromiseA;

/**
 * 发布订阅模式（Event Emitter）
 * - on: 订阅事件
 * - emit: 发布事件
 * - off: 取消订阅
 * - once: 订阅一次
 */
class EventEmitter {
  constructor() {
    this.events = {}; // 存储所有事件及其对应的回调
  }
  
  /**
   * 订阅事件
   * @param {string} event - 事件名
   * @param {Function} callback - 回调函数
   * @returns {Function} 取消订阅的函数
   */
  on(event, callback) {
    if (!this.events[event]) {
      this.events[event] = [];
    }
    this.events[event].push(callback);
    
    // 返回取消订阅的函数
    return () => this.off(event, callback);
  }
  
  /**
   * 发布事件
   * @param {string} event - 事件名
   * @param {...any} args - 传递给回调的参数
   */
  emit(event, ...args) {
    const callbacks = this.events[event];
    if (callbacks) {
      callbacks.forEach(cb => {
        try {
          cb(...args);
        } catch (err) {
          console.error(`Event "${event}" callback error:`, err);
        }
      });
    }
  }
  
  /**
   * 取消订阅
   * @param {string} event - 事件名
   * @param {Function} callback - 要移除的回调（不传则移除该事件所有回调）
   */
  off(event, callback) {
    if (!callback) {
      // 不传回调则移除该事件所有订阅
      delete this.events[event];
      return;
    }
    
    const callbacks = this.events[event];
    if (callbacks) {
      this.events[event] = callbacks.filter(cb => cb !== callback);
    }
  }
  
  /**
   * 订阅一次（触发后自动取消）
   * @param {string} event - 事件名
   * @param {Function} callback - 回调函数
   */
  once(event, callback) {
    const wrapper = (...args) => {
      callback(...args);
      this.off(event, wrapper);
    };
    this.on(event, wrapper);
  }
}

/**
 * 观察者模式
 */

// 目标对象（被观察者）
class Subject {
  constructor() {
    this.observers = []; // 观察者列表
  }
  
  // 添加观察者
  addObserver(observer) {
    if (observer && observer.update) {
      this.observers.push(observer);
    }
  }
  
  // 移除观察者
  removeObserver(observer) {
    this.observers = this.observers.filter(obs => obs !== observer);
  }
  
  // 通知所有观察者
  notify(data) {
    this.observers.forEach(observer => observer.update(data));
  }
}

// 观察者
class Observer {
  constructor(name) {
    this.name = name;
  }
  
  // 被通知时调用的方法
  update(data) {
    console.log(`${this.name} 收到通知:`, data);
  }
}

// --- 使用示例 ---
// const subject = new Subject();
// const obs1 = new Observer('观察者1');
// const obs2 = new Observer('观察者2');
// subject.addObserver(obs1);
// subject.addObserver(obs2);
// subject.notify('状态变了！');

/**
 * 单例模式 - 使用闭包实现
 */
function createSingleton(className) {
  let instance = null;
  
  return class Singleton {
    constructor(...args) {
      if (instance) {
        return instance;
      }
      instance = this;
      if (typeof className === 'function') {
        className.apply(this, args);
      }
    }
  };
}

/**
 * 单例模式 - 使用静态方法实现
 */
class Singleton {
  constructor(name) {
    if (Singleton._instance) {
      return Singleton._instance;
    }
    this.name = name;
    Singleton._instance = this;
  }
  
  static getInstance(name) {
    if (!Singleton._instance) {
      Singleton._instance = new Singleton(name);
    }
    return Singleton._instance;
  }
}

/**
 * 原生 Ajax 实现 - 使用 XMLHttpRequest
 * @param {object} options - 配置项
 * @param {string} options.url - 请求地址
 * @param {string} [options.method='GET'] - 请求方法
 * @param {object} [options.data] - 请求数据
 * @param {boolean} [options.async=true] - 是否异步
 * @param {object} [options.headers] - 自定义请求头
 * @param {Function} [options.onSuccess] - 成功回调
 * @param {Function} [options.onError] - 失败回调
 * @param {Function} [options.onProgress] - 进度回调
 */
function ajax(options) {
  const xhr = new XMLHttpRequest();
  const method = (options.method || 'GET').toUpperCase();
  const async = options.async !== false;
  
  // 处理 GET 请求参数拼接到 URL
  let url = options.url;
  if (method === 'GET' && options.data) {
    const params = Object.entries(options.data)
      .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
      .join('&');
    url += (url.includes('?') ? '&' : '?') + params;
  }
  
  xhr.open(method, url, async);
  
  // 设置请求头
  if (options.headers) {
    Object.entries(options.headers).forEach(([key, value]) => {
      xhr.setRequestHeader(key, value);
    });
  }
  
  // 设置响应类型
  xhr.responseType = options.responseType || 'json';
  
  // 监听状态变化
  xhr.onreadystatechange = function () {
    if (xhr.readyState === 4) {
      if (xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) {
        options.onSuccess && options.onSuccess(xhr.response);
      } else {
        options.onError && options.onError(new Error(`请求失败: ${xhr.status}`));
      }
    }
  };
  
  // 监听进度
  if (options.onProgress) {
    xhr.onprogress = options.onProgress;
  }
  
  // 发送请求
  const body = method === 'POST' && options.data ? JSON.stringify(options.data) : null;
  xhr.send(body);
}

/**
 * Promise 版本的 Ajax
 * @param {string} url - 请求地址
 * @param {object} [options] - 配置项
 * @returns {Promise} 返回 Promise
 */
function ajaxPromise(url, options = {}) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    const method = (options.method || 'GET').toUpperCase();
    
    let requestUrl = url;
    if (method === 'GET' && options.data) {
      const params = Object.entries(options.data)
        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
        .join('&');
      requestUrl += (url.includes('?') ? '&' : '?') + params;
    }
    
    xhr.open(method, requestUrl, true);
    
    if (options.headers) {
      Object.entries(options.headers).forEach(([key, value]) => {
        xhr.setRequestHeader(key, value);
      });
    }
    
    xhr.responseType = options.responseType || 'json';
    xhr.withCredentials = options.withCredentials || false;
    xhr.timeout = options.timeout || 0;
    
    xhr.onload = function () {
      if (xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) {
        resolve(xhr.response);
      } else {
        reject(new Error(`HTTP ${xhr.status}: ${xhr.statusText}`));
      }
    };
    
    xhr.onerror = function () {
      reject(new Error('网络错误'));
    };
    
    xhr.ontimeout = function () {
      reject(new Error('请求超时'));
    };
    
    const body = ['POST', 'PUT', 'PATCH'].includes(method) && options.data
      ? JSON.stringify(options.data)
      : null;
    xhr.send(body);
  });
}

// --- 使用示例 ---
// ajaxPromise('/api/users')
//   .then(data => console.log(data))
//   .catch(err => console.error(err));

/**
 * JSONP 实现
 * @param {string} url - 请求地址
 * @param {object} params - URL 参数
 * @param {string} [callbackName='callback'] - 后端接收的回调函数名
 * @returns {Promise} 返回 Promise
 */
function jsonp(url, params = {}, callbackName = 'callback') {
  return new Promise((resolve, reject) => {
    // 生成唯一的回调函数名
    const uniqueCallback = `jsonp_${Date.now()}_${Math.random().toString(36).slice(2)}`;
    
    // 构建 URL 参数
    const queryParams = {
      ...params,
      [callbackName]: uniqueCallback
    };
    const queryString = Object.entries(queryParams)
      .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
      .join('&');
    
    const fullUrl = url + (url.includes('?') ? '&' : '?') + queryString;
    
    // 创建全局回调函数
    window[uniqueCallback] = function (data) {
      resolve(data);
      cleanup();
    };
    
    // 创建 script 标签
    const script = document.createElement('script');
    script.src = fullUrl;
    script.async = true;
    
    // 超时处理
    const timeout = setTimeout(() => {
      reject(new Error('JSONP 请求超时'));
      cleanup();
    }, params.timeout || 10000);
    
    // 错误处理
    script.onerror = function () {
      reject(new Error('JSONP 加载失败'));
      cleanup();
    };
    
    // 清理函数
    function cleanup() {
      clearTimeout(timeout);
      delete window[uniqueCallback];
      document.body.removeChild(script);
    }
    
    document.body.appendChild(script);
  });
}

/**
 * 模拟实现 async/await - 使用 Generator + Promise
 * async 函数返回 Promise，内部通过 Generator 控制执行流程
 */

// 一个 async 函数的示例
// async function fetchData() {
//   const data1 = await api1();
//   const data2 = await api2(data1);
//   return data2;
// }

/**
 * async/await 原理实现 - 使用 Generator + Promise
 * 
 * async/await 的本质：
 * 1. async 函数会返回一个 Promise
 * 2. await 后面的表达式会被 Promise.resolve() 包装
 * 3. Generator 函数通过 yield 暂停，通过 next() 恢复执行
 * 4. 自执行器（runner）自动执行 Generator，每次 yield 返回 Promise
 *    并在 Promise resolve 后继续 next()
 */

/**
 * Generator 自执行器 - 模拟 async
 * @param {GeneratorFunction} generatorFn - Generator 函数
 * @returns {Function} 返回一个函数，执行后返回 Promise
 */
function asyncWrapper(generatorFn) {
  return function (...args) {
    const generator = generatorFn.apply(this, args);
    
    return new Promise((resolve, reject) => {
      function step(key, arg) {
        let result;
        try {
          result = generator[key](arg);
        } catch (err) {
          return reject(err);
        }
        
        const { value, done } = result;
        
        if (done) {
          return resolve(value);
        }
        
        // value 可能是 Promise 或普通值，统一用 Promise.resolve 包装
        Promise.resolve(value).then(
          val => step('next', val),
          err => step('throw', err)
        );
      }
      
      step('next');
    });
  };
}

// --- 使用示例 ---
// function* fetchData() {
//   const data1 = yield Promise.resolve('数据1');
//   console.log(data1); // '数据1'
//   const data2 = yield Promise.resolve('数据2');
//   console.log(data2); // '数据2'
//   return '完成';
// }
// 
// const asyncFetchData = asyncWrapper(fetchData);
// asyncFetchData().then(result => console.log(result)); // '完成'

/**
 * 模拟 const - 使用 Object.defineProperty
 * 利用全局对象的属性，设置 writable: false 使其不可修改
 */
function myConst(key, value) {
  // 在全局对象上定义不可写的属性
  Object.defineProperty(globalThis, key, {
    value,
    writable: false,    // 不可写
    configurable: false, // 不可配置
    enumerable: true     // 可枚举
  });
}

// --- 使用示例 ---
// myConst('MY_CONST', 100);
// console.log(MY_CONST); // 100
// MY_CONST = 200; // 严格模式下报错，非严格模式下静默失败

/**
 * ES6 extends 实现原理（ES5 模拟）
 * - 子类继承父类：原型链继承 + 构造函数窃取
 */
function extendsImpl(child, parent) {
  // 1. 继承父类静态属性
  Object.setPrototypeOf(child, parent);
  
  // 2. 继承父类原型方法
  child.prototype = Object.create(parent.prototype, {
    constructor: {
      value: child,
      writable: true,
      configurable: true
    }
  });
  
  // 3. 存储父类引用
  child._super = parent;
}

// --- 使用示例 ---
// function Animal(name) { this.name = name; }
// Animal.prototype.speak = function() { return this.name; };
// 
// function Dog(name, breed) {
//   Animal.call(this, name);
//   this.breed = breed;
// }
// extendsImpl(Dog, Animal);