WPS中代码段的识别方法及JS宏实现

于 2025-05-17 01:20:23 发布
阅读量795 收藏 19
点赞数 18
文章标签： wps javascript 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzm12278828/article/details/148020004
版权
#JavaScript性能优化实战#

在WPS中，文档的基本结构可以通过对象模型来理解：

（1）Document对象：表示整个文档

（2）Range对象：表示文档中的一段连续区域，可以是一个字符、一个句子或整个文档

（3）Paragraph对象：表示文档中的段落

（4）Selection对象：表示当前用户选中的区域

为了更高效的工作，我们希望通过WPS JS宏可以帮助你识别文档中的代码段并添加样式，快速实现美化文档效果。这时，就要先确定文档中的内容是否为代码段，有很多的方法。

一、基于标记的代码段识别方法

1.方法概述

基于标记的方法，即通过特定的开始和结束标记来识别代码块。这种方法适用于已经使用特定标记（如 ```、/* */ 等）标识的代码。

这种方法需要定义多种可能的代码块标记，包括常见的Markdown、HTML和注释风格标记，使用正则表达式来查找文档中的代码块，之后再为每个识别出的代码块应用统一的样式，包括边框、背景色和等宽字体。

为什么提示 “未在文档中找到代码块！”？

这可能有以下几个原因：

（1）文档中确实没有使用预定义标记的代码块

（2）代码块使用了其他标记或格式

（3）正则表达式匹配不够灵活，无法识别某些格式的代码块

2.改进代码块识别的方法

以下是几种可以改进代码块识别的方法：

（1）增加更多的标记类型：可以扩展codeStartMarkers和codeEndMarkers数组，添加更多可能的代码块标记。添加了常见的编程和 HTML 标记（如 <?php、<script 等），可以根据需要继续扩展这个列表。

（2）基于代码特征识别：除了标记外，还可以基于代码的一些特征来识别，如缩进、特定关键字等。例如，通过检测连续缩进的段落来识别代码块，设置了一个缩进阈值（4 个空格），超过这个阈值的段落会被视为代码的一部分。例如，添加关键字检测，检查段落是否以常见的代码关键字（如function、if、for等）开头，这有助于识别没有明显缩进但确实是代码的段落。

（3）使用AI辅助识别：如果需要更智能的识别，可以考虑调用AI API来分析文本是否为代码。

3.代码示例

// 高亮代码块主函数 - 供自定义功能区按钮调用

function highlightCodeBlocks() {

    try {

        // 获取当前文档

        let doc = ThisDocument;

        if (!doc) {

            alert("未找到当前文档!");

            return;

        }

        

        // 定义代码块样式配置

        let codeBlockStyle = {

            borderColor: "#cccccc",

            borderWidth: 1,

            backgroundColor: "#f7f7f9",

            fontFamily: "Consolas, 'Courier New', monospace",

            fontSize: 10.5

        };

        

        // 获取文档内容

        let content = doc.Content.Text;

        

        // 方法1: 使用标记识别代码块

        let codeBlocks = findCodeBlocksByMarkers(content);

        

        // 方法2: 识别连续缩进的段落作为代码块

        if (codeBlocks.length === 0) {

            codeBlocks = findCodeBlocksByIndentation(doc);

        }

        

        // 如果没有找到代码块，提示用户

        if (codeBlocks.length === 0) {

            alert("未在文档中找到代码块!");

            return;

        }

        

        // 处理每个代码块

        for (let block of codeBlocks) {

            try {

                // 创建Range对象

                let codeRange = doc.Range(block.start, block.end);

                

                // 应用代码块样式

                applyCodeBlockStyle(codeRange, codeBlockStyle);

            } catch (e) {

                console.error(`处理代码块时出错: ${e.message}`);

            }

        }

        

        alert(`成功处理 ${codeBlocks.length} 个代码块!`);

    } catch (e) {

        alert(`执行过程中出错: ${e.message}`);

    }

}



// 方法1: 使用标记识别代码块

function findCodeBlocksByMarkers(content) {

    // 定义代码块可能的开始和结束标记

    let codeStartMarkers = [

        "```", "/*", "<code>", "# 代码开始", "// 代码开始",

        "<?php", "<script", "<style", "<html"

    ];

    let codeEndMarkers = [

        "```", "*/", "</code>", "# 代码结束", "// 代码结束",

        "?>", "</script>", "</style>", "</html>"

    ];

    

    let codeBlocks = [];

    

    // 使用正则表达式查找代码块

    for (let i = 0; i < codeStartMarkers.length; i++) {

        let startMarker = codeStartMarkers[i];

        let endMarker = codeEndMarkers[i];

        

        // 构建正则表达式

        let regexPattern = `${escapeRegExp(startMarker)}(.*?)${escapeRegExp(endMarker)}`;

        let regex = new RegExp(regexPattern, 'gs');

        

        let match;

        while ((match = regex.exec(content)) !== null) {

            codeBlocks.push({

                start: match.index,

                end: match.index + match[0].length,

                content: match[0]

            });

        }

    }

    

    return codeBlocks;

}



// 方法2: 识别连续缩进的段落作为代码块

function findCodeBlocksByIndentation(doc) {

    let codeBlocks = [];

    let currentCodeBlock = null;

    let indentThreshold = 4; // 至少4个空格的缩进

    

    // 遍历文档中的每个段落

    for (let i = 1; i <= doc.Paragraphs.Count; i++) {

        let para = doc.Paragraphs(i);

        let firstLineIndent = para.Format.FirstLineIndent;

        let leftIndent = para.Format.LeftIndent;

        let totalIndent = Math.abs(firstLineIndent) + Math.abs(leftIndent);

        

        // 检查段落是否以常见代码关键字开头

        let isCodeLine = false;

        let paraText = para.Range.Text.trim();

        let codeKeywords = ["function", "class", "def", "if", "for", "while", "import", "package"];

        

        for (let keyword of codeKeywords) {

            if (paraText.startsWith(keyword)) {

                isCodeLine = true;

                break;

            }

        }

        

        // 如果段落有足够的缩进或者以代码关键字开头

        if (totalIndent >= indentThreshold || isCodeLine) {

            if (!currentCodeBlock) {

                // 开始一个新的代码块

                currentCodeBlock = {

                    start: para.Range.Start,

                    end: para.Range.End,

                    paragraphCount: 1

                };

            } else {

                // 扩展当前代码块

                currentCodeBlock.end = para.Range.End;

                currentCodeBlock.paragraphCount++;

            }

        } else if (currentCodeBlock) {

            // 如果当前有代码块且当前段落不是代码行，则结束当前代码块

            // 只添加至少包含2个段落的代码块，避免误判

            if (currentCodeBlock.paragraphCount >= 2) {

                codeBlocks.push(currentCodeBlock);

            }

            currentCodeBlock = null;

        }

    }

    

    // 添加最后一个代码块（如果有）

    if (currentCodeBlock && currentCodeBlock.paragraphCount >= 2) {

        codeBlocks.push(currentCodeBlock);

    }

    

    return codeBlocks;

}



// 应用代码块样式

function applyCodeBlockStyle(range, style) {

    // 应用段落格式

    range.ParagraphFormat.Borders.Enable = true;

    range.ParagraphFormat.Borders.OutsideLineStyle = wdLineStyleSingle;

    range.ParagraphFormat.Borders.OutsideLineWidth = style.borderWidth;

    range.ParagraphFormat.Borders.OutsideColor = RGBToColor(style.borderColor);

    

    // 应用字符格式

    range.Font.Name = style.fontFamily;

    range.Font.Size = style.fontSize;

    

    // 应用底纹

    range.Shading.BackgroundPatternColor = RGBToColor(style.backgroundColor);

    

    // 增加段落间距

    range.ParagraphFormat.SpaceBefore = 6;

    range.ParagraphFormat.SpaceAfter = 6;

}



// 辅助函数：将RGB颜色字符串转换为WPS颜色值

function RGBToColor(rgbStr) {

    // 移除可能的#符号

    rgbStr = rgbStr.replace('#', '');

    

    // 解析RGB值

    let r = parseInt(rgbStr.substring(0, 2), 16);

    let g = parseInt(rgbStr.substring(2, 4), 16);

    let b = parseInt(rgbStr.substring(4, 6), 16);

    

    // WPS使用BGR顺序

    return r + (g << 8) + (b << 16);

}



// 辅助函数：转义正则表达式特殊字符

function escapeRegExp(string) {

    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

}

二、基于文本特征的代码段识别方法

如果我是直接将代码文本复制到文档中，没有使用任何特殊标记（如 ``` 或缩进）。这种情况下，我们需要更智能的方式来识别代码段。

我设计了一种基于文本特征的代码段识别方法，通过分析文本的语言特征、结构模式和统计特性来判断是否为代码。这种方法不需要用户添加任何特殊标记，只需要将纯代码文本粘贴到文档中即可。

1.智能代码识别原理

通过使用了以下策略来识别纯文本代码：

（1）特征库匹配：内置了多种编程语言的特征库，包括关键字、操作符和特殊符号

（2）统计分析：分析文本中代码特征的出现频率，超过一定阈值则认为是代码

（3）连续段落检查：要求代码至少连续出现 3 行，避免误判

（4）文本过滤：排除包含 URL、邮箱或大量中文的段落，这些通常不是代码

（5）多语言支持：目前支持通用代码、Python、JavaScript 和 Java，可以根据需要扩展更多语言

2.主要改进思路

（1）增强语言的特征库：以下以JavaScript为例，添加更多JavaScript关键字和操作符，增加对JavaScript注释的特殊处理。

（2）降低识别阈值：将JavaScript的最小特征匹配数从4降低到2，将连续代码行要求从3降低到2。

（3）改进注释处理：专门添加了对//、/*和*/的检查，直接将注释行识别为代码的一部分

（4）优化中文检测：将中文阈值从20%提高到30%，减少误判。

3.代码示例

// 高亮代码块主函数 - 供自定义功能区按钮调用

function highlightCodeBlocks() {

    try {

        // 获取当前文档

        let doc = ThisDocument;

        if (!doc) {

            alert("未找到当前文档!");

            return;

        }

        

        // 定义代码块样式配置

        let codeBlockStyle = {

            borderColor: "#cccccc",

            borderWidth: 1,

            backgroundColor: "#f7f7f9",

            fontFamily: "Consolas, 'Courier New', monospace",

            fontSize: 10.5

        };

        

        // 使用智能代码识别

        let codeBlocks = findCodeBlocksByAI(doc);

        

        // 如果没有找到代码块，提示用户

        if (codeBlocks.length === 0) {

            alert("未在文档中找到可识别的代码块!");

            return;

        }

        

        // 处理每个代码块

        for (let block of codeBlocks) {

            try {

                // 创建Range对象

                let codeRange = doc.Range(block.start, block.end);

                

                // 应用代码块样式

                applyCodeBlockStyle(codeRange, codeBlockStyle);

            } catch (e) {

                console.error(`处理代码块时出错: ${e.message}`);

            }

        }

        

        alert(`成功识别并处理 ${codeBlocks.length} 个代码块!`);

    } catch (e) {

        alert(`执行过程中出错: ${e.message}`);

    }

}



// 智能代码识别方法

function findCodeBlocksByAI(doc) {

    let codeBlocks = [];

    let paragraphs = doc.Paragraphs;

    

    // 代码特征库 - 增强了JavaScript识别能力

    let codePatterns = [

        // JavaScript 特征 - 增强版

        {

            name: "javascript",

            keywords: [

                "function", "class", "let", "const", "var", "if", "else", "for", "while",

                "return", "import", "export", "async", "await", "try", "catch", "finally",

                "switch", "case", "default", "break", "continue", "this", "new", "delete"

            ],

            operators: [

                "==", "===", "!=", "!==", ">=", "<=", "++", "--", "&&", "||", "=>", "=",

                "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "&=", "^=", "|="

            ],

            symbols: [

                "{", "}", "[", "]", "(", ")", ";", ":", ",", "`", "'", "\"", ".", "..", "...",

                "?", "??", "?."

            ],

            comments: ["//", "/*", "*/"], // 专门处理注释

            minOccurrences: 2, // 降低阈值，只需满足2个特征

            minConsecutive: 2 // 只需连续2行

        },

        // 通用代码特征

        {

            name: "general",

            keywords: ["function", "class", "def", "return", "if", "else", "for", "while", "import", "package"],

            operators: ["==", "!=", "=>", "++", "--", "&&", "||", "=>", "->", "::"],

            symbols: ["{", "}", "[", "]", "(", ")", ";", ":", "=", ","],

            minOccurrences: 3,

            minConsecutive: 3

        },

        // Python 特征

        {

            name: "python",

            keywords: ["def", "class", "if", "else", "elif", "for", "while", "in", "range", "return", "import", "from", "as"],

            operators: ["==", "!=", ">=", "<=", "=", "+=", "-=", "*=", "/=", "%=", "//=", "**="],

            symbols: [":", "#", "(", ")", "[", "]", "{", "}", ","],

            indentation: true,

            minOccurrences: 3,

            minConsecutive: 3

        },

        // Java 特征

        {

            name: "java",

            keywords: ["public", "private", "protected", "class", "interface", "void", "static", "if", "else", "for", "while", "return", "import", "package"],

            operators: ["==", "!=", ">=", "<=", "++", "--", "&&", "||", "=", "+=", "-=", "*=", "/=", "%="],

            symbols: ["{", "}", "[", "]", "(", ")", ";", ":", ",", "\"", "'"],

            minOccurrences: 3,

            minConsecutive: 3

        }

    ];

    

    // 分析每个段落，寻找代码块

    let currentBlock = null;

    let consecutiveCodeLines = 0;

    

    for (let i = 1; i <= paragraphs.Count; i++) {

        let para = paragraphs(i);

        let text = para.Range.Text.trim();

        

        // 跳过空段落

        if (text.length === 0) {

            if (currentBlock) {

                consecutiveCodeLines++;

            }

            continue;

        }

        

        // 检查当前段落是否为代码

        let isCode = analyzeParagraph(text, codePatterns);

        

        if (isCode) {

            consecutiveCodeLines++;

            

            if (!currentBlock) {

                // 开始一个新的代码块

                currentBlock = {

                    start: para.Range.Start,

                    end: para.Range.End,

                    paragraphCount: 1

                };

            } else {

                // 扩展当前代码块

                currentBlock.end = para.Range.End;

                currentBlock.paragraphCount++;

            }

        } else {

            // 如果当前有代码块且当前段落不是代码行，则结束当前代码块

            if (currentBlock && consecutiveCodeLines >= codePatterns[0].minConsecutive) {

                codeBlocks.push(currentBlock);

            }

            currentBlock = null;

            consecutiveCodeLines = 0;

        }

    }

    

    // 添加最后一个代码块（如果有）

    if (currentBlock && consecutiveCodeLines >= codePatterns[0].minConsecutive) {

        codeBlocks.push(currentBlock);

    }

    

    return codeBlocks;

}



// 分析段落是否为代码 - 改进版

function analyzeParagraph(text, codePatterns) {

    // 检查是否包含URL、邮箱等非代码文本

    if (text.match(/https?:\/\/\S+|www\.\S+|\S+@\S+\.\S+/)) {

        return false;

    }

    

    // 检查是否包含中文（超过30%的字符是中文可能不是代码）

    let chineseChars = text.match(/[\u4e00-\u9fa5]/g);

    if (chineseChars && chineseChars.length / text.length > 0.3) {

        return false;

    }

    

    // 特殊处理JavaScript注释行

    if (text.startsWith("//") || text.startsWith("/*") || text.endsWith("*/")) {

        return true; // 直接认为注释行是代码的一部分

    }

    

    // 检查是否符合任意一种代码模式

    for (let pattern of codePatterns) {

        let score = 0;

        

        // 检查关键字

        for (let keyword of pattern.keywords) {

            // 确保关键字是独立的，而不是其他单词的一部分

            let regex = new RegExp(`\\b${keyword}\\b`);

            if (regex.test(text)) {

                score++;

            }

        }

        

        // 检查操作符

        for (let operator of pattern.operators) {

            if (text.includes(operator)) {

                score++;

            }

        }

        

        // 检查符号

        for (let symbol of pattern.symbols) {

            if (text.includes(symbol)) {

                score++;

            }

        }

        

        // 检查缩进（仅对Python）

        if (pattern.indentation && (text.startsWith('    ') || text.startsWith('\t'))) {

            score++;

        }

        

        // 如果得分超过阈值，认为是代码

        if (score >= pattern.minOccurrences) {

            return true;

        }

    }

    

    return false;

}



// 应用代码块样式

function applyCodeBlockStyle(range, style) {

    // 应用段落格式

    range.ParagraphFormat.Borders.Enable = true;

    range.ParagraphFormat.Borders.OutsideLineStyle = wdLineStyleSingle;

    range.ParagraphFormat.Borders.OutsideLineWidth = style.borderWidth;

    range.ParagraphFormat.Borders.OutsideColor = RGBToColor(style.borderColor);

    

    // 应用字符格式

    range.Font.Name = style.fontFamily;

    range.Font.Size = style.fontSize;

    

    // 应用底纹

    range.Shading.BackgroundPatternColor = RGBToColor(style.backgroundColor);

    

    // 增加段落间距

    range.ParagraphFormat.SpaceBefore = 6;

    range.ParagraphFormat.SpaceAfter = 6;

}



// 辅助函数：将RGB颜色字符串转换为WPS颜色值

function RGBToColor(rgbStr) {

    // 移除可能的#符号

    rgbStr = rgbStr.replace('#', '');

    

    // 解析RGB值

    let r = parseInt(rgbStr.substring(0, 2), 16);

    let g = parseInt(rgbStr.substring(2, 4), 16);

    let b = parseInt(rgbStr.substring(4, 6), 16);

    

    // WPS使用BGR顺序

    return r + (g << 8) + (b << 16);

}



// 辅助函数：转义正则表达式特殊字符

function escapeRegExp(string) {

    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

}

4.使用方法

（1）将代码添加到WPS JS宏编辑器

（2）在自定义功能区中添加对highlightCodeBlocks函数的调用

（3）将纯代码文本复制粘贴到文档中

（4）点击自定义功能区中的按钮执行宏

这个版本应该能够识别没有任何标记的纯代码文本，并为其添加边框和背景色，使其在文档中明显区分出来。如果识别效果不理想，你可以调整findCodeBlocksByAI函数中的参数，如增加语言特征库或调整阈值。

三、基于“密度”和“结构”的识别方法

如果现有的识别算法还不够灵活，无法准确识别你的代码。我再提供一个更简单直接的版本，这个版本会尝试通过代码的“密度”和“结构”来识别，而不是依赖特定的关键字。

1.新的代码识别方法

（1）计算每行的符号密度（如括号、分号等）

（2）检查是否有一致的缩进模式

（3）寻找代码特有的结构模式（如函数定义、循环等）

2.这个版本的改进

（1）基于符号密度的识别：计算每行中代码特有的符号数量，超过阈值即认为是代码。

（2）结构模式匹配：使用正则表达式识别常见的代码结构（函数定义、循环等）。

（3）宽松的条件：连续2行代码即可识别为代码块，允许代码块中包含少量空行，降低了对特定关键字的依赖。

（4）更好的注释处理：直接将注释行识别为代码的一部分。

3.代码示例

// 高亮代码块主函数 - 供自定义功能区按钮调用

function highlightCodeBlocks() {

    try {

        // 获取当前文档

        let doc = ThisDocument;

        if (!doc) {

            alert("未找到当前文档!");

            return;

        }

        

        // 定义代码块样式配置

        let codeBlockStyle = {

            borderColor: "#cccccc",

            borderWidth: 1,

            backgroundColor: "#f7f7f9",

            fontFamily: "Consolas, 'Courier New', monospace",

            fontSize: 10.5

        };

        

        // 使用基于结构和密度的代码识别

        let codeBlocks = findCodeBlocksByStructure(doc);

        

        // 如果没有找到代码块，提示用户

        if (codeBlocks.length === 0) {

            alert("未在文档中找到可识别的代码块!");

            return;

        }

        

        // 处理每个代码块

        for (let block of codeBlocks) {

            try {

                // 创建Range对象

                let codeRange = doc.Range(block.start, block.end);

                

                // 应用代码块样式

                applyCodeBlockStyle(codeRange, codeBlockStyle);

            } catch (e) {

                console.error(`处理代码块时出错: ${e.message}`);

            }

        }

        

        alert(`成功识别并处理 ${codeBlocks.length} 个代码块!`);

    } catch (e) {

        alert(`执行过程中出错: ${e.message}`);

    }

}



// 基于结构和密度的代码识别方法

function findCodeBlocksByStructure(doc) {

    let codeBlocks = [];

    let paragraphs = doc.Paragraphs;

    

    // 代码特征符号

    let codeSymbols = ["{", "}", "[", "]", "(", ")", ";", ":", "=", "+", "-", "*", "/", "%", "&", "|", "^", "!", "~", "<", ">", ","];

    

    // 代码结构模式

    let codePatterns = [

        /^\s*function\s/,

        /^\s*class\s/,

        /^\s*(let|const|var)\s/,

        /^\s*if\s*\(/,

        /^\s*for\s*\(/,

        /^\s*while\s*\(/,

        /^\s*switch\s*\(/,

        /^\s*return\s/,

        /^\s*def\s/,

        /^\s*class\s/,

        /^\s*import\s/,

        /^\s*from\s/,

        /^\s*public\s/,

        /^\s*private\s/,

        /^\s*protected\s/

    ];

    

    // 分析每个段落，寻找代码块

    let currentBlock = null;

    let consecutiveCodeLines = 0;

    

    for (let i = 1; i <= paragraphs.Count; i++) {

        let para = paragraphs(i);

        let text = para.Range.Text.trim();

        

        // 跳过空段落

        if (text.length === 0) {

            if (currentBlock) {

                consecutiveCodeLines++;

                // 空行允许，但连续空行过多则结束代码块

                if (consecutiveCodeLines > 3) {

                    if (currentBlock.paragraphCount >= 2) {

                        codeBlocks.push(currentBlock);

                    }

                    currentBlock = null;

                    consecutiveCodeLines = 0;

                }

            }

            continue;

        }

        

        // 检查当前段落是否为代码

        let isCode = analyzeLineAsCode(text, codeSymbols, codePatterns);

        

        if (isCode) {

            consecutiveCodeLines++;

            

            if (!currentBlock) {

                // 开始一个新的代码块

                currentBlock = {

                    start: para.Range.Start,

                    end: para.Range.End,

                    paragraphCount: 1

                };

            } else {

                // 扩展当前代码块

                currentBlock.end = para.Range.End;

                currentBlock.paragraphCount++;

            }

        } else {

            // 如果当前有代码块且当前段落不是代码行，则结束当前代码块

            if (currentBlock && currentBlock.paragraphCount >= 2) {

                codeBlocks.push(currentBlock);

            }

            currentBlock = null;

            consecutiveCodeLines = 0;

        }

    }

    

    // 添加最后一个代码块（如果有）

    if (currentBlock && currentBlock.paragraphCount >= 2) {

        codeBlocks.push(currentBlock);

    }

    

    return codeBlocks;

}



// 分析行是否为代码

function analyzeLineAsCode(text, codeSymbols, codePatterns) {

    // 检查是否包含URL、邮箱等非代码文本

    if (text.match(/https?:\/\/\S+|www\.\S+|\S+@\S+\.\S+/)) {

        return false;

    }

    

    // 检查是否包含大量中文（超过30%的字符是中文可能不是代码）

    let chineseChars = text.match(/[\u4e00-\u9fa5]/g);

    if (chineseChars && chineseChars.length / text.length > 0.3) {

        return false;

    }

    

    // 检查是否是注释行

    if (text.startsWith("//") || text.startsWith("/*") || text.startsWith("#") || text.endsWith("*/")) {

        return true;

    }

    

    // 检查符号密度 - 代码通常有较高的符号密度

    let symbolCount = 0;

    for (let symbol of codeSymbols) {

        symbolCount += (text.split(symbol).length - 1);

    }

    

    // 如果符号数量超过阈值，认为是代码

    if (symbolCount >= 3) {

        return true;

    }

    

    // 检查是否匹配任何代码结构模式

    for (let pattern of codePatterns) {

        if (pattern.test(text)) {

            return true;

        }

    }

    

    // 检查是否有一致的缩进（代码通常有一致的缩进模式）

    if (text.startsWith('    ') || text.startsWith('\t')) {

        return true;

    }

    

    return false;

}



// 应用代码块样式

function applyCodeBlockStyle(range, style) {

    // 应用段落格式

    range.ParagraphFormat.Borders.Enable = true;

    range.ParagraphFormat.Borders.OutsideLineStyle = wdLineStyleSingle;

    range.ParagraphFormat.Borders.OutsideLineWidth = style.borderWidth;

    range.ParagraphFormat.Borders.OutsideColor = RGBToColor(style.borderColor);

    

    // 应用字符格式

    range.Font.Name = style.fontFamily;

    range.Font.Size = style.fontSize;

    

    // 应用底纹

    range.Shading.BackgroundPatternColor = RGBToColor(style.backgroundColor);

    

    // 增加段落间距

    range.ParagraphFormat.SpaceBefore = 6;

    range.ParagraphFormat.SpaceAfter = 6;

}



// 辅助函数：将RGB颜色字符串转换为WPS颜色值

function RGBToColor(rgbStr) {

    // 移除可能的#符号

    rgbStr = rgbStr.replace('#', '');

    

    // 解析RGB值

    let r = parseInt(rgbStr.substring(0, 2), 16);

    let g = parseInt(rgbStr.substring(2, 4), 16);

    let b = parseInt(rgbStr.substring(4, 6), 16);

    

    // WPS使用BGR顺序

    return r + (g << 8) + (b << 16);

}



// 辅助函数：转义正则表达式特殊字符

function escapeRegExp(string) {

    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

}

四、基于字符统计和行模式的代码识别

到了这里，看起来我们需要更激进的代码识别策略。我将尝试一种基于字符分布和行模式的方法，这种方法不依赖于特定的语言关键字，而是分析文本的整体特征。

1.这个版本的特点

（1）不依赖特定语言：通过分析字符分布和行模式来识别代码，适用于各种编程语言

（2）统计特征分析：计算代码特有的符号密度，分析行首缩进模式，检查行长度分布，检测代码结构特征。

（3）宽松的识别条件：只要满足符号密度、缩进、长度和结构的综合条件即可识别，对注释行有特殊处理，允许代码块中有少量空行。

（4）中文文本过滤：通过限制中文字符比例来减少误判。

2.代码示例

以下是一个完全重写的代码块识别算法，它通过分析文本的字符分布、行长度变化和结构模式来识别代码：

// 高亮代码块主函数 - 供自定义功能区按钮调用

function highlightCodeBlocks() {

    try {

        // 获取当前文档

        let doc = ThisDocument;

        if (!doc) {

            alert("未找到当前文档!");

            return;

        }

        

        // 定义代码块样式配置

        let codeBlockStyle = {

            borderColor: "#cccccc",

            borderWidth: 1,

            backgroundColor: "#f7f7f9",

            fontFamily: "Consolas, 'Courier New', monospace",

            fontSize: 10.5

        };

        

        // 使用基于统计特征的代码识别

        let codeBlocks = findCodeBlocksByStats(doc);

        

        // 如果没有找到代码块，提示用户

        if (codeBlocks.length === 0) {

            alert("未在文档中找到可识别的代码块!");

            return;

        }

        

        // 处理每个代码块

        for (let block of codeBlocks) {

            try {

                // 创建Range对象

                let codeRange = doc.Range(block.start, block.end);

                

                // 应用代码块样式

                applyCodeBlockStyle(codeRange, codeBlockStyle);

            } catch (e) {

                console.error(`处理代码块时出错: ${e.message}`);

            }

        }

        

        alert(`成功识别并处理 ${codeBlocks.length} 个代码块!`);

    } catch (e) {

        alert(`执行过程中出错: ${e.message}`);

    }

}



// 基于统计特征的代码识别方法

function findCodeBlocksByStats(doc) {

    let codeBlocks = [];

    let paragraphs = doc.Paragraphs;

    

    // 代码特征字符

    let codeChars = "{}[]();:.,+-*/%=&|!~<>\"'`";

    

    // 分析每个段落，寻找代码块

    let currentBlock = null;

    let consecutiveCodeLines = 0;

    

    for (let i = 1; i <= paragraphs.Count; i++) {

        let para = paragraphs(i);

        let text = para.Range.Text;

        

        // 跳过空段落

        if (text.trim().length === 0) {

            if (currentBlock) {

                // 空行允许，但连续空行过多则结束代码块

                consecutiveCodeLines++;

                if (consecutiveCodeLines > 3) {

                    if (currentBlock.paragraphCount >= 2) {

                        codeBlocks.push(currentBlock);

                    }

                    currentBlock = null;

                    consecutiveCodeLines = 0;

                }

            }

            continue;

        }

        

        // 检查当前段落是否为代码

        let isCode = analyzeLineByStats(text, codeChars);

        

        if (isCode) {

            consecutiveCodeLines++;

            

            if (!currentBlock) {

                // 开始一个新的代码块

                currentBlock = {

                    start: para.Range.Start,

                    end: para.Range.End,

                    paragraphCount: 1

                };

            } else {

                // 扩展当前代码块

                currentBlock.end = para.Range.End;

                currentBlock.paragraphCount++;

            }

        } else {

            // 如果当前有代码块且当前段落不是代码行，则结束当前代码块

            if (currentBlock && currentBlock.paragraphCount >= 2) {

                codeBlocks.push(currentBlock);

            }

            currentBlock = null;

            consecutiveCodeLines = 0;

        }

    }

    

    // 添加最后一个代码块（如果有）

    if (currentBlock && currentBlock.paragraphCount >= 2) {

        codeBlocks.push(currentBlock);

    }

    

    return codeBlocks;

}



// 基于统计特征分析行是否为代码

function analyzeLineByStats(text, codeChars) {

    // 移除行首缩进

    let trimmedText = text.trim();

    

    // 检查是否包含URL、邮箱等非代码文本

    if (trimmedText.match(/https?:\/\/\S+|www\.\S+|\S+@\S+\.\S+/)) {

        return false;

    }

    

    // 检查是否是注释行

    if (trimmedText.startsWith("//") || trimmedText.startsWith("/*") ||

        trimmedText.startsWith("#") || trimmedText.endsWith("*/")) {

        return true;

    }

    

    // 计算代码特征字符的比例

    let codeCharCount = 0;

    for (let i = 0; i < trimmedText.length; i++) {

        if (codeChars.includes(trimmedText[i])) {

            codeCharCount++;

        }

    }

    

    // 代码通常有较高的符号密度

    let codeCharRatio = codeCharCount / trimmedText.length;

    

    // 计算行首缩进量（空格或制表符）

    let indentCount = 0;

    while (indentCount < text.length && (text[indentCount] === ' ' || text[indentCount] === '\t')) {

        indentCount++;

    }

    

    // 代码通常有一致的缩进模式

    let hasIndent = indentCount > 0;

    

    // 代码行通常不会太长也不会太短

    let lineLength = trimmedText.length;

    let isTypicalLength = lineLength > 5 && lineLength < 200;

    

    // 检查是否有代码特有的结构模式

    let hasCodeStructure =

        trimmedText.includes('{') || trimmedText.includes('}') ||

        trimmedText.includes('(') || trimmedText.includes(')') ||

        trimmedText.includes(';') || trimmedText.includes('=') ||

        trimmedText.includes(':') || trimmedText.includes(',');

    

    // 计算中文字符比例

    let chineseChars = text.match(/[\u4e00-\u9fa5]/g);

    let chineseRatio = chineseChars ? chineseChars.length / text.length : 0;

    

    // 综合判断：如果符号密度高、有缩进、长度适中、有代码结构，且中文比例低，则认为是代码

    return (codeCharRatio > 0.1 || hasIndent) &&

           isTypicalLength &&

           hasCodeStructure &&

           chineseRatio < 0.3;

}



// 应用代码块样式

function applyCodeBlockStyle(range, style) {

    // 应用段落格式

    range.ParagraphFormat.Borders.Enable = true;

    range.ParagraphFormat.Borders.OutsideLineStyle = wdLineStyleSingle;

    range.ParagraphFormat.Borders.OutsideLineWidth = style.borderWidth;

    range.ParagraphFormat.Borders.OutsideColor = RGBToColor(style.borderColor);

    

    // 应用字符格式

    range.Font.Name = style.fontFamily;

    range.Font.Size = style.fontSize;

    

    // 应用底纹

    range.Shading.BackgroundPatternColor = RGBToColor(style.backgroundColor);

    

    // 增加段落间距

    range.ParagraphFormat.SpaceBefore = 6;

    range.ParagraphFormat.SpaceAfter = 6;

}



// 辅助函数：将RGB颜色字符串转换为WPS颜色值

function RGBToColor(rgbStr) {

    // 移除可能的#符号

    rgbStr = rgbStr.replace('#', '');

    

    // 解析RGB值

    let r = parseInt(rgbStr.substring(0, 2), 16);

    let g = parseInt(rgbStr.substring(2, 4), 16);

    let b = parseInt(rgbStr.substring(4, 6), 16);

    

    // WPS使用BGR顺序

    return r + (g << 8) + (b << 16);

}



// 辅助函数：转义正则表达式特殊字符

function escapeRegExp(string) {

    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

}



这个版本的特点

（1）不依赖特定语言：通过分析字符分布和行模式来识别代码，适用于各种编程语言。

（2）统计特征分析：计算代码特有的符号密度，分析行首缩进模式，检查行长度分布，检测代码结构特征。

（3）宽松的识别条件：只要满足符号密度、缩进、长度和结构的综合条件即可识别，对注释行有特殊处理，允许代码块中有少量空行。

（4）中文文本过滤：通过限制中文字符比例来减少误判。

// 高亮代码块主函数 - 供自定义功能区按钮调用

function highlightCodeBlocks() {

    try {

        // 获取当前文档

        let doc = ThisDocument;

        if (!doc) {

            alert("未找到当前文档!");

            return;

        }

        

        // 定义代码块样式配置

        let codeBlockStyle = {

            borderColor: "#cccccc",

            borderWidth: 1,

            backgroundColor: "#f7f7f9",

            fontFamily: "Consolas, 'Courier New', monospace",

            fontSize: 10.5

        };

        

        // 使用基于统计特征的代码识别

        let codeBlocks = findCodeBlocksByStats(doc);

        

        // 如果没有找到代码块，提示用户

        if (codeBlocks.length === 0) {

            alert("未在文档中找到可识别的代码块!");

            return;

        }

        

        // 处理每个代码块

        for (let block of codeBlocks) {

            try {

                // 创建Range对象

                let codeRange = doc.Range(block.start, block.end);

                

                // 应用代码块样式

                applyCodeBlockStyle(codeRange, codeBlockStyle);

            } catch (e) {

                console.error(`处理代码块时出错: ${e.message}`);

            }

        }

        

        alert(`成功识别并处理 ${codeBlocks.length} 个代码块!`);

    } catch (e) {

        alert(`执行过程中出错: ${e.message}`);

    }

}



// 基于统计特征的代码识别方法

function findCodeBlocksByStats(doc) {

    let codeBlocks = [];

    let paragraphs = doc.Paragraphs;

    

    // 代码特征字符

    let codeChars = "{}[]();:.,+-*/%=&|!~<>\"'`";

    

    // 分析每个段落，寻找代码块

    let currentBlock = null;

    let consecutiveCodeLines = 0;

    

    for (let i = 1; i <= paragraphs.Count; i++) {

        let para = paragraphs(i);

        let text = para.Range.Text;

        

        // 跳过空段落

        if (text.trim().length === 0) {

            if (currentBlock) {

                // 空行允许，但连续空行过多则结束代码块

                consecutiveCodeLines++;

                if (consecutiveCodeLines > 3) {

                    if (currentBlock.paragraphCount >= 2) {

                        codeBlocks.push(currentBlock);

                    }

                    currentBlock = null;

                    consecutiveCodeLines = 0;

                }

            }

            continue;

        }

        

        // 检查当前段落是否为代码

        let isCode = analyzeLineByStats(text, codeChars);

        

        if (isCode) {

            consecutiveCodeLines++;

            

            if (!currentBlock) {

                // 开始一个新的代码块

                currentBlock = {

                    start: para.Range.Start,

                    end: para.Range.End,

                    paragraphCount: 1

                };

            } else {

                // 扩展当前代码块

                currentBlock.end = para.Range.End;

                currentBlock.paragraphCount++;

            }

        } else {

            // 如果当前有代码块且当前段落不是代码行，则结束当前代码块

            if (currentBlock && currentBlock.paragraphCount >= 2) {

                codeBlocks.push(currentBlock);

            }

            currentBlock = null;

            consecutiveCodeLines = 0;

        }

    }

    

    // 添加最后一个代码块（如果有）

    if (currentBlock && currentBlock.paragraphCount >= 2) {

        codeBlocks.push(currentBlock);

    }

    

    return codeBlocks;

}



// 基于统计特征分析行是否为代码

function analyzeLineByStats(text, codeChars) {

    // 移除行首缩进

    let trimmedText = text.trim();

    

    // 检查是否包含URL、邮箱等非代码文本

    if (trimmedText.match(/https?:\/\/\S+|www\.\S+|\S+@\S+\.\S+/)) {

        return false;

    }

    

    // 检查是否是注释行

    if (trimmedText.startsWith("//") || trimmedText.startsWith("/*") ||

        trimmedText.startsWith("#") || trimmedText.endsWith("*/")) {

        return true;

    }

    

    // 计算代码特征字符的比例

    let codeCharCount = 0;

    for (let i = 0; i < trimmedText.length; i++) {

        if (codeChars.includes(trimmedText[i])) {

            codeCharCount++;

        }

    }

    

    // 代码通常有较高的符号密度

    let codeCharRatio = codeCharCount / trimmedText.length;

    

    // 计算行首缩进量（空格或制表符）

    let indentCount = 0;

    while (indentCount < text.length && (text[indentCount] === ' ' || text[indentCount] === '\t')) {

        indentCount++;

    }

    

    // 代码通常有一致的缩进模式

    let hasIndent = indentCount > 0;

    

    // 代码行通常不会太长也不会太短

    let lineLength = trimmedText.length;

    let isTypicalLength = lineLength > 5 && lineLength < 200;

    

    // 检查是否有代码特有的结构模式

    let hasCodeStructure =

        trimmedText.includes('{') || trimmedText.includes('}') ||

        trimmedText.includes('(') || trimmedText.includes(')') ||

        trimmedText.includes(';') || trimmedText.includes('=') ||

        trimmedText.includes(':') || trimmedText.includes(',');

    

    // 计算中文字符比例

    let chineseChars = text.match(/[\u4e00-\u9fa5]/g);

    let chineseRatio = chineseChars ? chineseChars.length / text.length : 0;

    

    // 综合判断：如果符号密度高、有缩进、长度适中、有代码结构，且中文比例低，则认为是代码

    return (codeCharRatio > 0.1 || hasIndent) &&

           isTypicalLength &&

           hasCodeStructure &&

           chineseRatio < 0.3;

}



// 应用代码块样式

function applyCodeBlockStyle(range, style) {

    // 应用段落格式

    range.ParagraphFormat.Borders.Enable = true;

    range.ParagraphFormat.Borders.OutsideLineStyle = wdLineStyleSingle;

    range.ParagraphFormat.Borders.OutsideLineWidth = style.borderWidth;

    range.ParagraphFormat.Borders.OutsideColor = RGBToColor(style.borderColor);

    

    // 应用字符格式

    range.Font.Name = style.fontFamily;

    range.Font.Size = style.fontSize;

    

    // 应用底纹

    range.Shading.BackgroundPatternColor = RGBToColor(style.backgroundColor);

    

    // 增加段落间距

    range.ParagraphFormat.SpaceBefore = 6;

    range.ParagraphFormat.SpaceAfter = 6;

}



// 辅助函数：将RGB颜色字符串转换为WPS颜色值

function RGBToColor(rgbStr) {

    // 移除可能的#符号

    rgbStr = rgbStr.replace('#', '');

    

    // 解析RGB值

    let r = parseInt(rgbStr.substring(0, 2), 16);

    let g = parseInt(rgbStr.substring(2, 4), 16);

    let b = parseInt(rgbStr.substring(4, 6), 16);

    

    // WPS使用BGR顺序

    return r + (g << 8) + (b << 16);

}



// 辅助函数：转义正则表达式特殊字符

function escapeRegExp(string) {

    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

}

五、新增JS宏并配置菜单调用

在WPS中配置自定义功能区时：

（1）打开 "选项" > "自定义功能区"

（2）在 "从下列位置选择命令" 下拉菜单中选择 "宏"

（3）选择 "Project.Module5.highlightCodeBlocks"

（4）将其添加到你自定义的功能区中

（5）为按钮设置图标和名称

这样配置后，点击自定义功能区中的按钮就能直接调用highlightCodeBlocks()函数，实现代码块高亮功能。

梳理：WPS JS宏之WPS表格单元格读写值
学点笔记
05-28 9257
文章目录单元格写入数据读取单元格的值 出租屋的床太硬，我躺不平，所以我只能希望码字看看自己能不能卷一卷……老板的蛋糕做不大了，我们只能继续拼抢插着蜡烛的那一块……我发现我抢不过他们，只好自己尝试自己做蛋糕。准备着手时，我才发现自己没有打蛋器、没有裱花器、没有模具、没有转台、没有烤箱；而大厨却一再表示，没有这些东西我依旧能做出蛋糕……最后的最后：我可以不吃蛋糕的，我不一定要吃蛋糕的，啪，点枝烟继续码字…… 单元格对象集合：Ranges，单元格对象：Range; 更多信息参考：WPS客户端开
wps js宏表格也智能起来
hsl2487718的博客
04-18 904
以下的代码比较容易理解，这里不再多说，作为一业余爱好者，没有太高代码写作水平，给大家提供了一个思路的参考。已有一段身份证校验自定义函数。这段函数是根据网上提供的身份证校验代码进行修改的JS宏代码函数。上面的函数调用了这段代码。这段代码使用了indexof()方法，匹配字符实现了列的动态查找，让代码也智能了起来。4、使用for...of循环，查代身份证号码，出生日期，年龄，性别等识别信息所在列。3、定义日期所在列，年龄所在列，性别所在列。2、定义年龄计算截止日期，由用户输入。5、定义身份证所在列的数组。
WPS宏编程-JS宏常用基础操作
qq_61913010的博客
11-02 7531
WPS的JS宏基本用法
WPS JS宏使用Range单元格数据拆分
u013251491的博客
10-02 466
使用Range读取数据，在E列做为判断依据。分发数据，对中文和英文分开。
WPS的JS宏基础（二）——数据类型
一位VBA和JSA、书法爱好者
11-10 2237
数值分为整数和小浮点数（小数），但返回的都是number类型。下面介绍一下关于处理数值的一些常用方法。
操作单元格_学习wps js宏
tpmr000888的博客
08-28 1770
Range（"A1"）或者cells（1,1），行在前，列在后。vba中，单元格的值用value属性。1.单元格在Excel中是以二维存在，比如A1就是第一行第一列。值用value2表示。vba操作excel相对熟悉，这次学习一下js宏。第一个要学会操作单元格。//以下程序用于，操作单元格的值。
WPS JS宏编程教程（从基础到进阶）-- 第八部分：字符串技术与WPS结合应用
最新发布
石头的博客
04-15 1183
字符串技术与WPS结合应用
office 脚本与wpsJS宏代码的差别初体验
hsl2487718的博客
04-18 1647
TS代码是JS的超集，是JS的一个库，懂得使用JS代码，基本上能够使用JS代码。我并没有学过TS。虽然这样还是花了不少力气修改了一段代码。除了语言上的差异，API接口的方式也有很大的差别。
实现图片放大镜效果的JavaScript代码教程
2. **代码**：指的是具体的JavaScript代码实现，代码段可以是完整的函数、类、方法等，是实现特效的具体指令集合。 3. **放大镜特效**：这是一种网页特效，通过特定的编程技术实现，能够增强用户界面的交互性和视觉...
【WPS-Excel与JavaScript宏的进阶技巧】：打造动态交互式报表，让你的报告更生动
![WPS-Excel 办公 + JS 宏编程教程基础到进阶 + 函数使用手册]... WPS-Excel与JavaScript宏的基本概念 ## 1.1 WPS-Excel宏的定义与作用 宏是WP
wps js宏获取工作簿、工作表、单元格的值、链接转图片、单元格区域数据转二维数组、保存工作簿的常用Excel操作
热门推荐
huaermeier的博客
02-05 3万+
wps js宏入门看这里，我写了常用的js操作Excel的方法：获取工作簿对象、获取工作表对象、获取单元格的值、链接转图片、生成条形码图片、单元格区域数据转二维数组方法、保存工作簿、弹出输入框、YesNo选择框，助你从VBA转战JS。
WPS的JS宏操作方法
陈十七的博客
07-06 1万+
【代码】WPS的JS宏操作方法。
获取Range 列名 和 行号
m0_60646395的博客
11-16 1016
获取 Range 的列名 和 行号
wps js宏编辑器案例3-工作簿和工作表操作
chuangxin的专栏
05-22 3987
本文通过一个连锁门店每天营业额按门店名称进行拆分的案例，讲述wps js宏编辑器中工作簿、工作表和Range的相关操作，比如：工作表的复制，工作簿另存&关闭，Range.findNext使用注意实现等，案例已上传到gitee，文章最后有案例下载地址。
WPS JS宏教程文档，0基础入门，超详细~
MrFlySand的博客
12-15 3万+
0基础入门，输入输出、if判断、循环、数组、单元格操作、表格操作、文档操作，关注了解最新教程~
WPS JS宏编程是什么
u014175525的博客
03-28 5828
WPS JS宏编程是一种基于JavaScript语言的自动化办公技术，可以通过编写脚本来自动化执行一些重复性的任务。WPS JS宏编程是一种基于JavaScript语言的自动化办公技术，可以通过编写脚本来自动化执行一些重复性的任务，例如格式化文本、生成报表、处理数据等。WPS JS宏编程可以帮助我们提高办公效率，节省时间和精力，尤其是对于一些大量重复性的任务，例如格式化文本、生成报表、处理数据等。WPS JS宏编程提供了一些常用的API，可以方便地操作WPS Office应用程序的对象和属性。
WPS的简单JS宏应用
长空孤月
01-24 1万+
WPS的简单JS宏应用
探索: wps js API 之 Range.Offset 如何安全“漂移”
学点笔记
06-01 1113
文章目录Range.Offset 属性参数挑毛病小结"极限"挑战小结区域偏移单列偏移单行偏移单行列偏移小结注意：进阶可套用“算法”规避报错"正向"偏移"反向"偏移自定义限制偏移次数（偏移量） 偏移，漂移是一种驾驶技巧，又称“甩尾”（甩尾一般指FF，而漂移一般指FR和4WD），车手以过度转向的方式令车子侧滑行走……我没有车；今天是“六一”，我连女朋友都没有……CSDN还要求我必须每周至少码足 length >= 5000 的文章……随着最后一缕烟的升腾飘散，烟灭了，我该继续了…… 要开始了，请你先自
WPS JS宏表格定位实例
hsl2487718的博客
01-25 2533
for (var Rng of Sheets("合并处理").Range(Cells(2,2),Cells(82,2))){for (var Rng1 of arr=Sheets("合并处理").Range("e2:e20"))3、 由于填写其他表格的需要，所以对任教年级与课程内容也进行了合并！本实例的定位要实现将功课表的各教师任教情况定位到表中，实现上有一定的难度。给你这样的功课表，将各位老师的功课定位到任课情况中去。2、对合并的行数组，进行每个单元格合并。工具软件：WPS JS宏编辑器。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

搏博

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值