VS Code扩展开发：如何避免在字符串/注释中替换指定关键词

嗨，这个问题我之前也碰到过——简单的全局字符串匹配肯定会误触注释和字符串里的内容，核心解决方案是用状态机跟踪代码上下文，精准区分正常代码、字符串、注释区域，只在真正的代码区做替换。下面是具体的实现思路和修改后的完整代码：

我们需要维护一个状态变量，逐字符扫描代码时切换状态，比如：

• 正常代码区
• 单引号/双引号字符串内
• 单行注释内
• 多行注释内（还要支持跨行的情况）

只有当状态处于「正常代码区」时，才去匹配并替换目标关键词。

1. 定义状态枚举 #

先把需要区分的状态用枚举明确下来：

enum ParseState {
  Normal,          // 正常代码区域
  SingleQuoteStr,  // 单引号字符串内
  DoubleQuoteStr,  // 双引号字符串内
  LineComment,     // 单行注释内
  BlockComment     // 多行注释内（未结束）
}

2. 修改StUpdater类实现 #

下面是修改后的完整代码，加入了状态机逻辑，还额外处理了转义字符、关键词边界（避免匹配类似mytrue的自定义变量）和跨行多行注释：

import { window, workspace, WorkspaceEdit, Range, Position } from 'vscode';

export class StUpdater {
  private _lines: number;
  private _targetKeywords: Array<string>;
  // 记住多行注释的状态，处理跨行的情况
  private _inBlockComment: boolean = false;

  constructor() {
    this._lines = 0;
    this._targetKeywords = ['true', 'false', 'exit', 'continue', 'return'];
  }

  Update(Cntx: boolean = false) {
    const editor = window.activeTextEditor;
    if (!editor || editor.document.languageId !== 'st') {
      window.showErrorMessage('No valid ST editor active!');
      return;
    }

    const doc = editor.document;
    if (!Cntx) {
      if (this._lines >= doc.lineCount) {
        this._lines = doc.lineCount;
        return;
      }
      this._lines = doc.lineCount;
      const autoFormat = workspace.getConfiguration('st').get('autoFormat');
      if (!autoFormat) {
        return;
      }
    }

    const edit = new WorkspaceEdit();
    // 初始化状态：如果上次停在多行注释中，这次继续
    let currentState = this._inBlockComment ? ParseState.BlockComment : ParseState.Normal;

    for (let lineNum = 0; lineNum < doc.lineCount; lineNum++) {
      const line = doc.lineAt(lineNum);
      const lineText = line.text;
      const lineLength = lineText.length;
      let charIndex = 0;

      while (charIndex < lineLength) {
        const char = lineText[charIndex];

        switch (currentState) {
          case ParseState.Normal:
            // 碰到单行注释，直接跳到行尾
            if (char === '/' && charIndex + 1 < lineLength && lineText[charIndex + 1] === '/') {
              currentState = ParseState.LineComment;
              charIndex += 2;
              break;
            }
            // 碰到多行注释开始，切换状态
            if (char === '/' && charIndex + 1 < lineLength && lineText[charIndex + 1] === '*') {
              currentState = ParseState.BlockComment;
              charIndex += 2;
              break;
            }
            // 碰到单引号字符串
            if (char === "'") {
              currentState = ParseState.SingleQuoteStr;
              charIndex++;
              break;
            }
            // 碰到双引号字符串
            if (char === '"') {
              currentState = ParseState.DoubleQuoteStr;
              charIndex++;
              break;
            }
            // 现在是正常代码区，检查目标关键词
            let matched = false;
            for (const keyword of this._targetKeywords) {
              const keywordLen = keyword.length;
              if (charIndex + keywordLen <= lineLength && lineText.slice(charIndex, charIndex + keywordLen) === keyword) {
                // 验证关键词前后是单词边界，避免匹配`mytrue`这类变量
                const prevChar = charIndex > 0 ? lineText[charIndex - 1] : '';
                const nextChar = charIndex + keywordLen < lineLength ? lineText[charIndex + keywordLen] : '';
                const isWordBoundary = /\W|^$/.test(prevChar) && /\W|^$/.test(nextChar);
                
                if (isWordBoundary) {
                  // 执行替换
                  edit.replace(
                    doc.uri,
                    new Range(
                      new Position(lineNum, charIndex),
                      new Position(lineNum, charIndex + keywordLen)
                    ),
                    keyword.toUpperCase()
                  );
                  charIndex += keywordLen;
                  matched = true;
                  break;
                }
              }
            }
            // 没匹配到关键词，移动一个字符
            if (!matched) charIndex++;
            break;

          case ParseState.SingleQuoteStr:
            // 碰到非转义的单引号，退出字符串状态
            if (char === "'" && (charIndex === 0 || lineText[charIndex - 1] !== '\\')) {
              currentState = ParseState.Normal;
            }
            charIndex++;
            break;

          case ParseState.DoubleQuoteStr:
            // 碰到非转义的双引号，退出字符串状态
            if (char === '"' && (charIndex === 0 || lineText[charIndex - 1] !== '\\')) {
              currentState = ParseState.Normal;
            }
            charIndex++;
            break;

          case ParseState.LineComment:
            // 单行注释直接跳到行尾
            charIndex = lineLength;
            break;

          case ParseState.BlockComment:
            // 碰到多行注释结束，切换回正常状态
            if (char === '*' && charIndex + 1 < lineLength && lineText[charIndex + 1] === '/') {
              currentState = ParseState.Normal;
              charIndex += 2;
            } else {
              charIndex++;
            }
            break;
        }
      }
    }

    // 保存多行注释状态，下次调用Update时继续处理
    this._inBlockComment = currentState === ParseState.BlockComment;

    return workspace.applyEdit(edit);
  }

  public dispose() {
    this._inBlockComment = false;
  }
}

// 补充状态枚举定义
enum ParseState {
  Normal,
  SingleQuoteStr,
  DoubleQuoteStr,
  LineComment,
  BlockComment
}

几个关键优化点 #

• 上下文精准识别：通过状态机彻底区分了代码、字符串、注释区域，不会再误替换
• 关键词边界检查：避免把mytrue这类包含关键词的变量当成目标替换
• 转义字符处理：字符串里的转义引号（比如\"）不会被当成字符串结束符
• 跨行多行注释支持：记住多行注释的状态，即使注释跨了好几行也能正确处理

这样修改后，你的工具就只会在真正的ST代码里替换true/false这些关键词，完全不会碰字符串和注释里的内容啦！

内容的提问来源于stack exchange，提问作者Sergey Romanov