JS

// 防抖
function debounce(fn, delay) {
  let timer;
  return function (...args) {
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(this, args), delay);
  };
}
// 节流
function throttle(fn, interval) {
  let last = 0;
  return function (...args) {
    const now = Date.now();
    if (now - last >= interval) {
      last = now;
      fn.apply(this, args);
    }
  };
}

class MyPromise {
  constructor(executor) {
    this.state = 'pending';
    this.value = undefined;
    this.callbacks = [];

    const resolve = (value) => {
      if (this.state !== 'pending') return;
      this.state = 'fulfilled';
      this.value = value;
      this.callbacks.forEach(cb => cb.onFulfilled(value));
    };
    const reject = (reason) => {
      if (this.state !== 'pending') return;
      this.state = 'rejected';
      this.value = reason;
      this.callbacks.forEach(cb => cb.onRejected(reason));
    };
    try { executor(resolve, reject); } catch (e) { reject(e); }
  }

  then(onFulfilled, onRejected) {
    return new MyPromise((resolve, reject) => {
      const handle = () => {
        const cb = this.state === 'fulfilled' ? onFulfilled : onRejected;
        if (!cb) {
          (this.state === 'fulfilled' ? resolve : reject)(this.value);
          return;
        }
        try {
          const result = cb(this.value);
          result instanceof MyPromise ? result.then(resolve, reject) : resolve(result);
        } catch (e) { reject(e); }
      };
      if (this.state === 'pending') {
        this.callbacks.push({ onFulfilled: handle, onRejected: handle });
      } else {
        setTimeout(handle); // 微任务模拟（用 setTimeout 近似）
      }
    });
  }
}

Function.prototype.myBind = function (context, ...args1) {
  const fn = this;
  return function (...args2) {
    return fn.apply(context, [...args1, ...args2]);
  };
};

Function.prototype.softBind = function (context, ...args1) {
  const fn = this;
  return function (...args2) {
    const ctx = (!this || this === globalThis) ? context : this;
    return fn.apply(ctx, [...args1, ...args2]);
  };
};

function pMap(arr, mapper, concurrency = Infinity) {
  return new Promise((resolve, reject) => {
    const results = new Array(arr.length);
    let running = 0;
    let index = 0;

    function next() {
      if (index === arr.length && running === 0) {
        return resolve(results);
      }
      while (running < concurrency && index < arr.length) {
        const i = index++;
        running++;
        Promise.resolve(mapper(arr[i], i))
          .then(val => { results[i] = val; })
          .catch(reject)
          .finally(() => { running--; next(); });
      }
    }
    next();
  });
}
// 使用：pMap(urls, url => fetch(url), 3).then(console.log)

// 方法1：Array.from（推荐）
const arr = Array.from(arrayLike);

// 方法2：展开运算符
const arr = [...arrayLike];

// 方法3：Array.prototype.slice.call
const arr = [].slice.call(arrayLike);
const arr = Array.prototype.slice.call(arrayLike);

// 方法4：for 循环 + push（最简单直接）
const arr = [];
for (let i = 0; i < arrayLike.length; i++) arr.push(arrayLike[i]);

// 要填充，先用 fill
Array(100).fill(0).map(x => 1); // [1, 1, 1, ...]
// 或用 Array.from
Array.from({ length: 100 }, () => 1);

// 方案1：key=val1&key=val2（最常见，服务端框架大多支持）
?tags=js&tags=html&tags=css
// URLSearchParams 读取时会合并为数组

// 方案2：逗号分隔
?tags=js,html,css

// 方案3：JSON 编码
?data=encodeURIComponent(JSON.stringify([1,2,3]))

// 方案4：带下标的参数
?arr[0]=1&arr[1]=2&arr[2]=3

// URLSearchParams 获取
const params = new URLSearchParams(location.search);
params.getAll('tags'); // ['js', 'html', 'css']

// 从右到左执行（pipe 是左到右）
function compose(...fns) {
  return function (value) {
    return fns.reduceRight((acc, fn) => fn(acc), value);
  };
}

// 用法
const double = x => x * 2;
const add1 = x => x + 1;
const compute = compose(double, add1);
compute(5); // double(add1(5)) = 12

// pipe（从左到右）
const pipe = (...fns) => value => fns.reduce((acc, fn) => fn(acc), value);

function get(obj, path, defaultValue) {
  const keys = Array.isArray(path) ? path : path.replace(/\[(\d+)\]/g, '.$1').split('.');
  let result = obj;
  for (const key of keys) {
    if (result == null) return defaultValue;
    result = result[key];
  }
  return result === undefined ? defaultValue : result;
}
// get({a: {b: [0, {c: 1}]}}, 'a.b[1].c') → 1

const name = user?.profile?.name; // user 或 profile 为 null/undefined 时不报错
// 访问数组
const first = arr?.[0];
// 调用函数
const result = obj.method?.();
// 动态属性
const val = obj?.['key' + suffix];

function cloneDeep(obj, map = new WeakMap()) {
  if (obj === null || typeof obj !== 'object') return obj;

  // 处理循环引用
  if (map.has(obj)) return map.get(obj);

  // 处理 Date、RegExp 等特殊对象
  if (obj instanceof Date) return new Date(obj);
  if (obj instanceof RegExp) return new RegExp(obj.source, obj.flags);
  if (obj instanceof Map) {
    const copy = new Map();
    map.set(obj, copy);
    obj.forEach((v, k) => copy.set(k, cloneDeep(v, map)));
    return copy;
  }
  if (obj instanceof Set) {
    const copy = new Set();
    map.set(obj, copy);
    obj.forEach(v => copy.add(cloneDeep(v, map)));
    return copy;
  }

  const result = Array.isArray(obj) ? [] : Object.create(Object.getPrototypeOf(obj));
  map.set(obj, result);
  Reflect.ownKeys(obj).forEach(key => {
    result[key] = cloneDeep(obj[key], map);
  });
  return result;
}

// flatMap = map + flat(1)
function flatMap(arr, fn) {
  return arr.reduce((acc, item, index) => {
    const value = fn(item, index, arr);
    return acc.concat(Array.isArray(value) ? flatMap(value, x => x) : [value]);
  }, []);
}

// 简单版
function flatMap(arr, fn) {
  return arr.reduce((acc, item, index) => acc.concat(fn(item, index, arr)), []);
}
// 或
Array.prototype.flatMap = function (fn) {
  return this.map(fn).flat(1);
};

// 前端裁剪核心步骤
async function cropImage(file, cropArea) {
  // 1. 读取文件
  const img = new Image();
  img.src = URL.createObjectURL(file);
  await new Promise(r => img.onload = r);

  // 2. 在 Canvas 上绘制裁剪区域
  const canvas = document.createElement('canvas');
  canvas.width = cropArea.width;
  canvas.height = cropArea.height;
  const ctx = canvas.getContext('2d');
  ctx.drawImage(img, cropArea.x, cropArea.y, cropArea.width, cropArea.height, 0, 0, cropArea.width, cropArea.height);

  // 3. 导出为 Blob
  return new Promise(resolve => canvas.toBlob(resolve, 'image/jpeg', 0.9));
}
// 库：react-cropper、cropperjs

// 自动执行 Generator 的函数（co 库的核心）
function asyncToGenerator(generatorFunc) {
  return function (...args) {
    const gen = generatorFunc.apply(this, args);
    return new Promise((resolve, reject) => {
      function step(key, arg) {
        let result;
        try {
          result = gen[key](arg);
        } catch (error) {
          return reject(error);
        }
        const { value, done } = result;
        if (done) return resolve(value);
        Promise.resolve(value).then(
          val => step('next', val),
          err => step('throw', err)
        );
      }
      step('next');
    });
  };
}

async function asyncAll(promises) {
  const results = [];
  for (let i = 0; i < promises.length; i++) {
    results[i] = await promises[i];
  }
  return results;
}
// 但这样是串行的！要并行：
async function asyncAll(promises) {
  const results = [];
  // 同时启动所有 promise，然后 await 结果
  const pending = promises.map((p, i) =>
    Promise.resolve(p).then(v => { results[i] = v; })
  );
  await Promise.all(pending);
  return results;
}

const results = await Promise.allSettled([p1, p2, p3]);
// results = [
//   { status: 'fulfilled', value: 1 },
//   { status: 'rejected', reason: Error('failed') },
//   { status: 'fulfilled', value: 3 },
// ]

class LRUCache {
  constructor(capacity) {
    this.capacity = capacity;
    this.cache = new Map();
  }

  get(key) {
    if (!this.cache.has(key)) return -1;
    const value = this.cache.get(key);
    this.cache.delete(key);
    this.cache.set(key, value); // 移到末尾（最近使用）
    return value;
  }

  put(key, value) {
    if (this.cache.has(key)) this.cache.delete(key);
    this.cache.set(key, value);
    if (this.cache.size > this.capacity) {
      // Map 的 keys() 返回插入顺序，第一个是最不常用的
      this.cache.delete(this.cache.keys().next().value);
    }
  }
}

Promise.myRace = function (promises) {
  return new Promise((resolve, reject) => {
    for (const p of promises) {
      Promise.resolve(p).then(resolve, reject);
    }
  });
};

// 加超时控制的 race（常见场景）
function raceWithTimeout(promises, timeout) {
  return Promise.race([
    ...promises,
    new Promise((_, reject) => setTimeout(() => reject('timeout'), timeout))
  ]);
}

function myNew(constructor, ...args) {
  const obj = Object.create(constructor.prototype);
  const result = constructor.apply(obj, args);
  return result instanceof Object ? result : obj;
}

// ES2021+：replaceAll
'hello hello'.replaceAll('hello', 'hi'); // 'hi hi'

// 正则 + g 标志（通用）
'hello hello'.replace(/hello/g, 'hi');

// split + join（不用正则时推荐，兼容性好）
'hello hello'.split('hello').join('hi');

// 特殊字符需 escape：replace(/[.*+?^${}()|[\]\\]/g, '\\$&')

// 1. 原型链继承（ES5）
function Parent() { this.name = 'parent'; }
Parent.prototype.say = function () { console.log(this.name); };
function Child() { Parent.call(this); }  // 继承实例属性
Child.prototype = Object.create(Parent.prototype);  // 继承原型方法
Child.prototype.constructor = Child;

// 2. ES6 Class
class Parent {
  constructor() { this.name = 'parent'; }
  say() { console.log(this.name); }
}
class Child extends Parent {
  constructor() {
    super(); // 调用 parent constructor
  }
}
// extends + super 本质上是基于原型链的语法糖

function once(fn) {
  let called = false, result;
  return function (...args) {
    if (!called) {
      called = true;
      result = fn.apply(this, args);
    }
    return result;
  };
}
// 使用场景：单例初始化、事件处理只执行一次

function isPlainObject(obj) {
  if (typeof obj !== 'object' || obj === null) return false;
  // 原型为 null 或 constructor 的 prototype 就是 obj 自身
  const proto = Object.getPrototypeOf(obj);
  if (proto === null) return true;
  const Ctor = Object.prototype.hasOwnProperty.call(proto, 'constructor') && proto.constructor;
  return typeof Ctor === 'function' && Ctor instanceof Ctor &&
    Function.prototype.toString.call(Ctor) === Function.prototype.toString.call(Object);
}
// Lodash 的 isPlainObject 核心逻辑

// sum(1)(2)(3)() = 6 或 sum(1, 2, 3) = 6 或 sum(1)(2)(3) = 6

// 方案1：柯里化 + 空括号终止
function sum(...args1) {
  let total = args1.reduce((a, b) => a + b, 0);
  return function next(...args2) {
    if (args2.length === 0) return total;
    total += args2.reduce((a, b) => a + b, 0);
    return next;
  };
}
// sum(1)(2)(3)() → 6

// 方案2：利用 valueOf / toString
function sum(a) {
  function f(b) { return sum(a + b); }
  f.valueOf = () => a;
  f.toString = () => String(a);
  return f;
}
// +sum(1)(2)(3) → 6

// 这个会冻结整个浏览器/进程！仅在极度特殊场景用
function sleep(ms) {
  const start = Date.now();
  while (Date.now() - start < ms) {} // 自旋等待，不推荐
}

// 正确做法：使用异步
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}
// await sleep(1000);
// 或 Atomics.wait（SharedArrayBuffer 场景）

function parseQuery(url) {
  const params = {};
  const search = url.includes('?') ? url.split('?')[1] : url;
  if (!search) return params;
  for (const [key, val] of new URLSearchParams(search)) {
    if (params.hasOwnProperty(key)) {
      params[key] = [].concat(params[key], val);
    } else {
      params[key] = val;
    }
  }
  return params;
}
// parseQuery('?a=1&b=2&a=3') → {a: ['1', '3'], b: '2'}

// URL API 一行写法
const qs = Object.fromEntries(new URL(url).searchParams);

const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

async function demo() {
  console.log('开始');
  await sleep(2000);
  console.log('2秒后');
}

function sample(arr) {
  const index = Math.floor(Math.random() * arr.length);
  return arr[index];
}

// 取多个不重复元素
function sampleSize(arr, n) {
  const shuffled = arr.slice().sort(() => Math.random() - 0.5);
  return shuffled.slice(0, n);
}

function encodeQuery(params) {
  const searchParams = new URLSearchParams();
  for (const [key, value] of Object.entries(params)) {
    if (Array.isArray(value)) {
      value.forEach(v => searchParams.append(key, v));
    } else {
      searchParams.set(key, value);
    }
  }
  return searchParams.toString();
}
// encodeQuery({a: 1, b: [2, 3]}) → 'a=1&b=2&b=3'

// 手动方式
function encodeQuery(params) {
  return Object.entries(params)
    .map(([k, v]) => [].concat(v).map(val => `${encodeURIComponent(k)}=${encodeURIComponent(val)}`).join('&'))
    .join('&');
}

// 递归版
function flatten(arr, depth = Infinity) {
  return depth > 0
    ? arr.reduce((acc, item) => acc.concat(Array.isArray(item) ? flatten(item, depth - 1) : item), [])
    : arr.slice();
}

// 迭代版（栈）
function flatten(arr) {
  const result = [];
  const stack = [...arr];
  while (stack.length) {
    const next = stack.pop();
    if (Array.isArray(next)) {
      stack.push(...next);
    } else {
      result.unshift(next);
    }
  }
  return result;
}

// 原生：arr.flat(depth) 或 arr.flat(Infinity)

// Set（最简单，不能去重对象）
const unique = arr => [...new Set(arr)];

// reduce + includes
const unique = arr => arr.reduce((acc, cur) => acc.includes(cur) ? acc : [...acc, cur], []);

// filter + indexOf
const unique = arr => arr.filter((item, index) => arr.indexOf(item) === index);

// 对象数组去重（按某个字段）
const uniqueBy = (arr, key) => [...new Map(arr.map(item => [item[key], item])).values()];

// Fisher-Yates（Knuth）洗牌算法
function shuffle(arr) {
  const result = arr.slice();
  for (let i = result.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [result[i], result[j]] = [result[j], result[i]];
  }
  return result;
}
// 时间复杂度 O(n)，公平随机

const reverse = str => str.split('').reverse().join('');

// 或用扩展运算符
const reverse = str => [...str].reverse().join('');

// for 循环
function reverse(str) {
  let result = '';
  for (let i = str.length - 1; i >= 0; i--) result += str[i];
  return result;
}

const input = document.querySelector('input[type=file]');
input.addEventListener('change', (e) => {
  const file = e.target.files[0];

  // 1. FileReader 读文本
  const reader = new FileReader();
  reader.onload = () => console.log(reader.result);
  reader.readAsText(file); // 文本

  // 2. 读为 ArrayBuffer
  reader.readAsArrayBuffer(file);

  // 3. 读为 Data URL（Base64 预览）
  reader.readAsDataURL(file);

  // 4. 不读取，直接使用 Blob/File 对象
  const url = URL.createObjectURL(file); // 预览图片等
});

function merge(target, ...sources) {
  for (const source of sources) {
    for (const key of Object.keys(source)) {
      if (isPlainObject(source[key]) && isPlainObject(target[key])) {
        merge(target[key], source[key]);
      } else if (Array.isArray(source[key]) && Array.isArray(target[key])) {
        // 数组浅合并（Lodash 默认行为），也可改为递归
        target[key] = source[key];
      } else if (source[key] !== undefined) {
        target[key] = source[key];
      }
    }
  }
  return target;
}

Promise.myAny = function (promises) {
  let count = 0;
  const errors = new Array(promises.length);
  return new Promise((resolve, reject) => {
    promises.forEach((p, i) => {
      Promise.resolve(p).then(resolve, err => {
        errors[i] = err;
        count++;
        if (count === promises.length) {
          reject(new AggregateError(errors, 'All promises were rejected'));
        }
      });
    });
  });
};

Promise.myAll = function (promises) {
  return new Promise((resolve, reject) => {
    const results = new Array(promises.length);
    let count = 0;
    promises.forEach((p, i) => {
      Promise.resolve(p).then(value => {
        results[i] = value;
        count++;
        if (count === promises.length) resolve(results);
      }, reject);
    });
  });
};

// falsy: false, 0, '', null, undefined, NaN
const arr = [0, 1, false, '', 'hello', null, undefined, NaN];
const truthy = arr.filter(Boolean);
// [1, 'hello']

// 方法1：Array.from（推荐）
Array.from({ length: 100 }, () => 0);

// 方法2：fill
new Array(100).fill(0);

// 方法3：扩展 + map
[...Array(100)].map(() => 0);

// 方法4：循环
const arr = [];
for (let i = 0; i < 100; i++) arr.push(0);

const arr = [];
const [a = 3, ...c] = arr;
// a = 3, c = []

const arr2 = [1, 2, 3, 4];
const [a2 = 3, ...c2] = arr2;
// a2 = 1, c2 = [2, 3, 4]

// 基本类型
arr.includes(value);          // ES2016，返回 boolean
arr.indexOf(value) !== -1;    // ES5

// 对象数组（按条件）
arr.some(item => item.id === targetId);
arr.find(item => item.id === targetId) !== undefined;

str.includes(substr);              // ES2015，返回 boolean
str.indexOf(substr) !== -1;        // ES1，返回位置
/pattern/.test(str);               // 正则匹配
str.match(/pattern/);              // 返回匹配结果
str.startsWith(substr);            // 是否以某串开头
str.endsWith(substr);              // 是否以某串结尾

Array.isArray(value);  // 最佳选择，能跨 iframe
// 其他方法（有局限性）
value instanceof Array;  // 跨 iframe 失效
Object.prototype.toString.call(value) === '[object Array]';  // 也可靠
Array.isArray = (arg) => Object.prototype.toString.call(arg) === '[object Array]';

Object.defineProperty(obj, 'name', {
  value: 'John',
  writable: false,       // 是否可写
  enumerable: true,      // 是否可枚举（for...in、Object.keys）
  configurable: false,   // 是否可配置/删除
  get() { return this._name; },  // getter
  set(val) { this._name = val; }  // setter
});

// Node.js 的 util.inherits 也类似于这个
function inherits(Child, Parent) {
  Child.prototype = Object.create(Parent.prototype);
  Child.prototype.constructor = Child;
  //Node legacy hack: 如果 Parent 是 Error 等特殊类型
  // 通常在 ES5 时代用于简化的 "寄生组合继承"
}

// 解决方案
Math.abs(a - b) < Number.EPSILON;  // 同 Number.EPSILON 比较
(a * 10 + b * 10) / 10;             // 转为整数运算（需适用的情况）
a.toFixed(10) === b.toFixed(10);    // 限定位数比较

// 纯函数
const add = (a, b) => a + b;

// 非纯函数（有副作用）
let count = 0;
const increment = () => ++count;

// 正则
function formatNumber(num) {
  return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
}

// Intl.NumberFormat（原生）
new Intl.NumberFormat('en-US').format(1234567);  // '1,234,567'

// toLocaleString
(1234567).toLocaleString('en-US');  // '1,234,567'

function deepEqual(a, b) {
  if (a === b) return true;
  if (a == null || b == null || typeof a !== 'object' || typeof b !== 'object') {
    return a !== a && b !== b; // NaN 比较
  }
  if (a.constructor !== b.constructor) return false;

  if (a instanceof Date) return a.getTime() === b.getTime();
  if (a instanceof RegExp) return a.toString() === b.toString();

  const keysA = Object.keys(a);
  const keysB = Object.keys(b);
  if (keysA.length !== keysB.length) return false;

  return keysA.every(key => deepEqual(a[key], b[key]));
}

// Object.is polyfill
Object.defineProperty(Object, 'is', {
  value(x, y) {
    return x === y ? (x !== 0 || 1 / x === 1 / y) : x !== x && y !== y;
  }
});

Object.entries(obj);  // {a: 1, b: 2} → [['a', 1], ['b', 2]]

// 手动实现不适用原生
function toEntries(obj) {
  return Object.keys(obj).map(key => [key, obj[key]]);
}

// 反向：Object.fromEntries(entries) → 对象

// 1. Object.defineProperty（Vue2）
let _val = obj.prop;
Object.defineProperty(obj, 'prop', {
  get() { return _val; },
  set(val) { console.log('changed'); _val = val; }
});

// 2. Proxy（Vue3）
const proxy = new Proxy(obj, {
  set(target, key, value) {
    console.log(`${key} changed to ${value}`);
    target[key] = value;
    return true;
  }
});

// 3. getter/setter（class 内定义）

const asyncIterable = {
  async *[Symbol.asyncIterator]() {
    for (let i = 0; i < 3; i++) {
      await sleep(1000);
      yield i;
    }
  }
};
for await (const value of asyncIterable) {
  console.log(value); // 每秒输出一次
}
// 场景：分页 API、流式数据、Node.js Readable Stream

// 方法1：Math.random + toString（常用、简短）
Math.random().toString(36).substring(2, 10); // 8 位

// 方法2：crypto.getRandomValues（更安全）
Array.from(crypto.getRandomValues(new Uint8Array(16)), byte =>
  byte.toString(16).padStart(2, '0')
).join(''); // 32 位十六进制字符串

// 方法3：指定字符集
function randomStr(len) {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  return Array.from({ length: len }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
}

// 方法4：crypto.randomUUID()
crypto.randomUUID(); // '36b8f84d-...' 唯一的 UUID v4

Number.isInteger(value); // 最推荐，ES6

// 旧方法
typeof value === 'number' && value % 1 === 0;
Math.floor(value) === value;
parseInt(value) === value;

Number.isSafeInteger(value);
Number.MAX_SAFE_INTEGER; // 9007199254740991
// 涉及大整数的场景用 BigInt
const big = 9007199254740992n;

str.toLowerCase();  // 'Hello'.toLowerCase() → 'hello'
str.toLocaleLowerCase('tr'); // 土耳其语等特定字符映射问题

// 数组已经实现了 Iterable 接口，直接可迭代
for (const v of arr) {}

// 获取迭代器对象
const iterator = arr[Symbol.iterator]();
iterator.next(); // { value: 1, done: false }

// 如果一定要"转化"为纯迭代器（舍弃数组其他特性）
function* arrayToGenerator(arr) { yield* arr; }

// call 实现
Function.prototype.myCall = function (context, ...args) {
  context = context == null ? globalThis : Object(context);
  const key = Symbol('fn');
  context[key] = this;
  const result = context[key](...args);
  delete context[key];
  return result;
};

// apply 实现
Function.prototype.myApply = function (context, args) {
  context = context == null ? globalThis : Object(context);
  const key = Symbol('fn');
  context[key] = this;
  const result = context[key](...args);
  delete context[key];
  return result;
};

function hasCycle(obj, seen = new WeakSet()) {
  if (obj === null || typeof obj !== 'object') return false;
  if (seen.has(obj)) return true;
  seen.add(obj);
  for (const key of Object.keys(obj)) {
    if (hasCycle(obj[key], seen)) return true;
  }
  return false;
}
// WeakSet 用弱引用，不影响 GC

// 十进制 → 二进制（字符串）
function dec2bin(dec) { return dec.toString(2); }
// 或手动
function dec2bin(dec) {
  if (dec === 0) return '0';
  let result = '';
  while (dec > 0) {
    result = (dec % 2) + result;
    dec = Math.floor(dec / 2);
  }
  return result;
}

// 二进制 → 十进制
function bin2dec(bin) { return parseInt(bin, 2); }
// 或手动
function bin2dec(bin) {
  let result = 0;
  for (let i = 0; i < bin.length; i++) {
    result = result * 2 + (+bin[i]);
  }
  return result;
}

// 1. for...in：遍历自身 + 原型链上可枚举的属性
for (const key in obj) {
  if (obj.hasOwnProperty(key)) { /* 只遍历自身属性 */ }
}

// 2. Object.keys：自身可枚举的属性名
Object.keys(obj).forEach(key => console.log(key, obj[key]));

// 3. Object.entries：自身可枚举的键值对
for (const [key, value] of Object.entries(obj)) { }

// 4. Object.values：自身可枚举的属性值
Object.values(obj).forEach(value => console.log(value));

// 5. Object.getOwnPropertyNames：自身所有属性（含不可枚举，不包含 Symbol）
// 6. Reflect.ownKeys：自身所有属性（含 Symbol 和不可枚举）

// 使用 postMessage 或 MessageChannel 实现接近 0ms 的延迟
function setImmediate(fn) {
  const channel = new MessageChannel();
  channel.port1.onmessage = fn;
  channel.port2.postMessage('');
}

// 或直接在 web worker 中使用 setImmediate polyfill
setTimeout(fn); // 不指定时间等同于 setTimeout(fn, 0)

function myInstanceOf(obj, Constructor) {
  let proto = Object.getPrototypeOf(obj);
  const prototype = Constructor.prototype;
  while (proto) {
    if (proto === prototype) return true;
    proto = Object.getPrototypeOf(proto);
  }
  return false;
}

async function foo() {
  // return promise：promise 被 resolve 包装，如果 Promise 抛出异常，异常被吞没处理时机稍晚
  return promise;

  // return await promise：await 会在 await 点时捕获异常、并在 async 函数内部
  return await promise; // 微任务稍多了一些，但能正确捕获异常栈
}

// 整数部分
Math.trunc(3.14);       // 3（ES6）
Math.floor(3.14);       // 3
Math.floor(-3.14);      // -4（注意 floor 是向下取整）
~~3.14;                 // 3（位运算取整，32位）

// 小数部分
num % 1;                // 0.14
num - Math.trunc(num);  // 0.14
String(num).split('.')[1]; // '14'（字符串方式）

function batchFn(fn) {
  let argsList = [];
  let scheduled = false;

  return function (arg) {
    argsList.push(arg);
    if (!scheduled) {
      scheduled = true;
      Promise.resolve().then(() => {
        fn(argsList);
        argsList = [];
        scheduled = false;
      });
    }
  };
}
// 在同一个微任务中多次调用的参数会批量传给 fn

function cloneDeep(obj, map = new WeakMap()) {
  if (obj === null || typeof obj !== 'object') return obj;
  if (map.has(obj)) return map.get(obj); // 遇到循环引用，直接返回已拷贝的引用

  const copy = Array.isArray(obj) ? [] : {};
  map.set(obj, copy);

  for (const key of Object.keys(obj)) {
    copy[key] = cloneDeep(obj[key], map);
  }
  return copy;
}