给出一棵二叉树，其上每个结点的值都是 0 或 1 。每一条从根到叶的路径都代表一个从最高有效位开始的二进制数。

• 例如，如果路径为 0 -> 1 -> 1 -> 0 -> 1，那么它表示二进制数 01101，也就是 13 。

对树上的每一片叶子，我们都要找出从根到该叶子的路径所表示的数字。

返回这些数字之和。题目数据保证答案是一个 32 位 整数。

示例 1：

输入：root = [1,0,1,0,1,0,1]
输出：22
解释：(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22

示例 2：

输入：root = [0]
输出：0

提示：

• 树中的节点数在 [1, 1000] 范围内
• Node.val 仅为 0 或 1 

递归

容易想到「递归」进行求解，在 DFS 过程中记录下当前的值为多少，假设遍历到当前节点 $x$ 前，记录的值为 $cur$，那么根据题意，我们需要先将 $cur$ 进行整体左移（腾出最后一位），然后将节点 $x$ 的值放置最低位来得到新的值，并继续进行递归。

递归有使用「函数返回值」和「全局变量」两种实现方式。

代码：

###Java

class Solution {
    public int sumRootToLeaf(TreeNode root) {
        return dfs(root, 0);
    }
    int dfs(TreeNode root, int cur) {
        int ans = 0, ncur = (cur << 1) + root.val;
        if (root.left != null) ans += dfs(root.left, ncur);
        if (root.right != null) ans += dfs(root.right, ncur);
        return root.left == null && root.right == null ? ncur : ans;
    }
}

###Java

class Solution {
    int ans = 0;
    public int sumRootToLeaf(TreeNode root) {
        dfs(root, 0);
        return ans;
    }
    void dfs(TreeNode root, int cur) {
        int ncur = (cur << 1) + root.val;
        if (root.left != null) dfs(root.left, ncur);
        if (root.right != null) dfs(root.right, ncur);
        if (root.left == null && root.right == null) ans += ncur;
    }
}

• 时间复杂度：$O(n)$
• 空间复杂度：忽略递归带来的额外空间开销，复杂度为 $O(1)$

迭代

自然也可以使用「迭代」进行求解。

为了不引入除「队列」以外的其他数据结构，当我们可以把某个节点 $x$ 放出队列时，先将其的值修改为当前遍历路径对应的二进制数。

代码：

###Java

class Solution {
    public int sumRootToLeaf(TreeNode root) {
        int ans = 0;
        Deque<TreeNode> d = new ArrayDeque<>();
        d.addLast(root);
        while (!d.isEmpty()) {
            TreeNode poll = d.pollFirst();
            if (poll.left != null) {
                poll.left.val = (poll.val << 1) + poll.left.val;
                d.addLast(poll.left);
            }
            if (poll.right != null) {
                poll.right.val = (poll.val << 1) + poll.right.val;
                d.addLast(poll.right);
            }
            if (poll.left == null && poll.right == null) ans += poll.val;
        }
        return ans;
    }
}

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

最后

如果有帮助到你，请给题解点个赞和收藏，让更多的人看到 ~ ("▔□▔)/

也欢迎你 关注我 和 加入我们的「组队打卡」小群 ，提供写「证明」&「思路」的高质量题解。

所有题解已经加入 刷题指南，欢迎 star 哦 ~

思路分析：
本题最直观的思路就是直接递归遍历即可：按照访问根节点——左子树——右子树——的方式遍历这棵树，而在访问左子树或者右子树的时候，我们按照同样的方式遍历，直到遍历完整棵树。

实现步骤：

1. 确定递归函数的参数和返回值： 因为本题需要递归遍历每个节点而且当前节点的计算用到了上次计算的结果，所以函数返回值是 计算结果值；
2. 确定终止条件： 当然是当前遍历的节点是空了，那么本层递归就要要结束了，所以如果当前遍历的这个节点是空，就直接 $return$ $0$；
3. 确定单层递归的逻辑：
   • 如果节点是叶子节点，返回它对应的数字 $sum$；
   • 如果节点是非叶子节点，返回它的左子树和右子树对应的结果之和；

【图解举例】

具体代码如下：

###C++

class Solution {
public:
    int traserval(TreeNode *root, int sum) {
        if(root == NULL) return 0;
        sum = (sum << 1) | root->val;
        if(!root->left && !root->right) return sum;
        int leftVal  = traserval(root->left, sum);
        int rightVal = traserval(root->right, sum);
        return leftVal + rightVal;
    }

    int sumRootToLeaf(TreeNode* root) {
        return traserval(root, 0);
    }
};

复杂度分析：

• 时间复杂度：$O(n)$，其中 $n$ 是二叉搜索树的节点数；
• 空间复杂度：$O(n)$。

前言

关于二叉树后序遍历的详细说明请参考「145. 二叉树的后序遍历的官方题解」。

方法一：递归

后序遍历的访问顺序为：左子树——右子树——根节点。我们对根节点 $\textit{root}$ 进行后序遍历：

• 如果节点是叶子节点，返回它对应的数字 $\textit{val}$。

• 如果节点是非叶子节点，返回它的左子树和右子树对应的结果之和。

###Python

class Solution:
    def sumRootToLeaf(self, root: Optional[TreeNode]) -> int:
        def dfs(node: Optional[TreeNode], val: int) -> int:
            if node is None:
                return 0
            val = (val << 1) | node.val
            if node.left is None and node.right is None:
                return val
            return dfs(node.left, val) + dfs(node.right, val)
        return dfs(root, 0)

###C++

class Solution {
public:
    int dfs(TreeNode *root, int val) {
        if (root == nullptr) {
            return 0;
        }
        val = (val << 1) | root->val;
        if (root->left == nullptr && root->right == nullptr) {
            return val;
        }
        return dfs(root->left, val) + dfs(root->right, val);
    }

    int sumRootToLeaf(TreeNode* root) {
        return dfs(root, 0);
    }
};

###Java

class Solution {
    public int sumRootToLeaf(TreeNode root) {
        return dfs(root, 0);
    }

    public int dfs(TreeNode root, int val) {
        if (root == null) {
            return 0;
        }
        val = (val << 1) | root.val;
        if (root.left == null && root.right == null) {
            return val;
        }
        return dfs(root.left, val) + dfs(root.right, val);
    }
}

###C#

public class Solution {
    public int SumRootToLeaf(TreeNode root) {
        return DFS(root, 0);
    }

    public int DFS(TreeNode root, int val) {
        if (root == null) {
            return 0;
        }
        val = (val << 1) | root.val;
        if (root.left == null && root.right == null) {
            return val;
        }
        return DFS(root.left, val) + DFS(root.right, val);
    }
}

###C

int dfs(struct TreeNode *root, int val) {
    if (root == NULL) {
        return 0;
    }
    val = (val << 1) | root->val;
    if (root->left == NULL && root->right == NULL) {
        return val;
    }
    return dfs(root->left, val) + dfs(root->right, val);
}

int sumRootToLeaf(struct TreeNode* root){
    return dfs(root, 0);
}

###JavaScript

var sumRootToLeaf = function(root) {
    const dfs = (root, val) => {
        if (!root) {
            return 0;
        }
        val = (val << 1) | root.val;
        if (!root.left&& !root.right) {
            return val;
        }
        return dfs(root.left, val) + dfs(root.right, val);
    }
    return dfs(root, 0);
};

###go

func dfs(node *TreeNode, val int) int {
    if node == nil {
        return 0
    }
    val = val<<1 | node.Val
    if node.Left == nil && node.Right == nil {
        return val
    }
    return dfs(node.Left, val) + dfs(node.Right, val)
}

func sumRootToLeaf(root *TreeNode) int {
    return dfs(root, 0)
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是节点数目。总共访问 $n$ 个节点。

• 空间复杂度：$O(n)$。递归栈需要 $O(n)$ 的空间。

方法二：迭代

我们用栈来模拟递归，同时使用一个 $\textit{prev}$ 指针来记录先前访问的节点。算法步骤如下：

1. 如果节点 $\textit{root}$ 非空，我们将不断地将它及它的左节点压入栈中。

2. 我们从栈中获取节点：

   • 该节点的右节点为空或者等于 $\textit{prev}$，说明该节点的左子树及右子树都已经被访问，我们将它出栈。如果该节点是叶子节点，我们将它对应的数字 $\textit{val}$ 加入结果中。设置 $\textit{prev}$ 为该节点，设置 $\textit{root}$ 为空指针。

   • 该节点的右节点非空且不等于 $\textit{prev}$，我们令 $\textit{root}$ 指向该节点的右节点。

3. 如果 $\textit{root}$ 为空指针或者栈空，中止算法，否则重复步骤 $1$。

需要注意的是，每次出入栈都需要更新 $\textit{val}$。

###Python

class Solution:
    def sumRootToLeaf(self, root: Optional[TreeNode]) -> int:
        ans = val = 0
        st = []
        pre = None
        while root or st:
            while root:
                val = (val << 1) | root.val
                st.append(root)
                root = root.left
            root = st[-1]
            if root.right is None or root.right == pre:
                if root.left is None and root.right is None:
                    ans += val
                val >>= 1
                st.pop()
                pre = root
                root = None
            else:
                root = root.right
        return ans

###C++

class Solution {
public:
    int sumRootToLeaf(TreeNode* root) {
        stack<TreeNode *> st;
        int val = 0, ret = 0;
        TreeNode *prev = nullptr;
        while (root != nullptr || !st.empty()) {
            while (root != nullptr) {
                val = (val << 1) | root->val;
                st.push(root);
                root = root->left;
            }
            root = st.top();
            if (root->right == nullptr || root->right == prev) {
                if (root->left == nullptr && root->right == nullptr) {
                    ret += val;
                }
                val >>= 1;
                st.pop();
                prev = root;
                root = nullptr;
            } else {
                root = root->right;
            }
        }
        return ret;
    }
};

###Java

class Solution {
    public int sumRootToLeaf(TreeNode root) {
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        int val = 0, ret = 0;
        TreeNode prev = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                val = (val << 1) | root.val;
                stack.push(root);
                root = root.left;
            }
            root = stack.peek();
            if (root.right == null || root.right == prev) {
                if (root.left == null && root.right == null) {
                    ret += val;
                }
                val >>= 1;
                stack.pop();
                prev = root;
                root = null;
            } else {
                root = root.right;
            }
        }
        return ret;
    }
}

###C#

public class Solution {
    public int SumRootToLeaf(TreeNode root) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        int val = 0, ret = 0;
        TreeNode prev = null;
        while (root != null || stack.Count > 0) {
            while (root != null) {
                val = (val << 1) | root.val;
                stack.Push(root);
                root = root.left;
            }
            root = stack.Peek();
            if (root.right == null || root.right == prev) {
                if (root.left == null && root.right == null) {
                    ret += val;
                }
                val >>= 1;
                stack.Pop();
                prev = root;
                root = null;
            } else {
                root = root.right;
            }
        }
        return ret;
    }
}

###C

#define MAX_NODE_SIZE 1000

int sumRootToLeaf(struct TreeNode* root) {
    struct TreeNode ** stack = (struct TreeNode **)malloc(sizeof(struct TreeNode *) * MAX_NODE_SIZE);
    int top = 0;
    int val = 0, ret = 0;
    struct TreeNode *prev = NULL;
    while (root != NULL || top) {
        while (root != NULL) {
            val = (val << 1) | root->val;
            stack[top++] = root;
            root = root->left;
        }
        root = stack[top - 1];
        if (root->right == NULL || root->right == prev) {
            if (root->left == NULL && root->right == NULL) {
                ret += val;
            }
            val >>= 1;
            top--;
            prev = root;
            root = NULL;
        } else {
            root = root->right;
        }
    }
    free(stack);
    return ret;
}

###JavaScript

var sumRootToLeaf = function(root) {
    const stack = [];
    let val = 0, ret = 0;
    let prev = null;
    while (root || stack.length) {
        while (root) {
            val = (val << 1) | root.val;
            stack.push(root);
            root = root.left;
        }
        root = stack[stack.length - 1];
        if (!root.right || root.right === prev) {
            if (!root.left && !root.right) {
                ret += val;
            }
            val >>= 1;
            stack.pop();
            prev = root;
            root = null;
        } else {
            root = root.right;
        }
    }
    return ret;
};

###go

func sumRootToLeaf(root *TreeNode) (ans int) {
    val, st := 0, []*TreeNode{}
    var pre *TreeNode
    for root != nil || len(st) > 0 {
        for root != nil {
            val = val<<1 | root.Val
            st = append(st, root)
            root = root.Left
        }
        root = st[len(st)-1]
        if root.Right == nil || root.Right == pre {
            if root.Left == nil && root.Right == nil {
                ans += val
            }
            val >>= 1
            st = st[:len(st)-1]
            pre = root
            root = nil
        } else {
            root = root.Right
        }
    }
    return
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是节点数目。总共访问 $n$ 个节点。

• 空间复杂度：$O(n)$。栈最多压入 $n$ 个节点。

什么是 JSBridge

JSBridge 是 WebView 中 JavaScript 与 Native 代码之间的通信桥梁。核心问题是：两个不同运行环境的代码如何互相调用？

通信原理

1. Native 调用 JS（简单）

WebView 本身就提供了执行 JS 的能力，原理很直接：WebView 控制着 JS 引擎，可以直接向其注入并执行代码。

// Android
webView.evaluateJavascript("window.appCallJS('data')", null);

// iOS
webView.evaluateJavaScript("window.appCallJS('data')")

// Flutter
webViewController.runJavaScript("window.appCallJS('data')");

2. JS 调用 Native（核心难点）

JS 运行在沙箱中，无法直接访问系统 API。有两种主流方案：

方案一：注入 API

Native 在 WebView 初始化时，向 JS 全局对象注入方法：

// Android - 注入对象到 window
webView.addJavascriptInterface(new Object() {
    @JavascriptInterface
    public void showToast(String msg) {
        Toast.makeText(context, msg, Toast.LENGTH_SHORT).show();
    }
}, "NativeBridge");

JS 端直接调用：

window.NativeBridge.showToast("Hello")

本质：Native 把自己的方法"挂"到了 JS 的全局作用域里。

方案二：URL Scheme 拦截

JS 发起一个特殊协议的请求，Native 拦截并解析：

// JS 端
location.href = 'jsbridge://showToast?msg=Hello'

// 或使用 iframe（避免页面跳转）
const iframe = document.createElement('iframe')
iframe.src = 'jsbridge://showToast?msg=Hello'
document.body.appendChild(iframe)

// Android 端拦截
webView.setWebViewClient(new WebViewClient() {
    @Override
    public boolean shouldOverrideUrlLoading(WebView view, String url) {
        if (url.startsWith("jsbridge://")) {
            // 解析 url，执行对应 Native 方法
            return true;
        }
        return false;
    }
});

本质：利用 WebView 的 URL 加载机制作为通信通道。

异步回调的实现

JS 调用 Native 后如何拿到返回值？通过回调 ID 机制：

// JS 端
let callbackId = 0
const callbacks = {}

function callNative(method, params) {
    return new Promise((resolve) => {
        const id = callbackId++
        callbacks[id] = resolve
        // 告诉 Native：调用完成后，用这个 id 回调我
        window.NativeBridge.invoke(JSON.stringify({
            method,
            params,
            callbackId: id
        }))
    })
}

// Native 执行完后调用这个函数
window.handleCallback = (id, result) => {
    callbacks[id]?.(result)
    delete callbacks[id]
}

流程：JS 调用 → Native 处理 → Native 调用 evaluateJavascript 执行回调函数 → JS 收到结果

各平台注入对象命名

Android 示例

// 第二个参数就是 JS 中的对象名，可以随便取
webView.addJavascriptInterface(bridgeObject, "MyBridge");

// JS 端
window.MyBridge.method()

iOS 示例

// name 就是 JS 中的 handler 名
configuration.userContentController.add(self, name: "iOSBridge")

// JS 端
window.webkit.messageHandlers.iOSBridge.postMessage(data)

Flutter (flutter_inappwebview) 示例

// Flutter 端注册 handler，handlerName 可自定义
webViewController.addJavaScriptHandler(
  handlerName: 'myCustomHandler',
  callback: (args) { ... }
);

// JS 端，flutter_inappwebview 是固定的
window.flutter_inappwebview.callHandler('myCustomHandler', data)

通信方式总结

常见通信方式对比

最佳实践建议

1. 统一封装：抽离成独立的 bridge 工具类，统一管理通信逻辑
2. 消息队列：处理 Native 未就绪时的调用，避免丢失消息
3. 超时处理：添加超时机制，防止回调永远不返回
4. 类型安全：使用 TypeScript 定义消息类型
5. 错误处理：统一的错误捕获和上报机制

给你一个二进制字符串 s 和一个整数 k 。如果所有长度为 k 的二进制字符串都是 s 的子串，请返回 true ，否则请返回 false 。

示例 1：

输入：s = "00110110", k = 2
输出：true
解释：长度为 2 的二进制串包括 "00"，"01"，"10" 和 "11"。它们分别是 s 中下标为 0，1，3，2 开始的长度为 2 的子串。

示例 2：

输入：s = "0110", k = 1
输出：true
解释：长度为 1 的二进制串包括 "0" 和 "1"，显然它们都是 s 的子串。

示例 3：

输入：s = "0110", k = 2
输出：false
解释：长度为 2 的二进制串 "00" 没有出现在 s 中。

提示：

• 1 <= s.length <= 5 * 105
• s[i] 不是'0' 就是 '1'
• 1 <= k <= 20

方法一：暴力

暴力枚举所有长为 $k$ 的子串，保存到一个哈希集合中。

如果最终哈希集合的大小恰好等于 $2^k$，那么说明所有长为 $k$ 的二进制串都在 $s$ 中。

###py

class Solution:
    def hasAllCodes(self, s: str, k: int) -> bool:
        st = {s[i - k: i] for i in range(k, len(s) + 1)}
        return len(st) == 1 << k

###java

class Solution {
    public boolean hasAllCodes(String s, int k) {
        Set<String> set = new HashSet<>();
        for (int i = k; i <= s.length(); i++) {
            set.add(s.substring(i - k, i));
        }
        return set.size() == (1 << k);
    }
}

###cpp

class Solution {
public:
    bool hasAllCodes(string s, int k) {
        unordered_set<string> st;
        for (int i = k; i <= s.size(); i++) {
            st.insert(s.substr(i - k, k));
        }
        return st.size() == (1 << k);
    }
};

###go

func hasAllCodes(s string, k int) bool {
set := map[string]struct{}{}
for i := k; i <= len(s); i++ {
set[s[i-k:i]] = struct{}{}
}
return len(set) == 1<<k
}

复杂度分析

• 时间复杂度：$\mathcal{O}((n-k)k)$，其中 $n$ 是 $s$ 的长度。
• 空间复杂度：$\mathcal{O}((n-k)k)$。

方法二：位运算滑窗

把子串转成整数，保存到哈希集合或者布尔数组中。

小优化：如果循环过程中发现已经找到 $2^k$ 个不同的二进制数，可以提前返回 $\texttt{true}$。

###py

class Solution:
    def hasAllCodes(self, s: str, k: int) -> bool:
        MASK = (1 << k) - 1
        st = set()  # 更快的写法见另一份代码【Python3 列表】
        x = 0
        for i, ch in enumerate(s):
            # 把 ch 加到 x 的末尾：x 整体左移一位，然后或上 ch
            # &MASK 目的是去掉超出 k 的比特位
            x = (x << 1 & MASK) | int(ch)
            if i >= k - 1:
                st.add(x)
        return len(st) == 1 << k

###py

class Solution:
    def hasAllCodes(self, s: str, k: int) -> bool:
        MASK = (1 << k) - 1
        has = [False] * (1 << k)
        cnt = x = 0
        for i, ch in enumerate(s):
            # 把 ch 加到 x 的末尾：x 整体左移一位，然后或上 ch
            # &MASK 目的是去掉超出 k 的比特位
            x = (x << 1 & MASK) | int(ch)
            if i < k - 1 or has[x]:
                continue
            has[x] = True
            cnt += 1
            if cnt == 1 << k:
                return True
        return False

###java

class Solution {
    public boolean hasAllCodes(String s, int k) {
        final int MASK = (1 << k) - 1;
        boolean[] has = new boolean[1 << k];
        int cnt = 0;
        int x = 0;
        for (int i = 0; i < s.length() && cnt < (1 << k); i++) {
            char ch = s.charAt(i);
            // 把 ch 加到 x 的末尾：x 整体左移一位，然后或上 ch&1
            // &MASK 目的是去掉超出 k 的比特位
            x = (x << 1 & MASK) | (ch & 1);
            if (i >= k - 1 && !has[x]) {
                has[x] = true;
                cnt++;
            }
        }
        return cnt == (1 << k);
    }
}

###cpp

class Solution {
public:
    bool hasAllCodes(string s, int k) {
        const int MASK = (1 << k) - 1;
        vector<int8_t> has(1 << k);
        int cnt = 0;
        int x = 0;
        for (int i = 0; i < s.size() && cnt < (1 << k); i++) {
            // 把 s[i] 加到 x 的末尾：x 整体左移一位，然后或上 s[i]&1
            // &MASK 目的是去掉超出 k 的比特位
            x = (x << 1 & MASK) | (s[i] & 1);
            if (i >= k - 1 && !has[x]) {
                has[x] = true;
                cnt++;
            }
        }
        return cnt == (1 << k);
    }
};

###go

func hasAllCodes(s string, k int) bool {
has := make([]bool, 1<<k)
cnt := 0
mask := 1<<k - 1
x := 0
for i, ch := range s {
// 把 ch 加到 x 的末尾：x 整体左移一位，然后或上 ch&1
// &mask 目的是去掉超出 k 的比特位
x = x<<1&mask | int(ch&1)
if i < k-1 || has[x] {
continue
}
has[x] = true
cnt++
if cnt == 1<<k {
return true
}
}
return false
}

复杂度分析

• 时间复杂度：$\mathcal{O}(n)$，其中 $n$ 是 $s$ 的长度。
• 空间复杂度：$\mathcal{O}(n-k)$ 或 $\mathcal{O}(2^k)$，取决于实现。

分类题单

如何科学刷题？

1. 滑动窗口与双指针（定长/不定长/单序列/双序列/三指针/分组循环）
2. 二分算法（二分答案/最小化最大值/最大化最小值/第K小）
3. 单调栈（基础/矩形面积/贡献法/最小字典序）
4. 网格图（DFS/BFS/综合应用）
5. 位运算（基础/性质/拆位/试填/恒等式/思维）
6. 图论算法（DFS/BFS/拓扑排序/基环树/最短路/最小生成树/网络流）
7. 动态规划（入门/背包/划分/状态机/区间/状压/数位/数据结构优化/树形/博弈/概率期望）
8. 常用数据结构（前缀和/差分/栈/队列/堆/字典树/并查集/树状数组/线段树）
9. 数学算法（数论/组合/概率期望/博弈/计算几何/随机算法）
10. 贪心与思维（基本贪心策略/反悔/区间/字典序/数学/思维/脑筋急转弯/构造）
11. 链表、树与回溯（前后指针/快慢指针/DFS/BFS/直径/LCA）
12. 字符串（KMP/Z函数/Manacher/字符串哈希/AC自动机/后缀数组/子序列自动机）

我的题解精选（已分类）

欢迎关注 B站@灵茶山艾府

方法一：哈希表

我们遍历字符串 $s$，并用一个哈希集合（HashSet）存储所有长度为 $k$ 的子串。在遍历完成后，只需要判断哈希集合中是否有 $2^k$ 项即可，这是因为长度为 $k$ 的二进制串的数量为 $2^k$。

注意到如果 $s$ 包含 $2^k$ 个长度为 $k$ 的二进制串，那么它的长度至少为 $2^k+k-1$。因此我们可以在遍历前判断 $s$ 是否足够长。

###C++

class Solution {
public:
    bool hasAllCodes(string s, int k) {
        if (s.size() < (1 << k) + k - 1) {
            return false;
        }

        unordered_set<string> exists;
        for (int i = 0; i + k <= s.size(); ++i) {
            exists.insert(move(s.substr(i, k)));
        }
        return exists.size() == (1 << k);
    }
};

###C++

class Solution {
public:
    bool hasAllCodes(string s, int k) {
        if (s.size() < (1 << k) + k - 1) {
            return false;
        }

        string_view sv(s);
        unordered_set<string_view> exists;
        for (int i = 0; i + k <= s.size(); ++i) {
            exists.insert(sv.substr(i, k));
        }
        return exists.size() == (1 << k);
    }
};

###Python

class Solution:
    def hasAllCodes(self, s: str, k: int) -> bool:
        if len(s) < (1 << k) + k - 1:
            return False
        
        exists = set(s[i:i+k] for i in range(len(s) - k + 1))
        return len(exists) == (1 << k)

###Java

class Solution {
    public boolean hasAllCodes(String s, int k) {
        if (s.length() < (1 << k) + k - 1) {
            return false;
        }

        Set<String> exists = new HashSet<String>();
        for (int i = 0; i + k <= s.length(); ++i) {
            exists.add(s.substring(i, i + k));
        }
        return exists.size() == (1 << k);
    }
}

###C#

public class Solution {
    public bool HasAllCodes(string s, int k) {
        if (s.Length < (1 << k) + k - 1) {
            return false;
        }

        HashSet<string> exists = new HashSet<string>();
        for (int i = 0; i + k <= s.Length; ++i) {
            exists.Add(s.Substring(i, k));
        }
        return exists.Count == (1 << k);
    }
}

###Go

func hasAllCodes(s string, k int) bool {
    if len(s) < (1 << k) + k - 1 {
        return false
    }

    exists := make(map[string]bool)
    for i := 0; i + k <= len(s); i++ {
        substring := s[i:i+k]
        exists[substring] = true
    }
    return len(exists) == (1 << k)
}

###C

typedef struct {
    char *key;
    UT_hash_handle hh;
} HashItem; 

HashItem *hashFindItem(HashItem **obj, char *key) {
    HashItem *pEntry = NULL;
    HASH_FIND_STR(*obj, key, pEntry);
    return pEntry;
}

bool hashAddItem(HashItem **obj, char *key) {
    if (hashFindItem(obj, key)) {
        return false;
    }
    HashItem *pEntry = (HashItem *)malloc(sizeof(HashItem));
    pEntry->key = strdup(key);
    HASH_ADD_STR(*obj, key, pEntry);
    return true;
}

void hashFree(HashItem **obj) {
    HashItem *curr = NULL, *tmp = NULL;
    HASH_ITER(hh, *obj, curr, tmp) {
        HASH_DEL(*obj, curr); 
        free(curr->key); 
        free(curr);             
    }
}

bool hasAllCodes(char* s, int k) {
    int len = strlen(s);
    int total = 1 << k;
    if (len < total + k - 1) {
        return false;
    }

    HashItem *exists = NULL;
    for (int i = 0; i + k <= len; ++i) {
        char tmp[k + 1];
        strncpy(tmp, s + i, k);
        tmp[k] = '\0';
        hashAddItem(&exists, tmp);
    }

    bool ret = HASH_COUNT(exists) == (1 << k);
    hashFree(&exists);
    return ret;
}

###JavaScript

var hasAllCodes = function(s, k) {
    if (s.length < (1 << k) + k - 1) {
        return false;
    }

    const exists = new Set();
    for (let i = 0; i + k <= s.length; ++i) {
        exists.add(s.substring(i, i + k));
    }
    return exists.size === (1 << k);
};

###TypeScript

function hasAllCodes(s: string, k: number): boolean {
    if (s.length < (1 << k) + k - 1) {
        return false;
    }

    const exists = new Set<string>();
    for (let i = 0; i + k <= s.length; ++i) {
        exists.add(s.substring(i, i + k));
    }
    return exists.size === (1 << k);
}

###Rust

use std::collections::HashSet;

impl Solution {
    pub fn has_all_codes(s: String, k: i32) -> bool {
        let k = k as usize;
        let total = 1 << k;
        
        if s.len() < total + k - 1 {
            return false;
        }

        let mut exists = HashSet::new();
        for i in 0..=(s.len() - k) {
            exists.insert(&s[i..i + k]);
        }
        exists.len() == total
    }
}

复杂度分析

• 时间复杂度：$O(k * |s|)$，其中 $|s|$ 是字符串 $s$ 的长度。将长度为 $k$ 的字符串加入哈希集合的时间复杂度为 $O(k)$，即为计算哈希值的时间。

• 空间复杂度：$O(k * 2^k)$。哈希集合中最多有 $2^k$ 项，每一项是一个长度为 $k$ 的字符串。

方法二：哈希表 + 滑动窗口

我们可以借助滑动窗口，对方法一进行优化。

假设我们当前遍历到的长度为 $k$ 的子串为

$$
s_i, s_{i+1}, \cdots, s_{i+k-1}
$$

它的下一个子串为

$$
s_{i+1}, s_{i+2}, \cdots, s_{i+k}
$$

由于这些子串都是二进制串，我们可以将其表示成对应的十进制整数的形式，即

$$
\begin{aligned}
& \textit{num}i &= s_i * 2^{k-1} + s{i+1} * 2^{k-2} + \cdots + s_{i+k-1} * 2^0 \
& \textit{num}{i+1} &= s{i+1} * 2^{k-1} + s_{i+2} * 2^{k-2} + \cdots + s_{i+k} * 2^0 \
\end{aligned}
$$

那么我们可以将这些十进制整数作为哈希表中的项。由于每一个长度为 $k$ 的二进制串都唯一对应了一个十进制整数，因此这样做与方法一是一致的。与二进制串本身不同的是，我们可以在 $O(1)$ 的时间内通过 $\textit{num}i$ 得到 $\textit{num}{i+1}$，即：

$$
num_{i+1} = (num_{i} - s_i * 2^{k-1}) * 2 + s_{i+k}
$$

这样以来，我们在遍历 $s$ 的过程中只维护子串对应的十进制整数，而不需要对字符串进行操作，从而减少了时间复杂度。

###C++

class Solution {
public:
    bool hasAllCodes(string s, int k) {
        if (s.size() < (1 << k) + k - 1) {
            return false;
        }

        int num = stoi(s.substr(0, k), nullptr, 2);
        unordered_set<int> exists = {num};
        
        for (int i = 1; i + k <= s.size(); ++i) {
            num = (num - ((s[i - 1] - '0') << (k - 1))) * 2 + (s[i + k - 1] - '0');
            exists.insert(num);
        }
        return exists.size() == (1 << k);
    }
};

###Python

class Solution:
    def hasAllCodes(self, s: str, k: int) -> bool:
        if len(s) < (1 << k) + k - 1:
            return False
        
        num = int(s[:k], base=2)
        exists = set([num])

        for i in range(1, len(s) - k + 1):
            num = (num - ((ord(s[i - 1]) - 48) << (k - 1))) * 2 + (ord(s[i + k - 1]) - 48)
            exists.add(num)
        
        return len(exists) == (1 << k)

###Java

class Solution {
    public boolean hasAllCodes(String s, int k) {
        if (s.length() < (1 << k) + k - 1) {
            return false;
        }

        int num = Integer.parseInt(s.substring(0, k), 2);
        Set<Integer> exists = new HashSet<Integer>();
        exists.add(num);
        
        for (int i = 1; i + k <= s.length(); ++i) {
            num = (num - ((s.charAt(i - 1) - '0') << (k - 1))) * 2 + (s.charAt(i + k - 1) - '0');
            exists.add(num);
        }
        return exists.size() == (1 << k);
    }
}

###C#

public class Solution {
    public bool HasAllCodes(string s, int k) {
        if (s.Length < (1 << k) + k - 1) {
            return false;
        }

        int num = Convert.ToInt32(s.Substring(0, k), 2);
        HashSet<int> exists = new HashSet<int> { num };
        
        for (int i = 1; i + k <= s.Length; ++i) {
            num = (num - ((s[i - 1] - '0') << (k - 1))) * 2 + (s[i + k - 1] - '0');
            exists.Add(num);
        }
        return exists.Count == (1 << k);
    }
}

###Go

func hasAllCodes(s string, k int) bool {
    if len(s) < (1 << k) + k - 1 {
        return false
    }

    num := 0
    for i := 0; i < k; i++ {
        num = num << 1
        if s[i] == '1' {
            num |= 1
        }
    }
    
    exists := make(map[int]bool)
    exists[num] = true
    for i := 1; i + k <= len(s); i++ {
        num = (num - (int(s[i-1]-'0') << (k-1))) * 2 + int(s[i+k-1]-'0')
        exists[num] = true
    }
    return len(exists) == (1 << k)
}

###C

typedef struct {
    int key;        
    UT_hash_handle hh;
} HashItem;

HashItem *hashFindItem(HashItem **obj, int key) {
    HashItem *pEntry = NULL;
    HASH_FIND_INT(*obj, &key, pEntry);
    return pEntry;
}

bool hashAddItem(HashItem **obj, int key) {
    if (hashFindItem(obj, key)) {
        return false;
    }
    HashItem *pEntry = (HashItem *)malloc(sizeof(HashItem));
    pEntry->key = key;
    HASH_ADD_INT(*obj, key, pEntry);
    return true;
}

void hashFree(HashItem **obj) {
    HashItem *curr = NULL, *tmp = NULL;
    HASH_ITER(hh, *obj, curr, tmp) {
        HASH_DEL(*obj, curr);
        free(curr);
    }
}

bool hasAllCodes(char* s, int k) {
    int len = strlen(s);
    int total = 1 << k;
    if (len < total + k - 1) {
        return false;
    }

    int num = 0;
    for (int i = 0; i < k; i++) {
        num = (num << 1) | (s[i] - '0');
    }
    
    HashItem *exists = NULL;
    hashAddItem(&exists, num);
    for (int i = k; i < len; i++) {
        int mask = (1 << k) - 1;
        num = ((num << 1) | (s[i] - '0')) & mask;
        hashAddItem(&exists, num);
    }

    bool ret = HASH_COUNT(exists) == total;
    hashFree(&exists);
    return ret;
}

###JavaScript

var hasAllCodes = function(s, k) {
    if (s.length < (1 << k) + k - 1) {
        return false;
    }

    let num = parseInt(s.substring(0, k), 2);
    const exists = new Set([num]);
    for (let i = 1; i + k <= s.length; ++i) {
        num = (num - (parseInt(s[i - 1]) << (k - 1))) * 2 + parseInt(s[i + k - 1]);
        exists.add(num);
    }
    return exists.size === (1 << k);
};

###TypeScript

function hasAllCodes(s: string, k: number): boolean {
    if (s.length < (1 << k) + k - 1) {
        return false;
    }

    let num = parseInt(s.substring(0, k), 2);
    const exists = new Set<number>([num]);
    for (let i = 1; i + k <= s.length; ++i) {
        num = (num - (parseInt(s[i - 1]) << (k - 1))) * 2 + parseInt(s[i + k - 1]);
        exists.add(num);
    }
    return exists.size === (1 << k);
}

###Rust

use std::collections::HashSet;

impl Solution {
    pub fn has_all_codes(s: String, k: i32) -> bool {
        let k = k as usize;
        let total = 1 << k;
        
        if s.len() < total + k - 1 {
            return false;
        }

        let bytes = s.as_bytes();
        let mut num = 0;
        for i in 0..k {
            num = (num << 1) | (bytes[i] - b'0') as usize;
        }

        let mut exists = HashSet::new();
        exists.insert(num);
        for i in 1..=bytes.len() - k {
            let high_bit = ((bytes[i - 1] - b'0') as usize) << (k - 1);
            num = (num - high_bit) << 1 | (bytes[i + k - 1] - b'0') as usize;
            exists.insert(num);
        }
        
        exists.len() == total
    }
}

复杂度分析

• 时间复杂度：$O(|s|)$，其中 $|s|$ 是字符串 $s$ 的长度。

• 空间复杂度：$O(2^k)$。哈希集合中最多有 $2^k$ 项，每一项是一个十进制整数。

大多数题解，都是在哈希表中存储字符串。类似如下的代码：

class Solution {
public:
    bool hasAllCodes(string s, int k) {

        unordered_set<string> set;
        for(int i = 0; i + k <= s.size(); i ++) set.insert(s.substr(i, k));
        return set.size() == (1 << k);
    }
};

但其实，这样做，因为哈希表中存的是长度为 k 的子串。每次计算子串的哈希值，是需要 O(k) 的时间的。所以这个算法真正的复杂度是 O(|s| * k)

我提交的数据是这样的：

这个问题可以优化，我们可以使用滑动窗口的思想，每次把长度为 k 的子串所对应的整数计算出来。之后，每次窗口向前移动，子串最高位丢掉一个字符；最低位添加一个字符，使用 O(1) 的时间即可计算出新的数字。同时，哈希表中存储的是整型，复杂度才是真正的 O(1)。整体算法复杂度是 O(|s|)的。

class Solution {
public:
    bool hasAllCodes(string s, int k) {

        if(k > s.size()) return 0;

        int cur = 0;
        for(int i = 0; i < k - 1; i ++)
            cur = 2 * cur + (s[i] == '1');

        unordered_set<int> set;
        for(int i = k - 1; i < s.size(); i ++){
            cur = cur * 2 + (s[i] == '1');
            set.insert(cur);
            cur &= ~(1 << (k - 1));
        }
        return set.size() == (1 << k);
    }
};

上面的代码在 leetcode 上测试，时间快一倍，空间消耗也更少。

最后，如果使用整型，我们就可以不再使用哈希表了，直接把数组当哈希表用，索引即是 key。这样，性能又能提升一倍。

class Solution {
public:
    bool hasAllCodes(string s, int k) {

        if(k > s.size()) return 0;

        int cur = 0;
        for(int i = 0; i < k - 1; i ++)
            cur = 2 * cur + (s[i] == '1');

        vector<bool> used(1 << k, false);
        for(int i = k - 1; i < s.size(); i ++){
            cur = cur * 2 + (s[i] == '1');
            used[cur] = true;
            cur &= ~(1 << (k - 1));
        }
        
        for(int e: used) if(!e) return false;
        return true;
    }
};

觉得有帮助请点赞哇！

Checkbox Pattern 详解：构建无障碍复选框组件

复选框（Checkbox）是表单中最常见的交互元素之一，支持双状态（选中/未选中）和三状态（选中/未选中/部分选中）两种类型。本文基于 W3C WAI-ARIA Checkbox Pattern 规范，详解如何构建无障碍的复选框组件。

一、Checkbox 的定义与核心概念

复选框是一种允许用户进行二元或三元选择的控件。根据使用场景，复选框分为两种类型：

1.1 双状态复选框（Dual-State Checkbox）

在两个状态之间切换：

• 选中（Checked）：复选框被选中
• 未选中（Not Checked）：复选框未被选中

1.2 三状态复选框（Tri-State Checkbox）

在三个状态之间切换：

• 选中（Checked）：复选框被选中
• 未选中（Not Checked）：复选框未被选中
• 部分选中（Partially Checked）：表示一组选项中部分被选中

1.3 三状态复选框的典型应用场景

三状态复选框常用于软件安装程序或权限设置中，一个总控复选框控制整组选项的状态：

• 全部选中：如果组内所有选项都被选中，总控复选框显示为选中状态
• 部分选中：如果组内部分选项被选中，总控复选框显示为部分选中状态
• 全部未选中：如果组内没有选项被选中，总控复选框显示为未选中状态

用户可以通过点击总控复选框一次性改变整组选项的状态：

• 点击选中的总控复选框 → 取消全选
• 点击未选中的总控复选框 → 全选
• 点击部分选中的总控复选框 → 根据实现可能全选或恢复之前的状态

二、WAI-ARIA 角色与属性

2.1 基本角色

复选框具有 role="checkbox"。

2.2 可访问标签

复选框的可访问标签可以通过以下方式提供：

• 可见文本内容：直接包含在具有 role="checkbox" 的元素内的文本
• aria-labelledby：引用包含标签文本的元素的 ID
• aria-label：直接在复选框元素上设置标签文本

<!-- 方式一：可见文本内容 -->
<div role="checkbox" aria-checked="false">
  订阅新闻邮件
</div>

<!-- 方式二：aria-labelledby -->
<span id="newsletter-label">订阅新闻邮件</span>
<div role="checkbox" aria-checked="false" aria-labelledby="newsletter-label"></div>

<!-- 方式三：aria-label -->
<div role="checkbox" aria-checked="false" aria-label="订阅新闻邮件"></div>

2.3 状态属性

• aria-checked="true"：复选框被选中
• aria-checked="false"：复选框未被选中
• aria-checked="mixed"：复选框处于部分选中状态（仅三状态复选框）

2.4 分组属性

如果一组复选框作为逻辑组呈现且有可见标签：

• 使用 role="group" 包裹整组复选框
• 使用 aria-labelledby 引用组标签的 ID

<fieldset role="group" aria-labelledby="group-label">
  <legend id="group-label">选择权限</legend>
  <label><input type="checkbox" /> 读取</label>
  <label><input type="checkbox" /> 写入</label>
  <label><input type="checkbox" /> 删除</label>
</fieldset>

2.5 描述属性

如果包含额外的描述性静态文本，使用 aria-describedby：

<div role="checkbox" aria-checked="false" aria-describedby="terms-desc">
  我同意服务条款
</div>
<p id="terms-desc">点击此处查看完整的服务条款内容</p>

三、键盘交互规范

当复选框获得焦点时：

四、实现方式

4.1 双状态复选框

原生 HTML 实现（推荐）

<label>
  <input type="checkbox" name="newsletter" />
  订阅新闻邮件
</label>

ARIA 实现（自定义样式）

<div 
  role="checkbox" 
  tabindex="0" 
  aria-checked="false"
  onclick="toggleCheckbox(this)"
  onkeydown="handleKeydown(event, this)">
  <span class="checkbox-icon" aria-hidden="true"></span>
  订阅新闻邮件
</div>

<script>
  function toggleCheckbox(checkbox) {
    const isChecked = checkbox.getAttribute('aria-checked') === 'true';
    checkbox.setAttribute('aria-checked', !isChecked);
  }
  
  function handleKeydown(event, checkbox) {
    if (event.key === ' ') {
      event.preventDefault();
      toggleCheckbox(checkbox);
    }
  }
</script>

4.2 三状态复选框（全选/取消全选）

<fieldset role="group" aria-labelledby="permissions-label">
  <legend id="permissions-label">文件权限</legend>
  
  <!-- 总控复选框 -->
  <label>
    <input 
      type="checkbox" 
      id="select-all"
      aria-checked="false"
      onchange="toggleAll(this)" />
    全选
  </label>
  
  <!-- 子复选框组 -->
  <div class="checkbox-group">
    <label>
      <input 
        type="checkbox" 
        name="permission"
        value="read"
        onchange="updateSelectAll()" />
      读取
    </label>
    <label>
      <input 
        type="checkbox" 
        name="permission"
        value="write"
        onchange="updateSelectAll()" />
      写入
    </label>
    <label>
      <input 
        type="checkbox" 
        name="permission"
        value="delete"
        onchange="updateSelectAll()" />
      删除
    </label>
  </div>
</fieldset>

<script>
  function toggleAll(selectAllCheckbox) {
    const checkboxes = document.querySelectorAll('input[name="permission"]');
    const isChecked = selectAllCheckbox.checked;
    
    checkboxes.forEach(checkbox => {
      checkbox.checked = isChecked;
    });
    
    updateSelectAllState();
  }
  
  function updateSelectAll() {
    updateSelectAllState();
  }
  
  function updateSelectAllState() {
    const selectAllCheckbox = document.getElementById('select-all');
    const checkboxes = document.querySelectorAll('input[name="permission"]');
    const checkedCount = document.querySelectorAll('input[name="permission"]:checked').length;
    
    if (checkedCount === 0) {
      selectAllCheckbox.checked = false;
      selectAllCheckbox.indeterminate = false;
      selectAllCheckbox.setAttribute('aria-checked', 'false');
    } else if (checkedCount === checkboxes.length) {
      selectAllCheckbox.checked = true;
      selectAllCheckbox.indeterminate = false;
      selectAllCheckbox.setAttribute('aria-checked', 'true');
    } else {
      selectAllCheckbox.checked = false;
      selectAllCheckbox.indeterminate = true;
      selectAllCheckbox.setAttribute('aria-checked', 'mixed');
    }
  }
</script>

4.3 使用原生 HTML 实现三状态效果

HTML5 的 indeterminate 属性可以实现部分选中视觉效果：

<label>
  <input 
    type="checkbox" 
    id="master-checkbox"
    onclick="handleMasterClick(this)" />
  全选
</label>

<label><input type="checkbox" class="child-checkbox" onchange="updateMaster()" /> 选项 1</label>
<label><input type="checkbox" class="child-checkbox" onchange="updateMaster()" /> 选项 2</label>
<label><input type="checkbox" class="child-checkbox" onchange="updateMaster()" /> 选项 3</label>

<script>
  function updateMaster() {
    const master = document.getElementById('master-checkbox');
    const children = document.querySelectorAll('.child-checkbox');
    const checkedCount = document.querySelectorAll('.child-checkbox:checked').length;
    
    if (checkedCount === 0) {
      master.checked = false;
      master.indeterminate = false;
    } else if (checkedCount === children.length) {
      master.checked = true;
      master.indeterminate = false;
    } else {
      master.checked = false;
      master.indeterminate = true;
    }
  }
  
  function handleMasterClick(master) {
    const children = document.querySelectorAll('.child-checkbox');
    const isChecked = master.checked;
    
    children.forEach(child => {
      child.checked = isChecked;
    });
  }
</script>

五、常见应用场景

5.1 表单选项

用户注册表单中的选项选择：

<fieldset>
  <legend>兴趣爱好</legend>
  <label><input type="checkbox" name="hobby" value="reading" /> 阅读</label>
  <label><input type="checkbox" name="hobby" value="sports" /> 运动</label>
  <label><input type="checkbox" name="hobby" value="music" /> 音乐</label>
  <label><input type="checkbox" name="hobby" value="travel" /> 旅行</label>
</fieldset>

5.2 权限设置

系统权限管理中的功能授权：

<fieldset role="group" aria-labelledby="permissions-heading">
  <h3 id="permissions-heading">用户权限</h3>
  
  <label>
    <input type="checkbox" id="select-all-permissions" />
    全选所有权限
  </label>
  
  <div class="permission-group">
    <label><input type="checkbox" name="permission" value="view" /> 查看数据</label>
    <label><input type="checkbox" name="permission" value="create" /> 创建记录</label>
    <label><input type="checkbox" name="permission" value="edit" /> 编辑内容</label>
    <label><input type="checkbox" name="permission" value="delete" /> 删除数据</label>
  </div>
</fieldset>

5.3 安装程序选项

软件安装时的组件选择：

<fieldset>
  <legend>选择安装组件</legend>
  
  <label>
    <input type="checkbox" id="select-all-components" />
    安装所有组件
  </label>
  
  <label><input type="checkbox" name="component" value="core" checked disabled /> 核心程序（必需）</label>
  <label><input type="checkbox" name="component" value="docs" /> 帮助文档</label>
  <label><input type="checkbox" name="component" value="plugins" /> 插件包</label>
  <label><input type="checkbox" name="component" value="shortcuts" /> 桌面快捷方式</label>
</fieldset>

5.4 表格行选择

数据表格中的批量操作：

<table role="grid">
  <thead>
    <tr>
      <th>
        <input type="checkbox" id="select-all-rows" aria-label="选择所有行" />
      </th>
      <th>姓名</th>
      <th>邮箱</th>
      <th>状态</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><input type="checkbox" class="row-checkbox" aria-label="选择张三" /></td>
      <td>张三</td>
      <td>zhangsan@example.com</td>
      <td>活跃</td>
    </tr>
    <tr>
      <td><input type="checkbox" class="row-checkbox" aria-label="选择李四" /></td>
      <td>李四</td>
      <td>lisi@example.com</td>
      <td>待审核</td>
    </tr>
  </tbody>
</table>

六、最佳实践

6.1 优先使用原生复选框

原生 HTML <input type="checkbox"> 提供完整的无障碍支持，包括：

• 自动键盘交互（Space 键切换）
• 屏幕阅读器自动播报状态
• 浏览器原生样式和焦点管理

6.2 标签关联

始终使用 <label> 元素关联复选框和标签文本：

<!-- 推荐：使用 for 属性关联 -->
<input type="checkbox" id="agree" />
<label for="agree">我同意服务条款</label>

<!-- 推荐：使用嵌套方式 -->
<label>
  <input type="checkbox" />
  我同意服务条款
</label>

6.3 分组语义

相关复选框应使用 <fieldset> 和 <legend> 进行分组：

<fieldset>
  <legend>选择通知方式</legend>
  <label><input type="checkbox" /> 邮件通知</label>
  <label><input type="checkbox" /> 短信通知</label>
  <label><input type="checkbox" /> 应用内通知</label>
</fieldset>

6.4 状态同步

三状态复选框需要确保 DOM 属性与 ARIA 属性同步：

function updateTriState(checkbox, checkedCount, totalCount) {
  if (checkedCount === 0) {
    checkbox.checked = false;
    checkbox.indeterminate = false;
    checkbox.setAttribute('aria-checked', 'false');
  } else if (checkedCount === totalCount) {
    checkbox.checked = true;
    checkbox.indeterminate = false;
    checkbox.setAttribute('aria-checked', 'true');
  } else {
    checkbox.checked = false;
    checkbox.indeterminate = true;
    checkbox.setAttribute('aria-checked', 'mixed');
  }
}

6.5 视觉指示

确保复选框状态有清晰的视觉指示：

• 未选中：空框
• 选中：勾选标记
• 部分选中：横线或减号

6.6 焦点管理

为自定义复选框提供清晰的焦点样式：

[role="checkbox"]:focus {
  outline: 2px solid #005a9c;
  outline-offset: 2px;
}

七、Checkbox 与 Radio 的区别

八、总结

构建无障碍的复选框组件需要关注三个核心：正确的语义化标记（优先使用原生 <input type="checkbox">）、清晰的状态管理（aria-checked 属性）、以及良好的标签关联（<label> 元素）。对于复杂的三状态场景，需要确保总控复选框与子复选框之间的状态同步，为屏幕阅读器用户提供准确的状态反馈。

遵循 W3C Checkbox Pattern 规范，我们能够创建既美观又包容的复选框组件，为不同能力的用户提供一致的体验。

文章同步于 an-Onion 的 Github。码字不易，欢迎点赞。

【Unity Shader Graph 使用与特效实现】专栏-直达

概述

Matrix 2x2节点是Unity URP Shader Graph中的一个基础数学节点，用于在着色器程序中定义和操作2x2矩阵。在计算机图形学和实时渲染中，矩阵是不可或缺的数学工具，而2x2矩阵虽然规模较小，但在特定场景下具有重要的应用价值。该节点允许着色器开发者在可视化编程环境中直接创建和配置2x2矩阵，无需编写复杂的HLSL代码。

在Shader Graph的节点体系中，Matrix 2x2节点属于常量定义类节点，它输出的矩阵值在着色器执行过程中保持不变。这种特性使得它特别适合用于定义那些在渲染过程中不需要变化的变换参数，如固定的旋转、缩放或剪切变换。

理解Matrix 2x2节点的功能和应用场景对于掌握Shader Graph的高级技巧至关重要。虽然现代图形编程中更常见的是4x4矩阵（用于处理3D空间变换），但2x2矩阵在优化性能和特定算法实现方面仍具有独特优势，特别是在处理2D图形、UV坐标变换和简化计算等方面。

描述

Matrix 2x2节点在Shader Graph环境中创建并输出一个2行2列的常量矩阵。从数学角度看，2x2矩阵是由4个标量元素 arranged in a rectangular array with two rows and two columns。在着色器编程中，这种数据结构通常用于表示线性变换，如旋转、缩放、剪切和反射等。

该节点的主要特点是其输出的矩阵值在着色器执行期间保持不变，这意味着它不适合用于需要动态变化的变换操作。对于需要每帧更新的矩阵变换，开发者应当考虑使用Shader Graph中的其他节点，如通过脚本传递的矩阵参数或基于时间节点的动态计算。

在内部实现上，Matrix 2x2节点对应于HLSL中的float2x2数据类型。当Shader Graph编译时，该节点会生成相应的HLSL代码，在最终着色器中声明一个常量矩阵。这种设计使得不熟悉HLSL语法的美术师和设计师也能轻松创建和使用矩阵运算，降低了着色器开发的技术门槛。

Matrix 2x2节点的应用范围相当广泛，从简单的纹理坐标变换到复杂的数学运算都能见到它的身影。在2D游戏开发中，它可用于创建精灵的旋转和缩放效果；在UI着色器中，它能帮助实现各种动态变换效果；甚至在3D渲染中，它也能优化某些特定计算，如法线变换的部分计算或简化版的投影变换。

端口

Matrix 2x2节点的端口配置相对简单，仅包含一个输出端口，这反映了该节点作为数据源的本质特性。

输出端口

Matrix 2x2节点的输出端口是节点功能的唯一出口，负责将定义的矩阵数据传递给Shader Graph中的其他节点。理解这个端口的特性对于正确使用该节点至关重要。

• 名称：Out
• 方向：输出
• 类型：Matrix 2
• 绑定：无
• 描述：输出值

输出端口类型被标记为"Matrix 2"，这指的是一个2x2的浮点数矩阵。在Shader Graph的类型系统中，这是一种基本的数据类型，可以与许多其他节点兼容。当连接该输出到其他节点的输入时，Shader Graph会自动处理类型匹配和转换，前提是目标输入支持矩阵类型或可以进行隐式转换。

值得注意的是，输出端口的连接灵活性使得Matrix 2x2节点可以与其他多种节点类型配合使用。例如，它可以连接到矩阵乘法节点的输入，与另一个矩阵或向量进行运算；也可以连接到自定义函数节点，作为复杂计算的输入参数；甚至可以作为着色器阶段的输出，影响最终的渲染结果。

在实际使用中，输出端口的矩阵数据遵循行优先的存储顺序。这意味着矩阵的第一行元素首先存储在内存中，然后是第二行元素。这种存储方式与HLSL的标准一致，但在与某些按列优先存储矩阵的系统（如某些数学库）交互时需要注意顺序转换。

控件

Matrix 2x2节点的控件界面是用户与节点交互的主要途径，通过这个界面，开发者可以直观地设置矩阵的具体数值。

矩阵控件

Matrix 2x2节点的核心控件是一个2x2的矩阵输入界面，允许用户直接设置四个矩阵元素的值。这个设计既满足了精确控制的需求，又保持了操作的直观性。

• 名称：（无特定名称，通常以节点类型标识）
• 类型：Matrix 2x2
• 选项：无
• 描述：设置输出值

控件界面通常呈现为一个2行2列的网格，每个单元格对应矩阵中的一个元素。用户可以直接在单元格中输入数值，或者通过拖拽方式调整值。在某些Shader Graph版本中，还可能支持通过表达式或引用其他节点的方式来定义矩阵值，这增加了使用的灵活性。

矩阵控件的默认值通常是单位矩阵（Identity Matrix），即主对角线上的元素为1，其他元素为0。单位矩阵在矩阵运算中扮演着类似于数字1的角色，任何矩阵与单位矩阵相乘都不会改变。这种默认设置是合理的，因为它确保了新添加的Matrix 2x2节点不会意外改变现有的变换效果。

从用户体验角度考虑，矩阵控件的设计遵循了Shader Graph的一致性原则：提供即时视觉反馈。当用户修改矩阵值时，可以立即在Shader Graph的预览窗口中看到效果变化，这大大加快了着色器的迭代开发过程。

对于高级用户，矩阵控件还支持通过脚本或Graph API进行批量设置和自动化操作，这在处理大量相似着色器或需要程序化生成材质的情况下非常有用。

生成的代码示例

当Shader Graph编译时，Matrix 2x2节点会生成对应的HLSL代码，了解这些代码有助于深入理解节点的底层工作原理和进行高级优化。

基础代码生成

最基本的Matrix 2x2节点会生成如下形式的HLSL代码：

HLSL

float2x2 _Matrix2x2 = float2x2(1, 0, 0, 1);

这行代码声明了一个名为_Matrix2x2的float2x2类型变量，并将其初始化为单位矩阵。在HLSL语法中，float2x2构造函数接受四个浮点参数，按行优先顺序排列：第一行第一个元素、第一行第二个元素、第二行第一个元素、第二行第二个元素。

自定义矩阵值

如果用户在控件中设置了非默认的矩阵值，例如：

[2, 1]
[3, 4]

生成的代码将反映这些变化：

HLSL

float2x2 _Matrix2x2 = float2x2(2, 1, 3, 4);

这种直接的代码生成方式确保了Shader Graph可视化编程与文本式着色器编程之间的一致性。对于熟悉HLSL的开发者来说，这种透明性使得他们可以预测和优化最终生成的着色器代码。

代码集成

在完整的着色器中，生成的矩阵变量可以被其他部分引用。例如，结合矩阵乘法运算：

HLSL

// Matrix 2x2节点生成的代码
float2x2 _RotationMatrix = float2x2(0.707, -0.707, 0.707, 0.707);

// 其他节点可能生成的代码
float2 inputVector = float2(1, 0);
float2 transformedVector = mul(_RotationMatrix, inputVector);

此示例展示了如何用Matrix 2x2节点定义一个旋转矩阵，并将其应用于输入向量。在实际的Shader Graph中，这些操作通过节点连接可视化完成，但底层仍然转换为类似的HLSL代码。

理解代码生成机制对于调试复杂着色器尤为重要。当遇到性能问题或渲染错误时，检查生成的HLSL代码可以帮助定位问题源头，确定是Matrix 2x2节点本身的问题，还是与其他节点组合使用时产生的问题。

应用场景

Matrix 2x2节点在Shader Graph中有多种应用场景，从简单的变换操作到复杂的数学计算都能发挥作用。

2D变换操作

2x2矩阵最直接的用途是表示二维线性变换，包括旋转、缩放、剪切等操作。

• 旋转：通过2x2旋转矩阵可以对2D坐标进行旋转变换。旋转矩阵的形式为：

  [cos(θ), -sin(θ)]
  [sin(θ),  cos(θ)]
  

  其中θ表示旋转角度。在Shader Graph中，可以通过将Matrix 2x2节点与三角函数节点结合来创建这样的矩阵。

• 缩放：缩放矩阵是对角矩阵，对角线上的元素表示各轴的缩放因子：

  [sx,  0]
  [ 0, sy]
  

  这种矩阵在实现非均匀缩放效果时非常有用。

• 剪切：剪切变换可以通过非对角矩阵实现，例如：

  [1, k]
  [0, 1]
  

  表示水平剪切变换，其中k是剪切因子。

UV动画与变形

在纹理采样前对UV坐标进行变换是Matrix 2x2节点的常见应用。

• 流动效果：通过旋转矩阵可以使纹理UV产生旋转流动效果，常用于水面、魔法特效等场景。
• 动态变形：结合时间节点，可以创建动态变化的矩阵，实现纹理的脉动、扭曲等复杂动画效果。
• 多图层混合：使用不同的变换矩阵处理多个纹理图层，然后通过混合节点合成，可以创建丰富的材质效果。

数学运算与算法实现

除了图形变换，2x2矩阵在实现特定算法方面也有重要作用。

• 线性方程组求解：2x2矩阵可用于表示和求解二元线性方程组，在着色器中实现简单的数学建模。
• 特征值分解：对于对称2x2矩阵，可以相对容易地计算特征值和特征向量，用于方向性效果和物理模拟。
• 坐标系统转换：在不同2D坐标系统之间转换时，2x2矩阵可以表示基变换。

性能优化

在某些情况下，使用2x2矩阵代替更高维矩阵可以优化着色器性能。

• 简化计算：当处理2D数据时，使用2x2矩阵而不是4x4矩阵可以减少计算量，提高着色器执行效率。
• 特定硬件优化：在移动平台或低端硬件上，减少矩阵运算复杂度可以显著提升渲染性能。

与其他节点的连接

Matrix 2x2节点的真正威力在于与其他Shader Graph节点的组合使用，通过节点连接可以构建复杂的着色器功能。

与数学节点的连接

Matrix 2x2节点可以与各种数学节点连接，实现动态矩阵生成和变换。

• 三角函数节点：结合Sin和Cos节点可以创建旋转矩阵，实现基于角度的旋转变换。
• 算术运算节点：通过Add、Multiply等节点可以对矩阵值进行动态修改，创建动画效果。
• 向量分解节点：使用Vector2节点的输出作为矩阵的输入元素，实现基于向量的矩阵构造。

与矩阵运算节点的连接

Shader Graph提供了专门的矩阵运算节点，与Matrix 2x2节点配合使用。

• 矩阵乘法节点：将Matrix 2x2节点与另一个矩阵或向量连接，实现线性变换。
• 矩阵转置节点：获取Matrix 2x2节点的转置矩阵，用于特定数学运算。
• 矩阵求逆节点：计算2x2矩阵的逆矩阵，用于撤销变换效果。

与采样器和纹理节点的连接

Matrix 2x2节点可以控制纹理采样过程，实现动态纹理效果。

• UV变换：将Matrix 2x2节点连接到Sample Texture 2D节点的UV输入，实现对纹理坐标的变换。
• 多纹理混合：使用不同的变换矩阵处理多个纹理，然后通过混合节点合成复杂材质。
• 程序化生成：结合噪声节点和矩阵变换，可以程序化生成各种自然图案和效果。

与自定义函数节点的连接

对于高级用户，Matrix 2x2节点可以与Custom Function节点结合，实现Shader Graph原生节点无法提供的功能。

• 特殊算法：将矩阵传递给自定义HLSL函数，实现复杂的数学运算或特定渲染算法。
• 数据封装：使用矩阵作为多个相关参数的封装，简化节点图的复杂度。
• 跨图形API兼容：通过自定义函数处理不同图形API下的矩阵差异，确保着色器跨平台兼容。

最佳实践与性能考虑

正确使用Matrix 2x2节点不仅关乎功能实现，还影响着色器的性能和可维护性。

性能优化策略

在实时渲染中，性能始终是关键考虑因素，使用Matrix 2x2节点时应注意以下性能要点：

• 优先使用2x2矩阵：当处理2D数据时，使用2x2矩阵而不是更高维矩阵可以减少计算开销。与4x4矩阵相比，2x2矩阵乘法只需要4次乘法和2次加法，而4x4矩阵需要16次乘法和12次加法。
• 避免每帧更新：由于Matrix 2x2节点定义的是常量矩阵，不适合需要频繁更新的场景。对于动态矩阵，考虑使用脚本通过Material.SetMatrix方法传递，或使用Shader Graph属性并设置为可动态更新。
• 合理使用矩阵运算：不是所有变换都需要矩阵表示。简单的平移、缩放操作有时使用向量运算更为高效，特别是在移动平台上。
• 注意精度选择：在不需要高精度的场合，考虑使用half精度而不是float精度，这可以显著提升移动设备的性能。

节点图优化技巧

优化Shader Graph节点图结构可以提高工作效率并减少错误：

• 命名规范：为Matrix 2x2节点赋予描述性名称，如"RotationMatrix"或"UvTransform"，便于理解和维护复杂节点图。
• 模块化设计：将常用的矩阵变换封装为Sub Graph，提高重用性并减少节点图复杂度。
• 默认值设置：合理设置矩阵的默认值，确保新材质实例具有预期的初始行为。
• 文档注释：使用Sticky Note节点为复杂的矩阵运算添加说明，便于团队协作和后期维护。

调试与故障排除

当使用Matrix 2x2节点遇到问题时，以下调试技巧可能有所帮助：

• 预览节点输出：使用Preview节点可视化矩阵变换结果，检查是否符合预期。
• 分步验证：复杂矩阵运算应分步验证，确保每个阶段的结果正确。
• 检查矩阵顺序：确认矩阵构造和乘法顺序是否正确，行优先和列优先顺序的混淆是常见错误来源。
• 验证单位矩阵：当不确定矩阵运算是否正确时，先用单位矩阵测试，确保基础流程正常工作。

实际案例

通过具体案例可以更好地理解Matrix 2x2节点的实际应用。

案例一：2D精灵旋转动画

创建一个使2D精灵绕中心点旋转的着色器：

1. 添加Matrix 2x2节点到Shader Graph中
2. 创建Time节点和Multiply节点，将时间与旋转速度相乘
3. 使用Sin和Cos节点根据角度生成旋转矩阵元素
4. 将旋转矩阵连接到Sprite Shader节点的UV输入
5. 调整旋转中心，确保精灵绕正确点旋转

这种技术可用于创建游戏中的旋转道具、角色特效等。

案例二：动态纹理变形

实现一个随时间动态变形的纹理效果：

1. 使用两个Matrix 2x2节点，一个用于基础变换，一个用于动态扰动
2. 将Time节点与噪声节点结合，生成动态扰动因子
3. 通过矩阵乘法组合基础变换和扰动矩阵
4. 将最终矩阵应用于纹理采样UV
5. 调整参数控制变形强度和频率

这种效果适用于水面、热浪扭曲等场景。

案例三：多图层UV变换

创建具有多个纹理图层，每层有独立变换的复杂材质：

1. 为每个纹理图层创建独立的Matrix 2x2节点
2. 使用不同的变换参数（旋转角度、缩放因子等）
3. 将各变换矩阵分别应用到对应的纹理采样节点
4. 使用混合节点合并各图层结果
5. 通过参数控制图层混合方式

这种方法可以创建丰富的材质效果，如锈迹斑斑的金属、磨损的皮革等。

【Unity Shader Graph 使用与特效实现】专栏-直达 （欢迎点赞留言探讨，更多人加入进来能更加完善这个探索的过程，🙏）

The patch command applies a set of changes described in a diff file to one or more original files. It is the standard way to distribute and apply source code changes, security fixes, and configuration updates in Linux, and pairs directly with the diff command.

This guide explains how to use the patch command in Linux with practical examples.

Syntax #

The general syntax of the patch command is:

patch [OPTIONS] [ORIGINALFILE] [PATCHFILE]

You can pass the patch file using the -i option or pipe it through standard input:

patch [OPTIONS] -i patchfile [ORIGINALFILE]
patch [OPTIONS] [ORIGINALFILE] < patchfile

patch Options #

Create and Apply a Basic Patch #

The most common workflow is to use diff to generate a patch file and patch to apply it.

Start with two versions of a file. Here is the original:

print("Hello, World!")
print("Version 1")

And the updated version:

print("Hello, Linux!")
print("Version 2")

Use diff with the -u flag to generate a unified diff and save it to a patch file:

diff -u hello.py hello_new.py > hello.patch

The hello.patch file will contain the following differences:

--- hello.py 2026-02-21 10:00:00.000000000 +0100
+++ hello_new.py 2026-02-21 10:05:00.000000000 +0100
@@ -1,2 +1,2 @@
-print("Hello, World!")
-print("Version 1")
+print("Hello, Linux!")
+print("Version 2")

To apply the patch to the original file:

patch hello.py hello.patch

patching file hello.py

hello.py now contains the updated content from hello_new.py.

Dry Run Before Applying #

Use --dry-run to test whether a patch will apply cleanly without actually modifying any files:

patch --dry-run hello.py hello.patch

patching file hello.py

If the patch cannot be applied cleanly, patch reports the conflict without touching any files. This is useful before applying patches from external sources or when you are unsure whether a patch has already been applied.

Back Up the Original File #

Use the -b option to create a backup of the original file before applying the patch. The backup is saved with a .orig extension:

patch -b hello.py hello.patch

patching file hello.py

After running this command, hello.py.orig contains the original unpatched file. You can restore it manually if needed.

Strip Path Components with -p #

When a patch file is generated from a different directory structure than the one where you apply it, the file paths inside the patch may not match your local paths. Use -p N to strip N leading path components from the paths recorded in the patch.

For example, a patch generated with git diff will reference files like:

--- a/src/utils/hello.py
+++ b/src/utils/hello.py

To apply this patch from the project root, use -p1 to strip the a/ and b/ prefixes:

patch -p1 < hello.patch

-p1 is the standard option for patches generated by git diff and by diff -u from the root of a project directory. Without it, patch would look for a file named a/src/utils/hello.py on disk, which does not exist.

Reverse a Patch #

Use the -R option to undo a previously applied patch and restore the original file:

patch -R hello.py hello.patch

patching file hello.py

The file is restored to its state before the patch was applied.

Apply a Multi-File Patch #

A single patch file can contain changes to multiple files. In this case, you do not specify a target file on the command line — patch reads the file names from the diff headers inside the patch:

patch -p1 < project.patch

patch processes each file name from the diff headers and applies the corresponding changes. Use -p1 when the patch was produced by git diff or diff -u from the project root.

Quick Reference #

Troubleshooting #

Hunk #1 FAILED at line N.
The patch does not match the current content of the file. This usually means the file has already been modified since the patch was created, or you are applying the patch against the wrong version. patch creates a .rej file containing the failed hunk so you can review and apply the change manually.

Reversed (or previously applied) patch detected! Assume -R?
patch has detected that the changes in the patch are already present in the file — the patch may have been applied before. Answer y to reverse the patch or n to skip it. Use -N (--forward) to automatically skip already-applied patches without prompting.

patch: **** malformed patch at line N
The patch file is corrupted or not in a recognized format. Make sure the patch was generated with diff -u (unified format). Non-unified formats require the -c (context) or specific format flag to be passed to patch.

File paths in the patch do not match files on disk.
Adjust the -p N value. Run patch --dry-run -p0 < changes.patch first, then increment N (-p1, -p2) until patch finds the correct files.

FAQ #

How do I create a patch file?
Use the diff command with the -u flag: diff -u original.txt updated.txt > changes.patch. The -u flag produces a unified diff, which is the format patch works with by default. See the diff command guide for details.

What does -p1 mean?
-p1 tells patch to strip one leading path component from file names in the patch. Patches generated by git diff prefix file paths with a/ and b/, so -p1 removes that prefix before patch looks for the file on disk.

How do I undo a patch I already applied?
Run patch -R originalfile patchfile. patch reads the diff in reverse and restores the original content.

What is a .rej file?
When patch cannot apply one or more sections of a patch (called hunks), it writes the failed hunks to a file with a .rej extension alongside the original file. You can open the .rej file and apply those changes manually.

What is the difference between patch and git apply?
Both apply diff files, but git apply is designed for use inside a Git repository and integrates with the Git index. patch is a standalone POSIX tool that works on any file regardless of version control.

Conclusion #

The patch command is the standard tool for applying diff files in Linux. Use --dry-run to verify a patch before applying it, -b to keep a backup of the original, and -R to reverse changes when needed.

If you have any questions, feel free to leave a comment below.

1. 浅拷贝

对于引用数据类型只拷贝第一层，若第一层中也存在引用数据类型，则拷贝的仅仅是地址，若该数据修改，则会影响原数据

示例数据

const originalObj = {
    name: 'John',
    age: 30,
    address: {
        city: 'Beijing',
        country: 'China',
    },
    hobbies: ['reading', 'traveling', 'cooking'],
};

const originalArr = [1, 2, 3, { a: 4 }];

使用Object.assign()

const shallowCopyObj = Object.assign({}, originalObj);

解构赋值

// 对象
const shallowCopyObj2 = { ...originalObj };
// 数组
const shallowCopyArr4 = [...originalArr];

拷贝数组

// 拷贝数组：使用Array.prototype.slice()
const shallowCopyArr = originalArr.slice();

// 拷贝数组：使用Array.prototype.concat()
const shallowCopyArr2 = originalArr.concat();

// 拷贝数组：使用Array.from()
const shallowCopyArr3 = Array.from(originalArr);

2. 深拷贝

深拷贝完全复制对象，如果对象中存在嵌套的引用数据类型，则会另外开辟一个空间来进行存储，拷贝后的对象与原对象互相独立，互不影响

递归实现深拷贝

function deepClone(obj) {
    // 基础数据类型直接原样返回
    if (obj === null || typeof obj !== 'object') {
        return obj;
    }

    // 处理数组
    if (Array.isArray(obj)) {
        return obj.map(deepClone);
    }

    const result = {};
    Object.keys(obj).forEach((key) => {
        // 只拷贝对象自己本身的属性，不拷贝原型链上的属性
        if (obj.hasOwnProperty(key)) {
            result[key] = deepClone(obj[key]);
        }
    });

    return result;
}

递归实现深拷贝进阶版：解决循环引用，Date和正则的拷贝

function deepCloneCircular(obj, visited = new WeakMap()) {
    // 基础数据类型直接原样返回
    if (obj === null || typeof obj !== 'object') {
        return obj;
    }

    // 检查循环引用
    if (visited.has(obj)) {
        return visited.get(obj);
    }

    if (obj instanceof Date) {
        return new Date(obj);
    }

    if (obj instanceof RegExp) {
        return new RegExp(obj.source, obj.flags);
    }

    const result = Array.isArray(obj) ? [] : {};

    // 保存引用避免循环引用
    visited.set(obj, result);

    Object.keys(obj).forEach((key) => {
        // 只拷贝对象自己本身的属性，不拷贝原型链上的属性
        if (obj.hasOwnProperty(key)) {
            result[key] = deepCloneCircular(obj[key], visited);
        }
    });

    return result;
}

JSON方法实现深拷贝

function deepCloneByJSON(obj) {
    return JSON.parse(JSON.stringify(obj));
}

局限性：

1. 无法拷贝函数：如果对象中存在函数，拷贝结果中函数将会丢失
2. 无法拷贝undefined：拷贝过程中值为undefined的属性会丢失
3. 无法拷贝Symbol：拷贝过程中如果键名为Symbol也会拷贝丢失
4. Date类型会被转为字符串
5. 正则对象在拷贝过程中也会丢失
6. NaN和Infinity在拷贝过程中会变为null
7. 若对象中存在循环饮用，则会报错
8. 对于Map,Set,WeakMap,WeakSet的拷贝结果会变为{}空对象

使用现代浏览器支持方法

// 现代浏览器原生支持 (Chrome 98+, Firefox 94+, Node 17+)
const result = structuredClone(originalObj);

一、起因：为什么要做这个项目？

最近在做数据可视化需求时，看了太多千篇一律的后台管理界面，总想着能不能做点更酷的东西。正好看到很多政府和企业的智慧城市指挥中心大屏，那些闪烁的数据、3D 地图、实时图表，科技感爆棚！

于是决定自己撸一个，顺便探索一下现代前端可视化技术的边界。

二、效果展示：先看看成品

🎨 整体布局

• 左侧面板：经济指标 + 4 种图表（饼图、柱状图、折线图、面积图）
• 中间地图：3D 网格地图 + 5 个区域标记（西南/中心/西北/东北/东南）
• 右侧面板：人口民生 + 雷达图 + 指标卡片
• 底部导航：城市交通、城市安全、人口民生三大模块切换

✨ 核心亮点

1. 炫酷的 3D 地图效果：透视网格 + 发光区域圆圈 + 浮动标记
2. 丰富的图表交互：悬停显示详细数据，Tooltip 自定义样式
3. 流畅的动画效果：Framer Motion 驱动的进场动画 + 数据轮播
4. 完整的数据流：Mock API + 自动刷新 Hook + 数据轮播组件
5. 响应式布局：左右面板自适应宽度，图表自动撑满

三、技术栈：用了哪些工具？

四、核心功能拆解

📊 1. 自定义 Tooltip（图表交互增强）

痛点：Recharts 默认 Tooltip 样式太朴素，不符合科技大屏的气质。

解决方案：自定义 Tooltip 组件

const CustomTooltip = ({ active, payload, label }: any) => {
  if (active && payload && payload.length) {
    return (
      <div className="bg-[#0a1628]/95 backdrop-blur-md border border-cyan-500/30 rounded-lg p-3 shadow-[0_0_20px_rgba(0,229,255,0.3)]">
        <p className="text-cyan-400 text-xs font-bold mb-2">{label}</p>
        {payload.map((entry: any, index: number) => (
          <div key={index} className="flex items-center gap-2">
            <div className="w-2 h-2 rounded-full" style={{ backgroundColor: entry.color }} />
            <span className="text-white">{entry.name}: {entry.value}</span>
          </div>
        ))}
      </div>
    );
  }
  return null;
};

效果：

• 深色半透明背景 + 发光边框
• 彩色指示点与图表颜色对应
• 平滑的淡入淡出动画

🗺️ 2. 3D 地图效果（视觉核心）

实现思路：

1. 透视网格：使用 CSS transform: perspective() rotateX() 创建 3D 感
2. 发光圆圈：每个区域用渐变圆圈 + blur 阴影 + animate-pulse
3. 浮动标记：自定义 3D 金字塔 SVG + 上下浮动动画

// 透视网格
<div style={{
  background: `
    linear-gradient(rgba(0, 229, 255, 0.1) 1px, transparent 1px), 
    linear-gradient(90deg, rgba(0, 229, 255, 0.1) 1px, transparent 1px)
  `,
  backgroundSize: '60px 60px',
  transform: 'perspective(1000px) rotateX(70deg) translateY(-200px) scale(1.5)',
  maskImage: 'radial-gradient(circle at center, black 0%, transparent 70%)',
}} />

技巧：

• 用 maskImage 实现边缘渐隐效果
• 5 个区域圆圈位置精确对应地图标记
• 标记自带信息卡片，悬停放大

🔄 3. 数据自动刷新（实战 Hooks）

需求：模拟实时数据更新，每 5 秒刷新一次。

自定义 Hook：

export function useDataRefresh<T>(
  fetchFunction: () => Promise<T>,
  interval: number = 5000,
  initialData: T
) {
  const [data, setData] = useState<T>(initialData);
  const [loading, setLoading] = useState(false);

  const fetchData = useCallback(async () => {
    try {
      setLoading(true);
      const result = await fetchFunction();
      setData(result);
    } catch (err) {
      console.error('Data fetch error:', err);
    } finally {
      setLoading(false);
    }
  }, [fetchFunction]);

  useEffect(() => {
    fetchData(); // 初始加载
    const timer = setInterval(fetchData, interval); // 定时刷新
    return () => clearInterval(timer);
  }, [fetchData, interval]);

  return { data, loading, refresh: fetchData };
}

使用方式：

const { data, loading, refresh } = useDataRefresh(
  fetchMetrics, // Mock API 函数
  5000,         // 刷新间隔
  []            // 初始数据
);

🎠 4. 数据轮播组件（动态展示）

场景：首页需要轮播展示多个重点指标。

实现要点：

1. useDataCarousel Hook：管理轮播逻辑
2. AnimatePresence：切换时的淡入淡出动画
3. 控制按钮：上一个/下一个/播放/暂停

const { currentData, next, prev, pause, play, isPlaying } = 
  useDataCarousel(dataList, 3000);

<AnimatePresence mode="wait">
  <motion.div
    key={currentIndex}
    initial={{ opacity: 0, x: 50 }}
    animate={{ opacity: 1, x: 0 }}
    exit={{ opacity: 0, x: -50 }}
    transition={{ duration: 0.5 }}
  >
    {/* 数据内容 */}
  </motion.div>
</AnimatePresence>

亮点：

• 支持手动控制和自动播放
• 轮播指示器实时同步
• 数据切换动画流畅自然

📡 5. Mock API 数据服务

为什么需要 Mock：

• 前端开发阶段后端接口未就绪
• 方便演示和测试
• 模拟随机数据，更真实

API 设计：

// Mock API: 获取指标数据
export const fetchMetrics = async (): Promise<MetricData[]> => {
  await delay(500); // 模拟网络延迟
  return [
    { 
      title: '公共预算收入', 
      value: random(500, 600).toString(), 
      unit: '亿', 
      trend: 'up', 
      percentage: random(20, 30) 
    },
    // ... 更多数据
  ];
};

完整 API 列表：

• fetchMetrics() - 顶部指标卡片
• fetchLineChartData() - 折线图
• fetchPieData() - 饼图
• fetchBarChartData() - 柱状图
• fetchAreaChartData() - 面积图
• fetchRadarData() - 雷达图
• fetchMapMarkers() - 地图标记

🎨 6. 响应式布局方案

挑战：大屏通常是固定分辨率，但需要适配不同屏幕。

方案对比：

我的选择：Flexbox + 百分比宽度

// 左右面板自适应
<div className="w-[22%] min-w-[320px] max-w-[400px]">
  {/* 面板内容 */}
</div>

// 图表区域撑满
<div className="flex-1 min-h-0 overflow-y-auto">
  {/* 图表列表 */}
</div>

技巧：

• flex-1 + min-h-0 解决 flex 子元素溢出
• overflow-y-auto 让图表区域可滚动
• ResponsiveContainer 让图表自动适应容器

五、踩坑实录

🐛 坑 1：Recharts 图表不撑满容器

现象：图表固定高度，无法充满 flex 容器。

原因：ResponsiveContainer 需要明确的高度。

解决：

// ❌ 错误写法
<div className="flex-1">
  <ResponsiveContainer width="100%" height="100%">
    <LineChart data={data} />
  </ResponsiveContainer>
</div>

// ✅ 正确写法
<div className="flex-1 min-h-0"> {/* 关键：min-h-0 */}
  <ResponsiveContainer width="100%" height="100%">
    <LineChart data={data} />
  </ResponsiveContainer>
</div>

🐛 坑 2：Framer Motion 动画闪烁

现象：列表项动画时会闪烁或重复。

原因：没有设置唯一的 key。

解决：

<AnimatePresence mode="wait"> {/* mode="wait" 很重要 */}
  <motion.div key={currentIndex}> {/* key 必须唯一 */}
    {/* 内容 */}
  </motion.div>
</AnimatePresence>

🐛 坑 3：地图标记位置不准

现象：标记偏离预期位置。

原因：绝对定位的基准点是左上角，而不是标记中心。

解决：

<div style={{ left: x, top: y }}> {/* 左上角定位 */}
  <div className="transform -translate-x-1/2 -translate-y-1/2"> {/* 居中偏移 */}
    {/* 标记内容 */}
  </div>
</div>

六、性能优化建议

⚡ 1. 图表按需加载

import { LineChart } from 'recharts'; // ✅ 具名导入
// 而不是 import * as Recharts from 'recharts'; // ❌

⚡ 2. 动画节流

// 使用 Framer Motion 的 layout 模式
<motion.div layout layoutId="card">

⚡ 3. 数据缓存

const [cachedData, setCachedData] = useState({});
// 相同请求返回缓存结果

七、未来计划

• WebSocket 实时数据推送：替换定时轮询
• 可配置主题：支持多种颜色方案
• 其他界面：增加其他tab大屏

八、总结

这个项目最大的收获是：

1. Recharts 不只是画图：结合 TypeScript + 自定义组件，可以实现高度定制化
2. Hooks 真香：useDataRefresh 和 useDataCarousel 可以复用到任何项目
3. CSS 动画比想象中强大：perspective + blur + animate-pulse 就能做出酷炫效果
4. Mock 数据是好习惯：前后端分离开发效率翻倍

如果你也在做数据可视化项目，希望这篇文章能给你一些启发！

九、快速上手

📦 安装依赖

npm install react recharts framer-motion lucide-react
npm install -D tailwindcss @tailwindcss/vite

🚀 启动项目

npm run dev

📂 项目结构

src/
├── api/
│   └── mockData.ts          # Mock API 服务
├── hooks/
│   └── useDataRefresh.ts    # 数据刷新 Hook
├── components/
│   └── DataCarouselDemo.tsx # 轮播组件
└── App.tsx                  # 主应用

本文所有代码均可商用，欢迎参考和学习！

我放在公众号（柳杉前端） 回复 智慧城市大屏 获取源码

#前端开发 #数据可视化 #React #智慧城市 #大屏设计

URL编码/解码 核心JS实现

核心功能实现

URL编码/解码工具的核心功能基于JavaScript原生的四个方法：encodeURI、encodeURIComponent、decodeURI 和 decodeURIComponent。这四个方法是浏览器内置的，无需引入任何外部库，直接就可以使用。

在线工具网址：see-tool.com/url-encode-…
工具截图：

状态管理

使用Vue的响应式数据来管理输入和输出状态，这样当数据变化时，界面会自动更新：

const inputText = ref('')
const outputText1 = ref('')
const outputText2 = ref('')

这里定义了三个响应式变量：inputText 用于存储用户输入的原始文本，outputText1 用于存储 encodeURI 处理后的结果，outputText2 用于存储 encodeURIComponent 处理后的结果。

编码功能

编码功能是整个工具的核心之一。当用户点击编码按钮时，会触发 handleEncode 函数：

const handleEncode = () => {
  if (!inputText.value.trim()) {
    MessagePlugin.warning(t('urlEncodeDecode.emptyInput'))
    return
  }

  try {
    outputText1.value = encodeURI(inputText.value)
    outputText2.value = encodeURIComponent(inputText.value)
    MessagePlugin.success(t('urlEncodeDecode.encode') + ' ' + t('urlEncodeDecode.copied'))
  } catch (error) {
    console.error('Encode error:', error)
    MessagePlugin.error(t('urlEncodeDecode.encodeError'))
  }
}

这个函数首先检查用户是否输入了内容，如果输入框为空，会显示一个提示消息。然后使用 try-catch 包裹编码逻辑，防止异常导致程序崩溃。编码成功后，会同时生成两种编码结果并显示在界面上，同时给出成功提示。

解码功能

解码功能与编码功能相对应，当用户点击解码按钮时，会触发 handleDecode 函数：

const handleDecode = () => {
  if (!inputText.value.trim()) {
    MessagePlugin.warning(t('urlEncodeDecode.emptyInput'))
    return
  }

  try {
    outputText1.value = decodeURI(inputText.value)
    outputText2.value = decodeURIComponent(inputText.value)
    MessagePlugin.success(t('urlEncodeDecode.decode') + ' ' + t('urlEncodeDecode.copied'))
  } catch (error) {
    console.error('Decode error:', error)
    MessagePlugin.error(t('urlEncodeDecode.decodeError'))
  }
}

解码函数的结构和编码函数类似，同样先检查输入是否为空，然后尝试使用 decodeURI 和 decodeURIComponent 进行解码。需要注意的是，如果输入的编码字符串格式不正确，解码可能会抛出异常，所以必须使用 try-catch 来捕获错误并给用户友好的提示。

清空功能

清空功能可以一键清除所有输入和输出内容，方便用户重新开始：

const clearAll = () => {
  inputText.value = ''
  outputText1.value = ''
  outputText2.value = ''
  MessagePlugin.info(t('urlEncodeDecode.clear'))
}

这个函数很简单，就是将三个响应式变量都重置为空字符串，然后显示一个信息提示。

复制功能

复制功能是一个很实用的功能，用户可以一键将编码或解码结果复制到剪贴板：

const copyResult1 = async () => {
  if (!outputText1.value.trim()) {
    MessagePlugin.warning(t('urlEncodeDecode.noContent'))
    return
  }

  try {
    await navigator.clipboard.writeText(outputText1.value)
    MessagePlugin.success(t('urlEncodeDecode.copied'))
  } catch {
    const textarea = document.createElement('textarea')
    textarea.value = outputText1.value
    document.body.appendChild(textarea)
    textarea.select()
    document.execCommand('copy')
    document.body.removeChild(textarea)
    MessagePlugin.success(t('urlEncodeDecode.copied'))
  }
}

复制功能首先检查是否有内容可复制。然后优先使用现代浏览器的 navigator.clipboard API，这是目前推荐的方式。如果这个 API 不可用（比如在一些旧浏览器中），就会使用降级方案：创建一个临时的 textarea 元素，将内容设置进去，选中后执行 document.execCommand('copy') 命令，最后再移除这个临时元素。无论使用哪种方式，复制成功后都会给用户一个成功提示。

自动聚焦

为了提升用户体验，页面加载时会自动聚焦到输入框，用户可以直接开始输入：

onMounted(() => {
  if (process.client) {
    const input = document.querySelector('textarea')
    if (input) {
      input.focus()
    }
  }
})

这里使用了 Vue 的 onMounted 生命周期钩子，在组件挂载后执行。首先判断是否在客户端环境（因为 Nuxt.js 支持服务端渲染，服务端没有 DOM），然后找到 textarea 元素并调用 focus() 方法聚焦。

encodeURI 和 encodeURIComponent 的区别

这两个方法虽然都是用来编码 URL 的，但它们的使用场景不同：

• encodeURI 主要用于编码完整的URL，不会编码URL中的特殊字符（如 :/?#[]@!$&'()*+,;=），因为这些字符在 URL 中是有特殊含义的，需要保留。
• encodeURIComponent 会编码所有字符，包括URL中的特殊字符，所以它更适合编码 URL 的参数部分，比如查询字符串的值。

相应的，解码时也需要使用对应的方法：decodeURI 对应 encodeURI，decodeURIComponent 对应 encodeURIComponent。

以上就是URL编码/解码工具的核心JS实现。

Vue是一个流行的框架，它能够提供如同翻转开关一样的快速响应和大量的帮助功能来实现更快更好的交互。随着Vue 3的推出，很多人看到了它的潜力。在 Vue 3 的生命周期里，Vue 结合了模板的优化，以及 v-model、生命周期钩子等细节做了很多改进，可以更好的适应更快的发展需求。而 Vite 作为一种开发环境，对于 Vue 来说是必不可少的工具之一。在目前的 Vue 3 中，Vite 的速度已经超越了 Webpack。

在Vue 3的生命周期里，我们还要提一下 Element Plus， Element Plus是一个基于Element UI的组件库，但是 Element Plus 比 Element UI 更为轻量级，更为简洁。Element Plus的目标是“提供优雅的组件”，并将组件使用进行了重构和优化。同时，它也为大量的开发者提供了一些非常有用的工具和组件。不出意外，Element Plus 很快就会成为 Vue 开发中的一大利器。

Vue、Vite和Element Plus三个工具的结合可以帮助我们更好的进行开发工作。在开发中，我们可以使用Vue来编写组件，使用Element Plus来提供样式和组件，同时使用Vite来启动本地开发服务器。这样的话，开发者可以更加专注于业务逻辑的实现，同时又可以减少很多不必要的麻烦。

安装配置

首先，我们需要保证我们安装了Node.js和npm包管理器。然后，在命令行中输入以下命令来安装Vue CLI和Vite：

npm install -g @vue/cli
npm install -g vite

接着，我们可以使用如下命令来创建一个Vue 3项目：

# 使用Vue CLI创建项目
vue create my-project

cd my-project

# 安装Element Plus
npm install element-plus

创建完项目并安装好Element Plus之后，在项目根目录下运行以下命令启动Vite开发服务器：

npm install
npm run dev

这时候我们在浏览器中输入 http://localhost:3000 就能看到我们的项目页面了。

使用

在我们的Vue代码中，可以通过import引入Element Plus组件：

import { ElButton } from 'element-plus';

export default {
  components: {
    ElButton,
  },
}

然后就可以在模板中使用<el-button>标签来使用Element Plus提供的按钮组件了：

<template>
  <div>
    <el-button>点击我</el-button>
  </div> 
</template>

除了组件，Element Plus还提供了一些非常实用的工具函数，例如 message 和 notification。我们可以通过如下方式来引入和使用它们：

import { createApp } from 'vue';
import ElementPlus from 'element-plus';
import 'element-plus/lib/theme-chalk/index.css';

import App from './App.vue';

const app = createApp(App);

app.use(ElementPlus);

app.mount('#app');

在这个例子中，我们使用了 Element Plus 提供的 createApp 函数创建了我们的 Vue 实例，然后通过 use 方法将 Element Plus 安装到我们的应用程序中。最后的 mount 方法指定了我们组件的挂载点。

当然，在使用 Element Plus 的过程中，我们可能会遇到一些需要调试的问题，这时候我们可以使用 Vue Devtools 来进行调试。如果还遇到一些其他的问题，可以查看 Element Plus 的官方文档或者在社区中寻求帮助。

生命周期的不同

Vue 3 中与 Vue 2 生命周期相比，有以下变化：
beforeCreate 和 created 生命周期钩子函数的替代品是 setup 函数。在 Vue 3 中，大部分的组件逻辑都可以在 setup 函数中编写，包括组件的数据、计算属性、方法和生命周期函数等。
beforeMount 和 mounted 生命周期钩子函数的替代品是 onBeforeMount 和 onMounted 函数。
beforeUpdate 和 updated 生命周期钩子函数的替代品是 onBeforeUpdate 和 onUpdated 函数。
activated 和 deactivated 生命周期钩子函数不再有了替代品，这两个生命周期函数只在 keep-alive 组件中使用。
beforeDestroy 和 destroyed 生命周期钩子函数的替代品是 onBeforeUnmount 和 onUnmounted 函数。
errorCaptured 生命周期钩子函数的替代品是 onErrorCaptured 函数。
beforeRouteEnter、beforeRouteUpdate 和 beforeRouteLeave 生命周期钩子函数依赖于 Vue Router 的版本。在 v4 中，这些生命周期函数的替代品是 beforeRouteEnter 和 beforeRouteLeave 钩子函数。

关于VUE3一些知识点

Composition API

Composition API 允许我们按逻辑组织代码。它通过一组函数、ref、expose 等方法来管理组件内状态和行为。

例如，我们可以使用 reactive() 函数创建响应式对象：

import { reactive } from 'vue'

export default {
  setup() {
    const state = reactive({
      count: 0,
      increment() {
        state.count++
      }
    })

    return {
      state
    }
  }
}

在上面的例子中，我们使用 reactive() 函数来创建响应式对象 state。我们可以在 state 对象中使用 count 属性并将其绑定到模板中的一个元素上，以实现响应式更新。

Teleport

Teleport 允许我们在 DOM 树中的不同位置传输组件。它可以很容易地实现模态框、菜单等 UI 组件。

例如：

<template>
  <button @click="showModal = true">Show Modal</button>
  <teleport to="body">
    <div v-if="showModal" class="modal">
      <h2>Modal</h2>
      <button @click="showModal = false">Close Modal</button>
    </div>
  </teleport>
</template>

在上面的例子中，我们使用了 Teleport 组件将 modal 放置在了页面的 body 元素下。这样不仅可以避免组件层次过深，而且可以按照需要进行灵活布局。

Fragments

Fragment 允许我们在模板中使用多个根元素，并显式地声明根元素。

例如：

<template>
  <div>
    <h1>Hello, Vue 3!</h1>
    <ul>
      <li v-for="item in items" :key="item.id">{{ item.name }}</li>
    </ul>
  </div>
</template>

在上面的例子中，我们使用了 div 元素来包裹 h1 和 ul 元素。使用 Fragments，可以简化这个模板：

<template>
  <>
    <h1>Hello, Vue 3!</h1>
    <ul>
      <li v-for="item in items" :key="item.id">{{ item.name }}</li>
    </ul>
  </>
</template>

在上面的例子中，我们使用了 Fragment，以便可以在不使用 div 元素的情况下包含多个根元素。

Optimized Re-rendering

在 Vue 2 中，每个组件更新时都会重新渲染整个组件，这在大型应用程序中可能会导致性能问题。Vue 3 引入了许多优化，以提高性能。

例如，在 Vue 3 中，只有在被更改的数据上才进行更新，而在不变更的数据、方法和计算属性上则不会发生更新。

原文链接：vue3+vite+elementplus简单介绍

在前端开发的历史长河中，CSS 布局一直是重难点。很多初学者甚至有经验的开发者，在面对“父元素高度塌陷”、“外边距合并”或是“文字环绕”等问题时，往往通过死记硬背 overflow: hidden 或 clearfix 来解决，却知其然不知其所以然。

这一切背后的核心机制，就是 BFC（Block Formatting Context，块级格式化上下文） 。本文将从浏览器渲染机制的角度，带你彻底理解这一概念。

一、引言：从“消失的背景”说起

我们先来看一个经典的 CSS 布局“Bug”。

现象复现

我们构建一个父容器 .container（绿色背景）和一个子元素 .box（红色背景，左浮动）。

Html

<div class="container">
  <div class="box"></div>
</div>

CSS

.container {
  background-color: green;
  /* 此时未设置高度，期望由子元素撑开 */
}

.box {
  width: 100px;
  height: 100px;
  background-color: red;
  float: left; /* 子元素浮动 */
}

运行结果：  绿色背景消失了。父容器的高度变成了 0。

原理解析

这是典型的 父元素高度塌陷。
原因在于 CSS 的 文档流（Normal Flow）  机制。当元素设置了 float 属性后，它会 脱离文档流。对于父容器而言，在计算自身高度时，默认只计算文档流内的元素。由于 .box 已经“漂”在了上面，父容器认为自己内部是空的，因此高度为 0。

要解决这个问题，我们需要强制父容器在计算高度时，将浮动元素也包含在内。这正是 BFC 的核心能力之一。

二、深度解析：什么是 BFC

BFC (Block Formatting Context) ，直译为“块级格式化上下文”。

不要被这个学术名词吓到。从渲染引擎的角度来看，BFC 就是一个 独立的、隔离的渲染区域。

你可以将其理解为一个个封闭的“箱子”或“结界”。在这个箱子里，有一套属于自己的布局规则。

BFC 的核心渲染规则

1. 内部隔离：BFC 内部的元素布局不会影响到外部的元素，反之亦然。
2. 高度计算：计算 BFC 的高度时，浮动元素也参与计算（解决高度塌陷的核心）。
3. 布局互斥：BFC 的区域不会与 float 盒子重叠（两栏布局的核心）。
4. 垂直排列：内部的 Box 会在垂直方向，一个接一个地放置。
5. Margin 合并：属于同一个 BFC 的两个相邻 Box 的垂直 Margin 会发生重叠。

如何触发 BFC（召唤结界）

BFC 不是一个可以直接设置的属性（例如没有 bf-context: true），而是通过特定的 CSS 属性隐式触发的。

以下是常见的触发方式及其副作用对比：

注意：  很多资料会提到 position: absolute 会触发 BFC。确实如此，但请注意，BFC 仅处理文档流和浮动流的布局关系。BFC 本身并不会成为绝对定位元素的包含块（Containing Block） ，除非该元素同时设置了 position: relative/absolute。

三、实战演练：BFC 能解决什么问题

1. 清除浮动（解决高度塌陷）

场景：如引言所述，父元素高度为 0。
原理：利用 BFC 规则—— “计算 BFC 的高度时，浮动元素也参与计算” 。

CSS

.container {
  background-color: green;
  /* 触发 BFC */
  display: flow-root; 
  /* 或者使用兼容性更好的 overflow: hidden; */
}

.box {
  float: left;
  width: 100px;
  height: 100px;
  background-color: red;
}

结果：父容器高度被撑开，绿色背景正常显示。

2. 防止 Margin 重叠（外边距合并）

场景：两个相邻的 div，上一个 margin-bottom: 20px，下一个 margin-top: 20px。
现象：实际间距是 20px，而不是 40px。这是 CSS 的默认行为（Margin Collapse）。

原理：利用 BFC 规则—— “BFC 就是一个隔离容器” 。只有属于 同一个 BFC 的子元素才会发生 Margin 合并。如果我们让其中一个元素处于 另一个 BFC 中，合并就会被阻断。

Html

<div class="box">Box 1</div>

<!-- 创建一个 BFC 容器包裹 Box 2 -->
<div class="bfc-wrapper">
  <div class="box">Box 2</div>
</div>

CSS

.box {
  margin: 20px 0;
  height: 50px;
  background: blue;
}

.bfc-wrapper {
  /* 触发 BFC，形成隔离墙 */
  display: flow-root; 
}

结果：两个盒子之间的间距变为 40px。

3. 自适应两栏布局（防止文字环绕）

场景：左侧固定宽度浮动，右侧不设宽度（自适应）。
现象：如果不处理，右侧的文字会环绕在左侧浮动元素的下方（像报纸排版一样）。虽然这是 float 设计的初衷，但在布局应用中通常是不被希望的。

原理：利用 BFC 规则—— “BFC 的区域不会与 float 盒子重叠” 。当右侧元素触发 BFC 后，它会像一堵墙一样，把自己限制在浮动元素的旁边，不再“钻”到浮动元素底下。

Html

<div class="layout">
  <div class="sidebar">左侧浮动</div>
  <div class="main">右侧内容区（自适应）</div>
</div>

CSS

.sidebar {
  float: left;
  width: 200px;
  background: lightblue;
  height: 300px;
}

.main {
  /* 关键点：触发 BFC */
  display: flow-root; 
  /* 若不触发 BFC，main 的内容会环绕 sidebar，且背景色会延伸到 sidebar 下方 */
  
  background: lightcoral;
  height: 400px;
}

结果：.main 区域会自动计算剩余宽度，且与 .sidebar 泾渭分明，形成标准的左右两栏布局。

四、面试指北：满分回答模版

面试官提问：“请说说你对 BFC 的理解，它有什么用，怎么触发？”

参考回答：

1. 定义核心：
BFC 全称是块级格式化上下文。从原理上讲，它是一个独立的渲染区域或隔离容器。BFC 内部的布局规则是独立的，内部元素再怎么变化也不会影响到外部的元素，反之亦然。

2. 触发方式：
触发 BFC 的方式有很多，最现代且无副作用的方式是使用 display: flow-root。
在旧项目中，最常用的是 overflow: hidden（前提是内容不需要溢出）。
此外，设置 float 不为 none，position 为 absolute/fixed，或者 display 为 flex/inline-block 等也能触发，但会带来改变元素定位或显示模式的副作用。

3. 核心应用场景：
我在实际开发中主要用它解决三个问题：

• 清除浮动：因为 BFC 在计算高度时会包含浮动元素，可以解决父元素高度塌陷的问题。
• 布局隔离：BFC 区域不会与浮动盒子重叠，常用于实现“左侧固定、右侧自适应”的两栏布局，防止文字环绕。
• 解决外边距合并：通过将元素包裹在不同的 BFC 中，可以阻止垂直外边距（Margin）的合并。

你让 AI 帮你设计一个聊天应用的后端接口，它给你推荐了 GraphQL + WebSocket。你看着文档，心想：真的需要这么复杂吗？普通的 REST 不行吗？

技术选型时最容易陷入"别人都在用"的误区。我们习惯记忆"优缺点"，却很容易忽视其背后的设计思想。这篇文章是我试图理解"每种方案到底解决了什么问题"的思考过程，试图分析我们应该"如何选择"。

从一个简单需求开始：获取用户信息

最简单的场景

需求：前端需要显示用户的基本信息。

// Expected data
{
  "name": "Zhang San",
  "avatar": "https://...",
  "email": "zhangsan@example.com"
}

方案1：REST API

// Environment: Browser
// Scenario: Basic data fetching

// Request
fetch('https://api.example.com/users/123')
  .then(res => res.json())
  .then(data => {
    console.log(data);
    // { id: 123, name: 'Zhang San', avatar: '...', email: '...' }
  });

// Backend design (pseudo code)
app.get('/users/:id', (req, res) => {
  const user = db.getUser(req.params.id);
  res.json(user);
});

这里就够了吗？

对于简单场景：完全够用 ✅

• 清晰、直观、易于理解
• 符合 HTTP 语义（GET 获取资源）

思考点：

• 如果需求开始变复杂呢？
• 如果前端只需要用户名，不需要邮箱呢？
• 如果需要实时更新用户状态呢？

REST：理解"无状态"的设计

REST 的核心思想

REST 不是一个协议，而是一种架构风格。

核心约束：

• 客户端-服务器分离
• 无状态（Stateless）← 最重要
• 可缓存
• 统一接口
• 分层系统

为什么要"无状态"？

"无状态"意味着什么？让我先对比两种设计：

// Environment: Backend
// Scenario: Stateful design (session-based)

// Request 1
POST /login
{ username: 'zhangsan', password: '123456' }
// Response: Set session, return session_id

// Request 2
GET /profile
// Header includes session_id
// Server reads user info from session

// Problem: Server needs to "remember" user login state

// Environment: Backend
// Scenario: Stateless design (token-based)

// Request 1
POST /login
{ username: 'zhangsan', password: '123456' }
// Response: Return JWT token

// Request 2
GET /profile
// Header includes token (contains user info)
// Server parses token, no need to query session

// Advantage: Server doesn't need to "remember" anything

无状态的好处：

用个类比：你去便利店买东西。

有状态的便利店（Session） ：

• 店员记住了你昨天买了什么
• 你今天再来，店员说"还是老样子吗？"
• 问题：店员离职了怎么办？店员记不住太多人怎么办？

无状态的便利店（Token） ：

• 每次你都要重新说要买什么
• 看起来麻烦，但任何一个店员都能服务你
• 优势：换店员、开分店都没问题

技术上的好处：

• ✅ 水平扩展容易：加服务器不需要同步 session
• ✅ 容错性好：一台服务器挂了不影响其他
• ✅ 可缓存：相同请求返回相同结果

REST 的典型场景

✅ 适合 REST 的场景：

// Environment: Backend API
// Scenario: Standard CRUD operations

GET    /users       // Get user list
GET    /users/123   // Get single user
POST   /users       // Create user
PUT    /users/123   // Update user
DELETE /users/123   // Delete user

// Scenario: Clear resource relationships
GET /users/123/posts      // Posts of a user
GET /posts/456/comments   // Comments of a post

特点分析：

• 操作对象是"资源"（users、posts）
• 动作用 HTTP 方法表示（GET、POST、PUT、DELETE）
• URL 语义化，易于理解

❌ REST 开始不够用的场景：

问题1：Over-fetching（获取了不需要的数据）

// Environment: Browser
// Scenario: Frontend only needs name and avatar

fetch('/users/123')
  .then(res => res.json())
  .then(data => {
    // But returns complete user info
    console.log(data);
    // {
    //   id: 123,
    //   name: 'Zhang San',
    //   avatar: '...',
    //   email: '...',        // Don't need
    //   phone: '...',        // Don't need
    //   address: '...',      // Don't need
    //   bio: '...',          // Don't need
    //   createdAt: '...',    // Don't need
    // }
  });

问题2：Under-fetching（需要多次请求）

// Environment: Browser
// Scenario: Display post + author + comments

// Approach 1: Multiple requests (N+1 problem)
const post = await fetch('/posts/456').then(r => r.json());
const author = await fetch(`/users/${post.authorId}`).then(r => r.json());
const comments = await fetch('/posts/456/comments').then(r => r.json());

// Problem: 3 network requests, slow!

// Approach 2: Backend provides combined endpoint
fetch('/posts/456?include=author,comments')

// Problem: Backend needs to write endpoints for every combination

问题3：接口版本管理

// Environment: Backend API
// Scenario: API versioning

// v1: Basic info
GET /v1/users/123
// { id, name, email }

// v2: Added new fields
GET /v2/users/123
// { id, name, email, avatar, bio }

// Problems:
// - Maintain multiple versions
// - Client needs to know which version to use
// - When to deprecate old versions?

AI 对 REST 的理解：

AI 友好度：⭐⭐⭐⭐⭐

• ✅ AI 非常擅长生成 REST API
• ✅ 模式简单、规范清晰
• ✅ 大量训练数据

但 AI 可能忽略的：

• ⚠️ 复杂的查询需求（筛选、排序、分页）
• ⚠️ 接口粒度设计（太细 vs 太粗）
• ⚠️ 缓存策略

REST 的最佳实践

// Environment: Backend API
// Scenario: Good REST API design

// ✅ Use plural nouns
GET /users      // Not /user

// ✅ Use nesting for relationships
GET /users/123/posts

// ✅ Use query params for filtering
GET /posts?status=published&sort=createdAt&limit=10

// ✅ Use HTTP status codes
200 OK          // Success
201 Created     // Creation success
400 Bad Request // Client error
404 Not Found   // Resource not found
500 Server Error// Server error

// ✅ Return consistent error format
{
  "error": {
    "code": "USER_NOT_FOUND",
    "message": "User with id 123 not found"
  }
}

小结：

• REST 简单、直观、易于理解
• 适合标准的 CRUD 操作
• 当需求变复杂时（组合查询、自定义字段），REST 开始力不从心

GraphQL：解决 REST 的痛点

GraphQL 的核心思想

GraphQL 不是 REST 的替代品，而是不同的思路。

核心理念：

• 客户端精确描述需要什么数据
• 服务端按需返回，不多不少

解决 Over-fetching 和 Under-fetching

场景：显示文章详情页

// Environment: Browser + REST
// Scenario: Multiple requests needed

// Problem 1: Over-fetching
const post = await fetch('/posts/456').then(r => r.json());
// Returns all fields of post, but only need title and content

// Problem 2: Under-fetching (multiple requests)
const author = await fetch(`/users/${post.authorId}`).then(r => r.json());
const comments = await fetch('/posts/456/comments').then(r => r.json());

// Environment: Browser + GraphQL
// Scenario: Single request for exact data needed

const query = `
  query {
    post(id: 456) {
      title
      content
      author {
        name
        avatar
      }
      comments {
        content
        author {
          name
        }
      }
    }
  }
`;

fetch('https://api.example.com/graphql', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ query })
})
  .then(res => res.json())
  .then(data => {
    console.log(data);
    // {
    //   post: {
    //     title: '...',
    //     content: '...',
    //     author: { name: '...', avatar: '...' },
    //     comments: [
    //       { content: '...', author: { name: '...' } }
    //     ]
    //   }
    // }
  });

GraphQL 的优势：

• ✅ 一次请求获取所有需要的数据
• ✅ 精确控制返回的字段
• ✅ 强类型系统（schema 定义数据结构）
• ✅ 自动文档（从 schema 生成）

GraphQL 的代价

问题1：后端复杂度大增

// Environment: Backend
// Scenario: Complexity comparison

// REST: Simple and clear
app.get('/posts/:id', async (req, res) => {
  const post = await db.posts.findById(req.params.id);
  res.json(post);
});

// GraphQL: Need to define schema and resolvers
const typeDefs = `
  type Post {
    id: ID!
    title: String!
    content: String!
    author: User!
    comments: [Comment!]!
  }
  
  type User {
    id: ID!
    name: String!
    avatar: String
  }
  
  type Comment {
    id: ID!
    content: String!
    author: User!
  }
  
  type Query {
    post(id: ID!): Post
  }
`;

const resolvers = {
  Query: {
    post: (parent, { id }, context) => {
      return context.db.posts.findById(id);
    }
  },
  Post: {
    author: (post, args, context) => {
      return context.db.users.findById(post.authorId);
    },
    comments: (post, args, context) => {
      return context.db.comments.findByPostId(post.id);
    }
  },
  Comment: {
    author: (comment, args, context) => {
      return context.db.users.findById(comment.authorId);
    }
  }
};

// Need to setup Apollo Server or other GraphQL server

复杂度对比：

• REST：写一个路由就行
• GraphQL：需要定义类型、写 resolver、处理关联

问题2：N+1 查询问题

// Environment: Backend + GraphQL
// Scenario: N+1 query problem

const query = `
  query {
    posts {
      title
      author {
        name
      }
    }
  }
`;

// Without optimization, this causes:
// 1. Query all posts (1 database query)
// 2. For each post, query author (N database queries)

// Solution: DataLoader (batch loading + caching)
const DataLoader = require('dataloader');

const userLoader = new DataLoader(async (userIds) => {
  // Single query for all needed users
  const users = await db.users.findByIds(userIds);
  return userIds.map(id => users.find(u => u.id === id));
});

const resolvers = {
  Post: {
    author: (post, args, context) => {
      return context.userLoader.load(post.authorId);
    }
  }
};

问题3：缓存困难

// REST: URL is cache key
GET /posts/456
// Browser, CDN can easily cache

// GraphQL: All requests are POST to same endpoint
POST /graphql
body: { query: "..." }
// HTTP cache doesn't work! Need application-level caching

问题4：学习曲线陡峭

团队需要学习：

• GraphQL 查询语法
• Schema 定义
• Resolver 编写
• DataLoader 优化
• Apollo Client / Relay

何时真正需要 GraphQL？

✅ 适合 GraphQL 的场景：

1. 移动端应用

   • 网络条件差，减少请求次数很重要
   • 不同设备需要不同粒度的数据

2. 复杂的前端需求

   • 大量的组合查询
   • 频繁变化的数据需求

3. 多客户端（Web、iOS、Android）

   • 每个客户端需要不同的数据子集
   • 不想为每个客户端写专门的接口

4. BFF（Backend for Frontend）模式

   • GraphQL 作为中间层
   • 聚合多个微服务的数据

❌ 不需要 GraphQL 的场景：

1. 简单的 CRUD 应用

   • REST 已经够用
   • GraphQL 是 over-engineering

2. 团队经验不足

   • 学习成本高
   • 容易出现性能问题

3. 后端资源有限

   • GraphQL 对后端开发要求更高
   • 需要更多的优化工作

AI 对 GraphQL 的理解：

AI 友好度：⭐⭐⭐

AI 擅长的：

• ✅ 生成基础的 schema 定义
• ✅ 生成简单的 resolver
• ✅ 生成客户端查询

AI 不擅长的：

• ❌ 复杂的 N+1 优化
• ❌ 缓存策略设计
• ❌ 性能调优
• ❌ 安全性（查询深度限制、复杂度限制）

REST vs GraphQL 对比

小结：

• GraphQL 解决了 REST 的某些痛点
• 但带来了新的复杂度
• 不是"更好"，而是"不同的权衡"

WebSocket：实时通信的需求

问题场景：聊天应用

需求：实现一个聊天室，用户发消息后，其他人能立即看到。

方案1：REST 轮询（Polling）

// Environment: Browser
// Scenario: Poll for new messages every 1 second

let lastMessageId = 0;

setInterval(() => {
  fetch('/messages?since=' + lastMessageId)
    .then(res => res.json())
    .then(messages => {
      if (messages.length > 0) {
        displayMessages(messages);
        lastMessageId = messages[messages.length - 1].id;
      }
    });
}, 1000);

// Problems:
// - Many useless requests (even when no new messages)
// - Delay up to 1 second (polling interval)
// - High server load

方案2：长轮询（Long Polling）

// Environment: Browser + Backend
// Scenario: Long polling

// Client
function longPoll() {
  fetch('/messages/poll')
    .then(res => res.json())
    .then(messages => {
      displayMessages(messages);
      longPoll(); // Immediately start next request
    });
}

// Server (pseudo code)
app.get('/messages/poll', async (req, res) => {
  // Hold connection, wait for new messages
  const messages = await waitForNewMessages(30000); // Wait max 30s
  res.json(messages);
});

// Improvements:
// ✅ Reduced useless requests
// ✅ Lower latency
// ❌ Still "pull" mode, not truly real-time

方案3：WebSocket

// Environment: Browser + WebSocket server
// Scenario: True bidirectional real-time communication

// Client
const ws = new WebSocket('wss://chat.example.com');

// Connection established
ws.onopen = () => {
  console.log('Connected');
};

// Receive messages
ws.onmessage = (event) => {
  const message = JSON.parse(event.data);
  displayMessage(message);
};

// Send message
function sendMessage(text) {
  ws.send(JSON.stringify({
    type: 'message',
    content: text
  }));
}

// Connection closed
ws.onclose = () => {
  console.log('Disconnected');
  // Reconnect logic
  setTimeout(() => {
    reconnect();
  }, 1000);
};

// Server (Node.js + ws)
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

const clients = new Set();

wss.on('connection', (ws) => {
  clients.add(ws);
  
  ws.on('message', (data) => {
    const message = JSON.parse(data);
    
    // Broadcast to all clients
    clients.forEach(client => {
      if (client.readyState === WebSocket.OPEN) {
        client.send(JSON.stringify(message));
      }
    });
  });
  
  ws.on('close', () => {
    clients.delete(ws);
  });
});

WebSocket 的优势：

• ✅ 真正的双向通信（服务器可主动推送）
• ✅ 低延迟（毫秒级）
• ✅ 低开销（保持连接，不需要重复 HTTP 握手）
• ✅ 高效（二进制传输可选）

WebSocket 的代价

问题1：连接管理复杂

// Environment: Browser
// Scenario: Robust WebSocket connection management

class WebSocketManager {
  constructor(url) {
    this.url = url;
    this.ws = null;
    this.reconnectDelay = 1000;
    this.maxReconnectDelay = 30000;
    this.heartbeatInterval = null;
  }
  
  connect() {
    this.ws = new WebSocket(this.url);
    
    this.ws.onopen = () => {
      console.log('Connected');
      this.reconnectDelay = 1000;
      this.startHeartbeat();
    };
    
    this.ws.onclose = () => {
      console.log('Disconnected');
      this.stopHeartbeat();
      this.reconnect();
    };
    
    this.ws.onerror = (error) => {
      console.error('Error:', error);
    };
  }
  
  reconnect() {
    setTimeout(() => {
      console.log('Reconnecting...');
      this.connect();
      // Exponential backoff
      this.reconnectDelay = Math.min(
        this.reconnectDelay * 2,
        this.maxReconnectDelay
      );
    }, this.reconnectDelay);
  }
  
  startHeartbeat() {
    this.heartbeatInterval = setInterval(() => {
      if (this.ws.readyState === WebSocket.OPEN) {
        this.ws.send(JSON.stringify({ type: 'ping' }));
      }
    }, 30000); // Send heartbeat every 30s
  }
  
  stopHeartbeat() {
    if (this.heartbeatInterval) {
      clearInterval(this.heartbeatInterval);
    }
  }
}

问题2：服务器资源消耗

REST:
- Request → Response → Connection closed
- Stateless, easy to scale horizontally

WebSocket:
- Each client maintains a long connection
- 10000 users = 10000 connections
- High memory, file descriptor consumption
- Need load balancing (sticky session)

问题3：兼容性和回退

// Environment: Backend
// Scenario: Fallback mechanism

// Need to consider:
// - Old browsers don't support WebSocket
// - Some networks don't allow WebSocket
// - Need fallback (long polling)

// Use Socket.IO for automatic handling
const io = require('socket.io')(server);

io.on('connection', (socket) => {
  // Socket.IO automatically chooses:
  // 1. WebSocket (preferred)
  // 2. Long Polling (fallback)
});

SSE：WebSocket 的轻量替代

Server-Sent Events（SSE）：服务器单向推送

// Environment: Browser + SSE
// Scenario: Server pushes real-time data (e.g., stock prices)

// Client
const eventSource = new EventSource('https://api.example.com/stock-prices');

eventSource.onmessage = (event) => {
  const data = JSON.parse(event.data);
  updateStockPrice(data);
};

eventSource.onerror = () => {
  console.error('Connection error');
  eventSource.close();
};

// Server (Node.js)
app.get('/stock-prices', (req, res) => {
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');
  
  // Push every second
  const interval = setInterval(() => {
    const price = getLatestPrice();
    res.write(`data: ${JSON.stringify(price)}\n\n`);
  }, 1000);
  
  req.on('close', () => {
    clearInterval(interval);
  });
});

SSE vs WebSocket：

何时选择什么？

REST（最常见） ：

• ✅ 标准的 CRUD 操作
• ✅ 不需要实时性

GraphQL：

• ✅ 复杂的数据查询
• ✅ 多客户端，需求各异

SSE：

• ✅ 服务器单向推送（股票、通知）
• ✅ 自动重连很重要

WebSocket：

• ✅ 双向实时通信（聊天、协作编辑）
• ✅ 高频数据交换（游戏、实时绘图）

AI 对实时通信的理解：

AI 友好度：

• WebSocket：⭐⭐⭐
• SSE：⭐⭐⭐⭐

AI 擅长的：

• ✅ 生成基础的 WebSocket 客户端代码
• ✅ 生成简单的服务器端代码
• ✅ SSE 的实现（更简单）

AI 不擅长的：

• ❌ 断线重连逻辑
• ❌ 心跳保活
• ❌ 负载均衡配置
• ❌ 大规模部署的优化

综合对比与决策

核心权衡维度

维度1：请求模式

1. Pull（拉）：客户端主动请求

   • REST、GraphQL
   • 优势：简单、可缓存
   • 劣势：无法主动通知

2. Push（推）：服务器主动推送

   • WebSocket、SSE
   • 优势：实时性好
   • 劣势：连接管理复杂

维度2：数据粒度

1. 粗粒度（固定结构）：

   • REST
   • 优势：简单、可预测
   • 劣势：可能 over-fetching

2. 细粒度（自定义）：

   • GraphQL
   • 优势：精确控制
   • 劣势：复杂度高

维度3：连接成本

1. 短连接（HTTP）：

   • REST、GraphQL
   • 每次请求建立连接
   • 适合低频交互

2. 长连接：

   • WebSocket
   • 保持连接
   • 适合高频交互

决策树

graph TD
    A[选择数据传输方式] --> B{需要实时性?}
    
    B --> |需要| C{双向通信?}
    C --> |是| D[WebSocket]
    C --> |否| E[SSE]
    
    B --> |不需要| F{数据查询复杂?}
    
    F --> |复杂| G{多客户端?}
    G --> |是| H[GraphQL]
    G --> |否| I{团队经验?}
    I --> |GraphQL 经验| H
    I --> |REST 经验| J[REST + 定制接口]
    
    F --> |简单 CRUD| J[REST]
    
    style J fill:#d4edff
    style H fill:#fff4cc
    style D fill:#ffe0e0
    style E fill:#e1f5dd

实际项目的组合使用

案例1：电商网站

• REST：商品列表、购物车、订单
• WebSocket：在线客服聊天
• SSE：订单状态更新推送

案例2：协作文档（类 Google Docs）

• GraphQL：文档结构查询
• WebSocket：实时协作编辑
• REST：文件上传/下载

案例3：社交应用

• GraphQL：复杂的 feed 流查询
• WebSocket：私信聊天
• SSE：通知推送

关键原则：

• 没有一种方案能解决所有问题
• 根据具体场景，组合使用不同方案

延伸与发散：AI 时代的数据传输

AI 对不同方案的生成质量

AI 应用中的新场景

流式输出（Streaming）

// Environment: Browser
// Scenario: AI generates text, returns word by word
// Like ChatGPT typing effect

// Approach 1: SSE (recommended)
const eventSource = new EventSource('/api/ai/generate');

eventSource.onmessage = (event) => {
  const chunk = event.data;
  appendToOutput(chunk);
};

// Approach 2: Fetch Stream
fetch('/api/ai/generate', {
  method: 'POST',
  body: JSON.stringify({ prompt: '...' })
})
  .then(response => {
    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    
    function read() {
      reader.read().then(({ done, value }) => {
        if (done) return;
        const chunk = decoder.decode(value);
        appendToOutput(chunk);
        read();
      });
    }
    
    read();
  });

思考：

• AI 流式输出最适合用什么方案？
• SSE vs Fetch Stream 的选择？

未来的趋势

问题：协议会继续演进吗？

可能的方向：

1. HTTP/3 + QUIC：更快的连接建立
2. gRPC：高性能的 RPC 框架
3. WebTransport：下一代实时通信

待探索的问题：

• 边缘计算如何影响数据传输选择？
• Serverless 架构下，WebSocket 如何实现？
• AI Agent 之间的通信，需要什么协议？

小结

这篇文章梳理了常见的数据传输方案，但没有给出"最佳答案"——因为并不存在唯一最优解。

核心收获：

• REST：简单、成熟，适合大多数场景
• GraphQL：解决特定问题（复杂查询），但有代价
• WebSocket：实时双向通信，连接管理复杂
• SSE：单向推送，够用且简单

选择的逻辑：

1. 先问"我的需求是什么"
2. 再问"哪个方案的优势匹配我的需求"
3. 最后问"我能承担这个方案的代价吗"

开放性问题：

• 你的项目用了什么方案？为什么？
• 有没有遇到过"选错方案"的情况？
• 如果重新设计，你会怎么选？

参考资料

• REST API Tutorial - REST API 设计最佳实践
• GraphQL Official Documentation - GraphQL 官方文档
• MDN - WebSocket - WebSocket API 详解
• MDN - Server-Sent Events - SSE 使用指南
• Roy Fielding - Architectural Styles and the Design of Network-based Software Architectures - REST 架构风格论文
• GraphQL N+1 Problem - 解决 N+1 查询问题