fix: 编码问题

Author: yefansky

src/fuzzyMatch.ts

@@ -1,4 +1,4 @@
-// ================ 类型定义 ================
+// ================ 类型定义 ================
 interface MatchPosition {
     start: number;
     end: number;
@@ -9,7 +9,7 @@ interface NormalizedContent {
     mapping: number[];
 }
 
-// ================ 核心实现 ================
+// ================ 核心实现 ================
 const MAX_EDIT_DISTANCE = 5;
 const SEGMENT_COUNT = MAX_EDIT_DISTANCE + 1;
 
@@ -18,42 +18,42 @@ export function applyFuzzyGlobalReplace(
     strOldContent: string,
     strNewContent: string
 ): string {
-    // 第二阶段：模糊匹配流程
+    // 第二阶段：模糊匹配流程
     const { content: normContent, mapping } = normalizeContent(strContent);
     const pattern = normalizePattern(strOldContent);
 
-    // 分片查找候选位置
+    // 分片查找候选位置
     const candidates = findCandidatePositions(normContent, pattern);
 
-    // 验证并获取有效匹配
+    // 验证并获取有效匹配
     const matches = verifyMatches(normContent, pattern, candidates, mapping);
 
     if (matches.length === 0) {
-        throw new Error(`GLOBAL-REPLACE失败：未找到允许${MAX_EDIT_DISTANCE}个字符差异的匹配`);
+        throw new Error(`GLOBAL-REPLACE失败：未找到允许${MAX_EDIT_DISTANCE}个字符差异的匹配`);
     }
 
-    // 应用替换
+    // 应用替换
     return applyReplacements(strContent, matches, strNewContent);
 }
 
-// ================ 算法核心模块 ================
+// ================ 算法核心模块 ================
 export function normalizeContent(original: string): { content: string; mapping: number[] } {
-    // 第一步：去除注释
+    // 第一步：去除注释
     const { content: noComments, mapping: mapping1 } = removeComments(original);
 
-    // 第二步：去除符号前后的空格
+    // 第二步：去除符号前后的空格
     const { content: noSymbolSpaces, mapping: mapping2 } = removeSymbolSpaces(noComments);
 
-    // 第三步：将换行符改为空格，并合并连续的空格
+    // 第三步：将换行符改为空格，并合并连续的空格
     const { content: finalContent, mapping: mapping3 } = normalizeWhitespace(noSymbolSpaces);
 
-    // 合并 mapping
+    // 合并 mapping
     const finalMapping = mapping3.map(idx => mapping2[idx]).map(idx => mapping1[idx]);
 
     return { content: finalContent, mapping: finalMapping };
 }
 
-// 辅助函数1：去除注释，并确保 mapping 数组严格对应每个输出字符（包括换行符）
+// 辅助函数1：去除注释，并确保 mapping 数组严格对应每个输出字符（包括换行符）
 export function removeComments(original: string): { content: string; mapping: number[] } {
     const astrLines: string[] = original.split('\n');
     let strContent: string = "";
@@ -65,27 +65,27 @@ export function removeComments(original: string): { content: string; mapping: nu
         const nCommentIndex: number = strLine.indexOf('//');
         const strCleanLine: string = nCommentIndex !== -1 ? strLine.slice(0, nCommentIndex) : strLine;
 
-        // 添加清理后的行内容，并记录映射
+        // 添加清理后的行内容，并记录映射
         strContent += strCleanLine;
         for (let nI: number = 0; nI < strCleanLine.length; nI++) {
             arrMapping.push(nCurrentPos + nI);
         }
 
-        // 只有在不是最后一行时添加换行符
+        // 只有在不是最后一行时添加换行符
         if (i < astrLines.length - 1) {
             strContent += "\n";
             arrMapping.push(nCurrentPos + strLine.length);
-            nCurrentPos += strLine.length + 1; // +1 表示换行符
+            nCurrentPos += strLine.length + 1; // +1 表示换行符
         } else {
-            nCurrentPos += strLine.length; // 最后一行没有换行符
+            nCurrentPos += strLine.length; // 最后一行没有换行符
         }
     }
     return { content: strContent, mapping: arrMapping };
 }
 
-// 辅助函数2：去除符号前后的空格
+// 辅助函数2：去除符号前后的空格
 export function removeSymbolSpaces(strContentIn: string): { content: string; mapping: number[] } {
-    // 更新正则表达式，匹配常见符号
+    // 更新正则表达式，匹配常见符号
     const regSymbols: RegExp = /[+\-/*()\[\]{};=,'"`!&|]/;
     let strNewContent: string = "";
     const arrMapping: number[] = [];
@@ -94,59 +94,59 @@ export function removeSymbolSpaces(strContentIn: string): { content: string; map
     for (let nI: number = 0; nI < nLen; nI++) {
         const strCurrentChar: string = strContentIn[nI];
 
-        // 使用正则表达式匹配所有空白字符（空格、制表符、换行符等）
+        // 使用正则表达式匹配所有空白字符（空格、制表符、换行符等）
         if (/\s/.test(strCurrentChar) && strCurrentChar !== '\n') {
-            // 查找向左第一个非空白字符
+            // 查找向左第一个非空白字符
             let nPrev: number = nI - 1;
             while (nPrev >= 0 && /\s/.test(strContentIn[nPrev])) {
                 nPrev--;
             }
-            // 查找向右第一个非空白字符
+            // 查找向右第一个非空白字符
             let nNext: number = nI + 1;
             while (nNext < nLen && /\s/.test(strContentIn[nNext])) {
                 nNext++;
             }
 
             let bSkipSpace: boolean = false;
-            // 如果前一个字符是符号，跳过当前空白字符
+            // 如果前一个字符是符号，跳过当前空白字符
             if (nPrev >= 0 && regSymbols.test(strContentIn[nPrev])) {
                 bSkipSpace = true;
             }
-            // 如果后一个字符是符号，跳过当前空白字符
+            // 如果后一个字符是符号，跳过当前空白字符
             if (nNext < nLen && regSymbols.test(strContentIn[nNext])) {
                 bSkipSpace = true;
             }
 
             if (bSkipSpace) {
-                continue; // 跳过符号附近的空白字符
+                continue; // 跳过符号附近的空白字符
             }
         }
 
-        // 保留非空白字符或未跳过的空白字符
+        // 保留非空白字符或未跳过的空白字符
         strNewContent += strCurrentChar;
         arrMapping.push(nI);
     }
 
     return { content: strNewContent, mapping: arrMapping };
 }
 
-// 辅助函数3：将换行符改为空格，并合并连续的空格
+// 辅助函数3：将换行符改为空格，并合并连续的空格
 export function normalizeWhitespace(content: string): { content: string; mapping: number[] }
 {
     let strNewContent: string = "";
     let arrMapping: number[] = [];
-    let bAtLineStart: boolean = true;          // 标记当前是否处于行首
-    let nPendingSpaceIndex: number | null = null; // 待添加空格的原始索引
+    let bAtLineStart: boolean = true;          // 标记当前是否处于行首
+    let nPendingSpaceIndex: number | null = null; // 待添加空格的原始索引
 
     for (let nIdx = 0; nIdx < content.length; nIdx++)
     {
         const chChar: string = content[nIdx];
 
         if (chChar === '\n')
         {
-            // 遇到换行符时，丢弃待添加的空格（避免行尾空格）
+            // 遇到换行符时，丢弃待添加的空格（避免行尾空格）
             nPendingSpaceIndex = null;
-            // 如果输出为空或上一个字符不是换行符，则添加换行符
+            // 如果输出为空或上一个字符不是换行符，则添加换行符
             if (strNewContent.length === 0 || strNewContent[strNewContent.length - 1] !== '\n')
             {
                 strNewContent += '\n';
@@ -156,7 +156,7 @@ export function normalizeWhitespace(content: string): { content: string; mapping
         }
         else if (/\s/.test(chChar))
         {
-            // 遇到非换行空白字符：如果在行首，则忽略；否则，记录第一个空白字符索引
+            // 遇到非换行空白字符：如果在行首，则忽略；否则，记录第一个空白字符索引
             if (!bAtLineStart)
             {
                 if (nPendingSpaceIndex === null)
@@ -167,7 +167,7 @@ export function normalizeWhitespace(content: string): { content: string; mapping
         }
         else
         {
-            // 遇到非空白字符时，如果有待添加的空格则先输出一个空格
+            // 遇到非空白字符时，如果有待添加的空格则先输出一个空格
             if (nPendingSpaceIndex !== null)
             {
                 strNewContent += ' ';
@@ -235,13 +235,13 @@ export function verifyMatches(
         }
     });
 
-    // 如果找到了最佳候选，则用贪心方式扩展匹配范围
+    // 如果找到了最佳候选，则用贪心方式扩展匹配范围
     if (bestMatch && bestCandidate !== -1)
     {
         let candidateIdx: number = bestCandidate;
         let patternIdx: number = 0;
         let startIndex: number = -1;
-        // 从最佳候选起点开始，贪心扫描候选区域，遇到匹配的字符则同步推进模式串下标
+        // 从最佳候选起点开始，贪心扫描候选区域，遇到匹配的字符则同步推进模式串下标
         while (candidateIdx < content.length && patternIdx < pattern.length)
         {
             if (content.charAt(candidateIdx) === pattern.charAt(patternIdx))
@@ -256,7 +256,7 @@ export function verifyMatches(
         }
 
         let tmpMatch : MatchPosition = bestMatch;
-        // nCandidateIdx 作为最终匹配结束位置（注意这里是最后一次匹配后加1的位置）
+        // nCandidateIdx 作为最终匹配结束位置（注意这里是最后一次匹配后加1的位置）
         tmpMatch.start = mapping[startIndex];
         tmpMatch.end = mapping[Math.min(candidateIdx, content.length - 1)];
         bestMatch = tmpMatch;
@@ -265,7 +265,7 @@ export function verifyMatches(
     return bestMatch ? [bestMatch] : [];
 }
 
-// ================ 工具函数 ================
+// ================ 工具函数 ================
 function splitPatternWithStart(pattern: string, count: number): { segment: string, start: number }[] {
     const segments: { segment: string, start: number }[] = [];
     const minSegmentLength = 3;
@@ -289,7 +289,7 @@ function calculateEditDistance(a: string, b: string, maxDistance: number): numbe
         return Infinity;
     }
 
-    // 使用滚动数组优化
+    // 使用滚动数组优化
     let prevRow = Array(b.length + 1).fill(0).map((_, i) => i);
     let currentRow = new Array(b.length + 1);
 

src/utiliti.ts

@@ -8,41 +8,41 @@ export function activate(context: ExtensionContext) {
 }
 
 /**
- * 读取文件并根据其编码（GBK、UTF-8 或带 BOM 的 UTF-8）转换为 UTF-8 字符串
- * @param filePath 文件路径
- * @returns 转换后的 UTF-8 字符串
- * @throws 如果无法读取文件或解码失败，抛出错误
+ * 读取文件并根据其编码（GBK、UTF-8 或带 BOM 的 UTF-8）转换为 UTF-8 字符串
+ * @param filePath 文件路径
+ * @returns 转换后的 UTF-8 字符串
+ * @throws 如果无法读取文件或解码失败，抛出错误
  */
 export async function readFileAsUtf8(filePath: string): Promise<string> {
     try {
-        // 读取文件的原始 Buffer
+        // 读取文件的原始 Buffer
         const buffer = await fs.readFile(filePath);
 
-        // 检测是否为带 BOM 的 UTF-8
+        // 检测是否为带 BOM 的 UTF-8
         const isUtf8WithBom =
             buffer.length >= 3 &&
             buffer[0] === 0xEF &&
             buffer[1] === 0xBB &&
             buffer[2] === 0xBF;
 
         if (isUtf8WithBom) {
-            // 移除 BOM 并作为 UTF-8 解码
+            // 移除 BOM 并作为 UTF-8 解码
             return buffer.slice(3).toString('utf8');
         }
 
-        // 尝试作为 UTF-8 解码
+        // 尝试作为 UTF-8 解码
         try {
-            // 先验证是否是有效的 UTF-8
+            // 先验证是否是有效的 UTF-8
             const utf8Text = buffer.toString('utf8');
-            // 简单的 UTF-8 有效性检查：重新编码后比较
+            // 简单的 UTF-8 有效性检查：重新编码后比较
             if (Buffer.from(utf8Text, 'utf8').equals(buffer)) {
                 return utf8Text;
             }
         } catch (utf8Error) {
-            // 如果 UTF-8 解码失败，继续尝试 GBK
+            // 如果 UTF-8 解码失败，继续尝试 GBK
         }
 
-        // 尝试作为 GBK 解码
+        // 尝试作为 GBK 解码
         try {
             const gbkText = iconv.decode(buffer, 'gbk');
             return gbkText;