一、数组操作类函数手写实现

1. 高阶数组方法：reduce进阶实现

原生Array.prototype.reduce的实现存在边界条件处理不足的问题。手写版本需要完整处理以下场景：

function customReduce(arr, callback, initialValue) {
  let accumulator = initialValue !== undefined ? initialValue : arr[0];
  const startIndex = initialValue !== undefined ? 0 : 1;
  if (arr.length === 0 && initialValue === undefined) {
    throw new TypeError('Reduce of empty array with no initial value');
  }
  for (let i = startIndex; i < arr.length; i++) {
    accumulator = callback(accumulator, arr[i], i, arr);
  }
  return accumulator;
}

关键点包括：

• 初始值缺失时的自动处理
• 空数组的边界检查
• 回调参数的完整传递（累加值、当前值、索引、原数组）

2. 扁平化数组的深度控制实现

原生flat()方法的手写实现需要考虑深度参数和空位处理：

function customFlat(arr, depth = 1) {
  const result = [];
  for (const item of arr) {
    if (Array.isArray(item) && depth > 0) {
      result.push(...customFlat(item, depth - 1));
    } else {
      result.push(item);
    }
  }
  return result;
}

性能优化点：

• 使用展开运算符替代concat减少中间数组创建
• 递归深度控制防止栈溢出
• 空位处理（for...of自动跳过空位）

二、函数组合与高阶函数实现

1. 柯里化函数的类型安全实现

传统柯里化实现存在参数类型检查缺失的问题：

function safeCurry(fn, arity = fn.length) {
  return function curried(...args) {
    if (args.length >= arity) {
      return fn.apply(this, args);
    } else {
      return function(...moreArgs) {
        // 参数类型校验
        const allArgs = [...args, ...moreArgs];
        if (allArgs.some(arg => typeof arg !== 'function' && typeof fn(...allArgs.slice(0, -1)) !== 'function')) {
          throw new TypeError('Invalid argument type');
        }
        return curried.apply(this, allArgs);
      };
    }
  };
}

进阶特性：

• 自动参数长度检测
• 类型安全检查
• 支持占位符的变体实现

2. 组合函数的管道式实现

函数组合需要处理执行顺序和错误传播：

function compose(...fns) {
  return function(initialValue) {
    return fns.reduceRight((acc, fn) => {
      try {
        return fn(acc);
      } catch (error) {
        error.compositionStack = fns.map(f => f.name || 'anonymous').join(' -> ');
        throw error;
      }
    }, initialValue);
  };
}

关键设计：

• 错误堆栈追踪
• 参数类型自动推导
• 支持异步函数组合（需配合Promise实现）

三、异步控制流手写实现

1. Promise.all的容错版本实现

原生Promise.all在单个Promise失败时立即拒绝，手写版本可实现部分成功：

function promiseAllSettled(promises) {
  return Promise.all(
    promises.map(p => 
      Promise.resolve(p).then(
        value => ({ status: 'fulfilled', value }),
        reason => ({ status: 'rejected', reason })
      )
    )
  );
}

扩展功能：

• 超时控制
• 进度回调
• 并发数限制

2. 生成器控制的异步流

使用生成器实现更灵活的异步控制：

function asyncFlow(generatorFn) {
  return function(...args) {
    const generator = generatorFn(...args);
    function handle(result) {
      if (result.done) return Promise.resolve(result.value);
      return Promise.resolve(result.value)
        .then(res => handle(generator.next(res)))
        .catch(err => handle(generator.throw(err)));
    }
    try {
      return handle(generator.next());
    } catch (err) {
      return Promise.reject(err);
    }
  };
}

应用场景：

• 复杂异步任务编排
• 资源加载依赖管理
• 错误恢复机制

四、性能优化与调试技巧

1. 记忆化缓存的实现策略

function memoize(fn, resolver = JSON.stringify) {
  const cache = new Map();
  return function(...args) {
    const key = resolver(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn.apply(this, args);
    cache.set(key, result);
    return result;
  };
}

优化方向：

• 缓存失效策略
• 弱引用缓存
• 多参数序列化方案

2. 性能分析装饰器

function performanceLogger(target, name, descriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = function(...args) {
    const start = performance.now();
    const result = originalMethod.apply(this, args);
    const end = performance.now();
    console.log(`${name} executed in ${(end - start).toFixed(2)}ms`);
    return result;
  };
  return descriptor;
}

进阶功能：

• 调用频率限制
• 性能基准对比
• 热点方法识别

五、实战案例：手写实现lodash核心方法

1. 防抖与节流的组合实现

function advancedThrottle(fn, wait, options = {}) {
  let timeout, context, args, result;
  let previous = 0;
  const later = () => {
    previous = options.leading === false ? 0 : Date.now();
    timeout = null;
    result = fn.apply(context, args);
    if (!timeout) context = args = null;
  };
  const throttled = function(...params) {
    context = this;
    args = params;
    const now = Date.now();
    if (!previous && options.leading === false) previous = now;
    const remaining = wait - (now - previous);
    if (remaining <= 0 || remaining > wait) {
      if (timeout) {
        clearTimeout(timeout);
        timeout = null;
      }
      previous = now;
      result = fn.apply(context, args);
      if (!timeout) context = args = null;
    } else if (!timeout && options.trailing !== false) {
      timeout = setTimeout(later, remaining);
    }
    return result;
  };
  throttled.cancel = function() {
    clearTimeout(timeout);
    previous = 0;
    timeout = context = args = null;
  };
  return throttled;
}

2. 深拷贝的完整实现

function deepClone(value, hash = new WeakMap()) {
  if (value === null || typeof value !== 'object') return value;
  if (hash.has(value)) return hash.get(value);
  const clone = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
  hash.set(value, clone);
  for (const key in value) {
    if (value.hasOwnProperty(key)) {
      clone[key] = deepClone(value[key], hash);
    }
  }
  // 处理Symbol属性
  const symbolKeys = Object.getOwnPropertySymbols(value);
  for (const symKey of symbolKeys) {
    clone[symKey] = deepClone(value[symKey], hash);
  }
  return clone;
}

结论与进阶建议

手写JavaScript函数不仅是面试必备技能，更是深入理解语言特性的有效途径。建议开发者：

1. 从简单函数开始重构，逐步增加复杂度
2. 结合ES6+特性优化实现
3. 建立自己的函数库并持续迭代
4. 对比原生方法性能，理解优化边界

掌握这些手写实现技巧后，开发者将能更灵活地应对复杂业务场景，在性能优化和功能定制方面获得更大自主权。建议定期复习这些实现，并尝试在不同项目中实践应用。