Figma Document Layer 面试题 2026：apply、commit_batch、redo 全面拆解

Figma Document Layer 面试题 2026 是 2026 年高频真题。
因此，这题很适合工程岗冲刺。
它看似偏实现题。
但是，本质是状态一致性题。

此外，这是我们学员贡献的最新面经。
并且，题目来自真实技术电面。
你会被追问实现细节。
同时，还会被追问复杂度取舍。

换句话说，答题关键不在 API 名字。
关键在你能否说清状态机。
因此，你要先稳住语义边界。
再给出可落地代码。

2026 面试流程深度复盘：Figma Document Layer 面试题 2026

首先，Figma Document Layer 面试题 2026 常分三段。
第一段先做 apply。
第二段追加 commit_batch。
第三段再加 redo。

其次，面试官先看你是否抓住主线。
apply 必须立刻生效。
因此，文档当前态要实时更新。
这一步不能拖到 commit_batch。

此外，commit_batch 常被误解。
它不负责让修改生效。
它只定义 undo 的回滚粒度。
因此，它是历史边界操作。

与此同时，undo/redo 会考一致性。
你需要维护两栈或等价结构。
并且，undo 后新提交要清空 redo。
否则，历史会分叉并失真。

最后，Figma Document Layer 面试题 2026 常追问压缩。
如果存全部 apply，空间会爆。
因此，要按对象字段做增量合并。
同键连续改值要折叠成一条语义。

核心题目解析

首先，Figma Document Layer 面试题 2026 的推荐模型很清晰。
doc 存当前状态。
open_batch 存未提交增量。
undo_stack/redo_stack 存批次历史。

其次，单次 apply 的语义如下。
先读旧值，再写新值。
因此，用户立刻看到结果。
同时，把变更合并进 open_batch。

此外，合并规则要严格。
键相同时，只保留最早 before。
并且，持续更新最新 after。
若 before == after，该增量可删除。

逻辑流程图

flowchart TD
A[apply(id, field, value)] --> B[立即写入 doc]
B --> C[合并到 open_batch]
C --> D{commit_batch?}
D -- 是 --> E[push 到 undo_stack]
E --> F[clear redo_stack]
D -- 否 --> G[继续接收 apply]
H[undo] --> I[pop undo_stack]
I --> J[逆序写回 before]
J --> K[push 到 redo_stack]
L[redo] --> M[pop redo_stack]
M --> N[顺序写回 after]
N --> O[push 到 undo_stack]

参考代码（Python）

from dataclasses import dataclass
from typing import Any, Dict, List, Tuple

MISSING = object()  # 区分“字段不存在”和“值为 None”

@dataclass
class Delta:
    obj_id: int
    field: str
    before: Any
    after: Any

class DocumentLayer:
    def __init__(self) -> None:
        self.doc: Dict[Tuple[int, str], Any] = {}
        self.open_batch: List[Delta] = []
        self.open_index: Dict[Tuple[int, str], int] = {}
        self.undo_stack: List[List[Delta]] = []
        self.redo_stack: List[List[Delta]] = []

    def get(self, obj_id: int, field: str) -> Any:
        return self.doc.get((obj_id, field), MISSING)

    def _set_value(self, key: Tuple[int, str], value: Any) -> None:
        if value is MISSING:
            self.doc.pop(key, None)
        else:
            self.doc[key] = value

    def apply(self, obj_id: int, field: str, value: Any) -> None:
        key = (obj_id, field)
        old = self.doc.get(key, MISSING)
        if old == value:
            return

        # 1) 立即生效：先更新当前文档状态
        self._set_value(key, value)

        # 2) 历史压缩：同一 key 在当前 batch 内只保留一条 Delta
        if key in self.open_index:
            i = self.open_index[key]
            self.open_batch[i].after = value
            if self.open_batch[i].before == self.open_batch[i].after:
                self._remove_open_delta(i)
        else:
            self.open_index[key] = len(self.open_batch)
            self.open_batch.append(Delta(obj_id, field, old, value))

    def _remove_open_delta(self, idx: int) -> None:
        removed = self.open_batch[idx]
        last = self.open_batch[-1]
        self.open_batch[idx] = last
        self.open_batch.pop()
        self.open_index.pop((removed.obj_id, removed.field), None)
        if idx < len(self.open_batch):
            self.open_index[(last.obj_id, last.field)] = idx

    def commit_batch(self) -> None:
        # 仅提交历史边界，不做“生效”动作
        if not self.open_batch:
            return
        self.undo_stack.append(list(self.open_batch))
        self.redo_stack.clear()  # 新提交打断 redo 链
        self.open_batch.clear()
        self.open_index.clear()

    def undo(self) -> bool:
        # 常见工程做法：先自动提交打开中的 batch
        if self.open_batch:
            self.commit_batch()
        if not self.undo_stack:
            return False

        batch = self.undo_stack.pop()
        for d in reversed(batch):
            self._set_value((d.obj_id, d.field), d.before)
        self.redo_stack.append(batch)
        return True

    def redo(self) -> bool:
        if not self.redo_stack:
            return False

        batch = self.redo_stack.pop()
        for d in batch:
            self._set_value((d.obj_id, d.field), d.after)
        self.undo_stack.append(batch)
        return True

因此，时间复杂度很稳。
apply 平均是 O(1)。
commit_batch 是 O(1) 到 O(k)。
undo/redo 是批次大小 O(k)。

专家备考策略与高频考点：Figma Document Layer 面试题 2026

首先，Figma Document Layer 面试题 2026 的核心考点如下。
因此，你要按这四点组织口头表达。

首先，apply 实时生效，当前态优先。
其次，commit_batch 只管历史分组。
此外，undo/redo 必须保持可逆一致。
同时，历史要压缩，避免存全部明细。
最后，同键连续改值必须语义合并。

此外，BQ 回答建议用 STAR。
这样更像北美面试官的预期。

Situation：首先，描述文档撤销错乱场景。
Task：其次，定义目标是可逆与省内存。
Action：此外，说明你做了批次和压缩。
Result：最后，给出稳定性与性能提升。

换句话说，别只谈代码。
你还要谈边界与测试。
例如，覆盖空撤销与重复提交。
同时，覆盖 undo 后新改动清空 redo。

总结与行动号召（CTA）

总而言之，Figma Document Layer 面试题 2026 的胜负点很明确。
你要先讲清语义，再写出可运行实现。
此外，这也是我们学员贡献的最新面经。
并且，这是 2026 年最新训练重点。

如果你要做一对一冲刺，点击这里：
联系我们的专家进行一对一面试辅导

如果你要补算法基础，点击这里：
权威算法参考