阅读视图

发现新文章,点击刷新页面。

每日一题-判断通过操作能否让字符串相等 II🟡

给你两个字符串 s1 和 s2 ,两个字符串长度都为 n ,且只包含 小写 英文字母。

你可以对两个字符串中的 任意一个 执行以下操作 任意 次:

  • 选择两个下标 i 和 j ,满足 i < j 且 j - i 是 偶数,然后 交换 这个字符串中两个下标对应的字符。

 

如果你可以让字符串 s1  s2 相等,那么返回 true ,否则返回 false 。

 

 

示例 1:

输入:s1 = "abcdba", s2 = "cabdab"
输出:true
解释:我们可以对 s1 执行以下操作:
- 选择下标 i = 0 ,j = 2 ,得到字符串 s1 = "cbadba" 。
- 选择下标 i = 2 ,j = 4 ,得到字符串 s1 = "cbbdaa" 。
- 选择下标 i = 1 ,j = 5 ,得到字符串 s1 = "cabdab" = s2 。

示例 2:

输入:s1 = "abe", s2 = "bea"
输出:false
解释:无法让两个字符串相等。

 

提示:

  • n == s1.length == s2.length
  • 1 <= n <= 105
  • s1 和 s2 只包含小写英文字母。

7005. 判断通过操作能否让字符串相等 II 简单易懂的c++代码 新手推荐

Problem: 7005. 判断通过操作能否让字符串相等 II

[TOC]

思路

讲述看到这一题的思路

解题方法

对每个字符串的奇数位,偶数位进行排序从小到大。并且用一个临时的字符串数组存放a[0]放奇数排好的,a[1]放偶数排好的。
最后返回拼接,对比。

复杂度

  • 时间复杂度:

$O(nlogn)$

  • 空间复杂度:

$O(1)$

image.png

Code

###C++


class Solution {
public:
    string work(string & s)
    {
        string a[2];
        for(int i=0;i<s.size();i++)  //奇数放a[1],偶数放a[0]
            a[i%2]+=s[i];
        for(int i=0;i<2;i++)         //分别排序
            sort(a[i].begin(),a[i].end());
        return a[0]+a[1];            //组合
    }
    bool checkStrings(string s1, string s2) {
        return work(s1)==work(s2);   //对比
    }
};

看下标为偶数/奇数的字符个数是否都一样(Python/Java/C++/Go)

有一个更强的结论:改成 $j-i=2$,也是一样的。

既然可以交换相距为 $2$ 的字符,那么相距为 $4$ 的字符可以通过多次交换实现。例如 $x-y-z$ 变成 $y-x-z$ 变成 $y-z-x$ 变成 $z-y-z$。

依此类推,所有相距为偶数的字符都可以随意交换。

所以只需要看下标为偶数的字符个数是否都一样,下标为奇数的字符个数是否都一样。

请看 视频讲解

class Solution:
    def checkStrings(self, s1: str, s2: str) -> bool:
        return Counter(s1[::2]) == Counter(s2[::2]) and Counter(s1[1::2]) == Counter(s2[1::2])
class Solution {
    public boolean checkStrings(String s1, String s2) {
        int[][] cnt1 = new int[2][26];
        int[][] cnt2 = new int[2][26];
        for (int i = 0; i < s1.length(); i++) {
            cnt1[i % 2][s1.charAt(i) - 'a']++;
            cnt2[i % 2][s2.charAt(i) - 'a']++;
        }
        return Arrays.deepEquals(cnt1, cnt2);
    }
}
class Solution {
public:
    bool checkStrings(string s1, string s2) {
        int cnt1[2][26]{}, cnt2[2][26]{};
        for (int i = 0; i < s1.length(); i++) {
            cnt1[i % 2][s1[i] - 'a']++;
            cnt2[i % 2][s2[i] - 'a']++;
        }
        return memcmp(cnt1, cnt2, sizeof(cnt1)) == 0;
    }
};
func checkStrings(s1, s2 string) bool {
var cnt1, cnt2 [2][26]int
for i, c := range s1 {
cnt1[i%2][c-'a']++
cnt2[i%2][s2[i]-'a']++
}
return cnt1 == cnt2
}

复杂度分析

  • 时间复杂度:$\mathcal{O}(n+|\Sigma|)$,其中 $n$ 为 $s_1$ 的长度。
  • 空间复杂度:$\mathcal{O}(|\Sigma|)$,其中 $|\Sigma|$ 为字符集合的大小,本题中字符均为小写字母,所以 $|\Sigma|=26$。

思考题

改成 $j-i=3$ 要怎么做?

分类题单

如何科学刷题?

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

我的题解精选(已分类)

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

哈希表-简易思路

可以通过记录偶数下标和奇数下标的哈希表是否相同即可。

class Solution {
public:
    bool checkStrings(string s1, string s2) {
        int n = s1.size();
        vector<int> mp1(26), mp2(26);
        for (int i = 0; i < n; i++) {
            if (i % 2 == 0 || i == 0) {
                ++mp1[s1[i] - 'a'];
            } else {
                ++mp2[s1[i] - 'a'];
            }
        }
        vector<int> mp3(26), mp4(26);
        for (int i = 0; i < n; i++) {
            if (i % 2 == 0 || i == 0) {
                ++mp3[s2[i] - 'a'];
            } else {
                ++mp4[s2[i] - 'a'];
            }
        }
        for (int i = 0; i < 26; i++) {
            if (mp1[i] != mp3[i] || mp2[i] != mp4[i]) return false;
        }
        return true;
    }
};
class Solution {
    public boolean checkStrings(String s1, String s2) {
        int n = s1.length();
        int[] mp1 = new int[26];
        int[] mp2 = new int[26];

        for (int i = 0; i < n; i++) {
            if (i % 2 == 0 || i == 0) {
                mp1[s1.charAt(i) - 'a']++;
            } else {
                mp2[s1.charAt(i) - 'a']++;
            }
        }

        int[] mp3 = new int[26];
        int[] mp4 = new int[26];

        for (int i = 0; i < n; i++) {
            if (i % 2 == 0 || i == 0) {
                mp3[s2.charAt(i) - 'a']++;
            } else {
                mp4[s2.charAt(i) - 'a']++;
            }
        }

        for (int i = 0; i < 26; i++) {
            if (mp1[i] != mp3[i] || mp2[i] != mp4[i]) {
                return false;
            }
        }
        return true;
    }
}
func checkStrings(s1 string, s2 string) bool {
    n := len(s1)
    mp1 := make([]int, 26)
    mp2 := make([]int, 26)

    for i := 0; i < n; i++ {
        if i%2 == 0 || i == 0 {
            mp1[s1[i]-'a']++
        } else {
            mp2[s1[i]-'a']++
        }
    }

    mp3 := make([]int, 26)
    mp4 := make([]int, 26)

    for i := 0; i < n; i++ {
        if i%2 == 0 || i == 0 {
            mp3[s2[i]-'a']++
        } else {
            mp4[s2[i]-'a']++
        }
    }

    for i := 0; i < 26; i++ {
        if mp1[i] != mp3[i] || mp2[i] != mp4[i] {
            return false
        }
    }
    return true
}

从“连接失败”到丝滑登录:我用 ethers.js 连接 MetaMask 的完整踩坑实录

背景

上个月,我接手了一个新的 NFT 铸造平台前端开发。项目要求很简单:用户进入网站,点击“连接钱包”按钮,用 MetaMask 登录,然后页面显示其钱包地址和 ETH 余额。这听起来是 Web3 开发的“Hello World”,对吧?我心想,用老伙计 ethers.js 分分钟搞定。毕竟之前参与 DeFi 项目时也用过,感觉轻车熟路。于是,我新建了一个 React 项目,安装好 ethers,开始撸代码。没想到,就是这个看似简单的任务,让我在接下来的几个小时里,跟各种奇怪的错误和浏览器行为斗智斗勇。

问题分析

我最开始的思路非常直接:检查 window.ethereum 是否存在(这是 MetaMask 注入的对象),然后用 ethers.providers.Web3Provider 包装它,最后调用 provider.send('eth_requestAccounts') 来请求账户授权。代码一气呵成,运行,点击按钮——控制台一片寂静,页面毫无反应。

我第一反应是 MetaMask 没安装?检查了一下,扩展明明好好的。然后我加了一堆 console.log,发现 window.ethereum 确实是存在的。那问题出在哪?我仔细阅读了 ethers.js 文档,发现了一个关键点:MetaMask 从 v8 开始,window.ethereum 的 API 发生了变化,它现在是一个 EIP-1193 规范的 Provider,而 ethers.jsWeb3Provider 正是为了适配这种规范而设计的。我的思路没错啊。

接着,我尝试在按钮点击事件里直接写:

const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });

这次弹窗出来了!这说明基础连接请求是通的。那么问题就锁定在 ethers.js 的用法上了。我意识到,我可能忽略了异步状态和 React 生命周期的配合,以及一些错误处理的边界情况。是时候重新梳理,一步步构建一个健壮的连接流程了。

核心实现

第一步:检测 Provider 与浏览器兼容性

首先,我们不能假设用户一定安装了 MetaMask。因此,连接之前必须先做检测。同时,现代 MetaMask 也可能同时注入 window.ethereum 和旧的 window.web3,我们应该优先使用新的。

// 检测函数
const checkIfMetaMaskInstalled = () => {
  // 检查是否有 EIP-1193 规范的 provider
  if (window.ethereum && window.ethereum.isMetaMask) {
    return true;
  }
  // 如果用户使用的是非常老的版本,可能只有 window.web3
  if (window.web3 && window.web3.currentProvider) {
    console.warn('检测到旧版 MetaMask,建议用户升级。');
    // 这里可以做一些降级处理,但为了简单,我们先返回false引导用户
    return false;
  }
  return false;
};

这里有个坑:仅仅检查 window.ethereum 是不够的,因为其他钱包(如 Coinbase Wallet)也可能注入这个对象。所以加上 window.ethereum.isMetaMask 属性判断更准确。但注意,这个属性是 MetaMask 特有的。

第二步:初始化 Ethers Provider 和 Signer

检测通过后,我们需要初始化 ethers 的核心对象:Provider 和 Signer。Provider 是连接区块链的抽象,Signer 代表一个有签名权限的账户。

import { ethers } from 'ethers';

const initializeProviderAndSigner = async () => {
  // 再次确认,避免竞态条件
  if (!window.ethereum) {
    throw new Error('请安装 MetaMask!');
  }

  // 1. 创建 Web3Provider
  // 注意:ethers v5 和 v6 的导入方式不同,这里是 v5
  const provider = new ethers.providers.Web3Provider(window.ethereum, 'any'); // 'any' 表示支持任何网络

  // 2. 请求账户授权,这会弹出 MetaMask 窗口
  await provider.send('eth_requestAccounts', []);

  // 3. 获取 Signer
  const signer = provider.getSigner();

  // 4. 获取当前账户地址
  const address = await signer.getAddress();

  return { provider, signer, address };
};

注意这个细节new ethers.providers.Web3Provider(window.ethereum, ‘any’) 中的第二个参数 ‘any’。这是网络配置,‘any’ 允许任何网络。如果你只支持特定网络(如主网),可以传入 ‘homestead’。使用 ‘any’ 能让用户在切换网络(比如从以太坊主网切换到 Polygon)时,我们的 provider 能自动适应,而不会报错。

第三步:监听账户与网络变化

用户可能在连接后切换 MetaMask 账户,或者切换网络。如果我们的前端没有监听这些事件,状态就会不同步,导致显示错误的地址或余额。

const setupEventListeners = (provider: ethers.providers.Web3Provider, updateAccountCallback: (address: string) => void) => {
  // 监听 accountsChanged 事件(用户切换账户)
  window.ethereum.on('accountsChanged', (accounts: string[]) => {
    if (accounts.length === 0) {
      // 用户锁定了钱包或断开了所有账户
      console.log('请连接钱包');
      updateAccountCallback('');
    } else {
      // 账户切换了
      console.log('当前账户变为:', accounts[0]);
      updateAccountCallback(accounts[0]);
      // 注意:这里不需要再次请求授权(eth_requestAccounts)
    }
  });

  // 监听 chainChanged 事件(用户切换网络)
  window.ethereum.on('chainChanged', (_chainId: string) => {
    // 链ID是十六进制字符串,例如“0x1”(主网)
    console.log('网络切换,新的Chain ID:', _chainId);
    // 页面完全重载是最简单的方式,因为很多合约实例、provider都需要重新初始化
    window.location.reload();
  });
};

这里有个大坑chainChanged 事件触发后,简单的更新状态可能不够。因为网络变了,之前初始化的 Provider 实例内部可能还缓存着旧网络的 RPC 信息,直接使用可能导致后续的 RPC 调用发往错误的网络。最稳妥的办法是刷新页面,让所有组件重新初始化。虽然体验略有中断,但能保证状态绝对干净。在更复杂的 DApp 中,你可能需要设计一个更精细的状态管理方案来优雅地处理网络切换。

第四步:获取账户余额并整合到 React 状态

最后,我们把上面的功能整合到一个 React 组件中,并获取账户的 ETH 余额。

import { useState, useEffect, useCallback } from 'react';

const useMetaMask = () => {
  const [account, setAccount] = useState<string>('');
  const [balance, setBalance] = useState<string>('');
  const [isConnecting, setIsConnecting] = useState<boolean>(false);
  const [error, setError] = useState<string>('');

  const connectWallet = useCallback(async () => {
    setIsConnecting(true);
    setError('');
    try {
      if (!checkIfMetaMaskInstalled()) {
        throw new Error('未检测到 MetaMask,请安装后重试。');
      }

      const { provider, signer, address } = await initializeProviderAndSigner();
      setAccount(address);

      // 获取余额
      const balanceRaw = await provider.getBalance(address);
      const balanceFormatted = ethers.utils.formatEther(balanceRaw);
      setBalance(balanceFormatted);

      // 设置事件监听
      setupEventListeners(provider, (newAddress) => {
        setAccount(newAddress);
        if (newAddress) {
          // 如果切换到了新账户,重新获取余额
          provider.getBalance(newAddress).then(bal => setBalance(ethers.utils.formatEther(bal)));
        } else {
          setBalance('');
        }
      });

    } catch (err: any) {
      console.error('连接钱包失败:', err);
      setError(err.message || '连接失败');
      setAccount('');
      setBalance('');
    } finally {
      setIsConnecting(false);
    }
  }, []); // 依赖项为空,因为这个函数只在初始化时定义一次

  // 组件卸载时,移除事件监听(避免内存泄漏)
  useEffect(() => {
    return () => {
      if (window.ethereum && window.ethereum.removeListener) {
        // 注意:ethers provider 包装后,事件源还是 window.ethereum
        window.ethereum.removeAllListeners('accountsChanged');
        window.ethereum.removeAllListeners('chainChanged');
      }
    };
  }, []);

  return { account, balance, isConnecting, error, connectWallet };
};

注意这个细节:获取的余额是 BigNumber 类型,单位是 wei(1 ETH = 10^18 wei)。必须用 ethers.utils.formatEther 将其转换为可读的 ETH 单位字符串。另外,错误处理非常重要,要把 MetaMask 抛出的错误(比如用户拒绝连接)友好地展示给用户。

完整代码

下面是一个可以直接在 React 项目中使用的完整组件示例:

// MetaMaskConnector.tsx
import React, { useState, useEffect, useCallback } from 'react';
import { ethers } from 'ethers';

// 类型声明
declare global {
  interface Window {
    ethereum?: any;
    web3?: any;
  }
}

const MetaMaskConnector: React.FC = () => {
  const [account, setAccount] = useState<string>('');
  const [balance, setBalance] = useState<string>('');
  const [isConnecting, setIsConnecting] = useState<boolean>(false);
  const [error, setError] = useState<string>('');
  const [provider, setProvider] = useState<ethers.providers.Web3Provider | null>(null);

  // 1. 检测 MetaMask
  const checkIfMetaMaskInstalled = useCallback((): boolean => {
    return !!(window.ethereum && window.ethereum.isMetaMask);
  }, []);

  // 2. 初始化
  const initializeWallet = useCallback(async () => {
    if (!window.ethereum) throw new Error('未安装 MetaMask');

    const prov = new ethers.providers.Web3Provider(window.ethereum, 'any');
    await prov.send('eth_requestAccounts', []);
    const signer = prov.getSigner();
    const address = await signer.getAddress();

    return { prov, address };
  }, []);

  // 3. 连接钱包主函数
  const connectWallet = useCallback(async () => {
    setIsConnecting(true);
    setError('');
    try {
      if (!checkIfMetaMaskInstalled()) {
        throw new Error('请安装 MetaMask 浏览器扩展。');
      }

      const { prov, address } = await initializeWallet();
      setProvider(prov);
      setAccount(address);

      // 获取余额
      const balanceRaw = await prov.getBalance(address);
      setBalance(ethers.utils.formatEther(balanceRaw));

    } catch (err: any) {
      console.error('连接失败:', err);
      setError(err.message || '未知错误');
      setAccount('');
      setBalance('');
    } finally {
      setIsConnecting(false);
    }
  }, [checkIfMetaMaskInstalled, initializeWallet]);

  // 4. 设置事件监听
  useEffect(() => {
    if (!provider || !window.ethereum) return;

    const handleAccountsChanged = (accounts: string[]) => {
      if (accounts.length === 0) {
        // 用户锁定了钱包
        setAccount('');
        setBalance('');
        setError('钱包已断开连接。');
      } else if (accounts[0] !== account) {
        // 切换了账户
        setAccount(accounts[0]);
        provider.getBalance(accounts[0]).then(bal => {
          setBalance(ethers.utils.formatEther(bal));
        });
      }
    };

    const handleChainChanged = () => {
      // 网络切换,建议刷新页面
      window.location.reload();
    };

    window.ethereum.on('accountsChanged', handleAccountsChanged);
    window.ethereum.on('chainChanged', handleChainChanged);

    // 清理函数
    return () => {
      if (window.ethereum && window.ethereum.removeListener) {
        window.ethereum.removeListener('accountsChanged', handleAccountsChanged);
        window.ethereum.removeListener('chainChanged', handleChainChanged);
      }
    };
  }, [provider, account]);

  // 5. 页面加载时尝试自动连接(可选,谨慎使用)
  useEffect(() => {
    const tryAutoConnect = async () => {
      if (checkIfMetaMaskInstalled() && window.ethereum.isConnected()) {
        // 检查是否已经授权过
        const accounts = await window.ethereum.request({ method: 'eth_accounts' });
        if (accounts.length > 0) {
          // 自动连接
          connectWallet();
        }
      }
    };
    tryAutoConnect();
  }, [checkIfMetaMaskInstalled, connectWallet]);

  return (
    <div style={{ padding: '20px', fontFamily: 'sans-serif' }}>
      <h2>MetaMask 钱包连接示例</h2>
      {!account ? (
        <div>
          <button
            onClick={connectWallet}
            disabled={isConnecting}
            style={{
              padding: '10px 20px',
              fontSize: '16px',
              cursor: isConnecting ? 'wait' : 'pointer',
            }}
          >
            {isConnecting ? '连接中...' : '连接 MetaMask'}
          </button>
          {error && <p style={{ color: 'red' }}>错误: {error}</p>}
        </div>
      ) : (
        <div>
          <p><strong>连接成功!</strong></p>
          <p><strong>账户地址:</strong> {`${account.substring(0, 6)}...${account.substring(account.length - 4)}`}</p>
          <p><strong>ETH 余额:</strong> {parseFloat(balance).toFixed(4)} ETH</p>
          <button
            onClick={() => {
              setAccount('');
              setBalance('');
              setError('');
            }}
            style={{ marginTop: '10px', padding: '5px 10px' }}
          >
            断开连接(前端)
          </button>
          <p style={{ fontSize: '12px', color: '#666' }}>
            (注意:这只是前端清除状态,MetaMask 中的连接授权仍需在其界面内管理)
          </p>
        </div>
      )}
      {!checkIfMetaMaskInstalled() && (
        <p style={{ color: 'orange', marginTop: '10px' }}>
          未检测到 MetaMask。请
          <a href="https://metamask.io/download/" target="_blank" rel="noopener noreferrer">下载安装</a>
          后刷新页面。
        </p>
      )}
    </div>
  );
};

export default MetaMaskConnector;

踩坑记录

  1. window.ethereumundefined,但 MetaMask 已安装。

    • 问题:在 Next.js 或 SSR 框架中,代码可能在服务器端执行,那里没有 window 对象。
    • 解决:所有对 window.ethereum 的访问都必须放在 useEffect 中或通过 typeof window !== ‘undefined’ 进行保护。
  2. 用户拒绝连接后,再次点击按钮无效。

    • 问题:MetaMask 会记住用户的拒绝操作,短时间内再次调用 eth_requestAccounts 不会弹出窗口。
    • 解决:引导用户点击 MetaMask 扩展图标,在弹出界面中手动重置已拒绝的站点授权。这是 MetaMask 的用户体验设计,前端无法绕过。
  3. accountsChanged 事件在初次连接时也触发了。

    • 问题:有些版本的 MetaMask 在用户授权账户后,会立即触发一次 accountsChanged 事件,导致事件处理函数和初始化逻辑重复执行。
    • 解决:在事件处理函数中,通过对比新旧账户地址来判断是初次连接还是主动切换。如果旧地址为空字符串,新地址有值,可以视为初次连接的一部分,避免不必要的状态更新或重复请求。
  4. 余额显示为巨大的整数。

    • 问题:直接 console.logprovider.getBalance() 获取的结果,显示为一个包含 hex 属性的对象或一个巨大的数字。
    • 解决:这是 ethers.jsBigNumber 类型。必须使用 ethers.utils.formatEther 进行单位转换。我差点自己写转换函数,幸好查了文档。

小结

通过这次实践,我深刻体会到 Web3 前端开发中“细节决定成败”——Provider的初始化参数、事件监听的绑定与清理、异步错误处理,每一个环节疏忽都可能导致功能失效。完整的钱包连接不仅仅是弹出授权窗口,更要考虑用户后续的所有操作路径。下一步,我可以在此基础上集成合约调用、签名消息等功能,并考虑用 wagmi 这样的高阶库来管理更复杂的状态。

Pretext:一个绕过 DOM 的纯 JavaScript 排版引擎

本文首发 猩猩程序员 欢迎关注

在 Web 前端开发中,"文本到底有多高"这个看似简单的问题,一直是困扰开发者的一大难题。传统做法是将文本塞入 DOM,然后通过 getBoundingClientRectoffsetHeight 等 API 来获取尺寸,但这种操作会触发浏览器的布局回流(layout reflow) ——这是浏览器中最昂贵的操作之一。现在,由 Cheng Lou 开源的 Pretext 库,用一种全新的方式彻底解决了这个问题。

Cheng Lou 是前端领域的重量级人物,曾参与 ReactJS、ReasonML、ReScript、Messenger 以及 Midjourney 等知名项目的开发。他在 2026 年 3 月底正式发布了 Pretext,一经发布便在社区引发广泛关注。

Pretext 是什么?

Pretext 是一个纯 JavaScript/TypeScript 编写的多行文本测量与排版库。它的核心理念是:完全绕过 DOM,用纯算术运算完成文本高度计算与行排版。 它借助浏览器自身的字体引擎(通过 Canvas 的 measureText)作为真实度量来源,实现了自己的文本测量逻辑。换句话说,Pretext 做了一次前期准备(prepare),之后的所有布局计算都是极其廉价的纯数学运算,无需再次触碰 DOM。

更令人印象深刻的是,Pretext 支持几乎所有你能想到的语言和文字系统,包括 emoji 和混合双向文本(Bidi),并且针对不同浏览器的排版差异进行了专门处理。

为什么需要 Pretext?

Web 开发中,文本高度的获取是许多高级 UI 功能的基石,但传统方法的代价太高。Pretext 的出现为以下场景提供了全新的解决方案。

虚拟列表与遮挡剔除(Virtualization/Occlusion)。 在构建长列表或无限滚动界面时,开发者需要知道每个条目的高度以正确计算滚动位置。过去,这通常依赖粗略的估算或缓存值。Pretext 能以极低的成本精确计算文本高度,让虚拟列表的实现变得可靠且高效。

自定义布局引擎。 想在 JavaScript 中实现瀑布流(Masonry)布局、类 Flexbox 布局,或是对布局值进行微调而不依赖 CSS hack?Pretext 提供的精确文本尺寸信息,正是这些自定义布局所需的关键输入。

开发时验证。 特别是在 AI 辅助生成 UI 的今天,开发者可以在不打开浏览器的情况下验证按钮上的文案是否会溢出到下一行。

消除布局偏移(Layout Shift)。 当新文本加载后需要重新锚定滚动位置时,Pretext 可以提前计算高度,从而避免恼人的页面跳动。

核心 API 设计

Pretext 的 API 设计非常精巧,分为两个主要使用场景。

场景一:快速测量段落高度

这是最常见的使用方式。只需两步:先用 prepare() 做一次性的文本分析和度量,然后用 layout() 进行纯算术计算。

import { prepare, layout } from '@chenglou/pretext'

const prepared = prepare('AGI .   ', '16px Inter')
const { height, lineCount } = layout(prepared, textWidth, 20)

prepare() 负责繁重的前期工作:规范化空白字符、分词分段、应用断行规则,以及通过 Canvas 度量各段的宽度,最终返回一个不透明的句柄。layout() 则是高频热路径——只做纯数学运算,无任何 DOM 交互。

在官方的基准测试中,对 500 段文本的批处理中,prepare() 耗时约 19ms,而 layout() 仅需约 0.09ms。这意味着在需要反复重排布局的场景(如窗口缩放、响应式调整)中,性能优势极为显著。

场景二:手动逐行排版

对于更高级的渲染需求,Pretext 提供了一套丰富的底层 API,支持渲染到 Canvas、SVG、WebGL 等非 DOM 目标。

layoutWithLines() 可以在固定宽度下返回所有行的详细信息:

import { prepareWithSegments, layoutWithLines } from '@chenglou/pretext'

const prepared = prepareWithSegments('AGI .   ', '18px "Helvetica Neue"')
const { lines } = layoutWithLines(prepared, 320, 26)
for (let i = 0; i < lines.length; i++) ctx.fillText(lines[i].text, 0, i * 26)

walkLineRanges() 是一个低级 API,可以在不构建文本字符串的情况下遍历行宽和游标信息,非常适合做投机性布局探索——例如通过二分搜索找到一个"恰到好处"的容器宽度,实现 CSS 原生无法做到的多行文本"收缩包裹(shrink-wrap)"效果。

let maxW = 0
walkLineRanges(prepared, 320, line => { if (line.width > maxW) maxW = line.width })
// maxW 就是最宽行的宽度——也就是能容纳文本的最窄容器宽度!

layoutNextLine() 则提供了迭代器风格的逐行排版能力,允许每一行使用不同的宽度。这对于文本环绕浮动元素的场景尤其有用:

let cursor = { segmentIndex: 0, graphemeIndex: 0 }
let y = 0

while (true) {
  const width = y < image.bottom ? columnWidth - image.width : columnWidth
  const line = layoutNextLine(prepared, cursor, width)
  if (line === null) break
  ctx.fillText(line.text, 0, y)
  cursor = line.end
  y += 26
}

pre-wrap 模式

Pretext 还支持 pre-wrap 白空间模式,适用于类似 <textarea> 的场景,保留普通空格、\t 制表符和 \n 硬换行符。只需在 prepare()prepareWithSegments() 中传入 { whiteSpace: 'pre-wrap' } 选项即可。制表符遵循浏览器默认的 tab-size: 8 行为。

当前限制

Pretext 目前并不试图成为一个完整的字体渲染引擎,而是聚焦于最常见的文本排版配置:white-space: normal(或 pre-wrap)、word-break: normaloverflow-wrap: break-wordline-break: auto。在 macOS 上,使用 system-ui 字体可能影响 layout() 的精度,建议使用具名字体。此外,由于默认包含 overflow-wrap: break-word,在极窄的容器中,单词可能会在字素(grapheme)边界处被断开。

设计哲学与技术渊源

Pretext 的核心架构可以追溯到 Sebastian Markbage 在上一个十年创建的 text-layout 项目。其中利用 Canvas measureText 进行字形度量、借鉴 pdf.js 的双向文本处理、以及流式断行算法等设计思想,都被 Pretext 继承和进一步完善。

值得注意的是,Pretext 的迭代方法被描述为"非常 AI 友好"——这意味着开发者可以很方便地让 AI 工具利用 Pretext 的 API 来构建和验证复杂的文本布局。

对 Web 开发的意义

Pretext 的发布标志着 Web 文本排版领域的一个重要里程碑。长期以来,Web 开发者不得不将布局决策完全交给浏览器的 CSS 引擎,而 Pretext 打开了一扇新的大门——让 JavaScript 拥有了独立于 DOM 的、精确的文本排版能力。

这对于构建下一代 Web UI 具有深远影响。无论是 AI 驱动的动态界面生成、高性能虚拟滚动列表、跨渲染目标(Canvas/SVG/WebGL/服务端)的统一文本排版,还是 CSS 原生无法实现的"收缩包裹"与"平衡文本"布局,Pretext 都提供了坚实的基础。

快速上手

安装非常简单:

npm install @chenglou/pretext

想要体验更多 Demo,可以访问 chenglou.me/pretext 或克隆仓库后运行 bun install && bun start 在本地查看。

总结下吧

Pretext 用一种优雅而务实的方式,解决了 Web 开发中一个由来已久的痛点。它不是要取代浏览器的排版引擎,而是为开发者提供了一个轻量、快速、精确的补充工具,让文本测量不再是性能瓶颈,让布局创新不再受限于 DOM 的束缚。对于任何需要精确控制文本排版的前端项目来说,Pretext 都值得关注和尝试。

本文首发 猩猩程序员 欢迎关注

Ctrl ACV工程师的提效之路:删掉项目中的冗余

在前端项目的开发周期中,随着功能的迭代、人员的更替,项目中会逐渐积累大量的冗余文件和未被使用的依赖包。这些“累赘”不仅会占用存储空间,还会拖慢项目的构建速度、增加维护成本,甚至可能引发潜在的兼容性问题。因此,定期对前端项目进行冗余清理,是保障项目稳定高效运行的必要举措。

为什么会产生冗余?

(一)依赖包的“历史遗留”

在前端项目开发过程中,为了快速实现某些功能,开发者通常会引入各种各样的第三方依赖包,新建项目时可能是从老项目复制过来的,有很多冗余依赖,然而,随着项目的推进,部分功能可能被废弃、重构或者替换,但是对应的依赖包却没有及时被移除。

(二)文件的“迭代残留”

在项目的功能迭代过程中,开发者会不断创建新的文件来实现新的功能,同时也会对旧的文件进行修改、重构。然而,很多时候,旧的文件并没有被及时删除,而是被保留在项目中,成为“历史遗留文件”。这些文件可能是早期的草稿版本、被废弃的组件、测试用的临时文件等。

【例子】从index.vue文件复制了一份index Copy.vue,结果没用上;另外就是有些开发者喜欢复制index_old.vue去记录老版本代码,实际上过了一段时间的版本迭代之后,新代码已经稳定运行,老代码还原回来也会报错,变得毫无意义。

(三)配置文件的“过时无效”

前端项目中通常包含大量的配置文件,如package.json、webpack.config.js、.babelrc等。随着项目技术栈的升级、构建工具的更新,这些配置文件中的一些配置项可能会变得过时或者无效。例如,当Webpack从4.x版本升级到5.x版本时,一些旧的配置项如optimization.splitChunks的默认值发生了变化,旧的配置可能不再适用,但开发者可能没有及时更新配置文件,导致配置文件中存在冗余的配置项。此外,一些配置文件中可能还残留着针对已废弃功能的配置,这些配置不仅没有实际作用,还会增加配置文件的复杂度。

(四)团队协作中的“沟通盲区”

在多人协作的前端项目中,由于沟通不畅或者信息不对称,也容易导致冗余的产生。例如,当一个开发者负责开发某个功能模块时,可能会创建一些临时文件或者引入一些依赖包,但是在功能完成后,没有及时告知其他团队成员,也没有将这些文件或依赖从项目中移除。而其他团队成员在不知情的情况下,可能会继续基于这些冗余内容进行开发,导致冗余进一步积累。此外,不同开发者的开发习惯和规范不一致,也可能导致项目中出现重复的文件或依赖。

冗余清理的方法与工具

删除依赖:depcheck

执行之后,会列出这几个依赖列表,例如:

Unused dependencies:

  • lodash
    Unused devDependencies:
  • eslint-plugin-vue@6.2.2
    Missing dependencies:
  • axios

删除多余的文件

借助AI工具(Trae),直接帮我们生成了一个Node.js脚本,输出未被引用的文件:

const fs = require('fs');
const path = require('path');

// Recursively get all files with specified extensions
function getAllFiles(dir, extensions) {
  let files = [];
  const items = fs.readdirSync(dir, { withFileTypes: true });
  
  for (const item of items) {
    const itemPath = path.join(dir, item.name);
    if (item.isDirectory()) {
      files = [...files, ...getAllFiles(itemPath, extensions)];
    } else if (extensions.includes(path.extname(item.name))) {
      files.push(itemPath);
    }
  }
  
  return files;
}

function analyzeUnusedFiles() {
  const srcDir = '/my-pro/src';
  const projectRoot = '/my-pro';
  
  // Get all TypeScript, Vue, and JavaScript files
  const extensions = ['.ts', '.vue', '.js', '.tsx', '.jsx'];
  const absoluteFiles = getAllFiles(srcDir, extensions);
  
  const importRegex = /from\s+['"]([^'"]+)['"]/g;
  const referencedFiles = new Set();
  
  // Add main.ts as referenced since it's imported in index.html
  const mainTsPath = path.join(srcDir, 'main.ts');
  referencedFiles.add(mainTsPath);
  
  // Check index.html for references to main.ts
  const indexHtmlPath = path.join(projectRoot, 'index.html');
  if (fs.existsSync(indexHtmlPath)) {
    const indexContent = fs.readFileSync(indexHtmlPath, 'utf8');
    if (indexContent.includes('/src/main.ts')) {
      referencedFiles.add(mainTsPath);
    }
  }
  
  // Track all referenced files
  for (const file of absoluteFiles) {
    if (fs.existsSync(file)) {
      const content = fs.readFileSync(file, 'utf8');
      let match;
      
      // Check for import statements
      while ((match = importRegex.exec(content)) !== null) {
        let importedPath = match[1];
        
        // Handle alias imports
        if (importedPath.startsWith('/@/')) {
          importedPath = importedPath.replace('/@/', '');
          importedPath = path.join(srcDir, importedPath);
        } 
        // Handle relative imports
        else if (importedPath.startsWith('./') || importedPath.startsWith('../')) {
          importedPath = path.resolve(path.dirname(file), importedPath);
        }
        
        // Add common extensions if missing
        if (!path.extname(importedPath)) {
          const exts = ['.ts', '.vue', '.js', '.tsx', '.jsx'];
          for (const ext of exts) {
            const candidate = importedPath + ext;
            if (fs.existsSync(candidate)) {
              importedPath = candidate;
              break;
            }
          }
        }
        
        // Add to referenced files if it exists
        if (fs.existsSync(importedPath)) {
          referencedFiles.add(importedPath);
        }
      }
      
      // Check for dynamic imports
      const dynamicImportRegex = /import\(['"]([^'"]+)['"]\)/g;
      let dynamicMatch;
      while ((dynamicMatch = dynamicImportRegex.exec(content)) !== null) {
        let importedPath = dynamicMatch[1];
        
        // Handle alias imports
        if (importedPath.startsWith('/@/')) {
          importedPath = importedPath.replace('/@/', '');
          importedPath = path.join(srcDir, importedPath);
        } 
        // Handle relative imports
        else if (importedPath.startsWith('./') || importedPath.startsWith('../')) {
          importedPath = path.resolve(path.dirname(file), importedPath);
        }
        
        // Add common extensions if missing
        if (!path.extname(importedPath)) {
          const exts = ['.ts', '.vue', '.js', '.tsx', '.jsx'];
          for (const ext of exts) {
            const candidate = importedPath + ext;
            if (fs.existsSync(candidate)) {
              importedPath = candidate;
              break;
            }
          }
        }
        
        // Add to referenced files if it exists
        if (fs.existsSync(importedPath)) {
          referencedFiles.add(importedPath);
        }
      }
    }
  }
  
  // Find unreferenced files
  const unreferencedFiles = absoluteFiles.filter(file => !referencedFiles.has(file));
  
  console.log('未被引用的文件:');
  unreferencedFiles.forEach(file => console.log(file.replace(srcDir, '')));
}

analyzeUnusedFiles();

输出结果:

204bb29a-730b-4711-b293-bdf774378f1e.png

94640c74-a2cc-46b6-8f8a-481f7c4bfbb3.png

AI给我们的思路是:使用脚本递归扫描项目文件,检测import语句和动态import,识别被引用的文件。

删除空文件夹

分支切换的时候经常会出现,我们也可以通过执行脚本去删除对应文件夹。

const rimraf = require('rimraf');
const fs = require('fs');
const path = require('path'); 

// 递归遍历目录,找出所有空目录
function findEmptyDirs(dir) {  
  const emptyDirs = [];  
  const items = fs.readdirSync(dir);  
  for (const item of items) {    
    const itemPath = path.join(dir, item);    
    const stats = fs.statSync(itemPath);    
    if (stats.isDirectory()) {      
      const subItems = fs.readdirSync(itemPath);      
      if (subItems.length === 0) {        
        emptyDirs.push(itemPath);      
      } else {        
        emptyDirs.push(...findEmptyDirs(itemPath));      
      }    
    }
  }  
  return emptyDirs;
} 

// 删除所有空目录
function deleteEmptyDirs(rootDir) {  
  const emptyDirs = findEmptyDirs(rootDir);  
  console.log(`找到 ${emptyDirs.length} 个空目录`);   
  for (const dir of emptyDirs) {    
    rimraf(dir, (err) => {      
      if (err) {        
        console.error(`删除失败: ${dir}`, err);      
      } else {        
        console.log(`已删除: ${dir}`);      
      }    
    });
  }
} 

// 示例调用

deleteEmptyDirs('./src'); 

如果空文件夹是有用的,可以在空文件夹里新建一个.gitkeep文件用于占位。

清理后的验证与总结

  1. 依靠AI,但不依赖

在上面用AI生成脚本检索代码的时候,我发现AI帮我把package.json完全替换了,显然这不是我们所期望的。我们通过AI找到了冗余文件,不能直接让AI帮忙删掉,而是自己去再做一次复核,然后再去删除,毕竟项目负责人是我们自己,不是AI。我们不能和用户说:由于AI误删除了文件导致了项目无法运行。

  1. 性能指标评估

清理完成后,我们应该对项目的性能指标进行评估,对比清理前后的差异,衡量清理的效果。主要关注的性能指标包括:项目的构建时间、打包后的文件大小、页面的加载时间等等。

  1. 清理文档记录

最后,要对本次冗余清理的过程和结果进行详细的文档记录。记录的内容包括:清理的时间、清理的范围、使用的工具、移除的依赖包列表、删除的文件列表、遇到的问题及解决方法、性能指标的对比结果等。

  1. 对冗余代码进行分析

清理了一些代码之后,我们需要去分析冗余产生的原因,从而去规范化我们的代码。例如,静态图片文件要统一放在指定的目录下;相似组件库,例如vue-draggablesortable.js只取一个即可。

五、结语

前端项目的冗余清理是一项长期而细致的工作,它不仅仅是简单地删除几个文件或依赖包,更是对项目技术债务的一次梳理和优化。通过定期的冗余清理,我们可以为前端项目减轻负担,提高项目的构建速度和运行性能,降低维护成本,同时也能让项目的代码结构更加清晰、易于理解。在清理过程中,我们也要注意对现有业务不能有影响,需要自己验证,并且备份原始代码,在出问题的时候可以一键回退。

LangChain 进阶实战:从玩具 Demo 到生产级 AI 应用(JS/TS 全栈版)

前端 er 零门槛上手,从核心原理、LCEL 黑魔法、RAG 优化到生产避坑,一篇给你讲透!

家人们谁懂啊!2026 年了,还有人觉得 LangChain 就是个「拼 LLM 接口的胶水框架」?

我见过太多同学,跟着教程 npm install 一下,写了个调用 DeepSeek 的 Demo,输出一句「你好,我是 AI」,就发朋友圈说自己入门 AI 开发了。结果产品经理一句「给我做个能查公司内部文档的客服机器人」,直接傻眼:

  • RAG 检索永远答非所问,上下文驴唇不对马嘴
  • 多轮对话聊个七八轮就崩,token 直接爆仓
  • 想换个性价比更高的模型,代码要全量重写
  • 线上一限流、API 一超时,服务直接原地升天

最后只能甩锅「LangChain 不好用」—— 不是它不好用,是你只解锁了它 10% 的能力!

上一篇我们聊了 LangChain 的核心概念和基础 Demo,这篇咱们直接进阶,用前端 er 听得懂的梗、能直接抄的生产级代码,把 LangChain 扒得明明白白,带你从「调包侠」直接进阶成 AI 应用架构师。

一、重新认识 LangChain:你之前对它的理解可能全错了

很多人对 LangChain 的认知还停留在「Lang = 语言模型,Chain = 把步骤串起来」,格局小了家人们!咱们先把底层逻辑掰扯清楚。

1.1 它不是胶水代码,是 AI 应用界的「React」

咱们前端 er 都懂:原生 JS 能写页面,但是为什么大家都用 React?因为 React 把 DOM 操作、状态管理、组件复用、生命周期这些脏活累活全给你封装好了,让你能专注写业务逻辑,不用天天跟浏览器兼容性对线。

LangChain 就是干了一模一样的事!

  • 原生 LLM 接口 = 原生 JS:能实现基础功能,但是每加一个需求就要写一堆重复代码,换个环境直接不兼容
  • LangChain = React:把提示词工程、模型适配、数据流转、工具调用、内存管理、异常处理这些 AI 应用的通用脏活全给你封装了,提供了一套标准化的开发范式,让你不用天天跟不同模型的 API 文档对线。

它的核心从来不是「把接口串起来」,而是一套可组合、可扩展、生产级可用的 AI 原生应用开发框架

1.2 前端 er 狂喜!JS/TS 生态才是全栈开发的王炸

很多人有个误区:「LangChain 是 Python 的,JS 版本就是个玩具」。大错特错!

现在 LangChain 的 JS/TS 版本已经完全成熟,生产级可用,而且对咱们前端全栈开发者来说,它简直是天选之子:

  • 完全基于 Node.js 开发,原生支持 ESM 规范,跟你天天写的 Next.js、NestJS、Express 无缝衔接,不用额外学一门 Python
  • 完美兼容前端生态,你熟悉的 npm、yarn、pnpm 直接用,dotenv、axios 这些常用库随便接
  • 类型提示拉满!TypeScript 原生支持,写代码的时候 IDE 直接给你提示参数、报错,不用对着文档瞎猜,这一点直接吊打 Python 版本的体验。

别再被 Python 教程劝退了,用你最熟悉的 JS/TS,照样能写出顶级的 AI 应用。

1.3 适配器模式的终极奥义:不止是换模型,是给应用上了「双保险」

上一篇我们聊了 LangChain 的适配器模式,很多同学看完只记住了「能随便换模型」,但它的价值远不止于此。

咱们用前端最熟悉的 Axios 来类比:Axios 为什么好用?因为它封装了浏览器和 Node.js 的 http 请求差异,不管你在什么环境,都是一套get/postAPI,不用管底层是 XMLHttpRequest 还是 http 模块。

LangChain 的适配器就是干了这件事!

  • 不管你用的是 DeepSeek、OpenAI、Anthropic,还是本地部署的 Ollama 模型,全都是一套标准的invoke/stream接口
  • 不用去研究每个模型的请求格式、参数差异、鉴权方式,适配器全给你处理好了
  • 你写的业务逻辑完全和底层模型解耦,真正做到了「面向接口编程,而不是面向实现编程」

这带来的生产级价值,可比「换模型方便」大多了:

  1. 模型 A/B 测试:同一个业务逻辑,同时测试 DeepSeek 和 GPT-4o 的效果,只需要改一行模型名,业务代码一行不用动
  2. 灰度发布:新模型上线,先给 10% 的流量用,出问题一键切回旧模型,零成本
  3. 降级容灾:主模型 API 挂了、限流了,自动切换到备用模型,服务完全不中断,用户根本感知不到
  4. 成本优化:简单问题用便宜的小模型,复杂问题用强大的大模型,自动切换,把你的 API 账单直接打下来

二、LangChain 灵魂核心:LCEL 表达式,告别祖传屎山代码

如果你还在用旧版的ConversationChainRetrievalQA这些类式 API,那你真的错过了 LangChain 最香的部分 ——LCEL(LangChain Expression Language,LangChain 表达式语言)

LCEL 就是 LangChain 的「React Hooks」,直接告别了旧时代类式 API 的冗余、难复用、难维护的问题,用声明式的管道写法,让你写 AI 应用跟写 Promise 链一样简单。

2.1 什么是 LCEL?5 分钟上手,比写 Promise 链还简单

LCEL 的核心就是一个管道符|,把不同的功能模块像管道一样串起来,前一个模块的输出,就是后一个模块的输入。

咱们用前端的概念类比:它就像 RxJS 的pipe方法,或者数组的链式调用,把数据处理的每一步拆成独立的函数,可组合、可复用、可测试。

先看个最简单的例子,对比一下旧写法和 LCEL 写法的差距:

旧版类式 API 写法(又臭又长,难维护)

javascript

import 'dotenv/config';
import { ChatDeepSeek } from '@langchain/deepseek';
import { PromptTemplate } from '@langchain/core/prompts';
import { LLMChain } from 'langchain/chains';

// 初始化模型
const model = new ChatDeepSeek({
  model: 'deepseek-reasoner',
  temperature: 0.7,
});

// 创建提示词模板
const prompt = PromptTemplate.fromTemplate(`
  你是一个{role},请用不超过{limit}个字符回答:{question}
`);

// 创建Chain
const chain = new LLMChain({ llm: model, prompt: prompt });

// 调用Chain
const res = await chain.call({
  role: '前端架构师',
  limit: 50,
  question: '怎么快速学好React?'
});

console.log(res.text);

LCEL 写法(简洁优雅,一行搞定核心逻辑)

javascript

import 'dotenv/config';
import { ChatDeepSeek } from '@langchain/deepseek';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

// 1. 初始化模型和输出解析器
const model = new ChatDeepSeek({
  model: 'deepseek-reasoner',
  temperature: 0.7,
});
// 输出解析器:直接提取模型返回的文本内容,不用再写res.content
const outputParser = new StringOutputParser();

// 2. 创建提示词模板(推荐用ChatPromptTemplate,适配对话模型)
const prompt = ChatPromptTemplate.fromTemplate(`
  你是一个{role},请用不超过{limit}个字符回答:{question}
`);

// 3. 用LCEL管道符串起整个流程,一行搞定Chain!
const chain = prompt | model | outputParser;

// 4. 调用Chain,就是这么简单
const res = await chain.invoke({
  role: '前端架构师',
  limit: 50,
  question: '怎么快速学好React?'
});

console.log(res);

看到差距了吗?LCEL 写法逻辑清晰,每一步做什么一目了然,没有冗余的类实例化,模块之间完全解耦,想改哪一步直接替换就行,比如想换个模型,直接把 model 变量换了,其他代码一行不用动。

2.2 LCEL 的黑魔法:生产级能力开箱即用

你以为 LCEL 只是写法简洁?它真正的王炸,是自带了一堆生产级的能力,不用你自己手写一堆胶水代码。

能力 1:流式输出,一行代码搞定打字机效果

上一篇的 Demo 里我们只用了invoke方法,但是做聊天应用,必须要有流式输出的打字机效果,LCEL 里直接用stream方法就行,简单到离谱:

javascript

// 还是上面那个chain,一行代码实现流式输出
const stream = await chain.stream({
  role: '前端架构师',
  limit: 100,
  question: '怎么快速学好Vue3?'
});

// 遍历流,逐字输出,前端直接对接打字机效果
for await (const chunk of stream) {
  process.stdout.write(chunk);
}

能力 2:自动重试 + 降级容灾,再也不怕 API 崩了

生产环境最怕什么?模型 API 超时、限流、挂了。LCEL 自带withRetrywithFallbacks方法,直接给你的服务上双保险:

javascript

import 'dotenv/config';
import { ChatDeepSeek } from '@langchain/deepseek';
import { ChatOllama } from '@langchain/ollama';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

// 主模型:DeepSeek在线模型
const primaryModel = new ChatDeepSeek({
  model: 'deepseek-reasoner',
  temperature: 0.7,
}).withRetry({
  stopAfterAttempt: 3, // 失败最多重试3次
});

// 备用模型:本地部署的Ollama模型,完全不依赖外网
const fallbackModel = new ChatOllama({
  model: 'qwen:7b',
  temperature: 0.7,
});

// 带降级的模型:主模型失败,自动切备用模型
const modelWithFallback = primaryModel.withFallbacks({
  fallbacks: [fallbackModel],
});

// 构建Chain
const prompt = ChatPromptTemplate.fromTemplate(`
  你是一个{role},请用不超过{limit}个字符回答:{question}
`);
const outputParser = new StringOutputParser();
const chain = prompt | modelWithFallback | outputParser;

// 调用的时候,完全不用关心底层的重试和降级,安心用就行
const res = await chain.invoke({
  role: '前端架构师',
  limit: 50,
  question: '怎么学好TypeScript?'
});
console.log(res);

就这么几行代码,你就实现了生产级的重试和降级容灾,再也不怕 API 挂了导致服务不可用。

能力 3:并行执行,大幅提升接口响应速度

遇到需要同时调用多个模型、或者多个步骤的场景,LCEL 支持并行执行,不用你自己写 Promise.all,直接提升响应速度。

比如做一个 AI 文案生成工具,需要同时生成标题、正文、结尾,用 LCEL 的并行写法,直接同时执行,不用串行等待:

javascript

import { RunnableParallel, RunnablePassthrough } from '@langchain/core/runnables';
import { ChatDeepSeek } from '@langchain/deepseek';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const model = new ChatDeepSeek({ model: 'deepseek-reasoner' });
const outputParser = new StringOutputParser();

// 标题生成Chain
const titleChain = ChatPromptTemplate.fromTemplate('给文章主题{topic}生成3个爆款标题') | model | outputParser;
// 正文生成Chain
const contentChain = ChatPromptTemplate.fromTemplate('给文章主题{topic}生成100字的正文') | model | outputParser;
// 结尾生成Chain
const endChain = ChatPromptTemplate.fromTemplate('给文章主题{topic}生成一个引导点赞关注的结尾') | model | outputParser;

// 并行执行三个Chain,同时返回结果
const parallelChain = RunnableParallel({
  title: titleChain,
  content: contentChain,
  end: endChain,
  // 把原始输入也透传下去
  topic: new RunnablePassthrough(),
});

// 一次调用,同时拿到三个结果,响应速度直接拉满
const res = await parallelChain.invoke('前端进阶学习指南');
console.log(res);

三、核心场景进阶实战:从玩具 Demo 到生产级应用

上一篇我们讲了基础的 Demo,这一节咱们直接升级,解决大家做项目时真正会遇到的痛点问题。

3.1 提示词工程进阶:告别瞎写 Prompt,用模板体系拿捏模型输出

很多同学写 Prompt 就是随便写一句话,结果模型输出的内容忽好忽坏,完全不可控。其实 LangChain 已经给你提供了完整的提示词模板体系,帮你稳定模型输出。

进阶 1:用 ChatPromptTemplate 替代 PromptTemplate,适配对话模型

现在我们用的几乎都是对话大模型(Chat Model),而不是旧的补全模型,用ChatPromptTemplate可以精准控制消息的角色(系统提示、用户消息、AI 消息),效果比PromptTemplate好太多。

javascript

import { ChatPromptTemplate } from '@langchain/core/prompts';

// 精准定义系统提示、用户消息,角色分离,模型更听话
const prompt = ChatPromptTemplate.fromMessages([
  // 系统提示词:给模型定规矩,写在这里不会被用户的输入轻易绕过
  ["system", "你是一个资深的前端架构师,回答必须简洁专业,只讲干货,不写废话,每一条回答不超过3条要点"],
  // 用户消息:用占位符接收用户输入
  ["human", "用户的问题:{question},相关技术栈:{techStack}"],
]);

// 格式化提示词
const formattedPrompt = await prompt.formatMessages({
  question: 'React项目性能优化怎么做?',
  techStack: 'React 18 + TypeScript'
});

console.log(formattedPrompt);

进阶 2:少样本学习 FewShotPromptTemplate,让模型秒懂你的要求

想让模型按照你的格式输出,与其写一大堆要求,不如直接给几个示例,这就是少样本学习。LangChain 的FewShotChatMessagePromptTemplate可以轻松实现:

javascript

import { ChatPromptTemplate, FewShotChatMessagePromptTemplate } from '@langchain/core/prompts';

// 1. 定义示例:告诉模型你想要的输入输出格式
const examples = [
  {
    input: "Vue和React的区别",
    output: "核心差异:1. 核心理念:Vue渐进式框架,React函数式UI;2. 响应式:Vue双向绑定,React单向数据流;3. 上手难度:Vue更低,React对JS要求更高"
  },
  {
    input: "var和let的区别",
    output: "核心差异:1. 作用域:var函数作用域,let块级作用域;2. 提升:var存在变量提升,let存在暂时性死区;3. 重复声明:var允许,let不允许"
  }
];

// 2. 定义单个示例的模板
const examplePrompt = ChatPromptTemplate.fromMessages([
  ["human", "{input}"],
  ["ai", "{output}"],
]);

// 3. 创建少样本提示词模板
const fewShotPrompt = new FewShotChatMessagePromptTemplate({
  examplePrompt,
  examples,
  inputVariables: ["input"],
});

// 4. 拼接成最终的提示词
const finalPrompt = ChatPromptTemplate.fromMessages([
  ["system", "你是一个资深前端讲师,回答问题必须简洁明了,只列核心差异,不写废话"],
  fewShotPrompt, // 把示例插在这里,模型自动学习格式
  ["human", "{input}"],
]);

// 调用模型,直接输出符合你格式的内容
const chain = finalPrompt | new ChatDeepSeek({ model: 'deepseek-reasoner' }) | new StringOutputParser();
const res = await chain.invoke({ input: "Promise和async/await的区别" });
console.log(res);

用了少样本学习,你会发现模型输出的内容稳定性直接拉满,再也不会出现格式乱飘的情况。

3.2 RAG 系统进阶:解决答非所问,从「能用」到「好用」

RAG(检索增强生成)是大家用得最多的场景,上一篇我们给了基础的 Demo,但是很多同学做完发现,检索出来的内容根本不对,模型永远答非所问。这一节咱们就把 RAG 的核心优化点讲透。

先上基于 LCEL 的生产级 RAG 完整代码

javascript

import 'dotenv/config';
// 文档加载与分割
import { PDFLoader } from '@langchain/community/document_loaders/fs/pdf';
import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters';
// 嵌入与向量数据库
import { OpenAIEmbeddings } from '@langchain/openai';
import { Chroma } from '@langchain/community/vectorstores/chroma';
// LCEL核心组件
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { ChatDeepSeek } from '@langchain/deepseek';
import { StringOutputParser } from '@langchain/core/output_parsers';
import { RunnablePassthrough, RunnableSequence } from '@langchain/core/runnables';

// ========== 第一步:文档处理与向量库构建 ==========
// 1. 加载PDF文档
const loader = new PDFLoader('./前端开发规范.pdf');
const docs = await loader.load();

// 2. 文本分块(核心优化点!)
const textSplitter = new RecursiveCharacterTextSplitter({
  chunkSize: 500, // 块大小:技术文档推荐300-800,不要太大也不要太小
  chunkOverlap: 100, // 块重叠:保留上下文,避免关键信息被截断
  separators: ["\n\n", "\n", "。", "!", "?", " ", ""], // 按语义分割,不要硬切
});
const splitDocs = await textSplitter.splitDocuments(docs);

// 3. 生成嵌入向量,存入向量数据库
const embeddings = new OpenAIEmbeddings({
  model: 'text-embedding-3-small', // 用专门的嵌入模型,不要用大模型的嵌入能力
});
const vectorStore = await Chroma.fromDocuments(splitDocs, embeddings, {
  collectionName: 'frontend_docs',
});

// 4. 创建检索器
const retriever = vectorStore.asRetriever({
  k: 4, // 只返回最相关的4条内容,不是越多越好
  searchType: 'similarity', // 相似度检索,进阶可以用mmr最大边际相关性,兼顾相关性和多样性
});

// ========== 第二步:构建RAG问答Chain ==========
// 1. 构建RAG专属提示词模板
const ragPrompt = ChatPromptTemplate.fromTemplate(`
你是一个专业的文档问答助手,只能基于下面的参考文档回答用户的问题,绝对不能编造文档里没有的信息。
如果参考文档里没有相关内容,直接回答“抱歉,参考文档中没有相关内容”,不要自己瞎编。

参考文档:
{context}

用户的问题:{question}
`);

// 2. 格式化检索到的文档内容
const formatDocs = (docs) => docs.map(doc => doc.pageContent).join('\n\n');

// 3. 用LCEL构建RAG Chain
const ragChain = RunnableSequence.from([
  // 并行获取检索内容和原始问题
  {
    context: (input) => retriever.invoke(input.question).then(formatDocs),
    question: new RunnablePassthrough(),
  },
  ragPrompt,
  new ChatDeepSeek({ model: 'deepseek-reasoner', temperature: 0 }),
  new StringOutputParser(),
]);

// ========== 第三步:调用问答 ==========
const answer = await ragChain.invoke({
  question: '公司的Git提交规范是什么?'
});

console.log(answer);

RAG 核心优化点,解决答非所问的痛点

  1. 文本分块是重中之重很多人 RAG 效果差,90% 的问题都出在分块上。不要一刀切用 1000 甚至 2000 的 chunkSize,技术文档推荐 300-800 的 chunkSize,一定要加 chunkOverlap,避免关键信息被切在两个块里,还要按语义分割,不要硬把一句话切成两半。
  2. 嵌入模型要选对不要用大模型自带的嵌入能力,专门的嵌入模型(比如 OpenAI 的 text-embedding-3-small、阿里云的 text-embedding-v2)效果好太多,而且成本极低。
  3. 检索结果不是越多越好很多人觉得 k 设得越大,内容越多越好,其实不对。太多无关内容会污染模型的上下文,反而让回答跑偏,一般 k 设 3-5 就足够了。
  4. 提示词一定要加边界限制必须明确告诉模型「只能用参考文档的内容回答,不能编造信息,没有就说不知道」,不然模型会一本正经地胡说八道,这就是 RAG 里最常见的「幻觉问题」。

3.3 多轮对话进阶:聊一百轮也不崩的上下文管理

做聊天机器人,最常见的问题就是聊个十几轮就崩了,要么上下文全忘了,要么 token 直接爆了。核心就是没做好上下文的内存管理。

LangChain 提供了完整的对话内存管理方案,结合 LCEL,轻松实现不崩的多轮对话:

javascript

import 'dotenv/config';
import { ChatDeepSeek } from '@langchain/deepseek';
import { ChatPromptTemplate, MessagesPlaceholder } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';
import { RunnableWithMessageHistory } from '@langchain/core/runnables';
import { ChatMessageHistory } from '@langchain/community/stores/message/in_memory';

// 1. 构建带历史消息的提示词模板
const chatPrompt = ChatPromptTemplate.fromMessages([
  ["system", "你是一个友好的前端技术助手,专业解答前端相关问题,回答简洁易懂"],
  // 关键:MessagesPlaceholder用来存放历史对话消息
  new MessagesPlaceholder("chat_history"),
  ["human", "{input}"],
]);

// 2. 初始化模型和Chain
const model = new ChatDeepSeek({ model: 'deepseek-reasoner', temperature: 0.7 });
const outputParser = new StringOutputParser();
const chatChain = chatPrompt | model | outputParser;

// 3. 给对话加上历史消息管理
const chainWithHistory = new RunnableWithMessageHistory({
  runnable: chatChain,
  // 按sessionId存储不同用户的对话历史,多用户场景直接用
  getMessageHistory: (sessionId) => new ChatMessageHistory(),
  inputMessagesKey: "input",
  historyMessagesKey: "chat_history",
});

// 4. 多轮对话测试
// 第一轮对话
const res1 = await chainWithHistory.invoke(
  { input: "我现在在学React,应该先学什么?" },
  { configurable: { sessionId: "user_001" } } // 每个用户一个唯一sessionId
);
console.log("AI回答1:", res1);

// 第二轮对话,AI自动记住上下文
const res2 = await chainWithHistory.invoke(
  { input: "那学完这些之后呢?" },
  { configurable: { sessionId: "user_001" } }
);
console.log("AI回答2:", res2);

进阶优化:解决 token 爆仓问题

对话轮次多了,历史消息会越来越长,token 直接就爆了。这时候可以用对话摘要内存,自动把长对话压缩成摘要,只保留关键信息,大幅减少 token 占用:

javascript

import { ConversationSummaryMemory } from 'langchain/memory';

// 初始化摘要内存,自动总结对话历史
const memory = new ConversationSummaryMemory({
  llm: new ChatDeepSeek({ model: 'deepseek-reasoner' }),
  returnMessages: true,
  memoryKey: "chat_history",
});

// 每次对话结束,自动把新的对话内容更新到摘要里
// 不管聊多少轮,摘要都只会保留关键信息,token占用极低

四、LangChain 生产级避坑指南:90% 的人都踩过这些坑

坑 1:乱用 PromptTemplate,对话模型效果直接打对折

很多人不管什么场景都用PromptTemplate,但对于对话模型,ChatPromptTemplate的角色分离能力,能让模型的效果和可控性提升一个量级。记住:只要用的是 Chat 模型,优先用ChatPromptTemplate

坑 2:文本分块一刀切,检索永远答非所问

不要随便抄个 chunkSize=1000 就用,不同的文档类型,分块策略完全不一样:

  • 技术文档、合同条款:chunkSize 小一点,300-800,保证语义完整
  • 小说、长文:chunkSize 可以大一点,800-1500,保留上下文
  • 一定要加 chunkOverlap,一般是 chunkSize 的 10%-20%

坑 3:不做 token 管理,聊几句就爆上下文

永远不要把完整的历史消息全丢给模型,一定要做上下文管理:要么用滑动窗口只保留最近的几轮对话,要么用摘要内存压缩历史消息,不然 token 账单和报错会教你做人。

坑 4:没有错误处理和降级,线上一限流就崩

LLM 的 API 不是 100% 稳定的,超时、限流、报错是常有的事。生产环境一定要加重试机制和降级策略,LCEL 的withRetrywithFallbacks直接用,不要自己手写一堆 try/catch。

坑 5:不用 LCEL,硬写胶水代码,维护到哭

很多人还在用旧的LLMChainRetrievalQA,甚至自己手写 Promise 串流程,代码又臭又长,改一个需求就要重构一半。赶紧拥抱 LCEL,声明式的写法,可组合、可复用、好维护,谁用谁知道。

坑 6:硬编码 API 密钥,上线直接被刷爆欠费

永远不要把 API 密钥硬编码在代码里!一定要用环境变量加载,生产环境用云服务的密钥管理服务,不然代码一提交到 GitHub,密钥直接被爬虫爬走,一夜之间欠费几万块,这种事真的天天都在发生。

五、进阶玩法拓展:LangChain 生态的王炸组合

掌握了上面的内容,你已经能写出生产级的 AI 应用了。如果还想进阶,LangChain 的生态还有两个王炸组合:

  1. LangSmith:LangChain 官方的调试、监控、评估平台,能看到每一次调用的完整链路、token 消耗、耗时,还能给模型的输出做评分,调试 AI 应用跟调试前端代码一样简单。
  2. LangGraph:基于 LangChain 的智能体工作流框架,能实现更复杂的循环、分支、多智能体协作,比如代码生成机器人(写代码→执行→调试→重写)、智能客服机器人(检索→判断→转人工),能实现普通 Chain 做不到的复杂业务逻辑。

结尾

其实 LangChain 从来都不是什么高深的东西,它只是把 AI 应用开发里的通用能力做了封装,让我们这些开发者不用重复造轮子,能专注于业务逻辑本身。

对于咱们前端全栈开发者来说,JS/TS 版本的 LangChain,就是我们进入 AI 应用开发领域最好的入场券 —— 不用学新的语言,不用换技术栈,用你最熟悉的代码,就能写出顶级的 AI 应用。

AI时代,前端开发者到底还剩下什么?又该往哪里走?

说实话,这两年做前端,多少都有点焦虑。

以前我们比的是谁更会写组件、谁更懂框架、谁能把页面调得更丝滑。但现在,很多“基础活”AI已经能帮你完成得七七八八:写一个表单页、封装一个 hooks、甚至帮你搭个项目骨架,都不算难事。

那问题就来了——AI时代,前端开发者到底还剩下什么?又该往哪里走?

我结合自己这段时间的实际体验,聊点更接地气的。


一、先认清一个现实:前端不会消失,但“只会写页面”的会

如果你现在的工作主要是:

  • 根据设计稿还原页面
  • 写一些 CRUD 表单
  • 调接口、拼数据

那说难听点,这部分确实是最容易被AI覆盖的

不是说岗位没了,而是——
门槛被拉低了,竞争的人变多了

以前你写一个后台系统可能要2天,现在AI+模板可能半天搞定,那公司还需要那么多人吗?

所以第一步不是卷,而是换一个思路:

不要再把自己当“切图工程师”,而是产品 + 技术的中间人


二、真正拉开差距的,是这3件事

1. 业务理解能力(这点越来越重要)

很多人忽略这一点,但这是最难被替代的。

举个很真实的例子:

同样是做一个“订单列表页”:

  • 初级:把接口数据展示出来
  • 中级:加筛选、分页、优化体验
  • 高级:会问——
  • 为什么这个字段要展示?
  • 用户最关心的是哪个状态?
  • 能不能减少操作路径?

AI可以帮你写代码,但不会帮你做业务决策(至少现在不行)。

所以建议你:

  • 多参与需求评审(哪怕一开始听不懂)
  • 主动问“为什么这么做”
  • 站在用户角度思考,而不是“需求让我怎么写”

2. 工程能力(前端真正的护城河)

AI能写代码,但它不太擅长这些:

  • 项目架构设计
  • 状态管理方案选择
  • 性能优化(首屏、缓存、分包)
  • 构建体系(webpack / vite / CI/CD)

比如你问AI:“怎么优化首屏?”

它能给你一堆方案,但真正落地的时候:

  • 哪些组件该懒加载?
  • 哪些数据该预取?
  • SSR 还是 CSR?
  • 怎么平衡开发成本?

这些,还是靠经验 + 判断

建议你重点提升:

  • 模块拆分能力(组件设计,而不是写组件)
  • 性能意识(不是优化,而是“设计时就避免问题”)
  • 工程化思维(自动化、规范、工具链)

3. 利用AI的能力(不是对抗,而是放大)

很多人现在还停留在:

“AI帮我写代码”

但更高阶的用法是:

让AI成为你的“外包团队”

举个我平时的用法:

  • 用AI快速生成:
    • demo代码
    • 正则表达式
    • 类型定义(TypeScript)
  • 让AI帮我:
    • review思路(不是代码)
    • 提供多种实现方案
  • 用AI做:
    • 文档生成
    • 单测补全

你会发现:

厉害的人不是不用AI,而是用得更狠


三、未来更吃香的前端,会是什么样?

我个人的判断(偏实战派一点):

1. “会后端一点”的前端

现在越来越多的项目是:

  • BFF(Backend For Frontend)
  • Node.js 中间层
  • Serverless

如果你只停留在浏览器那一层,其实是受限的。

建议:

  • 至少能写简单 Node 服务
  • 懂接口设计,而不是只会“调接口”

2. “懂AI一点”的前端

不是让你去做算法,而是:

知道怎么把AI接进产品里

比如:

  • 聊天类功能(流式输出、SSE)
  • AI辅助表单填写
  • 智能推荐 / 搜索

未来会变成:

前端 = UI + 交互 + AI体验设计


3. “更像产品经理”的前端

很多优秀前端,其实已经在做:

  • 交互设计优化
  • 用户路径分析
  • 数据埋点 & 反馈闭环

AI会写代码,但:

不会替你理解用户情绪


四、一些更具体的提升建议(不虚的)

我尽量说点能直接做的:

技术层面

  • 把一个项目“重构一遍”
    • 不只是改代码,而是:
      • 模块怎么拆?
      • 状态怎么管理?
  • 深入一个点:
    • 比如性能优化 / SSR / 渲染机制

工程层面

  • 自己搭一套脚手架(哪怕简化版)
  • 把 CI/CD 跑通一次(GitHub Actions 也行)

AI结合

  • 每天强制用AI写一部分代码
  • 但一定要:
    自己review + 改造,而不是直接用

思维层面

多问3个问题:

  • 这个需求的“本质”是什么?
  • 有没有更简单的实现?
  • 用户真的需要这个吗?

五、最后说点实在的

AI不会让前端消失,但会让这个行业:

两极分化更严重

  • 会用AI + 有经验的人 → 效率爆炸
  • 只会写基础代码的人 → 被快速替代

所以关键不是“学不学AI”,而是:

你有没有在变成“更高维度的前端”

🚀 AI Agent 入门实战:基于 LangChain + MCP 构建智能导游助手

🚀 AI Agent 入门实战:基于 LangChain + MCP 构建智能导游助手

前言

我是前端出身,这几年 AI 带来的变化非常明显。它不是简单的工具升级,而是在重塑整个开发方式。

我开始学习 AI Agent,主要有三个原因:

  1. 技术趋势已经很明确,AI 正在快速进入开发流程
  2. 只会写传统 CRUD 的竞争力越来越弱,前端也需要新的能力栈
  3. AI 相关岗位和项目需求在增长,早点入门,才能尽早建立自己的第二曲线

这是我学习 AI Agent 开发以来做的第一个入门项目。这个项目里,我尝试把几个核心概念真正串起来,包括:

  • 提示词设计
  • RAG 检索增强
  • Tool 工具调用
  • MCP 协议接入
  • 自定义 MCP 服务实现

如果文中有理解不够准确的地方,或者你有更好的实现方式,欢迎交流指正。

什么是 AI Agent?

AI Agent 可以理解为一个具备“感知、决策、执行”能力的智能应用。

更通俗一点说:

  • 大模型负责思考
  • 工具负责执行
  • 记忆负责上下文
  • 循环负责多步任务推进

所以,AI Agent 不只是一个会聊天的模型,而是一个能真正帮你做事的系统。


这篇文章能给你带来什么?

如果你也是前端开发者,想入门 AI Agent,这篇文章会帮你:

  1. 建立认知:理解 AI Agent 是什么、能做什么
  2. 掌握原理:工具调用、RAG 检索、MCP 协议等核心概念
  3. 动手实践:从零实现一个完整的 AI Agent 应用
  4. 串联知识:提示词工程、RAG、Tool、MCP 一次讲清

项目效果

先看一段实际运行效果:

🤖 重出江湖(输入 "quit""exit" 可退出)
请开始你的表演:
> 帮我生成余干县旅游攻略
⏳ 处理中...
🚀 工具调用中 [maps_text_search]
🚀 工具调用中 [writeFile]
✅ 结果:
已为您生成余干县旅游攻略,文件保存在:
./txt/余干县旅游攻略.md

请继续你的表演:
> 那边天气怎么样?
⏳ 处理中...
🚀 工具调用中 [maps_weather]
✅ 结果:
余干县今天天气:
🌤️ 多云转晴
🌡️ 温度:18-27°C
💨 风力:东南风3-4级
💧 湿度:65%

这里最关键的一点是:第二句里的“那边”,AI 依然能理解指的是上一轮提到的“余干县”。这就是上下文记忆在起作用。


项目架构

整个项目的数据流很简单:

用户输入
  ↓
main.mjs:管理对话入口和历史记录
  ↓
byQueryMergePrompt.mjs:做 RAG 检索,补充知识上下文
  ↓
runAgent.mjs:组装提示词,调用模型,进入工具循环
  ↓
工具层:MCP 工具、地图工具、自定义写文件工具
  ↓
返回结果给用户

关键理解点

  1. Agent 的核心是“循环”
  2. 每一步都会累加上下文
  3. 大模型负责决定要不要调用工具、调用什么工具
  4. 工具返回结果后,大模型会继续思考,直到任务完成

核心实现

1. 对话记忆

这个项目里,我先用一个消息集合 historyPrompt 来保存对话历史。

你可以把它理解成一个会持续追加的消息数组,里面记录了:

  • 用户说了什么
  • 模型回复了什么
  • 工具返回了什么

这样下一轮对话时,模型就能看到完整上下文,从而理解“那边”指的是上一轮提到的地点。

const historyPrompt = [];

const result = await runner({ historyPrompt, currentQuery: cmd });

historyPrompt.push(new HumanMessage(cmd));
historyPrompt.push(result);

这是一种最直接、最好理解的做法,特别适合入门阶段。

不过要注意,这种方式更适合 Demo 和学习场景。真正做线上项目时,LangChain 还有更正规的记忆管理方案,比如会话状态管理、消息裁剪、长期存储等能力,可以用来处理更长的上下文和多轮会话。


2. RAG 检索增强

RAG 的作用很简单:先查资料,再回答问题

它解决的是大模型容易“胡编乱造”的问题。

我的实现思路是:

  1. abu.txt 拆成小片段
  2. 转成向量
  3. 根据用户问题查最相关的片段
  4. 把结果拼进系统提示词里
const retriever = await vectorstoreRef.similaritySearchWithScore(query, 3);

const docs = retriever.filter((doc) => {
  const [document, score] = doc;
  return score && score > 0.5;
});

这里我做了一个相似度过滤,避免无关片段干扰模型判断。这个细节很重要,不然检索结果一乱,后面的回答也会跟着飘。


3. MCP 工具接入

MCP 的价值是统一工具接入标准。

你可以把它理解成 AI 工具的“标准接口”:

  • 本地工具可以通过 stdio 接入
  • 远程服务可以通过 HTTP 接入
  • 模型只需要面对统一工具格式,不用关心底层实现

我这里做了两个来源的工具:

  • 自己写的本地 MCP 服务
  • 高德地图提供的远程 MCP 服务

本地 MCP 的写法大概是这样:

server.registerTool(
  'Read_parsed_file',
  {
    description: '我可以帮你读取文件,解析文件',
    inputSchema: {
      path: z.string().describe('文件路径')
    }
  },
  async ({ path }) => {
    const content = fs.readFileSync(path, 'utf-8');
    return {
      content: [{
        type: 'text',
        text: `文件内容:${content}`
      }]
    };
  }
);

4. 工具调用循环

这是整个 Agent 最核心的地方。

流程很简单:

  1. 模型先思考
  2. 如果需要工具,就返回 tool_calls
  3. 执行工具
  4. 把工具结果加入上下文
  5. 再次调用模型
  6. 直到没有工具调用为止
let response = await model.bindTools(tools).invoke(prompt);
prompt.push(response);

let toolCalls = response.tool_calls;

while (toolCalls?.length) {
  for (const tool of toolCalls) {
    const foundTool = tools.find(t => t.name === tool.name);
    const toolResponse = await foundTool.invoke(tool.args);

    prompt.push(new ToolMessage({
      content: toolResponse,
      tool_call_id: tool.id
    }));
  }

  response = await model.bindTools(tools).invoke(prompt);
  prompt.push(response);
  toolCalls = response.tool_calls;
}

这里最容易踩坑的点是 tool_call_id。这个字段不能漏,不然工具结果和模型调用对不上,后面很容易报错。


代码结构说明

main.mjs

负责对话入口和历史记录管理。
核心作用是把用户输入和模型回复保存下来,保证下一轮还能接着聊。

runAgent.mjs

负责 Agent 主逻辑。
包括模型初始化、工具绑定、RAG 拼接、工具调用循环。

byQueryMergePrompt.mjs

负责 RAG 检索。
把本地知识库转成向量,再根据用户输入检索相关内容。

mcp-server.mjs

负责本地 MCP 工具服务。
这里主要演示一个文件读取工具,帮助理解 MCP 的标准接入方式。

tools.mjs

负责自定义工具。
这里实现的是文件写入功能,适合生成旅游攻略这类场景。


踩坑与优化

1. 历史消息要成对保存

用户输入和模型回复都要存进历史记录,不然下一轮对话模型就会“失忆”。

2. tool_call_id 不能漏

模型一次可能调用多个工具,结果必须用 tool_call_id 对上,否则会出问题。

3. MCP 路径尽量用绝对路径

本地启动 MCP 服务时,路径写错非常常见。
如果用了相对路径,运行目录一变就容易挂。

4. RAG 检索要做过滤

向量库返回的不一定全是高相关结果,做相似度过滤很有必要。

5. 记忆不要无限堆积

historyPrompt 这种方式很好理解,但如果不做裁剪,长对话会越来越长。
正式项目里,建议用 LangChain 的记忆管理能力来控制上下文长度。


总结

通过这个项目,我最直接的收获是把 AI Agent 的核心链路跑通了:

  • 让模型会思考
  • 让工具会执行
  • 让记忆能延续上下文
  • 让 RAG 给回答提供依据
  • 让 MCP 把外部能力接进来

这个项目虽然还是一个入门 Demo,但已经把 Agent 的基本形态搭出来了。

对我来说,最重要的不是“做了一个能跑的项目”,而是开始真正理解:

AI Agent 不是单纯的聊天,而是把大模型变成能做事的系统。


关于作者

我是 辣椒炒代码,一名前端开发者,也是 AI Agent 的学习者。

这篇文章记录了我从零搭建第一个 AI Agent 项目的过程,希望能帮同样来自前端方向的同学,快速建立对 AI Agent 的基本认知,并真正跑通一个可用的实战案例。

标签#AI Agent #LangChain #MCP协议 #RAG #实战教程 #导游助手 #前端开发

前端性能指标接入 Prometheus 技术方案

目标:以最小指标集将 Web Vitals 数据采集、上报、存储、并在 Prometheus + Grafana 中实现"可见即所得"的展示,不扩散冗余指标。


一、整体架构

浏览器
  └─ web-vitals SDK
       └─ Navigator.sendBeacon / fetch
            └─ [POST /metrics/vitals]
                 └─ Node.js / Go 上报服务
                      ├─ 聚合 → prom-client(Histogram / Counter / Gauge)
                      └─ /metrics(Prometheus scrape endpoint)
                           └─ Prometheus → Grafana Dashboard

二、前端采集(web-vitals SDK)

2.1 只采集核心 Web Vitals

指标 含义 类型建议
LCP 最大内容绘制 Histogram(分位数)
FID / INP 首次输入延迟 / 交互响应 Histogram
CLS 累计布局偏移 Histogram
FCP 首次内容绘制 Histogram
TTFB 首字节时间 Histogram

不采集:自定义埋点、资源加载明细、长任务列表等——避免指标爆炸。

2.2 采集代码示例

// vitals-reporter.ts
import { onLCP, onFID, onCLS, onFCP, onTTFB, onINP } from 'web-vitals';

interface VitalPayload {
  name: string;   // 'LCP' | 'FID' | 'CLS' | 'FCP' | 'TTFB' | 'INP'
  value: number;  // 原始值(ms 或 score)
  rating: string; // 'good' | 'needs-improvement' | 'poor'
  page: string;   // location.pathname(不带查询参数)
}

const ENDPOINT = '/metrics/vitals';

function report(payload: VitalPayload) {
  const body = JSON.stringify(payload);
  // 优先 sendBeacon(页面卸载时不丢失)
  if (navigator.sendBeacon) {
    navigator.sendBeacon(ENDPOINT, new Blob([body], { type: 'application/json' }));
  } else {
    fetch(ENDPOINT, { method: 'POST', body, keepalive: true,
      headers: { 'Content-Type': 'application/json' } });
  }
}

function buildPayload(metric: any): VitalPayload {
  return {
    name: metric.name,
    value: metric.value,
    rating: metric.rating,
    page: location.pathname,
  };
}

onLCP(m => report(buildPayload(m)));
onFID(m => report(buildPayload(m)));
onINP(m => report(buildPayload(m)));
onCLS(m => report(buildPayload(m)));
onFCP(m => report(buildPayload(m)));
onTTFB(m => report(buildPayload(m)));

关键原则

  • page 只传 pathname不传完整 URL,防止高基数标签炸掉 Prometheus。
  • 每个指标只上报最终值(web-vitals 默认行为),不上报中间值。
  • 不附加用户 ID、Session ID 等高基数维度。

三、后端处理(Node.js + prom-client)

3.1 指标定义(仅 6 个 Histogram + 1 个 Counter)

// metrics.ts
import client from 'prom-client';

const register = new client.Registry();
client.collectDefaultMetrics({ register }); // 可选:CPU/内存等默认指标

// --- Histogram:用于分位数 p50 / p75 / p90 / p95 / p99 ---
// Bucket 设计原则:覆盖 Good / NI / Poor 阈值的边界点
const TIMING_BUCKETS = [100, 200, 300, 500, 800, 1000, 1500, 2000, 3000, 4000, 5000, 8000, 10000];
const CLS_BUCKETS    = [0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5, 1.0];

export const vitalsHistogram = new client.Histogram({
  name: 'web_vitals_duration_ms',
  help: 'Web Vitals timing metrics (LCP/FID/INP/FCP/TTFB in ms; CLS * 1000)',
  labelNames: ['metric', 'page', 'rating'] as const,
  buckets: TIMING_BUCKETS,
  registers: [register],
});

export const clsHistogram = new client.Histogram({
  name: 'web_vitals_cls_score',
  help: 'Cumulative Layout Shift score',
  labelNames: ['page', 'rating'] as const,
  buckets: CLS_BUCKETS,
  registers: [register],
});

// Counter:统计各评级的页面加载次数(Good / NI / Poor)
export const vitalsRatingCounter = new client.Counter({
  name: 'web_vitals_rating_total',
  help: 'Count of Web Vitals reports by metric and rating',
  labelNames: ['metric', 'page', 'rating'] as const,
  registers: [register],
});

export { register };

为什么用 Histogram 而非 Summary? Histogram 在 Prometheus 服务端聚合分位数(histogram_quantile),可跨实例合并;Summary 在客户端计算,无法合并多实例数据。

3.2 上报接口

// server.ts
import express from 'express';
import { vitalsHistogram, clsHistogram, vitalsRatingCounter, register } from './metrics';

const app = express();
app.use(express.json({ limit: '10kb' }));

const PAGE_ALLOWLIST = /^/[a-zA-Z0-9-_/]{0,100}$/; // 白名单,防注入

app.post('/metrics/vitals', (req, res) => {
  const { name, value, rating, page } = req.body;

  // 基本校验
  if (!['LCP','FID','INP','CLS','FCP','TTFB'].includes(name)) return res.sendStatus(400);
  if (!['good','needs-improvement','poor'].includes(rating)) return res.sendStatus(400);
  if (typeof value !== 'number' || value < 0 || value > 60000) return res.sendStatus(400);

  // 清洗 page:只保留路径,去掉查询参数和锚点
  const safePage = PAGE_ALLOWLIST.test(page) ? page : '/unknown';

  if (name === 'CLS') {
    clsHistogram.observe({ page: safePage, rating }, value);
  } else {
    vitalsHistogram.observe({ metric: name, page: safePage, rating }, value);
  }
  vitalsRatingCounter.inc({ metric: name, page: safePage, rating });

  res.sendStatus(204);
});

// Prometheus scrape endpoint
app.get('/metrics', async (_req, res) => {
  res.set('Content-Type', register.contentType);
  res.end(await register.metrics());
});

app.listen(3000);

3.3 高基数防护

防护措施 说明
page 白名单正则 防止随机路径生成海量 label 值
page 路径归一化 /product/123/product/:id(可选,用路由映射表)
不暴露 user/session 绝不作为 label
限流 单 IP 限流,防刷接口污染指标

四、Prometheus 配置

# prometheus.yml
scrape_configs:
  - job_name: 'web-vitals-backend'
    static_configs:
      - targets: ['your-backend:3000']
    scrape_interval: 15s

五、Grafana 展示:可见即所得

5.1 推荐展示面板(共 8 个 Panel)

Panel 1:核心指标分位数总览(Stat 或 Gauge)

# LCP p75(Google 推荐的评估分位数)
histogram_quantile(0.75,
  sum(rate(web_vitals_duration_ms_bucket{metric="LCP"}[5m])) by (le)
)

对 LCP / INP / FCP / TTFB 各出一个 Stat Panel,阈值颜色:

  • 绿色(Good):LCP < 2500ms、INP < 200ms、FCP < 1800ms、TTFB < 800ms
  • 黄色(NI)
  • 红色(Poor)

Panel 2:LCP 分位数趋势(Time Series)

# p50 / p75 / p95
histogram_quantile(0.50, sum(rate(web_vitals_duration_ms_bucket{metric="LCP"}[5m])) by (le))
histogram_quantile(0.75, sum(rate(web_vitals_duration_ms_bucket{metric="LCP"}[5m])) by (le))
histogram_quantile(0.95, sum(rate(web_vitals_duration_ms_bucket{metric="LCP"}[5m])) by (le))

Panel 3:INP 分位数趋势(Time Series)

histogram_quantile(0.75, sum(rate(web_vitals_duration_ms_bucket{metric="INP"}[5m])) by (le))

Panel 4:CLS p75 趋势(Time Series)

histogram_quantile(0.75, sum(rate(web_vitals_cls_score_bucket[5m])) by (le))

Panel 5:各指标 Good 率(Bar Gauge 或 Pie)

# LCP Good 率
sum(rate(web_vitals_rating_total{metric="LCP", rating="good"}[1h]))
/
sum(rate(web_vitals_rating_total{metric="LCP"}[1h]))

对 LCP / INP / CLS 各出一条,直观反映"用户体验达标率"。

Panel 6:按页面分组的 LCP p75(Bar Chart)

histogram_quantile(0.75,
  sum(rate(web_vitals_duration_ms_bucket{metric="LCP"}[30m])) by (le, page)
)

快速定位哪个页面是性能瓶颈。

Panel 7:上报量 / 错误率(Time Series)

# 每分钟上报次数
sum(rate(web_vitals_rating_total[1m])) by (metric)

监控数据采集本身是否正常。

Panel 8:TTFB p75 趋势(Time Series)

histogram_quantile(0.75, sum(rate(web_vitals_duration_ms_bucket{metric="TTFB"}[5m])) by (le))

反映服务端响应速度,与后端性能关联。


5.2 告警规则示例

# alerts.yml
groups:
  - name: web-vitals
    rules:
      - alert: LCP_P75_Too_High
        expr: |
          histogram_quantile(0.75,
            sum(rate(web_vitals_duration_ms_bucket{metric="LCP"}[10m])) by (le)
          ) > 4000
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "LCP p75 超过 4s,用户体验差"

      - alert: INP_P75_Too_High
        expr: |
          histogram_quantile(0.75,
            sum(rate(web_vitals_duration_ms_bucket{metric="INP"}[10m])) by (le)
          ) > 500
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "INP p75 超过 500ms,页面交互迟钝"

      - alert: Good_Rate_LCP_Drop
        expr: |
          sum(rate(web_vitals_rating_total{metric="LCP",rating="good"}[30m]))
          / sum(rate(web_vitals_rating_total{metric="LCP"}[30m])) < 0.5
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "LCP Good 率低于 50%,大量用户体验差"

六、指标清单汇总

指标名 类型 Labels 用途
web_vitals_duration_ms Histogram metric, page, rating 计算 LCP/FID/INP/FCP/TTFB 分位数
web_vitals_cls_score Histogram page, rating 计算 CLS 分位数
web_vitals_rating_total Counter metric, page, rating 计算 Good/NI/Poor 分布率

3 个指标,配合 label 维度满足所有展示需求,无冗余。


七、依赖版本参考

组件 版本
web-vitals ^4.x
prom-client(Node.js) ^15.x
Prometheus ^2.45
Grafana ^10.x

八、实施步骤

  1. 前端npm install web-vitals,在应用入口引入 vitals-reporter.ts
  2. 后端:部署上报服务,暴露 /metrics/vitals(POST)和 /metrics(GET)
  3. Prometheus:添加 scrape job,15s 采集间隔
  4. Grafana:导入上述 8 个 Panel,设置阈值颜色映射
  5. 告警:配置 Alertmanager 接收 Web Vitals 告警,对接钉钉 / Slack

方案遵循 Google Web Vitals 评估标准(2024),以 p75 作为主要健康评估分位数。

基于腾讯云COS的小程序素材上传功能实现

基于腾讯云COS的小程序素材上传功能实现

前言

由于开发小程序需要上传图片素材时总是需要后端协助,最近在项目中实现了一个小程序素材上传功能,支持图片上传到腾讯云COS,并提供便捷的链接复制和预览功能,减少沟通合作成本,本文将分享这个功能的实现思路和核心代码。

功能概述

小程序素材上传功能主要包括以下特性:

  • 支持批量上传图片
  • 文件格式和大小校验
  • 自定义上传路径配置
  • 支持链接复制和在线预览
  • 重复文件检测提示
  • 基于腾讯云COS的对象存储

技术方案

1. 整体架构

前端组件 → 腾讯云COS SDK → 后端获取临时凭证 → 对象存储

2. 核心依赖

import COS from 'cos-js-sdk-v5'
import { Modal, Upload, Icon, Form, Select, Input, Radio, message } from 'antd'

3. 上传流程

  1. 用户选择文件类型和业务类型
  2. 配置上传路径参数
  3. 拖拽或点击上传图片
  4. 前端获取临时凭证
  5. 直接上传到COS
  6. 返回文件链接

核心实现

1. 模态框组件结构

const AppletMaterModal = (props) => {
  const { form = {}, visible, onCancel, brandCode } = props
  const { getFieldDecorator, validateFields, getFieldsValue, getFieldValue } = form

  const [fileList, setFileList] = useState([])
  const [cosData, setCosData] = useState(null)
  const [credentials, setCredentials] = useState(null)

  const cosPromiseRef = useRef(null)

  // ...
}

2. 文件校验

在上传前进行严格的格式和大小校验:

const uploadImgValidateFields = async (file) => {
  return new Promise((resolve) => {
    validateFields(async (error, values) => {
      if (error) return resolve(false)

      // 格式校验
      const acceptStr = '.jpeg,.jpg,.png,.gif'
      const checkType = validType(file, acceptStr)
      if (!checkType) {
        message.error('仅支持JPEG/JPG/PNG/GIF格式')
        return resolve(false)
      }

      // 大小校验
      const maxSizeMB = 5
      if (file.size / 1024 / 1024 > maxSizeMB) {
        message.error(`图片大小不能超过${maxSizeMB}MB`)
        return resolve(false)
      }
      resolve(true)
    })
  })
}

// 上传图片校验
const handleBeforeUploadImg = async (file) => {
  return new Promise(async (resolve, reject) => {
    try {
      const checkResult = await uploadImgValidateFields(file)
      if (checkResult) {
        resolve(true)
      }
      resolve(false)
    } catch (error) {
      resolve(false)
    }
  })
}

3. COS实例管理

使用useRef缓存COS实例,避免重复创建:

const getCosInstance = useCallback(async (params) => {
  // 如果已有数据,直接返回
  if (cosData && credentials) {
    return { cos: cosData, credentials }
  }

  // 如果已有正在进行的请求,复用该 Promise
  if (cosPromiseRef.current) {
    return cosPromiseRef.current
  }

  // 创建新的请求
  cosPromiseRef.current = (async () => {
    try {
      const cosInstance = Cos()
      const cosInstanceData = await cosInstance.getCosInstance(params)
      setCosData(cosInstanceData.cos)
      setCredentials(cosInstanceData.credentials)
      return cosInstanceData
    } finally {
      // 请求完成后清除引用
      cosPromiseRef.current = null
    }
  })()
  return cosPromiseRef.current
}, [cosData, credentials])

4. 自定义上传逻辑

const customRequest = useCallback(async (info) => {
  const { file } = info
  const valid = await handleBeforeUploadImg(file)
  if (!valid) return

  const { businessType, path, fileUploadPathContainsDate } = getFieldsValue()
  const { name } = file

  const params = {
    file: file,
    fileType: 1,
    accessType: 1,
    fileNameList: [name],
    fileNums: 1,
    businessType: businessType,
    fileUploadPathContainsDate: fileUploadPathContainsDate,
    addFileUploadPath: path
  }

  try {
    // 等待唯一的 COS 实例数据
    const { cos, credentials } = await getCosInstance(params)
    const response = await Cos().pushObject(params, cos, credentials)
    const imgUrl = {
      name: response.fileName,
      url: `${response.domainUrl}${response.filePath}${response.fileName}`,
    }
    setFileList(prev => [...prev, imgUrl])
    message.success('上传成功')
  } catch (error) {
    if (error.code === 400000) {
      const imgUrl = {
        name: name,
        url: error.data,
        repeat: true
      }
      setFileList(prev => [...prev, imgUrl])
    }
  }
}, [fileList, cosData, credentials])

5. COS工具类封装

export class Cos {
  /**
   * 获取cos实例
   */
  async getCosInstance(params) {
    const credentials = await this.getCredential(params)
    const config = {
      TmpSecretId: credentials.tmpSecretId,
      TmpSecretKey: credentials.tmpSecretKey,
      XCosSecurityToken: credentials.sessionToken,
      StartTime: credentials.startTime,
      ExpiredTime: credentials.expiredTime,
      DomainUrl: credentials.domainUrl,
    }

    this._cos = new COS({
      getAuthorization: (_, callback) => callback(config),
    })
    return { cos: this._cos, credentials: credentials }
  }

  /**
   * 获取credential
   */
  async getCredential(params) {
    const response = await requestService('common.cosFileUpload.getCredential', {
      ...params,
    })
    const { code, data, message } = response

    if (code !== 200) {
      throw new Error(`获取cos credential 错误:${message}`)
    }

    const { expiredTime, fileUploadPath, credential, bucket, region, startTime, domainUrl } = data

    return {
      expiredTime,
      startTime,
      fileUploadPath,
      bucket,
      region,
      domainUrl,
      ...credential,
    }
  }

  /**
   * push 文件对象
   */
  async pushObject(config, cos, credentials) {
    const { fileUploadPath, bucket, region, domainUrl } = credentials
    const { key, ...record } = this.createRecord(config, { filePath: fileUploadPath })
    const { file, onProgress = null } = config

    return new Promise((resolve, reject) => {
      const payload = {
        Bucket: bucket,
        Region: region,
        Key: key,
        StorageClass: 'STANDARD',
        Body: file,
        onProgress: onProgress,
      }

      cos.putObject(payload, (err, responseData) => {
        if (err) {
          reject({ message: '上传异常,请稍后重试' })
          return
        }
        resolve({ ...responseData, ...record, domainUrl })
      })
    })
  }

  /**
   * 生成日志记录
   */
  createRecord = (config, params) => {
    const { filePath } = params
    const { accessType, module, file = {}, fileNameList = [] } = config
    const { size: fileSize, type = '' } = file
    let suffix = type.split('/')[1]
    if (!type) {
      const index = file.name.lastIndexOf('.')
      suffix = file.name.substring(index + 1)
    }

    const fileName = fileNameList.length ? `${fileNameList[0]}` : `${uuidv4().replace(/-/g, '')}.${suffix}`

    const record = {
      accessType,
      fileName,
      fileSize: fileSize / 1024,
      module,
      suffix,
      key: filePath + fileName,
      ...params,
    }
    return record
  }
}

亮点功能

1. 智能路径配置

支持自定义上传路径,可选择是否添加时间目录:

<Form.Item label="追加路径">
  {getFieldDecorator('path', {
    initialValue: 'gg',
    rules: [{ required: false }],
  })(
    <Input onChange={() => handleResetCos()} />
  )}
</Form.Item>

<Form.Item label="路径添加时间目录">
  {getFieldDecorator('fileUploadPathContainsDate', {
    initialValue: 1,
    rules: [{ required: false }],
  })(
    <Radio.Group onChange={() => handleResetCos()}>
      <Radio value={1}></Radio>
      <Radio value={0}></Radio>
    </Radio.Group>
  )}
</Form.Item>

2. 链接复制功能

提供便捷的链接复制功能,支持现代浏览器和兼容旧浏览器:

const handleCopy = (item) => {
  if (navigator.clipboard && navigator.clipboard.writeText) {
    navigator.clipboard.writeText(item.url)
      .then(() => {
        message.success('链接已复制到剪贴板')
      })
      .catch((err) => {
        message.error('复制失败: ', err)
      })
  } else {
    // Fallback for older browsers
    const textArea = document.createElement('textarea')
    textArea.value = item.url
    document.body.appendChild(textArea)
    textArea.select()
    document.execCommand('copy')
    document.body.removeChild(textArea)
    message.success('链接已复制到剪贴板')
  }
}

3. 重复文件检测

上传时检测文件是否已存在,并给出提示:

try {
  const { cos, credentials } = await getCosInstance(params)
  const response = await Cos().pushObject(params, cos, credentials)
  const imgUrl = {
    name: response.fileName,
    url: `${response.domainUrl}${response.filePath}${response.fileName}`,
  }
  setFileList(prev => [...prev, imgUrl])
  message.success('上传成功')
} catch (error) {
  if (error.code === 400000) {
    const imgUrl = {
      name: name,
      url: error.data,
      repeat: true
    }
    setFileList(prev => [...prev, imgUrl])
  }
}

4. 拖拽上传体验

使用Ant Design的Dragger组件,提供友好的拖拽上传体验:

const draggerProps = {
  name: 'file',
  multiple: true,
  accept: 'image/jpeg,image/jpg,image/png,image/gif',
  action: '',
  showUploadList: false,
  beforeUpload: () => true,
  customRequest: customRequest
}

<Dragger {...draggerProps} style={{maxWidth: '500px'}}>
  <p className="ant-upload-drag-icon">
    <Icon type="inbox" />
  </p>
  <p className="ant-upload-text">点击或拖动图片到此区域进行上传</p>
  <p className="ant-upload-hint">支持:.jpeg,.jpg,.png,.gif格式,大小不超过5Mb</p>
  <p className="ant-upload-hint">支持单次或批量上传</p>
</Dragger>

遇到的问题和解决方案

1. COS实例重复创建

问题:每次上传都创建新的COS实例,导致性能浪费

解决方案:使用useRef缓存COS实例和Promise,确保同一批次上传复用同一个实例

const cosPromiseRef = useRef(null)

const getCosInstance = useCallback(async (params) => {
  if (cosData && credentials) {
    return { cos: cosData, credentials }
  }

  if (cosPromiseRef.current) {
    return cosPromiseRef.current
  }

  cosPromiseRef.current = (async () => {
    try {
      const cosInstance = Cos()
      const cosInstanceData = await cosInstance.getCosInstance(params)
      setCosData(cosInstanceData.cos)
      setCredentials(cosInstanceData.credentials)
      return cosInstanceData
    } finally {
      cosPromiseRef.current = null
    }
  })()
  return cosPromiseRef.current
}, [cosData, credentials])

2. 临时凭证过期

问题:临时凭证有过期时间,需要及时更新

解决方案:在getCosInstance中检查凭证状态,过期时自动重新获取

const getCosInstance = useCallback(async (params) => {
  // 如果已有数据,直接返回
  if (cosData && credentials) {
    return { cos: cosData, credentials }
  }

  // 否则重新获取
  cosPromiseRef.current = (async () => {
    try {
      const cosInstance = Cos()
      const cosInstanceData = await cosInstance.getCosInstance(params)
      setCosData(cosInstanceData.cos)
      setCredentials(cosInstanceData.credentials)
      return cosInstanceData
    } finally {
      cosPromiseRef.current = null
    }
  })()
  return cosPromiseRef.current
}, [cosData, credentials])

3. 批量上传并发控制

问题:批量上传时可能出现并发冲突

解决方案:使用Promise.all管理批量上传,确保所有上传任务完成后再更新状态

async pushObject(config, cos, credentials) {
  const { file } = config
  if (Array.isArray(file)) {
    const promiseAll = []
    file.map((item, index) => {
      config.file = item
      promiseAll.push(this.uploadReal(config, cos, credentials))
    })
    return Promise.all(promiseAll.map((p) => p.catch(() => {})))
  } else {
    return this.uploadReal(config, cos, credentials)
  }
}

4. 文件格式校验

问题:需要确保上传的文件格式符合要求

解决方案:在上传前进行严格的格式校验

const uploadImgValidateFields = async (file) => {
  return new Promise((resolve) => {
    validateFields(async (error, values) => {
      if (error) return resolve(false)

      // 格式校验
      const acceptStr = '.jpeg,.jpg,.png,.gif'
      const checkType = validType(file, acceptStr)
      if (!checkType) {
        message.error('仅支持JPEG/JPG/PNG/GIF格式')
        return resolve(false)
      }

      // 大小校验
      const maxSizeMB = 5
      if (file.size / 1024 / 1024 > maxSizeMB) {
        message.error(`图片大小不能超过${maxSizeMB}MB`)
        return resolve(false)
      }
      resolve(true)
    })
  })
}

完整组件代码

import React, { memo, useCallback, useState, useRef } from 'react'
import { Modal, Upload, Icon, Form, Select, Input, Radio, message } from 'antd'
import Cos from './cos'
import { getBrandMap } from 'constant'
import {
  getBusinessTypeList,
  validType,
  fileTypeList,
} from 'scrmMessage/constans'
import { initial } from 'lodash'

import styles from './index.scss'

const { Dragger } = Upload

const formItemLayout = {
  labelCol: {
    xs: { span: 24 },
    sm: { span: 6 },
  },
  wrapperCol: {
    xs: { span: 24 },
    sm: { span: 18 },
  },
}

const brandMap = getBrandMap()

const AppletMaterModal = (props) => {
  const { form = {}, visible, onCancel, brandCode } = props
  const { getFieldDecorator, validateFields, getFieldsValue, getFieldValue } = form

  const cosPromiseRef = useRef(null)

  const [fileList, setFileList] = useState([])
  const [cosData, setCosData] = useState(null)
  const [credentials, setCredentials] = useState(null)

  const uploadImgValidateFields = async (file) => {
    return new Promise((resolve) => {
      validateFields(async (error, values) => {
        if (error) return resolve(false)

        const acceptStr = '.jpeg,.jpg,.png,.gif'
        const checkType = validType(file, acceptStr)
        if (!checkType) {
          message.error('仅支持JPEG/JPG/PNG/GIF格式')
          return resolve(false)
        }

        const maxSizeMB = 5
        if (file.size / 1024 / 1024 > maxSizeMB) {
          message.error(`图片大小不能超过${maxSizeMB}MB`)
          return resolve(false)
        }
        resolve(true)
      })
    })
  }

  const handleBeforeUploadImg = async (file) => {
    return new Promise(async (resolve, reject) => {
      try {
        const checkResult = await uploadImgValidateFields(file)
        if (checkResult) {
          resolve(true)
        }
        resolve(false)
      } catch (error) {
        resolve(false)
      }
    })
  }

  const handleCopy = (item) => {
    if (navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(item.url)
        .then(() => {
          message.success('链接已复制到剪贴板')
        })
        .catch((err) => {
          message.error('复制失败: ', err)
        })
    } else {
      const textArea = document.createElement('textarea')
      textArea.value = item.url
      document.body.appendChild(textArea)
      textArea.select()
      document.execCommand('copy')
      document.body.removeChild(textArea)
      message.success('链接已复制到剪贴板')
    }
  }

  const getCosInstance = useCallback(async (params) => {
    if (cosData && credentials) {
      return { cos: cosData, credentials }
    }

    if (cosPromiseRef.current) {
      return cosPromiseRef.current
    }

    cosPromiseRef.current = (async () => {
      try {
        const cosInstance = Cos()
        const cosInstanceData = await cosInstance.getCosInstance(params)
        setCosData(cosInstanceData.cos)
        setCredentials(cosInstanceData.credentials)
        return cosInstanceData
      } finally {
        cosPromiseRef.current = null
      }
    })()
    return cosPromiseRef.current
  }, [cosData, credentials])

  const customRequest = useCallback(async (info) => {
    const { file } = info
    const valid = await handleBeforeUploadImg(file)
    if (!valid) return

    const { businessType, path, fileUploadPathContainsDate } = getFieldsValue()
    const { name } = file

    const params = {
      file: file,
      fileType: 1,
      accessType: 1,
      fileNameList: [name],
      fileNums: 1,
      businessType: businessType,
      fileUploadPathContainsDate: fileUploadPathContainsDate,
      addFileUploadPath: path
    }

    try {
      const { cos, credentials } = await getCosInstance(params)
      const response = await Cos().pushObject(params, cos, credentials)
      const imgUrl = {
        name: response.fileName,
        url: `${response.domainUrl}${response.filePath}${response.fileName}`,
      }
      setFileList(prev => [...prev, imgUrl])
      message.success('上传成功')
    } catch (error) {
      if (error.code === 400000) {
        const imgUrl = {
          name: name,
          url: error.data,
          repeat: true
        }
        setFileList(prev => [...prev, imgUrl])
      }
    }
  }, [fileList, cosData, credentials])

  const draggerProps = {
    name: 'file',
    multiple: true,
    accept: 'image/jpeg,image/jpg,image/png,image/gif',
    action: '',
    showUploadList: false,
    beforeUpload: () => true,
    customRequest: customRequest
  }

  const handleResetCos = () => {
    setCosData(null)
    setCredentials(null)
  }

  return (
    <Modal
      title="上传图片"
      visible={visible}
      footer={null}
      okText="确定"
      cancelText="取消"
      width={500}
      onCancel={onCancel}
      maskClosable={false}
      destroyOnClose
    >
      <div>
        <Form>
          <Form.Item label="品牌" {...formItemLayout}>
            <span>{brandMap[brandCode]}</span>
          </Form.Item>
          <Form.Item label="文件类型" {...formItemLayout}>
            {getFieldDecorator('fileType', {
              initialValue: 1,
              rules: [{ required: true, message: '请选择文件类型' }],
            })(
              <Radio.Group onChange={() => handleResetCos()}>
                <Radio value={1}>图片</Radio>
                <Radio disabled={true} value={2}>文件</Radio>
                <Radio disabled={true} value={3}>视频/音频</Radio>
              </Radio.Group>
            )}
          </Form.Item>
          <Form.Item label="业务类型" {...formItemLayout}>
            {getFieldDecorator('businessType', {
              rules: [{ required: true, message: '请选择业务类型' }],
            })(
              <Select onChange={() => handleResetCos()}>
                {getBusinessTypeList(brandCode).map((item, index) => (
                  <Select.Option key={index} value={item.value}>{item.label}</Select.Option>
                ))}
              </Select>
            )}
          </Form.Item>
          <Form.Item label="追加路径" {...formItemLayout}>
            {getFieldDecorator('path', {
              initialValue: 'gg',
              rules: [{ required: false }],
            })(
              <Input onChange={() => handleResetCos()} />
            )}
          </Form.Item>
          <Form.Item label="路径添加时间目录" {...formItemLayout}>
            {getFieldDecorator('fileUploadPathContainsDate', {
              initialValue: 1,
              rules: [{ required: false }],
            })(
              <Radio.Group onChange={() => handleResetCos()}>
                <Radio value={1}></Radio>
                <Radio value={0}></Radio>
              </Radio.Group>
            )}
          </Form.Item>
        </Form>

        {getFieldValue('fileType') == 1 ? <Dragger {...draggerProps} style={{maxWidth: '500px'}}>
          <p className="ant-upload-drag-icon">
            <Icon type="inbox" />
          </p>
          <p className="ant-upload-text">点击或拖动图片到此区域进行上传</p>
          <p className="ant-upload-hint">支持:.jpeg,.jpg,.png,.gif格式,大小不超过5Mb</p>
          <p className="ant-upload-hint">支持单次或批量上传</p>
        </Dragger>:null}

        {fileList.map((item, index) => (
          <div key={index} style={{ display: 'flex', flexDirection: 'row', justifyContent: 'space-between', alignItems: 'center' }}>
            <div className={item?.repeat?styles.AppletMaterModal_red:''}>{item.name}</div>
            <div>
              <Icon onClick={() => window.open(item.url, '_blank')} style={{ cursor: 'pointer', margin: '0 20px' }} type="eye" theme="twoTone" />
              <Icon onClick={() => handleCopy(item)} style={{ cursor: 'pointer' }} type="copy" theme="twoTone" />
            </div>
          </div>
        ))}
      </div>
    </Modal>
  )
}

export default memo(Form.create()(AppletMaterModal))

总结

在实际使用中,该功能表现稳定,能够满足日常的小程序素材管理需求。后续可以考虑添加进度条显示、断点续传、图片压缩等高级功能,进一步提升用户体验。

参考文档


希望这篇文章对你有所帮助!如有问题欢迎交流讨论。

DOM树与节点操作:用JS给网页“动手术”

你写的HTML页面,在浏览器眼里其实是一棵树。今天我们就来当一回“外科医生”,用JS给这棵树做手术——增、删、改、查,想怎么动就怎么动。看完这篇,你就能理解为什么说“JS能控制网页的一切”。

前言

你有没有想过,当你用document.getElementById拿到一个元素,然后改它的文字、换它的颜色时,背后发生了什么?

其实,浏览器把HTML解析成了一棵“树”,每个标签、属性、文本都是树上的一个“节点”。JS能做的,就是在这棵树上爬上爬下,找到某个节点,然后对它做各种操作——换个果子、摘掉枯枝、甚至嫁接新枝。

今天我们就来解剖这棵DOM树,学会用JS给网页“做手术”。

一、DOM树:网页的“族谱”

DOM(Document Object Model)把HTML文档表示成一棵树。比如这段HTML:

<!DOCTYPE html>
<html>
  <head>
    <title>我的网页</title>
  </head>
  <body>
    <div class="container">
      <h1>标题</h1>
      <p>一段文字</p>
    </div>
  </body>
</html>

在浏览器眼里,它长这样:

html
├── head
│   └── title
│       └── "我的网页"
└── body
    └── div.container
        ├── h1
        │   └── "标题"
        └── p
            └── "一段文字"

每个方框都是一个节点。节点之间是父子、兄弟关系。这棵树的根节点是document

节点有不同的类型,最常见的是:

  • 元素节点:比如<div><p>,类型是1
  • 文本节点:比如“标题”这两个字,类型是3
  • 属性节点:比如class="container",类型是2(但很少单独操作)

二、获取节点:找到你要动刀的位置

做手术第一步,得找到病灶。JS提供了好几种“找节点”的方法:

1. 单个元素

// 根据ID(最常用)
const header = document.getElementById('header');

// 根据CSS选择器(推荐,灵活)
const container = document.querySelector('.container');
const title = document.querySelector('#title');

// 根据类名(返回集合)
const items = document.getElementsByClassName('item'); // HTMLCollection,实时更新

2. 多个元素

// 获取所有匹配的元素
const allDivs = document.querySelectorAll('div'); // NodeList,静态快照

// 根据标签名
const paras = document.getElementsByTagName('p'); // HTMLCollection

3. 在节点之间“爬树”

拿到一个节点后,你可以在它周围爬来爬去:

const container = document.querySelector('.container');

// 往上爬
const parent = container.parentNode;

// 往下爬
const firstChild = container.firstChild; // 可能是文本节点(换行)
const firstElementChild = container.firstElementChild; // 只算元素

// 找兄弟
const prev = container.previousSibling; // 可能是文本节点
const prevElement = container.previousElementSibling;
const next = container.nextElementSibling;

坑点firstChildnextSibling这些会返回文本节点(包括换行和空格),所以大部分时候用firstElementChildnextElementSibling更安全。

三、修改节点:动手术的核心操作

找到目标后,就可以下手了。

1. 修改内容和属性

// 改文本内容
element.textContent = '新文本'; // 纯文本,安全
element.innerHTML = '<strong>新文本</strong>'; // 解析HTML,有XSS风险

// 改属性
element.id = 'newId';
element.className = 'newClass'; // 覆盖所有类
element.classList.add('active'); // 推荐,增删类
element.classList.remove('hidden');
element.classList.toggle('open');

// 改样式(内联样式)
element.style.color = 'red';
element.style.backgroundColor = '#f0f0f0'; // 驼峰命名

2. 创建新节点

// 创建元素
const newDiv = document.createElement('div');
newDiv.textContent = '我是新来的';

// 创建文本节点(很少单独用)
const textNode = document.createTextNode('一段文字');

3. 插入节点

// 追加到最后
parent.appendChild(newDiv);

// 插入到某个子节点之前
parent.insertBefore(newDiv, referenceNode);

// 现代插入方法(更灵活)
referenceNode.before(newDiv); // 插到前面
referenceNode.after(newDiv);  // 插到后面
parent.prepend(newDiv);       // 插到父元素开头
parent.append(newDiv);        // 插到父元素末尾(类似appendChild)

4. 删除节点

// 删除自己
element.remove();

// 通过父节点删除
parent.removeChild(child);

四、实战:动态添加待办事项

来做个简单待办列表,把上面的操作串起来:

<div id="todo-app">
  <input type="text" id="todo-input" placeholder="输入待办事项">
  <button id="add-btn">添加</button>
  <ul id="todo-list"></ul>
</div>
const input = document.getElementById('todo-input');
const addBtn = document.getElementById('add-btn');
const list = document.getElementById('todo-list');

function addTodo() {
  const text = input.value.trim();
  if (text === '') return;
  
  // 创建li元素
  const li = document.createElement('li');
  li.textContent = text;
  
  // 创建删除按钮
  const delBtn = document.createElement('button');
  delBtn.textContent = '删除';
  delBtn.onclick = function() {
    li.remove(); // 删除这一项
  };
  
  li.appendChild(delBtn);
  list.appendChild(li);
  
  input.value = ''; // 清空输入框
}

addBtn.addEventListener('click', addTodo);
// 按回车也添加
input.addEventListener('keypress', function(e) {
  if (e.key === 'Enter') addTodo();
});

就这几行代码,一个动态待办列表就有了。你看,增删改查全用上了。

五、节点集合:HTMLCollection vs NodeList

当你用getElementsByClassName时,拿到的是HTMLCollection;用querySelectorAll拿到的是NodeList。它们有啥区别?

  • HTMLCollection:实时的。DOM变了,它也跟着变。而且它只有元素节点,没有文本节点。
  • NodeList:大部分是静态快照(querySelectorAll返回的就是静态的)。但childNodes返回的NodeList是实时的。
const live = document.getElementsByClassName('item'); // 实时
const static = document.querySelectorAll('.item'); // 静态

// 如果你删除了一个.item元素,live会立刻变少,static还是原来的

遍历时,HTMLCollection没有forEach方法(但可以Array.from()转成数组),NodeList有forEach

六、性能小贴士:别频繁动DOM

DOM操作是“重活”,频繁操作会影响性能。记住几个原则:

  1. 批量操作:用document.createDocumentFragment()创建虚拟片段,一次性插入。
const fragment = document.createDocumentFragment();
for (let i = 0; i < 1000; i++) {
  const li = document.createElement('li');
  li.textContent = i;
  fragment.appendChild(li);
}
list.appendChild(fragment); // 只触发一次重排
  1. 减少重排:修改样式时,尽量用classList批量改,而不是一个个改style属性。

  2. 离屏操作:先把元素从DOM树上摘下来,改完再放回去。

七、总结:DOM就是你的“手术台”

  • DOM是HTML解析成的树,每个标签、文本都是节点。
  • document.querySelector等方法找到节点。
  • textContentinnerHTML改内容,用classList改样式。
  • createElement造新节点,用appendinsertBefore插入,用remove删除。
  • 注意HTMLCollection和NodeList的区别,实时和静态要分清。
  • 批量操作、减少重排,让页面更流畅。

掌握了这些,你就能用JS随心所欲地操控页面。明天我们将继续深入,聊聊事件流与事件委托——当用户点击按钮时,浏览器里到底发生了什么。

如果你觉得今天的“手术”课够实用,点个赞让更多人看到。我们明天见!

四轮分析法:Nodejs Heap Snapshot 深度分析方法论

基于 Node.js SSR 应用内存泄漏的实战复盘,主要解决拿到 heapdump 文件却也分析不出内存泄露问题的痛点。这里提出了四轮分析法,主要是给人 + AI结合去使用的


为什么 Heap Snapshot 分析这么难

拿到一个 177MB 的 heapsnapshot 文件,里面有 100 万个节点、370 万条边。你面对的不是"找 bug",而是"在一座城市的下水道网络里找到那个漏水的管道接头"。

难点在于:

  1. 信息量巨大但信噪比极低。138MB 堆内存中,可能只有 30MB 是泄漏的,剩下的都是正常的运行时开销(V8 编译代码、webpack 模块、框架内部结构)。你需要先学会区分"正常的大"和"异常的大"。

  2. 泄漏对象本身往往不可疑。一个字符串 "Hello World" 看起来完全正常——它就是一条业务数据。问题不在于这个字符串存在,而在于它不应该在这里被长期持有。

  3. 引用链很深且经过混淆。从泄漏的字符串到真正的根因(mem 包的无界 Map),中间隔了 5-6 层引用,而且 closure 名字被 mimic-fn 改成了 "l",源码路径指向打包后的 chunk 文件。

本文记录的是一套经过验证的、可复现的分析方法「四轮分析法」,核心思路是:逐层缩小范围,每一轮只回答一个问题

这个方法主要是给人 + AI 结合使用的,heap dump 数据量大,人眼往往很难直接看出问题,要利用这个分析思路,让 AI 通过脚本去统计和分析


如果你只想快速修复问题,仅看本章节即可

这里将后文的思路封装成了一个 skill:

gitee.com/qsjn/codes/…

把这个 skill 复制到你的编辑器 skills 目录,就可以让 ai 按照这个思路进行分析了

第一轮:全局概览——"内存都花在哪了?"

目标

不要一上来就找泄漏。先建立全局认知:这 138MB 堆内存的构成是什么?哪些是正常开销,哪些是异常的?

方法

对快照做四个维度的统计:

  1. 按节点类型统计内存分布(string / object / code / array / closure ...)
  2. 按构造函数名统计 Top 50(哪类对象最多、最大)
  3. 列出 self_size 最大的单个对象(有没有异常大的对象)
  4. 列出最长的字符串内容(字符串往往是泄漏的载体)

本次案例的发现

string:    302,124 个,  77.09 MB  ← 占了堆的 56%,这正常吗?
code:      196,735 个,  25.79 MB  ← V8 编译代码,Next.js 项目正常
array:      18,824 个,  12.35 MB  ← 需要看看是什么 array 这么大
object:    167,287 个,   7.53 MB  ← 正常

77MB 的字符串占了堆的 56%。对于一个 SSR 渲染的内容型应用来说,这个比例偏高。正常的 Next.js 应用,字符串占比通常在 30-40%。

但此时还不能下结论。77MB 字符串里可能大部分是 webpack 打包的源码字符串(这是正常的)。需要进一步分解。

关键思维

第一轮的目的不是找到答案,而是找到"下一步该往哪里挖"。

你需要的是一个"异常信号"——某个数字看起来不太对劲。在本次案例中,信号是"77MB 字符串"。


第二轮:分解异常区域——"77MB 字符串里都是什么?"

目标

把第一轮发现的异常区域(77MB 字符串)拆开看,区分正常内容和可疑内容。

方法

对所有字符串按内容特征分类:

  • 包含 webpack / __webpack_require__ 的 → webpack 模块源码(正常)
  • 包含 <p> / <img> / <div> 等 HTML 标签的 → HTML 内容(可疑)
  • 包含 { 开头的 JSON 结构 → API 响应数据(可疑)
  • 短字符串(< 100 字符)→ 变量名、属性名等(正常)
  • [" 开头的 → JSON.stringify 的结果(可疑)

本次案例的发现

webpack 模块源码:     ~13 MB   ← 正常,Next.js SSR 需要在服务端持有模块代码
HTML 内容字符串:      ~17 MB   ← 异常!为什么服务端要长期持有业务 HTMLJSON 包装字符串:      ~13 MB   ← 异常!大量 '["业务内容..."]' 格式的字符串
短字符串/属性名:      ~34 MB   ← 正常运行时开销

17MB 的 HTML 内容 + 13MB 的 JSON 包装字符串,合计 30MB。这些字符串的内容是用户生成的业务数据(UGC 内容)。

关键发现:JSON 包装字符串的格式是 '["原始内容"]',这是 JSON.stringify(["原始内容"]) 的结果。说明有某个地方在用 JSON.stringify 作为 cache key。

关键思维

到这一步,你已经知道"泄漏的是什么"(业务 HTML 内容),但还不知道"谁在持有它"。

JSON.stringify 格式的字符串是一个重要线索——它暗示了某种缓存机制在用 JSON.stringify 做 key。


第三轮:追踪引用链——"谁在持有这些字符串?"

目标

这是整个分析中最关键的一步。找到泄漏字符串的 retainer(持有者),沿着引用链往上追溯,直到找到根对象。

方法

Heap snapshot 中每个节点都有 edge(边)信息,记录了"谁引用了谁"。追踪引用链的方法:

  1. 选取几个典型的泄漏字符串(比如包含业务内容的 HTML 字符串)
  2. 找到引用这个字符串的父节点(retainer)
  3. 再找父节点的父节点,逐层往上
  4. 直到找到一个"不应该存在的长生命周期容器"

本次案例的引用链追踪过程

1 层:业务 HTML 字符串 "some user generated content..."
         ↑ 被谁引用?

第 2 层:Object { data: "some user generated content...", maxAge: Infinity }
         ↑ 一个包含 data 和 maxAge 字段的对象。maxAge 是 Infinity。
           这看起来像某种缓存条目的结构。

第 3 层:Array (155,029 条边)
         ↑ 一个巨大的数组,包含了 15 万个条目。
           这是 V8Map 的内部 hash table 实现。

第 4 层:Map (id=677247)
         ↑ 一个 Map 对象。15 万个条目的 Map,存储了所有业务内容。
           这就是泄漏的容器。

第 5 层:closure "l" (id=605069)
         ↑ 一个闭包函数,名字被混淆成了 "l"。
           它的 context 变量中包含这个 Map。

第 6 层:WeakMap (id=1328353)
         ↑ 一个 WeakMap,以 closure 为 key,以 Map 为 value。
           这是 mem 包的 cacheStore 结构。

关键思维

引用链追踪是体力活,但有几个加速技巧:

  1. maxAge: Infinity 这个字段——这是 mem 包的签名特征。如果你熟悉 mem 的源码,看到 { data, maxAge } 结构就能立刻联想到。

  2. 看 Map 的大小——一个 15 万条目的 Map 在正常业务逻辑中几乎不可能出现。这种"数量异常"是强信号。

  3. 看 closure 的 context 变量——即使函数名被混淆了,context 中的变量(如 stringify、匿名 cacheKey 函数)仍然能提供线索。


第四轮:确认身份——"这个 closure 到底是哪段代码?"

目标

第三轮找到了一个名为 "l" 的 closure,但函数名被 mimic-fn 混淆了。需要确认它对应的源码位置。

方法

  1. 从 closure 节点的属性中找 shared_function_info,它包含源码文件路径和行号
  2. 检查 closure 的 context 变量,看有没有能识别身份的线索
  3. 在打包后的 chunk 文件中搜索对应的代码

本次案例的确认过程

closure "l" 的信息:

  • 源码位置:/app/.next/server/chunks/xxx.js(打包后的 chunk 文件)
  • context 变量:
    • context::a → 匿名 closure(这是 cacheKey 函数)
    • context::bstringify(即 JSON.stringify
    • context::c → Map (id=677247)(就是那个大 Map)

看到 stringify + cacheKey + Map,再结合 { data, maxAge } 的缓存条目结构,可以确认这就是 mem 包创建的 memoized 函数。

然后在项目源码中搜索 mem( 的调用,找到:

// 示例:使用 mem 包对某个函数做 memoize,但未设置 maxAge
export const memoizedFn = mem(someFunction, {
  cacheKey: JSON.stringify  // ← context::b 就是这个 stringify
});

至此,根因定位完成:mem 包默认 maxAge: Infinity,缓存永不过期,而 cacheKey 使用 JSON.stringify,导致每个不同的输入都会创建一个新的缓存条目,在 SSR 长生命周期进程中无限增长。


分析中容易走的弯路

弯路 1:一开始就盯着 LRUNode

本次分析中,第一轮概览时 LRUNode(27,184 个)在构造函数名 Top 50 中非常显眼。很容易一头扎进去分析 LRU 相关的问题。

实际上 LRUNode 是 Next.js 内部的路由缓存,虽然也有问题(淘汰机制失效),但只占 ~5MB,不是主要矛盾。

教训:先看总量,再看个体。77MB 字符串才是大头,5MB 的 LRU 是次要问题。

弯路 2:在 Chrome DevTools 里手动翻找

177MB 的快照在 DevTools 里打开就要几分钟,每次操作都卡顿。手动在 Summary/Comparison 视图里翻找,效率极低。

更好的方式是写脚本做批量统计分析。heapsnapshot 文件本质上是一个 JSON,可以用 Node.js 流式解析。

弯路 3:只看 self_size 不看 retained_size

一个 Map 对象的 self_size 可能只有几十字节,但它 retained 的所有 key-value 可能有 30MB。如果只按 self_size 排序,这个 Map 根本排不到前面。

需要同时关注:

  • self_size 大的对象(直接占用内存多)
  • 子节点/边数异常多的对象(间接持有大量内存)

弯路 4:不理解 V8 的内部表示

V8 的 Map 不是直接存储 key-value 对的。它内部有一个 hash table(表现为 Array 节点),key 和 value 交替存储在这个 Array 中。如果你不知道这一点,看到一个 155,029 条边的 Array 会很困惑。

常见的 V8 内部结构:

  • Map → 内部有一个 table 属性指向 Array(hash table)
  • Set → 类似 Map,内部也是 hash table
  • closure → 有 context 属性,存储闭包捕获的变量
  • concatenated string → V8 对字符串拼接的优化,不会立即创建新字符串,而是创建一个指向两个子字符串的节点
  • sliced string → 字符串 slice 操作的结果,持有对原始字符串的引用

如何引导 AI Agent 分析 Heap Snapshot

如果快照文件太大无法直接喂给 AI,可以分阶段引导:

阶段 1:让 AI 写分析脚本

我有一个 177MB 的 V8 heap snapshot 文件(.heapsnapshot),
Chrome DevTools 打开太卡了。
请帮我写一个 Node.js 脚本,流式解析这个文件,输出以下统计信息:
1. 按节点类型(string/object/code/array/closure)统计数量和总 self_size
2. 按构造函数名统计 Top 50(按总 self_size 排序)
3. 列出 self_size 最大的 20 个对象(输出类型、大小、构造函数名)
4. 列出最长的 20 个字符串的前 200 个字符

拿到输出后,把统计结果贴给 AI,让它帮你判断哪些是异常的。

阶段 2:让 AI 深入可疑区域

上一轮分析发现 77MB 的字符串中有大量 HTML 内容和 JSON 包装字符串。
请帮我写一个脚本,对所有字符串按以下规则分类统计:
- 包含 HTML 标签的(<p>, <div>, <img> 等)
- 以 '["' 开头的(JSON.stringify 结果)
- 包含 webpack 关键词的
- 其他
每类统计数量和总大小,并采样输出 10 个典型内容。

阶段 3:让 AI 追踪引用链

上一轮发现大量业务 HTML 内容被长期持有。
请帮我写一个脚本,做以下事情:
1. 找到所有包含 HTML 标签且长度 > 500 的字符串节点
2. 对每个这样的字符串,追踪它的 retainer 链(最多 6 层)
3. 统计这些 retainer 链中出现频率最高的"容器对象"MapSetArray、closure 等)
4. 对出现频率最高的容器,输出它的详细信息(类型、大小、子节点数、构造函数名)

阶段 4:让 AI 确认根因

上一轮追踪到一个 Map(id=677247),包含 15 万个条目,
存储了 { data: 业务内容, maxAge: Infinity } 结构的缓存条目。
这个 Map 被一个名为 "l" 的 closure 持有。

请帮我写一个脚本:
1. 找到这个 closure 的 shared_function_info,输出源码文件路径
2. 输出这个 closure 的所有 context 变量的名称和值
3. 在项目源码中搜索可能创建这种 { data, maxAge } 缓存结构的代码

引导 AI 的关键原则

  1. 每次只问一个问题。不要一次性让 AI 分析整个快照,它会迷失在信息海洋中。
  2. 把上一轮的结论作为下一轮的输入。形成"发现 → 假设 → 验证"的循环。
  3. 让 AI 写脚本而不是直接分析数据。快照数据量太大,AI 无法直接处理,但它很擅长写解析脚本。
  4. 提供领域知识。告诉 AI 这是一个 Next.js SSR 应用、用了什么技术栈、是什么类型的业务。这些上下文能帮助 AI 判断什么是正常的、什么是异常的。

Heapsnapshot 文件结构速查

写分析脚本时需要理解 .heapsnapshot 文件的 JSON 结构:

{
  "snapshot": {
    "meta": {
      "node_fields": ["type","name","id","self_size","edge_count","trace_node_id","detachedness"],
      "node_types": [["hidden","array","string","object","code","closure","regexp","number",
                       "native","synthetic","concatenated string","sliced string","symbol","bigint"],
                     "string","number","number","number","number","number"],
      "edge_fields": ["type","name_or_index","to_node"],
      "edge_types": [["context","element","property","internal","hidden","shortcut","weak"],
                     "string_or_number","node"]
    },
    "node_count": 1032504,
    "edge_count": 3728200
  },
  "nodes": [0,1,3,48,5,0,0, ...],      // 扁平数组,每 7 个值描述一个节点
  "edges": [1,2,7, ...],                // 扁平数组,每 3 个值描述一条边
  "strings": ["","<dummy>","GC roots",...]  // 字符串表,节点和边通过索引引用
}

节点字段(每 7 个值一组):

  • type: 节点类型索引(0=hidden, 1=array, 2=string, 3=object, 5=closure ...)
  • name: 字符串表索引(构造函数名或字符串内容)
  • id: 节点唯一 ID
  • self_size: 自身占用字节数
  • edge_count: 从该节点出发的边数
  • trace_node_id: 分配追踪 ID
  • detachedness: 是否已分离

边字段(每 3 个值一组):

  • type: 边类型索引(0=context, 1=element, 2=property, 3=internal ...)
  • name_or_index: 属性名(字符串表索引)或数组下标
  • to_node: 目标节点在 nodes 数组中的偏移量(注意是偏移量,不是 ID)

理解这个结构后,就可以写脚本遍历所有节点和边,做任意维度的统计分析。


总结:四轮分析法

第一轮  全局概览        → 找到异常信号(77MB 字符串)
第二轮  分解异常区域    → 确认泄漏内容(业务 HTML + JSON.stringify key)
第三轮  追踪引用链      → 找到泄漏容器(无界 Map15 万条目)
第四轮  确认代码身份    → 定位源码(mem 包的 memoized 函数未设置 maxAge)

每一轮只回答一个问题,用上一轮的结论驱动下一轮的方向。不要跳步,不要猜测。

前端工程化工具链从零配置:simple-git-hooks + lint-staged + commitlint

摘要

前端工程化涉及方方面面的配置,其中 Git 钩子工具链是团队协作的基础设施。本文聚焦三个核心工具:simple-git-hooks 负责管理 Git 钩子,lint-staged 负责对暂存区文件执行格式化,commitlint 负责校验提交信息的规范性。文章按照安装顺序逐步讲解,帮助你渐进式地理解每个工具的用途和配置细节。

AI 协助编写的博客文章

这篇文章有参与 AI 协助的。使用了 AI 润色文章。

1. 为什么需要这套工具链

在团队项目中,代码风格不统一和提交信息混乱是两个最常见的痛点。

  • 张三喜欢两空格缩进,李四坚持四空格,王五直接用 Tab,合并代码时一片混乱。
  • 提交信息形如 "fix" "改了一下" "aaa" ,三个月后完全看不懂到底改了什么。

解决方案就是在 提交代码这个时机 上做拦截:提交前自动格式化文件,提交时校验 commit 信息。这套流程的三个主角分别是 simple-git-hooks、lint-staged 和 commitlint。

2. simple-git-hooks:管理 Git 钩子

2.1. 它是什么

simple-git-hooks 是一个轻量的 Git 钩子管理库。Git 原生支持在特定操作节点执行自定义脚本(即 hooks),simple-git-hooks 的作用就是让你把这些钩子配置写在项目的配置文件里,随着 pnpm install 自动生成到 .git/hooks/ 目录下。

常见的钩子使用场景:

  • commit-msg 钩子:在提交信息写入前做格式校验。
  • pre-commit 钩子:在代码提交前执行格式化或 lint 检查。

2.2. 安装

pnpm i -D simple-git-hooks

2.3. 配置钩子命令

按照官方文档的 Additional configuration options,推荐使用独立配置文件 simple-git-hooks.mjs

注意:配置文件的后缀必须是 .mjs,不能是 .js。如果使用 simple-git-hooks.js,后续运行 npx simple-git-hooks 时会直接报错,导致钩子生成失败。

配置示例如下:

/**
 * 每次修改该文件后务必执行一次 `npx simple-git-hooks` 命令
 * 否则这些钩子不会生效
 */
export default {
/**
 * @see https://juejin.cn/post/7381372081915166739#heading-8
 * @see https://fabric.modyqyw.top/zh-Hans/guide/git/commitlint.html#整合-simple-git-hooks
 */
"commit-msg": "npx --no-install commitlint --edit ${1}",
"pre-commit": "npx lint-staged",
};

这里配置了两个钩子:

  • pre-commit:提交前触发 lint-staged,对暂存区文件做格式化。
  • commit-msg:提交信息写入时触发 commitlint,校验信息格式。--edit ${1} 是必须的参数,用于指定提交信息文件路径。

2.4. 配置命令行:让钩子随安装自动生成

推荐在 package.jsonpostinstall 钩子里,自动运行 simple-git-hooks 命令:

{
"scripts": {
"postinstall": "pnpm run init-git-hooks",
"init-git-hooks": "simple-git-hooks"
}
}

这样,每次执行 pnpm install 之后,postinstall 钩子会自动触发,把配置文件中定义的钩子写入本地的 .git/hooks/ 目录。

用以下命令确认钩子已正确生成:

ls .git/hooks

正常情况下,你应该能看到 pre-commitcommit-msg 等文件被创建出来。

钩子文件生成效果

2.5. 注意事项

关于 github workflow:在 CI 流水线里,postinstall 触发 simple-git-hooks 是能正常执行的,不会引发错误,可以放心使用。

关于对外发包的项目:如果你的 package 会发布到 npm,postinstall 脚本会在用户安装你的包时被触发,可能影响用户的本地环境。请阅读官方文档中的 Note for npm package developers 部分。如果你的项目不发包,跳过此部分即可。

2.6. 与 husky 的对比

最出名的 Git 钩子管理库是 husky,功能更完善,社区资料也更多。simple-git-hooks 的优势在于配置更简单,适合不需要复杂钩子逻辑的项目。本文不对 husky 做详细说明,感兴趣可以查阅 husky 官网

3. lint-staged:只格式化暂存区的文件

3.1. 它是什么

lint-staged 是一个借助 glob 语法匹配 git 暂存区文件,并对这些文件执行指定命令的库。

为什么不直接对全项目做格式化? 因为时间成本太高了。一个积累了几年的项目,全量格式化一次可能需要几十秒甚至更久。如果每次 git commit 都触发全量格式化,就会在最频繁的操作上制造最大的卡顿——这是不可接受的。

lint-staged 的解法很优雅:只处理这次提交涉及的文件。你改了 5 个文件,它就只格式化这 5 个文件,秒级完成。

3.2. 安装

pnpm i -D lint-staged

3.3. 配置格式化规则

按照官方文档的说明,在项目根目录新建 lint-staged.config.js 配置文件。推荐使用带有 TypeScript 类型注解的写法,以获得 IDE 智能提示:

/**
 * @filename lint-staged.config.js
 * @description 用于配置 lint-staged 的配置文件。
 * @type {import('lint-staged').Configuration}
 * @see https://github.com/lint-staged/lint-staged/blob/main/README.md#typescript
 */
export default {
/** @see https://github.com/lint-staged/lint-staged/blob/main/README.md#automatically-fix-code-style-with-prettier-for-any-format-prettier-supports */
"*": "prettier --ignore-unknown --experimental-cli --write",
};

这里用 "*" 匹配所有暂存文件,对它们统一执行 Prettier 格式化。--ignore-unknown 参数会让 Prettier 跳过它不认识的文件类型,避免报错。

将 lint-staged 接入 simple-git-hooks 的 pre-commit 钩子,就完成了整个"提交前自动格式化"的链路。

4. commitlint:规范化提交信息

4.1. 它是什么

commitlint 是一个对 git commit 信息做格式校验的工具。配合 Conventional Commits 规范使用,可以强制团队的提交信息遵循统一格式,例如:

feat: 新增用户登录功能
fix: 修复 token 过期后页面白屏问题
docs: 更新 README 安装说明

4.2. 安装

pnpm i -D commitlint

同时还需要安装对应的规范包,例如官方提供的 @commitlint/config-conventional

pnpm i -D @commitlint/config-conventional

或者使用社区封装的配置包,比如 @ruan-cat/commitlint-config

4.3. 配置文件

在项目根目录新建 commitlint.config.js

/** @type {import('@commitlint/types').UserConfig} */
export default {
extends: ["@commitlint/config-conventional"],
};

4.4. 与 simple-git-hooks 集成

simple-git-hooks.mjs 中配置 commit-msg 钩子时,必须带上 --edit ${1} 参数,否则 commitlint 无法读取到提交信息文件:

export default {
"commit-msg": "npx --no-install commitlint --edit ${1}",
};

${1} 是 Git 传递给 commit-msg 钩子的第一个参数,即包含提交信息的临时文件路径(通常是 .git/COMMIT_EDITMSG)。漏掉这个参数,commitlint 就拿不到数据,校验自然失效。

4.5. 参考资料

5. 用 AI Skill 快速初始化:init-prettier-git-hooks

上面讲的这些配置步骤,每次新建项目都要手动做一遍,其实挺繁琐的。为此,笔者专门制作了一个叫做 init-prettier-git-hooks 的 AI Skill,可以在支持 Agent Skills 的 AI 编程工具(如 Claude Code、Cursor 等)中,一键完成整套工程化配置的初始化

5.1. 它能做什么

这个 Skill 不是简单地把配置文件模板复制进去,而是遵循合并策略——先侦察项目现状,再精确补全缺失项,保留你已有的项目特化配置。

一次完整的初始化会完成以下工作:

操作对象 具体内容
依赖检查 逐一检查 6 个必需依赖是否已安装,只安装缺失的
.gitattributes 收敛全局文本规则为 * text=auto eol=lf
.editorconfig 确保 [*] 区块存在 end_of_line = lf
prettier.config.mjs 写入 Prettier 配置,强制 endOfLine: "lf"
lint-staged.config.js 生成 lint-staged 配置文件
simple-git-hooks.mjs 生成钩子配置文件
package.json 新增 formatprepare 脚本
Git 行尾归一化 执行 git add --renormalize . 统一已追踪文件行尾

5.2. 为什么特别处理行尾(EOL)

这是这个 Skill 相比手动配置最有价值的地方之一。

在 Windows 环境下开发时,Git 默认会把文件的行尾换行符转换成 CRLF(\r\n),而 Linux/macOS 使用 LF(\n)。如果团队成员使用不同操作系统,或者 Prettier 的 endOfLine 配置不统一,就会出现幽灵修改——明明没有改任何代码,git status 却显示文件有变动,diff 里全是换行符的差异。

Skill 会把以下三个环节全部收敛到 LF:

  • .gitattributes:控制 Git 存储和检出时的行尾策略
  • .editorconfig:控制编辑器新建文件时的行尾策略
  • prettier.config.mjs:控制 Prettier 格式化时写入的行尾

三者同时对齐,才能从根本上解决幽灵修改问题。

5.3. 涵盖的 6 个必需依赖

Skill 会自动检查并安装以下依赖:

# 依赖名称 说明
1 prettier 核心代码格式化工具
2 @prettier/plugin-oxc 使用 oxc 引擎解析 JS/TS,速度更快
3 prettier-plugin-lint-md Markdown 文件格式化插件
4 lint-staged 只对 git 暂存区文件执行 lint/format
5 simple-git-hooks 轻量级 git hooks 管理工具
6 commitlint git 提交信息规范校验

5.4. 如何使用

在支持 Agent Skills 的 AI 工具中,直接告诉 AI:

帮我初始化 prettier git hooks,使用 init-prettier-git-hooks 技能

AI 会自动读取 Skill 文件,按照步骤检查依赖、创建配置文件、执行行尾归一化,最后输出一份自检清单,让你确认每一项都已正确完成。

Skill 的完整文档地址:init-prettier-git-hooks/SKILL.md

6. 总结

把三个工具串联起来,完整的 Git 提交拦截链路如下:

时机 触发钩子 执行工具 作用
git commit 提交前 pre-commit lint-staged + Prettier 自动格式化暂存区文件
git commit 信息写入时 commit-msg commitlint 校验提交信息格式

这套工具链的配置成本很低,但收益却是长期的:代码格式不再依赖人工约定,提交历史真正有意义可读。对于多人协作的项目来说,这是性价比极高的基础设施投入。

最后有一点需要特别留意:每次修改 simple-git-hooks.mjs 之后,必须手动重新运行 npx simple-git-hooks,否则本地的 .git/hooks/ 文件不会被更新,新的配置不会生效。如果你配置了 postinstall,也可以通过 pnpm install 来触发。

【节点】[TextureSize节点]原理解析与实际应用

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

Texture Size 节点是 Unity URP Shader Graph 中一个功能强大且实用的输入节点,它允许着色器程序访问和利用纹理的尺寸信息。在实时渲染和着色器开发中,了解纹理的确切尺寸对于实现各种视觉效果至关重要,从简单的纹理平铺调整到复杂的屏幕空间效果都离不开纹理尺寸数据。

该节点接收一个 Texture 2D 输入,并返回四个关键的输出值:纹理的宽度和高度(以 texel 为单位),以及每个 texel 在 UV 坐标空间中的宽度和高度。这些输出为着色器程序员提供了对纹理尺寸的完整控制能力,使得基于纹理像素精度的计算成为可能。

在技术实现上,Texture Size 节点利用了 Unity 的内置变量系统,特别是 {texturename}_TexelSize 这一特殊属性。这个内置变量是 Unity 为每个纹理自动生成的,包含了纹理在 GPU 内存中的实际尺寸信息。理解这一机制对于高效使用 Texture Size 节点非常重要。

"texel"这一术语是"texture element"或"texture pixel"的缩写,指的是纹理中的单个像素元素。举例来说,如果一个纹理的分辨率为 512x512 texel,在标准的 UV 坐标空间中,这个纹理会被映射到[0,1]的范围内,因此每个 texel 在 UV 空间中的尺寸就是 1/512 x 1/512。这种转换关系是理解纹理采样和处理的基矗

节点兼容性与版本要求

Texture Size 节点在设计时考虑了跨渲染管线的兼容性,它可以在 Unity 的所有主流渲染管线中正常工作,包括内置渲染管线、Universal Render Pipeline (URP)和 High Definition Render Pipeline (HDRP)。这种广泛的兼容性使得基于 Texture Size 节点开发的着色器能够轻松地在不同的项目和渲染配置间迁移。

需要注意的是,在某些特定情况下,特别是在使用自定义功能节点或复杂子图时,可能会遇到纹理采样相关的错误。这些问题通常与 Shader Graph 的版本兼容性有关。根据 Unity 官方文档的建议,如果遇到此类问题,将 Shader Graph 更新至 10.3 或更高版本通常能够解决。这是因为较新版本的 Shader Graph 对纹理处理系统进行了优化和改进,提供了更稳定的纹理尺寸访问机制。

性能优化建议

在性能优化方面,Texture Size 节点有一个重要的使用注意事项:避免使用默认输入来引用 Texture 2D 资源。直接使用默认输入虽然方便,但会对着色器的性能产生负面影响,因为它可能导致不必要的纹理引用和内存访问。

正确的做法是将 Texture 2D Asset 节点显式连接到 Texture Size 节点的纹理输入端口,并通过这种方式重用纹理定义进行采样。这种优化策略基于几个关键考虑因素:

  • 减少不必要的纹理绑定操作
  • 优化 GPU 内存访问模式
  • 提高着色器编译效率
  • 避免冗余的纹理描述符创建

通过遵循这一最佳实践,开发者可以确保基于 Texture Size 节点的着色器在保持功能完整性的同时,也能达到最优的运行性能。

创建节点菜单类别

在 Shader Graph 的创建节点菜单中,Texture Size 节点被组织在 Input -> Texture 类别下。这种分类方式反映了节点的主要功能和用途,使得开发者能够快速定位和访问相关的纹理输入节点。

Input 类别包含了所有类型的输入节点,这些节点负责向着色器提供各种外部数据,包括纹理、时间、摄像机参数等。Texture 子类别则专门处理与纹理相关的输入,除了 Texture Size 节点外,还包括:

  • Texture 2D Asset 节点 - 用于引用具体的纹理资源
  • Texture 3D 节点 - 处理三维纹理数据
  • Texture Cube 节点 - 用于立方体贴图操作
  • Sampler State 节点 - 控制纹理采样行为

这种逻辑清晰的组织结构使得 Shader Graph 的学习曲线更加平缓,同时也提高了复杂着色器开发的效率。

端口详解与数据流

Texture Size 节点的端口系统设计精巧,提供了完整的纹理尺寸信息访问能力。理解每个端口的特性和用途对于有效使用该节点至关重要。

输入端口

Texture 输入端口是该节点唯一的数据输入通道,它接受 Texture 2D 类型的连接。这个端口的设计具有以下特点:

  • 数据类型严格限定为 Texture 2D,确保类型安全
  • 支持动态纹理绑定,可以在运行时切换不同的纹理资源
  • 与 Unity 的纹理导入系统无缝集成,自动处理各种纹理格式
  • 支持 Mipmap 链的访问,可以获取不同 Mip 级别的尺寸信息

输出端口系统

Texture Size 节点提供了四个输出端口,每个端口都承载着特定的纹理尺寸信息:

Width 输出端口返回纹理的横向分辨率,即纹理在水平方向上的 texel 数量。这个值是一个整数值,直接反映了纹理资源的实际宽度。在着色器代码中,这个值通常用于基于纹理宽度的比例计算和坐标变换。

Height 输出端口提供纹理的纵向分辨率,表示纹理在垂直方向上的 texel 总数。与 Width 类似,这也是一个整数值,在涉及垂直方向效果的计算中非常重要,如瀑布流效果、垂直扫描线等。

Texel Width 输出端口计算的是单个 texel 在 UV 坐标空间中的宽度。这个值等于 1.0 除以纹理的实际宽度,表示在标准化 UV 坐标系中,一个纹理像素所占据的水平空间范围。这个值在精确的纹理采样和像素级效果中至关重要。

Texel Height 输出端口与 Texel Width 类似,但针对的是垂直方向。它表示在 UV 坐标系中单个 texel 的垂直尺寸,等于 1.0 除以纹理的实际高度。这个值在实现与屏幕像素对齐的效果时特别有用。

端口数据绑定机制

每个输出端口都有其特定的数据绑定关系,这些绑定直接映射到 Unity 的内置纹理属性系统:

  • Width 端口绑定到 {texturename}_TexelSize.z
  • Height 端口绑定到 {texturename}_TexelSize.w
  • Texel Width 端口绑定到 {texturename}_TexelSize.x
  • Texel Height 端口绑定到 {texturename}_TexelSize.y

这种绑定机制确保了数据的一致性和准确性,同时也为高级用户提供了直接访问底层数据的可能性。

生成代码示例与底层实现

理解 Texture Size 节点在底层是如何实现的,对于高级着色器开发和性能优化具有重要意义。当在 Shader Graph 中使用 Texture Size 节点时,Unity 会将其转换为相应的 HLSL 代码。

基本代码生成

典型的代码生成示例如下所示:

float _TexelSize_Width = Texture_TexelSize.z;
float _TexelSize_Height = Texture_TexelSize.w;

这段代码展示了节点最基本的实现方式,其中 Texture_TexelSize 是 Unity 自动为纹理生成的 float4 类型变量。这个变量的四个分量分别存储了不同的纹理尺寸信息:

  • x 分量:Texel Width (1.0 / 纹理宽度)
  • y 分量:Texel Height (1.0 / 纹理高度)
  • z 分量:纹理实际宽度
  • w 分量:纹理实际高度

完整实现示例

在实际的着色器代码中,Texture Size 节点的完整实现可能更加复杂:

// 纹理属性声明
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
float4 _MainTex_TexelSize;

// 在片段着色器中的使用
void surf(Input IN, inout SurfaceOutput o)
{
    // 获取纹理尺寸信息
    float texWidth = _MainTex_TexelSize.z;
    float texHeight = _MainTex_TexelSize.w;
    float texelWidth = _MainTex_TexelSize.x;
    float texelHeight = _MainTex_TexelSize.y;

    // 基于纹理尺寸的计算
    float2 uv = IN.uv_MainTex;
    float2 pixelPos = uv * float2(texWidth, texHeight);

    // 应用基于像素的效果
    // ...
}

平台兼容性处理

在不同的图形 API 和平台上,Texture Size 节点的代码生成可能会有所差异。Unity 的 Shader Graph 系统会自动处理这些平台差异,确保生成的代码在各个目标平台上都能正确工作。例如,在某些移动平台上,可能会使用不同的精度限定符或优化策略。

实际应用场景与示例

Texture Size 节点在着色器开发中有着广泛的应用场景,从简单的纹理处理到复杂的屏幕空间效果都离不开纹理尺寸信息。

像素精确效果

在实现像素艺术风格或需要像素级精度的效果时,Texture Size 节点变得不可或缺:

// 创建像素化效果
float2 pixelatedUV = floor(uv * float2(texWidth, texHeight)) / float2(texWidth, texHeight);
float4 color = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, pixelatedUV);

这种技术可以用于创建复古游戏风格、像素化过渡效果,或者确保纹理元素在屏幕上精确对齐。

基于纹理尺寸的采样优化

在需要高质量纹理过滤或特殊采样模式时,纹理尺寸信息可以帮助优化采样过程:

// 计算适当的采样偏移
float2 sampleOffset = float2(texelWidth, texelHeight) * 0.5;
float4 color1 = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv + sampleOffset);
float4 color2 = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv - sampleOffset);

屏幕空间效果

对于全屏后处理效果,Texture Size 节点可以帮助将效果与屏幕像素对齐:

// 屏幕像素对齐的波纹效果
float2 screenSize = float2(texWidth, texHeight);
float2 center = float2(0.5, 0.5);
float2 dir = normalize(uv - center);
float dist = length(uv - center) * screenSize.x;
float wave = sin(dist * 0.1 - _Time.y) * 0.01;

纹理坐标变换

在需要动态调整纹理坐标或实现复杂 UV 变换时,纹理尺寸信息提供了必要的参考基准:

// 基于纹理尺寸的坐标缩放
float2 scaledUV = uv * float2(texWidth / 1024.0, texHeight / 1024.0);

这种技术可以用于实现自适应的纹理细节层次,或者根据纹理实际尺寸调整效果强度。

高级用法与最佳实践

对于有经验的着色器开发者,Texture Size 节点可以与其他 Shader Graph 节点结合使用,实现更加复杂和高效的效果。

与 Custom Function 节点结合

通过将 Texture Size 节点与 Custom Function 节点结合,可以实现高度定制化的纹理处理逻辑:

// 在Custom Function中使用纹理尺寸
void AdvancedTextureProcessing(float2 uv, float4 texelSize, out float4 result)
{
    // 实现自定义的纹理处理算法
    // 使用texelSize.z和texelSize.w获取纹理尺寸
    // 使用texelSize.x和texelSize.y进行精确的偏移计算
}

性能优化策略

在性能敏感的应用中,合理使用 Texture Size 节点可以显著提高渲染效率:

  • 在子图中预计算纹理尺寸相关值,避免重复计算
  • 利用纹理尺寸信息优化采样次数和采样模式
  • 在顶点着色器中计算纹理尺寸相关参数,减少片段着色器的计算负担

错误处理与调试

当 Texture Size 节点出现异常时,系统的调试策略包括:

  • 检查纹理导入设置,确保纹理资源正确配置
  • 验证纹理引用是否正确绑定
  • 使用 Debug 节点输出中间值进行调试
  • 检查目标平台的纹理尺寸限制和兼容性

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

我是怎么把单 Tool Calling 升级成多 Tool Runtime 的

本文对应项目版本:v0.0.6

v0.0.5 里,我已经把项目的单 Tool Calling 闭环跑通了:模型能发起 tool_calls,服务端能校验参数、执行工具,前端也能把 reasoning / tool / text 三类内容分开渲染。

但我很快意识到,单 Tool 能跑通,并不意味着系统已经具备了“多能力扩展”的基础。

v0.0.6 我真正想解决的问题不是“再接两个小功能”,而是把当前项目从单 Tool 验证版升级成一个可扩展的多 Tool Runtime

  • 服务端不再只围着一个工具转
  • 新增工具不需要继续把主流程越写越重
  • 前端能稳定展示不同类型的工具调用
  • 多轮上下文不至于随着能力变多而越来越失控

这篇文章就记录一下,这一版我是怎么把 calculator 扩展成 calculator + datetime + text-transform,以及在这个过程中做了哪些设计取舍、踩了哪些坑。

主界面图.png

为什么 v0.0.6 不直接做 Agent

这版最开始其实也有一个很自然的诱惑:既然已经有 Tool Calling 了,是不是下一步应该直接做 Agent、Skill、MCP?

最后我没有这么做,原因很简单:

  • v0.0.5 验证的是“单 Tool 可行”
  • v0.0.6 更值得验证的是“多 Tool Runtime 能不能站住”
  • 如果这时直接进入 Agent Loop、Skill 编排或者 MCP 接入,问题会一下子混在一起

所以我给 v0.0.6 定的边界非常明确:

  1. 只做多 Tool Runtime
  2. 只接入 3 个工具
  3. 不引入新的重型运行时
  4. 优先把注册、校验、执行、展示和上下文管理收稳

也就是说,这版的重点不是“能力平台化”,而是“运行时工程化”。

这版具体做了什么

先把本版范围说清楚。

本次接入的 3 个工具分别是:

  • calculator
  • datetime
  • text-transform

它们分别代表了三类不同能力:

  • calculator:确定性数值计算
  • datetime:确定性时间与日期处理
  • text-transform:结构化文本转换与提取

配套完成的核心能力还有:

  • Tool Registry 重构
  • 前端多 Tool 卡片展示
  • 最近 N=8 轮上下文窗口
  • 一轮回归测试清单与结果记录

这几个点加在一起,才构成了这一版真正的主题:

v0.0.6 的重点不是多了两个 Tool,而是项目第一次具备了可继续生长的多 Tool Runtime 骨架。

总体架构:先稳 Runtime,再谈上层能力

这一版的主链路还是延续前面的设计,只是运行时从“单 Tool”升级成了“多 Tool”。

用户输入
  -> 前端页面
    -> /api/chat
      -> chat-service
        -> Tool Registry
        -> LangChain ChatOllama
        -> tool calling / tool execution
          -> NDJSON stream
            -> useChatStream
              -> reasoning / tool / text 展示

这个架构里,我刻意保留了几件事:

  • 继续用 LangChain.js + Ollama
  • 继续保留自定义 NDJSON 协议
  • 继续保留 useChatStream
  • 继续保留 Markdown + typed parts + Streamdown

原因是这版的关键不是推翻已有结构,而是在已有结构里把 Runtime 层做扎实。

多 Tool 真正难的不是“接入”,而是 Runtime 设计

接一个 Tool 和管理多个 Tool,完全不是一回事。

单 Tool 时,很多问题都还不明显:

  • 工具定义写在一个文件里没关系
  • 主流程里偶尔写一点工具特判也能接受
  • 前端只展示一种 Tool 卡片也还说得过去

但工具一旦从 1 变成 3,问题就会立刻变得具体:

  • 工具怎么注册?
  • 每个工具的 schema 放哪?
  • 参数归一化由谁负责?
  • 不同工具的展示信息从哪来?
  • 错误路径怎么统一处理?
  • 新增一个 Tool 时,主运行时能不能尽量不改?

这也是为什么我把这一版最核心的升级点放在了 Tool Registry 上。

Tool Registry:这版最关键的工程升级

如果只看表面,这版像是在“新增两个 Tool”;但从工程角度看,更重要的是我先把 Tool 组织方式重构了。

我最后采用的是一种轻插件化思路:

  • 每个 Tool 都是独立能力单元
  • 每个 Tool 自己携带 schema、归一化逻辑、展示配置和执行逻辑
  • Runtime 只依赖统一接口,不依赖具体 Tool 的内部细节

这并不是重型插件系统,不涉及动态安装、插件市场或热插拔。它更像是:

Tool 是插件单元,Registry 是插件容器,Runtime 是插件调度层。

关键代码:统一的 Tool 定义接口

这段代码解决的问题是:让不同类型的工具,都能被 Runtime 用同一种方式注册和调度。

export interface ChatToolDefinition<TArgs = unknown> {
    name: string
    tool: StructuredToolInterface
    schema: ZodType<TArgs>
    normalizeArgs?: (args: unknown) => unknown
    formatInput?: (args: TArgs) => string
    formatOutput?: (result: unknown) => string
    getDisplayConfig?: (args: TArgs) => ToolDisplayConfig
    resultIsAuthoritative?: boolean
    isAvailable?: () => boolean
}

这里我最在意的是 4 个字段:

  • schema:决定这个 Tool 的输入边界
  • normalizeArgs:把模型生成的参数做轻量归一化
  • getDisplayConfig:给前端 Tool 卡片提供统一展示信息
  • resultIsAuthoritative:标记某个工具的结果是否应该被视为高优先级事实来源

也就是说,Registry 不是“把几个 Tool 放进数组里”这么简单,而是在为 Runtime 建立一个足够稳定的契约层。

关键代码:Registry 聚合入口

这段代码解决的问题是:新增 Tool 时,主运行时尽量不需要改。

import { calculatorToolDefinition } from './calculator-tool'
import { datetimeToolDefinition } from './datetime-tool'
import { createChatToolRegistry, type ChatToolDefinition } from './registry'
import { textTransformToolDefinition } from './text-transform-tool'

const chatToolDefinitions: ChatToolDefinition[] = [
    calculatorToolDefinition,
    datetimeToolDefinition,
    textTransformToolDefinition,
]

export const chatToolRegistry = createChatToolRegistry(chatToolDefinitions)

这个设计带来的直接收益是:

  • 新增 Tool 原则上只需要“新增文件 + 注册”
  • chat-service 不再需要知道每个 Tool 的内部细节
  • 后续往 Skill / MCP / Agent 方向演进时,也有一个比较清晰的能力层基础

为什么是 calculator、datetime、text-transform

这 3 个工具并不是随便挑的。

calculator:确定性数值工具

calculator 延续自 v0.0.5,它的价值不是“做个计算器”,而是作为多 Tool Runtime 里的基准工具

  • 输入输出边界非常清楚
  • 结果是确定性的
  • 很适合验证 tool_calls -> schema -> execution -> tool result 这条链路

同时,它也让我确认了一件事:

Tool 结果正确,不代表最终回答一定正确。

因为即使 calculator 算对了,模型在第二阶段组织答案时,仍然有可能把内容写歪。所以这类确定性工具,最终还需要“结果优先”策略兜底。

datetime:确定性时间工具

datetime 是这版最有代表性的新增 Tool。

它覆盖的能力包括:

  • 当前时间
  • 日期加减
  • 星期判断

之所以选它,是因为这类问题非常真实,又特别容易暴露 Tool Calling 的稳定性问题。比如:

  • “现在是什么时候”
  • “明天是星期几”
  • “后天是几号”

这类问题本质上都应该优先走工具,但实际运行里,模型有时会自己脑补推断,甚至说“我无法获取当前日期”。这也让我更清楚地看到:

Prompt 能提高命中率,但不能替代 Runtime 兜底。

text-transform:文本转换工具

text-transform 是这一版里我很喜欢的一个选择。

它不是继续做“闲聊能力”,而是验证另一类 Tool 设计方式:一个 Tool 下有多个 action。

我给它收的第一版 action 是:

  • markdown-to-text
  • extract-links
  • extract-code-blocks
  • json-pretty

它的价值在于:

  • 让 Runtime 不再只面向“单功能工具”
  • 提前验证“一 Tool 多 action”的 schema 设计
  • 为后续 Skill 提供更自然的基础能力组件

服务端 Runtime:重点不是能不能调 Tool,而是能不能稳定调对 Tool

多 Tool 之后,chat-service 的职责就不只是“把模型流透给前端”了。

它现在要负责:

  • 创建统一模型配置
  • 基于当前可用工具集合挂载 Tool 能力
  • 处理 planning / retry / final 三段生成
  • 校验 tool_calls
  • 执行 Tool
  • 输出 tool-start / tool-end / tool-error
  • 决定哪些 Tool 结果具有更高优先级

关键代码:统一模型接入层

这段代码解决的问题是:Runtime 不再按问题类型人工分流,而是按当前可用工具集合决定是否挂载 Tool 能力。

function createBaseModel(request: ChatRequest, deps: ChatServiceDependencies) {
    return new ChatOllama({
        model: request.options?.model ?? deps.defaultModel,
        baseUrl: deps.baseUrl ?? process.env.OLLAMA_BASE_URL ?? 'http://127.0.0.1:11434',
        temperature: request.options?.temperature ?? 0.3,
        numPredict: request.options?.maxTokens,
        think: request.options?.enableReasoning,
        streaming: true,
    })
}

const baseModel = createBaseModel(request, deps)
const activeTools = chatToolRegistry.listActive()
const toolBoundModel =
    activeTools.length > 0 ? baseModel.bindTools(activeTools.map(toolDefinition => toolDefinition.tool)) : null

这个判断的价值在于:

  • 它不是“普通模型”和“工具模型”两套业务分叉
  • 而是一个基础模型接入层,在运行时决定是否挂工具能力

这比继续往 chat-service 里堆问题类型判断,要干净得多。

关键代码:显式校验 tool call 参数

这段代码解决的问题是:模型输出并不可信,tool call 参数不能直接执行。

const normalizedArgs = toolDefinition.normalizeArgs
    ? toolDefinition.normalizeArgs(toolCall.args)
    : toolCall.args

const parsedArgs = toolDefinition.schema.safeParse(normalizedArgs)

if (!parsedArgs.success) {
    toolErrors.push({
        id: toolCall.id,
        toolName: toolCall.name,
        input: formatToolInput({
            ...toolCall,
            args: normalizedArgs,
        }),
        message: createToolValidationErrorMessage(toolCall, parsedArgs.error),
    })
    continue
}

validatedToolCalls.push({
    ...toolCall,
    args: parsedArgs.data,
})

这一步很关键,因为它把 Tool Calling 从“模型说了算”拉回到了“运行时有边界”。

关键代码:非法 tool call 不再静默 finish

这段代码解决的问题是:当模型生成的全是非法 tool_call 时,前端至少要收到明确的错误,而不是无声结束。

if (toolCalls.length === 0) {
    writeToolValidationErrors(validationResult.toolErrors, writeChunk)
    writeChunk({
        type: 'finish',
    })
    return
}

这是这一版回归测试里修掉的一个很重要的问题。之前如果模型只给出非法 tool_call,服务端会直接 finish,前端看起来像“只思考、不回答、也不报错”,排查体验非常差。

前端:现在渲染的不是字符串,而是工具事件流

进入多 Tool 之后,前端最大的变化不是“多了几个卡片”,而是消费内容的方式变了。

useChatStream 现在处理的是一串结构化事件:

  • start
  • reasoning-*
  • tool-*
  • text-*
  • finish
  • error

这意味着前端不再只是拼接一段字符串,而是在消费整个运行时状态变化。

关键代码:按 chunk 消费 NDJSON 流

这段代码解决的问题是:把服务端输出的结构化 NDJSON 流稳定转成前端状态更新。

async function consumeNdjsonStream(
    stream: ReadableStream<Uint8Array>,
    onChunk: (chunk: ChatStreamChunk) => void
) {
    const reader = stream.getReader()
    const decoder = new TextDecoder()
    let buffer = ''

    while (true) {
        const { done, value } = await reader.read()

        if (done) {
            break
        }

        buffer += decoder.decode(value, { stream: true })
        const lines = buffer.split('\n')
        buffer = lines.pop() ?? ''

        for (const line of lines) {
            const trimmedLine = line.trim()

            if (!trimmedLine) {
                continue
            }

            const parsedChunk = chatStreamChunkSchema.safeParse(JSON.parse(trimmedLine))

            if (!parsedChunk.success) {
                throw new Error('Invalid chat stream chunk.')
            }

            onChunk(parsedChunk.data)
        }
    }
}

关键代码:最近 N 轮上下文窗口

这段代码解决的问题是:前端保留完整聊天记录,但只把最近窗口回传给模型,减少历史噪音。

const MAX_CONTEXT_TURNS = 8

function getRecentContextWindow(messages: MindMessage[]): MindMessage[] {
    const systemMessages = messages.filter(message => message.role === 'system')
    const conversationalMessages = messages.filter(message => message.role !== 'system')

    const recentMessages: MindMessage[] = []
    let userTurnCount = 0

    for (let index = conversationalMessages.length - 1; index >= 0; index -= 1) {
        const message = conversationalMessages[index]
        recentMessages.unshift(message)

        if (message.role === 'user') {
            userTurnCount += 1

            if (userTurnCount >= MAX_CONTEXT_TURNS) {
                break
            }
        }
    }

    return [...systemMessages, ...recentMessages]
}

这里我没有一上来做摘要记忆,而是先固定 N = 8。原因很简单:

  • 实现简单
  • 行为稳定
  • 容易测试
  • 方便版本对比

对当前阶段来说,这是一个非常划算的工程折中。

took-think1.png

这版最值得记录的几个坑

这篇文章如果只写“最终方案”,其实会显得太平。v0.0.6 真正有价值的地方,恰恰在于它暴露了多 Tool Runtime 里的很多真实问题。

1. 多 Tool 不等于模型会稳定选 Tool

这版最明显的现象是:

  • calculator 相对比较稳
  • datetime 在“当前时间 / 相对日期”上并不稳定
  • text-transform 在非法 JSON 边界输入上也会绕开 Tool

这说明一个很现实的问题:

Tool 变多以后,系统的难点会从“能不能调 Tool”,转成“能不能稳定地调对 Tool”。

2. Prompt 很重要,但真的有上限

这一版我对 prompt 做了不少收紧,尤其是时间类问题:

  • 明确当前时间要走 datetime
  • 明确相对日期要优先调工具
  • 明确不能说“我无法获取当前日期”

这些约束确实有帮助,但实践下来我也越来越确定:

Prompt 可以提高命中率,但不能替代 Runtime。

尤其是:

  • 相对日期
  • 非法 JSON

这类边界问题,一旦只靠 prompt,收益会越来越接近上限。

3. 非法 tool call 的静默 finish

这个问题前面已经提过,但我觉得很值得单独记录。

因为它特别像真实工程里那种“功能看起来没挂,但体验非常差”的问题:

  • 服务端没有崩
  • 前端也没有明显异常
  • 但整条对话就像凭空断掉了一样

这种问题不把 Runtime 的错误链路补清楚,后面会非常难调。

4. 版本边界控制本身也是设计能力

这一版做完以后,我反而更确信一件事:

知道什么时候不做,比知道还能做什么更重要。

因为如果这版继续往下扩:

  • Agent Loop
  • Skill Runtime
  • MCP 接入

那整篇文章和整版工程都会失焦。

回归测试:这版到底稳到了什么程度

这一版我没有只凭“感觉能跑”就结束,而是把回归测试清单和实际回归结果单独整理成了文档。

重点验证了几类场景:

  • 普通问答
  • calculator
  • datetime
  • text-transform
  • 多轮上下文
  • 非法 tool_call
  • 一轮失败后下一轮是否受影响

当前可以认为比较稳定的部分:

  • 普通问答直答
  • calculator
  • text-transform 正常输入路径
  • 非法 tool_call 的服务端错误透传

还没有完全收稳的部分:

  • datetime 的当前时间 / 相对日期问题
  • text-transform(json-pretty) 的非法 JSON 边界输入

这也恰好说明了这版的真实状态:

多 Tool Runtime 骨架已经成型,但某些工具边界还在逼近“单靠 Prompt 不够”的上限。

当前版本已经完成什么,还没有完成什么

如果给 v0.0.6 一个比较准确的状态定义,我会说:

方案已经基本实现完成,版本进入收口和打磨阶段。

已完成

  • 多 Tool Runtime
  • Tool Registry
  • calculator
  • datetime
  • text-transform
  • 前端多 Tool 展示
  • 最近 N=8 轮上下文窗口
  • 回归测试清单与结果记录

还没做

  • Skill 系统
  • MCP 接入
  • Agent Loop
  • 长期记忆
  • 并行工具调度

这不是缺陷,而是我刻意保留的版本边界。

下一步路线:从 Runtime 走向更高层能力

这版做完之后,后面的演进路线已经比之前清楚很多了。

我现在更倾向于把后续能力理解成一条逐步演进链:

  • Tool:原子能力
  • Skill:能力模板
  • MCP:外部能力接入标准
  • Agent:调度这些能力完成任务的运行时

从这个角度看,v0.0.6 的价值并不只是多了两个 Tool,而是它第一次把这条演进链的底座打得比较像样了。

最后总结

这版真正完成的,不是“多接了两个工具”,而是让项目第一次具备了可继续演进的多 Tool Runtime 骨架。

它解决的是一组更底层、也更长期的问题:

  • Tool 怎么注册
  • Tool 怎么校验
  • Tool 怎么执行
  • Tool 怎么展示
  • 多轮上下文怎么控制

而这些问题一旦理顺,后面无论是继续扩 Tool,还是往 Skill / MCP / Agent 走,都会自然很多。

项目地址

GitHub:[github.com/HWYD/ai-min…]

如果这篇文章或这个项目对你有帮助,欢迎点个 Star 支持一下。
后续我也会继续按版本节奏,把它往 Skill、MCP、Agent 的方向一点点推进下去。

Superpowers:给 AI 编程 Agent 装上"工程化超能力"

Hi~大家好呀,我是清汤饺子。 前几天让 Claude Code 帮我写个小功能,它噼里啪啦一顿输出,代码倒是挺像那么回事。一跑,报错 40 个。

我盯着屏幕愣了三秒,然后开始一个个手动修。

事后复盘,问题不在 AI 写的代码烂,而在于——它太有热情了。拿到需求就开干,根本不问我"你想解决什么问题"、"这个场景下最优解是什么"。

这感觉就像招了一个「执行力超强但完全没有工程纪律」的 junior。

然后我发现了 Superpowers。

01 解决什么问题

AI Coding Agent 最大的通病,懂的都懂:

  • 拿到需求就开干:不等你确认,先肝为敬
  • 不写测试:代码写完自己都不知道写了啥
  • 代码像开盲盒:这次好使,下次不知道哪个版本就崩了

人类工程师有 TDD、有 code review、有设计评审,有一整套工程纪律来约束自己。但 AI Agent 呢?它只管输出,不管后果。

Superpowers 就是干这个的——给 AI Agent 装上一组技能卡,让它学会工程化的工作流

不是让它更聪明,是让它更有章法。

02 Superpowers 是什么

这是 Jesse Vincent(GitHub @obra)做的一个开源项目,全称是 Superpowers — An agentic skills framework & software development methodology

翻译成人话:一套给 AI 编程 Agent 用的技能框架

它不是让你用更厉害的模型,而是让你的 AI Agent 具备一套工程化思维:

  • 写代码前先做设计评审
  • 先写测试再写实现
  • 任务拆解到 2-5 分钟一个
  • 子 Agent 并行执行 + 两阶段 review

支持 Claude Code、Cursor、Codex、OpenCode 和 Gemini,主流 AI 编程工具都能用。

03 这工作流是怎么跑起来的

第一步:brainstorming —— 先别写代码,灵魂拷问一下

Superpowers 的第一条技能叫 brainstorming,触发时机是「写代码之前」。

当 AI 看到你要做新功能,它不会直接开干,而是反过来问你:

"你到底想解决什么问题?" "这个场景下有哪些边界情况?" "你觉得最优解是什么?"

我第一次用它做设计,它连着问了我 6 个问题才肯动笔。那感觉……像找了个 senior 在给我做 design review。

Socratic 追问,让 AI 先理解需求再动手。这治好了 AI "拿到需求就肝" 的毛病。

第二步:writing-plans —— 任务拆解到 2-5 分钟

需求确认之后,进入 writing-plans 技能。

AI 会把整个功能拆成若干小任务,每个任务:

  • 精确到文件路径
  • 有完整的代码内容
  • 有验收标准

更关键的是:每个任务 2-5 分钟就能跑完

以前我让 AI 写整个功能,它容易迷失在中途。现在它把活儿拆成「傻瓜式操作手册」,就像给一个「执行力强但没耐心」的 junior 写了一份 2 分钟就能完成的小任务清单。

第三步:subagent-driven-development —— 子 Agent 并行跑

计划就绪,主 Agent 调度 subagent-driven-development 技能。

它的核心是:

  1. 子 Agent 并行执行:每个任务交给独立的子 Agent 处理
  2. 两阶段 review:先检查规格是否合规,再检查代码质量
  3. 连续运行能力:实测 Claude 可以连续跑 2 小时不用管

简单说就是:你当老板,AI 们当工人。主 Agent 包工头负责分配任务、监督进度、质量把关。

第四步:TDD 红绿重构 —— 先写测试这道坎

这是我觉得最有价值的部分:test-driven-development

核心流程就三步:

  1. RED:写一个注定失败的测试
  2. GREEN:写最少的代码让测试通过
  3. REFACTOR:重构优化

重点是:必须先写测试,再写实现,测试前的代码直接删掉

这治好了 AI "写完代码懒得测" 的毛病。以前我让 AI 写功能,它输出完就完事,根本不管测试。现在它被强制绑上了 TDD 的战车。

第五步:收尾工作 —— finishing-a-development-branch

任务全部完成后,finishing-a-development-branch 技能接管:

  • 验证所有测试通过
  • 给出四个选项:merge / PR / 保留 / 丢弃
  • 自动清理 worktree

不需要你手动去处理分支清理,AI 会把收尾工作做完。

04 技能全景图

技能 触发时机 作用
brainstorming 写代码前 需求澄清,Socratic 追问
writing-plans 设计批准后 任务拆分,2-5min/任务
using-git-worktrees 设计批准后 创建独立分支,验证干净测试基线
verification-before-completion 调试完成后 验证问题真的修好了
subagent-driven-development 计划就绪 子 Agent 并行执行 + 两阶段 review
test-driven-development 实现中 强制红绿重构
systematic-debugging 调试时 4 阶段根因分析
requesting-code-review 任务间 按严重性报告问题
finishing-a-development-branch 任务完成 收尾 + 分支清理

这套技能的精妙之处在于:触发完全自动。你不需要手动调用,AI 会根据当前任务状态自动匹配技能。

就像给 AI 装了一堆「工程化本能」,遇到对应场景自动触发。

05 怎么装上

各平台安装方法:

Claude Code

# 方式一:官方 Claude 插件市场(推荐)
/plugin install superpowers@claude-plugins-official

# 方式二:社区 marketplace(需要先注册)
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Cursor

# 在 Agent chat 中
/add-plugin superpowers

Codex

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md

安装大约 5 分钟,配上之后的感觉像是——给 AI 做了一个完整的入职培训。

06 真实感受

惊喜时刻

  • 项目节奏完全变了。以前我追着 AI 跑,现在是 AI 追着任务跑
  • Claude 真的能连续跑 2 小时不出岔子
  • TDD 闭环治好了我懒得写测试的毛病

崩溃时刻

  • 第一次用的时候它问太多问题(brainstorming 阶段),差点想卸载
  • 配置比想象中复杂,需要花时间理解每个技能的触发逻辑

适合的人

  • 有一定经验的开发者,懂 TDD、懂工程化的人用起来如虎添翼
  • 团队协作场景,AI 能承接更多的工程纪律

不适合的人

  • 纯新手可能觉得被束缚,不知道为什么要这么做
  • 小项目不值得折腾,简单功能直接让 AI 写反而更快

07 本质是什么

用了一圈下来,我觉得 Superpowers 的本质是:

不是让 AI 替代你,是让它成为更有章法的搭档。

它不是在提升 AI 的智商,而是在约束 AI 的行为——让它像人类工程师一样思考、像人类工程师一样工作。

以前我把活儿交给 AI,总是提心吊胆,不知道它会整出什么幺蛾子。现在有了 Superpowers 的工程化约束,我更愿意把任务交给 AI 了。

因为它不会再半夜给我埋雷。

08 技术原理

看完了 GitHub 仓库之后,我发现 Superpowers 的实现比"配置文件合集"要精妙得多。

SKILL.md:技能即文档

每个技能都是一个 .md 文件(Markdown),放在 skills/ 目录下。文件格式包含两部分:

Frontmatter(YAML 元信息)

---
name: brainstorming
description: Use when [condition] - [what it does]
---

正文内容:技能的详细指令,告诉 AI 在什么场景下怎么做。

关键是 description 字段——这是 AI 自动发现和触发技能的依据。Codex/Claude Code 在每次任务执行前,会扫描 ~/.agents/skills/ 目录,根据 description 匹配当前上下文,自动激活对应技能。整个过程不需要你手动调用。

7 步接力:上游输出驱动下游输入

每一步的输出成为下一步的输入:

  • brainstorming 产出设计文档(human-approved)
  • using-git-worktrees 创建隔离分支环境
  • writing-plans 把设计拆成任务清单
  • subagent-driven-development 按任务执行 + 两阶段 review
  • test-driven-development 强制 TDD
  • requesting-code-review 任务间按严重性报告问题
  • finishing-a-development-branch 收尾

两阶段 Review:规格合规 → 代码质量

每个子 Agent 完成任务后,经历两关:

  1. 规格合规性审查:任务有没有按 plan 执行?有没有超出范围?
  2. 代码质量审查:代码本身写得怎么样?有没有明显 bug 或坏味道?

两关都过,才进入下一个任务。这治好了 AI "做多了或做歪了" 的问题。

TDD 强制闭环

test-driven-development 的核心规则:

  • RED:AI 必须先写一个注定失败的测试
  • GREEN:然后写最少的代码让测试通过
  • REFACTOR:最后重构优化

最狠的一条:测试写出来之前的代码直接删掉。AI 没有"先写实现后补测试"的选项。

哲学层:Process over guessing

README 里 Jesse Vincent 写了四条原则:

  • Test-Driven Development — 先写测试,永远
  • Systematic over ad-hoc — 系统化流程 > 猜测
  • Complexity reduction — 简单性是首要目标
  • Evidence over claims — 用验证说话,不要只靠感觉

本质就是:不要相信 AI 的直觉,要相信工程纪律

GitHub 仓库:github.com/obra/superp…


写在最后

Superpowers 这套技能框架,解决的不是 AI 能力不足的问题,而是 AI 行为不可控的问题。

如果你也在用 AI Coding Agent,感觉它"太热情但不靠谱",建议试试这套方法论。

当然,它不是银弹。工程纪律是给有工程经验的人用的,如果你本身对 TDD、代码审查这些概念不熟悉,Superpowers 可能会让你更困惑。

核心问题是:你愿不愿意花时间教会 AI 按你的方式工作?

这个问题没有标准答案,取决于你的项目规模和团队情况。


你在用 AI 编程工具吗?有什么"AI 疯狂输出但最后还是我来收拾烂摊子"的经历吗?欢迎在评论区聊聊,看看大家都有什么奇葩故事。

如果觉得有帮助,点个赞收藏一下,我会更有动力更新下一期。

也欢迎关注我的公众号「清汤饺子」,获取更多技术干货!

three 实现简单机械臂逆运动

很久没写博客了。原来那种事无巨细地铺开技术细节的写法,现在看性价比已经不高了,如何有结构地和 AI 协作反而更重要。这篇就从个人视角回顾一个具体案例。

开始

25 年底机缘巧合需要使用 Unity,我在接近零基础的情况下借助 Coding Agent,快速迁移和扩展了已有知识,把一个角色绕圆柱世界移动的需求拆成了运动合成问题,并通过大量试验做 trade-off,解决了视角抖动和偏移。虽然项目本身只是个半成品,但随着对话轮数增加,工程量还是涨得很快。整个过程在几周内完成,这样的迭代速度让我意识到可以去探索一些更有意思的东西,于是我开始花时间了解机器人的运动学。

机械臂建模

dhLinks.png

一开始最先遇到的问题是,机械臂该怎么定义。这个问题很快收敛到用 DH 参数和改进型 DH 参数(MDH)来描述机械结构。我原本以为这部分会很简单,无非是父子层级关系下的一套坐标系嵌套,但真正实现时还是踩了不少坑。后来通过几套结构反复试验、补上可视化 gizmo、再结合一些 AI 给出的改进方向,才把这部分逐渐理顺。这部分我单独整理到了 wwjll.github.io/three-chamb… ,希望对开始该领域学习的朋友有所帮助。

继续探索

这套东西本身已经很成熟了。我一开始就确定不想用 FABRIK、CCD 这类游戏里常见的巧解,也不想走基于几何关系推导的纯几何解析,因为一旦到了多轴机械臂,复杂度会迅速上升,而且不够通用。这样问题就明确了下来,需要引入 Jacobian matrix 来同时表达旋转和位移。问题到这里虽然变精确了,但也开始发散,因为我并不知道这些量在工程里到底一一对应什么。继续追问之后,AI 默认我已经有了相关背景,开始往工业解法和动力学方程上带。那时我的状态大概就是,“字都认识,意思不清楚”。

问题收敛

在继续扩展之前,我先把问题压到一个能实现的范围里。我想要的只是一个基于位移和旋转的简单可视化求解过程,用 JavaScript 跑在网页里,而不是把 Mujoco 一整套搬进来。于是我给自己定了一个边界:忽略电机参数、编码器噪声、动力学方程这些工业机械臂必须面对的内容,只保留 forward kinematics 和 inverse kinematics,用它们来定义 position error 和 orientation error。这样问题的复杂度就收敛到了一个我当时还能继续推进的层级。

问题定义

把问题压到最小以后,inverse kinematics 的目标就可以写得很直接。设机械臂当前 joint variables 为 qRn\mathbf q \in \mathbb R^n,end effector 当前 pose 记为 x(q)\mathbf x(\mathbf q),目标 pose 记为 xd\mathbf x_d。要做的并不是一次性“解出答案”,而是每一帧根据当前位置和目标位置之间的误差,算出一小步 joint increment Δq\Delta \mathbf q,让机械臂逐步逼近目标。

如果只看微分关系,这件事可以写成:

ΔxJ(q)Δq\Delta \mathbf x \approx \mathbf J(\mathbf q)\,\Delta \mathbf q

其中 J(q)\mathbf J(\mathbf q) 是 Jacobian matrix,它描述了“每个关节动一点点,end effector 的 pose 会怎样变化”。于是 inverse kinematics 的核心就变成了:已知末端误差 e\mathbf e,求一个合适的 Δq\Delta \mathbf q,使得

J(q)Δqe\mathbf J(\mathbf q)\,\Delta \mathbf q \approx \mathbf e

这里的 error vector 通常拆成 position error 和 orientation error 两部分:

e=[eper]R6\mathbf e = \begin{bmatrix} \mathbf e_p \\ \mathbf e_r \end{bmatrix} \in \mathbb R^6

其中 position error 可以直接写成

ep=pdp\mathbf e_p = \mathbf p_d - \mathbf p

orientation error 则不再直接拿 Euler angles 相减,而是更常见地转成 axis-angle 或 rotation vector 来表达。也就是说,我真正需要求解的不是“角度本身”,而是一个能让当前姿态朝目标姿态旋过去的微小旋转量。

如果 J\mathbf J 恰好是方阵且可逆,形式上可以写成

Δq=J1e\Delta \mathbf q = \mathbf J^{-1}\mathbf e

但这在真实问题里几乎不是常态。机械臂经常会遇到下面几种情况:

  • 关节数和任务维度不一致,J\mathbf J 不是方阵
  • 机械臂接近奇异位形,J\mathbf J 虽然看起来能逆,但数值会很不稳定
  • 有些目标本来就不可能被当前结构精确到达,只能求一个最接近的解

所以工程里更常见的是用 pseudoinverse 来做 least-squares 意义下的求解:

Δq=J+e\Delta \mathbf q = \mathbf J^+ \mathbf e

其中 J+\mathbf J^+J\mathbf J 的 Moore-Penrose pseudoinverse。可以把它理解成:在所有可能的 joint increment 里,找一个尽量减小末端误差、同时又不过分夸张的解。工程上通常不会直接停在普通 pseudoinverse 这一步,还会继续引入更稳的形式,但这个项目先走到这里。

整个求解过程可以理解成一个迭代循环:

qk+1=qk+αΔqk\mathbf q_{k+1} = \mathbf q_k + \alpha \,\Delta \mathbf q_k

阶段实现

ik.png

Finite Difference 验证

“每次沿一个很小的方向更新,然后重新计算误差”,顺着这个思路,我先让 Codex 搭了一个只处理位置误差的 demo。它每轮扰动角度 ε\mathbf \varepsilon,反复迭代求解。这个 demo 确实会慢慢向目标靠近,但速度很慢,收敛也不稳定。拆开来看,它做的是下面这件事:

首先,假设第 ii 列 Jacobian 通过 forward finite difference 来近似,那么它通常写成

Jip(q+εei)p(q)ε\mathbf J_i \approx \frac{\mathbf p(\mathbf q + \varepsilon \mathbf e_i) - \mathbf p(\mathbf q)}{\varepsilon}

其中 ei\mathbf e_i 是第 ii 个关节对应的 basis vector。这个式子看起来只是一列一个小公式,但真正落到代码里,含义其实是:

  • 先拿当前关节姿态 q\mathbf q
  • 只扰动第 ii 个关节一个很小的量 ε\varepsilon
  • 重新做一次 forward kinematics,得到新的末端位置
  • 和原来的末端位置做差
  • 最后除以 ε\varepsilon

问题在于,Jacobian 不是只有一列,而是每个关节都要来一次。如果机械臂有 nn 个关节,那么一轮迭代里大致要做:

  • 1 次 forward kinematics,用来求当前误差
  • nn 次扰动后的 forward kinematics,用来拼出整个 Jacobian

也就是说,一轮迭代的成本大约就是

1+n1 + n

次 FK 级别的工作。

写成伪代码:

function solveStep(q, targetPosition, epsilon):
    # 1. 当前姿态先做一次 FK,拿到当前位置和误差
    p0 = forwardKinematics(q)
    error = targetPosition - p0

    # 2. 用数值差分构造 Jacobian
    J = zeroMatrix(3, n)

    for i in 0 .. n-1:
        qPerturbed = copy(q)
        qPerturbed[i] += epsilon

        pi = forwardKinematics(qPerturbed)

        Ji = (pi - p0) / epsilon
        J.setColumn(i, Ji)

    # 3. 解一个关节增量
    dq = pseudoInverse(J) * error

    # 4. 更新关节
    qNext = q + alpha * dq
    return qNext

如果放到 three.js 这类基于节点树的实现里,这个“做一次 FK”往往不只是算几个三角函数,而是要把整条链条上的 local transform 重新传播到 world transform。换句话说,每求一列数值 Jacobian,基本都要重新触发一遍从关节到末端的 world matrix 更新。这也是为什么它在 demo 阶段还能跑,但一旦关节数增多、每帧迭代次数提高,性能就会很快掉下去。

如果这时再叠加一些工程上常见的策略,比如:

  • 每轮失败后 retry
  • 为了避免发散做 backtracking
  • 对多个 candidate step 分别试算误差

那么每试一次候选步长,通常都还要重新评估一次误差,开销会继续往上叠。所以“差分法验证”很适合拿来确认思路,但并不适合作为后续稳定迭代的核心方案。

另外,finite difference 还有一个精度和稳定性上的两难。ε\varepsilon 取大了,导数近似会变粗;ε\varepsilon 取小了,又容易受到浮点误差和姿态表示方式的影响,尤其是在旋转问题里更明显。它既慢,又不够稳,这也是我后来必须继续往 analytic Jacobian 方向走的原因。

Analytic Jacobian 梯度下降

对第 ii 个转动关节,记:

  • joint position 为 pi\mathbf p_i
  • joint axis direction 为 ai\mathbf a_i
  • 末端位置为 p\mathbf p

则 Jacobian 的 linear velocity 部分为:

Jv,i=ai×(ppi) \mathbf J_{v,i} = \mathbf a_i \times (\mathbf p - \mathbf p_i)

angular velocity 部分为:

Jω,i=ai \mathbf J_{\omega,i} = \mathbf a_i

所以第 ii 列 Jacobian 写成:

Ji=[Jv,iJω,i]=[ai×(ppi)ai] \mathbf J_i = \begin{bmatrix} \mathbf J_{v,i} \\ \mathbf J_{\omega,i} \end{bmatrix} = \begin{bmatrix} \mathbf a_i \times (\mathbf p - \mathbf p_i) \\ \mathbf a_i \end{bmatrix}

写成伪代码,会更容易看出为什么它比 finite difference 便宜:

function solveStepAnalytic(q, targetPosition):
    # 1. 先做一次 FK,拿到整条链的世界坐标信息
    updateWorldTransforms(q)

    pEnd = getEndEffectorPosition()
    error = targetPosition - pEnd

    # 2. 直接用关节轴和末端位置构造 Jacobian
    J = zeroMatrix(3, n)

    for i in 0 .. n-1:
        pJoint = getJointWorldPosition(i)
        axis = getJointWorldAxis(i)

        Ji = cross(axis, pEnd - pJoint)
        J.setColumn(i, Ji)

    # 3. 解一个关节增量
    dq = pseudoInverse(J) * error

    # 4. 更新关节
    qNext = q + alpha * dq
    return qNext

这里的 qNext 表示这一轮更新之后的新 joint state,也就是把当前 joint variables q\mathbf q 沿着本轮算出来的 increment Δq\Delta \mathbf q 推进一步:

qk+1=qk+αΔqk\mathbf q_{k+1} = \mathbf q_k + \alpha \Delta \mathbf q_k

finite difference 和 analytic Jacobian 最大的区别,不在最后那一步更新公式,而在 Jacobian 的构造方式:

  • finite difference 是“每扰动一个关节,就重新做一次 FK,再拿结果做差”
  • analytic Jacobian 是“先做一次 FK,拿到所有关节的 world position 和 axis direction,再直接算出每一列”

所以每轮迭代的开销大致分别是:

数值差分:

1+n 次 FK1 + n \text{ 次 FK}

analytic Jacobian:

1 次 FK+O(n) 个向量运算1 \text{ 次 FK} + O(n) \text{ 个向量运算}

前者把大部分时间花在重复刷新整条链的 world transform,后者则把这部分工作压缩到一次,然后只做叉乘、减法和矩阵拼装。对于 three.js 这种场景,这个差距会很直接地反映在每帧迭代次数和交互流畅度上。

到这里,这个简单的算法已经能比较流畅地工作了。点击实验 wwjll.github.io/three-chamb…

加入 Physics Engine

ikPick.png

后来发现官方在用 rapier 这个相对轻量的 physics engine,于是我也把它引了进来,设计了一个带滑轨的夹爪,并把各个部分做了一定程度的解耦。动画过程也被拆成几个阶段:夹爪下降、夹取、抬升、移动到目标位、释放。

为了保证渲染性能,我把整个仓库里的例子都改成了 lazy rendering,也就是只有显式触发 render request 时才会真正渲染,性能提升很明显。

但 physics engine 和 grasp flow 一旦加进来,复杂度也立刻上去了,state control 多了很多。为了让过程更可控,又补了不少设定:

  • 预设了 end effector 垂直向下的 zero pose
  • 抓取过程的 physics contact state 解除
  • 增加了 joint limits,限位外的无法到达
  • 增加了 axis sign 来方便控制不同关节旋转正负号
  • position、quaternion pose 的插值
  • 可视化调节 controls

这部分可以在 wwjll.github.io/three-chamb… 里实验,需要先点击 “spawn cubes” 生成拾取方块。

最后的感受是,复杂度上来之后,真正关键的不是多写几轮代码,而是先把整体结构想清楚。遇到未知步骤时要停下来,重新拆解和设计,而不是顺着惯性往下堆实现。和 AI 协作也是一样,前提仍然是自己对问题边界、模块关系和验证方式有基本判断。

❌