阶段 1:JavaScript 基础数据结构与操作

1.1 数组:动态数据处理的核心

  • 核心方法​:

    // 渲染动态列表(map)
    const listItems = dataArray.map(item => `<li>${item.name}</li>`);
     
    // 表单过滤(filter)
    const validInputs = inputs.filter(input => input.value.trim() !== "");
     
    // 数据聚合(reduce)
    const totalPrice = cartItems.reduce((sum, item) => sum + item.price, 0);
  • 应用场景​:表格渲染、表单验证、购物车计算。


1.2 字符串与正则表达式

  • 关键操作​:

    // URL 解析(split)
    const [protocol, domain] = url.split("://");
     
    // 输入验证(正则)
    const isEmailValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(userInput);
     
    // 模板字符串拼接
    const greeting = `Hello, ${userName}!`;
  • 应用场景​:表单验证、动态模板生成、URL 处理。


1.3 对象、Map 与 Set

  • 高效数据管理​:

    // 缓存数据(Map)
    const cache = new Map();
    cache.set('user_123', { name: 'Alice' });
     
    // 数组去重(Set)
    const uniqueValues = [...new Set(duplicateArray)];
  • 应用场景​:状态管理、快速查找、数据去重。


阶段 2:关键数据结构与前端实践

2.1 栈(Stack):后进先出

  • 代码实现​:

    class Stack {
      constructor() { this.items = []; }
      push(item) { this.items.push(item); }
      pop() { return this.items.pop(); }
    }
     
    // 撤销操作实现
    const historyStack = new Stack();
    historyStack.push(currentState);  // 保存状态
    const lastState = historyStack.pop();  // 撤销
  • 应用场景​:浏览器历史记录、编辑器撤销操作。


2.2 队列(Queue):先进先出

  • 代码实现​:

    class Queue {
      constructor() { this.items = []; }
      enqueue(item) { this.items.push(item); }
      dequeue() { return this.items.shift(); }
    }
     
    // 异步任务调度
    const taskQueue = new Queue();
    taskQueue.enqueue(fetchDataTask);  // 添加任务
    setTimeout(() => taskQueue.dequeue().run(), 100); // 按序执行
  • 应用场景​:事件循环、BFS 算法、请求队列。


2.3 树(Tree)与 DOM 操作

  • DOM 树遍历示例​:

    // 深度优先遍历(递归)
    function traverseDOM(node) {
      console.log(node);
      Array.from(node.children).forEach(child => traverseDOM(child));
    }
     
    // 广度优先遍历(队列)
    function bfsTraverse(root) {
      const queue = new Queue();
      queue.enqueue(root);
      while (!queue.isEmpty()) {
        const node = queue.dequeue();
        console.log(node);
        Array.from(node.children).forEach(child => queue.enqueue(child));
      }
    }
  • 应用场景​:组件层级操作、DOM 节点搜索。


阶段 3:常用算法与性能优化

3.1 排序算法:快速排序(QuickSort)​

  • 代码实现​:

    function quickSort(arr) {
      if (arr.length <= 1) return arr;
      const pivot = arr[0];
      const left = [], right = [];
      for (let i = 1; i < arr.length; i++) {
        arr[i] < pivot ? left.push(arr[i]) : right.push(arr[i]);
      }
      return [...quickSort(left), pivot, ...quickSort(right)];
    }
     
    // 表格数据排序
    const sortedData = quickSort(tableData);
  • 对比​:Array.prototype.sort 在 Chrome 中使用 TimSort(混合归并+插入排序)。


3.2 搜索算法:二分查找

  • 有序数组查找​:

    function binarySearch(arr, target) {
      let left = 0, right = arr.length - 1;
      while (left <= right) {
        const mid = Math.floor((left + right) / 2);
        if (arr[mid] === target) return mid;
        arr[mid] < target ? left = mid + 1 : right = mid - 1;
      }
      return -1;
    }
     
    // 应用场景:分页数据快速定位
    const userIndex = binarySearch(sortedUsers, targetUserId);
  • 适用场景​:有序数据查询(如日志时间戳搜索)。


3.3 递归与深拷贝

  • 递归实现深拷贝​:

    function deepClone(obj) {
      if (typeof obj !== 'object' || obj === null) return obj;
      const clone = Array.isArray(obj) ? [] : {};
      for (const key in obj) {
        clone[key] = deepClone(obj[key]);
      }
      return clone;
    }
     
    // 应用场景:表单状态管理
    const initialFormState = deepClone(defaultFormConfig);
  • 注意​:递归可能导致栈溢出(可用循环 + 栈结构优化)。


阶段 4:前端框架底层原理关联

4.1 React Fiber 架构与链表

  • 链表结构​:Fiber 节点通过 childsiblingreturn 指针连接。

    class FiberNode {
      constructor(element) {
        this.element = element;
        this.child = null;    // 第一个子节点
        this.sibling = null;  // 兄弟节点
        this.return = null;   // 父节点
      }
    }
     
    // 异步渲染:链表可中断遍历
  • 应用场景​:React 异步渲染、优先级调度。


4.2 虚拟 DOM Diff 算法

  • 树对比优化​:
    • 同级节点比较(O(n) 复杂度)。
    • Key 值优化列表渲染(减少节点移动)。

阶段 5:实战训练与面试准备

5.1 高频面试题解析

  1. 括号匹配(栈)​​:

    function isValidParentheses(s) {
      const stack = [];
      const map = { ')': '(', '}': '{', ']': '[' };
      for (const char of s) {
        if (!map[char]) stack.push(char);
        else if (stack.pop() !== map[char]) return false;
      }
      return stack.length === 0;
    }
  2. 反转链表(双指针)​​:

    function reverseList(head) {
      let prev = null, curr = head;
      while (curr) {
        const next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
      }
      return prev;
    }

5.2 推荐练习路径

  1. LeetCode 标签分类​:
    • 字符串:#344 反转字符串#3 最长子串
    • 树:#104 最大深度#102 层序遍历
  2. 实战项目​:
    • 实现虚拟 DOM Diff 工具
    • 封装高性能缓存工具(LRU 算法)

总结

  • 先理解再编码​:结合前端场景(如 DOM 操作、性能优化)理解算法。
  • 逐步进阶​:从数组/字符串 → 栈/队列 → 树 → 动态规划。
  • 框架思维​:理解 React/Vue 底层数据结构和算法设计。

通过此文档,前端工程师可逐步构建算法思维,并在实际工作中解决性能瓶颈和复杂逻辑问题。