解法：搜索 & 枚举

因为好整数是 $k$ 回文整数的排列，因此我们可以把数字频率相同的 $k$ 回文整数视为同一种。枚举每种 $k$ 回文整数，再算算它不以 $0$ 为开头的排列有几种即可。

怎样枚举每种 $k$ 回文整数呢？由于回文数要求前半和后半相同，因此我们可以通过 DFS 搜索回文数的前半部分填什么。找到一个 $k$ 回文整数之后，再统计它的数字频率即可。这一部分的复杂度是 $\mathcal{O}(b^{\frac{n}{2}} \times b)$，其中 $b = 10$ 是可选的数字种类。因为 $n$ 很小所以没问题。

最后一个问题：给定每种数字的频率，怎么求不以 $0$ 为开头的排列有几种？我们可以用全排列数扣掉以 $0$ 为开头的排列。带重复元素的全排列数公式为

$$\frac{n!}{\prod n_i!}$$

其中 $n_i$ 是第 $i$ 种元素的出现频率。那么设 $c_i$ 为数字 $i$ 出现的频率，答案就是

$$
\frac{n!}{\prod\limits_{i = 0}^9 c_i!} - \frac{(n - 1)!}{(c_0 - 1)! \times \prod\limits_{i = 1}^9 c_i!}
$$

因为对于每种 $k$ 回文整数，我们需要 $\mathcal{O}(b)$ 的复杂度计算答案，这一部分的复杂度也是 $\mathcal{O}(b^{\frac{n}{2}} \times b)$。

参考代码（c++）

###cpp

class Solution {
public:
    long long countGoodIntegers(int n, int K) {
        long long P[n];
        P[0] = 1;
        for (int i = 1; i < n; i++) P[i] = P[i - 1] * 10;

        int cnt[10] = {0};
        // 用 string 保存每种数的出现次数，因为 vector 不能放进 unordered_set 里
        unordered_set<string> st;
        auto dfs = [&](auto &&self, int l, int r, long long now) {
            if (l > r) {
                // 所有数都填完了，检查能否被 K 整除，并记录数字出现频率
                if (now % K != 0) return;
                string s;
                for (int i = 0; i < 10; i++) s.push_back(cnt[i]);
                st.insert(s);
                return;
            }

            // 枚举第 l 和 r 位放什么数，注意不能有前导 0
            for (int i = (r == n - 1 ? 1 : 0); i < 10; i++) {
                if (l == r) {
                    cnt[i]++;
                    self(self, l + 1, r - 1, now + i * P[l]);
                    cnt[i]--;
                } else {
                    cnt[i] += 2;
                    self(self, l + 1, r - 1, now + i * (P[l] + P[r]));
                    cnt[i] -= 2;
                }
            }
        };
        dfs(dfs, 0, n - 1, 0);

        // 预处理阶乘
        long long fac[n + 1];
        fac[0] = 1;
        for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i;

        long long ans = 0;
        // 枚举每种 K 回文整数
        for (auto &s : st) {
            // 全排列数
            long long a = fac[n];
            for (int i = 0; i < 10; i++) a /= fac[s[i]];
            ans += a;
            if (s[0] == 0) continue;
            // 减去以 0 为开头的排列数
            a = fac[n - 1];
            for (int i = 0; i < 10; i++) {
                int t = (i == 0 ? s[i] - 1 : s[i]);
                a /= fac[t];
            }
            ans -= a;
        }
        return ans;
    }
};

方法一：枚举 + 组合数学

我们可以考虑枚举所有长度为 $n$ 的回文数，判断它们是否是 $k$ 回文数。由于回文数的性质，我们只需要枚举前半部分的数字，然后将其反转拼接到后面即可。

前半部分的数字长度为 $\lfloor \frac{n - 1}{2} \rfloor$，那么前半部分的数字范围是 $[10^{\lfloor \frac{n - 1}{2} \rfloor}, 10^{\lfloor \frac{n - 1}{2} \rfloor + 1})$。我们可以将前半部分的数字拼接到后面，形成一个长度为 $n$ 的回文数。注意到，如果 $n$ 是奇数，则需要将中间的数字做特殊处理。

然后，我们判断该回文数是否是 $k$ 回文数，如果是，则统计该回文数的所有排列组合。为了避免重复，我们可以使用一个集合 $\textit{vis}$ 来存储已经出现过的回文数的每个最小排列。如果该回文数的最小排列已经出现过，则跳过该回文数。否则，我们统计该回文数有多少个不重复的排列组合，添加到答案中。

我们可以使用一个数组 $\textit{cnt}$ 来统计每个数字出现的次数，然后使用组合数学的公式计算排列组合的数量。具体来说，假设数字 $0$ 出现了 $x_0$ 次，数字 $1$ 出现了 $x_1$ 次，...，数字 $9$ 出现了 $x_9$ 次，那么该回文数的排列组合数量为：

$$
\frac{(n - x_0) \cdot (n - 1)!}{x_0! \cdot x_1! \cdots x_9!}
$$

其中 $(n - x_0)$ 表示最高位可以选择除 $0$ 以外的所有数字，而 $(n - 1)!$ 表示除最高位以外的所有数字的排列组合数量，然后我们除以每个数字出现的次数的阶乘，避免重复。

最后，我们将所有的排列组合数量相加，得到最终的答案。

###python

class Solution:
    def countGoodIntegers(self, n: int, k: int) -> int:
        fac = [factorial(i) for i in range(n + 1)]
        ans = 0
        vis = set()
        base = 10 ** ((n - 1) // 2)
        for i in range(base, base * 10):
            s = str(i)
            s += s[::-1][n % 2 :]
            if int(s) % k:
                continue
            t = "".join(sorted(s))
            if t in vis:
                continue
            vis.add(t)
            cnt = Counter(t)
            res = (n - cnt["0"]) * fac[n - 1]
            for x in cnt.values():
                res //= fac[x]
            ans += res
        return ans

###java

class Solution {
    public long countGoodIntegers(int n, int k) {
        long[] fac = new long[n + 1];
        fac[0] = 1;
        for (int i = 1; i <= n; i++) {
            fac[i] = fac[i - 1] * i;
        }

        long ans = 0;
        Set<String> vis = new HashSet<>();
        int base = (int) Math.pow(10, (n - 1) / 2);

        for (int i = base; i < base * 10; i++) {
            String s = String.valueOf(i);
            StringBuilder sb = new StringBuilder(s).reverse();
            s += sb.substring(n % 2);
            if (Long.parseLong(s) % k != 0) {
                continue;
            }

            char[] arr = s.toCharArray();
            Arrays.sort(arr);
            String t = new String(arr);
            if (vis.contains(t)) {
                continue;
            }
            vis.add(t);
            int[] cnt = new int[10];
            for (char c : arr) {
                cnt[c - '0']++;
            }

            long res = (n - cnt[0]) * fac[n - 1];
            for (int x : cnt) {
                res /= fac[x];
            }
            ans += res;
        }

        return ans;
    }
}

###cpp

class Solution {
public:
    long long countGoodIntegers(int n, int k) {
        vector<long long> fac(n + 1, 1);
        for (int i = 1; i <= n; ++i) {
            fac[i] = fac[i - 1] * i;
        }

        long long ans = 0;
        unordered_set<string> vis;
        int base = pow(10, (n - 1) / 2);

        for (int i = base; i < base * 10; ++i) {
            string s = to_string(i);
            string rev = s;
            reverse(rev.begin(), rev.end());
            s += rev.substr(n % 2);
            if (stoll(s) % k) {
                continue;
            }
            string t = s;
            sort(t.begin(), t.end());
            if (vis.count(t)) {
                continue;
            }
            vis.insert(t);
            vector<int> cnt(10);
            for (char c : t) {
                cnt[c - '0']++;
            }
            long long res = (n - cnt[0]) * fac[n - 1];
            for (int x : cnt) {
                res /= fac[x];
            }
            ans += res;
        }
        return ans;
    }
};

###go

func factorial(n int) []int64 {
fac := make([]int64, n+1)
fac[0] = 1
for i := 1; i <= n; i++ {
fac[i] = fac[i-1] * int64(i)
}
return fac
}

func countGoodIntegers(n int, k int) (ans int64) {
fac := factorial(n)
vis := make(map[string]bool)
base := int(math.Pow(10, float64((n-1)/2)))

for i := base; i < base*10; i++ {
s := strconv.Itoa(i)
rev := reverseString(s)
s += rev[n%2:]
num, _ := strconv.ParseInt(s, 10, 64)
if num%int64(k) != 0 {
continue
}
bs := []byte(s)
slices.Sort(bs)
t := string(bs)

if vis[t] {
continue
}
vis[t] = true
cnt := make([]int, 10)
for _, c := range t {
cnt[c-'0']++
}
res := (int64(n) - int64(cnt[0])) * fac[n-1]
for _, x := range cnt {
res /= fac[x]
}
ans += res
}

return
}

func reverseString(s string) string {
t := []byte(s)
for i, j := 0, len(t)-1; i < j; i, j = i+1, j-1 {
t[i], t[j] = t[j], t[i]
}
return string(t)
}

###ts

function countGoodIntegers(n: number, k: number): number {
    const fac = factorial(n);
    let ans = 0;
    const vis = new Set<string>();
    const base = Math.pow(10, Math.floor((n - 1) / 2));

    for (let i = base; i < base * 10; i++) {
        let s = `${i}`;
        const rev = reverseString(s);
        if (n % 2 === 1) {
            s += rev.substring(1);
        } else {
            s += rev;
        }

        if (+s % k !== 0) {
            continue;
        }

        const bs = Array.from(s).sort();
        const t = bs.join('');

        if (vis.has(t)) {
            continue;
        }

        vis.add(t);

        const cnt = Array(10).fill(0);
        for (const c of t) {
            cnt[+c]++;
        }

        let res = (n - cnt[0]) * fac[n - 1];
        for (const x of cnt) {
            res /= fac[x];
        }
        ans += res;
    }

    return ans;
}

function factorial(n: number): number[] {
    const fac = Array(n + 1).fill(1);
    for (let i = 1; i <= n; i++) {
        fac[i] = fac[i - 1] * i;
    }
    return fac;
}

function reverseString(s: string): string {
    return s.split('').reverse().join('');
}

###rust

impl Solution {
    pub fn count_good_integers(n: i32, k: i32) -> i64 {
        use std::collections::HashSet;
        let n = n as usize;
        let k = k as i64;
        let mut fac = vec![1_i64; n + 1];
        for i in 1..=n {
            fac[i] = fac[i - 1] * i as i64;
        }

        let mut ans = 0;
        let mut vis = HashSet::new();
        let base = 10_i64.pow(((n - 1) / 2) as u32);

        for i in base..base * 10 {
            let s = i.to_string();
            let rev: String = s.chars().rev().collect();
            let full_s = if n % 2 == 0 {
                format!("{}{}", s, rev)
            } else {
                format!("{}{}", s, &rev[1..])
            };

            let num: i64 = full_s.parse().unwrap();
            if num % k != 0 {
                continue;
            }

            let mut arr: Vec<char> = full_s.chars().collect();
            arr.sort_unstable();
            let t: String = arr.iter().collect();
            if vis.contains(&t) {
                continue;
            }
            vis.insert(t);

            let mut cnt = vec![0; 10];
            for c in arr {
                cnt[c as usize - '0' as usize] += 1;
            }

            let mut res = (n - cnt[0]) as i64 * fac[n - 1];
            for &x in &cnt {
                if x > 0 {
                    res /= fac[x];
                }
            }
            ans += res;
        }

        ans
    }
}

###js

/**
 * @param {number} n
 * @param {number} k
 * @return {number}
 */
var countGoodIntegers = function (n, k) {
    const fac = factorial(n);
    let ans = 0;
    const vis = new Set();
    const base = Math.pow(10, Math.floor((n - 1) / 2));

    for (let i = base; i < base * 10; i++) {
        let s = String(i);
        const rev = reverseString(s);
        if (n % 2 === 1) {
            s += rev.substring(1);
        } else {
            s += rev;
        }

        if (parseInt(s, 10) % k !== 0) {
            continue;
        }

        const bs = Array.from(s).sort();
        const t = bs.join('');

        if (vis.has(t)) {
            continue;
        }

        vis.add(t);

        const cnt = Array(10).fill(0);
        for (const c of t) {
            cnt[parseInt(c, 10)]++;
        }

        let res = (n - cnt[0]) * fac[n - 1];
        for (const x of cnt) {
            res /= fac[x];
        }
        ans += res;
    }

    return ans;
};

function factorial(n) {
    const fac = Array(n + 1).fill(1);
    for (let i = 1; i <= n; i++) {
        fac[i] = fac[i - 1] * i;
    }
    return fac;
}

function reverseString(s) {
    return s.split('').reverse().join('');
}

时间复杂度 $({10}^m \times n \times \log n)$，空间复杂度 $O({10}^m \times n)$，其中 $m = \lfloor \frac{n - 1}{2} \rfloor$。

---

有任何问题，欢迎评论区交流，欢迎评论区提供其它解题思路（代码），也可以点个赞支持一下作者哈😄~

给你两个 正 整数 n 和 k 。

如果一个整数 x 满足以下条件，那么它被称为 k 回文 整数 。

• x 是一个 回文整数 。
• x 能被 k 整除。

如果一个整数的数位重新排列后能得到一个 k 回文整数 ，那么我们称这个整数为 好 整数。比方说，k = 2 ，那么 2020 可以重新排列得到 2002 ，2002 是一个 k 回文串，所以 2020 是一个好整数。而 1010 无法重新排列数位得到一个 k 回文整数。

请你返回 n 个数位的整数中，有多少个 好 整数。

注意 ，任何整数在重新排列数位之前或者之后 都不能 有前导 0 。比方说 1010 不能重排列得到 101 。

 

示例 1：

示例 2：

示例 3：

 

提示：

• 1 <= n <= 10
• 1 <= k <= 9

Problem: 3272. 统计好整数的数目

[TOC]

思路

先回溯找到所有可能的回文串，然后统计每个回文串的排列个数，注意排列不能0开头

Code

###Python3

@cache
def fac(x):
    if x == 0:
        return 1
    return x * fac(x-1)

class Solution:
    def countGoodIntegers(self, n: int, k: int) -> int:
        pow10 = [1] * n
        for i in range(1, n):
            pow10[i] = pow10[i - 1] * 10 % k

        st = set()
        m = (n + 1) // 2
        res = []
        def dfs(i: int, j: int) -> None:
            if i == m:
                if j == 0:
                    cur = res.copy()
                    cur += cur[:n // 2]
                    cur.sort()
                    st.add("".join(cur))

                return
            
            mn = 1 if i == 0 else 0
            for d in range(mn, 10):  
                if n % 2 and i == m - 1:  # 正中间
                    j2 = (j + d * pow10[i]) % k
                else:
                    j2 = (j + d * (pow10[i] + pow10[-1 - i])) % k
                res.append(str(d))
                dfs(i + 1, j2)
                res.pop()
            
        dfs(0, 0)
        ans = 0
        for x in st:
            cnt = Counter(x)
            f = fac(n)
            for v in cnt.values():
                f //= fac(v)
            
            # 减去0开头的
            if cnt['0'] > 0:
                f1 = fac(n-1) 
                for k, v in cnt.items():
                    if k == '0':
                        f1 //= fac(v - 1)
                    else:
                        f1 //= fac(v)
                f -= f1 
            ans += f 
        
        return ans

考虑枚举所有长为 $n$ 的回文数。

首先，知道了回文数的左半边，就知道了回文数的右半边，所以可以枚举回文数的左半边。

设 $m = \left\lfloor\dfrac{n-1}{2}\right\rfloor$，设 $\textit{base} = 10^m$。

在 $[\textit{base}, 10\cdot\textit{base})$ 范围内枚举所有长为 $n$ 的回文数的左半边。

如果回文数 $x$ 能被 $k$ 整除，那么接下来需要解决的问题有两个：

1. 计算 $x$ 有多少个不同的排列。
2. 不能重复统计。

为了保证不重复统计，可以像 49. 字母异位词分组 那样，把 $x$ 的十进制字符串 $s$ 排序，如果之前遇到过同样的字符串 $t$，那么 $s$ 生成的所有排列，$t$ 也能生成。用哈希表记录排序后的字符串，如果 $s$ 排序后在哈希表中，那么就跳过。

下面是组合数学时间。

本质上计算的是「有重复元素的排列个数」。

统计 $s$ 中的每个数字的出现次数 $\textit{cnt}$。

先填最高位。由于不能有前导零，最高位可以填的数有 $n-\textit{cnt}_0$ 个。其余 $n-1$ 个数随便排，有 $(n-1)!$ 种方案。

当然，这里面有重复的，例如 $x=34543$，其中两个 $3$ 和两个 $4$ 的排列就是重复的，由于这两个 $3$ 无法区分，两个 $4$ 无法区分，方案数要除以 $2!2!$。

综上，排列个数为

$$
\dfrac{(n-\textit{cnt}0)\cdot (n-1)!}{\prod\limits{i=0}^{9}\textit{cnt}_i!}
$$

加入答案。

具体请看 视频讲解 第三题，欢迎点赞关注~

###py

class Solution:
    def countGoodIntegers(self, n: int, k: int) -> int:
        fac = [factorial(i) for i in range(n + 1)]
        ans = 0
        vis = set()
        base = 10 ** ((n - 1) // 2)
        for i in range(base, base * 10):  # 枚举回文数左半边
            s = str(i)
            s += s[::-1][n % 2:]
            if int(s) % k:  # 回文数不能被 k 整除
                continue

            sorted_s = ''.join(sorted(s))
            if sorted_s in vis:  # 不能重复统计
                continue
            vis.add(sorted_s)

            cnt = Counter(sorted_s)
            res = (n - cnt['0']) * fac[n - 1]
            for c in cnt.values():
                res //= fac[c]
            ans += res
        return ans

###java

class Solution {
    public long countGoodIntegers(int n, int k) {
        int[] factorial = new int[n + 1];
        factorial[0] = 1;
        for (int i = 1; i <= n; i++) {
            factorial[i] = factorial[i - 1] * i;
        }

        long ans = 0;
        Set<String> vis = new HashSet<>();
        int base = (int) Math.pow(10, (n - 1) / 2);
        for (int i = base; i < base * 10; i++) { // 枚举回文数左半边
            String s = Integer.toString(i);
            s += new StringBuilder(s).reverse().substring(n % 2);
            if (Long.parseLong(s) % k > 0) { // 回文数不能被 k 整除
                continue;
            }

            char[] sortedS = s.toCharArray();
            Arrays.sort(sortedS);
            if (!vis.add(new String(sortedS))) { // 不能重复统计
                continue;
            }

            int[] cnt = new int[10];
            for (char c : sortedS) {
                cnt[c - '0']++;
            }
            int res = (n - cnt[0]) * factorial[n - 1];
            for (int c : cnt) {
                res /= factorial[c];
            }
            ans += res;
        }
        return ans;
    }
}

###cpp

class Solution {
public:
    long long countGoodIntegers(int n, int k) {
        vector<int> factorial(n + 1);
        factorial[0] = 1;
        for (int i = 1; i <= n; i++) {
            factorial[i] = factorial[i - 1] * i;
        }

        long long ans = 0;
        unordered_set<string> vis;
        int base = pow(10, (n - 1) / 2);
        for (int i = base; i < base * 10; i++) { // 枚举回文数左半边
            string s = to_string(i);
            s += string(s.rbegin() + (n % 2), s.rend());
            if (stoll(s) % k) { // 回文数不能被 k 整除
                continue;
            }

            ranges::sort(s);
            if (!vis.insert(s).second) { // 不能重复统计
                continue;
            }

            int cnt[10]{};
            for (char c : s) {
                cnt[c - '0']++;
            }
            int res = (n - cnt[0]) * factorial[n - 1];
            for (int c : cnt) {
                res /= factorial[c];
            }
            ans += res;
        }
        return ans;
    }
};

###go

func countGoodIntegers(n, k int) (ans int64) {
factorial := make([]int, n+1)
factorial[0] = 1
for i := 1; i <= n; i++ {
factorial[i] = factorial[i-1] * i
}

vis := map[string]bool{}
base := int(math.Pow10((n - 1) / 2))
for i := base; i < base*10; i++ { // 枚举回文数左半边
x := i
t := i
if n%2 > 0 {
t /= 10
}
for ; t > 0; t /= 10 {
x = x*10 + t%10
}
if x%k > 0 { // 回文数不能被 k 整除
continue
}

bs := []byte(strconv.Itoa(x))
slices.Sort(bs)
s := string(bs)
if vis[s] { // 不能重复统计
continue
}
vis[s] = true

cnt := [10]int{}
for _, c := range bs {
cnt[c-'0']++
}
res := (n - cnt[0]) * factorial[n-1]
for _, c := range cnt {
res /= factorial[c]
}
ans += int64(res)
}
return
}

复杂度分析

• 时间复杂度：$\mathcal{O}(10^m\cdot n\log n)$，其中 $m = \left\lfloor\dfrac{n-1}{2}\right\rfloor$。
• 空间复杂度：$\mathcal{O}(10^m\cdot n)$。

分类题单

如何科学刷题？

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

我的题解精选（已分类）

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

Problem: 3272. 统计好整数的数目

[TOC]

思路

枚举

回文，很容易想到折半枚举，n最大10位，折半枚举最大就5位，所以：

• 枚举回文左边
• 镜像得到右边
• 拼接成完整数字，再判断该数字能否被k整除

        # 枚举
        n_half = (n+1) // 2
        start = 10**(n_half-1)
        end = 10**n_half
        dt = set()
        for num in range(start,end,1):
            l = str(num)
            if n&1:
                r = l[:-1][::-1]
            else:
                r = l[::-1]
            
            s = l+r
            if int(s) % k == 0:
                # 去重
                dt.add(''.join(sorted(s)))

组合数学

将第一步得到的数字打乱，看可以得到多少个没有前缀0的整数。

• 枚举非0头位
• 剩下的位置塞入其它数字

        res = 0
        # 组合数学
        for s in dt:
            # 计数
            cnt = Counter(s)

            # 开头非0
            for w in '123456789':
                if cnt[w]:
                    cnt[w] -= 1
                    # 组合数学
                    t = 1
                    rest = n - 1
                    for lw in '0123456789':
                        # 剩余位中插入数字
                        t *= comb(rest,cnt[lw])
                        rest -= cnt[lw]
                    # 回溯
                    cnt[w] += 1
                    res += t

        return res

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

Code

###Python3

class Solution:
    def countGoodIntegers(self, n: int, k: int) -> int:
        '''
        打表
        折半 + 组合数字
        '''
        
        # 枚举
        n_half = (n+1) // 2
        start = 10**(n_half-1)
        end = 10**n_half
        dt = set()
        for num in range(start,end,1):
            l = str(num)
            if n&1:
                r = l[:-1][::-1]
            else:
                r = l[::-1]
            
            s = l+r
            if int(s) % k == 0:
                # 去重
                dt.add(''.join(sorted(s)))
        
        res = 0
        # 组合数学
        for s in dt:
            # 计数
            cnt = Counter(s)

            # 开头非0
            for w in '123456789':
                if cnt[w]:
                    cnt[w] -= 1
                    # 组合数学
                    t = 1
                    rest = n - 1
                    for lw in '0123456789':
                        if cnt[lw]:
                            t *= comb(rest,cnt[lw])
                            rest -= cnt[lw]
                    # 回溯
                    cnt[w] += 1
                    res += t

        return res

‌一、大型项目搭建要点‌

1. ‌架构设计与技术选型‌

   • ‌核心原则‌：强扩展性、可持续维护性、技术生态成熟度。

   • ‌典型方案‌：

     • 采用‌微前端架构‌（如qiankun），支持多团队并行开发与独立部署‌；
     • 技术栈选择‌React/Vue3+TypeScript‌，搭配‌Webpack/Vite‌构建工具，确保长期生态支持‌；
     • 集成‌SSR（服务端渲染） ‌提升SEO和首屏性能，如Next.js/Nuxt.js‌。

   • ‌案例‌：某金融平台项目采用微前端+React+TS架构，支持5年内新增10+业务模块，代码复用率达60%‌。

2. ‌开发流程与规范‌

   • ‌代码质量管控‌：

     • 强制‌ESLint/Prettier‌规范，结合‌Git Hooks‌拦截不规范提交‌；
     • 建立‌组件库‌（如Storybook），统一UI交互逻辑，降低重复开发成本‌。

   • ‌分支管理‌：

     • 采用‌GitFlow‌模式，定义feature（功能分支）、release（预发布分支）等流程‌。

3. ‌长期维护策略‌

   • ‌模块化拆分‌：按业务域划分模块（如支付、风控），通过‌Monorepo‌管理依赖‌；
   • ‌自动化运维‌：搭建‌CI/CD流水线‌（如Jenkins），支持灰度发布和回滚机制‌。

---

‌二、中短期项目（7-8个月周期）搭建要点‌

1. ‌敏捷开发与快速交付‌

   • ‌技术选型‌：

     • 选择‌轻量框架‌（如Vite+React），减少配置成本‌；
     • 集成‌低代码平台‌（如amis），实现表单/列表页快速生成‌。

   • ‌案例‌：某政务H5项目采用Vite+预置模板，2周完成核心功能开发，节省30%工时‌。

2. ‌需求管理与风险控制‌

   • ‌需求冻结机制‌：在开发中期设置‌需求评审截止点‌，避免范围蔓延‌；
   • ‌动态资源配置‌：使用‌甘特图工具‌（如Jira）可视化进度，及时调整人力分配‌。

3. ‌代码复用与灵活扩展‌

   • ‌脚手架定制‌：预置‌axios封装、权限模块、错误监控‌等基础能力‌；
   • ‌动态配置化‌：通过JSON驱动页面布局（如动态表单生成器），支持快速迭代‌。

---

‌三、通用核心注意点‌

1. ‌团队协作优化‌

   • ‌角色分工‌：明确前端开发、UI协作、测试验收流程（如Figma标注自动生成代码）‌；
   • ‌知识沉淀‌：建立‌Confluence文档库‌，记录技术决策与踩坑记录‌。

2. ‌性能与兼容性‌

   • ‌基线要求‌：

     • 兼容Chrome/Firefox/Edge最新3个版本‌；
     • 首屏加载时间≤1.5秒（3G网络）‌。

   • ‌监控体系‌：集成‌Sentry‌错误追踪+‌Lighthouse‌性能评分‌。

3. ‌安全防护‌

   • ‌XSS/CSRF防御‌：对用户输入内容强制过滤（如DOMPurify）‌；
   • ‌敏感操作验证‌：关键接口增加二次确认（如短信验证码）‌。

---

典型项目周期对比表

‌维度‌	‌大型项目（5-6年） ‌	‌中短期项目（7-8个月） ‌
技术选型	React/Vue3+TS+微前端	Vite+轻量框架+低代码
构建工具	Webpack（定制化配置）	Vite（开箱即用）
代码规范	企业级ESLint规则+Monorepo	社区标准规则+快速模板
测试策略	单元测试+集成测试+E2E	核心路径E2E测试
部署频率	按月发布（灰度策略）	按周发布（敏捷迭代）

React + TypeScript + Vite

React + TypeScript + Vite + React Router + React Redux项目脚手架模版。GitHub：react-vite-ts-template

• 很好的集成了Code Lint周边工具，支持对TS，CSS，LESS等文件的自动格式化。
• 支持PC 和 H5
• 规范化的目录结构

建议项目的前端相关文档，比如架构设计文档，模块设计文档统一收敛到docs目录下。或者如果是外部文档链接，也可以贴到docs目录里面

一、环境

• node: >=20.0.0

二、运行

• npm install
• npm run dev

三、Code Lint配置及介绍

在开始介绍Code Lint配置前，需要准备以下工作：

需要在vscode安装以下插件：

• eslint
• prettier
• editorconfig
• Stylelint

下图是Code Lint必备插件：

code lint相关工具及其作用

• eslint。负责规范并校验js代码的编写，本身不具备自动格式化功能
• commit lint。负责校验commit msg是否符合规范
• stylint。负责规范并校验css/scss/less 代码的编写。
• prettier。保存代码自动格式化
• editor config。确保大家编辑器的风格统一，比如空格啥的。确保编辑器安装了editorconfig插件，比如vscode需要安装EditorConfig
• lint stage
• husky

3.1 vscode 配置

vscode基础配置，比如保存代码自动格式化等基础配置，均需要在./vscode/settings.json文件修改，同时这份文件需要提交上去，确保团队基础配置统一。

3.2 eslint + prettier

需要确保vscode安装了eslint和prettier插件。

eslint负责规范并校验js代码的编写，本身不具备自动格式化功能。ctrl+s保存代码时，prettier会自动格式化代码，比如下图，eslint提示import语句的顺序不对，同时提示useEffect，useState没有使用到。当ctrl + s保存代码时，prettier会自动格式化这些代码。

如果项目使用的ESLint可能会出现与 Prettier 的格式化规则冲突的情况。为了避免这种情况,可以使用 eslint-config-prettier 来禁用所有与 Prettier 冲突的 ESLint 规则

3.3 stylelint + prettier

需要确保vscode安装了Stylelint和prettier插件。

stylelint负责规范并校验css/scss/less 代码的编写，本身不具备自动格式化的功能呢。ctrl + s保存代码时，prettier会自动格式化代码，比如下图，stylelint提示height的位置不对，因此保存代码时，prettier会自动调整这些规则的顺序。

3.4 editorconfig

需要确保vscode安装了editorconfig for vscode插件，并在根目录下创建.editorconfig文件。

主要作用：

• 确保团队成员在不同的编辑器中使用相同的缩进、换行符、字符编码等规则。
• 避免因代码风格不一致导致的冲突或混乱

比如indent_size指定缩进的大小(2个空格或者4个空格)

比如下面是indent_size指定为2时，按tab键的空格数

比如下面是indent_size指定为4时，按tab键的空格数

3.5 lintstaged + husky

lint-staged 是一个工具，它允许你在 Git 提交前对暂存区（即通过 git add 的文件）运行预定义的代码检查任务，如 ESLint、Prettier 等。它的核心功能是只对暂存区的文件进行检查，避免对未修改的文件进行不必要的检查

为什么使用 lint-staged：

• 高效的代码检查：只对暂存区的文件进行检查，避免了全量检查，提高了效率。
• 提高代码质量：在提交前自动检查代码，减少低质量代码被提交的概率。
• 集成流畅：与 husky 等工具结合，能够自动化工作流，减少手动操作

执行npm install后，默认会在项目根目录下新建.husky文件目录，需要在.husky下面新增两个文件，才能使得git commit时自动跑lint校验

• .husky/commit-msg
• .husky/pre-commit

如下图所示，当代码中存在错误时，代码就没法提交上去

因此，在开发的过程中，如果有eslint的告警，要及时修复，避免在提交的时候遇到麻烦。

3.6 commitlint + husky

commitlint 是一个用于校验 Git 提交消息是否符合规范的工具。它可以帮助团队维护一致的提交消息格式，从而提高项目的可维护性和协作效率

主要功能：

• 格式检查：确保每条提交信息都遵循预定义的格式，例如使用特定的提交类型标签（如 fix、feat、docs 等）。
• 一致性维护：通过强制执行一致的提交信息格式，减少不同开发者之间的差异。
• 文档生成：基于提交信息生成项目变更日志，便于团队成员了解项目的历史变更。
• 自动化测试：可以在持续集成/持续部署（CI/CD）流程中集成，确保每次提交都符合格式要求，从而提高代码质量

背景

最近需要制作一个基于aar的Flutter插件，但遇到了一些问题。 我们假设插件名称叫作my_plugin。以前我的解决方案是把aar文件导入my_plugin/android/libs中，然后在my_plugin/android/build.gradle做如下修改：

rootProject.allprojects {
    repositories {
        google()
        jcenter()
        flatDir {
            dirs project(':my_plugin').file('libs')
        }
    }
}

dependencies {
    implementation fileTree(include: ['*.aar'], dir: 'libs')
}

但我很快发现，这条路现在行不通：

Execution failed for task 'xxxx'.
> Direct local .aar file dependencies are not supported when building an AAR. 
The resulting AAR would be broken because the classes and Android resources from any local .aar 
file dependencies would not be packaged in the resulting AAR. Previous versions of the Android 
Gradle Plugin produce broken AARs in this case too (despite not throwing this error). The 
following direct local .aar file dependencies of the xxxx project caused this error: 
______.aar

很快我又换了一个姿势，同样使用flatDir，但这次我改用了compileOnly

rootProject.allprojects {
    repositories {
        google()
        mavenCentral()
        flatDir {
            dirs project(':my_plugin').file('libs')
        }
    }
}

dependencies {
    compileOnly fileTree(include: ['*.aar'], dir: 'libs')
}

但也引起了一个小小的麻烦，这种方式需要在宿主app中把aar文件再次导入到对应的libs文件下，然后又要在build.gradle中添加 implementation fileTree(include: ['*.aar'], dir: 'libs')。对于使用者来说不友好，而且flatDir这种形式官方其实是不太推荐的（你会在控制台看到一些警告）。所以怎么相对优雅地解决这个问题？最快的方法当然是发布到远程maven之类的仓库了。谁都能想得到，但很实际开发中并不具备发布到远程maven的条件。

既然远程maven不行，那本地的maven是不是就可以了？

姿势一

第一种方式是直接借用maven-publish插件了。在my_plugin/android/build.gradle写点代码：

//define this
String mavenLocalPath = project(":my_plugin").mkdir("m2repository").absolutePath


rootProject.allprojects {
    repositories {
        google()
        mavenCentral()
        maven {
            url mavenLocalPath
        }
    }
}


//apply plugin
apply plugin: "maven-publish"


publishing {
  publications {
    release(MavenPublication) {
            groupId = 'com.my-company'
            artifactId = 'my-library'
            version = '1.0'
            artifact "path/to/aar"
    }
  }
  repositories {
    maven {
      name = 'myrepo'
      url = mavenLocalPath
    }
  }
}

dependencies {
    implementation "com.my-company:my-library:1.0"
}

然后使用gradle运行publish任务即可：

./gradlew publish

//or 
gradle publish

然后你会发现在my_plugin/m2repository目录下生成了相关文件，大功告成！当有新版本时，我们只需再次publish即可。

姿势二

第一种方是借用了maven-publish插件，当然我们也可以手搓一个类似功能的，假设我们把aar放到了my_plugin/android/libs下：

import java.security.MessageDigest
import java.security.NoSuchAlgorithmException

//define this
String mavenLocalPath = project(":my_plugin").mkdir("m2repository").absolutePath


rootProject.allprojects {
    repositories {
        google()
        mavenCentral()
        maven {
            url mavenLocalPath
        }
    }
}

task useAar {
    File file = project.file("libs")
    if (file.exists() && file.isDirectory()) {
        file.listFiles(new FileFilter() {
            @Override
            boolean accept(File pathname) {
                return pathname.name.endsWith(".aar")
            }
        }).each { item ->
            String aarName = item.name.substring(0, item.name.length() - 4)
            String[] aarInfo = aarName.split("-")
            String sha1 = getFileSha1(item)
            String md5 = getFileMD5(item)
            String fromStr = item.path
            String intoStr = aarPath + "/" + aarInfo[0].replace(".", "/") + "/" + aarInfo[1] + "/" + aarInfo[2]
            String newName = aarInfo[1] + "-" + aarInfo[2] + ".aar"

            project.copy {
                from fromStr
                into intoStr
                rename(item.name, newName)
            }

            project.file(intoStr + "/" + newName + ".md5").write(md5)
            project.file(intoStr + "/" + newName + ".sha1").write(sha1)

            String pomPath = intoStr + "/" + newName.substring(0, newName.length() - 4) + ".pom"
            project.file(pomPath).write(createPomStr(aarInfo[0], aarInfo[1], aarInfo[2]))
            project.file(pomPath + ".md5").write(getFileMD5(project.file(pomPath)))
            project.file(pomPath + ".sha1").write(getFileSha1(project.file(pomPath)))

            String metadataPath = project.file(intoStr).getParentFile().path + "/maven-metadata.xml"
            project.file(metadataPath).write(createMetadataStr(aarInfo[0], aarInfo[1], aarInfo[2]))
            project.file(metadataPath + ".md5").write(getFileMD5(project.file(metadataPath)))
            project.file(metadataPath + ".sha1").write(getFileSha1(project.file(metadataPath)))
            dependencies {
                implementation "${aarInfo[0]}:${aarInfo[1]}:${aarInfo[2]}"
            }
        }
    }
}

public static String createMetadataStr(String groupId, String artifactId, String version) {
    return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<metadata>\n" +
            "  <groupId>$groupId</groupId>\n" +
            "  <artifactId>$artifactId</artifactId>\n" +
            "  <versioning>\n" +
            "    <release>$version</release>\n" +
            "    <versions>\n" +
            "      <version>$version</version>\n" +
            "    </versions>\n" +
            "    <lastUpdated>${new Date().format('yyyyMMdd')}000000</lastUpdated>\n" +
            "  </versioning>\n" +
            "</metadata>\n"
}

public static String createPomStr(String groupId, String artifactId, String version) {
    return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<project xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd\" xmlns=\"http://maven.apache.org/POM/4.0.0\"\n" +
            "    xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n" +
            "  <modelVersion>4.0.0</modelVersion>\n" +
            "  <groupId>$groupId</groupId>\n" +
            "  <artifactId>$artifactId</artifactId>\n" +
            "  <version>$version</version>\n" +
            "  <packaging>aar</packaging>\n" +
            "</project>\n"
}

public static String getFileSha1(File file) {
    FileInputStream input = null;
    try {
        input = new FileInputStream(file);
        MessageDigest digest = MessageDigest.getInstance("SHA-1");
        byte[] buffer = new byte[1024 * 1024 * 10];

        int len = 0;
        while ((len = input.read(buffer)) > 0) {
            digest.update(buffer, 0, len);
        }
        String sha1 = new BigInteger(1, digest.digest()).toString(16);
        int length = 40 - sha1.length();
        if (length > 0) {
            for (int i = 0; i < length; i++) {
                sha1 = "0" + sha1;
            }
        }
        return sha1;
    }
    catch (IOException e) {
        System.out.println(e);
    }
    catch (NoSuchAlgorithmException e) {
        System.out.println(e);
    }
    finally {
        try {
            if (input != null) {
                input.close();
            }
        }
        catch (IOException e) {
            System.out.println(e);
        }
    }
}

public static String getFileMD5(File file) {
    FileInputStream input = null;
    try {
        input = new FileInputStream(file);
        MessageDigest digest = MessageDigest.getInstance("MD5");
        byte[] buffer = new byte[1024 * 1024 * 10];

        int len = 0;
        while ((len = input.read(buffer)) > 0) {
            digest.update(buffer, 0, len);
        }
        String md5 = new BigInteger(1, digest.digest()).toString(16);
        int length = 32 - md5.length();
        if (length > 0) {
            for (int i = 0; i < length; i++) {
                md5 = "0" + md5;
            }
        }
        return md5;
    }
    catch (IOException e) {
        System.out.println(e);
    }
    catch (NoSuchAlgorithmException e) {
        System.out.println(e);
    }
    finally {
        try {
            if (input != null) {
                input.close();
            }
        }
        catch (IOException e) {
            System.out.println(e);
        }
    }
}

结束语

当然方式可能有很多，最后我也只用了第一种方式，如果大家有更好的招，欢迎指出~

Turbopack 是 Vercel 推出的一款高性能前端打包工具，旨在显著提升前端开发过程中服务器启动和模块热更新（HMR）的速度。

核心特性

• 基于 Rust 构建：利用 Rust 语言出色的性能和内存管理能力，充分发挥多核 CPU 优势，能高效处理大量文件和复杂模块，为大型项目提供快速构建和热更新能力。同理 Vite 借助了一些用 Rust 编写的工具和库来提升性能
• 智能增量更新：具备智能缓存机制，可精准识别项目中发生变化的模块，仅对修改部分重新打包，避免重复工作，极大提高构建效率。
• 多框架兼容：与众多主流前端框架良好集成，如 Next.js、React、Vue 等，为不同技术栈项目提供统一高效的打包解决方案。

优势体现

• 开发效率提升：显著缩短开发服务器启动时间和模块热更新时间，让开发者能更快看到代码修改效果，专注于编码工作。
• 适配 Next.js：作为 Next.js 官方推荐的打包工具，与 Next.js 深度集成，能更好支持 Next.js 的服务器端渲染（SSR）、静态站点生成（SSG）等特性。

局限性

• 社区资源不足：作为较新的工具，相比 Webpack、Vite 等成熟工具，社区资源和文档不够丰富，开发者遇到问题时解决难度较大。
• 特定场景表现一般：在某些特定场景下，其性能优势不明显甚至不如其他工具。

应用场景

• 大型项目：对于文件和模块众多的大型前端项目，Turbopack 的高性能可充分发挥，有效提升开发效率。
• Next.js 项目：天然适配 Next.js 生态，能为使用 Next.js 进行开发的项目提供高效打包支持。

总体而言，Turbopack 凭借其高性能和多框架兼容性，为前端开发带来了新的选择，尤其在大型项目和 Next.js 项目中具有显著优势。不过，由于其社区尚在发展中，在使用时可能会面临一些挑战。

---

尤雨溪作为 Vite 的核心开发者，对 Turbopack 的评价主要围绕性能基准测试和技术实现细节展开，既有对其技术创新的认可，也指出了宣传与实际场景的差异。以下是具体分析：

一、对 Turbopack 性能的客观验证

尤雨溪曾通过实际测试直接对比 Vite 与 Turbopack 的 HMR（模块热更新）性能。他创建了一个名为 vite-vs-next-turbo-hmr 的测试项目，模拟包含 1000 个组件的复杂应用，并在 M1 MacBook Pro 上进行测试。结果显示：

• 客户端模式：Turbopack 的 HMR 速度确实优于 Vite（根组件更新平均 334.6ms vs. Vite 的 606ms，子组件 84.4ms vs. 171.8ms）。
• 服务器组件（RSC）模式：Vite 的表现反而更优（根组件 836.4ms vs. Turbopack 的 782ms）。

这表明 Turbopack 在特定场景下（如客户端渲染的大型项目）确实有显著优势，但并非普遍适用。

二、对 Vercel 宣传的质疑与争议

尤雨溪对 Turbopack 最初宣称的“比 Vite 快 10 倍”提出了方法论层面的批评：

1. 测试条件差异：Vercel 的基准测试中，Vite 使用默认的 Babel 进行 React 转换，而 Turbopack 依赖更快的 SWC（Rust 实现）。若 Vite 切换为 SWC，性能差距会大幅缩小。
2. 四舍五入问题：Vercel 将 Turbopack 的 15ms 四舍五入为 0.01s，而 Vite 的 87ms 显示为 0.09s，人为放大了差距。
3. 场景局限性：Turbopack 的“10 倍优势”仅在模块数量超过 30k 时成立，这对绝大多数项目来说并不现实。

尤雨溪强调，用户更关心端到端的 HMR 体验（从保存文件到浏览器更新），而非单纯的“模块评估时间”。他认为 Vercel 的营销存在误导性，呼吁更透明的基准测试。

三、技术层面的交流与认可

尽管存在争议，尤雨溪与 Vercel 团队保持了技术对话：

• Bug 反馈：Turbopack 官方博客提到，尤雨溪帮助他们发现并纠正了基准测试中的错误（如四舍五入问题），并感谢其贡献。
• 架构差异：尤雨溪指出，Turbopack 的增量计算引擎（基于 Rust）在处理超大型项目时确实有优势，但其设计更偏向“黑箱优化”，而 Vite 强调灵活性和生态兼容性（如支持 Vue、React、Svelte 等多框架）。

四、对前端工具生态的态度

尤雨溪多次强调，不同工具适用于不同场景：

• Turbopack 的定位：作为 Next.js 的官方打包工具，其性能优化与 Next.js 的架构（如 RSC）深度绑定，更适合 React 生态的大型项目。
• Vite 的优势：Vite 以原生 ESM 为核心，注重开发体验的“开箱即用”和跨框架支持，尤其适合中小型项目和需要高度定制化的场景。

他认为，前端工具的竞争推动了技术进步，但开发者应根据项目需求选择工具，而非盲目追求“最快”。

总结

尤雨溪对 Turbopack 的评价呈现出理性平衡的态度：

• 认可其技术创新：Turbopack 在 Rust 性能、增量计算等方面的突破值得肯定，尤其在 Next.js 生态中表现突出。
• 批评过度营销：Vercel 的“10 倍快”宣传存在测试条件不透明、场景局限性等问题，可能误导用户。
• 强调生态多样性：不同工具服务于不同需求，开发者应根据项目特点选择，而非陷入“工具之争”。

这一立场体现了尤雨溪作为开源项目维护者对技术中立性的坚持，以及对用户实际需求的关注。

Spring Framework 是一个开源的、功能强大的 Java框架，旨在简化企业级 Java开发。它通过提供全面的基础设施支持，使开发者能够专注于业务逻辑的实现。Spring 框架由多个模块组成，如 Spring Core、Spring MVC、Spring Data、Spring Security等。开发者可以根据项目需求，选择性地引入和使用这些模块，构建灵活且可扩展的应用。

虽然 Spring 功能强大，但其配置和设置过程可能繁琐。Spring Boot 建立在 Spring Framework 之上，简化了 Spring 应用的配置和部署。它并不是另一个框架，而是一个增强Spring Framework的配置和启动工具。

Spring 和 SpringBoot 的关系有点类似于 Node.js 中 Koa 与 Egg.js 的关系，Spring 和 Koa 都是基础性的框架，提供了核心功能，但需要更多定制；Spring Boot 和 Egg.js 在各自的基础框架之上进行了增强，提供了更多的预配置和自动化工具，帮助开发者快速上手并提高效率。

使用 Spring Initializr 创建 SpringBoot 项目

Spring Initializr 是一个在线工具，用于生成Spring Boot项目的基础结构

点击 Generate 按钮，下载生成的项目压缩包并解压，即可得到如下的项目结构

hellospring
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com.example.hellospring
│   │   │       ├── HellospringApplication.java
│   │   │       └── controller
│   │   │           └── HelloController.java
│   │   └── resources
│   │       ├── application.properties
│   │       └── static
│   │           └── ...
│   └── test
│       └── java
│           └── com.example.hellospring
│               └── HellospringApplicationTests.java
├── mvnw
├── mvnw.cmd
├── pom.xml
└── README.md

• src/main/java：Java 源代码目录
• src/main/resources：资源文件目录，如配置文件、静态资源等
• pom.xml：Maven 项目配置文件
• mvnw & mvnw.cmd：Maven Wrapper 脚本，确保团队使用相同版本的 Maven

Controller

既然是 Web 应用请求自然先到 Controller，Controller 负责处理 HTTP 请求，它们接收请求，调用相应的服务，并返回响应

// src/main/java/com/example/hellospring/controller/HelloController.java
package com.example.hellospring.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

@RestController 用于将类标记为 Spring MVC 控制器，并自动将控制器中的方法返回的对象序列化为 JSON 或 XML 格式的响应体，它是 @Controller 和 @ResponseBody 注解的组合

• @Controller: 标记一个类作为控制器，处理 HTTP 请求
• @ResponseBody: 指示控制器方法的返回值应该直接写入 HTTP 响应体，而不是返回一个视图

@GetMapping 是@RequestMapping(method = RequestMethod.GET) 的简写，用来处理 HTTP GET 请求。sayHello 方法使用 @GetMapping("/hello") 注解，这意味着该方法会处理 /hello 的 GET 请求

通过这些注解，Spring 提供了直观和简洁的方法来定义控制器的请求映射和响应处理，大大简化了开发 RESTful 服务的工作

构建一个简单的 REST API

为了更好地理解 Spring Boot 的工作机制，通过一个简单的示例项目，构建一个 RESTful API，实现用户的 CRUD 操作

创建文件

├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── com
    │   │       └── example
    │   │           └── hellospring
    │   │               ├── HellospringApplication.java
    │   │               ├── controller
    │   │               │   └── UserController.java
    │   │               ├── model
    │   │               │   └── User.java
    │   │               └── repository
    │   │                   └── UserRepository.java
    │   └── resources
    │       ├── application.properties
    │       ├── static
    │       └── templates
    └── test

添加必要依赖

在 pom.xml添加依赖

<!-- Spring Boot Starter Web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- Spring Data JPA -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<!-- H2 Database -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

• spring-boot-starter-web：用于快速启动和构建基于 Spring MVC 的 Web 应用程序。这个 Starter 包含了构建 Web 应用程序所需的常用依赖和配置，简化了开发过程
  • Spring MVC：提供构建 Web 应用的基础架构，支持 MVC 架构设计模式，帮助开发者创建 Web 控制器、服务和 View 层
  • Embedded Servers：自带嵌入式服务器（如 Tomcat、Jetty、Undertow），使应用可以独立运行，不需要额外安装外部服务器
  • RESTful Services：支持创建 RESTful 风格的 Web 服务和 API，非常适合构建轻量级服务
  • JSON 处理：默认集成 Jackson 库，用于处理 JSON 数据的序列化和反序列化
  • 数据验证：支持使用 Java Bean Validation API 进行数据验证
  • 内容协商：提供内容协商机制，可以根据客户端请求的 Accept 头返回不同格式（如 JSON、XML）的响应

• spring-boot-starter-data-jpa：用于简化基于 Java Persistence API (JPA) 的数据访问层开发，它集成了 Spring Data JPA 和 Hibernate ORM 等常用组件，使得与数据库的交互更加简单高效
• com.h2database：是 Maven 依赖的一个组 ID，对应的是 H2 数据库，H2 是一种轻量级的嵌入式关系型数据库。H2 数据库因为其小巧、易于使用以及内存模式的支持，常常被用作开发、测试阶段的内存数据库

定义 Entity

在 Java 的持久化领域中，Entity 是一个非常重要的概念。实体类用来表示一个数据库表。每个实体类的实例，即一个对象，通常对应数据库表中的一行记录

• @Entity：表明该类是一个实体，需要持久化
• @Table：用于指定实体类对应的数据库表名，如果没有这个注解，默认表名是实体类的名字
• @Id：指定实体的主键字段
• @Column：用于指定实体类的某个字段对应于数据库表的特定列

实体类需要一个无参数构造函数，以便 JPA 提供的工具来构造此对象的实例

// src/main/java/com/example/hellospring/model/User.java
package com.example.hellospring.model;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 主键的生成策略
    private Long id;

    private String name;
    private String email;

    // 构造器
    public User() {}

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // Getters 和 Setters

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    // toString 方法（可选）
    @Override
    public String toString() {
        return "User{id=" + id + ", name='" + name + "', email='" + email + "'}";
    }
}

创建 Repository

Repository 接口抽象化数据访问层，负责与数据库进行交互，执行 CRUD 操作，Spring Data JPA 自动生成实现类，简化数据访问逻辑

• CrudRepository：定义了一些通用的 CRUD 操作方法。如 save()、findById()、findAll()、deleteById() 等
• JpaRepository：继承自 CrudRepository，提供了更多 JPA 相关的功能，例如批量操作
• PagingAndSortingRepository：扩展自 CrudRepository，添加了分页和排序功能的方法

// src/main/java/com/example/hellospring/repository/UserRepository.java
package com.example.hellospring.repository;

import com.example.hellospring.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // 可以在这里定义自定义查询方法
}

编写 Controller

在传统的 Java 编程中，一个类依赖于另一个类时，通常需要明确地创建依赖对象，而在 Spring 中，框架自动决定类中依赖的对象，并创建和注入这些对象，这个过程被称为自动装配。

@Autowired 用于实现自动装配，告诉 Spring 要在上下文中找到被标注的依赖类型的 Bean，并将其注入到注解所在的位置

// src/main/java/com/example/hellospring/controller/UserController.java
package com.example.hellospring.controller;

import com.example.hellospring.model.User;
import com.example.hellospring.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    
    private final UserRepository userRepository;
    
    @Autowired
    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    // 创建用户
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }
    
    // 获取所有用户
    @GetMapping
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
    
    // 根据ID获取用户
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found"));
    }
    
    // 更新用户
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User updatedUser) {
        return userRepository.findById(id)
                .map(user -> {
                    user.setName(updatedUser.getName());
                    user.setEmail(updatedUser.getEmail());
                    return userRepository.save(user);
                })
                .orElseThrow(() -> new RuntimeException("User not found"));
    }
    
    // 删除用户
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }
}

配置数据库访问

application.properties 或 application.yml 用于配置应用的各种参数，如数据库连接、服务器端口等

# src/main/resources/application.properties

spring.application.name=hellospring

# Server Configuration
server.port=8080

# H2 Database Configuration (内存型数据库，方便测试)
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update

# H2 Console Configuration
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

项目启动后可以通过 http://localhost:8080/h2-console 可视化访问数据库

测试

创建用户

curl -X POST http://localhost:8080/users \
         -H "Content-Type: application/json" \
         -d '{"name":"Alice","email":"alice@example.com"}'
         
curl -X POST http://localhost:8080/users \
     -H "Content-Type: application/json" \
     -d '{"name":"Charlie","email":"charlie@example.com"}'

获取所有用户

curl -X GET http://localhost:8080/users

获取单个用户

curl -X GET http://localhost:8080/users/2

更新用户

curl -X PUT http://localhost:8080/users/1 \
         -H "Content-Type: application/json" \
         -d '{"name":"Alice Smith","email":"alice.smith@example.com"}'

删除用户

curl -X DELETE http://localhost:8080/users/1

自动化构建与热部署

Spring Boot DevTools 提供了自动重启和热部署功能，类似于前端的热模块替换（HMR），可以大幅提升开发效率

<!-- pom.xml -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runtime</scope>
  <optional>true</optional>
</dependency>

为了避免在服务环境启用，可以在 pom.xml 的 build 部分添加以下配置

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludeDevtools>true</excludeDevtools>
            </configuration>
        </plugin>
    </plugins>
</build>

如果使用 IntelliJ IDEA 还需要做几个设置

前言

TypeScript是现代前端和Node.js项目中非常受欢迎的一种类型化JavaScript超集语言。而 tsconfig.json文件是TypeScript项目的配置核心，它定义了项目编译的行为和规则。了解并掌握 tsconfig.json的配置选项对于提高开发效率、构建可靠的类型系统以及适应多种运行环境有着极大的帮助。

本文将对tsconfig.json文件进行全面解析，涵盖从基础到高级的各类配置项，并结合实际项目的应用场景，帮助读者构建属于自己的TypeScript编译策略。

一、什么是tsconfig.json？

tsconfig.json是TypeScript项目的配置文件，用于告知编译器如何编译项目中的代码。它一般位于项目根目录中，TypeScript编译器tsc会默认在当前目录中查找该文件。如果存在，则会根据其定义的选项执行编译流程。

一个最简单的tsconfig.json文件可能如下：

{
  "compilerOptions": {
    "target": "ES6"
  }
}

这段配置表示将TypeScript编译为ES6的JavaScript代码。

二、编译选项compilerOptions

compilerOptions是tsconfig.json的核心部分，几乎所有与编译行为相关的配置项都集中在此对象中。将其按照功能划分为几类进行逐项解析。

2.1 编译目标与模块系统配置

2.1.1 target

定义编译输出的JavaScript版本。可选值包括：ES3、ES5、ES6/ES2015、ES2016、ES2017、...、ESNext。

{
  "compilerOptions": {
    "target": "ES2020"
  }
}

示例说明：使用可选链和空值合并操作符的代码可在ES2020及以上版本中保留原样。

const config = settings?.database?.host ?? 'localhost';

如果将target设置为ES5，该语法将被降级处理。

2.2.2 module

指定模块系统的种类。可选值包括：CommonJS、ES6、UMD、AMD、System、None。

{
  "compilerOptions": {
    "module": "CommonJS"
  }
}

适用于Node.js环境。

import fs from 'fs';

2.2.3 moduleResolution

模块解析策略，决定import路径如何被定位。

• classic：传统TypeScript解析方式
• node：Node.js风格的模块解析方式（推荐）

{
  "compilerOptions": {
    "moduleResolution": "node"
  }
}

示例说明：

import { loadConfig } from './config';

编译器将尝试解析以下路径：

./config.ts
./config.tsx
./config.d.ts
./config/index.ts

2.2 源文件与输出配置

2.2.1 outDir

编译后的JavaScript文件输出目录。

{
  "compilerOptions": {
    "outDir": "./dist"
  }
}

2.2.2 rootDir

源文件根目录。

{
  "compilerOptions": {
    "rootDir": "./src"
  }
}

这样可以保持源码结构的清晰性：

src/
  app.ts
  lib/
    utils.ts
↓----------- 编译输出--------------↓
dist/
  app.js
  lib/
    utils.js

2.2.3 declaration

是否生成类型声明文件.d.ts。

{
  "compilerOptions": {
    "declaration": true
  }
}

示例：

export function greet(name: string): string {
  return `Hello, ${name}`;
}

将生成：

// greet.d.ts
export declare function greet(name: string): string;

2.3 严格模式与类型检查

2.3.1 strict

开启TypeScript严格模式，一次性启用以下检查：

• strictNullChecks
• noImplicitAny
• strictFunctionTypes
• strictBindCallApply
• strictPropertyInitialization
• alwaysStrict

{
  "compilerOptions": {
    "strict": true
  }
}

建议总是开启此项以获得最佳的类型安全保障。

2.3.2 noImplicitAny

禁止隐式any类型。

function calculate(x, y) {
  return x + y;
}

开启后会提示：参数x和y类型不明确。

修改为：

function calculate(x: number, y: number): number {
  return x + y;
}

2.3.3 strictNullChecks

开启后，null和undefined必须显式处理。

function getLength(str?: string) {
  return str.length; // Error!
}

修改方式：

function getLength(str?: string) {
  return str?.length ?? 0;
}

2.4 增量构建与缓存配置

2.4.1 incremental

启用增量编译。

{
  "compilerOptions": {
    "incremental": true
  }
}

首次编译后生成.tsbuildinfo缓存文件，加快下次编译速度。

2.5 Source Map 与调试配置

2.5.1 sourceMap

是否生成.map文件用于调试。

{
  "compilerOptions": {
    "sourceMap": true
  }
}

2.5.2 inlineSources

将源代码嵌入到Source Map中。

{
  "compilerOptions": {
    "inlineSources": true
  }
}

此配置有助于线上调试时查看源代码内容。

2.6. 模块路径映射与解析

2.6.1 baseUrl

配置模块导入时的基础目录。

{
  "compilerOptions": {
    "baseUrl": "./src"
  }
}
import { log } from 'utils/logger';

2.6.2 paths

用于设置路径别名。

{
  "compilerOptions": {
    "paths": {
      "@components/*": ["components/*"],
      "@models/*": ["models/*"]
    }
  }
}

实际代码中：

import Header from '@components/Header';

三、项目结构相关选项

3.1 include

指定需要编译的文件路径或模式。

{
  "include": ["src/**/*"]
}

3.2 exclude

指定需要排除的文件路径或模式。

{
  "exclude": ["node_modules", "dist"]
}

3.3 files

精确指定要编译的文件。

{
  "files": ["src/index.ts"]
}

不推荐大项目使用该方式。

四、类型声明相关选项

4.1 typeRoots & types

{
  "compilerOptions": {
    "typeRoots": ["./types"],
    "types": ["node", "jest"]
  }
}

这将只包含./types目录下的.d.ts声明文件，以及@types/node、@types/jest类型。

五、实验性功能支持

5.1 experimentalDecorators

启用装饰器支持：

{
  "compilerOptions": {
    "experimentalDecorators": true
  }
}
function Log(target: any, key: string) {
  console.log(`Accessed property: ${key}`);
}

class User {
  @Log
  name: string;
}

六、高级编译优化

6.1 skipLibCheck

跳过node_modules中类型检查，提升编译速度。

{
  "compilerOptions": {
    "skipLibCheck": true
  }
}

6.2 forceConsistentCasingInFileNames

强制一致的文件名大小写。

{
  "compilerOptions": {
    "forceConsistentCasingInFileNames": true
  }
}

七、配置继承 extends

支持继承其他配置文件。

{
  "extends": "./tsconfig.base.json",
  "compilerOptions": {
    "outDir": "./build"
  }
}

这样可以拆分通用配置与项目差异，提高可维护性。

八、常见项目模板

8.1 React项目配置模板

{
  "compilerOptions": {
    "target": "ES6",
    "module": "ESNext",
    "jsx": "react-jsx",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "baseUrl": "./src",
    "paths": {
      "@/*": ["*"],
      "@components/*": ["components/*"]
    }
  },
  "include": ["src"],
  "exclude": ["node_modules"]
}

总结

tsconfig.json是TypeScript项目的基础核心配置文件，熟悉其配置项可以帮助开发者更灵活地管理项目结构、提升开发体验、保障代码质量。通过合理组合使用各类配置项，我们可以根据项目需求定制出高效可靠的编译方案。希望本文能为你深入掌握TypeScript项目配置打下坚实基础。

后语

小伙伴们，如果觉得本文对你有些许帮助，点个👍或者➕个关注再走吧^_^ 。另外如果本文章有问题或有不理解的部分，欢迎大家在评论区评论指出，我们一起讨论共勉。

在进行以下操作之前，请确保已完成之前文章中提到的 源码拉取及编译 部分。

如果已顺利完成相关配置，即可继续执行后续操作。

---

目标

在 Chromium 中添加一个全局变量 myCode，值为 "你好！我是来自C++的字符串"，并通过 JavaScript 的 console.log(window.myCodeApi.myCode()) 直接访问。

实现步骤

步骤 1：定义全局变量

在 src/base 模块中定义全局变量 myCode，以便在整个 Chromium 项目中复用

在src/base目录下，创建文件：my_globals.h

文件内容：

#ifndef BASE_MY_GLOBALS_H_
#define BASE_MY_GLOBALS_H_

#include <string>

namespace base {
extern const char* const kMyCode;
}

#endif

base目录下创建文件：my_globals.cc

文件内容：

#include "base/my_globals.h"

namespace base {
const char* const kMyCode = "你好！我是来自C++的字符串";
}

修改 base/BUILD.gn

文件路径： src/base/BUILD.gn 操作： 在 component("base") 的 sources 列表中添加新文件的文件名

步骤 2：创建 JavaScript 绑定

在 src/content/renderer 目录中，创建文件：my_code_binding.h

文件内容：

#ifndef CONTENT_RENDERER_MY_CODE_BINDING_H_
#define CONTENT_RENDERER_MY_CODE_BINDING_H_

#include "v8/include/v8.h"

namespace content {

class MyCodeBinding {
 public:
  // 安装绑定到指定的 V8 上下文中
  static void Install(v8::Local<v8::Context> context);

 private:
  // 获取 my_code 值的 JavaScript 函数
  static void GetMyCode(const v8::FunctionCallbackInfo<v8::Value>& args);
};
}

#endif

在 src/content/renderer 目录中，创建文件：my_code_binding.cc

#include "content/renderer/my_code_binding.h"

#include "base/my_globals.h"
#include "third_party/blink/public/web/blink.h"
#include "v8/include/v8.h"

namespace content {

void MyCodeBinding::Install(v8::Local<v8::Context> context) {
  // 从 context 获取 Isolate
  v8::Isolate* isolate = context->GetIsolate();
  v8::HandleScope handle_scope(isolate);
  v8::Local<v8::Object> global = context->Global();
  v8::Local<v8::Object> my_code_api = v8::Object::New(isolate);
  my_code_api->Set(
      context,
      v8::String::NewFromUtf8(isolate, "myCode").ToLocalChecked(),
      v8::Function::New(context, &MyCodeBinding::GetMyCode).ToLocalChecked())
      .Check();

  global->Set(
      context,
      v8::String::NewFromUtf8(isolate, "myCodeApi").ToLocalChecked(),
      my_code_api)
      .Check();
}

void MyCodeBinding::GetMyCode(const v8::FunctionCallbackInfo<v8::Value>& args) {
  v8::Isolate* isolate = args.GetIsolate();
  v8::HandleScope handle_scope(isolate);
  args.GetReturnValue().Set(
      v8::String::NewFromUtf8(isolate, base::kMyCode)
          .ToLocalChecked());
}

}

修改 content/renderer/BUILD.gn

文件路径： src/content/renderer/BUILD.gn 操作： 在 target(link_target_type, "renderer") 的 sources 列表中添加新文件

步骤 3：绑定到 RenderFrameImpl

在 RenderFrameImpl 中调用绑定逻辑，将 myCode 属性安装到脚本上下文中

修改文件路径：src/content/renderer/render_frame_impl.cc

在文件顶部添加 my_code_binding.h 头文件，可以按文件头字母顺序添加

#include "content/renderer/my_code_binding.h"

在RenderFrameImpl::DidCreateScriptContext中添加如下代码

void RenderFrameImpl::DidCreateScriptContext(v8::Local<v8::Context> context,
                                             int world_id) {
   // 新增代码
  if (world_id == 0) {
    MyCodeBinding::Install(context);
  }
  // 新增代码

  TRACE_EVENT_WITH_FLOW0("navigation",
                         "RenderFrameImpl::DidCreateScriptContext",
                         TRACE_ID_LOCAL(this),
                         TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
  v8::MicrotasksScope microtasks(GetAgentGroupScheduler().Isolate(),
                                 context->GetMicrotaskQueue(),
                                 v8::MicrotasksScope::kDoNotRunMicrotasks);
  if (((enabled_bindings_.Has(BindingsPolicyValue::kMojoWebUi)) ||
       enable_mojo_js_bindings_) &&
      IsMainFrame() && world_id == ISOLATED_WORLD_ID_GLOBAL) {
    // We only allow these bindings to be installed when creating the main
    // world context of the main frame.
    blink::WebV8Features::EnableMojoJS(context, true);

    if (mojo_js_features_) {
      if (mojo_js_features_->file_system_access)
        blink::WebV8Features::EnableMojoJSFileSystemAccessHelper(context, true);
    }
  }

  if (world_id == ISOLATED_WORLD_ID_GLOBAL &&
      mojo_js_interface_broker_.is_valid()) {
    // MojoJS interface broker can be enabled on subframes, and will limit the
    // interfaces JavaScript can request to those provided in the broker.
    blink::WebV8Features::EnableMojoJSAndUseBroker(
        context, std::move(mojo_js_interface_broker_));
  }

  for (auto& observer : observers_)
    observer.DidCreateScriptContext(context, world_id);
}

最后，在src目录下，执行 gn gen out/Default ，重新生成构建文件

构建成功之后运行一下命令进行编译

autoninja -C out/Default chrome

如果你想实现console.log(window.myCode);这样的效果

将 my_code_binding.h 修改为

#ifndef CONTENT_RENDERER_MY_CODE_BINDING_H_
#define CONTENT_RENDERER_MY_CODE_BINDING_H_

#include "v8/include/v8.h"

namespace content {

class MyCodeBinding {
 public:
  static void Install(v8::Local<v8::Context> context);
};

}
#endif

将前面的 my_code_binding.cc 修改为

#include "content/renderer/my_code_binding.h"

#include "base/my_globals.h"
#include "v8/include/v8.h"

namespace content {

void MyCodeBinding::Install(v8::Local<v8::Context> context) {
  v8::Isolate* isolate = context->GetIsolate();
  v8::HandleScope handle_scope(isolate);

  v8::Local<v8::Object> global = context->Global();

  global->Set(
      context,
      v8::String::NewFromUtf8(isolate, "myCode").ToLocalChecked(),
      v8::String::NewFromUtf8(isolate, base::kMyCode).ToLocalChecked())
      .Check();
}

}

实现可配置的滚动效果：JavaScript与CSS双方案

滚动效果是现代Web界面中常见的交互方式，本文将详细介绍如何通过JavaScript实现一个可配置的公共滚动函数，以及纯CSS实现滚动效果的方法。

JavaScript实现可配置滚动函数

下面是一个通用的滚动函数，可以通过参数控制滚动方向、速度和行为：

/**
 * 通用滚动函数
 * @param {Object} options 配置对象
 * @param {HTMLElement} options.element 需要滚动的元素
 * @param {string} options.direction 滚动方向 ('horizontal'或'vertical')
 * @param {number} options.speed 滚动速度 (像素/帧)
 * @param {boolean} options.loop 是否循环滚动
 * @param {number} options.delay 开始前的延迟(毫秒)
 * @param {boolean} options.pauseOnHover 悬停时暂停
 */
function startAutoScroll(options) {
  const {
    element,
    direction = 'vertical',
    speed = 1,
    loop = true,
    delay = 0,
    pauseOnHover = true
  } = options;

  // 设置容器样式
  element.style.overflow = 'hidden';
  element.style.position = 'relative';
  
  // 创建内容包裹器
  const wrapper = document.createElement('div');
  wrapper.style.display = 'inline-block';
  wrapper.style.whiteSpace = 'nowrap';
  wrapper.style.transition = 'none';
  
  // 移动内容到包裹器
  while (element.firstChild) {
    wrapper.appendChild(element.firstChild);
  }
  element.appendChild(wrapper);

  // 克隆内容以实现无缝循环
  if (loop) {
    const clone = wrapper.cloneNode(true);
    element.appendChild(clone);
  }

  let isPaused = false;
  let animationId;
  let position = 0;

  // 悬停暂停功能
  if (pauseOnHover) {
    element.addEventListener('mouseenter', () => isPaused = true);
    element.addEventListener('mouseleave', () => isPaused = false);
  }

  // 开始滚动
  setTimeout(() => {
    function scroll() {
      if (isPaused) {
        animationId = requestAnimationFrame(scroll);
        return;
      }

      if (direction === 'horizontal') {
        position -= speed;
        wrapper.style.transform = `translateX(${position}px)`;
        
        // 循环逻辑
        if (loop && -position >= wrapper.offsetWidth) {
          position = 0;
        }
      } else {
        position -= speed;
        wrapper.style.transform = `translateY(${position}px)`;
        
        // 循环逻辑
        if (loop && -position >= wrapper.offsetHeight) {
          position = 0;
        }
      }

      animationId = requestAnimationFrame(scroll);
    }

    scroll();
  }, delay);

  // 返回停止函数
  return function stop() {
    cancelAnimationFrame(animationId);
  };
}

// 使用示例
const stopVerticalScroll = startAutoScroll({
  element: document.getElementById('vertical-scroller'),
  direction: 'vertical',
  speed: 0.5
});

const stopHorizontalScroll = startAutoScroll({
  element: document.getElementById('horizontal-scroller'),
  direction: 'horizontal',
  speed: 1,
  loop: true,
  pauseOnHover: true
});

// 需要停止时调用返回的函数
// stopVerticalScroll();
// stopHorizontalScroll();

功能特点

1. 方向可控：通过direction参数指定垂直或水平滚动
2. 速度可调：speed参数控制滚动速度
3. 循环模式：loop参数决定是否无缝循环
4. 交互控制：支持悬停暂停功能
5. 可停止：返回停止函数以便控制

CSS实现滚动效果

1. 垂直滚动

<div class="vertical-scroll-container">
  <div class="vertical-scroll-content">
    <!-- 你的内容 -->
  </div>
</div>

.vertical-scroll-container {
  height: 300px;
  overflow: hidden;
  position: relative;
}

.vertical-scroll-content {
  position: absolute;
  top: 0;
  left: 0;
  animation: verticalScroll 10s linear infinite;
}

@keyframes verticalScroll {
  0% {
    transform: translateY(0);
  }
  100% {
    transform: translateY(-100%);
  }
}

/* 悬停暂停 */
.vertical-scroll-container:hover .vertical-scroll-content {
  animation-play-state: paused;
}

2. 水平滚动

<div class="horizontal-scroll-container">
  <div class="horizontal-scroll-content">
    <!-- 你的内容 -->
  </div>
</div>

.horizontal-scroll-container {
  width: 100%;
  overflow: hidden;
  white-space: nowrap;
}

.horizontal-scroll-content {
  display: inline-block;
  animation: horizontalScroll 15s linear infinite;
}

@keyframes horizontalScroll {
  0% {
    transform: translateX(0);
  }
  100% {
    transform: translateX(-100%);
  }
}

/* 悬停暂停 */
.horizontal-scroll-container:hover .horizontal-scroll-content {
  animation-play-state: paused;
}

3. 无限循环滚动（CSS方案）

要实现无缝循环，需要复制一份内容：

<div class="infinite-scroll-container">
  <div class="infinite-scroll-content">
    <!-- 你的内容 -->
  </div>
  <div class="infinite-scroll-content" aria-hidden="true">
    <!-- 重复内容 -->
  </div>
</div>

.infinite-scroll-container {
  overflow: hidden;
  white-space: nowrap;
}

.infinite-scroll-content {
  display: inline-block;
  animation: infiniteScroll 20s linear infinite;
}

@keyframes infiniteScroll {
  0% {
    transform: translateX(0);
  }
  100% {
    transform: translateX(-100%);
  }
}

方案对比

特性	JavaScript方案	CSS方案
控制精度	高，可逐像素控制	中等，依赖关键帧
性能	中等（需要requestAnimationFrame）	高（浏览器优化）
复杂度	高，需要处理逻辑	低，纯声明式
交互性	强，可随时调整参数	有限，只能暂停/继续
兼容性	好（可polyfill）	好（现代浏览器）

最佳实践建议

1. 优先考虑CSS方案：对于简单滚动效果，CSS性能更好且实现简单

2. 复杂交互用JavaScript：当需要动态调整速度、方向或复杂逻辑时

3. 注意性能优化：

   • 减少滚动区域的回流和重绘
   • 对滚动内容使用will-change: transform
   • 避免在滚动容器中有太多子元素

4. 无障碍考虑：

   • 为可滚动区域添加适当的ARIA属性
   • 确保滚动不会影响键盘导航
   • 提供暂停/继续的控件

通过上述方案，你可以灵活地为项目添加各种滚动效果，无论是简单的文字滚动还是复杂的交互式滚动区域都能轻松应对。

一定记得return

1、flex布局

flex-wrap: wrap; 
align-content: space-between; 
justify-content: space-between;

2、布局切换：去除类名给点击的对象添加类名

记得使用检查查看对象名

document.querySelector('.active').classList.remove('active');
option.classList.add('active')

3、promise函数使用

const pipeline = async (initialValue, sequence) => 
{ 
    let res = initialValue; 
    for (const fn of sequence) { 
    res = await fn(res) 
 } 
 return res 
 };

4、element-plus 表单验证

认真读题，一般题中会给出使用方法，正则使用.test(/ /)来判断

5、在处理函数传多个参数时，合理使用三点...运算符

6、函数递归

function generateTree(dirPath) { // 读取目录下的所有文件和文件夹 const files = fs.readdirSync(dirPath); 
const tree = []; 
files.forEach(file => 
{ const filePath = path.join(dirPath, file); 
const isDirectory = fs.statSync(filePath).isDirectory();
if (isDirectory) { // 如果是目录，则递归生成子目录的文件树 
const subtree = generateTree(filePath);
tree.push({ name: file, children: subtree }); } 
else { // 如果是文件，则直接添加到文件树 
tree.push({ name: file }); 
} 
});
return tree;
}

7、.fliter和.slice

.fliter(item => item.name === name.value)和.slice(data.vale - 1, dataend.value)

8、.trim().charAt(0).toUpperCase()取首字母大写，.toLowerCase()大写转化为小写

.trim()是一个字符串方法，用于移除字符串两端的空白字符（包括空格、制表符 \t、换行符 \n 等）。它不会修改原字符串，而是返回一个新的字符串。

取首字母大写
let num = ' hell o  world';
let firstChar = num.trim().charAt(0).toUpperCase();

9、.find和.findIndex

10、Object.keys(obj)把对象中的键值封装成一个数组和.includes()判断字符串是否有

function appendParamsToURL(url, params) { 
  const paramString = Object.keys(params)
  .map((key) => `${encodeURIComponent(key)}
  =${encodeURIComponent(params[key])}`).join('&')
  const sep = url.includes('?') ? '&' : '?'

  const newurl = `${url}${sep}${paramString}`
  return newurl

}

11、.split("、")对字符串进行分割，.sort()对数组进行排序（也可以对对象进行排序）

const users = [
  { name: 'Alice', age: 25 },
  { name: 'Bob', age: 30 },
  { name: 'Charlie', age: 20 }
];
const numbers = [10, 2, 5, 1];
numbers.sort((a, b) => a - b);升序
numbers.sort((a, b) => b - a);降序
// 按 age 升序排序
users.sort((a, b) => a.age - b.age);
console.log(users);
// 输出：
// [
//   { name: 'Charlie', age: 20 },
//   { name: 'Alice', age: 25 },
//   { name: 'Bob', age: 30 }
// ]

12、typeof检查数据类型，返回数据类型

typeof "hello"      // "string"
typeof 42            // "number"
typeof true          // "boolean"
typeof undefined     // "undefined"
typeof null          // "object" (这是历史遗留问题)
typeof {}            // "object"
typeof []            // "object"
typeof function(){}  // "function"
typeof Symbol()      // "symbol"
typeof 10n           // "bigint"

13、for...in和for..of的用法

// 示例
const obj = {a: 1, b: 2, c: 3};
for (const key in obj) {
  console.log(key, obj[key]); // 输出 "a 1", "b 2", "c 3"
}

// 示例
const arr = ['a', 'b', 'c'];
for (const value of arr) {
  console.log(value); // 输出 "a", "b", "c"
}

// 适用于字符串
for (const char of 'hello') {
  console.log(char); // 输出 "h", "e", "l", "l", "o"
}

14、document的常用API

// 通过 CSS 选择器获取单个元素
const submitBtn = document.querySelector('.submit-btn'); 

// 通过 CSS 选择器获取多个元素
const menuItems = document.querySelectorAll('.menu li');

// 示例：添加点击事件
submitBtn.addEventListener('click', () => {
  console.log('按钮被点击了');
});

// 创建新元素
`&`const newDiv = document.createElement('div');
    newDiv.className = 'alert';
    newDiv.textContent = '这是一条新消息';
// 给submitBtn元素添加子标签createTextNode添加文本内容
`&`submitBtn
.appendChild(newDiv.createTextNode('一些文本内容')) 

`&`//修改样式
const box = document.querySelector('.box');
    // 直接修改样式
    box.style.color = 'red';
    box.style.backgroundColor = '#f0f0f0';
`&`// 添加/移除/切换类名
    box.classList.add('active');
    box.classList.remove('inactive');
    box.classList.toggle('hidden'); // 有则移除，无则添加 

`&`//给对象添加属性和值
let str = "color: red "
box["style"] = str
box["click"] = function(){}
box.setAttribute(name, value); 
    name ：要设置的属性名称（字符串）
    value ：要为属性设置的值（字符串）

15、.replace()和如何拿到方法和对象

//替换操作
.replace(/[A-Z]/,c => `-${c.toLowerCase()}`)

//给dom元素添加方法
dom[key] = prop

16、Map()和Set(),常用于去重

// 创建 Map
const map = new Map();

// 添加元素
map.set('name', 'Alice');
map.set(1, 'number one');
map.set({ id: 1 }, 'object key');

// 获取元素
console.log(map.get('name')); // 'Alice'
console.log(map.get(1));      // 'number one'

// 检查键是否存在
console.log(map.has('name')); // true

// 删除元素
map.delete('name');

// 清空 Map
map.clear();

// 获取大小
console.log(map.size); // 0



`// 创建 Set`
const set = new Set();

// 添加元素
set.add(1);
set.add(2);
set.add(2); // 重复值不会被添加

// 检查值是否存在
console.log(set.has(1)); // true

// 删除元素
set.delete(1);

// 清空 Set
set.clear();

// 获取大小
console.log(set.size); // 0

17、grid布局

.seat-area {
  margin-top: 50px;          /* 区域顶部有50px的外边距 */
  display: grid;             /* 使用CSS Grid布局 */
  grid-template-columns: repeat(8, auto);  /* 创建8列，每列宽度自动 */
  grid-template-rows: 100px 200px 150px;
 /* 三行，高度分别为100px、200px、150px */
  gap: 10px;                 /* 网格项之间的间隙为10px */
}
//:nth-of-type(8n + 2)伪选择器表示没8个的第二个
.seat:nth-of-type(8n + 2) {
  margin-right: 20px;        /* 每行第2个座位右侧增加20px外边距 */
}

.seat:nth-of-type(8n + 6) {
  margin-right: 20px;        /* 每行第6个座位右侧增加20px外边距 */
}

18、生成随机数

let randomInt = Math.floor(Math.random() * 10) + 1; 
console.log(randomInt); // 输出一个介于 1 到 10 之间的随机整数

/**
 * 封装函数，函数名 getRandomNum(min,max,countNum)
 * 生成 min~max 范围的 countNum 个不重复的随机数，存入数组并返回
 */
//生成指定数目和范围的随机数
const getRandomNum = function(min,max,countNum){
    var arr = [];
    // 在此处补全代码
    for(let i =0; i < countNum; i++){
        let random = Math.floor(Math.random() * max) + min

        if(!arr.includes(random)){
            arr.push(random)
        }
    }
    return arr;
}
module.exports = getRandomNum; //请勿删除

19、文本溢出，......代替

let wenben = document.querySelector('.more2_info_name')
    wenben.style.overflow = "hidden"
    wenben.style['-webkit-line-clamp'] = 2

20、@media媒体查询加弹性布局（看父元素）

@media(max-width: 768px){
    #container{
        flex-direction: column;
        gap: 45px;
    }
    #banner{
        width: 100%;
    }
    #news{
        width: 100%;
    }
}

21、关于获取Attribute的css相关用法

22、axios请求

23、css的var()设置属性

24、本地存储

最后心态放平不要看的太重

signals是继privider，riverpod状态管理器之后的又一个热门； 它运用方便，理解简单，特别是已经对前端signals框架比较熟悉的同学。

文本旨在研究signals的原理，复刻一个“够用就行”的低配版状态管理框架。

signals 的核心用法就是 signal 和 computed 方法。

final a = signal('a');
final b = signal('b');
final c = computed(() => a.value + b.value);
final dispose = effect((){
    print("c is ${c.value}");
});
expect(c.value, 'ab');
a.value = 'aa';
expect(c.value, 'aab');
dispose();

从上面的代码可以看出，我们在改变a的值后，c的值也随之改变。当c值改变时会触发effect的回调。 在flutter中我们可以将effect方法看作是 build方法，返回Wdiget树，那么当我们改变某个signal值时就会触发build重绘widget。

有意思的是，effect方法实际上监听的只是c的值，之所以改变a会触发c的改变是因为competed方法里c的值用到了a.value。

因此singals的核心思想就是这种链式监听。

初学者会感觉这像是一种魔法，因为c.value并没有传入任何的变量，那c和a,b等是如何实现关联监听的呢？ 从singals源码中可以一窥究竟：

@override
T get value {
    final node = addDependency(this);

    if (node != null) {
        node.version = this.version;
    }
    return this.internalValue;
}

Node? addDependency(ReadonlySignal signal) {

    if (evalContext == null) {
        return null;
    }
    var node = signal.node;
    if (node == null || node.target != evalContext) {
        node = Node()
        ..version = 0
        ..source = signal
        ..prevSource = evalContext!.sources
        ..nextSource = null
        ..target = evalContext!
        ..prevTarget = null
        ..nextTarget = null
        ..rollbackNode = node;
        if (evalContext!.sources != null) {
            evalContext!.sources!.nextSource = node;
        }
        evalContext!.sources = node;
        signal.node = node;

        if ((evalContext!.flags & TRACKING) != 0) {
            signal.subscribeToNode(node);
        }
        return node;

    } else if (node.version == -1) {
        node.version = 0;
        if (node.nextSource != null) {
            node.nextSource!.prevSource = node.prevSource;
        if (node.prevSource != null) {
            node.prevSource!.nextSource = node.nextSource;
        }

        node.prevSource = evalContext!.sources;
        node.nextSource = null;
        evalContext!.sources!.nextSource = node;
        evalContext!.sources = node;
    }
        return node;
    }
    return null;
}

以上是Signal类中截取的获取value的方法，可以看出它调用了addDependency返回了一个node。而在addDependency则对每个Signal初始化了一个Node对象用来管理Signal之间的关系，从代码实现来看Node对象之间是通过双向链表实现关联的。且从代码中还可以发evalContext这个引用频繁出现，且是一个全局变量。

我们再看看Computed的实现：

@override
T get value {
    if ((flags & RUNNING) != 0) {
        throw Exception('Cycle detected');
    }
    final node = addDependency(this);
    internalRefresh();
    if (node != null) {
        node.version = version;
    }
    if ((flags & HAS_ERROR) != 0) {
        throw error!;
    }
    return _internalValue;
}

bool internalRefresh() {
    this.flags &= ~NOTIFIED;
    if ((this.flags & RUNNING) != 0) {
        return false;
    }

    if ((this.flags & (OUTDATED | TRACKING)) == TRACKING) {
        return true;
    }

    this.flags &= ~OUTDATED;
    if (this.internalGlobalVersion == globalVersion) {
        return true;
    }

    this.internalGlobalVersion = globalVersion;
    this.flags |= RUNNING;
    if (version > 0 && !needsToRecompute(this)) {
        this.flags &= ~RUNNING;
        return true;
    }
    final prevContext = evalContext;
    try {
        prepareSources(this);
        evalContext = this;
        final val = this.fn();
        if (!_isInitialized ||
            (flags & HAS_ERROR) != 0 ||
            _internalValue != val ||
            version == 0) {
            internalValue = val;
            flags &= ~HAS_ERROR;
            version++;
        }
    } catch (err) {
        error = err;
        flags |= HAS_ERROR;
        version++;
    }
    evalContext = prevContext;
    cleanupSources(this);
    flags &= ~RUNNING;
    return true;
}

代码很长，我们可以看到Computed和Signal的value对象一样调用了addDependency，之后调用了internalRefresh方法，在internalRefresh方法里我们又看到evalContext的身影，我们发现在调用 final val = this.fn();前它：evalContext = this;调用结束后又重制回来了：evalContext = prevContext;

从上面代码我们不难看出，Signals的魔法就在这里通过全局变量evalContext临时存储上下文信息，执行结束后又重置回来。 魔法就此揭开了。也许有人会问，这样设置全局变量不会有并发问题吗？答案是不会，因为dart的运行时isolate是单线程模型，它运行的实际上是按照顺序执行代码块，这里不详细展开讲解，可以自行查isolate的执行原理。

---

OK，那么我们如何在flutter中实现一个简单的像signals里signal方法和computed方法呢？首先我们也需要写一个Node用来管理调用链之间的关系，这里为了简单只设计两层的调用链，也就是computed只允许signal，不允许computed嵌套使用。他们的关系就先用树结构进行管理：

mixin class Node {
    //关联的子节点用Set是为了避免节点重复加入
    final Set<Node> children = {};
    //添加子节点
    void addChild(Node node) {
        children.add(node);
    }
    //删除子节点
    void removeChild(Node node) {
        children.remove(node);
    }
    //通知子节点改变
    void notify() {
        for (var child in children) {
            child.notify();
        }
    }
    //销毁
    void dispose() {
        children.clear();
    }
}

有了节点，我们就先写Singal，这里为了和Signal区分就用UseValue代替，为了方便就直接用Flutter的ValueNotifier：

typedef DisposeFn = void Function();

typedef ComputeFn<T> = T Function();

Node? childNode;

class UseValue<T> extends ValueNotifier<T> with Node {
    final DisposeFn? disposeFn;
    UseValue(super.value, {this.disposeFn});
    
    @override
    T get value {
        if (childNode != null) {
            addChild(childNode!);
        }
        var value = super.value;
        return value;
    }

    @override
    void dispose() {
        disposeFn?.call();
        super.dispose();
    }

    @override
    void notifyListeners() {
        super.notifyListeners();
        notify();
    }
}

在以上代码中我们定义了一个childNode全局对象，这个跟signals里的evelContext是一个作用，用于关联节点之间的关系。在T get value方法里，会去判断childNode是否为空，如果不为空则会将它加入到自己的children里，如果自己的之值发生改变则会去通知children也去改变。

有了Signal再写Computed，为了区分，我这里用UseComputed代替：

class UseComputed<T> extends ChangeNotifier with Node {
    final ComputeFn<T> computeFn;
    UseComputed(this.computeFn);
    T get value {
        var oldChildNode = childNode;
        try {
            childNode = this;
            var computeValue = computeFn();
            return computeValue;
        } finally {
            childNode = oldChildNode;
        }
    }

    @override
    void notify() {
        notifyListeners();
    }
}

从上面代码中 T get value 的实现可以看出，我们会把全局变量 childNode暂时缓存并替换成自己，执行完回调函数后又重置回去。

我们再写一个State的实现：

mixin MixinUseState<W extends StatefulWidget> on State<W> {
    final Set<DisposeFn> _disposeFnSet = {};
    @override
    void dispose() {
        for (var disposeFn in _disposeFnSet) {
            disposeFn.call();
        }
        super.dispose();
    }
    
    void _notifyChanged() {
        setState(() {});
    }
    
    //类似 signals里的 signal 方法
    UseValue<T> use<T>(T value,{bool addListener}) {
        var useValue = UseValue<T>(value);
        if(addListener){
            useValue.addListener(_notifyChanged);
        }
        _disposeFnSet.add(useValue.dispose);
        return useValue;
    }
    //类似 signals里的 computed 方法
    UseComputed<T> computed<T>(ComputeFn<T> computeFn) {
        var useComputed = UseComputed(computeFn);
        _disposeFnSet.add(useComputed.dispose);
        useComputed.addListener(_notifyChanged);
        return useComputed;
    }

}

在上面代码中，还添加了自动dispose的功能，调用use和compted时会将dispose方法放入到 _disposeFnSet中。

再写个Demo：

    void main() {
        runApp(const MyApp());
    }

    class MyApp extends StatelessWidget {
        const MyApp({super.key});
        @override
        Widget build(BuildContext context) {
            return MaterialApp(
                title: 'Flutter Demo',
                theme: ThemeData(
                colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
                useMaterial3: true,
                ),
                home: const MyHomePage(title: 'Flutter Demo Home Page'),
            );
        }
    }

    class MyHomePage extends StatefulWidget {
        const MyHomePage({super.key, required this.title});
        final String title;
        @override
        State<MyHomePage> createState() => _MyHomePageState();
    }


    class _MyHomePageState extends State<MyHomePage> with MixinUseState {
        late final c1 = use(0);
        late final c2 = use(2);
        late final counter = computed(() {
            return c1.value + c2.value;
        });

        @override
        Widget build(BuildContext context) {
            return Scaffold(
                appBar: AppBar(
                    backgroundColor: Theme.of(context).colorScheme.inversePrimary,
                    title: Text(widget.title),
                ),
                body: Center(
                    child: Column(
                        mainAxisAlignment: MainAxisAlignment.center,
                        children: <Widget>[
                            const Text(
                            'You have pushed the button this many times:',
                            ),
                            Text(
                                '${counter.value}',
                                style: Theme.of(context).textTheme.headlineMedium,
                            ),
                        ],
                    ),),
               floatingActionButton: FloatingActionButton(
                    onPressed: () {
                        c1.value++;
                    },
                    tooltip: 'Increment',
                    child: const Icon(Icons.add),
                    ), // This trailing comma makes auto-formatting nicer for build methods.
                );
            }
    }

在测试代码中，定义了 c1，c2，c3，首先c1和c2类似于signal，而c3则是computed，我们在改变c1.value时会触发c3的改变，进行重新计算，并刷新UI。

自此这个简单的demo就实现完成了，但signals的功能远不止这些，例如batch可以同时改变多个值减少刷新次数，containner,类似riverpod里的family等。

1. 安装tdesign-miniprogram

创建package.json 创建终端执行命令 npm i tdesign-miniprogram -S --production

配置project.config.json

"setting": {
 "packNpmRelationList": [
   {
     "packageJsonPath": "package.json",
     "miniprogramNpmDistDir": "./"
   }
 ],
 "packNpmManually": true,
 },

选择工具-> 构建npm

配置app.json

"usingComponents": {
    "t-button": "tdesign-miniprogram/button/button"
  },

自定义主题 配置app.wxss

page {
  --td-primary-color-7: rgb(12, 200, 164); /* 基础颜色 */
  --td-primary-color-8: rgb(12, 200, 164); /* 按下颜色 */
}

2. 自定义底部导航栏

文件夹custom-tab-bar

是一个组件 index.json apply-shared为了自定义css使用

{
"component": true,
"styleIsolation": "apply-shared",
"usingComponents": {
  "t-tab-bar": "tdesign-miniprogram/tab-bar/tab-bar",
  "t-tab-bar-item": "tdesign-miniprogram/tab-bar-item/tab-bar-item"
}
}

index.wxml 自定义主题需要加一层view

<view class="wrapper">
<t-tab-bar t-class="t-tab-bar" value="{{value}}" bindchange="onChange" theme="tag" split="{{false}}">
<t-tab-bar-item wx:for="{{list}}" wx:key="index" value="{{item.value}}"> {{item.label}} </t-tab-bar-item>
</t-tab-bar>
</view>

index.wxss

.wrapper {
--td-tab-bar-active-color: rgb(12, 200, 164);
}

index.js

methods: {
  onChange(e) {
    wx.switchTab({
      url: `/pages/${e.detail.value}/index`,
    })
    this.setData({
      value: e.detail.value,
    });
  },
},

配置app.json pages： 里面每一个都是组件 tabBar： 配置custom和list

 "pages": [
  "pages/policy/index",
  "pages/data/index",
  "pages/me/index",
  "pages/login/login"
],
"tabBar": {
  "custom": true,
  "list": [
    {
      "pagePath": "pages/policy/index",
      "text": "策略"
    },
    {
      "pagePath": "pages/data/index",
      "text": "数据"
    },
    {
      "pagePath": "pages/me/index",
      "text": "我的"
    }
  ]
},

pages/policy/index 代码 index.json

{
"usingComponents": {}
}

index.js 是一个Component, 填写pageLifetimes 回调

Component({
    pageLifetimes: {
      show() {
        if (typeof this.getTabBar === 'function' &&
          this.getTabBar()) {
          this.getTabBar().setData({
            value: 'policy'
          })
        }
      }
    },
})

---

一、 Grid 容器属性 (Properties for the Grid Container)

应用于设置了 display: grid 或 display: inline-grid 的元素。

1. display

   • 作用：定义元素为 Grid 容器。

   • 值：

     • grid: 块级 Grid 容器。
     • inline-grid: 行内级 Grid 容器。

2. grid-template-columns

   • 作用：定义网格列的数量和尺寸。

   • 值：

     • : 定义每列的尺寸。可以是：

       • : 如 100px, 2em。
       • : 相对于容器宽度的百分比，如 25%。
       • auto: 由内容或 minmax() 函数决定。
       • (即 fr 单位): 弹性系数，代表可用空间的一份。如 1fr, 2fr。
       • minmax(min, max): 定义一个尺寸范围，如 minmax(100px, 1fr) (最小100px，最大占1份可用空间)。
       • fit-content(): 根据内容尺寸调整，但不超过指定值。

     • repeat(, ): 重复定义轨道。如 repeat(3, 1fr) (3列，每列1fr), repeat(auto-fill, minmax(100px, 1fr)) (自动填充尽可能多的列，每列最小100px)。

     • none: (默认值，但通常会显式定义) 没有显式定义的列。

3. grid-template-rows

   • 作用：定义网格行的数量和尺寸。
   • 值：同 grid-template-columns。

4. grid-template-areas

   • 作用：通过命名网格区域来定义网格布局。

   • 值：

     • 字符串 (Strings): 每个字符串代表一行，字符串中的名字代表单元格所属区域名。用空格分隔名字。

     • . (点): 代表一个空单元格。

     • none: (默认值) 不使用命名区域。

     • 示例：

             grid-template-areas:
         "header header header"
         "nav main aside"
         "footer footer footer";
           
       

5. grid-template

   • 作用：grid-template-rows, grid-template-columns, 和 grid-template-areas 的简写。

   • 值：组合上述三个属性的值，语法较复杂，通常分开写更清晰。

     • none: (默认值)
     • /
     • [ ? ? ? ]+ [ / ]? (定义 area 和 row/col)

6. gap (或 grid-gap)

   • 作用：设置网格线之间的间距（沟槽）。

   • 值：

     • : 设置一个值，同时用于行间距和列间距，如 10px。
     • : 分别设置行间距和列间距，如 15px 10px。

7. row-gap (或 grid-row-gap)

   • 作用：单独设置行间距。
   • 值：，如 20px。

8. column-gap (或 grid-column-gap)

   • 作用：单独设置列间距。
   • 值：，如 10px。

9. justify-items

   • 作用：定义网格项目在其分配的单元格内沿 行轴（水平方向） 的对齐方式。

   • 值：

     • start: 对齐到单元格的行起始边缘。
     • end: 对齐到单元格的行结束边缘。
     • center: 在单元格内水平居中。
     • stretch: (默认值) 项目填充单元格的整个宽度（如果项目未设置宽度）。

10. align-items

    • 作用：定义网格项目在其分配的单元格内沿 列轴（垂直方向） 的对齐方式。

    • 值：

      • start: 对齐到单元格的列起始边缘。
      • end: 对齐到单元格的列结束边缘。
      • center: 在单元格内垂直居中。
      • stretch: (默认值) 项目填充单元格的整个高度（如果项目未设置高度）。
      • baseline: 基于项目内容的基线对齐。

11. place-items

    • 作用：align-items 和 justify-items 的简写。

    • 值：

      • : 如果只提供一个值，justify-items 也使用相同的值。
      • : 分别设置。

12. justify-content

    • 作用：定义 整个网格 在容器内沿 行轴（水平方向） 的对齐方式（当网格总宽度小于容器宽度时）。

    • 值：

      • start: 网格向容器的行起始边缘对齐。
      • end: 网格向容器的行结束边缘对齐。
      • center: 网格在容器内水平居中。
      • stretch: 拉伸网格轨道以填满容器宽度（如果轨道尺寸是 auto）。
      • space-around: 网格轨道均匀分布，轨道两侧空间相等。
      • space-between: 网格轨道均匀分布，首尾轨道贴边。
      • space-evenly: 网格轨道和它们与容器边缘之间的空间都均匀分布。

13. align-content

    • 作用：定义 整个网格 在容器内沿 列轴（垂直方向） 的对齐方式（当网格总高度小于容器高度时）。
    • 值：同 justify-content（但作用于垂直方向）。

14. place-content

    • 作用：align-content 和 justify-content 的简写。

    • 值：

      • : 如果只提供一个值，justify-content 也使用相同的值。
      • : 分别设置。

15. grid-auto-columns

    • 作用：指定 隐式 创建的网格列的尺寸（当项目放置在显式定义的列之外时）。
    • 值： (同 grid-template-columns 的值)。

16. grid-auto-rows

    • 作用：指定 隐式 创建的网格行的尺寸。
    • 值： (同 grid-template-rows 的值)。

17. grid-auto-flow

    • 作用：指定自动布局算法如何放置没有明确放置在网格中的项目。

    • 值：

      • row: (默认值) 优先逐行填充。
      • column: 优先逐列填充。
      • dense: 尝试填补网格中较早出现的空隙，可能会打乱项目顺序。

18. grid

    • 作用：一个复杂的简写属性，可以同时设置 grid-template-rows, grid-template-columns, grid-template-areas, grid-auto-rows, grid-auto-columns, grid-auto-flow。因其复杂性，通常不推荐使用，分开写更清晰。

---

二、 Grid 项目属性 (Properties for the Grid Items)

应用于 Grid 容器的直接子元素。

1. grid-column-start

   • 作用：定义项目在列方向上开始的网格线。

   • 值：

     • : 线号 (如 1, 2, -1) 或线名。
     • span : 跨越指定数量的列。
     • auto: 自动放置。

2. grid-column-end

   • 作用：定义项目在列方向上结束的网格线。
   • 值：同 grid-column-start。

3. grid-row-start

   • 作用：定义项目在行方向上开始的网格线。
   • 值：同 grid-column-start。

4. grid-row-end

   • 作用：定义项目在行方向上结束的网格线。
   • 值：同 grid-column-start。

5. grid-column

   • 作用：grid-column-start 和 grid-column-end 的简写。

   • 值：

     • / : 如 1 / 3。
     • / span : 如 2 / span 3。
     • span / : 如 span 2 / 5。
     • : 如果只提供一个值，表示开始线，结束线自动推断（通常是下一条线）。
     • span : 如 span 2 (从自动放置位置开始跨越2列)。

6. grid-row

   • 作用：grid-row-start 和 grid-row-end 的简写。
   • 值：同 grid-column。

7. grid-area

   • 作用：给项目指定一个名称，使其放置在由 grid-template-areas 定义的同名区域中；或者是 grid-row-start / grid-column-start / grid-row-end / grid-column-end 的简写。

   • 值：

     • : 引用 grid-template-areas 中定义的区域名。
     • / / / : 如 2 / 1 / 4 / 3。
     • auto: 自动放置。

8. justify-self

   • 作用：覆盖容器的 justify-items，定义 当前项目 在其单元格内沿 行轴（水平方向） 的对齐方式。
   • 值：start, end, center, stretch。

9. align-self

   • 作用：覆盖容器的 align-items，定义 当前项目 在其单元格内沿 列轴（垂直方向） 的对齐方式。
   • 值：start, end, center, stretch, baseline。

10. place-self

    • 作用：align-self 和 justify-self 的简写。

    • 值：

      • : 如果只提供一个值，justify-self 也使用相同的值。
      • : 分别设置。

11. order (与 Flexbox 共享)

    • 作用：虽然 Grid 主要通过放置属性控制顺序，但 order 仍然可以影响未明确放置的项目的自动布局顺序，或在视觉顺序与 DOM 顺序需要分离时使用。数值越小越靠前。
    • 值： (默认为 0)。

---

案例 1

    <!-- 11.html -->
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Grid 布局示例</title>
    <link rel="stylesheet" href="11.css">
</head>
<body>

<h1>Grid 布局示例</h1>

<!-- 示例 1: 基础的 3x2 网格 -->
<h2>示例 1: 基础的 3x2 网格</h2>
<div class="grid-container example1">
    <div class="grid-item">1</div>
    <div class="grid-item">2</div>
    <div class="grid-item">3</div>
    <div class="grid-item">4</div>
    <div class="grid-item">5</div>
    <div class="grid-item">6</div>
</div>

<!-- 示例 2: 使用 fr 单位的弹性列 -->
<h2>示例 2: 使用 fr 单位的弹性列</h2>
<div class="grid-container example2">
    <div class="grid-item">1 (1fr)</div>
    <div class="grid-item">2 (2fr)</div>
    <div class="grid-item">3 (1fr)</div>
</div>

<!-- 示例 3: 经典的圣杯布局 (Holy Grail Layout) 变体 -->
<h2>示例 3: 经典的圣杯布局变体 (使用命名区域)</h2>
<div class="grid-container example3">
    <header class="grid-item header">页眉 (Header)</header>
    <nav class="grid-item nav">导航 (Nav)</nav>
    <main class="grid-item main">主内容区域 (Main)</main>
    <aside class="grid-item aside">侧边栏 (Aside)</aside>
    <footer class="grid-item footer">页脚 (Footer)</footer>
</div>

<!-- 示例 4: 响应式卡片布局 -->
<h2>示例 4: 响应式卡片布局</h2>
<div class="grid-container example4">
    <div class="grid-item card">卡片 1</div>
    <div class="grid-item card">卡片 2</div>
    <div class="grid-item card">卡片 3</div>
    <div class="grid-item card">卡片 4</div>
    <div class="grid-item card">卡片 5</div>
    <div class="grid-item card">卡片 6</div>
    <div class="grid-item card">卡片 7</div>
    <div class="grid-item card">卡片 8</div>
</div>

<!-- 示例 5: 项目跨越与显式放置 -->
<h2>示例 5: 项目跨越与显式放置</h2>
<div class="grid-container example5">
    <div class="grid-item item-a">A (跨2列)</div>
    <div class="grid-item item-b">B</div>
    <div class="grid-item item-c">C (跨2行)</div>
    <div class="grid-item item-d">D</div>
    <div class="grid-item item-e">E</div>
</div>

<!-- 示例 6: 项目对齐 -->
<h2>示例 6: 项目对齐</h2>
<div class="grid-container example6">
    <div class="grid-item align-start">Start</div>
    <div class="grid-item justify-center">Center (Horiz)</div>
    <div class="grid-item place-end">End (Both)</div>
    <div class="grid-item baseline-align">Base<br>line</div>
</div>

</body>
</html>

/* 11.css */
body {
  font-family: "Microsoft YaHei", sans-serif;
  margin: 20px;
}

h1, h2 {
  text-align: center;
  margin-bottom: 20px;
}

.grid-container {
  border: 3px solid steelblue;
  background-color: lightgray;
  padding: 10px;
  margin-bottom: 40px; /* 区分示例 */
  display: grid; /* !! 核心：启用 Grid 布局 !! */
}

.grid-item {
  border: 1px dashed #666;
  background-color: lightcoral;
  padding: 20px;
  text-align: center;
  font-size: 1.1em;
  color: white;
}

/* --- 各示例特定样式 --- */

/* 示例 1: 基础的 3x2 网格 */
.example1 {
  /* 定义 3 列，每列 100px */
  grid-template-columns: 100px 100px 100px;
  /* 定义 2 行，每行 50px */
  grid-template-rows: 50px 50px;
  /* 设置行和列的间距 */
  gap: 10px;
  /* 如果容器宽度大于 3*(100px + 10px) - 10px，网格会靠左对齐 */
  justify-content: start; /* 默认就是 start */
}

/* 示例 2: 使用 fr 单位的弹性列 */
.example2 {
  /* 定义 3 列，按 1:2:1 的比例分配可用宽度 */
  grid-template-columns: 1fr 2fr 1fr;
  /* 行高自动 */
  grid-template-rows: auto;
  gap: 15px;
}

/* 示例 3: 经典的圣杯布局变体 (使用命名区域) */
.example3 {
  /* 定义列：第一列固定宽度，第二、三列弹性 */
  grid-template-columns: 150px 1fr 150px;
  /* 定义行：页眉页脚高度自动，中间区域弹性 */
  grid-template-rows: auto 1fr auto;
  /* 定义区域名称 */
  grid-template-areas:
      "header header header"  /* 第一行：页眉跨越所有列 */
      "nav    main   aside"   /* 第二行：导航、主内容、侧边栏 */
      "footer footer footer"; /* 第三行：页脚跨越所有列 */
  gap: 10px;
  min-height: 400px; /* 给容器一个最小高度看效果 */
}
/* 将 HTML 元素分配到对应的区域 */
.example3 .header { grid-area: header; background-color: #16a085; }
.example3 .nav    { grid-area: nav;    background-color: #27ae60; }
.example3 .main   { grid-area: main;   background-color: #2ecc71; }
.example3 .aside  { grid-area: aside;  background-color: #f1c40f; }
.example3 .footer { grid-area: footer; background-color: #e67e22; }

/* 示例 4: 响应式卡片布局 */
.example4 {
  /* 关键：创建尽可能多的列，每列最小宽度180px，最大等分剩余空间 */
  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
  gap: 20px;
}
.example4 .card {
  background-color: #3498db;
  min-height: 100px; /* 卡片最小高度 */
}

/* 示例 5: 项目跨越与显式放置 */
.example5 {
  /* 定义一个 3 列 2 行的基础网格 */
  grid-template-columns: repeat(3, 1fr);
  grid-template-rows: repeat(2, 100px);
  gap: 10px;
}
.example5 .item-a {
  background-color: #8e44ad;
  /* 从第 1 条列线开始，跨越 2 列 (到第 3 条列线) */
  grid-column: 1 / span 2;
  /* 或者 grid-column: 1 / 3; */
  grid-row: 1; /* 放在第 1 行 (默认跨1行) */
}
.example5 .item-c {
  background-color: #c0392b;
  grid-column: 1; /* 放在第 1 列 */
   /* 从第 2 条行线开始，跨越 2 行 (到第 4 条行线) */
  grid-row: 2 / span 2;
  /* 或者 grid-row: 2 / 4; (如果只有2行，会自动适配) */
}
/* B, D, E 会自动填充剩余单元格 */

/* 示例 6: 项目对齐 */
.example6 {
  grid-template-columns: repeat(3, 1fr);
  grid-template-rows: 150px; /* 固定行高以观察垂直对齐 */
  gap: 10px;
  /* 可以设置容器默认对齐方式 */
  /* justify-items: center; */
  /* align-items: center; */
}
.example6 .align-start {
  align-self: start; /* 当前项目在单元格内顶部对齐 */
  background-color: #2980b9;
}
.example6 .justify-center {
  justify-self: center; /* 当前项目在单元格内水平居中 */
  background-color: #d35400;
  width: 60%; /* 设置宽度，否则 stretch 会覆盖 justify-self */
}
.example6 .place-end {
  place-self: end end; /* align-self: end; justify-self: end; 右下角对齐 */
  background-color: #2c3e50;
  width: 50%;
  height: 50%; /* 设置宽高看效果 */
}
.example6 .baseline-align {
  align-self: baseline; /* 基于基线对齐 */
  font-size: 1.5em;
  background-color: #7f8c8d;
}

案例 2

<!DOCTYPE html>
<html lang="zh">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Grid 博客布局</title>
  <style>
    * {
      box-sizing: border-box;
    }

    body {
      margin: 0;
      font-family: sans-serif;
    }

    .grid-container {
      display: grid;
      grid-template-areas:
        "header header header"
        "sidebar main aside"
        "footer footer footer";
      grid-template-columns: 200px 1fr 200px;
      grid-template-rows: auto 1fr auto;
      min-height: 100vh;
      gap: 10px;
      padding: 10px;
    }

    header {
      grid-area: header;
      background: #4CAF50;
      color: white;
      padding: 20px;
      font-size: 24px;
    }

    nav {
      grid-area: sidebar;
      background: #f4f4f4;
      padding: 20px;
    }

    main {
      grid-area: main;
      background: #fff;
      padding: 20px;
    }

    aside {
      grid-area: aside;
      background: #f9f9f9;
      padding: 20px;
    }

    footer {
      grid-area: footer;
      background: #222;
      color: white;
      text-align: center;
      padding: 10px;
    }

    /* 响应式：小屏幕折叠侧栏 */
    @media (max-width: 768px) {
      .grid-container {
        grid-template-areas:
          "header"
          "main"
          "aside"
          "sidebar"
          "footer";
        grid-template-columns: 1fr;
      }

      nav, aside {
        order: 1;
      }
    }
  </style>
</head>
<body>

  <div class="grid-container">
    <header>我的博客</header>
    <nav>导航<br>首页<br>归档<br>关于我</nav>
    <main>
      <h2>文章标题</h2>
      <p>这是文章的内容段落……</p>
    </main>
    <aside>热门推荐<br>文章1<br>文章2</aside>
    <footer>© 2025 我的博客. 保留所有权利。</footer>
  </div>

</body>
</html>

一、router.resolve() 是什么

router.resolve() 就好比是一个精准的 “导航参谋”。当我们在 Vue 3 应用里需要明确某个路由地址对应的详细信息时，它就能派上用场。我们给它传入路由信息，像路径、参数等，它会解析出对应的路由对象，这个对象包含了最终的 URL、要渲染的组件等关键信息。

二、它的用途

1. 动态创建链接

想象一下，我们的应用有一个商品详情页面，路由路径是 /product/:id。要是我们想在代码里动态生成指向某个商品详情页的链接，使用 router.resolve() 就很合适。通过传入商品的 id 参数，它能为我们生成准确无误的 URL，避免手动拼接路径可能产生的错误。

2. 获取路由详情

有时候，我们可能需要提前知晓某个路由对应的组件是什么，或者它是否有嵌套路由等信息。router.resolve() 能帮助我们获取这些信息，方便在业务逻辑中做出恰当的决策。比如在进行权限管理时，我们可以依据路由信息判断用户是否有权限访问该页面。

三、Vue 3 中的使用示例

假设我们的路由表是这样的

//router.js
import { createRouter, createWebHistory } from 'vue-router';
import Home from './views/Home.vue';
import Product from './views/Product.vue';

const routes = [
  {
    path: '/',
    name: 'home',
    component: Home
  },
  {
    path: '/product/:id',
    name: 'product',
    component: Product
  }
];

const router = createRouter({
  history: createWebHistory(),
  routes
});

export default router;

然后，在某个组件里，我们想生成一个指向商品详情页的链接，代码可以这样写：

<template>
  <div>
    <button @click="generateProductLink">生成商品链接</button>
  </div>
</template>

<script setup>
import { useRouter } from 'vue-router';

const router = useRouter();

const generateProductLink = () => {
  const productId = 456; // 假设这是我们要查看详情的商品 id
  const resolved = router.resolve({
    name: 'product',
    params: { id: productId }
  });
  const link = resolved.href;
  console.log(link); // 输出类似于 /product/456 的 URL
};
</script>

我们主要还可以使用到resolve返回值,例如我再解析一个以下这样的路由：

    //指定要解析的路由以及其参数
    let routes = router.resolve({
        path: "/home",
        query: {
            Id: 802,
            Type: 'Create'
        }
    });
    
   console.log("routes", routes);

那么解析出来的结果如下：

{
    "fullPath": "/home?Id=802&Type=Create",
    "hash": "",
    "query": {
        "EvalId": "802",
        "Type": "Create"
    },
    "name": "home",
    "path": "/home",
    "params": {},
    "matched": [
        {
            "path": "/home",
            "name": "home",
            "meta": {
                "sideMenu": false,
                "requireAuth": false
            },
            "props": {
                "default": false
            },
            "children": [],
            "instances": {},
            "leaveGuards": {},
            "updateGuards": {},
            "enterCallbacks": {},
            "components": {}
        }
    ],
    "meta": {
        "sideMenu": false,
        "requireAuth": false
    },
    "href": "#/home?Id=802&Type=Create"
}

我们主要看下href:

//返回的对象有href属性--一个完整的url，这个时候我们就完全可以使用router.push()去跳转了。
const path= #/home?Id=802&Type=Create

router.push(path)//路由跳转

---

朋友，我是喝西瓜汁的兔叽，感谢您的阅读，衷心祝福您和家人身体健康，事事顺心。