给你两个字符串，str1 和 str2，其长度分别为 n 和 m 。

如果一个长度为 n + m - 1 的字符串 word 的每个下标 0 <= i <= n - 1 都满足以下条件，则称其由 str1 和 str2 生成：

• 如果 str1[i] == 'T'，则长度为 m 的 子字符串（从下标 i 开始）与 str2 相等，即 word[i..(i + m - 1)] == str2。
• 如果 str1[i] == 'F'，则长度为 m 的 子字符串（从下标 i 开始）与 str2 不相等，即 word[i..(i + m - 1)] != str2。

返回可以由 str1 和 str2 生成 的 字典序最小 的字符串。如果不存在满足条件的字符串，返回空字符串 ""。

如果字符串 a 在第一个不同字符的位置上比字符串 b 的对应字符在字母表中更靠前，则称字符串 a 的 字典序 小于 字符串 b。
如果前 min(a.length, b.length) 个字符都相同，则较短的字符串字典序更小。

子字符串 是字符串中的一个连续、非空 的字符序列。

示例 1：

示例 2：

示例 3：

提示:

• 1 <= n == str1.length <= 104
• 1 <= m == str2.length <= 500
• str1 仅由 'T' 或 'F' 组成。
• str2 仅由小写英文字母组成。

When working with text files, you will often need to remove specific lines, whether it is stripping comments from a configuration file, cleaning up blank lines in log output, or cutting a range of lines from a data dump. The sed stream editor handles all of these cases from the command line, without opening the file in an editor.

sed processes input line by line, applies your commands, and writes the result to standard output. The original file stays untouched unless you explicitly tell sed to edit in place. If you need to find and replace text rather than remove entire lines, see How to Use sed to Find and Replace Strings in Files .

This guide explains how to use the sed delete command (d) with practical examples covering line numbers, patterns, ranges, and regular expressions.

How the Delete Command Works #

The general form of a sed delete expression is:

sed 'ADDRESSd' file

ADDRESS selects which lines to delete, and d is the delete command. When sed encounters a line that matches the address, it removes that line from the output entirely. Any line that does not match the address is printed as usual.

For demonstration purposes, the examples in this guide use the following file:

red
green
blue
yellow
white
black
orange
purple

Delete by Line Number #

The simplest form of delete targets a specific line number. To remove the third line, place 3 before the d command:

sed '3d' colors.txt

red
green
yellow
white
black
orange
purple

Notice that “blue” (which was on line 3) is gone from the output, but the original colors.txt file is unchanged. This is the default behavior of sed, and it gives you a safe way to preview changes before committing them.

Sometimes you need to remove the last line of a file without knowing how many lines it contains. The $ address represents the last line:

sed '$d' colors.txt

red
green
blue
yellow
white
black
orange

Here “purple” (the last line) has been removed from the output.

Delete Multiple Specific Lines #

If you need to remove several individual lines, separate the addresses with a semicolon. The following command deletes lines 2, 5, and 8 in a single pass:

sed '2d;5d;8d' colors.txt

red
blue
yellow
black
orange

The output is missing “green” (line 2), “white” (line 5), and “purple” (line 8). You can list as many addresses as needed this way.

Delete a Range of Lines #

To delete a block of consecutive lines, specify a range with two numbers separated by a comma. The following command removes lines 3 through 6:

sed '3,6d' colors.txt

red
green
orange
purple

Everything from “blue” (line 3) through “black” (line 6) is gone, and the remaining lines print normally.

You can also combine a line number with $ to delete from a given line to the end of the file. This keeps only the first four lines:

sed '5,$d' colors.txt

red
green
blue
yellow

Adding ! after the address inverts the selection, so sed deletes every line that is not in the range. The following command keeps only lines 3 through 5 and removes everything else:

sed '3,5!d' colors.txt

blue
yellow
white

This is a convenient way to extract a slice from a file without piping through head and tail.

Delete Every Nth Line #

GNU sed supports the step address first~step, which matches every Nth line starting from a given position. To delete every even-numbered line (2, 4, 6, …):

sed '0~2d' colors.txt

red
blue
white
orange

The first number is the starting offset (0 means “before the first line”, so the first match is line 2) and the second number is the step. In this case sed deletes lines 2, 4, 6, and 8.

To delete every third line starting from line 3:

sed '3~3d' colors.txt

red
green
yellow
white
orange
purple

Lines 3 (“blue”) and 6 (“black”) are removed. This syntax is specific to GNU sed and is not available in the BSD version shipped with macOS.

Delete Lines Matching a Pattern #

One of the most common uses of sed delete is removing lines that contain a specific string. Wrap the search pattern in forward slashes before the d command:

sed '/blue/d' colors.txt

red
green
yellow
white
black
orange
purple

Every line containing the string “blue” is removed from the output. Keep in mind that this is a substring match, so a pattern like /bl/d would also delete the line “black” because it contains “bl”.

If you want the match to be case-insensitive, add the I flag after d:

sed '/Blue/Id' colors.txt

This removes lines containing “blue”, “Blue”, “BLUE”, or any other case variation.

Delete Lines Not Matching a Pattern #

Adding ! after the pattern address inverts the match, so sed deletes every line that does not contain the pattern. The following command removes all lines that do not have the letter “e”:

sed '/e/!d' colors.txt

red
green
blue
yellow
white
orange
purple

Only “black” (line 6) was removed because it is the only line without an “e”. This works similarly to grep , but the advantage of sed is that you can combine it with other editing commands in the same expression.

Delete a Range Between Two Patterns #

You can use two patterns separated by a comma to define a range. sed starts deleting at the first line that matches the opening pattern and stops after the first line that matches the closing pattern. The following command removes everything from “green” through “white”:

sed '/green/,/white/d' colors.txt

red
black
orange
purple

Both the “green” and “white” lines are included in the deletion, along with “blue” and “yellow” between them.

You can also mix a line number with a pattern. This deletes from line 1 through the first line that contains “blue”:

sed '1,/blue/d' colors.txt

yellow
white
black
orange
purple

This kind of mixed address is useful when you know where the range starts (a fixed line) but not where it ends.

Delete Empty Lines #

Removing blank lines is one of the most common sed tasks. To delete completely empty lines, use the pattern ^$, which matches lines where the beginning and end have nothing between them:

sed '/^$/d' file.txt

This works well for truly empty lines, but it will not catch lines that contain only spaces or tabs. To remove those as well, use the [[:space:]] character class:

sed '/^[[:space:]]*$/d' file.txt

The * quantifier matches zero or more whitespace characters, so this pattern covers both empty lines and lines that appear blank but contain invisible whitespace.

Delete Lines Matching a Regular Expression #

The pattern between the slashes is a regular expression, so you can use anchors, character classes, and quantifiers for more precise matching.

A common example is stripping comment lines from a configuration file. The ^# pattern matches any line that starts with #:

sed '/^#/d' config.txt

To delete lines that end with a semicolon, anchor the pattern to the end of the line with $:

sed '/;$/d' source.txt

You can also match by line length. The following command deletes lines that are shorter than 5 characters. The \{0,4\} quantifier means “between 0 and 4 of any character”:

sed '/^.\{0,4\}$/d' file.txt

If you find the backslash escaping awkward, use extended regular expressions with the -E flag (or -r on older systems). This lets you write the same expression without escaping the braces:

sed -E '/^.{0,4}$/d' file.txt

Combining Delete with Other Commands #

One of the strengths of sed is that you can chain multiple operations in a single expression. For example, the following command first removes comment lines and then replaces “localhost” with “127.0.0.1” in whatever remains:

sed '/^#/d; s/localhost/127.0.0.1/g' config.txt

The commands are separated by a semicolon and execute left to right. If a line is deleted by an earlier command, the later commands never see it, so the replacement only applies to non-comment lines.

Editing Files In Place #

All of the examples above print the modified text to standard output without changing the original file. When you are satisfied with the result, add the -i flag to apply the changes directly:

sed -i '/^$/d' file.txt

On macOS, the BSD version of sed requires an explicit extension argument even if you do not want a backup. Use sed -i '' '/^$/d' file.txt for in-place editing without creating a backup file.

Quick Reference #

For a printable quick reference, see the sed cheatsheet .

FAQ #

How do I delete a line containing a specific word? Use sed '/word/d' file.txt. This removes any line where “word” appears as a substring. If you want to match the whole word only (so that “keyword” is not affected), use word boundaries: sed '/\bword\b/d' file.txt.

Can I delete lines from multiple files at once? Yes. Pass multiple filenames after the expression: sed -i '/pattern/d' file1.txt file2.txt. To process files recursively, combine sed with find: find . -name "*.log" -exec sed -i '/DEBUG/d' {} +.

What is the difference between sed '/pattern/d' and grep -v 'pattern'? Both remove matching lines from the output. The difference is that sed can combine deletion with other editing commands in the same expression and supports in-place editing with -i. If all you need is simple line filtering, grep -v is shorter to type.

How do I delete a range of lines and save the result? You can either redirect the output to a new file (sed '3,6d' file.txt > cleaned.txt) or edit in place with a backup (sed -i.bak '3,6d' file.txt). Do not redirect to the same input file, because the shell will truncate it before sed has a chance to read it.

Conclusion #

The sed delete command gives you a fast way to remove lines by number, pattern, or range without opening a file in an editor. For replacing text within lines rather than removing them, see the companion guide on sed find and replace . If you need to work with individual columns or fields within a line, awk is often the better tool for the job.

方法一：暴力修改

首先说做法。下文把 $\textit{str}_1$ 简记为 $s$，把 $\textit{str}_2$ 简记为 $t$。

先模拟：处理 $s$ 中的 T，把字符串 $t$ 填入答案的对应位置，如果发现矛盾，就返回空串。没填的位置（待定位置）初始化为 $\texttt{a}$。

再贪心：从左到右检查 F 对应的答案子串，如果发现子串和 $t$ 相同，那么把子串的最后一个待定位置改成 $\texttt{b}$。

本题的贪心策略是简单的，难点在正确性上。考虑如下问题：

• 按照上述贪心策略，是否存在一种情况，当我们把待定位置改成 $\texttt{b}$ 后，前面的某个 F 对应子串反而变成和 $t$ 相同了？

情况一

$t$ 全为 $\texttt{a}$ 的情况。

这是容易证明的，因为把待定位置改成 $\texttt{b}$ 后，前面的受到影响的子串（包含这个 $\texttt{b}$ 的子串）一定不会等于 $t$，毕竟 $t$ 只有 $\texttt{a}$。

例如 $t=\texttt{aaa}$，现在 $\textit{ans}=\texttt{aaa?????aaa}$。其中 $\texttt{?}$ 表示待定位置，初始值为 $\texttt{a}$。

• 我们遇到的第一个待定位置就会改成 $\texttt{b}$，后续所有包含这个 $\texttt{b}$ 的子串必然不等于 $t$，所以仍然为默认值 $\texttt{a}$。
• 直到我们遇到下一个需要改成 $\texttt{b}$ 的待定位置。
• 最终 $\textit{ans} = \texttt{aaa}\underline{\texttt{baabb}}\texttt{aaa}$。请动手算算，特别注意最后一个 $\texttt{b}$ 是怎么改的。

情况二

下面讨论 $t$ 包含不等于 $\texttt{a}$ 的字母的情况。

猜想：$t$ 形如 $t' + \texttt{aa\ldots a} + t'$。例如 $\texttt{baab},\texttt{baaaaba},\texttt{abaaaba}$ 等。

例如 $t=\texttt{baaaaba}$，即 $\texttt{ba} + \texttt{aaa} + \texttt{ba}$。

设 $\textit{ans} = \texttt{baaaaba???baaaaba}$。中间的 $\texttt{???}$ 不能全为 $\texttt{a}$，改成 $\texttt{aab}$，得 $\texttt{baaaaba}\underline{\texttt{aab}}\texttt{baaaaba}$，这里产生的 $\texttt{baaab}$ 可以保证前面的 F 对应子串不会和 $t$ 相同。

这可以推广到一般情况。抛砖引玉，欢迎在评论区发表你的证明。

同理，一旦我们修改了 $\textit{ans}[j]$，那么后面包含 $\textit{ans}[j]$ 的子串都不会和 $t$ 相同。所以只需改最后一个待定位置，不会出现改子串倒数第二个待定位置的情况。进一步地，可以直接跳到 $j+1$ 继续循环，这个优化用在方法二中。

###py

class Solution:
    def generateString(self, s: str, t: str) -> str:
        n, m = len(s), len(t)
        ans = ['?'] * (n + m - 1)  # ? 表示待定位置

        # 处理 T
        for i, b in enumerate(s):
            if b != 'T':
                continue
            # 子串必须等于 t
            for j, c in enumerate(t):
                v = ans[i + j]
                if v != '?' and v != c:
                    return ""
                ans[i + j] = c

        old_ans = ans
        ans = ['a' if c == '?' else c for c in ans]  # 待定位置的初始值为 a

        # 处理 F
        for i, b in enumerate(s):
            if b != 'F':
                continue
            # 子串必须不等于 t
            if ''.join(ans[i: i + m]) != t:
                continue
            # 找最后一个待定位置
            for j in range(i + m - 1, i - 1, -1):
                if old_ans[j] == '?':  # 之前填 a，现在改成 b
                    ans[j] = 'b'
                    break
            else:
                return ""

        return ''.join(ans)

###java

class Solution {
    public String generateString(String S, String t) {
        char[] s = S.toCharArray();
        int n = s.length;
        int m = t.length();
        char[] ans = new char[n + m - 1];
        Arrays.fill(ans, '?'); // '?' 表示待定位置

        // 处理 T
        for (int i = 0; i < n; i++) {
            if (s[i] != 'T') {
                continue;
            }
            // 子串必须等于 t
            for (int j = 0; j < m; j++) {
                char v = ans[i + j];
                if (v != '?' && v != t.charAt(j)) {
                    return "";
                }
                ans[i + j] = t.charAt(j);
            }
        }

        char[] oldAns = ans.clone();
        for (int i = 0; i < ans.length; i++) {
            if (ans[i] == '?') {
                ans[i] = 'a'; // 待定位置的初始值为 'a'
            }
        }

        // 处理 F
        for (int i = 0; i < n; i++) {
            if (s[i] != 'F') {
                continue;
            }
            // 子串必须不等于 t
            if (!new String(ans, i, m).equals(t)) {
                continue;
            }
            // 找最后一个待定位置
            boolean ok = false;
            for (int j = i + m - 1; j >= i; j--) {
                if (oldAns[j] == '?') { // 之前填 'a'，现在改成 'b'
                    ans[j] = 'b';
                    ok = true;
                    break;
                }
            }
            if (!ok) {
                return "";
            }
        }

        return new String(ans);
    }
}

###cpp

class Solution {
public:
    string generateString(string s, string t) {
        int n = s.size(), m = t.size();
        string ans(n + m - 1, '?'); // ? 表示待定位置

        // 处理 T
        for (int i = 0; i < n; i++) {
            if (s[i] != 'T') {
                continue;
            }
            // 子串必须等于 t
            for (int j = 0; j < m; j++) {
                char v = ans[i + j];
                if (v != '?' && v != t[j]) {
                    return "";
                }
                ans[i + j] = t[j];
            }
        }

        string old_ans = ans;
        for (char& c : ans) {
            if (c == '?') {
                c = 'a'; // 待定位置的初始值为 a
            }
        }

        // 处理 F
        for (int i = 0; i < n; i++) {
            if (s[i] != 'F') {
                continue;
            }
            // 子串必须不等于 t
            if (string(ans.begin() + i, ans.begin() + i + m) != t) {
                continue;
            }
            // 找最后一个待定位置
            bool ok = false;
            for (int j = i + m - 1; j >= i; j--) {
                if (old_ans[j] == '?') { // 之前填 a，现在改成 b
                    ans[j] = 'b';
                    ok = true;
                    break;
                }
            }
            if (!ok) {
                return "";
            }
        }

        return ans;
    }
};

###go

func generateString(s, T string) string {
    n, m := len(s), len(T)
    t := []byte(T)
    ans := bytes.Repeat([]byte{'?'}, n+m-1) // ? 表示待定位置
    
    // 处理 T
    for i, b := range s {
        if b != 'T' {
            continue
        }
        // sub 必须等于 t
        sub := ans[i : i+m]
        for j, c := range sub {
            if c != '?' && c != t[j] {
                return ""
            }
            sub[j] = t[j]
        }
    }
    oldAns := ans
    ans = bytes.ReplaceAll(ans, []byte{'?'}, []byte{'a'}) // 待定位置的初始值为 a

    // 处理 F
next:
    for i, b := range s {
        if b != 'F' {
            continue
        }
        // sub 必须不等于 t 
        sub := ans[i : i+m]
        if !bytes.Equal(sub, t) {
            continue
        }
        // 找最后一个待定位置
        old := oldAns[i : i+m]
        for j := m - 1; j >= 0; j-- {
            if old[j] == '?' { // 之前填 a，现在改成 b
                sub[j] = 'b'
                continue next
            }
        }
        return ""
    }

    return string(ans)
}

复杂度分析

• 时间复杂度：$\mathcal{O}(nm)$，其中 $n$ 是 $s$ 的长度，$m$ 是 $t$ 的长度。
• 空间复杂度：$\mathcal{O}(n+m)$。如果不考虑切片和返回值的话是 $\mathcal{O}(1)$。

方法二：Z 函数

在模拟（处理 $s$ 中的 T）的过程中，如果两个 $t$ 重叠，我们需要判断 $t$ 的某个长度的前后缀是否相同，这可以用 Z 函数直接解决。

判断 $\textit{ans}$ 子串是否等于 $t$ 也可以用 Z 函数。计算 $t + \textit{ans}$ 的 Z 函数，如果 $z[i+m]<m$，就说明从 $i$ 开始的 $\textit{ans}$ 子串不等于 $t$。

如果子串等于 $t$，那么找一个小于 $i+m$ 的最近待定位置，改成 $\texttt{b}$。这可以用一个数组 $\textit{preQ}$ 预处理每个 $\le i$ 的最近待定位置。

###py

class Solution:
    def calc_z(self, s: str) -> List[int]:
        n = len(s)
        z = [0] * n
        box_l, box_r = 0, 0  # z-box 左右边界（闭区间）
        for i in range(1, n):
            if i <= box_r:
                z[i] = min(z[i - box_l], box_r - i + 1)
            while i + z[i] < n and s[z[i]] == s[i + z[i]]:
                box_l, box_r = i, i + z[i]
                z[i] += 1
        z[0] = n
        return z

    def generateString(self, s: str, t: str) -> str:
        n, m = len(s), len(t)
        ans = ['?'] * (n + m - 1)

        # 处理 T
        z = self.calc_z(t)
        pre = -m
        for i, b in enumerate(s):
            if b != 'T':
                continue
            size = max(pre + m - i, 0)
            # t 的长为 size 的前后缀必须相同
            if size > 0 and z[m - size] < size:
                return ""
            # size 后的内容都是 '?'，填入 t
            ans[i + size: i + m] = t[size:]
            pre = i

        # 计算 <= i 的最近待定位置
        pre_q = [-1] * len(ans)
        pre = -1
        for i, c in enumerate(ans):
            if c == '?':
                ans[i] = 'a'  # 待定位置的初始值为 a
                pre = i
            pre_q[i] = pre

        # 找 ans 中的等于 t 的位置，可以用 KMP 或者 Z 函数
        z = self.calc_z(t + ''.join(ans))

        # 处理 F
        i = 0
        while i < n:
            if s[i] != 'F':
                i += 1
                continue
            # 子串必须不等于 t
            if z[m + i] < m:
                i += 1
                continue
            # 找最后一个待定位置
            j = pre_q[i + m - 1]
            if j < i:  # 没有
                return ""
            ans[j] = 'b'
            i = j + 1  # 直接跳过 j

        return ''.join(ans)

###java

class Solution {
    public String generateString(String S, String t) {
        char[] s = S.toCharArray();
        int n = s.length;
        int m = t.length();
        char[] ans = new char[n + m - 1];
        Arrays.fill(ans, '?');

        // 处理 T
        int[] z = calcZ(t);
        int pre = -m;
        for (int i = 0; i < n; i++) {
            if (s[i] != 'T') {
                continue;
            }
            int size = Math.max(pre + m - i, 0);
            // t 的长为 size 的前后缀必须相同
            if (size > 0 && z[m - size] < size) {
                return "";
            }
            // size 后的内容都是 '?'，填入 t
            for (int j = size; j < m; j++) {
                ans[i + j] = t.charAt(j);
            }
            pre = i;
        }

        // 计算 <= i 的最近待定位置
        int[] preQ = new int[ans.length];
        pre = -1;
        for (int i = 0; i < ans.length; i++) {
            if (ans[i] == '?') {
                ans[i] = 'a'; // 待定位置的初始值为 a
                pre = i;
            }
            preQ[i] = pre;
        }

        // 找 ans 中的等于 t 的位置，可以用 KMP 或者 Z 函数
        z = calcZ(t + new String(ans));

        // 处理 F
        for (int i = 0; i < n; i++) {
            if (s[i] != 'F') {
                continue;
            }
            // 子串必须不等于 t
            if (z[m + i] < m) {
                continue;
            }
            // 找最后一个待定位置
            int j = preQ[i + m - 1];
            if (j < i) { // 没有
                return "";
            }
            ans[j] = 'b';
            i = j; // 直接跳到 j
        }

        return new String(ans);
    }

    private int[] calcZ(String S) {
        char[] s = S.toCharArray();
        int n = s.length;
        int[] z = new int[n];
        int boxL = 0; // z-box 左右边界（闭区间）
        int boxR = 0;
        for (int i = 1; i < n; i++) {
            if (i <= boxR) {
                z[i] = Math.min(z[i - boxL], boxR - i + 1);
            }
            while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
                boxL = i;
                boxR = i + z[i];
                z[i]++;
            }
        }
        z[0] = n;
        return z;
    }
}

###cpp

class Solution {
    vector<int> calc_z(const string& s) {
        int n = s.size();
        vector<int> z(n);
        int box_l = 0, box_r = 0; // z-box 左右边界（闭区间）
        for (int i = 1; i < n; i++) {
            if (i <= box_r) {
                z[i] = min(z[i - box_l], box_r - i + 1);
            }
            while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
                box_l = i;
                box_r = i + z[i];
                z[i]++;
            }
        }
        z[0] = n;
        return z;
    }

public:
    string generateString(string s, string t) {
        int n = s.size(), m = t.size();
        string ans(n + m - 1, '?');

        // 处理 T
        vector<int> z = calc_z(t);
        int pre = -m;
        for (int i = 0; i < n; i++) {
            if (s[i] != 'T') {
                continue;
            }
            int size = max(pre + m - i, 0);
            // t 的长为 size 的前后缀必须相同
            if (size > 0 && z[m - size] < size) {
                return "";
            }
            // size 后的内容都是 '?'，填入 t
            for (int j = size; j < m; j++) {
                ans[i + j] = t[j];
            }
            pre = i;
        }

        // 计算 <= i 的最近待定位置
        vector<int> pre_q(ans.size());
        pre = -1;
        for (int i = 0; i < ans.size(); i++) {
            if (ans[i] == '?') {
                ans[i] = 'a'; // 待定位置的初始值为 a
                pre = i;
            }
            pre_q[i] = pre;
        }

        // 找 ans 中的等于 t 的位置，可以用 KMP 或者 Z 函数
        z = calc_z(t + ans);

        // 处理 F
        for (int i = 0; i < n; i++) {
            if (s[i] != 'F') {
                continue;
            }
            // 子串必须不等于 t
            if (z[m + i] < m) {
                continue;
            }
            // 找最后一个待定位置
            int j = pre_q[i + m - 1];
            if (j < i) { // 没有
                return "";
            }
            ans[j] = 'b';
            i = j; // 直接跳到 j
        }

        return ans;
    }
};

###go

func calcZ(s string) []int {
    n := len(s)
    z := make([]int, n)
    boxL, boxR := 0, 0 // z-box 左右边界（闭区间）
    for i := 1; i < n; i++ {
        if i <= boxR {
            z[i] = min(z[i-boxL], boxR-i+1)
        }
        for i+z[i] < n && s[z[i]] == s[i+z[i]] {
            boxL, boxR = i, i+z[i]
            z[i]++
        }
    }
    z[0] = n
    return z
}

func generateString(s, t string) string {
    n, m := len(s), len(t)
    ans := bytes.Repeat([]byte{'?'}, n+m-1)

    // 处理 T
    pre := -m
    z := calcZ(t)
    for i, b := range s {
        if b != 'T' {
            continue
        }
        size := max(pre+m-i, 0)
        // t 的长为 size 的前后缀必须相同
        if size > 0 && z[m-size] < size {
            return ""
        }
        // size 后的内容都是 '?'，填入 t
        copy(ans[i+size:], t[size:])
        pre = i
    }

    // 计算 <= i 的最近待定位置
    preQ := make([]int, len(ans))
    pre = -1
    for i, c := range ans {
        if c == '?' {
            ans[i] = 'a' // 待定位置的初始值为 a
            pre = i
        }
        preQ[i] = pre
    }

    // 找 ans 中的等于 t 的位置，可以用 KMP 或者 Z 函数
    z = calcZ(t + string(ans))

    // 处理 F
    for i := 0; i < n; i++ {
        if s[i] != 'F' {
            continue
        }
        // 子串必须不等于 t 
        if z[m+i] < m {
            continue
        }
        // 找最后一个待定位置
        j := preQ[i+m-1]
        if j < i { // 没有
            return ""
        }
        ans[j] = 'b'
        i = j // 直接跳到 j
    }

    return string(ans)
}

复杂度分析

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

更多相似题目，见下面贪心题单中的「§3.1 字典序最小/最大」和字符串题单中的「二、Z 函数」。

分类题单

如何科学刷题？

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

我的题解精选（已分类）

Problem: 3474. 字典序最小的生成字符串

[TOC]

思路

处理 T

如果str1[i] == T，那就可以确定res[i:i+m]上的字母，很划算，所以优先处理T，如果有冲突就直接return ""

        n,m = len(str1),len(str2)  
        N = m+n-1      
        # 先处理T
        res = [''] * N
        for i in range(n):
            if str1[i] == 'F':
                continue
            
            for j in range(m):
                if res[i+j] == str2[j]:
                    continue
                
                if res[i+j] == '':
                    res[i+j] = str2[j]                    
                    continue
                # 有冲突
                return ""

处理 F

滚动哈希

假设dfs(i-1)满足题意，然后往res[i]中填入新的字母w，那么：
如果str1[i-m+1] == F时，需要判断res[i-m+1:i+1]是否等于str2，如果不等于才能满足题意F。

为了快速判断res[i-m+1:i+1]是否等于str2，也就是经典字符串匹配，这里就直接用滚动哈希了：

• pre数组，滚动哈希"前缀和"
• tgt: str2的字符串哈希值
• pow_m = pow(base,m,mod)：base的m次方
• res：填入结果数组

        # 回溯处理 F，并 贪心 获取结果
        global ans
        ans = ""
        # 滚动哈希
        pre = [0]
        base, mod = 1331, 10**9 + 7
        # base 的 m 次方
        pow_m = pow(base,m,mod)             
        tgt = 0
        for w in str2:
            tgt = (tgt * base + ord(w)) % mod 

回溯 + 贪心

在贪心填入新字母的过程中，需要同步更新与回溯：

• pre 哈希前缀和
• res 结果数组

        # 到第i位
        def dfs(i):
            # 第一次构造成功后，赋值给 ans
            global ans
            if i == len(res):
                ans = ''.join(res)
                return True
            
            # 当前值由于预处理`T`时已经填好了
            if res[i] != '':
                # 同步更新 pre 哈希前缀和
                pre.append((pre[-1] * base + ord(res[i])) % mod)
                # 判断 F
                if i >= m - 1 and str1[i-m+1] == 'F' and (pre[-1] - pre[i+1-m] * pow_m) % mod == tgt:
                    # 回溯
                    pre.pop() 
                    return False
                if dfs(i+1):
                    return True
                # 回溯
                pre.pop() 
                return False
            
            # 贪心 填入新字母
            for w in ascii_lowercase:
                # 同步更新 pre 哈希前缀和
                pre.append((pre[-1] * base + ord(w)) % mod)
                # 同步更新 res 结果集
                res[i] = w
                if i < m - 1:
                    if dfs(i+1):                        
                        return True
                # 判断 F 符合题意
                elif (pre[-1] - pre[i+1-m] * pow_m) % mod != tgt:
                    if dfs(i+1):                        
                        return True
                # 回溯
                pre.pop() 
                res[i] = ''              
            # 均不满足题意
            return False

预校验 F

周赛没时间看这题，被T3卡常卡吐了，赛后看了下，也没多少思路，就试试暴力回溯能不能过吧，竟然过了，我也不知道时间复杂度是多少，快倒是挺快的：

感觉不是正确做法，~有没有新样例能卡一下？~
找到个新增样例①卡了：

"FFFFFFFFFFFFFFFFFFFFFFFFTTFFT
"fff"

超时了，原因是str1后面加粗的部分是不满足题意的，因此在处理 T后，先预校验 F

        # 预校验 F
        for i in range(n):
            if str1[i] == 'F':
                for j in range(m):
                    # 只要存在一个字母不等即可
                    if res[i+j] != str2[j]:
                        break
                else:
                    # 字符串相等了，不满足 F
                    return ""

如果这个预校验 F通过了，那回溯部分肯定能获取结果。
加了这个预处理后，没超时了，但感觉还是有问题，暂时找不到新样例卡回溯

更多题目模板总结，请参考2024年度总结与题目分享

Code

class Solution:
    def generateString(self, str1: str, str2: str) -> str: 
        n,m = len(str1),len(str2)  
        N = m+n-1      
        # 先处理T
        res = [''] * N
        for i in range(n):
            if str1[i] == 'F':
                continue
            
            for j in range(m):
                if res[i+j] == str2[j]:
                    continue
                
                if res[i+j] == '':
                    res[i+j] = str2[j]                    
                    continue
                # 有冲突
                return ""
        
        # 回溯处理 F，并 贪心 获取结果
        global ans
        ans = ""
        # 滚动哈希
        pre = [0]
        base, mod = 1331, 10**9 + 7
        # base 的 m 次方
        pow_m = pow(base,m,mod)             
        tgt = 0
        for w in str2:
            tgt = (tgt * base + ord(w)) % mod                    
         
        # 到第i位
        def dfs(i):
            # 第一次构造成功后，赋值给 ans
            global ans
            if i == len(res):
                ans = ''.join(res)
                return True
            
            # 当前值由于预处理`T`时已经填好了
            if res[i] != '':
                # 同步更新 pre 哈希前缀和
                pre.append((pre[-1] * base + ord(res[i])) % mod)
                # 判断 F
                if i >= m - 1 and str1[i-m+1] == 'F' and (pre[-1] - pre[i+1-m] * pow_m) % mod == tgt:
                    # 回溯
                    pre.pop() 
                    return False
                if dfs(i+1):
                    return True
                # 回溯
                pre.pop() 
                return False
            
            # 贪心 填入新字母
            for w in ascii_lowercase:
                # 同步更新 pre 哈希前缀和
                pre.append((pre[-1] * base + ord(w)) % mod)
                # 同步更新 res 结果集
                res[i] = w
                if i < m - 1:
                    if dfs(i+1):                        
                        return True
                # 判断 F 符合题意
                elif (pre[-1] - pre[i+1-m] * pow_m) % mod != tgt:
                    if dfs(i+1):                        
                        return True
                # 回溯
                pre.pop() 
                res[i] = ''              
            # 均不满足题意
            return False
        
        dfs(0)    
                
        return ans

class Solution:
    def generateString(self, str1: str, str2: str) -> str: 
        n,m = len(str1),len(str2)  
        N = m+n-1      
        # 先处理T
        res = [''] * N
        for i in range(n):
            if str1[i] == 'F':
                continue
            
            for j in range(m):
                if res[i+j] == str2[j]:
                    continue
                
                if res[i+j] == '':
                    res[i+j] = str2[j]
                    continue
                # 有冲突
                return ""
        
        # 预校验 F
        for i in range(n):
            if str1[i] == 'F':
                for j in range(m):
                    # 只要存在一个字母不等即可
                    if res[i+j] != str2[j]:
                        break
                else:
                    # 字符串相等了，不满足 F
                    return ""
                    
        # 回溯处理 F，并 贪心 获取结果
        # 滚动哈希
        pre = [0]
        base, mod = 1331, 10**9 + 7
        # base 的 m 次方
        pow_m = pow(base,m,mod)             
        tgt = 0
        for w in str2:
            tgt = (tgt * base + ord(w)) % mod                    
         
        # 到第i位
        def dfs(i):
            if i == len(res):
                return True
            
            # 当前值由于预处理`T`时已经填好了
            if res[i] != '':
                # 同步更新 pre 哈希前缀和
                pre.append((pre[-1] * base + ord(res[i])) % mod)
                # 判断 F
                if i >= m - 1 and str1[i-m+1] == 'F' and (pre[-1] - pre[i+1-m] * pow_m) % mod == tgt:
                    # 回溯
                    pre.pop() 
                    return False
                if dfs(i+1):
                    return True
                # 回溯
                pre.pop() 
                return False
            
            # 贪心 填入新字母
            for w in ['a','b']:
                # 同步更新 pre 哈希前缀和
                pre.append((pre[-1] * base + ord(w)) % mod)
                # 同步更新 res 结果集
                res[i] = w
                if i < m - 1:
                    if dfs(i+1):                        
                        return True
                # 判断 F 符合题意
                elif (pre[-1] - pre[i+1-m] * pow_m) % mod != tgt:
                    if dfs(i+1):                        
                        return True
                # 回溯
                pre.pop() 
                res[i] = ''              
            # 均不满足题意
            return False

        dfs(0)
        return "".join(res)
        

解法：构造 & 贪心

记 ans.substr(i, m) 表示从 ans[i] 开始的，长度为 $m$ 的子串。

首先，对于所有满足 str1[i] == 'T' 的下标 $i$，我们令 ans.substr(i, m) = str2。由于子串之间可能会互相覆盖，因此全部赋值一遍之后，我们还要检验一下所有子串仍然和 str2 相等。

完成这一步之后，所有 T 的要求就都满足了。为了让答案的字典序最小，剩下的没填的位置我们都先填上 a，然后再看如何满足 F 的要求。

我们从左到右看每个 str1[i] == 'F'。如果 ans.substr(i, m) == str2，说明我们必须要改掉至少一个字符，而我们能改的字符只有刚才没填，然后被我们补上 a 的位置。为了让字典序尽量小，我们选出这个子串里最后一个能改的位置，把它改成 b。如果没有位置能改，当然就是无解。

通过这个构造 + 检验 + 贪心的过程，我们就构造出了字典序最小的答案。暴力模拟上述构造过程的复杂度为 $\mathcal{O}(nm)$，当然也可以用数据结构维护子串的哈希值，将复杂度加快至 $\mathcal{O}((n + m)\log (n + m))$。

参考代码（c++）

class Solution {
public:
    string generateString(string str1, string str2) {
        int n = str1.size(), m = str2.size();
        string ans;
        ans.resize(n + m - 1);

        // flag[i] 表示下标 i 能否修改
        bool flag[n + m - 1];
        memset(flag, 0, sizeof(flag));
        // 先满足所有 T 的要求
        for (int i = 0; i < n; i++) if (str1[i] == 'T')
            for (int j = 0; j < m; j++) ans[i + j] = str2[j], flag[i + j] = true;
        // 检查一遍子串之间的覆盖没有影响答案
        for (int i = 0; i < n; i++) if (str1[i] == 'T')
            if (ans.substr(i, m) != str2) return "";
        
        // 把没填的位置都填上 a
        for (char &c : ans) if (c == 0) c = 'a';    

        // 接下来满足 F 的要求
        for (int i = 0; i < n; i++) if (str1[i] == 'F' && ans.substr(i, m) == str2) {
            bool failed = true;
            // 找到最后一个能改的位置，改成 b
            for (int j = m - 1; j >= 0; j--) if (!flag[i + j]) { ans[i + j] = 'b'; failed = false; break; }
            // 找不到就无解
            if (failed) return "";
        }
        return ans;
    }
};

Carousel Pattern 详解：构建无障碍轮播组件

轮播（Carousel）是一种按顺序展示一组内容项（称为幻灯片）的组件。本文基于 W3C WAI-ARIA Carousel Pattern 规范，详解如何构建无障碍的轮播组件。

一、Carousel 的定义与核心概念

1.1 什么是 Carousel

Carousel（也称为幻灯片或图片轮播器）具有以下特征：

• 展示一组称为**幻灯片（Slide）**的内容项
• 通常一次显示一个幻灯片，通过控制按钮切换
• 可以自动轮播，也可以手动控制
• 幻灯片可以包含任何类型的内容，图片轮播最为常见

1.2 核心术语

┌─────────────────────────────────────────────────────────────┐
│  Carousel (role="region" + aria-roledescription)            │
│                                                             │
│  ┌─────────────────────────────────────────────────────┐    │
│  │                                                     │    │
│  │              ┌─────────────────┐                    │    │
│  │              │    Slide 1      │                    │    │
│  │              │  ┌───────────┐  │                    │    │
│  │              │  │           │  │                    │    │
│  │              │  │  Image /  │  │  <-- Current       │    │
│  │              │  │  Content  │  │      Slide         │    │
│  │              │  │           │  │                    │    │
│  │              │  └───────────┘  │                    │    │
│  │              └─────────────────┘                    │    │
│  │                                                     │    │
│  │  ┌─────────────────────────────────────────────┐    │    │
│  │  │  Slide 2 (hidden)    │   Slide 3 (hidden)   │    │    │
│  │  └─────────────────────────────────────────────┘    │    │
│  │                                                     │    │
│  └─────────────────────────────────────────────────────┘    │
│                                                             │
│     <-- Prev        o O O        Next -->                   │
│           (Slide Picker / Dots Navigation)                  │
│                                                             │
│                    [ Pause/Play ]                           │
└─────────────────────────────────────────────────────────────┘

1.3 无障碍挑战

轮播组件如果没有正确实现，会对无障碍体验造成严重影响：

• 屏幕阅读器用户困惑：如果不可见的幻灯片没有被正确隐藏，用户可能在不知情的情况下从幻灯片 1 跳转到幻灯片 2 的内容
• 自动轮播干扰：自动轮播可能打断屏幕阅读器用户的浏览流程
• 键盘导航困难：如果轮播没有正确处理焦点管理，键盘用户可能无法有效控制轮播

二、WAI-ARIA 角色与属性

2.1 基本角色

轮播区域使用 role="region" 标记为地标区域，并通过 aria-roledescription="carousel" 提供额外的角色描述：

<section
  role="region"
  aria-roledescription="carousel"
  aria-label="产品展示">
  <!-- 轮播内容 -->
</section>

2.2 幻灯片属性

每个幻灯片具有以下属性：

• role="group"：将幻灯片标记为一个组
• aria-roledescription="slide"：提供幻灯片的角色描述
• aria-label 或 aria-labelledby：提供幻灯片的可访问标签

<div
  role="group"
  aria-roledescription="slide"
  aria-label="第 1 张，共 3 张">
  <!-- 幻灯片内容 -->
</div>

2.3 幻灯片可见性

使用 aria-hidden 控制幻灯片的可见性：

• aria-hidden="true"：幻灯片不可见（不在视口内）
• aria-hidden="false"：幻灯片可见（当前显示的幻灯片）

<!-- 当前显示的幻灯片 -->
<div
  role="group"
  aria-roledescription="slide"
  aria-label="第 1 张，共 3 张"
  aria-hidden="false">
  <img
    src="slide1.jpg"
    alt="产品图片 1" />
</div>

<!-- 隐藏的幻灯片 -->
<div
  role="group"
  aria-roledescription="slide"
  aria-label="第 2 张，共 3 张"
  aria-hidden="true">
  <img
    src="slide2.jpg"
    alt="产品图片 2" />
</div>

2.4 控制按钮属性

上一张/下一张按钮

使用 aria-controls 属性指向被控制的幻灯片容器 ID，让辅助技术用户了解按钮会影响哪个区域的内容：

<button
  aria-label="上一张"
  aria-controls="carousel-slides">
  ←
</button>
<button
  aria-label="下一张"
  aria-controls="carousel-slides">
  →
</button>

轮播控制按钮（停止/启动）

使用 aria-pressed 表示按钮的按下状态，false 表示轮播正在运行，点击后会停止：

<button
  aria-label="停止轮播"
  aria-pressed="false"
  aria-controls="carousel-slides">
  ⏸
</button>

幻灯片选择器（圆点导航）

幻灯片选择器使用 role="tab" 模式，每个圆点按钮都是一个 tab，通过 aria-selected 表示当前选中的幻灯片：

<div
  role="tablist"
  aria-label="幻灯片选择">
  <button
    role="tab"
    aria-label="第 1 张"
    aria-selected="true"
    aria-controls="slide-1"></button>
  <button
    role="tab"
    aria-label="第 2 张"
    aria-selected="false"
    aria-controls="slide-2"></button>
  <button
    role="tab"
    aria-label="第 3 张"
    aria-selected="false"
    aria-controls="slide-3"></button>
</div>

三、键盘交互规范

3.1 基本键盘交互

3.2 自动轮播的键盘行为

• 当轮播中的任何元素获得键盘焦点时，自动轮播必须停止
• 轮播不会自动恢复，除非用户明确激活旋转控制

3.3 Tab 顺序

• 旋转控制按钮（如果存在）必须是轮播内部 Tab 顺序中的第一个元素
• 这确保辅助技术用户可以轻松找到控制按钮

四、鼠标交互规范

4.1 悬停行为

• 当鼠标悬停在轮播上时，自动轮播必须停止
• 鼠标移出后，可以恢复自动轮播（根据设计决定）

4.2 点击行为

• 点击上一张/下一张按钮切换幻灯片
• 点击幻灯片选择器跳转到特定幻灯片
• 点击旋转控制按钮停止/启动自动轮播

五、实现方式

5.1 基础轮播结构

<section
  class="carousel"
  aria-roledescription="carousel"
  aria-label="产品展示">
  <!-- 旋转控制按钮 -->
  <button
    class="rotation-control"
    aria-label="停止轮播"
    aria-pressed="false"
    aria-controls="carousel-slides">
    ⏸
  </button>

  <!-- 幻灯片容器 -->
  <div
    id="carousel-slides"
    class="carousel-slides">
    <div
      role="group"
      aria-roledescription="slide"
      aria-label="第 1 张，共 3 张"
      aria-hidden="false"
      class="slide active">
      <img
        src="slide1.jpg"
        alt="产品图片 1" />
      <div class="slide-content">
        <h2>产品标题 1</h2>
        <p>产品描述...</p>
        <a href="/product1">了解更多</a>
      </div>
    </div>

    <div
      role="group"
      aria-roledescription="slide"
      aria-label="第 2 张，共 3 张"
      aria-hidden="true"
      class="slide">
      <img
        src="slide2.jpg"
        alt="产品图片 2" />
      <div class="slide-content">
        <h2>产品标题 2</h2>
        <p>产品描述...</p>
        <a href="/product2">了解更多</a>
      </div>
    </div>

    <div
      role="group"
      aria-roledescription="slide"
      aria-label="第 3 张，共 3 张"
      aria-hidden="true"
      class="slide">
      <img
        src="slide3.jpg"
        alt="产品图片 3" />
      <div class="slide-content">
        <h2>产品标题 3</h2>
        <p>产品描述...</p>
        <a href="/product3">了解更多</a>
      </div>
    </div>
  </div>

  <!-- 导航按钮 -->
  <button
    class="prev-btn"
    aria-label="上一张"
    aria-controls="carousel-slides">
    ←
  </button>
  <button
    class="next-btn"
    aria-label="下一张"
    aria-controls="carousel-slides">
    →
  </button>

  <!-- 幻灯片选择器 -->
  <div
    class="slide-picker"
    role="tablist"
    aria-label="幻灯片选择">
    <button
      role="tab"
      aria-label="第 1 张"
      aria-selected="true"
      aria-controls="slide-1"></button>
    <button
      role="tab"
      aria-label="第 2 张"
      aria-selected="false"
      aria-controls="slide-2"></button>
    <button
      role="tab"
      aria-label="第 3 张"
      aria-selected="false"
      aria-controls="slide-3"></button>
  </div>
</section>

5.2 关键实现要点

幻灯片可见性管理：

• 当前显示的幻灯片：aria-hidden="false"
• 隐藏的幻灯片：aria-hidden="true"
• 使用 CSS 控制显示/隐藏（如 opacity、display 或 visibility）

自动轮播控制：

• 键盘焦点进入轮播区域时，必须停止自动轮播
• 鼠标悬停在轮播上时，必须停止自动轮播
• 提供停止/启动按钮，让用户控制自动轮播

幻灯片选择器状态：

• 当前幻灯片对应的按钮：aria-selected="true"
• 其他按钮：aria-selected="false"

六、常见应用场景

6.1 产品图片展示

<section
  aria-roledescription="carousel"
  aria-label="产品图片">
  <div
    role="group"
    aria-roledescription="slide"
    aria-label="第 1 张，共 4 张">
    <img
      src="product-1.jpg"
      alt="产品正面视图" />
  </div>
  <div
    role="group"
    aria-roledescription="slide"
    aria-label="第 2 张，共 4 张">
    <img
      src="product-2.jpg"
      alt="产品侧面视图" />
  </div>
  <div
    role="group"
    aria-roledescription="slide"
    aria-label="第 3 张，共 4 张">
    <img
      src="product-3.jpg"
      alt="产品背面视图" />
  </div>
  <div
    role="group"
    aria-roledescription="slide"
    aria-label="第 4 张，共 4 张">
    <img
      src="product-4.jpg"
      alt="产品细节视图" />
  </div>
</section>

6.2 testimonials/客户评价

<section
  aria-roledescription="carousel"
  aria-label="客户评价">
  <div
    role="group"
    aria-roledescription="slide"
    aria-label="第 1 张，共 3 张">
    <blockquote>
      <p>"这个产品改变了我的工作方式..."</p>
      <footer>— 张三，某公司员工</footer>
    </blockquote>
  </div>
  <div
    role="group"
    aria-roledescription="slide"
    aria-label="第 2 张，共 3 张">
    <blockquote>
      <p>"客服非常专业，响应迅速..."</p>
      <footer>— 李四，自由职业者</footer>
    </blockquote>
  </div>
</section>

6.3 新闻/公告轮播

<section
  aria-roledescription="carousel"
  aria-label="最新公告">
  <div
    role="group"
    aria-roledescription="slide"
    aria-label="第 1 张，共 3 张">
    <article>
      <h3>公司发布新产品</h3>
      <p>我们很高兴地宣布...</p>
      <a href="/news/1">阅读更多</a>
    </article>
  </div>
</section>

七、最佳实践

7.1 始终提供轮播控制

• 必须提供上一张/下一张按钮
• 如果启用自动轮播，必须提供停止/启动控制按钮
• 建议提供幻灯片选择器（圆点导航）

7.2 正确处理幻灯片可见性

• 使用 aria-hidden="true" 隐藏不可见的幻灯片
• 确保隐藏的幻灯片内容不会被屏幕阅读器读取
• 当前幻灯片使用 aria-hidden="false"

7.3 自动轮播的控制

• 自动轮播必须在以下情况下停止：
  • 键盘焦点进入轮播区域
  • 鼠标悬停在轮播上
  • 用户点击停止按钮
• 不要在用户未明确请求的情况下重新启动自动轮播

7.4 提供清晰的标签

• 为轮播区域提供描述性的 aria-label
• 为每个幻灯片提供包含位置信息的标签（如"第 1 张，共 3 张"）
• 为所有控制按钮提供清晰的 aria-label

7.5 避免使用轮播的情况

以下情况不建议使用轮播：

• 内容对用户都很重要，需要同时可见
• 用户需要比较不同幻灯片的内容
• 幻灯片内容包含重要的交互元素

在这些情况下，考虑使用静态列表或网格布局。

7.6 移动端触摸支持

移动端应支持触摸滑动切换幻灯片：

• 向左滑动 → 显示下一张
• 向右滑动 → 显示上一张
• 需要设置滑动阈值（如 50px），避免误触

八、总结

构建无障碍的 Carousel 组件需要特别关注：

1. 正确的 ARIA 标记：使用 role="region"、aria-roledescription、aria-hidden 等属性
2. 完整的键盘支持：确保所有功能都可以通过键盘访问
3. 自动轮播控制：提供停止/启动控制，并在焦点进入时自动停止
4. 清晰的标签：为轮播、幻灯片和控制按钮提供描述性标签
5. 幻灯片可见性管理：正确隐藏不可见的幻灯片，避免屏幕阅读器混淆

轮播组件虽然常见，但如果没有正确实现，会对无障碍体验造成严重影响。遵循 W3C Carousel Pattern 规范，我们能够创建既美观又包容的轮播组件，为所有用户提供良好的体验。

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

上一篇已经拆解了大模型计费的底层逻辑：Token 是什么、官方如何收费，以及中转站倍率体系如何影响成本。但理解计费只是第一步，开发中更关键的问题是：知道它贵之后，如何把成本真正降下来。

需要先说明的是，本文中的案例将主要使用电商与客服场景来演示节省 Token 的方法。这样做是为了让成本结构更直观、优化路径更清晰；这些方法本身同样适用于多数具备多轮对话、工具调用、知识检索特征的 LLM 应用。

本文聚焦的问题是：在实际项目开发中，有哪些真正有效的策略可以减少 Token 消耗？ 文章不会停留在“少写点字”这类笼统建议上，而是从提示词工程、上下文管理、缓存策略、模型选择、架构设计五个维度，给出可直接落地的对比案例。

每个策略都会附上"优化前 vs 优化后"的对比，让你直观看到 Token 消耗的变化。

一、提示词精简：最直接的降本入口

提示词（System Prompt + User Prompt）是每次请求都会重复发送的内容。它的冗余程度，直接决定了你的输入 Token 基线。

1. 去除冗余描述和重复指令

很多开发者习惯在系统提示词里写得非常详细，甚至同一个意思用不同方式说了两三遍。模型并不需要这种"重复强调"。

❌ 优化前（约 180 Token）

你是一个非常专业的客服助手。你的任务是帮助用户解决问题。
你需要始终保持礼貌和专业。你回答问题时要简洁明了。
请不要回答与产品无关的问题。如果用户问了与产品无关的问题，
请礼貌地告诉用户你只能回答产品相关的问题。
你应该尽量用中文回答。回答时不要太长，保持简洁。
记住，你是客服助手，不是通用聊天机器人。

✅ 优化后（约 60 Token）

角色：产品客服助手
规则：
- 仅回答产品相关问题，其余礼貌拒绝
- 中文回答，简洁专业

节省效果：约 67% 的系统提示词 Token。 如果你的应用每天处理 1 万次请求，仅这一项优化每天就能减少约 120 万输入 Token。

许多提示词中的补充性表述并不会显著提升效果。除非场景确实需要多轮强调或额外约束，否则没有必要用面向人的沟通方式去“安抚”模型；从成本控制角度看，简洁明确往往更有效。

2. 使用结构化格式代替自然语言描述

模型对结构化指令的理解能力很强。与其用长段落描述规则，不如用 YAML、Markdown 列表或 JSON 格式。

❌ 优化前（约 250 Token）

当用户询问退款政策时，你需要告诉他们：如果商品在购买后7天内
且未拆封，可以全额退款。如果商品已拆封但在7天内，可以退款
但需要扣除15%的手续费。如果超过7天但在30天内，只能换货不
能退款。超过30天则不支持任何退款或换货服务。你需要根据用户
描述的情况判断属于哪种，然后给出对应的回答。

✅ 优化后（约 100 Token）

退款政策查找表：
| 条件 | 处理方式 |
|---|---|
| ≤7天 + 未拆封 | 全额退款 |
| ≤7天 + 已拆封 | 退款扣15%手续费 |
| 8-30天 | 仅换货 |
| >30天 | 不支持 |
根据用户情况匹配对应行回复。

节省效果：约 60% Token。 而且结构化格式还能提升模型的准确率，一举两得。

3. 用变量占位代替静态长文本

如果你的提示词里有大量静态内容（如产品说明、FAQ 列表），每次都原样发送会非常浪费。

❌ 优化前：把完整 FAQ 塞进每次请求（约 2000 Token）

System: 你是XX产品客服。以下是完整FAQ：
Q1: 如何注册？A: 打开官网点击注册...(200字)
Q2: 如何修改密码？A: 进入设置页面...(150字)
Q3: 支持哪些支付方式？A: 支持微信、支付宝...(180字)
...(共20条FAQ，总计约1800 Token)
请根据以上FAQ回答用户问题。

✅ 优化后：先分类再检索，只注入相关条目（约 300 Token）

System: 你是XX产品客服。根据以下相关FAQ回答：
{retrieved_faq}
如FAQ未覆盖，回复"我需要转接人工客服为您处理"。

其中 {retrieved_faq} 只包含与当前问题最相关的 1-3 条 FAQ。

节省效果：约 85% 的 FAQ 相关 Token。 这就是最基础的 RAG（检索增强生成）思路：不是把所有知识一次性塞给模型，而是只注入当前问题真正需要的内容。

二、上下文管理：控制多轮对话的隐形成本

上一篇已经提到，多轮对话中历史消息会在后续请求中被反复带入输入侧。这意味着对话越长，每一轮的输入 Token 成本就越高。

1. 滑动窗口：只保留最近 N 轮

最简单的策略是限制上下文长度，只把最近的几轮对话发给模型。

❌ 优化前：完整历史（第 10 轮时约 8000 Token 输入）

messages: [
  { role: "system", content: "..." },
  { role: "user", content: "第1轮问题" },
  { role: "assistant", content: "第1轮回答" },
  { role: "user", content: "第2轮问题" },
  { role: "assistant", content: "第2轮回答" },
  // ... 一直到第10轮
  { role: "user", content: "第10轮问题" }
]

✅ 优化后：滑动窗口保留最近 3 轮（约 2500 Token 输入）

messages: [
  { role: "system", content: "..." },
  { role: "user", content: "第8轮问题" },
  { role: "assistant", content: "第8轮回答" },
  { role: "user", content: "第9轮问题" },
  { role: "assistant", content: "第9轮回答" },
  { role: "user", content: "第10轮问题" }
]

节省效果：约 69% 的输入 Token。 对于大多数客服与问答场景，保留最近 3-5 轮通常已经足够。

2. 摘要压缩：用模型总结历史

如果业务需要更长的上下文记忆，可以用一次廉价的模型调用把历史压缩成摘要。

❌ 优化前：20 轮完整历史（约 15000 Token）

完整保留所有对话消息。

✅ 优化后：摘要 + 最近 3 轮（约 3500 Token）

messages: [
  { role: "system", content: "..." },
  { role: "system", content: "对话摘要：用户咨询了A产品的退款流程，
    已确认购买日期在7天内且未拆封，正在等待退款地址。" },
  { role: "user", content: "第18轮问题" },
  { role: "assistant", content: "第18轮回答" },
  { role: "user", content: "第19轮问题" },
  { role: "assistant", content: "第19轮回答" },
  { role: "user", content: "第20轮问题" }
]

节省效果：约 77%。 虽然生成摘要本身也会消耗 Token，但如果使用小模型（如 GPT-4o-mini）完成摘要，整体成本仍然远低于每一轮都携带完整历史。

3. 按需加载上下文而非全量注入

这是上下文管理中最容易被忽视的一点：不是所有上下文在每次请求时都需要。

❌ 优化前：每次请求都注入完整工具定义（约 3000 Token）

tools: [
  { name: "search_products", description: "...", parameters: {...} },
  { name: "check_order", description: "...", parameters: {...} },
  { name: "process_refund", description: "...", parameters: {...} },
  { name: "update_address", description: "...", parameters: {...} },
  { name: "send_email", description: "...", parameters: {...} },
  { name: "create_ticket", description: "...", parameters: {...} },
  // ... 共15个工具
]

✅ 优化后：根据意图分类，只注入相关工具（约 600 Token）

先用一次轻量分类（或规则匹配）判断用户意图，再只注入对应的工具子集：

// 用户意图: "退款"
tools: [
  { name: "check_order", description: "...", parameters: {...} },
  { name: "process_refund", description: "...", parameters: {...} }
]

节省效果：约 80%。 这一思路不只适用于工具定义，也适用于知识库片段、Schema 描述等所有“上下文素材”。

三、缓存策略：让重复内容只付一次全价

上一篇讲过，缓存命中的输入 Token 通常只按原价的 1/10 计费。所以，合理利用缓存机制是降本的重要手段。

1. 稳定前缀原则

缓存命中的前提是：请求的前缀部分和上次请求一致。所以，把不变的内容放前面，变化的内容放后面。

❌ 优化前：动态内容在前（缓存几乎无法命中）

messages: [
  { role: "user", content: "今天天气真好，我想问一下..." },
  { role: "system", content: "你是XX产品客服...（2000 Token 系统提示）" }
]

✅ 优化后：系统提示在前、动态内容在后（前缀可被缓存）

messages: [
  { role: "system", content: "你是XX产品客服...（2000 Token 系统提示）" },
  { role: "user", content: "今天天气真好，我想问一下..." }
]

节省效果： 假设系统提示 2000 Token，命中缓存后这部分从 2000 × Pin 降到 2000 × 0.1 × Pin，输入侧这部分节省 90%。

2. 批量请求共享前缀

如果你有一批类似任务（如批量翻译、批量分类），把它们组织成共享相同 system prompt 的连续请求，可以最大化缓存命中。

❌ 优化前：随机交替发送不同任务

请求1: [翻译系统提示] + 翻译任务A
请求2: [分类系统提示] + 分类任务B
请求3: [翻译系统提示] + 翻译任务C  ← 提示可能已被清出缓存
请求4: [分类系统提示] + 分类任务D  ← 提示可能已被清出缓存

✅ 优化后：同类任务集中发送

请求1: [翻译系统提示] + 翻译任务A
请求2: [翻译系统提示] + 翻译任务C  ← 缓存命中
请求3: [翻译系统提示] + 翻译任务E  ← 缓存命中
...
请求N: [分类系统提示] + 分类任务B
请求N+1: [分类系统提示] + 分类任务D  ← 缓存命中

节省效果： 如果批量处理 100 个翻译任务，系统提示为 1500 Token，那么第一个请求按原价计费，后 99 个请求命中缓存后按缓存价计费，可节省约 89% 的系统提示输入成本。

四、模型选择：不是所有任务都需要最强模型

这可能是最容易被忽视、但收益最显著的策略之一：不同任务使用不同模型。

1. 任务分级路由

❌ 优化前：所有任务统一用 Claude 3.5 Sonnet

意图识别 → Claude 3.5 Sonnet（$3/1M 输入，$15/1M 输出）
简单问答 → Claude 3.5 Sonnet
复杂推理 → Claude 3.5 Sonnet
文本分类 → Claude 3.5 Sonnet

✅ 优化后：按任务复杂度路由

意图识别 → GPT-4o-mini（$0.15/1M 输入，$0.6/1M 输出）
简单问答 → GPT-4o-mini
复杂推理 → Claude 3.5 Sonnet
文本分类 → GPT-4o-mini

假设流量分布是：60% 简单任务 + 25% 中等任务 + 15% 复杂任务：

加权平均输出单价：从 $15/1M 降到约$15/1M降到约2.76/1M，节省约 82%。

2. Thinking 模式的精准使用

上一篇说过，thinking 模式会额外产生大量推理 Token。所以它只应该在真正需要复杂推理时开启。

❌ 优化前：所有请求都开 thinking

一个简单的格式转换任务：

输入 Token: 500
可见输出 Token: 200
thinking Token: 2000  ← 模型"想"了很多但完全没必要
总输出计费: 2200 Token

✅ 优化后：仅对复杂推理任务开启 thinking

同一个格式转换任务：

输入 Token: 500
可见输出 Token: 200
thinking Token: 0
总输出计费: 200 Token

节省效果：输出侧 Token 减少约 91%。 对于简单任务，thinking 不仅会抬高成本，也会显著增加延迟。

五、输出控制：减少模型的"废话"

输出 Token 通常比输入贵 3-6 倍。控制输出长度是降本的高杠杆点。

1. 限定输出格式

❌ 优化前：自由格式回答（约 300 Token 输出）

User: 这个订单的状态是什么？
Assistant: 您好！感谢您的询问。我来帮您查看一下订单状态。
经过查询，您的订单号为 #12345 的订单目前处于"已发货"状态。
该订单已于2024年3月15日从我们的仓库发出，预计将在3-5个
工作日内送达。您可以使用快递单号 SF1234567890 在顺丰官网
查询物流信息。如果您还有其他问题，请随时告诉我！

✅ 优化后：要求结构化输出（约 60 Token 输出）

系统提示中增加：输出JSON格式: {status, shipped_date, tracking_no, eta}

{"status":"已发货","shipped_date":"2024-03-15",
"tracking_no":"SF1234567890","eta":"3-5工作日"}

节省效果：输出 Token 减少约 80%。 结构化输出不仅能减少 Token 消耗，也更便于程序稳定解析。

2. 设置 max_tokens 防止超长输出

即使提示词已经要求简洁，模型有时仍会"发挥过度"。设置 max_tokens 是最后一道防线。

// 分类任务：输出不应超过 20 Token
await openai.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [...],
  max_tokens: 20
});

这通常不会影响模型质量——如果任务本身只需要短输出，max_tokens 只是防止回答意外拉长。

六、架构设计：从系统层面控制成本

多层架构：规则拦截 → 语义缓存 → 模型兜底

以上是单次请求层面的优化。到了系统架构层面，还有几个影响更大的设计决策。

1. 结果缓存：相同问题不重复调用

❌ 优化前：每次相同问题都调用模型

用户A问: "你们的营业时间是？" → 调用模型 → 消耗 Token
用户B问: "营业时间几点？" → 调用模型 → 消耗 Token
用户C问: "什么时候开门？" → 调用模型 → 消耗 Token

✅ 优化后：语义缓存 + TTL

用户A问: "你们的营业时间是？"
  → embedding相似度搜索 → 未命中 → 调用模型 → 缓存结果
用户B问: "营业时间几点？"
  → embedding相似度搜索 → 命中 → 直接返回缓存 → 0 Token
用户C问: "什么时候开门？"
  → embedding相似度搜索 → 命中 → 直接返回缓存 → 0 Token

节省效果： 如果 30% 的问题可以通过语义缓存命中，整体模型调用量就能直接减少 30%。而 Embedding 的成本通常远低于生成式模型调用。

2. 预处理层：能不用模型就不用模型

❌ 优化前：所有请求都进模型

"你好" → 模型处理 → "你好！有什么可以帮助您的？"
"谢谢" → 模型处理 → "不客气！还有其他问题吗？"
"#@!$%" → 模型处理 → "抱歉，我没有理解您的意思"

✅ 优化后：规则层拦截 + 模型兜底

"你好" → 规则匹配 → 固定回复（0 Token）
"谢谢" → 规则匹配 → 固定回复（0 Token）
"#@!$%" → 规则拦截 → 固定回复（0 Token）
"我想退款" → 规则未匹配 → 进入模型处理

节省效果： 实际业务中，20%-40% 的对话可以被规则层直接处理，完全不消耗模型 Token。

3. 异步批处理 vs 实时调用

如果你的任务不要求实时返回（如数据标注、内容审核、批量翻译），使用 Batch API 通常可以获得 50% 的价格折扣。

七、综合案例：一个客服系统的全链路优化

把上面的策略组合起来，看一个完整的案例。

假设一个电商客服系统：

• 日均 10,000 次对话
• 平均每次对话 5 轮
• 系统提示词 2000 Token
• 每轮用户输入约 100 Token，模型输出约 300 Token

优化前的日均成本估算

每轮输入 ≈ 2000（系统提示）+ 累积历史（平均约 1500）+ 100（用户输入）= 3600 Token
每轮输出 ≈ 300 Token
每次对话 5 轮总输入 ≈ 18,000 Token
每次对话 5 轮总输出 ≈ 1,500 Token

日均总输入 = 10,000 × 18,000 = 1.8 亿 Token
日均总输出 = 10,000 × 1,500 = 1,500 万 Token

使用 GPT-4o（$2.5/1M 输入，$10/1M 输出）：
日均成本 = 180 × 2.5 + 15 × 10 = $450 + $150 = $600

优化后的日均成本估算

应用以下策略组合：

1. 提示词精简：2000 → 800 Token
2. 滑动窗口（保留 3 轮）：平均历史从 1500 降到 600 Token
3. 缓存命中（前缀稳定）：800 Token 系统提示 90% 命中缓存
4. 模型路由：85% 简单任务用 GPT-4o-mini
5. 输出结构化：输出从 300 降到 120 Token
6. 规则层拦截：30% 对话不进模型
7. 语义缓存：额外命中 15%

实际进入模型的对话 = 10,000 × (1 - 0.30 - 0.15) = 5,500 次

每轮输入 ≈ 80（未缓存提示）+ 720（缓存提示，按0.1计）+ 600 + 100 = 852 等效 Token
每轮输出 ≈ 120 Token
每次对话 5 轮总等效输入 ≈ 4,260 Token
每次对话 5 轮总输出 ≈ 600 Token

其中 85% 用 GPT-4o-mini，15% 用 GPT-4o：

mini 部分：
输入 = 5,500 × 0.85 × 4,260 = 约 2,000 万 Token × $0.15/1M = $3
输出 = 5,500 × 0.85 × 600 = 约 280 万 Token × $0.6/1M = $1.7

4o 部分：
输入 = 5,500 × 0.15 × 4,260 = 约 350 万 Token × $2.5/1M = $8.8
输出 = 5,500 × 0.15 × 600 = 约 50 万 Token × $10/1M = $5

日均总成本 ≈ $3 + $1.7 + $8.8 + $5 = $18.5

📊 优化效果汇总

• 优化前日均成本：$600
• 优化后日均成本：$18.5
• 节省比例：约 97%
• 月度节省：约 $17,445

以上数字是基于电商客服场景的理想化综合估算，实际效果仍取决于业务形态、流量结构与实现质量。但即使只达到其中一部分优化收益，节省幅度也往往足够可观。

八、策略选择优先级

不同策略的实施难度和收益差异很大。如果你不确定从哪里开始，可以参考这个优先级：

九、结论：省 Token 的本质是工程能力

回顾整篇文章，所有优化策略本质上都在做同一件事：

让模型只处理它真正需要处理的信息，只生成你真正需要的输出。

这不是某个神奇的参数配置，而是一整套工程实践：

• 提示词工程解决的是"少说废话"；
• 上下文管理解决的是"别重复带货"；
• 缓存策略解决的是"重复的东西别全价付"；
• 模型路由解决的是"杀鸡别用牛刀"；
• 架构设计解决的是"能不调模型就别调"。

上一篇讨论的是“钱是如何花出去的”，这一篇讨论的是“成本如何系统地降下来”。两篇结合起来，基本可以构成对大模型成本问题的完整认知闭环。

需要强调的是：省 Token 本身不是目的，在可接受的质量前提下降低 Token 成本，才有实际意义。 任何优化都不应以明显牺牲用户体验或输出质量为代价。在推进每一项优化时，都应该同步监控质量指标，确保成本下降不是以服务质量下滑换来的。

附：一个可实际体验的中转站选择

如果你想把本文的策略（提示词精简、上下文裁剪、缓存命中、模型路由、输出控制）真正落到工程里，最有效的办法之一是找一个计费透明、统计清晰、便于切模型与观察缓存的平台，做几组小实验把“优化前 vs 优化后”的差异跑出来。

如果你最近刚好在找可用的中转站，也可以参考我朋友超哥在做的 Amux API。它更适合用来做这些验证：

• 多模型统一接入：便于做“大小模型分流”的对比；
• 成本与用量更直观：方便核对输入、输出、缓存命中后的计费差异；
• 更贴近真实账单：用同一套业务请求去验证“前缀稳定”“输出变短”等策略的实际收益。

选平台时，建议仍按本文标准做取舍：不仅看倍率，也要看充值口径、缓存表现、计费透明度和稳定性。

写在最后🧪

这里是言萧凡的 AI 编程实验室。 我会在这里持续记录和分享 AI 工具、编程实践，以及那些值得沉淀下来的高效工作方法。 不只聊概念，也尽量分享能直接上手、能够复用的经验。 希望这间小小的实验室，能陪你一起探索、实践和成长。2026 年，一起进步。

JavaScript 闭包经典问题：为什么输出 10 次 i=10

问题代码

先观察以下代码，思考输出结果：

function f() {
    for(var i = 0; i < 10; i++) {
        setTimeout(() => {
            console.log('i=', i)
        });
    }
}

f();

输出结果：

i= 10
i= 10
i= 10
...（共 10 次）

执行过程详解

第一步：var 变量的作用域

for(var i = 0; i < 10; i())
    ↑
    └── var 声明的变量是函数作用域
        整个函数 f 内都能访问这个 i

第二步：循环执行过程

循环次数     i 的值    循环条件 (i < 10)
---------------------------------------
第 1 次      0         ✓ 通过
第 2 次      1         ✓ 通过
...
第 10 次     9         ✓ 通过
             10        ✗ 不通过，循环结束

循环结束后：i = 10

第三步：创建 10 个回调函数

for(var i = 0; i < 10; i++) {
    setTimeout(() => {
        console.log('i=', i)  // ← 所有回调共享同一个 i
    });
}

每次循环创建一个箭头函数，都通过闭包引用变量 i

第四步：异步执行时序

时间轴：
─────────────────────────────────────────
| 同步执行阶段        | 异步执行阶段        |
─────────────────────────────────────────
for 循环完成      setTimeout 回调执行
i 递增到 10       读取 i 的值（此时 i=10）
                  输出 10 次 i=10
─────────────────────────────────────────

核心原因

三个关键点

1. var 是函数作用域

   • 不是块级作用域
   • 整个函数内只有一个 i 变量

2. 闭包共享变量

   • 10 个箭头函数都引用同一个 i
   • 不是创建 10 个独立的 i 副本

3. setTimeout 异步执行

   • 回调函数放入任务队列延迟执行
   • 执行时循环已结束，i 已经是 10

图示理解

变量 i 的生命周期：
─────────────────────────────→ 时间
     0 1 2 3 4 5 6 7 8 9  10
     └───┬───┘ └───┬───┘
         │                │
     同步循环执行        循环结束
                        i=10

回调函数 1:  ────────────────────→ 读取 i (10)
回调函数 2:  ────────────────────→ 读取 i (10)
...
回调函数 10: ────────────────────→ 读取 i (10)

解决方案

方案 1：使用 let（推荐）✨

function f() {
    for(let i = 0; i < 10; i++) {
        setTimeout(() => {
            console.log('i=', i)
        });
    }
}

原理： let 是块级作用域，每次循环创建新的 i 绑定

输出： i= 0 到 i= 9 各一次

方案 2：IIFE 立即执行函数

function f() {
    for(var i = 0; i < 10; i++) {
        (function(j) {
            setTimeout(() => {
                console.log('i=', j)
            });
        })(i);
    }
}

原理： 通过函数参数保存每次循环的 i 值

方案 3：传递参数给 setTimeout

function f() {
    for(var i = 0; i < 10; i++) {
        setTimeout((j) => {
            console.log('i=', j)
        }, 0, i);
    }
}

原理： setTimeout 的第三个参数会传递给回调函数

知识点总结

一句话总结

var 的函数作用域 + 闭包共享变量 + setTimeout 异步执行 = 所有回调读取到循环结束后的同一个 i 值（10）

一名同时精通 Blender 建模与 Three.js 渲染的工程师，带你打通从艺术创作到 Web 实时渲染的全链路。

前言

很多开发者在学习 Three.js 时，习惯用代码"画"出几何体——一个 BoxGeometry，一个 SphereGeometry，就此打住。而建模师则沉浸在 Blender 的雕刻与材质世界里，对 Web 端渲染一无所知。

真正有价值的 3D Web 项目，往往需要这两者的深度结合：Blender 负责内容生产，Three.js 负责实时呈现。本文将从工作流、格式选择、材质映射、性能优化到动画同步，系统拆解这套协作体系的每一个关键节点。

一、为什么选择 Blender + Three.js？

Blender 的优势

Blender 是目前最强大的开源 3D 创作套件，集建模、雕刻、UV 展开、材质编辑、骨骼绑定、动画、渲染于一体。它的 PBR（基于物理的渲染）材质系统与 Three.js 的 MeshStandardMaterial 有高度的理论对应关系，这使得材质迁移成为可能，而非只能靠"近似"。

Three.js 的优势

Three.js 是 WebGL 的高级封装，让开发者无需手写 GLSL Shader 就能实现实时 3D 渲染。它支持 glTF 2.0 标准、骨骼动画、变形动画、PBR 材质、HDR 环境贴图，在浏览器端提供接近原生的视觉质量。

两者的天然契合点

glTF 2.0 是连接两者的"通用语言"，它由 Khronos Group 制定，Blender 对其有完整的原生导出支持，Three.js 也将其作为首推格式。

二、Blender 建模的 Web 友好实践

在 Blender 中建模时，如果目标是 Web 端实时渲染，需要从一开始就考虑"面向 Web 的建模规范"，而不是按离线渲染的标准来做。

2.1 多边形控制：少即是多

离线渲染可以承受千万面模型，但 Web 端 GPU 对三角面数极为敏感。经验值如下：

• 单个主体模型：5,000 ~ 50,000 三角面（取决于镜头距离）
• 背景/远景物体：500 ~ 2,000 三角面
• 整个场景：尽量控制在 300,000 三角面以内（移动端减半）

实用技巧：

在 Blender 中使用 Decimate 修改器可以智能减面，
Ratio 参数从 1.0 逐渐降低，观察模型形变程度，
通常 0.5 ~ 0.7 可在不明显损失细节的前提下大幅减面。

高模细节应通过 法线贴图（Normal Map）  烘焙到低模上，而不是保留在几何体中。这是 Web 3D 最核心的优化手段之一。

2.2 UV 展开的关键性

Three.js 中所有贴图都依赖 UV 坐标。Blender 中的 UV 展开质量直接决定贴图利用率和最终画质。

UV 展开建议：

1. 使用 Smart UV Project 快速处理机械类硬表面模型
2. 有机体（角色、生物）使用 Mark Seam + Unwrap 手动控制接缝位置
3. UV 岛之间保留 至少 4 像素的边距（Margin）  ，防止贴图渗色
4. 避免 UV 重叠（除非是对称模型且确定共用贴图）

2.3 坐标系与朝向

Blender 默认坐标系：Z 轴朝上，Y 轴朝前。 Three.js 坐标系：Y 轴朝上，Z 轴朝向观察者。

在 glTF 导出时，Blender 会自动进行坐标系转换，因此通常不需要手动旋转。但如果你在 Blender 中对模型进行了非标准旋转，导出后可能在 Three.js 中出现方向错误。

最佳实践：  在 Blender 中完成所有变换后，按 Ctrl+A → All Transforms 应用变换，确保对象的 Location/Rotation/Scale 归零。

三、PBR 材质：从 Blender 到 Three.js 的精确映射

这是整个工作流中最需要深入理解的环节。

3.1 Principled BSDF 与 MeshStandardMaterial 的对应关系

Blender 的 Principled BSDF 节点是工业级 PBR 着色器，其核心参数与 Three.js 的 MeshStandardMaterial 有如下对应：

注意：  glTF 2.0 格式将 Roughness 存储在贴图的 G 通道，Metallic 存储在 B 通道，合并为一张 metallicRoughnessMap。Three.js 的 GLTFLoader 会自动处理这个细节，开发者无需干预。

3.2 在 Blender 中烘焙 PBR 贴图

当模型使用了复杂的程序化材质（Noise、Voronoi、Wave 节点等）时，需要将其"烘焙"成位图才能在 Web 端使用。

烘焙流程：

1. 选中模型，进入 Cycles 渲染引擎（烘焙必须使用 Cycles）
2. 新建一张空白图像节点（Image Texture），不连接任何节点，只需选中它
3. 在 Render Properties → Bake 中选择烘焙类型：
4. • Diffuse（取消 Direct/Indirect，仅勾选 Color）→ Base Color 贴图
   • Roughness → Roughness 贴图
   • Normal（Space: Tangent）→ 法线贴图
   • Combined → 全局光照效果烘焙（含 AO、阴影，适合静态场景）
5. 点击 Bake，等待计算完成
6. 导出图像为 PNG（法线图）或 JPEG（颜色图，注意法线图不能用 JPEG 有损压缩！）

这里我推荐一个B站的烘焙教材，很不错的。

链接如下：

(www.bilibili.com/video/BV185…)

3.3 法线贴图的空间问题

Blender 默认导出**切线空间（Tangent Space）**法线贴图，Three.js 也默认使用切线空间法线，两者一致，无需额外处理。

但如果你在 Blender 中烘焙了**对象空间（Object Space）**法线贴图，则需要在 Three.js 中将 normalMapType 设置为 THREE.ObjectSpaceNormalMap：

material.normalMapType = THREE.ObjectSpaceNormalMap;

四、glTF 导出配置详解

glTF 是连接 Blender 和 Three.js 的核心桥梁，正确的导出配置至关重要。

4.1 .gltf vs .glb

推荐：生产环境使用 .glb，加载更快，管理更简单。

4.2 Blender 导出设置

File → Export → glTF 2.0，关键设置：

Format: glTF Binary (.glb)

✅ Include:
  - Selected Objects（只导出选中对象，避免导出无关物体）
  - Custom Properties（可传递自定义属性到 Three.js）

✅ Transform:
  - Y Up（确保坐标系正确）

✅ Geometry:
  - Apply Modifiers（应用所有修改器，但注意会破坏骨骼绑定）
  - UVs / Normals / Tangents / Vertex Colors
  - Loose Edges / Points（通常取消勾选）

✅ Animation:
  - Animations（导出动画数据）
  - Skinning（导出骨骼绑定）
  - Shape Keys（导出变形目标/Morph Targets）
  - NLA Strips（从非线性动画编辑器导出所有 Action）

✅ Draco Mesh Compression:
  开启后可大幅压缩几何体数据，但 Three.js 需要额外加载 DRACOLoader

4.3 在 Three.js 中加载 glTF

import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';

// 配置 Draco 解码器（如果导出时开启了 Draco 压缩）
const dracoLoader = new DRACOLoader();
dracoLoader.setDecoderPath('/draco/'); // 需要将 draco 解码器文件放在此路径

const loader = new GLTFLoader();
loader.setDRACOLoader(dracoLoader);

loader.load(
  '/models/scene.glb',
  (gltf) => {
    const model = gltf.scene;

    // 遍历所有网格，开启阴影
    model.traverse((node) => {
      if (node.isMesh) {
        node.castShadow = true;
        node.receiveShadow = true;

        // 如果使用 HDR 环境贴图，开启环境光反射
        node.material.envMapIntensity = 1.0;
      }
    });

    scene.add(model);
  },
  (progress) => {
    console.log(`加载进度: ${(progress.loaded / progress.total * 100).toFixed(1)}%`);
  },
  (error) => {
    console.error('加载失败:', error);
  }
);

五、动画系统深度对接

Blender 的动画系统与 Three.js 的 AnimationMixer 是整个工作流中最复杂的对接点。

5.1 Blender 动画类型与 Three.js 对应

骨骼动画（Armature Animation）

最常见的角色动画类型。Blender 中为骨骼创建 Action，绑定到 Mesh。导出后 Three.js 通过 SkinnedMesh 和 AnimationClip 驱动。

// 加载后获取所有动画
const animations = gltf.animations; // AnimationClip[]
const mixer = new THREE.AnimationMixer(gltf.scene);

// 播放特定动画（如 "Walk" Action）
const walkClip = THREE.AnimationClip.findByName(animations, 'Walk');
const walkAction = mixer.clipAction(walkClip);
walkAction.play();

// 在渲染循环中更新
const clock = new THREE.Clock();
function animate() {
  requestAnimationFrame(animate);
  const delta = clock.getDelta();
  mixer.update(delta); // 关键：每帧更新动画混合器
  renderer.render(scene, camera);
}
animate();

变形目标动画（Shape Keys / Morph Targets）

适用于面部表情、布料变形等。Blender 中的 Shape Key 导出为 glTF 的 Morph Target。

// 访问变形目标
const mesh = gltf.scene.getObjectByName('Face');
console.log(mesh.morphTargetDictionary); // { "Smile": 0, "Blink": 1, ... }

// 直接设置变形权重（0~1）
mesh.morphTargetInfluences[0] = 0.8; // 80% 的 Smile 表情

// 或通过 AnimationMixer 驱动
const smileClip = THREE.AnimationClip.findByName(animations, 'Smile');
mixer.clipAction(smileClip).play();

5.2 动画过渡：crossFadeTo

游戏和交互应用中，动画之间的平滑过渡至关重要：

let currentAction = idleAction;

function transitionTo(newAction, duration = 0.3) {
  if (currentAction === newAction) return;

  newAction.reset();
  newAction.play();
  currentAction.crossFadeTo(newAction, duration, true);
  currentAction = newAction;
}

// 按键触发动画切换
document.addEventListener('keydown', (e) => {
  if (e.code === 'Space') transitionTo(runAction);
});

document.addEventListener('keyup', (e) => {
  if (e.code === 'Space') transitionTo(idleAction);
});

5.3 NLA 编辑器与多 Action 管理

在 Blender 中，推荐使用 NLA（Non-Linear Animation）编辑器将不同 Action（Idle、Walk、Run、Attack）管理在同一骨骼上。导出时勾选 NLA Strips，Three.js 端会收到所有 Action 作为独立的 AnimationClip。

Blender 操作：

1. 在 Dope Sheet 中切换到 NLA Editor
2. 将 Action 下压为 NLA Strip
3. 每个 Strip 对应一个独立动画
4. 确保每个 Action 有清晰的命名（会直接成为 Three.js 中 clip.name）

六、灯光与环境：让 Web 端复现 Blender 的视觉效果

6.1 HDR 环境贴图

Blender 中使用 HDR 环境光照（World → Environment Texture），Three.js 中同样支持，且是让模型在 Web 端看起来"专业"的关键。

import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader.js';

const pmremGenerator = new THREE.PMREMGenerator(renderer);
pmremGenerator.compileEquirectangularShader();

new RGBELoader().load('/hdr/studio_small.hdr', (texture) => {
  const envMap = pmremGenerator.fromEquirectangular(texture).texture;

  scene.environment = envMap;  // 影响所有 MeshStandardMaterial 的反射
  scene.background = envMap;   // 可选：将 HDR 作为背景

  texture.dispose();
  pmremGenerator.dispose();
});

推荐资源：Poly Haven（polyhaven.com/hdris） 提供大量免费高质量 HDR 文件。

6.2 灯光类型对应

注意：  glTF 导出支持 Point、Spot、Directional 灯光（需开启 KHR_lights_punctual 扩展，Blender 默认勾选），Area Light 不支持直接导出，需在 Three.js 端手动添加。

6.3 阴影质量配置

// 渲染器阴影配置
renderer.shadowMap.enabled = true;
renderer.shadowMap.type = THREE.PCFSoftShadowMap; // 柔和阴影

// 方向光阴影配置
const dirLight = new THREE.DirectionalLight(0xffffff, 1);
dirLight.castShadow = true;
dirLight.shadow.mapSize.width = 2048;  // 阴影贴图分辨率
dirLight.shadow.mapSize.height = 2048;
dirLight.shadow.camera.near = 0.1;
dirLight.shadow.camera.far = 50;
dirLight.shadow.camera.left = -10;
dirLight.shadow.camera.right = 10;
dirLight.shadow.camera.top = 10;
dirLight.shadow.camera.bottom = -10;
dirLight.shadow.bias = -0.001; // 防止阴影痤疮（Shadow Acne）

七、性能优化：从 Blender 到浏览器的极致压缩

7.1 纹理压缩：KTX2 + Basis Universal

传统 JPEG/PNG 贴图在 GPU 中需要解码为原始像素，占用大量显存。KTX2/Basis Universal 是可以直接在 GPU 上保持压缩状态的格式，显存占用可降低 4~8 倍。

工具链：

# 安装 KTX-Software
# 将 PNG 转换为 KTX2（UASTC 模式，高质量）
toktx --uastc --uastc_rdo_l 4 output.ktx2 input.png

# Three.js 中加载 KTX2
import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader.js';

const ktx2Loader = new KTX2Loader()
  .setTranscoderPath('/basis/')
  .detectSupport(renderer);

loader.setKTX2Loader(ktx2Loader);

7.2 实例化渲染：InstancedMesh

场景中有大量相同模型（树木、石头、草地）时，使用 InstancedMesh 可以将数千次 Draw Call 合并为一次：

// 在 Blender 中建好单个树木模型，导出后：
const treeGeometry = treeModel.geometry;
const treeMaterial = treeModel.material;

const COUNT = 1000;
const instancedMesh = new THREE.InstancedMesh(treeGeometry, treeMaterial, COUNT);

const dummy = new THREE.Object3D();
for (let i = 0; i < COUNT; i++) {
  dummy.position.set(
    (Math.random() - 0.5) * 200,
    0,
    (Math.random() - 0.5) * 200
  );
  dummy.rotation.y = Math.random() * Math.PI * 2;
  dummy.scale.setScalar(0.8 + Math.random() * 0.4);
  dummy.updateMatrix();
  instancedMesh.setMatrixAt(i, dummy.matrix);
}
instancedMesh.instanceMatrix.needsUpdate = true;
scene.add(instancedMesh);

7.3 LOD（多细节层次）

对于远近距离视觉差异大的模型，在 Blender 中准备 3 个精度版本（高/中/低），Three.js 中根据距离自动切换：

const lod = new THREE.LOD();

// 高精度：0~10 米
lod.addLevel(highDetailMesh, 0);
// 中精度：10~50 米  
lod.addLevel(medDetailMesh, 10);
// 低精度：50 米以上
lod.addLevel(lowDetailMesh, 50);

scene.add(lod);
// LOD 会在每帧自动根据相机距离切换

八、进阶：自定义 Shader 扩展 glTF 材质

Three.js 的 onBeforeCompile 钩子允许在不放弃 PBR 管线的前提下，向材质注入自定义 GLSL 代码。这是高阶扩展的核心技巧。

// 在 Blender 中建好基础 PBR 材质，导出后：
model.traverse((node) => {
  if (node.isMesh && node.material.name === 'WindyGrass') {
    node.material.onBeforeCompile = (shader) => {
      // 注入 uniform
      shader.uniforms.uTime = { value: 0 };
      shader.uniforms.uWindStrength = { value: 0.3 };

      // 在顶点着色器头部注入声明
      shader.vertexShader = shader.vertexShader.replace(
        '#include <common>',
        `
        #include <common>
        uniform float uTime;
        uniform float uWindStrength;
        `
      );

      // 在顶点变换前注入风力位移
      shader.vertexShader = shader.vertexShader.replace(
        '#include <begin_vertex>',
        `
        #include <begin_vertex>
        // 根据 Y 轴高度决定摆动幅度（根部固定）
        float windFactor = position.y * uWindStrength;
        transformed.x += sin(uTime * 2.0 + position.z * 0.5) * windFactor;
        transformed.z += cos(uTime * 1.5 + position.x * 0.5) * windFactor * 0.5;
        `
      );

      // 保存 shader 引用以便每帧更新
      node.material.userData.shader = shader;
    };
  }
});

// 在渲染循环中更新 uniform
function animate() {
  requestAnimationFrame(animate);
  const t = clock.getElapsedTime();

  scene.traverse((node) => {
    if (node.isMesh && node.material.userData.shader) {
      node.material.userData.shader.uniforms.uTime.value = t;
    }
  });

  renderer.render(scene, camera);
}

九、完整工作流总结

Blender 创作阶段
│
├── 建模（控制面数，UV 展开）
├── 材质（Principled BSDF，程序化贴图）
├── 烘焙（BaseColor / Roughness / Normal / AO）
├── 动画（骨骼 / Shape Key / 物理模拟烘焙）
└── 导出（glTF 2.0 / .glb / Draco 压缩）
         │
         ▼
    glb / gltf 文件
         │
         ▼
Three.js 运行时阶段
│
├── 加载（GLTFLoader + DRACOLoader + KTX2Loader）
├── 材质增强（envMap / onBeforeCompile / 自定义 Shader）
├── 动画驱动（AnimationMixer / crossFadeTo）
├── 灯光配置（HDR 环境 + 实时灯光）
├── 性能优化（InstancedMesh / LOD / 纹理压缩）
└── 交互与后处理（Controls / EffectComposer）

十、推荐工具与资源

推荐大佬

• 郭隆邦：www.webgl3d.cn/
• Bruno Simon（布鲁诺·西蒙）：github.com/brunosimon

最后

Three.js 与 Blender 的结合，不是简单的"导出然后加载"，而是一套需要深度理解两个系统各自机制，并在接缝处做精细处理的工程实践。从 PBR 材质的精确映射，到动画系统的无缝对接，再到面向 Web 的性能优化，每个环节都有大量细节值得深挖。

掌握这套工作流，你将拥有从零到一打造高质量 Web 3D 体验的完整能力——既能胜任艺术侧的内容生产，也能驾驭工程侧的实时渲染。这正是当下 Web 3D 领域最稀缺的复合型能力。

现在AI还无法胜任3D可视化相关的工作，学起来为自己增加点筹码。需要相关blender、可视化学习资料的可以关注我私信获取

本文覆盖 Blender 4.x + Three.js r160+ 版本，部分 API 在旧版本中可能有差异

太棒了！👏
你已经从“理解 Promise”走到了“创造可用工具”的阶段。

现在，我们来手把手带你把 MyPromise 发布到 npm ——
完成一次 从学习 → 实践 → 分享 的完整闭环！

包名示例：@yourname/mypromise 或 mypromise-learn

功能：

import MyPromise from 'mypromise-learn';

new MyPromise(resolve => resolve('Hello')).then(console.log);

✅ 第一步：准备工作

1. 安装 Node.js 和 npm

确保你已安装：

node -v   # 应输出 v14.x 以上
npm -v    # 应输出 6.x 以上

👉 下载地址：nodejs.org

2. 注册 npm 账号（如果还没有）

访问：www.npmjs.com/signup

然后在终端登录：

npm login
# 输入你的用户名、密码、邮箱

✅ 登录成功后就可以发布包了。

📁 第二步：创建项目目录结构

mkdir mypromise-npm
cd mypromise-npm
npm init -y

生成的 package.json 长这样：

{
  "name": "mypromise-learn",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "test": "echo "Error: no test specified" && exit 1"
  },
  "keywords": ["promise", "tutorial", "async"],
  "author": "Your Name",
  "license": "MIT"
}

💡 建议名字别叫 mypromise，容易和别人冲突。可以用 mypromise-learn、simple-promise 等。

📄 第三步：添加源码文件

创建 index.js：

// index.js
const PENDING = 'pending';
const FULFILLED = 'fulfilled';
const REJECTED = 'rejected';

class MyPromise {
  constructor(executor) {
    this.status = PENDING;
    this.value = undefined;
    this.reason = undefined;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];

    const resolve = (value) => {
      if (this.status === PENDING) {
        this.status = FULFILLED;
        this.value = value;
        this.onFulfilledCallbacks.forEach(fn => fn());
      }
    };

    const reject = (reason) => {
      if (this.status === PENDING) {
        this.status = REJECTED;
        this.reason = reason;
        this.onRejectedCallbacks.forEach(fn => fn());
      }
    };

    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err);
    }
  }

  then(onFulfilled, onRejected) {
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : val => val;
    onRejected = typeof onRejected === 'function' ? onRejected : err => { throw err; };

    const promise2 = new MyPromise((resolve, reject) => {
      if (this.status === FULFILLED) {
        setTimeout(() => {
          try {
            const x = onFulfilled(this.value);
            this.resolvePromise(promise2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        }, 0);
      } else if (this.status === REJECTED) {
        setTimeout(() => {
          try {
            const x = onRejected(this.reason);
            this.resolvePromise(promise2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        }, 0);
      } else if (this.status === PENDING) {
        this.onFulfilledCallbacks.push(() => {
          setTimeout(() => {
            try {
              const x = onFulfilled(this.value);
              this.resolvePromise(promise2, x, resolve, reject);
            } catch (e) {
              reject(e);
            }
          }, 0);
        });
        this.onRejectedCallbacks.push(() => {
          setTimeout(() => {
            try {
              const x = onRejected(this.reason);
              this.resolvePromise(promise2, x, resolve, reject);
            } catch (e) {
              reject(e);
            }
          }, 0);
        });
      }
    });

    return promise2;
  }

  resolvePromise(promise2, x, resolve, reject) {
    if (promise2 === x) {
      return reject(new TypeError('Chaining cycle detected'));
    }

    let called = false;

    if (x !== null && (typeof x === 'object' || typeof x === 'function')) {
      try {
        const then = x.then;
        if (typeof then === 'function') {
          then.call(x,
            y => {
              if (called) return;
              called = true;
              this.resolvePromise(promise2, y, resolve, reject);
            },
            r => {
              if (called) return;
              called = true;
              reject(r);
            }
          );
        } else {
          resolve(x);
        }
      } catch (e) {
        if (called) return;
        called = true;
        reject(e);
      }
    } else {
      resolve(x);
    }
  }

  catch(onRejected) {
    return this.then(null, onRejected);
  }

  static resolve(value) {
    return new MyPromise(resolve => resolve(value));
  }

  static reject(reason) {
    return new MyPromise((_, reject) => reject(reason));
  }

  static all(promises) {
    return new MyPromise((resolve, reject) => {
      const results = [];
      let count = 0;
      if (promises.length === 0) return resolve(results);
      promises.forEach((p, index) => {
        MyPromise.resolve(p).then(
          value => {
            results[index] = value;
            count++;
            if (count === promises.length) resolve(results);
          },
          reject
        );
      });
    });
  }

  static race(promises) {
    return new MyPromise((resolve, reject) => {
      promises.forEach(p => {
        MyPromise.resolve(p).then(resolve, reject);
      });
    });
  }
}

module.exports = MyPromise;

⚠️ 如果你用的是 ES6 模块语法（import/export），需要改为 export default MyPromise 并设置 "type": "module"，后面会说明。

🧪 第四步：本地测试一下

创建 test.js 测试文件：

// test.js
const MyPromise = require('./index');

console.log('开始测试 MyPromise...');

MyPromise.resolve(1)
  .then(res => res + 1)
  .then(res => {
    console.log('结果:', res); // 输出: 结果: 2
    return MyPromise.resolve(3);
  })
  .then(console.log) // 输出: 3
  .catch(console.error);

// 测试循环引用
const p = MyPromise.resolve(1);
const p2 = p.then(() => p2);
p2.catch(err => console.log('捕获循环引用:', err.message));

运行测试：

node test.js

✅ 如果输出正常，说明可以发布了！

📦 第五步：完善 package.json（关键配置）

{
  "name": "mypromise-learn",
  "version": "1.0.0",
  "description": "A hand-written Promise implementation for learning purposes.",
  "main": "index.js",
  "scripts": {
    "test": "node test.js"
  },
  "keywords": ["promise", "tutorial", "async", "javascript"],
  "author": "Your Name <you@email.com>",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/yourname/mypromise.git"
  },
  "bugs": {
    "url": "https://github.com/yourname/mypromise/issues"
  },
  "homepage": "https://github.com/yourname/mypromise#readme"
}

📌 注意：

• name 必须全局唯一
• 可以先查是否已被占用：www.npmjs.com/search

🔐 第六步：发布到 npm

npm publish

✅ 成功后你会看到：

+ mypromise-learn@1.0.0

🎉 恭喜！你的包已经上线！

访问：https://www.npmjs.com/package/mypromise-learn 查看页面。

🌐 第七步：别人怎么使用它？

安装：

npm install mypromise-learn

使用：

const MyPromise = require('mypromise-learn');

// 或 ES6 import（需支持 module）
import MyPromise from 'mypromise-learn';

🎁 进阶建议（让项目更专业）

❤️ 最后一句话

你已经完成了从“学习者”到“贡献者”的转变。

你现在不只是在学代码，
而是在向世界分享你的理解与创造。

这比任何面试题都更有价值。✨

前端有战国七雄，低代码圈更是“百国千城”

引言

低代码开发平台的世界，如今就像春秋战国时期的诸侯割据——各种平台、各种引擎、各种规范层出不穷，表面上都是“让开发更简单”，实际用起来却各有各的“方言”，各有各的“城墙”。

更让人头疼的是，因为各家有各家的技术路线，连选型都成了一场赌博。

做OA的推工作流引擎强大，做ERP的强调数据模型灵活，做移动端的鼓吹多端适配能力，做报表的说自己可视化最牛……

甲方想统一技术栈，结果发现不同部门已经用了三四种低代码平台，数据不通、流程不通、权限不通，比全代码开发还乱。

低代码平台之争：各有各的“山头”

目前市面上的低代码平台，大致可以分为几大流派：

企业级应用平台

• 代表：OutSystems、Mendix、Salesforce

• 特点：功能全面，适合大型企业复杂业务，但价格昂贵、学习曲线陡峭

• 定位：高端市场，私有化部署为主

国内主流厂商

• 代表：JNPF、明道云、简道云、氚云

• 特点：贴近国内企业管理习惯，支持钉钉/企微集成，性价比高

• 差异：有的侧重表单流程，有的侧重数据中台，有的侧重ERP扩展

开源低代码

• 代表：Appsmith、Budibase、Saltcorn

• 特点：代码透明，可二次开发，但企业级功能（如复杂工作流、高并发）往往需要自研补齐

云厂商自研

• 代表：阿里宜搭、腾讯微搭、华为AppCube

• 特点：与云生态深度绑定，适合该云平台上的企业使用

对比分析：

• 低代码平台目前没有统一标准。一个平台设计的应用，基本无法迁移到另一个平台，厂商锁定问题突出。

• 每个平台都有自己的一套“元数据规范”“表达式语法”“API设计风格”，团队切换平台几乎等于推翻重来。

• 选型时不仅要看功能，还要评估开放性、扩展能力、私有化支持，避免未来被单一厂商绑定太死。

工作流引擎：百花齐放，各立山头

工作流是低代码的核心能力之一，也是“分裂”最严重的领域。

开源工作流引擎

• Activiti / Flowable / Camunda：BPMN 2.0标准的三巨头，各有各的版本分支和API风格。

• 选一个引擎，意味着团队要学习该引擎的变量设计、监听器写法、部署方式，后期替换成本极高。

低代码平台内置工作流

• 各家基本都宣称“可视化流程设计”，但设计器体验、节点能力、与其他模块的集成深度天差地别。

• 有的平台流程和表单是割裂的，有的平台流程引擎无法独立于平台使用。

BPM厂商产品

• 如IBM BPM、Pega，功能强大但价格昂贵，主要服务超大型企业。

对比分析：

• 工作流领域“学不动”的根源在于：每个引擎都有自己的“方言”，即便都支持BPMN 2.0，在具体实现细节、扩展方式上也差异巨大。

• 企业一旦选定，后续调整和升级都要围绕该引擎的生态展开，迁移成本极高。

表单设计器与UI渲染：各有各的“积木”

表单是用户与系统交互的界面，这一块同样是“诸侯割据”：

开源表单设计器

• Formily、FormGenerator、VForm……每个设计器产出的JSON Schema结构不同，渲染引擎互不兼容。

低代码平台自带设计器

• 有的平台提供纯Web可视化拖拽，有的则需要开发者编写少量代码来扩展组件。

• 组件的封装粒度、属性配置方式、事件绑定机制，各家千差万别。

UI组件库阵营

• 基于Ant Design、Element Plus、Naive UI等组件库的低代码平台，生成的代码风格迥异。

对比分析：

• 表单和UI这一块，统一的可能性最低，因为UI本身就是一个审美和习惯差异巨大的领域。

• 但企业真正需要的是：设计出来的表单能稳定运行，字段权限与工作流、数据权限自动联动，而不是只停留在UI层面。

集成与扩展：每个平台都是一座“孤岛”

低代码平台最怕的不是功能不够，而是无法融入企业现有的技术生态。

• 数据层：有的平台只能使用内置数据库，有的支持外部数据源，但支持的数据库类型和连接能力差异很大。

• API层：有的平台提供REST API可反向调用，有的只能通过平台内触发器调用外部接口，且鉴权方式五花八门。

• 前端扩展：有的允许写自定义代码嵌入页面，有的只能使用平台提供的组件，无法引入第三方库。

• 后端扩展：有的支持云函数/脚本，有的完全封闭，只能使用平台内置逻辑。

对比分析：

• 如果平台在集成扩展能力上过于封闭，那么随着业务复杂度的提升，最终还是会回到全代码开发的老路上，低代码反而成了“先甜后苦”的选择。

JNPF的“合纵”思路：不争引擎争生态

面对这个“百国千城”的局面，JNPF选择了一条不同的路——不试图用一套引擎取代所有，而是用开放生态减少内耗。

统一的底层架构，避免重复造轮子

JNPF提供了一体化的技术底座：从用户组织、权限中心、工作流引擎、表单设计器、报表设计器到代码生成器，全部基于同一套元数据规范和数据模型。企业不再需要为了“工作流用一个引擎、表单用一套设计器、报表用一个工具”而维护多套技术栈。

开放性与扩展性，不做“孤岛”

• 数据层：支持MySQL、SQL Server、Oracle、PostgreSQL等主流数据库，并可对接外部数据源，避免数据孤岛。

• 后端扩展：支持Java、C#双语言版本，并提供代码生成器，复杂业务可以编写原生代码，与平台无缝集成。

• 前端扩展：支持自定义组件嵌入，可以引入第三方UI库或业务组件，不被平台设计器限制。

• API层：提供完整的REST API，平台内的功能均可通过API调用，方便与现有系统集成。

工作流引擎的“实用主义”

JNPF工作流引擎基于成熟内核，但重点不在“引擎本身多强”，而在于与表单、权限、消息、第三方系统的开箱即用集成。业务人员画完流程，自动关联表单权限、自动同步组织架构、自动对接钉钉/企微消息，开发人员无需在集成上重复消耗精力。

可私有化、可掌控

对于中大型企业，JNPF支持全源码交付，企业可以获得完整的平台代码，自主部署、自主维护、自主二次开发。既享受了低代码的开发效率，又保留了技术自主权，避免被厂商锁定。

低代码圈的统一，可能不在引擎层面

前端领域这么多年都没等来“秦始皇”，低代码圈的统一可能也不是靠一个平台吞并所有。

真正的“统一”，或许是：

• 标准层面的趋同：比如元数据规范、API设计模式逐渐形成事实标准。

• 开放生态的普及：更多平台像JNPF一样，不再强求“全用我的”，而是提供良好的开放能力，让企业能够按需组合、平滑演进。

• 企业意识的成熟：选型时不再只看“功能列表多全”，而是看“能不能与现有系统共存”“能不能长期可控”。

JNPF的实践表明：与其在引擎层面争高下，不如在生态层面做整合。一个平台如果能做到——核心稳定、开放可控、集成顺手、扩展自由——那它不需要“一统天下”，也能成为企业数字化转型中的坚实底座。

一、TypeScript 内置工具类型

1.1 Partial 的作用

Partial<T>是 TypeScript 内置的工具类型，它可以将类型 T的所有属性变为可选。

typescript
typescript
复制
// Partial 的实现原理（简化版）
type Partial<T> = {
  [P in keyof T]?: T[P];
};

// 使用示例
interface Theme {
  primaryColor: string;
  secondaryColor: string;
  fontSize: number;
}

// 正常 Theme 类型，所有属性都是必需的
const theme1: Theme = {
  primaryColor: '#1890ff',
  secondaryColor: '#52c41a',
  fontSize: 14
};
// ✓ 所有属性都必须提供

// 使用 Partial<Theme> 后，所有属性都变为可选
const theme2: Partial<Theme> = {
  primaryColor: '#1890ff'
  // secondaryColor 和 fontSize 可以不提供
};
// ✓ 可以只提供部分属性

// 在函数参数中使用 Partial
function updateTheme(theme: Partial<Theme>): void {
  // 可以只更新部分属性
  // theme 可能只包含 primaryColor，或只包含 fontSize，或都包含
}

// 调用示例
updateTheme({ primaryColor: '#ff4d4f' }); // ✓ 只更新一个属性
updateTheme({ fontSize: 16 }); // ✓ 只更新另一个属性
updateTheme({}); // ✓ 传递空对象也可以

1.2 其他常用工具类型

typescript
typescript
复制
// 1. Required<T> - 将可选属性变为必填
interface User {
  id: number;
  name?: string;  // 可选
  email?: string; // 可选
}

type RequiredUser = Required<User>;
// 等价于：
// {
//   id: number;
//   name: string;   // 变为必填
//   email: string;  // 变为必填
// }

// 2. Readonly<T> - 将所有属性变为只读
type ReadonlyUser = Readonly<User>;
// 等价于：
// {
//   readonly id: number;
//   readonly name?: string;
//   readonly email?: string;
// }

// 3. Pick<T, K> - 从 T 中挑选部分属性
type UserBasicInfo = Pick<User, 'id' | 'name'>;
// 等价于：
// {
//   id: number;
//   name?: string;
// }

// 4. Omit<T, K> - 从 T 中排除部分属性
type UserWithoutId = Omit<User, 'id'>;
// 等价于：
// {
//   name?: string;
//   email?: string;
// }

// 5. Record<K, T> - 创建键值对类型
type UserMap = Record<string, User>;
// 等价于：
// {
//   [key: string]: User;
// }

// 6. Exclude<T, U> - 从 T 中排除可以赋值给 U 的类型
type T1 = 'a' | 'b' | 'c';
type T2 = 'a';
type Result = Exclude<T1, T2>; // 'b' | 'c'

// 7. Extract<T, U> - 从 T 中提取可以赋值给 U 的类型
type T3 = 'a' | 'b' | 'c';
type T4 = 'a' | 'd';
type Result2 = Extract<T3, T4>; // 'a'

// 8. NonNullable<T> - 排除 null 和 undefined
type T5 = string | number | null | undefined;
type Result3 = NonNullable<T5>; // string | number

二、Vue 3 中的类型

2.1 ComputedRef 类型

ComputedRef<T>是 Vue 3 中计算属性的类型，它是 Ref<T>的子类型。

typescript
typescript
复制
import { ref, computed, Ref, ComputedRef } from 'vue'

// 1. 基础使用
const count = ref<number>(0); // Ref<number>
const doubleCount = computed(() => count.value * 2); // ComputedRef<number>

// 2. 显式类型声明
const doubleCount2: ComputedRef<number> = computed(() => count.value * 2);

// 3. 带 getter 和 setter 的计算属性
const fullName = computed<string>({
  get: () => `${firstName.value} ${lastName.value}`,
  set: (value: string) => {
    const [first, last] = value.split(' ')
    firstName.value = first
    lastName.value = last || ''
  }
});

// 4. 在函数参数中使用
function logComputedValue(computedValue: ComputedRef<any>): void {
  console.log(computedValue.value);
}

logComputedValue(doubleCount);

2.2 Vue 3 常用类型

typescript
typescript
复制
import {
  Ref,           // 响应式引用类型
  ComputedRef,   // 计算属性类型
  UnwrapRef,     // 解包响应式类型
  MaybeRef,      // 可能是 Ref 或普通值
  MaybeRefOrGetter, // 可能是 Ref、getter 函数或普通值
  WritableComputedRef, // 可写的计算属性
  ShallowRef,    // 浅层 Ref
  ShallowReactive, // 浅层 reactive
  ToRefs,        // 将 reactive 转换为 refs
  ComponentPublicInstance, // 组件实例类型
  VNode,         // 虚拟节点类型
  Component      // 组件类型
} from 'vue'

// 1. Ref 类型
const countRef: Ref<number> = ref(0);

// 2. UnwrapRef - 获取 Ref 内部的类型
type CountType = UnwrapRef<typeof countRef>; // number

// 3. MaybeRef - 接受 Ref 或普通值
function useDouble(value: MaybeRef<number>): ComputedRef<number> {
  return computed(() => {
    // 判断是否是 Ref
    if (isRef(value)) {
      return value.value * 2
    }
    return value * 2
  });
}

// 或者使用 unref 工具函数
import { unref } from 'vue'

function useDouble2(value: MaybeRef<number>): ComputedRef<number> {
  return computed(() => unref(value) * 2);
}

// 4. ToRefs - 将 reactive 转换为多个 ref
interface State {
  count: number;
  name: string;
}

const state = reactive<State>({ count: 0, name: 'Vue' });
const stateRefs: ToRefs<State> = toRefs(state);
// 现在可以使用 stateRefs.count.value 和 stateRefs.name.value

三、实际应用示例

3.1 表单组件示例

typescript
typescript
复制
import { defineComponent, reactive, computed, toRefs } from 'vue'

// 表单数据类型
interface FormData {
  username: string
  email: string
  age: number | null
  agree: boolean
}

// 表单验证规则类型
type ValidationRule = (value: any) => string | true

interface FormRules {
  [key: string]: ValidationRule | ValidationRule[]
}

export default defineComponent({
  setup() {
    // 表单数据
    const formData = reactive<FormData>({
      username: '',
      email: '',
      age: null,
      agree: false
    })
    
    // 表单验证规则
    const rules: FormRules = {
      username: [
        (value: string) => !!value || '用户名不能为空',
        (value: string) => value.length >= 3 || '用户名至少3个字符'
      ],
      email: [
        (value: string) => !!value || '邮箱不能为空',
        (value: string) => /.+@.+..+/.test(value) || '邮箱格式不正确'
      ],
      age: (value: number | null) => {
        if (value === null) return '年龄不能为空'
        if (value < 0) return '年龄不能为负数'
        if (value > 150) return '年龄不能超过150岁'
        return true
      }
    }
    
    // 表单验证状态
    const errors = reactive<Partial<Record<keyof FormData, string>>>({})
    
    // 验证单个字段
    const validateField = (field: keyof FormData): boolean => {
      const value = formData[field]
      const rule = rules[field]
      
      if (!rule) {
        delete errors[field]
        return true
      }
      
      const rulesArray = Array.isArray(rule) ? rule : [rule]
      
      for (const validate of rulesArray) {
        const result = validate(value)
        if (typeof result === 'string') {
          errors[field] = result
          return false
        }
      }
      
      delete errors[field]
      return true
    }
    
    // 验证整个表单
    const validateForm = (): boolean => {
      let isValid = true
      
      Object.keys(formData).forEach(field => {
        if (!validateField(field as keyof FormData)) {
          isValid = false
        }
      })
      
      return isValid
    }
    
    // 提交表单
    const submitForm = (): void => {
      if (!validateForm()) {
        console.log('表单验证失败')
        return
      }
      
      console.log('提交表单:', formData)
      // 这里可以调用 API
    }
    
    // 重置表单
    const resetForm = (): void => {
      Object.assign(formData, {
        username: '',
        email: '',
        age: null,
        agree: false
      })
      
      Object.keys(errors).forEach(key => {
        delete errors[key as keyof typeof errors]
      })
    }
    
    // 计算属性：表单是否有效
    const isFormValid = computed<boolean>(() => {
      return Object.keys(errors).length === 0 &&
        formData.username !== '' &&
        formData.email !== '' &&
        formData.age !== null &&
        formData.agree
    })
    
    return {
      // 使用 toRefs 保持响应性
      ...toRefs(formData),
      errors,
      isFormValid,
      validateField,
      validateForm,
      submitForm,
      resetForm
    }
  }
})

3.2 使用工具类型的通用函数

typescript
typescript
复制
// utils/types.ts
// 自定义工具类型

// 1. 深度可选类型
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

// 2. 深度只读类型
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

// 3. 可空类型
type Nullable<T> = T | null | undefined;

// 4. 提取函数返回类型
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

// 5. 提取函数参数类型
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

// 6. 提取 Promise 的返回值类型
type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T;

// 使用示例
interface User {
  id: number;
  name: string;
  profile: {
    avatar: string;
    bio: string;
  };
  tags: string[];
}

// 深度可选
type PartialUser = DeepPartial<User>;
// 可以这样使用：
const user1: PartialUser = {
  name: '张三',
  profile: {
    avatar: 'avatar.jpg'
    // bio 可以不提供
  }
  // tags 可以不提供
};

// 深度只读
type ReadonlyUser = DeepReadonly<User>;
const user2: ReadonlyUser = {
  id: 1,
  name: '李四',
  profile: {
    avatar: 'avatar.jpg',
    bio: 'Hello'
  },
  tags: ['a', 'b']
};
// user2.profile.bio = 'World'; // ❌ 错误：不能修改只读属性

// 可空类型
let nullableString: Nullable<string> = 'Hello';
nullableString = null; // ✓
nullableString = undefined; // ✓

3.3 组合式函数的类型

typescript
typescript
复制
// composables/useFetch.ts
import { ref, computed, Ref, ComputedRef } from 'vue'

// 请求状态类型
type FetchStatus = 'idle' | 'loading' | 'success' | 'error'

// 返回类型
interface UseFetchReturn<T> {
  data: Ref<T | null>
  error: Ref<string | null>
  status: Ref<FetchStatus>
  isLoading: ComputedRef<boolean>
  isSuccess: ComputedRef<boolean>
  isError: ComputedRef<boolean>
  execute: (url: string, options?: RequestInit) => Promise<void>
  reset: () => void
}

// 选项类型
interface UseFetchOptions {
  immediate?: boolean
  initialData?: any
}

export function useFetch<T = any>(
  initialUrl?: string,
  options: UseFetchOptions = {}
): UseFetchReturn<T> {
  const { immediate = false, initialData = null } = options
  
  const data = ref<T | null>(initialData) as Ref<T | null>
  const error = ref<string | null>(null)
  const status = ref<FetchStatus>('idle')
  
  const isLoading = computed(() => status.value === 'loading')
  const isSuccess = computed(() => status.value === 'success')
  const isError = computed(() => status.value === 'error')
  
  const execute = async (url: string, requestOptions?: RequestInit): Promise<void> => {
    status.value = 'loading'
    error.value = null
    
    try {
      const response = await fetch(url, requestOptions)
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
      }
      
      const result = await response.json()
      data.value = result
      status.value = 'success'
    } catch (err) {
      error.value = err instanceof Error ? err.message : '请求失败'
      status.value = 'error'
    }
  }
  
  const reset = (): void => {
    data.value = initialData
    error.value = null
    status.value = 'idle'
  }
  
  // 立即执行
  if (immediate && initialUrl) {
    execute(initialUrl)
  }
  
  return {
    data,
    error,
    status,
    isLoading,
    isSuccess,
    isError,
    execute,
    reset
  }
}

// 在组件中使用
import { defineComponent, onMounted } from 'vue'

interface Post {
  id: number
  title: string
  body: string
  userId: number
}

export default defineComponent({
  setup() {
    // 使用 useFetch
    const { 
      data: posts, 
      error, 
      isLoading, 
      isSuccess, 
      execute 
    } = useFetch<Post[]>('https://jsonplaceholder.typicode.com/posts')
    
    // 或者延迟执行
    const { 
      data: user, 
      execute: fetchUser 
    } = useFetch<Post>(undefined, { immediate: false })
    
    onMounted(() => {
      // 手动执行
      fetchUser('https://jsonplaceholder.typicode.com/posts/1')
    })
    
    // 重新获取
    const refresh = (): void => {
      execute('https://jsonplaceholder.typicode.com/posts')
    }
    
    return {
      posts,
      error,
      isLoading,
      isSuccess,
      refresh
    }
  }
})

四、常见问题解答

Q1: 什么时候用 Partial？

A: 当你需要创建一个对象，它包含原始类型的一部分属性时使用。

typescript
typescript
复制
// 更新用户信息时，通常只需要更新部分字段
interface User {
  id: number
  name: string
  email: string
  age: number
}

function updateUser(userId: number, updates: Partial<User>): void {
  // updates 可以只包含 name，或只包含 email，或任意组合
  // 但不会包含不存在的属性
}

Q2: ComputedRef和普通 Ref有什么区别？

A: 主要区别：

• ComputedRef是只读的，你不能直接修改它的值
• ComputedRef的值是通过计算得到的
• 你可以为 ComputedRef提供 setter，但通常不建议

typescript
typescript
复制
// Ref - 可以直接修改
const count = ref(0)
count.value = 1  // ✓ 可以

// ComputedRef - 默认只读
const double = computed(() => count.value * 2)
double.value = 4  // ❌ 错误：不能直接修改计算属性

// 带 setter 的 ComputedRef
const fullName = computed({
  get: () => `${firstName.value} ${lastName.value}`,
  set: (value) => {
    const [first, last] = value.split(' ')
    firstName.value = first
    lastName.value = last || ''
  }
})

Q3: 什么时候需要显式指定类型？

A: TypeScript 有类型推断，但以下情况建议显式指定：

typescript
typescript
复制
// 1. 函数参数和返回值
function add(a: number, b: number): number {
  return a + b
}

// 2. 复杂对象
interface Config {
  apiUrl: string
  timeout: number
  retry: boolean
}

const config: Config = {
  apiUrl: '/api',
  timeout: 5000,
  retry: true
}

// 3. 组件 Props
interface Props {
  title: string
  count: number
  items: Array<{ id: number; name: string }>
}

// 4. API 响应
interface ApiResponse<T = any> {
  code: number
  data: T
  message: string
}

async function fetchUser(id: number): Promise<ApiResponse<User>> {
  const response = await fetch(`/api/users/${id}`)
  return response.json()
}

记住：TypeScript 的核心价值在于类型安全，良好的类型定义能帮助你在编码阶段就发现潜在的错误，提高代码质量和开发效率。

本文介绍基于前后端分离状态下前端部署缓存策略的实践。

背景

由于前端的蓬勃发展，前端框架react、vue、angular等在日常开发中已经非常普及，放大了前端的业务能力，也催生了前后端分离开发的模式。实际开发部署时只需要通过webpack等打包工具打包后生成静态资源，部署到nginx、Caddy等现有的静态服务器中，方便快捷同时与后端分离后彼此隔离，只通过RESTful api进行通信。这时对静态服务器的配置便显得至关重要。

浏览器缓存

强制缓存

强缓存所谓的“强”，在于强制让浏览器按照一定时间范围内来存储来自服务器的资源，有点强制的味道～，强缓存是利用Expires或者Cache-Control，不发送请求，直接从缓存中取，请求状态码会返回200（from cache）。

Expires（已逐步淘汰）

Expires是HTTP/1.0中提及的，让服务器为文件资源设置一个过期时间，在多长时间内可以将这些内容视为最新的，允许客户端在这个时间之前不去检查。

• 指定到期时间：

  指定缓存到期GMT的绝对时间，如果Expires到期需要重新请求。

  这个时间是服务器的时间，所以这里就会出现一个问题，服务器时间和本地时间不一致，就会造成缓存失效时间不准确。

  Expires:Sat, 09 Jun 2020 08:13:56 GMT
  

Cache-Control（主要）

相比Expires，两者有什么区别呢？ Cache-Control你可以理解成为高级版Expires，为了弥补Expires的缺陷在Http1.1协议引入的，且强大之外优先级也更高，也就是当Expires和Cache-Control同时存在时，Cache-Control会覆盖Expires的配置，即Cache-Control（ Http 1.1 ） > Expires （ Http 1.0 ）。

Cache-Control与Expires比具备更多的属性，其中包括如下：

• no-cache ：可以在本地缓存，可以在代理服务器缓存，需要先验证才可使用缓存。
• no-store ：禁止浏览器缓存，只能通过服务器获取。
• max-age ：设置资源的过期时间（效果与Expires一样）。

示例：

// 设置缓存时间为1年
Cache-Control: max-age=31536000
Expires:Sat, 09 Jun 2020 08:13:56 GMT //同时设置两个，Expires会失效

这意味着浏览器可以缓存一年的时间，无需请求服务器，同时如果同时声明Expires和Cache-Control，Expires将失效。

用户对浏览器的操作

Cache-Control no-cache与max-age=0的区别你按浏览器刷新与强制刷新的区分。

• Ctrl + F5（强制刷新）：request header多了cache-control: no-cache（重新获取请求）。
• F5（刷新）/ctrl+R刷新：request header多了cache-control: max-age=0（需要先验证才可使用缓存，Expires无效）。

协商缓存

协商缓存，就没有强缓存那么霸道，协商缓存需要客户端和服务端两端进行交互，通过服务器告知浏览器缓存是否可用，并增加缓存标识，“有事好好商量”，两者都会互相协商。 协商缓存，其实就是服务器与浏览器交互过程，一般有两个回合，而协商主要有以下几种方式：

Last-Modified（Http 1.0）

• 第一回合：当浏览器第一次请求服务器资源时，服务器通过Last-Modified来设置响应头的缓存标识，把资源最后修改的时间作为值写入，再将资源返回给浏览器。
• 第二回合：第二次请求时，浏览器会带上If-Modified-Since请求头去访问服务器，服务器将If-Modified-Since中携带的时间与资源修改的时间对比，当时间不一致时，意味更新了，服务器会返回新资源并更新Last-Modified，当时间一致时，意味着资源没有更新，服务器会返回304状态码，浏览器将从缓存中读取资源。

示例：

//response header 第一回合
Last-Modified: Wed, 21 Oct 2019 07:28:00 GMT

//request header 第二回合
If-Modified-Since: Wed, 21 Oct 2019 07:29:00 GMT

Etag（Http 1.1）

MDN中提到ETag之间的比较，使用的是强比较算法，即只有在每一个字节都相同的情况下，才可以认为两个文件是相同的，而这个hash值，是由对文件的索引节、大小和最后修改时间进行Hash后得到的，而且要注意的是分布式系统不适用，同时需要注意的是Etag的组装不同类型的服务器可能不同比如nginx的Etag可能是长的这样ETag: "5f3498d1-b0063"。

• 第一回合：也是跟上文一样，浏览器去请求服务器资源，不过这次不是通过Last-Modified了，而是用Etag来设置响应头缓存标识。Etag是由服务端生成的，然后浏览器会将Etag与资源缓存。
• 第二回合: 浏览器会将Etag放入If-None-Match请求头中去访问服务器，服务器收到后，会对比两端的标识，当两者不一致时，意味着资源更新，会从服务器的响应读取资源并更新Etag，浏览器将从缓存中读取资源，当两者一致时，意味着资源没有更新，服务器会返回304状态码，浏览器将从缓存中读取资源。

示例：

//response header 第一回合
ETag: "33a64df551425fcc55e4d42a148795d9f25f89d4"

//request header 第二回合
If-None-Match: "33a64df551425fcc55e4d42a148795d9f25f89d4"

对比完Last-Modified与Etag，我们可以很显然看到，协商缓存每次请求都会与服务器发生“关系”，第一回合都是拿数据和标识，而第二回合就是浏览器“咨询”服务器是否资源已经更新的过程。

同时，如果以上两种方式同时使用，Etag优先级会更高，即Etag（Http 1.1） > Last-Modified（Http 1.0）。

缓存状态码

状态码200 OK（from cache）

这是浏览器没有跟服务器确认，直接用了浏览器缓存，性能最好的，没有网络请求，那么什么情况会出现这种情况？一般在Expires或者Cache-Control中的max-age头部有效时会发生。

状态码304 Not Modified

是浏览器和服务器“交流”了，确定使用缓存后，再用缓存，也就是第二节讲的通过Etag或Last-Modified的第二回合中对比，对比两者一致，则意味资源不更新，则服务器返回304状态码。

状态码200

以上两种缓存全都失败，也就是未缓存或者缓存未过期，需要浏览器去获取最新的资源，效率最低 一句话：缓存是否过期用：Cache-Control（max-age）, Expires，缓存是否有效用：Last-Modified，Etag。

静态文件

前面介绍了浏览器缓存的一些方式，而随着前端工程化，前端可以做到通过打包工具（webpack等）来进行前端代码打包，生成一个可以直接部署到静态网站的源码。下面来看下通过打包后前端文件情况（以我的实际项目为例）：

• 由以上的截图可以看到，每次发布新的版本打包出来的文件入口的index.html和前端配置文件config.js或者path.js的文件名是不变的，而动态生成的js和png文件会自动添加不同的hash值是动态的。

• 结合上文讲到的浏览器缓存的内容可以知道如果不单独配置这些固定名称的文件的缓存策略的话由于不同服务器不同浏览器的实现不同极有可能会被缓存而导致发布新版本后页面失效的问题。

解决方案

上文已经提到前端打包生成的动态文件会根据内容自动生成对应hash和文件名，每次发布新版本这些文件的更新会命中协商缓存或者强缓存失效的规则，能形成破坏缓存的效果，达到发布新版本内容更新的效果，而入口文件index.html、config.js、path.js等可能会因为浏览器默认的缓存策略不能破坏缓存，达不到发布新版本内容即更新的效果（尤其是index.html这个整个服务的入口如果不更新则会造成对应的引入文件均不可用而使页面崩溃）。

针对这种情况，需要在服务器端针对上面提到的index.html、config.js、path.js等文件单独配置缓存策略，由截图中绿色框中的部分可以看出这些文件都不大，所有这里的缓存策略可以是配置强制缓存并且强制不让这些文件缓存Cache-control: no-store，让浏览器每次都重新从服务器拉取最新的文件。

以nginx为例，nginx.conf配置如下：

# server下增加如下配置
location ~* (.html|config.js|path.js)$ {
    # 通过gx_http_headers_module提供的add_header方法配置强缓存并任何情况下不可缓存
    add_header Cache-Control no-store;
}

来匹配我们上文中提到的三种静态文件，这里附上nginx中location匹配规则

• 增加以上配置后对nginx进行重启(nginx -s reload)。
• 第一次增加配置后建议用户进行强制刷新或者清除浏览器缓存后再使用。

验证方法

增加以上配置后可以通过两个途径进行验证：

• 桌面端的浏览器（以Chrome为例）：
  • 浏览器访问之前部署的服务uri路径。
  • F12打开开发者工具，切换到network选项，刷新或者强制刷新查看如下图：
• linux下或者windows PS命令行：
  • 执行curl http://ip:port来发送对应的请求。
  • 控制台会显示如下图：

总结

前端工程化的现在给我们发布服务很大的便利，浏览器缓存是优化网站性能的利器同时也会带来一些问题，制定好缓存策略至关重要，现在前端通过打包生成的文件能很好地破坏原有缓存，但也有例外，本实践通过对静态资源的缓存策略来保证发布新版本后用户及时获得最新更新页面。

参考资料

• 前端缓存那些事

前言

官方介绍 详细解释了在 React 18+ 环境下严格模式的行为（包括双重渲染和双重 Effect）

组件 “双闪” 现象

当你使用 react 18+ 开发环境中使用 useEffect 开发的过程中是否遇到过定时器跑倍数或者内存泄露的问题？

例如: 下面的代码，你觉得页面中定时器显示的值应该是多少？

import { useState, useEffect } from 'react'

function TimerFunction() {
  const [count, setCount] = useState(0)

  useEffect(() => {
    console.log('[Effect] 开启定时器')
    setInterval(() => {
      setCount((c) => c + 1)
    }, 1000)
  }, [])

  return <div>计数：{count}</div>
}

export default TimerFunction

直接揭晓答案，在严格模式下，当组件一加载，后台有两个定时器在跑，count 的值会成倍的增加。这里也是初学者容易困惑的地方，在严格模式下，组件会模拟 挂载 -> 卸载 -> 重新挂载 的过程。这里相当于初始化的时候页面挂载了两个定时器，所以也就解释了为什么看到的 count 的值是成倍增加的。

为什么要这样做？

react 团队之在 react 18 中强制加入严格模式，这是由于很多开发者在非严格模式下测试时，觉得“首次加载没有问题，就忽略了清理函数”，导致用户在当前页面停留时间过长，切换的页面越多，电脑越卡。而这种 bug 往往又很难发现，往往到了生产环境，用户反馈 “页面卡顿” 你才会意识到内存泄露了。

所以记得添加清理函数哦！！

import { useState, useEffect } from 'react'

function TimerFunction() {
  const [count, setCount] = useState(0)

  useEffect(() => {
    console.log('[Effect] 开启定时器')
    const timer = setInterval(() => {
      setCount((c) => c + 1)
    }, 1000)

    // 这是函数组件的“生命周期清理”
    return () => {
      console.log('[Cleanup] 清理定时器')
      clearInterval(timer)
    }
  }, [])

  return <div>计数：{count}</div>
}

export default TimerFunction

我应该开启它吗？

答案是肯定的，虽然这样做会让你的log翻倍，但是可以提前帮你排查代码的逻辑漏洞和潜在风险，同时着严格模式在构建的过程中自动失效，所有不用担心生产环境影响用户的性能。

结余

react 的严格模式更像是对开发者的一种 “善意的怀疑”，借用苏格拉底的一句话，“我唯一知道的，就是我一无所知”。

项目代码其实是两部分，一部分是基于 Axios 的 HTTP 请求封装;一部分是API 基础封装与管理，参考了后端接口，类，抽像类的设计思路。

☛ 基于 Axios 的 HTTP 请求封装

该文件提供了基于 Axios 的 HTTP 请求封装，主要功能包括：

1. 请求头管理：自动添加 Content-Type、CSRF 令牌、认证令牌等基础请求头
2. 双实例设计：分别创建 read 和 write 两个 Axios 实例，用于不同类型的请求
3. 拦截器配置：为请求和响应添加拦截器，可用于统一处理请求和响应
4. 统一 API 方法：封装了 apiFunc 函数，支持 GET、POST、PUT、DELETE 等请求方法
5. 读写分离：提供 requestRead 和 requestWrite 两个函数，分别用于读操作和写操作
6. 错误类型定义：统一定义了常见错误类型，便于错误处理

使用示例：

// 读操作示例
import { requestRead } from './axios/basic/axios'

const response = await requestRead({
  method: 'get',
  url: '/api/users',
 data: { page: 1, pageSize: 10 }
})

// 写操作示例
import { requestWrite } from './axios/basic/axios'

const response = await requestWrite({
 method: 'post',
 url: '/api/users',
 data: { name: 'John', age: 30 }
})

注意事项：

• GET 和 DELETE 请求的参数会自动转换为 URL 查询参数
• POST 和 PUT 请求的参数会作为请求体发送
• 所有请求都会自动添加必要的请求头，包括认证令牌和 CSRF 令牌
• 支持自定义 axios 配置，会与默认配置合并

☛ 基于 Axios 的 HTTP 请求封装

该文件提供了一套完整的 API 调用框架，主要功能包括：

1. 端点配置管理：通过 EndpointConfig 类标准化 API 端点配置
2. 通用请求处理：封装了 request 方法，支持缓存、错误处理等高级功能
3. CRUD 操作：提供了 list、page、add、update、delete、getById 等通用方法
4. 缓存机制：实现了基于内存的请求缓存，提高重复请求的响应速度
5. 错误处理：统一的错误类型定义和错误信息处理
6. 加载状态管理：自动处理请求的加载状态显示

核心组件：

• EndpointConfig：API 端点配置类，用于创建标准化的 API 端点配置
• ApiBase：API 基础抽象类，提供通用的 API 操作方法

使用示例：

// 1. 定义 API 端点配置
const userEndpoints: IBaseApiEndpoints = {
  list: new EndpointConfig('/api/users', {
    method: 'get',
    requestType: 'read',
    cacheable: true
  }),
  add: new EndpointConfig('/api/users', {
    method: 'post',
    requestType: 'write'
  }),
  // 其他端点配置...
}

// 2. 创建 API 实例
class UserApi extends ApiBase {
  constructor() {
    super(userEndpoints)
  }
}

// 3. 使用 API 实例
const userApi = new UserApi()

// 获取用户列表
const users = await userApi.list({ page: 1, pageSize: 10 })

// 添加新用户
await userApi.add({ name: 'John', email: 'john@example.com' })

// 更新用户信息
await userApi.update(1, { name: 'John Doe' })

// 删除用户
await userApi.delete([1, 2, 3])

// 获取用户详情
const user = await userApi.getById(1)

特性说明：

• 支持读写分离（read/write）
• 自动处理加载状态显示
• 统一的错误处理和提示
• 可配置的缓存机制
• 标准化的 API 端点配置

欢迎下载源码 使用，如觉得有用麻烦您点个赞。

深度图和价格图都是基于D3.js库来绘制的svg图形

D3.js (Data-Driven Documents) 是一个用于操作文档的JavaScript库，它可以通过使用HTML, SVG 和 CSS等技术在网页上动态生成数据可视化。下面跟着以下步骤实现深度图的绘制：

1.数据集定义

首先我们需要定义好我们要展示的数据，看下将要用到的数据集:liquidity表示y轴数据，token0Price表示x轴数据

[ {    "tick" : -887200,    "liquidity" : "2516871586768523698747878",    "token0Price" : "0.000000000000000000000000000000000000002960192591918355544122581114448831",    "token1Price" : "337815857904011940012765396015654000000",    "timestamp" : 1691676253239  }, {    "tick" : -610800,    "liquidity" : "2516871586768523698747878",    "token0Price" : "0.000000000000000000000000002982766743656641268864955452810751",    "token1Price" : "335259202593253190167580281.8803577",    "timestamp" : 1691676253239  },  ......  ]

2.设置画布

我们需要定义好将要使用的画布大小、内边距等属性。我们将会创建一个宽度为400像素，高度为200像素，且四周留有{ top: 20, right: 2, bottom: 20, left: 0 }像素的空白的画布

const margins = { top: 20, right: 2, bottom: 20, left: 0 };
const width = 400
const height = 200

3.定义比例尺

根据数据集中的数值范围，我们需要创建与之对应的比例尺。使用scaleLinear()函数分别创建x轴和y轴的比例尺：

使用domain()方法来设置比例尺的输入域（即数据范围），使用range()方法来确定输出范围（在画布上的位置）。

  // 计算好绘制面积
  const [innerHeight, innerWidth] = useMemo(() => {
    return [      height - margins.top - margins.bottom,      width - margins.left - margins.right,    ];
  }, [width, height, margins]);
 
 // 创建X轴、Y轴比例尺
 const scales = {
      xScale: scaleLinear()
        .domain([
          getPriceOnTick(computedCurrentPrice * zoomLevel.initialMin),
          getPriceOnTick(computedCurrentPrice * zoomLevel.initialMax),
        ])
        .range([0, innerWidth]),
      yScale: scaleLinear()
        .domain([
          0,
          max(formattedData, (d) => {
            return yAccessor(d); // Y轴上的最大值
          }),
        ])
        .range([innerHeight, 0]),
    };

4.创建面积图

现在我们需要根据流动性值，来绘制生成面积图。可以使用d3.area()来创建一个面积图：

该函数创建的面积图会使用series数据集合中的值，将x轴和y轴上的各个点用曲线连接起来；使用.curve()方法指定了折线的形状，curveStepAfter 是d3提供的一种曲线类型定义。

import { area, curveStepAfter } from 'd3';
export const xAccessor = (d) => {
  return d.price0;  //x轴取值
};
export const yAccessor = (d) => {
  return d.activeLiquidity; // y轴取值
};

/**
 * 
 * @param 
     xScale: x轴比例尺
     yScale: y轴比例尺
     series: 数据集合
     fill  ：面积填充颜色
     xValue ：xAccessor
     yValue ：yAccessor
 * @returns 
 */
export const Area = ({ xScale, yScale, series, xValue, yValue, fill }) => {
  const chartArea =
    xScale && yScale
      ? area()
          .curve(curveStepAfter)
          .x((d) => {
            return xScale(xValue(d));
          })
          .y0(yScale(0))
          .y1((d) => {
            return yScale(yValue(d));
          })(
          series.filter((d) => {
            const value = xScale(xValue(d));
            return value > 0;
          })
        )
      : null;
  return useMemo(() => {
    return <path fill={fill} d={chartArea} />;
  }, [fill, series, xScale, xValue, yScale, yValue]);
};

5.设置X坐标轴

我们需要添加坐标轴和数字标签，以便更好地显示数据。

深度图，我们只需要设置X坐标轴，并通过调用g元素上的.call()方法向画布上添加了这些坐标轴。我们还使用.transform()方法将坐标轴移动到正确的位置，使用.ticks(number)设置显示刻度的数量，并使用.tickFormat()自定义格式化坐标轴数据，.attr()可以像css一样设置刻度的样式

//X坐标轴
export const AxisBottom = ({ xScale, innerHeight, offset = 0 }) => {
  return useMemo(() => {
    if (xScale) {
      return (
        <g transform={`translate(0, ${innerHeight + offset})`}>
          <Axis
            axisGenerator={axisBottom(xScale)
              .ticks(6)
              .tickFormat((d) => {
                return formatD3value(d);
              })}
          />
        </g>
      );
    }
    return null;
  }, [innerHeight, offset, xScale]);
};

const Axis = ({ axisGenerator }) => {
  const axisRef = (axis) => {
    axis &&
      select(axis)
        .call(axisGenerator)
        .call((g) => {
          return g.select('.domain').remove();
        })
        .call((g) => {
          // 移除刻度上的锯齿
          return g.selectAll('.tick line').attr('display', 'none');
        })
        .call((g) => {
          return g
            .selectAll('.tick text')
            .attr('transform', `translate(${0},${2})`)
            .attr('fill', '#BDBDBD')
            .attr('font-size', '8px');
        });
  };

  return <g ref={axisRef} />;
};

6.绘制左右两根旗子

这里需要根据path来绘制，需要手动一点点调试样式

// 旗杆本身的path路径
export const brushHandlePath = (height) => {
  return [
    // handle
    `M 0 0`, // move to origin
    `v ${height}`, // vertical line
    // 'm 2 0', // move 1px to the right
    // `V 0`, // second vertical line
    `M 0 1`, // move to origin
    // head
    'h 10', // horizontal line
    'q 1 0, 1 1', // rounded corner
    'v 22', // vertical line
    'q 0 1 -1 1', // rounded corner
    'h -10', // horizontal line
    `z`, // close path
  ].join(' ');
};
// 旗杆头部填充的两根白色竖条的路径
export const brushHandleAccentPath = () => {
  return [
    'M 0 -3', // move to origin
    'm 3 7', // move to first accent
    'v 18', // vertical line
    'M 0 -3', // move to origin
    'm 8 7', // move to second accent
    'v 18', // vertical line
    'z',
  ].join(' ');
};
// 使用上面填好的path路径
const Handle = ({ color, d }) => {
  return (
    <path
      d={d}
      stroke={color}
      strokeWidth="2.5"
      fill={color}
      cursor="ew-resize"
      pointerEvents="none"
    />
  );
};

7.一切就绪，组装各UI模块

此时UI层面已经大功告成，就可以各模块组合看效果了

    // svg : 整个画布布局宽度、高度设置
     <svg  
        width="100%"
        height="100%"
        viewBox={`0 0 ${width} ${height}`}
        style={{ overflow: 'visible' }}
      >
       <defs>
       
          // brushDomain 就是两根旗子选中的范围，算出两个旗子的范围之差，然后截取出高亮的面积图
          {brushDomain && (
            // mask to highlight selected area
            <clipPath id={`${id}-chart-area-mask`}>
              <rect
                fill="white"
                x={xScale(brushDomain[0])}
                y={0}
                width={xScale(brushDomain[1]) - xScale(brushDomain[0])}
                height={innerHeight}
              />
            </clipPath>
          )}
        </defs>
        <g transform={`translate(${margins.left},${margins.top})`}>
          <g clipPath={`url(#${id}-chart-clip)`}>
            // 这是面积图
            <Area
              series={series}
              xScale={xScale}
              yScale={yScale}
              xValue={xAccessor}
              yValue={yAccessor}
              // fill="#78DE9D"
              fill="var(--okd-color-green-200)"
            />
            // 这里又绘制了一次面积图，原因是：两根旗子之间选中的流动性需要高亮，所以需要再绘制一个高亮颜色的面积图，并且 clipth = {`url(#${id}-chart-area-mask)`} 与上面的cliptath就对应上了。
            {brushDomain && (
              // duplicate area chart with mask for selected area
              <g clipPath={`url(#${id}-chart-area-mask)`}>
                <Area
                  series={series}
                  xScale={xScale}
                  yScale={yScale}
                  xValue={xAccessor}
                  yValue={yAccessor}
                  fill="var(--okd-color-green-500)"
                />
              </g>
            )}
            // 表示当前价格的一条竖线
            <Line value={current} xScale={xScale} innerHeight={innerHeight} />
            // X轴坐标轴
            <AxisBottom xScale={xScale} innerHeight={innerHeight} />
          </g>
           // 放大缩小
          <ZoomOverlay width={innerWidth} height={height} ref={zoomRef} />
          // 两根旗子
          <Brush
            id={id}
            xScale={xScale}
            interactive
            brushLabelValue={brushLabels}
            brushExtent={brushDomain ?? (xScale && xScale.domain())}
            innerWidth={innerWidth}
            innerHeight={innerHeight}
            setBrushExtent={onBrushDomainChange}
            westHandleColor="#31BD65"
            eastHandleColor="#31BD65"
          />
        </g>
      </svg>

8.静态部分完成，旗子可以动起来了

需要使用d3.brushX()函数：一维画笔X-尺寸。同样有brushY()函数:一维画笔Y-尺寸（价格图使用这个方法）

用法：d3.brushX();

参数：该函数不接受任何参数。 返回值：此函数沿x轴返回新创建的一维笔刷

  1、d3设置一维画笔
  brushBehavior.current = brushX()
      .extent([
        [Math.max(0 + BRUSH_EXTENT_MARGIN_PX, xScale(0)), 0],
        [innerWidth - BRUSH_EXTENT_MARGIN_PX, innerHeight],
      ]) //  extent 设置可刷取的范围
      .handleSize(30) // 设置brush柄的大小、默认为6
      .on('brush end', brushed); // 滑动结束事件，brushed里可以定义业务回调
    brushBehavior.current(select(brushRef.current)); // 选中的元素
    

2、画笔动作完成后，处理数据
  const onBrushDomainChange = useCallback((domain, mode) => {
    let leftRangeValue = Number(domain[0]);
    let rightRangeValue = Number(domain[1]);
    if (leftRangeValue <= 0) {
      leftRangeValue = 1 / 10 ** 18;
    }
    if (rightRangeValue > 1e35) {
      rightRangeValue = 1e35;
    }
    setLocalBrushExtent([leftRangeValue, rightRangeValue]);

    // 拖拽柱子时，handle:单根拖拽， drag：两个一起拖拽
    if (mode === 'handle' || mode === 'drag') {
      const { minPrice, maxPrice } = priceRange;

      // 左侧价格变化(minPrice)
      if (!compareIsEqualPrice(minPrice, leftRangeValue)) {
        // transformPriceOnTickPoint 把价格转化在整tick点上
        const { price, tick } = transformPriceOnTickPoint(
          leftRangeValue,
          false
        );
        // 改变下方价格输入框的值，以及和下单器询价联动
        onLeftRangeInput(tick, price);
      }

      //右侧价格变化(maxPrice)
      if (!compareIsEqualPrice(maxPrice, rightRangeValue)) {
        const { price, tick } = transformPriceOnTickPoint(
          rightRangeValue,
          mode === 'handle'
        );
        onRightRangeInput(tick, price);
      }
      updatePros({
        hasChangePrice: true,
      });
    }

    // 初始化时、点击重置价格区间时
    if (mode === 'reset' || mode === 'init') {
      if (leftRangeValue > 0) {
        const { price, tick } = transformPriceOnTickPoint(
          leftRangeValue,
          false
        );
        onLeftRangeInput(tick, price);
      }

      if (rightRangeValue > 0) {
        const { price, tick } = transformPriceOnTickPoint(
          rightRangeValue,
          mode !== 'init'
        );
        onRightRangeInput(tick, price);
      }
    }
    // 汇率反转时
    if (mode === 'reverse') {
      if (leftRangeValue > 0) {
        setPriceRange(PRICE_TYPE.MIN_PRICE, leftRangeValue);
      }
      if (rightRangeValue > 0) {
        setPriceRange(PRICE_TYPE.MAX_PRICE, rightRangeValue);
      }
    }
  });

  3、onRightRangeInput（以右侧价格为例） 价格输入框、下单器开始联动起来  
  const onRightRangeInput = (tickValue: number, priceValue: number) => {
    let rightInputTick = tickValue;
    let rightInputPrice = priceValue;
    
    const currentLeftRangeTick = isReverse
      ? -tickRange.tickUpper
      : tickRange.tickLower;
      // 判断滑动左右两个旗子的tick是否相同，如果是增加一个tickSpacing
    if (rightInputTick == currentLeftRangeTick) {
      rightInputTick += tickSpacing;
      rightInputPrice = getPriceByTick(
        rightInputTick,
        token0Precisions!,
        token1Precisions!
      );
    }

    // 更新价格范围-最大的价格
    uniV3SubscribeStore.setPriceRange(PRICE_TYPE.MAX_PRICE, rightInputPrice);
    
    // 判断是否是反转，决定更新tick的范围
    const tickType = isReverse ? TICK_TYPE.TICK_LOWER : TICK_TYPE.TICK_UPPER;
    // 更新tick
    uniV3SubscribeStore.setTickRange(
      tickType,
      isReverse ? -rightInputTick : rightInputTick
    );
    judgeOneSidedLiquidity(); // 判断单边流动性， 下单器是否投资单币、双币
    debounceV3ReceiveInfo(); // 根据最终的tick范围，开始询价
  };    

9.总结

以上就是深度图从UI层一步步的绘制，再到滑动旗杆改变价格，再计算得出tick范围，最终在下单器询价的整体流程

在小程序业务开发中，上传功能是高频场景，而部分业务需要同时支持文件上传（如 PDF、文档）和照片上传（如图片凭证）两种模式。

基于完整的业务代码，从 WXML 结构、JS 逻辑、WXSS 样式三个维度，深度解析一个支持双模式切换、带上传 / 预览 / 删除、容错处理完善的小程序上传组件。该组件直接复用即可落地，适配绝大多数表单类业务（如用印申请、资料提交等）。

通过wx:if根据uploadMode切换文件 / 照片上传 UI，同时实现切换按钮、上传区域、删除 / 预览功能。

js模式切换、文件上传、照片上传、删除 / 预览、异常处理全流程逻辑，代码注释详细，直接复用。

<view class="seal_wrapper">
  <view class="items_wrap">
    <!-- 标题栏：带必填标识 -->
    <view class="items_titles">
      <text>*</text>用印文件原件
    </view>
    <!-- 模式切换开关：文件/照片 -->
    <view class="upload-switch">
      <view class="upload-switch-item {{uploadMode === 'file' ? 'active' : ''}}" bind:tap="setUploadMode" data-mode="file">文件</view>
      <view class="upload-switch-item {{uploadMode === 'image' ? 'active' : ''}}" bind:tap="setUploadMode" data-mode="image">照片</view>
    </view>
    <!-- 上传内容区域：根据模式渲染 -->
    <view class="items_input">
      <!-- 文件上传模式 -->
      <view class="file-uploader" wx:if="{{uploadMode === 'file'}}">
        <!-- 已上传文件：显示文件名+删除按钮 -->
        <view class="file-item" wx:if="{{fileUrl}}">
          <view class="file-name">{{fileName || '已上传文件'}}</view>
          <image class="file-del" src="/img/close.png" mode="aspectFit" bind:tap="removeFile" />
        </view>
        <!-- 未上传文件：显示上传入口 -->
        <view class="file-add" bind:tap="chooseFile" wx:if="{{!fileUrl}}">
          <image class="file-add-icon" src="/img/add.png" mode="aspectFit"/>
          <view class="file-add-text">上传文件</view>
        </view>
      </view>

      <!-- 照片上传模式 -->
      <view class="images-grid" wx:if="{{uploadMode === 'image'}}">
        <!-- 已上传照片：显示图片+删除+预览 -->
        <view class="img-item" wx:if="{{images && images.length}}">
          <image class="img" src="{{images[0]}}" mode="aspectFit" bind:tap="previewImage" data-idx="0"/>
          <image class="img-del" src="/img/close.png" mode="aspectFit" bind:tap="removeImage" data-idx="0"/>
        </view>
        <!-- 未上传照片：显示上传入口 -->
        <view class="img-add" bind:tap="chooseImages">
          <image class="img-add-icon" src="/img/add.png" mode="aspectFit"/>
        </view>
      </view>
    </view>
  </view>
</view>

Page({
  data: {
    // 默认选中文件上传模式
    uploadMode: 'file',
    fileUrl: '', // 已上传文件的服务端链接
    fileName: '', // 已上传文件名称
    images: [] // 已上传照片链接数组
  },

  /**
   * 切换上传模式（文件/照片）
   */
  setUploadMode(e) {
    const mode = e?.currentTarget?.dataset?.mode || ''
    // 仅允许切换到合法模式
    if (mode !== 'file' && mode !== 'image') return
    this.setData({ uploadMode: mode })
  },

  /**
   * 删除已上传文件
   */
  removeFile() {
    this.setData({
      fileUrl: '',
      fileName: ''
    })
  },

  /**
   * 选择并上传文件（文档）
   */
  chooseFile() {
    wx.chooseMessageFile({
      count: 1, // 单次上传1个文件
      type: 'file', // 类型为文件
      success: (res) => {
        const files = res?.tempFiles || []
        const file = files[0] || null
        if (!file?.path) return

        // 保存文件名称
        this.setData({ fileName: file.name || '' })

        // 上传中loading
        wx.showLoading({ title: '上传中...' })
        // 调用上传接口
        wx.uploadFile({
          filePath: file.path,
          name: 'file', // 服务端接收的文件字段名
          url: api.ImgUpload(), // 替换为你的图片上传接口
          formData: {
            // 附加参数：用户身份标识
            OpenID: wx.getStorageSync('openId'),
            MID: wx.getStorageSync('mid'),
          },
          success: (resu) => {
            // 解析服务端返回（捕获JSON解析异常）
            let data = null
            try {
              data = JSON.parse(resu.data)
            } catch (e) {
              data = null
            }
            // 上传成功：保存文件链接
            if (data && data.code === 200 && data.data) {
              this.setData({ fileUrl: data.data })
              return
            }
            // 上传失败：提示错误信息
            wx.showToast({
              title: data?.msg || '上传失败',
              icon: 'none'
            })
          },
          fail: (err) => {
            console.error('文件上传失败：', err)
            wx.showToast({ title: '上传失败', icon: 'none' })
          },
          complete: () => {
            wx.hideLoading() // 无论成功失败，关闭loading
          }
        })
      },
      fail: (err) => {
        console.error('选择文件失败：', err)
      }
    })
  },

  /**
   * 预览照片
   */
  previewImage(e) {
    const idx = e?.currentTarget?.dataset?.idx || 0
    const urls = this.data.images || []
    if (!urls.length) return
    // 调用小程序原生预览API
    wx.previewImage({
      urls,
      current: urls[idx] || urls[0]
    })
  },

  /**
   * 删除已上传照片
   */
  removeImage(e) {
    const idx = e?.currentTarget?.dataset?.idx || 0
    const urls = [...(this.data.images || [])] // 浅拷贝避免直接修改原数据
    if (!urls.length) return
    urls.splice(idx, 1) // 删除对应索引的图片
    this.setData({ images: urls })
  },

  /**
   * 选择并上传照片
   */
  chooseImages() {
    wx.chooseMedia({
      count: 1, // 单次上传1张照片
      mediaType: ['image'], // 仅选择图片
      sourceType: ['album', 'camera'], // 支持相册/相机
      success: (res) => {
        const files = res?.tempFiles || []
        const tempFilePath = files[0]?.tempFilePath || ''
        if (!tempFilePath) return

        wx.showLoading({ title: '上传中...' })
        wx.uploadFile({
          filePath: tempFilePath,
          name: 'file',
          url: api.ImgUpload(), // 替换为你的图片上传接口
          formData: {
            OpenID: wx.getStorageSync('openId'),
            MID: wx.getStorageSync('mid'),
          },
          success: (resu) => {
            let data = null
            try {
              data = JSON.parse(resu.data)
            } catch (e) {
              data = null
            }
            if (data && data.code === 200 && data.data) {
              // 照片仅支持单张，直接覆盖数组
              this.setData({ images: [data.data] })
              return
            }
            wx.showToast({
              title: data?.msg || '上传失败',
              icon: 'none'
            })
          },
          fail: (err) => {
            console.error('照片上传失败：', err)
            wx.showToast({ title: '上传失败', icon: 'none' })
          },
          complete: () => {
            wx.hideLoading()
          }
        })
      },
      fail: (err) => {
        console.error('选择照片失败：', err)
      }
    })
  }
})

/* 外层容器：避免样式污染 */
.seal_wrapper .items_wrap {
  width: 100%;
  padding: 30rpx 0;
  border-bottom: 1rpx solid #f0f0f0;
}
/* 最后一项去掉下边框 */
.seal_wrapper .items_wrap:last-child {
  border-bottom: none;
}
/* 标题样式 */
.seal_wrapper .items_titles {
  font-size: 32rpx;
  margin-bottom: 20rpx;
  color: #222;
}
/* 必填红色星号 */
.seal_wrapper .items_titles text {
  color: #ff4d4f;
  margin-right: 8rpx;
}
/* 输入/上传区域 */
.seal_wrapper .items_input {
  width: 100%;
}
/* 模式切换容器 */
.seal_wrapper .upload-switch{
  display: flex;
  gap: 16rpx;
  margin: 8rpx 0 16rpx;
}
/* 切换项样式 */
.seal_wrapper .upload-switch-item{
  padding: 10rpx 26rpx;
  border-radius: 999rpx;
  background: #f3f4f6;
  color: #666;
  font-size: 26rpx;
  line-height: 1.4;
}
/* 选中态样式 */
.seal_wrapper .upload-switch-item.active{
  background: #e8f1ff;
  color: #2f7cff;
  font-weight: 700;
}
/* 文件上传容器 */
.seal_wrapper .file-uploader{
  width: 100%;
}
/* 未上传文件：虚线边框+居中 */
.seal_wrapper .file-add{
  width: 100%;
  height: 96rpx;
  border-radius: 16rpx;
  border: 2rpx dashed #d8d8d8;
  display: flex;
  align-items: center;
  justify-content: center;
  gap: 14rpx;
}
/* 上传图标 */
.seal_wrapper .file-add-icon{
  width: 44rpx;
  height: 44rpx;
  opacity: 0.7;
}
/* 上传文字 */
.seal_wrapper .file-add-text{
  font-size: 28rpx;
  color: #666;
}
/* 已上传文件：背景色+弹性布局 */
.seal_wrapper .file-item{
  width: 100%;
  min-height: 96rpx;
  border-radius: 16rpx;
  background: #f9fafb;
  padding: 18rpx;
  box-sizing: border-box;
  display: flex;
  align-items: center;
  justify-content: space-between;
}
/* 文件名：超出省略 */
.seal_wrapper .file-name{
  flex: 1;
  min-width: 0;
  font-size: 28rpx;
  color: #333;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
  padding-right: 16rpx;
}
/* 删除按钮 */
.seal_wrapper .file-del{
  width: 36rpx;
  height: 36rpx;
  background: rgba(0,0,0,0.3);
  border-radius: 18rpx;
  padding: 4rpx;
  box-sizing: border-box;
}
/* 照片网格布局 */
.seal_wrapper .images-grid{
  display: flex;
  flex-wrap: wrap;
  gap: 18rpx;
}
/* 已上传照片容器 */
.seal_wrapper .img-item{
  width: 160rpx;
  height: 160rpx;
  border-radius: 16rpx;
  overflow: hidden;
  position: relative;
}
/* 照片 */
.seal_wrapper .img{
  width: 100%;
  height: 100%;
}
/* 照片删除按钮 */
.seal_wrapper .img-del{
  position: absolute;
  top: 6rpx;
  right: 6rpx;
  width: 36rpx;
  height: 36rpx;
  background: rgba(0,0,0,0.3);
  border-radius: 18rpx;
  padding: 4rpx;
  box-sizing: border-box;
}
/* 未上传照片：虚线边框+居中 */
.seal_wrapper .img-add{
  width: 160rpx;
  height: 160rpx;
  border-radius: 16rpx;
  border: 2rpx dashed #d8d8d8;
  display: flex;
  align-items: center;
  justify-content: center;
}
/* 上传图标 */
.seal_wrapper .img-add-icon{
  width: 54rpx;
  height: 54rpx;
  opacity: 0.7;
}

概述

Pinia 是 Vue.js 的官方状态管理库，可以把它看作是 Vuex 的升级版。它提供了更简洁的 API 和更好的 TypeScript 支持，已经成为 Vue 生态中推荐的状态管理方案。Pinia基本三要素：

• store ，数据，用户自定义数据存储在store
• getters，获取数据或进行加工后的数据，类似计算属性computed
• actions，修改数据的方法

Pinia存储读取数据的基本方法

• 安装Pinia，npm install pinia
• 在main.ts引入Pinia，创建引用实例
• 创建Fish组件，数据name，price，site
• 创建store文件夹，创建useFishStore，存储Fish组件数据 文件结构目录 main.ts代码：

import { createApp } from 'vue'
import App from './App.vue'
import { createPinia } from 'pinia'
const app = createApp(App)
const pinia = createPinia()
app.use(pinia)
app.mount('#app')

Fis组件代码

<template>
  <div>
    <h2>鱼类：{{ store.name }}</h2>
    <h2>价格：{{ store.price }}</h2>
    <h2>位置：{{ store.site }}</h2>
  </div>
</template>
<script setup lang="ts">
import { useFishStore } from '@/store/useFishStore'
const store = useFishStore();
</script>

useFishStore.ts代码

import { defineStore } from 'pinia'
export const useFishStore = defineStore('fish', {
  state: () => ({
    name: '鲫鱼',
    price: 10,
    site:'河里'
  })
})

运行效果

Pinia修改数据的三种方法

• 直接修改
• 通过$patch方法修改
• 通过actions修改

直接修改数据

Fish组件

<template>
  <div>
    <h2>鱼类：{{ store.name }}</h2>
    <h2>价格：{{ store.price }}</h2>
    <h2>位置：{{ store.site }}</h2>
    <button @click="changeFish()">修改鱼的数据</button>
  </div>
</template>
<script setup lang="ts">
import { useFishStore } from '@/store/useFishStore'
const store = useFishStore();
function changeFish() {
  store.name += '~';
  store.price += 10;
  store.site+='!'

}
</script>

修改效果如下：

通过$patch方法修改

Fish组件源码

<template>
  <div>
    <h2>鱼类：{{ store.name }}</h2>
    <h2>价格：{{ store.price }}</h2>
    <h2>位置：{{ store.site }}</h2>
    <button @click="changeFish()">修改鱼的数据</button>
  </div>
</template>
<script setup lang="ts">
import { useFishStore } from '@/store/useFishStore'
const store = useFishStore();
function changeFish() {
   store.$patch({
    name: '带鱼',
    price: 300,
    site:'海里'
  });
}
</script>

修改效果如图：

通过actions修改

useFishStore增加actions，添加方法changeFish

import { defineStore } from 'pinia'
export const useFishStore = defineStore('fish', {
  state: () => ({
    name: '鲫鱼',
    price: 10,
    site:'河里'
  }),
  actions: {
    changeFish(fish: any) {
      this.name = fish.name;
      this.price = fish.price;
      this.site = fish.site
    }
  }
})

Fish组件代码

<template>
  <div>
    <h2>鱼类：{{ store.name }}</h2>
    <h2>价格：{{ store.price }}</h2>
    <h2>位置：{{ store.site }}</h2>
    <button @click="changeFish()">修改鱼的数据</button>
  </div>
</template>
<script setup lang="ts">
import { useFishStore } from '@/store/useFishStore'
const store = useFishStore();
function changeFish() {
  store.changeFish({
    name: '带鱼',
    price: 300,
    site: '海里'
  });
}
</script>

运行效果如下：

Pinia函数storeToRefs应用

在Fish引用useFishStore，从useFishStore()直接解析数据，会丢失响应式，需要使用toRefs转换，但toRefs会将所有成员变成响应式对象。storeToRefs只会将数据转换成响应式对象。 Fish组件代码

<template>
  <div>
    <h2>鱼类：{{ name }}</h2>
    <h2>价格：{{ price }}</h2>
    <h2>位置：{{ site }}</h2>
    <button @click="changeFish()">修改鱼的数据</button>
  </div>
</template>
<script setup lang="ts">
import { useFishStore } from '@/store/useFishStore'
import { toRefs } from 'vue';
import { storeToRefs } from 'pinia'
console.log(toRefs(useFishStore()));
console.log(storeToRefs(useFishStore()));
let { name, price, site } = storeToRefs(useFishStore());

function changeFish() {
  name.value += '~';
  price.value += 2;
  site.value += '!';

}
</script>

运行效果如图,注意控制台打印的日志:

Getters用法

类似组件的 computed，对state 数据进行派生计算。state数据发生改变，调用getters函数。 useFishStore.ts代码：

import { defineStore } from 'pinia'
export const useFishStore = defineStore('fish', {
  state: () => ({
    name: '鲫鱼',
    price: 10,
    site:'河里'
  }),
  actions: {
    changeFish(fish: any) {
      this.name = fish.name;
      this.price = fish.price;
      this.site = fish.site
    }
  },
  getters: {
    changeprice():number {
      return this.price * 20;
    },
    changesite():string {
      return this.name+'在'+this.site+'游泳'
    }
  }
})

注意changeprice():number，ts语法检查，函数返回类型为number。 Fish组件代码

<template>
  <div>
    <h2>鱼类：{{ name }}</h2>
    <h2>价格：{{ price }}新价格：{{ changeprice }}</h2>
    <h2>位置：{{ site }}新位置：{{ changesite }}</h2>
    <button @click="changeFish()">修改鱼的数据</button>
  </div>
</template>
<script setup lang="ts">
import { useFishStore } from '@/store/useFishStore'
import { toRefs } from 'vue';
import { storeToRefs } from 'pinia'
console.log(toRefs(useFishStore()));
console.log(storeToRefs(useFishStore()));
let { name, price, site,changeprice,changesite } = storeToRefs(useFishStore());

function changeFish() {
  name.value += '~';
  price.value += 2;
  site.value += '!';

}
</script>

运行效果如图：

$subscribe用法

$subscribe订阅信息，当数据发生变化，回调$subscribe订阅信息，当数据发生变化，回调subscribe函数设定的回调函数，该函数有两个参数：一是事件信息，一是修改后的数据数据。 $subscribe用于两组件的数据通信，Fish组件数据发生变化时，通知Cat组件。

import { defineStore } from 'pinia'
export const useFishStore = defineStore('fish', {
  state: () => ({
    name: '鲫鱼',
    price: 10,
    site:'河里'
  }),
  actions: {
    changeFish(fish: any) {
      this.name = fish.name;
      this.price = fish.price;
      this.site = fish.site
    }
  }
})

Fish组件：

<template>
  <div>
    <h2>鱼类：{{ name }}</h2>
    <h2>价格：{{ price }}</h2>
    <h2>位置：{{ site }}</h2>
    <button @click="changeFish()">修改鱼的数据</button>
  </div>
</template>
<script setup lang="ts">
import { useFishStore } from '@/store/useFishStore'
import { storeToRefs } from 'pinia'
let store = useFishStore()
let { name, price, site } = storeToRefs(store);
function changeFish() {
  name.value += '~';
  price.value += 2;
  site.value += '!';

}
</script>

Cat组件

<template>
  <div>
    <h2>鱼类：{{ name }}</h2>
    <h2>价格：{{ price }}</h2>
    <h2>位置：{{ site }}</h2>
  </div>
</template>
<script setup lang="ts">
import { useFishStore } from '@/store/useFishStore'
import { ref } from 'vue';
let name = ref('');
let price = ref(0);
let site=ref('')
let store = useFishStore();
store.$subscribe((mutate, state) => {
  console.log(mutate);
  console.log(state);
  name.value = state.name;
  price.value = state.price;
  site.value = state.site;
});

</script>

效果如图： 注意控制台打印的数据

Pinia组合式写法

组合式是vue3中新语法，有以下优势，

• 轻松提取和组合业务逻辑
• 使用所有 Vue 组合式 API（ref、computed、watch、生命周期等）
• 逻辑可以聚合在一起，而不是分散在不同配置项中

import { defineStore } from 'pinia'
import { computed, ref } from 'vue';
export const useFishStore = defineStore('fish', () => {
  let name = ref('鲫鱼');
  let price = ref(10);
  let site = ref('河里');
  function changeFish(fish: any) {
    console.log(fish)
    name.value = fish.name;
    price.value = fish.price;
    site.value = fish.site;
  }
  let calcPrice = computed(() => {
    return price.value * 2;

  })
  return { name, price,site,changeFish,calcPrice };

})

Fish组件

<template>
  <div>
    <h2>鱼类：{{ name }}</h2>
    <h2>价格：{{ price }}新价格：{{ calcPrice }}</h2>
    <h2>位置：{{ site }}</h2>
    <button @click="changeFish()">修改鱼的数据</button>
  </div>
</template>
<script setup lang="ts">
import { useFishStore } from '@/store/useFishStore'
import { storeToRefs } from 'pinia'
let store = useFishStore()
let { name, price, site ,calcPrice} = storeToRefs(store);
function changeFish() {
  store.changeFish({ name: '带鱼', price: 11, site: '海里' })

}
</script>

运行效果

detailsinfo: { // 逗号分隔的图片链接字符串（核心字段） 
    DocumentUrls: "http://192.168.0.28:53417/UpImg/20260330/20260330143414_583.png,http://192.168.0.28:53417/UpImg/20260330/20260330143416_482.png"
}

<view class="details_item" bind:tap="previewDocImage" data-url="{{detailsinfo.DocumentUrls}}">
    <view class="details_item_title">图片：</view>
    <view class="details_item_info text-d">详情</view>
</view>

  /**
 * 图片预览方法
 * 兼容：数组格式 / 逗号分隔字符串格式 的图片链接
 */
previewDocImage(e) {
  // 1. 从自定义属性中获取图片链接（容错获取，防止undefined报错）
  let url = e?.currentTarget?.dataset?.url || '';
  let urls = [];

  // 2. 格式兼容处理：数组直接用，字符串分割转数组
  if (Array.isArray(url)) {
    // 后端直接返回数组
    urls = url;
  } else if (typeof url === 'string') {
    // 后端返回逗号拼接字符串：分割 + 去空格 + 过滤空值
    urls = url.split(',').map(s => (s || '').trim()).filter(Boolean);
  }

  // 3. 兜底处理：如果dataset传参失败，直接从页面数据中获取
  if (!urls.length) {
    const detailsinfo = this.data.detailsinfo || {};
    const fallbackUrl = detailsinfo.DocumentUrls || '';
    
    if (Array.isArray(fallbackUrl)) {
      urls = fallbackUrl;
    } else if (typeof fallbackUrl === 'string') {
      urls = fallbackUrl.split(',').map(s => (s || '').trim()).filter(Boolean);
    }
  }

  // 4. 无图片时提示用户
  if (!urls.length) {
    wx.showToast({
      title: '暂无图片',
      icon: 'none',
    });
    return;
  }

  // 5. 调用微信原生图片预览API
  wx.previewImage({
    current: urls[0], // 默认显示第一张
    urls: urls, // 所有需要预览的图片链接
  });
},

点击详情后展示👇

① 容错获取传参

使用 ES6 可选链操作符 ?.，避免因 e/currentTarget/dataset 不存在导致代码报错，是小程序开发必备的容错写法。

② 格式兼容处理

• 数组：直接赋值使用
• 字符串：split(',') 分割成数组 + trim() 去空格 + filter(Boolean) 过滤空链接，保证数据纯净

③ 双层兜底保障

防止 data-url 传参失败，直接从页面 data 中重新获取图片链接，双重保险，绝不崩溃。

④ 无图友好提示

数组长度为 0 时，用 wx.showToast 提示用户，提升体验。

⑤ 调用原生预览

wx.previewImage 是微信官方 API：

• current：当前显示的图片链接
• urls：需要预览的所有图片数组