/**
 * 并发受限的 Promise.all
 * @param {number} limit 最大并发数
 * @param {Array<() => Promise<any>>} tasks 任务工厂数组（注意：是函数，不是已经启动的 Promise）
 * @returns {Promise<any[]>} 与 tasks 顺序一致的结果数组
 */
async function asyncPool(limit, tasks) {
  const list = Array.from(tasks); // 兼容任意可迭代对象，同时快照一份防止外部改动
  if (!Number.isInteger(limit) || limit < 1) {
    throw new TypeError('limit 必须是 >= 1 的整数');
  }
  const results = new Array(list.length);
  if (list.length === 0) return results; // 边界：空任务，直接返回 []

  let cursor = 0; // 共享游标。JS 单线程，cursor++ 与后面的 await 之间不会被打断，天然无竞态

  // 边界：limit 大于任务数时，worker 数量取小值，避免空转
  const workerCount = Math.min(limit, list.length);

  const worker = async () => {
    while (cursor < list.length) {
      const index = cursor++;          // 先同步占坑
      results[index] = await list[index](); // 再异步执行，结果按 index 回填保证顺序
    }
  };

  // 任一任务抛错则整体 reject，语义对齐 Promise.all
  await Promise.all(Array.from({ length: workerCount }, worker));
  return results;
}

function asyncPoolRace(limit, tasks) {
  const list = Array.from(tasks);
  const results = [];   // 存 Promise，最后统一 Promise.all
  const executing = new Set(); // 正在执行的 Promise 集合

  return (async () => {
    for (const task of list) {
      // 用 Promise.resolve().then 包一层：即使 task 同步抛错也能转成 rejected Promise
      const p = Promise.resolve().then(() => task());
      results.push(p);

      // 给 p 挂一个「完成即出队」的回调。注意两个分支都要挂，否则 reject 时窗口不释放
      const clean = () => executing.delete(p);
      p.then(clean, clean); // 这里已经消费了 rejection，不会产生 unhandledrejection

      executing.add(p);
      if (executing.size >= limit) {
        // 等最快的一个完成后再放行下一个。catch 兜底，防止 race 的 rejection 无人处理
        await Promise.race(executing).catch(() => {});
      }
    }
    return Promise.all(results);
  })();
}

async function asyncPoolSettled(limit, tasks) {
  // 把每个任务包成永不 reject 的形式，复用上面的 asyncPool
  return asyncPool(
    limit,
    Array.from(tasks, (task) => async () => {
      try {
        return { status: 'fulfilled', value: await task() };
      } catch (reason) {
        return { status: 'rejected', reason };
      }
    })
  );
}

const sleep = (ms, v) => new Promise((r) => setTimeout(() => r(v), ms));
const tasks = [1000, 500, 300, 400, 200].map((ms, i) => () => sleep(ms, `任务${i}(${ms}ms)`));

console.time('pool');
asyncPool(2, tasks).then((res) => {
  console.timeEnd('pool');            // ≈1200ms（并发 2），而非串行的 2400ms
  console.log(res);                   // ['任务0(1000ms)', '任务1(500ms)', ... ] 顺序严格对应
});

asyncPool(10, tasks).then(console.log); // 边界：limit > 任务数，等价于 Promise.all
asyncPool(3, []).then(console.log);     // 边界：空数组 -> []

/**
 * 包装一个请求函数，使其只有「最后一次调用」的结果会被消费
 * @param {(...args:any[]) => Promise<any>} request 原始请求函数
 */
function createLatestOnly(request) {
  let seq = 0; // 自增序号，闭包持有

  return function (...args) {
    const id = ++seq; // 本次调用的编号，先自增再记录
    return Promise.resolve(request.apply(this, args)).then(
      (data) => {
        // 回来时如果 seq 已经被更新过，说明我不是最后一次 -> 丢弃
        if (id !== seq) throw new StaleError();
        return data;
      },
      (err) => {
        // 过期请求的错误同样不该冒泡到 UI（否则会弹出早已过时的报错）
        if (id !== seq) throw new StaleError();
        throw err;
      }
    );
  };
}

/** 过期标记错误：调用方据此静默忽略，而不是当成真正的失败 */
class StaleError extends Error {
  constructor() {
    super('STALE_RESPONSE');
    this.name = 'StaleError';
  }
}
const isStale = (err) => err instanceof StaleError;

/**
 * 每次新调用都 abort 掉上一次未完成的请求
 * 约定：被包装的函数最后一个参数接收 { signal }
 */
function createAbortableLatest(request) {
  let controller = null;

  const wrapped = function (...args) {
    controller?.abort();                 // 取消上一次（首次为 null，可选链安全）
    controller = new AbortController();
    const current = controller;

    return Promise.resolve(request.apply(this, [...args, { signal: current.signal }]))
      .finally(() => {
        // 只有「自己还是当前那一次」时才清空，避免误清掉后来者的 controller
        if (controller === current) controller = null;
      });
  };

  wrapped.cancel = () => controller?.abort(); // 组件卸载时手动取消
  return wrapped;
}

// 配合 fetch 使用
const search = createAbortableLatest((keyword, { signal }) =>
  fetch(`/api/search?q=${encodeURIComponent(keyword)}`, { signal }).then((r) => r.json())
);

// 模拟：先发的请求反而更慢
const mockRequest = (kw) =>
  new Promise((r) => setTimeout(() => r(`结果:${kw}`), kw === 'a' ? 800 : 100));

const latest = createLatestOnly(mockRequest);

latest('a').then(console.log).catch((e) => isStale(e) || Promise.reject(e)); // 被丢弃，无输出
latest('ab').then(console.log);  // 100ms 后输出「结果:ab」—— 最终 UI 正确

// AbortController 版的调用方需要过滤 AbortError
search('ab').catch((e) => {
  if (e.name !== 'AbortError') throw e; // 主动取消不算错误
});

/**
 * Promise.all：全部成功才成功，任一失败立即失败
 * 边界：空数组立即 resolve([])；非 Promise 值原样透传；结果严格按输入顺序
 */
function myAll(iterable) {
  return new Promise((resolve, reject) => {
    const list = Array.from(iterable); // 支持任意可迭代对象（Set、生成器…）
    const results = new Array(list.length);
    let count = 0;

    if (list.length === 0) return resolve(results); // 边界：空数组同步 resolve

    list.forEach((item, index) => {
      // Promise.resolve 兼容 thenable 和普通值
      Promise.resolve(item).then(
        (value) => {
          results[index] = value; // 按下标回填，保证顺序而非完成顺序
          if (++count === list.length) resolve(results); // 用计数而非 index 判断，避免乱序完成时提前 resolve
        },
        reject // 任一失败直接 reject（Promise 状态不可逆，后续 reject 无效，无需加锁）
      );
    });
  });
}

/**
 * Promise.race：第一个 settle（无论成功失败）的结果决定最终状态
 * 边界：空数组 -> 永远 pending（这是规范行为，不是 bug）
 */
function myRace(iterable) {
  return new Promise((resolve, reject) => {
    for (const item of iterable) {
      Promise.resolve(item).then(resolve, reject); // 谁先到谁生效，后来者被忽略
    }
  });
}

/**
 * Promise.allSettled：永不 reject，返回每一项的状态描述
 */
function myAllSettled(iterable) {
  const list = Array.from(iterable);
  return myAll(
    list.map((item) =>
      Promise.resolve(item).then(
        (value) => ({ status: 'fulfilled', value }),
        (reason) => ({ status: 'rejected', reason }) // 把失败转成成功，所以整体永不 reject
      )
    )
  );
}

/** 附赠：Promise.any —— 任一成功即成功，全部失败抛 AggregateError */
function myAny(iterable) {
  return new Promise((resolve, reject) => {
    const list = Array.from(iterable);
    const errors = new Array(list.length);
    let count = 0;
    if (list.length === 0) return reject(new AggregateError([], 'All promises were rejected'));
    list.forEach((item, index) => {
      Promise.resolve(item).then(resolve, (err) => {
        errors[index] = err;
        if (++count === list.length) reject(new AggregateError(errors, 'All promises were rejected'));
      });
    });
  });
}

myAll([1, Promise.resolve(2), sleep(50, 3)]).then(console.log);        // [1, 2, 3]
myAll([]).then((r) => console.log('空数组:', r));                       // 空数组: []
myAll([1, Promise.reject(new Error('x'))]).catch((e) => console.log(e.message)); // x

myRace([sleep(100, 'slow'), sleep(10, 'fast')]).then(console.log);     // fast

myAllSettled([Promise.resolve(1), Promise.reject('e')]).then(console.log);
// [{status:'fulfilled',value:1}, {status:'rejected',reason:'e'}]

/**
 * 将 error-first 回调风格函数转为 Promise 风格
 * @param {Function} fn 形如 fn(...args, (err, ...values) => {})
 */
function promisify(fn) {
  if (typeof fn !== 'function') throw new TypeError('promisify 的参数必须是函数');

  // 必须用 function 而不是箭头函数：要透传调用时的 this（如 obj.method）
  return function (...args) {
    return new Promise((resolve, reject) => {
      // 用 fn.call(this, ...) 把 this 传给原函数，否则 fs.read 这类依赖 this 的方法会崩
      fn.call(this, ...args, (err, ...values) => {
        if (err) return reject(err);
        // Node 的 util.promisify 语义：多个返回值时给出数组，单个时直接给值
        resolve(values.length > 1 ? values : values[0]);
      });
    });
  };
}

/** 批量转换一个对象上的方法（保留原方法） */
function promisifyAll(obj, suffix = 'Async') {
  for (const key of Object.keys(obj)) {
    if (typeof obj[key] === 'function') {
      obj[`${key}${suffix}`] = promisify(obj[key]);
    }
  }
  return obj;
}

function readFileMock(path, callback) {
  setTimeout(() => {
    path ? callback(null, `${path} 的内容`) : callback(new Error('路径为空'));
  }, 10);
}

const readFile = promisify(readFileMock);
readFile('/a.txt').then(console.log);              // /a.txt 的内容
readFile('').catch((e) => console.log(e.message)); // 路径为空

// this 透传验证
const api = {
  base: 'https://x.com',
  get(path, cb) { cb(null, this.base + path); }, // 依赖 this
};
promisifyAll(api);
api.getAsync('/user').then(console.log);           // https://x.com/user

/**
 * 最简版：延迟指定毫秒后 resolve
 * @param {number} ms
 * @param {any} [value] 可选透传值，方便链式使用
 */
const sleep = (ms, value) => new Promise((resolve) => setTimeout(resolve, ms, value));

/**
 * 可取消版：支持 AbortSignal，避免组件卸载后定时器还在跑
 */
function sleepCancelable(ms, { signal } = {}) {
  return new Promise((resolve, reject) => {
    if (signal?.aborted) return reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));

    const timer = setTimeout(() => {
      signal?.removeEventListener('abort', onAbort); // 正常结束也要摘监听，防内存泄漏
      resolve();
    }, ms);

    function onAbort() {
      clearTimeout(timer); // 关键：真正清掉定时器，而不只是 reject
      reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
    }
    signal?.addEventListener('abort', onAbort, { once: true });
  });
}

async function demo() {
  console.log('start', Date.now());
  await sleep(500);
  console.log('after 500ms', Date.now());

  const v = await sleep(100, 'hello');
  console.log(v); // hello
}
demo();

// 可取消
const ac = new AbortController();
sleepCancelable(5000, { signal: ac.signal }).catch((e) => console.log(e.name)); // AbortError
ac.abort();

/**
 * 失败自动重试（支持次数、延迟、指数退避、条件重试、可取消）
 * @param {(attempt:number) => Promise<any>} fn 任务工厂，每次重试都会重新调用
 * @param {object} options
 * @param {number} options.retries  重试次数（不含首次），总执行次数 = retries + 1
 * @param {number} options.delay    首次重试前的等待毫秒
 * @param {number} options.factor   退避倍数，1 表示固定间隔
 * @param {number} options.maxDelay 延迟上限
 * @param {(err:Error, attempt:number) => boolean} options.shouldRetry 是否值得重试
 */
async function retry(fn, options = {}) {
  const {
    retries = 3,
    delay = 300,
    factor = 2,
    maxDelay = Infinity,
    shouldRetry = () => true,
    signal,
  } = options;

  let attempt = 0;   // 已失败次数
  let wait = delay;

  for (;;) {
    try {
      return await fn(attempt); // 把当前轮次告诉任务，方便打日志
    } catch (err) {
      // 三个终止条件：次数用尽 / 该错误不值得重试 / 外部已取消
      if (attempt >= retries || !shouldRetry(err, attempt) || signal?.aborted) {
        throw err; // 抛出的是「最后一次」的错误，保留原始堆栈
      }
      attempt++;
      await sleepCancelable(Math.min(wait, maxDelay), { signal });
      wait *= factor; // 指数退避：300 -> 600 -> 1200…
    }
  }
}

let n = 0;
const flaky = () => {
  n++;
  return n < 3 ? Promise.reject(new Error(`第${n}次失败`)) : Promise.resolve(`第${n}次成功`);
};

retry(flaky, { retries: 5, delay: 100 }).then(console.log); // 约 300ms 后输出「第3次成功」

// 只对 5xx / 网络错误重试，4xx 直接放弃（真实业务里最常见的诉求）
retry(() => fetch('/api').then((r) => {
  if (!r.ok) { const e = new Error(r.statusText); e.status = r.status; throw e; }
  return r.json();
}), {
  retries: 3,
  shouldRetry: (err) => err.status === undefined || err.status >= 500,
}).catch(console.error);

// 边界：retries = 0 表示不重试，只跑一次
retry(() => Promise.reject(new Error('boom')), { retries: 0 }).catch((e) => console.log(e.message));

/**
 * 用递归 setTimeout 模拟 setInterval
 * @returns {() => void} 取消函数（不用返回 id，闭包更安全）
 */
function mySetInterval(fn, delay, ...args) {
  let timer = null;
  let stopped = false;

  const loop = () => {
    timer = setTimeout(() => {
      if (stopped) return;      // 双保险：clear 之后仍可能进来（极端时序）
      fn(...args);              // 先执行业务
      if (!stopped) loop();     // 再排下一次；若 fn 里调用了 cancel，这里就不会再排
    }, delay);
  };

  loop();

  return function clear() {
    stopped = true;
    clearTimeout(timer);
    timer = null;
  };
}

/**
 * 进阶：补偿版，抵消 setTimeout 的累积漂移（做倒计时、动画节拍时必需）
 * 思路：每次都以「理论下一次触发时刻」和「当前真实时刻」的差值来修正等待时间
 */
function accurateInterval(fn, delay) {
  let stopped = false;
  let count = 0;
  const start = Date.now();
  let timer = null;

  const loop = () => {
    count++;
    // 第 count 次理论触发时刻是 start + count*delay，直接减去「现在」就是还要等多久。
    // 注意：这里要用绝对时刻相减，写成 delay - (now - (start + count*delay)) 会多等一个 delay
    const next = Math.max(0, start + count * delay - Date.now()); // 落后太多时立刻触发，不会是负数
    timer = setTimeout(() => {
      if (stopped) return;
      fn(count);
      if (!stopped) loop();
    }, next);
  };

  loop();
  return () => { stopped = true; clearTimeout(timer); };
}

/** 反向：用 setInterval 实现 setTimeout（同样是常见追问） */
function mySetTimeout(fn, delay, ...args) {
  const timer = setInterval(() => {
    clearInterval(timer); // 先清再执行，防止 fn 抛错导致定时器永远清不掉
    fn(...args);
  }, delay);
  return () => clearInterval(timer);
}

let i = 0;
const cancel = mySetInterval(() => {
  console.log('tick', ++i, Date.now());
  if (i === 5) cancel(); // 在回调内部取消，也能正确停止
}, 200);

// 验证漂移补偿：第 10 次触发应该落在 ≈1000ms，而不是被误差越拖越晚
const t0 = Date.now();
const marks = [];
const stop = accurateInterval((n) => {
  marks.push(Date.now() - t0);
  if (n === 10) { stop(); console.log(marks.join(','), '总耗时', Date.now() - t0); }
}, 100);

// 故意在 320ms 处同步阻塞 250ms，模拟长任务
setTimeout(() => { const end = Date.now() + 250; while (Date.now() < end); }, 320);
// 实测输出：115,209,304,585,596,611,705,813,906,1001  总耗时 1010
//          ↑ 阻塞期间欠下的 3 次会「追账式」补齐（585/596/611 紧挨着触发），
//            随后自动回到 100ms 的节拍上，总耗时仍锚定在 1000ms 附近。
//            如果不想要这种补触发，可以给 next 设一个下限，代价是放弃总时长的准确性。

/**
 * 防抖：事件停止触发 wait 毫秒后才执行。高频触发时不断重新计时。
 * @param {Function} fn
 * @param {number} wait
 * @param {boolean} immediate 是否在触发的第一时间就执行一次（前沿触发）
 */
function debounce(fn, wait = 300, immediate = false) {
  let timer = null;
  let lastArgs = null;
  let lastThis = null;
  let result;

  const debounced = function (...args) {
    lastArgs = args;
    lastThis = this;                       // 保存 this，保证 DOM 事件里 this 仍是元素

    const callNow = immediate && timer === null; // 只有「空闲期」的第一次才立即执行

    if (timer) clearTimeout(timer);
    timer = setTimeout(() => {
      timer = null;
      if (!immediate) {                    // 后沿触发：延迟结束时才真正执行
        result = fn.apply(lastThis, lastArgs);
        lastArgs = lastThis = null;        // 及时释放引用，避免闭包持有 DOM 造成泄漏
      }
    }, wait);

    if (callNow) {
      result = fn.apply(this, args);
      lastArgs = lastThis = null;
    }
    return result; // 注意：immediate=false 时返回的是「上一次」的结果，异步天然如此
  };

  /** 取消未执行的调用（组件卸载时必调） */
  debounced.cancel = () => {
    clearTimeout(timer);
    timer = null;
    lastArgs = lastThis = null;
  };

  /** 立即执行挂起的调用 */
  debounced.flush = () => {
    if (timer && !immediate && lastArgs) {
      clearTimeout(timer);
      timer = null;
      result = fn.apply(lastThis, lastArgs);
      lastArgs = lastThis = null;
    }
    return result;
  };

  /** 是否有待执行任务 */
  debounced.pending = () => timer !== null;

  return debounced;
}

/**
 * 节流：wait 毫秒内最多执行一次（时间戳 + 定时器合并版）
 * @param {object} options
 * @param {boolean} options.leading  是否响应「第一次」触发（默认 true）
 * @param {boolean} options.trailing 是否在最后补一次（默认 true）
 */
function throttle(fn, wait = 300, { leading = true, trailing = true } = {}) {
  let last = 0;          // 上一次执行的时间戳
  let timer = null;
  let lastArgs = null;
  let lastThis = null;
  let result;

  const throttled = function (...args) {
    const now = Date.now();
    // leading=false 时，把 last 初始化为 now，从而让第一次落到 trailing 分支
    if (last === 0 && !leading) last = now;

    const remaining = wait - (now - last);
    lastArgs = args;
    lastThis = this;

    // remaining > wait 是防御系统时间被回拨导致永远不触发
    if (remaining <= 0 || remaining > wait) {
      // —— 时间戳分支：立刻执行 ——
      if (timer) { clearTimeout(timer); timer = null; }
      last = now;
      result = fn.apply(this, args);
      lastArgs = lastThis = null;
    } else if (timer === null && trailing) {
      // —— 定时器分支：补上最后一次，保证「停止触发后」还有一次响应 ——
      timer = setTimeout(() => {
        last = leading ? Date.now() : 0; // leading=false 时重置，让下一轮仍走 trailing
        timer = null;
        if (lastArgs) result = fn.apply(lastThis, lastArgs);
        lastArgs = lastThis = null;
      }, remaining);
    }
    return result;
  };

  throttled.cancel = () => {
    clearTimeout(timer);
    timer = null;
    last = 0;
    lastArgs = lastThis = null;
  };

  return throttled;
}

// 防抖：搜索框，用户停止输入 500ms 后才请求
const onSearch = debounce((e) => console.log('请求:', e.target.value), 500);
input.addEventListener('input', onSearch);
// 组件卸载
onSearch.cancel();

// 立即执行版：按钮防连点，第一次立刻生效，1s 内的后续点击全忽略
const onSubmit = debounce(() => console.log('提交'), 1000, true);

// 节流：滚动计算位置，最多 100ms 一次
window.addEventListener('scroll', throttle(() => console.log(window.scrollY), 100));

// 快速验证节流：50ms 触发一次，共 10 次，wait=200 -> 大约执行 3~4 次而非 10 次
let c = 0;
const t = throttle(() => console.log('throttle 执行', ++c), 200);
const iv = setInterval(t, 50);
setTimeout(() => clearInterval(iv), 1000);

/**
 * myCall：改变 this 并立即执行
 * 原理：把函数临时挂到目标对象上作为方法调用，利用「谁调用 this 指向谁」，用完删除
 */
Function.prototype.myCall = function (thisArg, ...args) {
  if (typeof this !== 'function') {
    throw new TypeError('myCall 必须由函数调用');
  }
  // null / undefined 指向全局对象；原始值被包装成对象（这是非严格模式的原生行为）
  const ctx = thisArg === null || thisArg === undefined ? globalThis : Object(thisArg);

  // 用 Symbol 做 key，杜绝覆盖对象上的同名属性
  const key = Symbol('__myCall__');
  Object.defineProperty(ctx, key, {
    value: this,
    enumerable: false,   // 不可枚举，避免污染 for...in
    configurable: true,  // 必须可配置，否则删不掉
  });

  try {
    return ctx[key](...args); // 作为 ctx 的方法调用，函数内部 this === ctx
  } finally {
    delete ctx[key];          // 放在 finally，保证抛异常时也能清理
  }
};

/**
 * myApply：与 call 一致，只是参数是数组
 */
Function.prototype.myApply = function (thisArg, argsArray) {
  if (typeof this !== 'function') throw new TypeError('myApply 必须由函数调用');
  // 边界：不传或传 null/undefined 视为无参；传非类数组应报错
  if (argsArray === null || argsArray === undefined) return this.myCall(thisArg);
  if (typeof argsArray !== 'object') throw new TypeError('CreateListFromArrayLike called on non-object');
  return this.myCall(thisArg, ...Array.from(argsArray)); // Array.from 兼容类数组（arguments、NodeList）
};

/**
 * myBind：返回一个 this 被固定的新函数，支持柯里化，且支持 new 调用
 */
Function.prototype.myBind = function (thisArg, ...boundArgs) {
  if (typeof this !== 'function') throw new TypeError('myBind 必须由函数调用');
  const target = this;

  // 用普通函数（非箭头），才能拿到 new.target 和自己的 this
  function bound(...callArgs) {
    // 关键：作为构造函数调用（new bound()）时，new.target 有值，
    // 此时必须忽略 thisArg，让 this 指向新创建的实例
    return target.apply(
      new.target ? this : thisArg,
      [...boundArgs, ...callArgs] // 绑定时的参数在前，调用时的参数在后
    );
  }

  // 维持原型链，使 new bound() 的实例满足 instanceof target
  // 用 Object.create 中转而不是直接 bound.prototype = target.prototype，
  // 防止改动 bound.prototype 时污染原函数的原型
  if (target.prototype) {
    bound.prototype = Object.create(target.prototype);
  }

  // 规范里 bound function 的 length 是「原函数 length 减去已绑定参数数」，且不小于 0
  Object.defineProperty(bound, 'length', {
    value: Math.max(0, target.length - boundArgs.length),
    configurable: true,
  });
  Object.defineProperty(bound, 'name', {
    value: `bound ${target.name}`,
    configurable: true,
  });

  return bound;
};

function greet(greeting, punctuation) {
  return `${greeting}, ${this.name}${punctuation}`;
}
const user = { name: '张三' };

console.log(greet.myCall(user, '你好', '！'));    // 你好, 张三！
console.log(greet.myApply(user, ['Hi', '.']));   // Hi, 张三.
console.log(greet.myApply(user));                // 边界：不传参数数组也不报错
console.log(greet.myBind(user, '嗨')('~'));       // 嗨, 张三~  柯里化

// 重点验证：bind 后被 new 调用
function Person(name, age) {
  this.name = name;
  this.age = age;
}
Person.prototype.say = function () { return `${this.name}-${this.age}`; };

const BoundPerson = Person.myBind({ name: '应该被忽略' }, '李四');
const p = new BoundPerson(28);
console.log(p.name, p.age);          // 李四 28  —— thisArg 被正确忽略
console.log(p.say());                // 李四-28  —— 原型链完好
console.log(p instanceof Person);    // true
console.log(p instanceof BoundPerson); // true

// 不污染原型验证
BoundPerson.prototype.extra = 1;
console.log(Person.prototype.extra); // undefined

function myNew(Ctor, ...args) {
  if (typeof Ctor !== 'function') {
    throw new TypeError(`${Ctor} is not a constructor`);
  }
  // 箭头函数、Symbol、部分内置方法没有 prototype，不能被 new
  if (!('prototype' in Ctor)) {
    throw new TypeError(`${Ctor.name} is not a constructor`);
  }

  // ① + ② 创建对象并链接原型（Ctor.prototype 被改成原始值时回退到 Object.prototype，对齐规范）
  const proto = (typeof Ctor.prototype === 'object' || typeof Ctor.prototype === 'function')
    && Ctor.prototype !== null
      ? Ctor.prototype
      : Object.prototype;
  const instance = Object.create(proto);

  // ③ 执行构造函数，this 指向新对象
  const result = Ctor.apply(instance, args);

  // ④ 构造函数显式返回「对象/函数」则以它为准，返回原始值（含 undefined/null）则忽略
  const isObject = result !== null && (typeof result === 'object' || typeof result === 'function');
  return isObject ? result : instance;
}

function Person(name) {
  this.name = name;
}
Person.prototype.hello = function () { return 'hi ' + this.name; };

const p = myNew(Person, '王五');
console.log(p.name, p.hello(), p instanceof Person); // 王五 hi 王五 true

// 边界：构造函数返回对象 -> 返回值胜出
function Weird() { this.a = 1; return { b: 2 }; }
console.log(myNew(Weird)); // { b: 2 }，a 丢失

// 边界：返回原始值 -> 忽略
function Weird2() { this.a = 1; return 42; }
console.log(myNew(Weird2)); // Weird2 { a: 1 }

// 边界：箭头函数不可 new
const arrow = () => {};
try { myNew(arrow); } catch (e) { console.log(e.message); } // ... is not a constructor

function myInstanceof(left, right) {
  // 右侧必须是可调用对象
  if (typeof right !== 'function') {
    throw new TypeError('Right-hand side of instanceof is not callable');
  }
  // 边界：左侧是原始值（含 null）直接 false，不抛错 —— 与原生行为一致
  if (left === null || (typeof left !== 'object' && typeof left !== 'function')) {
    return false;
  }

  const prototype = right.prototype;
  if (prototype === null || (typeof prototype !== 'object' && typeof prototype !== 'function')) {
    throw new TypeError('Function has non-object prototype in instanceof check');
  }

  let proto = Object.getPrototypeOf(left); // 标准取原型方式，优于 left.__proto__
  while (proto !== null) {                 // 一直找到原型链尽头 Object.prototype -> null
    if (proto === prototype) return true;
    proto = Object.getPrototypeOf(proto);
  }
  return false;
}

console.log(myInstanceof([], Array));          // true
console.log(myInstanceof([], Object));         // true（原型链上有 Object.prototype）
console.log(myInstanceof(1, Number));          // false（原始值）
console.log(myInstanceof(new Number(1), Number)); // true（包装对象）
console.log(myInstanceof(null, Object));       // false
console.log(myInstanceof(() => {}, Function)); // true（函数也是对象）

class A {}
class B extends A {}
console.log(myInstanceof(new B(), A));         // true（继承链）

// 边界：原型被改写后 instanceof 会「说谎」
function C() {}
const c = new C();
C.prototype = {}; // 改写后，老实例的原型链上已经没有新的 C.prototype
console.log(myInstanceof(c, C));               // false

/**
 * @param {object|null} proto 新对象的原型
 * @param {object} [descriptors] 属性描述符对象，同 Object.defineProperties 的第二参
 */
function myObjectCreate(proto, descriptors) {
  if (proto !== null && typeof proto !== 'object' && typeof proto !== 'function') {
    throw new TypeError('Object prototype may only be an Object or null');
  }

  let obj;
  if (proto === null) {
    // 边界：F.prototype = null 时 new F() 的原型会回退到 Object.prototype，得不到真正的「无原型对象」。
    // 只有对象字面量里的 __proto__ 才能制造 null 原型（这是语法特性，不是普通属性赋值）
    obj = { __proto__: null };
  } else {
    // 借用「new 时实例原型 = 构造函数 prototype」这一机制
    function F() {}
    F.prototype = proto;
    obj = new F();
  }

  if (descriptors !== undefined) {
    Object.defineProperties(obj, descriptors); // 复用原生，题目考的是原型链那步
  }
  return obj;
}

const animal = { speak() { return `${this.name} 在叫`; } };

const dog = myObjectCreate(animal, {
  name: { value: '旺财', writable: true, enumerable: true, configurable: true },
});
console.log(dog.speak());                              // 旺财 在叫
console.log(Object.getPrototypeOf(dog) === animal);    // true

// 边界：null 原型，可当纯净字典用（不怕 key 撞上 toString/constructor）
const dict = myObjectCreate(null);
dict.toString = '我是数据，不是方法';
console.log(dict.toString, Object.getPrototypeOf(dict)); // 我是数据，不是方法 null

// 边界：非法原型
try { myObjectCreate(1); } catch (e) { console.log(e.message); }

/**
 * 深拷贝：支持循环引用、Date/RegExp/Map/Set、Symbol 键、原型链、getter
 * @param {any} value
 * @param {WeakMap} cache 已拷贝对象的映射，用于处理循环引用（WeakMap 弱引用，不阻碍 GC）
 */
function deepClone(value, cache = new WeakMap()) {
  // 1) 原始值（含 null、undefined、Symbol、BigInt）与函数：直接返回引用
  //    typeof function === 'function'，会走到这里，即函数按引用共享 —— 这是业界通用取舍
  if (value === null || typeof value !== 'object') return value;

  // 2) 循环引用：已经拷过就直接复用，避免无限递归
  if (cache.has(value)) return cache.get(value);

  // 3) 特殊内置对象
  if (value instanceof Date) return new Date(value.getTime());
  if (value instanceof RegExp) {
    const re = new RegExp(value.source, value.flags);
    re.lastIndex = value.lastIndex; // 带 g/y 标志时 lastIndex 是状态的一部分，别漏
    return re;
  }
  if (value instanceof Error) {
    // 注意：假定构造签名为 (message)。构造签名不同的自定义 Error 子类
    // （如 class HttpError extends Error { constructor(status, msg) }）会重建出错，
    // 业务里有这类子类时应退化为 new Error(message) 或按类型加白名单处理
    const err = new value.constructor(value.message);
    err.stack = value.stack;
    if ('cause' in value) err.cause = deepClone(value.cause, cache);
    return err;
  }
  // 包装对象 new String/Number/Boolean
  if (value instanceof String || value instanceof Number || value instanceof Boolean) {
    return new value.constructor(value.valueOf());
  }
  // 二进制类型
  if (value instanceof ArrayBuffer) return value.slice(0);
  if (ArrayBuffer.isView(value)) {
    // TypedArray / DataView：拷贝底层 buffer，保持视图类型
    return new value.constructor(deepClone(value.buffer, cache), value.byteOffset, value.length ?? value.byteLength);
  }
  // WeakMap/WeakSet 无法枚举，理论上不可深拷贝
  if (value instanceof WeakMap || value instanceof WeakSet) {
    throw new TypeError('WeakMap / WeakSet 无法被深拷贝（内容不可枚举）');
  }

  // 4) 创建同类型的空壳，保持原型链（自定义类的实例拷贝后仍是该类实例）
  let clone;
  if (Array.isArray(value)) clone = [];
  else if (value instanceof Map) clone = new Map();
  else if (value instanceof Set) clone = new Set();
  else clone = Object.create(Object.getPrototypeOf(value)); // null 原型也能正确处理

  // 5) 关键：先入缓存再递归子属性，否则自引用会死循环
  cache.set(value, clone);

  // 6) Map / Set 的内容不在自有属性里，要单独搬
  if (value instanceof Map) {
    for (const [k, v] of value) clone.set(deepClone(k, cache), deepClone(v, cache)); // 键也要深拷贝
  }
  if (value instanceof Set) {
    for (const v of value) clone.add(deepClone(v, cache));
  }

  // 7) Reflect.ownKeys 同时拿到字符串键和 Symbol 键（含不可枚举的）
  for (const key of Reflect.ownKeys(value)) {
    const desc = Object.getOwnPropertyDescriptor(value, key);
    if ('value' in desc) {
      // 数据属性：递归拷贝值，并保留 writable/enumerable/configurable
      Object.defineProperty(clone, key, { ...desc, value: deepClone(desc.value, cache) });
    } else {
      // 访问器属性：原样搬运 getter/setter，不去触发它（触发可能有副作用）
      Object.defineProperty(clone, key, desc);
    }
  }

  return clone;
}

const obj = {
  num: 1,
  str: 'a',
  nil: null,
  und: undefined,
  big: 10n,
  [Symbol('sk')]: 'symbol 键',
  date: new Date('2024-01-01'),
  reg: /ab+c/gi,
  arr: [1, [2, [3]]],
  map: new Map('k', { deep: true }),
  set: new Set([1, { x: 1 }]),
  fn() { return 1; },
};
obj.self = obj;        // 循环引用
obj.arr.push(obj.arr); // 数组自引用

const copy = deepClone(obj);
console.log(copy.self === copy);              // true  循环引用被正确重建（而不是 obj）
console.log(copy.self === obj);               // false
console.log(copy.arr[2] === copy.arr);        // true
console.log(copy.date instanceof Date, +copy.date === +obj.date); // true true
console.log(copy.reg.source === obj.reg.source, copy.reg !== obj.reg); // true true
console.log(copy.map.get('k') !== obj.map.get('k')); // true 深层也断开
console.log('und' in copy, copy.big);         // true 10n（undefined 键被保留）

// 自定义类的原型保持
class Node2 { constructor(v) { this.v = v; } getV() { return this.v; } }
const n = deepClone(new Node2(9));
console.log(n instanceof Node2, n.getV());    // true 9

const copy = structuredClone(obj); // 一行搞定，性能通常优于手写递归

class EventEmitter {
  #events = new Map(); // 事件名 -> Set<listener>，用 Map 支持 Symbol 事件名

  /** 订阅 */
  on(event, listener) {
    if (typeof listener !== 'function') throw new TypeError('listener 必须是函数');
    if (!this.#events.has(event)) this.#events.set(event, new Set());
    this.#events.get(event).add(listener);
    return this; // 支持链式调用
  }

  /** 只订阅一次 */
  once(event, listener) {
    if (typeof listener !== 'function') throw new TypeError('listener 必须是函数');

    const wrapper = (...args) => {
      // 先解绑再执行：万一 listener 内部抛错，也不会留下永不触发的僵尸监听
      this.off(event, wrapper);
      listener.apply(this, args);
    };
    // 关键：把原函数挂在包装函数上，这样 off(event, 原函数) 也能解绑
    wrapper.listener = listener;

    return this.on(event, wrapper);
  }

  /** 取消订阅：不传 listener 清空该事件，不传 event 清空全部 */
  off(event, listener) {
    if (event === undefined) { this.#events.clear(); return this; }
    if (listener === undefined) { this.#events.delete(event); return this; }

    const set = this.#events.get(event);
    if (!set) return this;

    if (!set.delete(listener)) {
      // 没直接命中，说明可能是 once 包装过的，按 wrapper.listener 反查
      for (const fn of set) {
        if (fn.listener === listener) { set.delete(fn); break; }
      }
    }
    if (set.size === 0) this.#events.delete(event); // 及时清理空集合，防止 Map 无限膨胀
    return this;
  }

  /** 发布 */
  emit(event, ...args) {
    const set = this.#events.get(event);
    if (!set || set.size === 0) return false; // 对齐 Node：无监听者返回 false

    // 关键：先快照。否则回调里 on/off 会改动正在遍历的 Set，导致漏触发或死循环
    for (const listener of [...set]) {
      try {
        listener.apply(this, args);
      } catch (err) {
        // 单个监听器抛错不应中断其余监听器
        queueMicrotask(() => { throw err; }); // 异步抛到全局，保留错误可见性
      }
    }
    return true;
  }

  /** 监听器数量，测试和排查泄漏时很有用 */
  listenerCount(event) {
    return this.#events.get(event)?.size ?? 0;
  }
}

const bus = new EventEmitter();

const onMsg = (a, b) => console.log('on:', a, b);
bus.on('msg', onMsg);
bus.once('msg', (a) => console.log('once:', a));

bus.emit('msg', 1, 2); // on: 1 2 / once: 1
bus.emit('msg', 3, 4); // on: 3 4（once 已自动解绑）

bus.off('msg', onMsg);
console.log(bus.emit('msg'), bus.listenerCount('msg')); // false 0

// 边界：用原函数解绑 once
const fn = () => console.log('never');
bus.once('x', fn).off('x', fn);
console.log(bus.emit('x')); // false —— 正确解绑

// 边界：回调中动态增删监听器不会导致漏触发
const e2 = new EventEmitter();
e2.on('a', () => { e2.on('a', () => console.log('新增的不应本轮触发')); console.log('第一个'); });
e2.on('a', () => console.log('第二个'));
e2.emit('a'); // 第一个 / 第二个

/** 被观察者：直接持有观察者列表并主动通知 */
class Subject {
  #observers = new Set();
  attach(observer) { this.#observers.add(observer); return this; }
  detach(observer) { this.#observers.delete(observer); return this; }
  notify(data) { for (const o of [...this.#observers]) o.update(data); }
}

/** 观察者：必须实现 update 接口 */
class Observer {
  constructor(name) { this.name = name; }
  update(data) { console.log(`${this.name} 收到:`, data); }
}

const subject = new Subject();
const o1 = new Observer('观察者A');
subject.attach(o1).attach(new Observer('观察者B'));
subject.notify({ price: 100 }); // 两个观察者都收到
subject.detach(o1);
subject.notify({ price: 200 }); // 只有 B 收到

/** 解法一：递归（最直观，能自然支持 depth） */
function flatRecursive(arr, depth = 1) {
  const result = [];
  for (const item of arr) {
    if (Array.isArray(item) && depth > 0) {
      result.push(...flatRecursive(item, depth - 1)); // depth 每下一层减 1
    } else {
      result.push(item);
    }
  }
  return result;
}

/** 解法二：reduce + 递归（写法最短，面试常写这个） */
const flatReduce = (arr, depth = 1) =>
  depth > 0
    ? arr.reduce(
        (acc, cur) => acc.concat(Array.isArray(cur) ? flatReduce(cur, depth - 1) : cur),
        []
      )
    : arr.slice();

/** 解法三：迭代 + 显式栈（无递归，超深数组也不会爆栈，是本题的最优解） */
function flatStack(arr, depth = Infinity) {
  // 栈里存 [元素, 剩余深度]
  const stack = arr.map((item) => [item, depth]);
  const result = [];

  while (stack.length > 0) {
    const [item, d] = stack.pop(); // 从尾部取，所以结果是逆序的
    if (Array.isArray(item) && d > 0) {
      // 展开后压回栈，深度 -1
      for (const sub of item) stack.push([sub, d - 1]);
    } else {
      result.push(item);
    }
  }
  return result.reverse(); // 最后统一反转，恢复原始顺序
}

/** 解法四：无限展开时的取巧写法（仅适用于纯数字/字符串数组，面试当彩蛋讲） */
const flatByToString = (arr) => arr.toString().split(',').map(Number);
// 缺陷：所有元素被转成字符串（null -> ''、undefined -> ''、对象 -> [object Object]），
// 只在「纯数字数组 + 无嵌套对象」时可用，绝不能当正解交上去

/** 对照：原生 API */
// arr.flat(Infinity)  —— ES2019，会跳过空位（holes）
// arr.flat()          —— 默认 depth = 1

const a = [1, [2, [3, [4, [5]]]], 6];

console.log(flatRecursive(a));           // [1, 2, [3,[4,[5]]], 6]  默认 depth=1
console.log(flatRecursive(a, Infinity)); // [1,2,3,4,5,6]
console.log(flatReduce(a, 2));           // [1, 2, 3, [4,[5]], 6]
console.log(flatStack(a));               // [1,2,3,4,5,6]
console.log(a.flat(Infinity));           // [1,2,3,4,5,6] 原生对照

// 边界
console.log(flatStack([]));              // []
console.log(flatStack([[], [[]], 1]));   // [1] 全空数组被抹平
console.log(flatRecursive([1, 2], 0));   // [1, 2] depth=0 原样返回

// 边界：数组空位
const holes = [1, , 3];                  // 索引 1 是空位（hole），不是 undefined
console.log(holes.flat());               // [1, 3]      原生跳过空位
console.log(flatRecursive(holes));       // [1, undefined, 3]  for...of 把空位读成 undefined

// 边界：超深数组，验证栈版本不爆栈
let deep = [];
let cur = deep;
for (let i = 0; i < 100000; i++) { const next = []; cur.push(next); cur = next; }
cur.push('底部');
console.log(flatStack(deep));            // ['底部']，递归版会 RangeError
// console.log(flatRecursive(deep, Infinity)); // RangeError: Maximum call stack size exceeded

/**
 * reduce：初始值缺省时用第一个「非空位」元素做累加器
 * 用剩余参数接收 initialValue，才能区分「没传」和「传了 undefined」
 */
Array.prototype.myReduce = function (callback, ...initialValue) {
  if (this === null || this === undefined) throw new TypeError('Array.prototype.myReduce called on null or undefined');
  if (typeof callback !== 'function') throw new TypeError(`${callback} is not a function`);

  const O = Object(this);
  const len = O.length >>> 0; // 无符号右移 0：把 length 规范成 [0, 2^32-1] 的整数
  let k = 0;
  let accumulator;

  if (initialValue.length > 0) {
    accumulator = initialValue[0];
  } else {
    // 跳过前导空位，找到第一个真实存在的元素
    while (k < len && !(k in O)) k++;
    if (k >= len) throw new TypeError('Reduce of empty array with no initial value'); // 边界：空数组 + 无初始值
    accumulator = O[k++];
  }

  while (k < len) {
    if (k in O) accumulator = callback(accumulator, O[k], k, O); // 空位不参与迭代
    k++;
  }
  return accumulator;
};

/** map：返回等长新数组，保留空位 */
Array.prototype.myMap = function (callback, thisArg) {
  if (this === null || this === undefined) throw new TypeError('called on null or undefined');
  if (typeof callback !== 'function') throw new TypeError(`${callback} is not a function`);

  const O = Object(this);
  const len = O.length >>> 0;
  const result = new Array(len); // 预分配长度，保证返回数组与原数组等长

  for (let k = 0; k < len; k++) {
    if (k in O) { // 空位跳过：既不调用回调，结果里也保持为空位
      result[k] = callback.call(thisArg, O[k], k, O);
    }
  }
  return result;
};

/** filter：保留回调返回真值的项，结果是紧凑数组（无空位） */
Array.prototype.myFilter = function (callback, thisArg) {
  if (this === null || this === undefined) throw new TypeError('called on null or undefined');
  if (typeof callback !== 'function') throw new TypeError(`${callback} is not a function`);

  const O = Object(this);
  const len = O.length >>> 0;
  const result = [];

  for (let k = 0; k < len; k++) {
    if (k in O && callback.call(thisArg, O[k], k, O)) {
      result.push(O[k]);
    }
  }
  return result;
};

/** find：返回第一个满足条件的「元素」；findIndex 返回下标。注意：不跳过空位 */
Array.prototype.myFind = function (callback, thisArg) {
  if (this === null || this === undefined) throw new TypeError('called on null or undefined');
  if (typeof callback !== 'function') throw new TypeError(`${callback} is not a function`);

  const O = Object(this);
  const len = O.length >>> 0;

  for (let k = 0; k < len; k++) {
    const value = O[k]; // 空位读出来是 undefined，且照样调用回调（与 map/filter 不同）
    if (callback.call(thisArg, value, k, O)) return value;
  }
  return undefined; // 边界：找不到返回 undefined（findIndex 返回 -1）
};

Array.prototype.myFindIndex = function (callback, thisArg) {
  const O = Object(this);
  const len = O.length >>> 0;
  for (let k = 0; k < len; k++) {
    if (callback.call(thisArg, O[k], k, O)) return k;
  }
  return -1;
};

/** 附赠：用 reduce 实现 map / filter，用来展示对 reduce 的理解 */
const mapByReduce = (arr, fn) => arr.reduce((acc, cur, i, src) => (acc.push(fn(cur, i, src)), acc), []);
const filterByReduce = (arr, fn) => arr.reduce((acc, cur, i, src) => (fn(cur, i, src) && acc.push(cur), acc), []);

console.log([1, 2, 3, 4].myReduce((a, b) => a + b));        // 10（无初始值）
console.log([1, 2, 3, 4].myReduce((a, b) => a + b, 100));   // 110
console.log([].myReduce((a, b) => a + b, 0));               // 0（空数组 + 初始值，正常）
try { [].myReduce((a, b) => a + b); } catch (e) { console.log(e.message); } // Reduce of empty array...
console.log([1, 2].myReduce((a, b) => a + b, undefined));   // NaN —— 正确识别「显式传了 undefined」

console.log([1, 2, 3].myMap((x) => x * 2));                 // [2, 4, 6]
console.log([1, 2, 3, 4].myFilter((x) => x % 2 === 0));     // [2, 4]
console.log([1, 5, 9].myFind((x) => x > 4));                // 5
console.log([1, 5, 9].myFind((x) => x > 100));              // undefined
console.log([1, 5, 9].myFindIndex((x) => x > 4));           // 1

// 边界：空位行为对齐原生
const holes = [1, , 3];
console.log(holes.myMap((x) => x * 2));  // [2, <1 empty item>, 6] 空位保留，回调未被调用
console.log(holes.myFilter(() => true)); // [1, 3]              空位被过滤掉
console.log(holes.myFind((x) => x === undefined)); // undefined，但回调确实被调用了