作者：iamlaosong

日常工作中可能会碰到这样的情况，就是需要批量替换一些文件的内容，如合同、产品说明、ISO认证标准化文档（质量手册、程序文件、管理手册）、项目推广方案等，先做批量替换，再进行修改，可以节省大量时间。

本工具可以实现一键完成批量替换，只需按键前将要替换的内容输入表格当中。工具用VBA实现，主要是针对ISO认证标准化文档做的，即对多个文件做同样的替换。界面如下：

功能简单，实现起来也容易。也就是读取表格内容到数组，选择要替换的文件，然后逐个替换即可。

1、文件夹替换：点击按钮选择一个文件夹，工具对文件夹下所有Word文档进行替换，替换后的文件保留在当前文件夹下新建的new文件夹下，文件名和源文件相同。

2、文件替换：点击按钮后选择一个或多个Word文档，工具对对选中的文档进行替换，替换后的文件保留在当前文件夹下新建的new文件夹下，文件名和源文件相同。

本来想用Excel VBA做的（毕竟这个我比较熟），可是Excel VBA代码写完后，打开Word文档没问题，其他代码执行没问题，就是替换功能那部分代码执行了完不成替换，而同样的代码在Word VBA中却可以实现所需的功能，不知道问题出在哪儿。

核心代码如下：

1、读取表格内容：

    '读取替换内容
    For k = 2 To 100
       tmp = ActiveDocument.Tables(1).Cell(k, 1)
       sFind(k) = Left(tmp, Len(tmp) - 2)
       tmp = ActiveDocument.Tables(1).Cell(k, 2)
       sRepl(k) = Left(tmp, Len(tmp) - 2)
       If sFind(k) = "" Then Exit For
    Next k
    WordNo = k - 1

2、批量替换

    If Dir(sPath & "\new", vbDirectory) = "" Then MkDir sPath & "\new"
    '开始替换
    For kk = 1 To FileNo
        Target = sPath & "\" & myFile(kk)
        Debug.Print Target
        Documents.Open Target
            
        For k = 2 To WordNo
            Selection.Find.ClearFormatting
            Selection.Find.Replacement.ClearFormatting
            With Selection.Find
                .Text = sFind(k)
                .Replacement.Text = sRepl(k)
                .Forward = True
                .Wrap = wdFindContinue
                .Format = False
                .MatchCase = False
                .MatchWholeWord = False
                .MatchByte = True
                .MatchWildcards = False
                .MatchSoundsLike = False
                .MatchAllWordForms = False
                '执行替换
                .Execute Replace:=wdReplaceAll
            End With
        Next k
        ActiveDocument.SaveAs2 FileName:=sPath & "\new\" & myFile(kk)
        'ActiveDocument.Save
        ActiveDocument.Close
    Next kk
    
    MsgBox "共有" & FileNo & "个文件替换完毕！"

感兴趣朋友可以下载试试：Word文档批量替换工具.doc

补记：

后来发现，Excel之所以不行，是因为Excel环境下wdReplaceAll、wdFindContinue都是空值。而这些参数为空值，是因为我们没有引用Word对象，引用一下就不是空值了（如果把wdReplaceAll、wdFindContinue等常量换成其值2、1，不引用也可以），如下图：

Excel下面的关键代码如下：

        '查找并替换
        For k = 1 To Strno
            With docApp.Selection.Find
                .ClearFormatting
                .Text = arrStr(k, 1)
                .Replacement.Text = arrStr(k, 2)
                .Forward = True
                .Wrap = wdFindContinue
                .MatchWildcards = False
            End With
            docApp.Selection.Find.Execute Replace:=wdReplaceAll
        Next k

注意：docApp是Word应用对象，即：Set docApp = CreateObject("Word.Application")

====================================================

补充强调一下：工具可以用于docx类型，如果选择文件夹替换的话，会包括docx文件；如果选择文件替换的话，可以把选择类型改成所有文件（*.*）就行了。文件替换时可以按Ctrl键多选。

WORD文档文字替换
利用关键字下角标位置的方式处理word文档区域文字分割无法匹配的问题

    /**
     * DOCX文档字符串查找
     *
     * @param document 文档
     * @param str      查找字符串
     */
    public static boolean findText(XWPFDocument document, String str) {
        boolean flag;
        try {
            // 段落中的指定文字
            List<XWPFParagraph> XWPFParagraphList = document.getParagraphs();
            flag = findXWPFParagraphText(XWPFParagraphList, str);
            if (flag) {
                return true;
            }
            // 表格中的指定文字
            List<XWPFTable> XWPFTableList = document.getTables();
            for (XWPFTable xwpfTable : XWPFTableList) {
                List<XWPFTableRow> rows = xwpfTable.getRows();
                for (XWPFTableRow row : rows) {
                    for (XWPFTableCell cell : row.getTableCells()) {
                        List<XWPFParagraph> cellParagraphs = cell.getParagraphs();
                        flag = findXWPFParagraphText(cellParagraphs, str);
                        if (flag) {
                            return true;
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error("操作WORD文件失败！", e);
            throw new BusinessException("操作WORD文件失败！");
        }
        return false;
    }

    /**
     * 查询word段落文字查找
     *
     * @param XWPFParagraphList
     * @param str
     * @return
     */
    public static boolean findXWPFParagraphText(List<XWPFParagraph> XWPFParagraphList, String str) {
        for (XWPFParagraph paragraph : XWPFParagraphList) {
            if (StringUtils.isBlank(paragraph.getText())) continue;
            if (paragraph.getText().contains(str)) {
                List<Map<String, Integer>> list = findAllSubRunPosInParagraph(paragraph, str);
                if (CollectionUtils.isNotEmpty(list)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * DOCX文档字符串查找
     *
     * @param document 文档
     */
    public static String getText(Object document) {
        StringBuilder result = new StringBuilder();
        if (null == document){
            return result.toString();
        }
        if (HWPFDocument.class.getName().equals(document.getClass().getName())){
            HWPFDocument hwpfDocument=(HWPFDocument)document;
            Range range = hwpfDocument.getRange();
            return range.text();
        }
        if (XWPFDocument.class.getName().equals(document.getClass().getName())){
            XWPFDocument xwpfDocument=(XWPFDocument)document;
            List<XWPFParagraph> XWPFParagraphList = xwpfDocument.getParagraphs();
            if (CollectionUtils.isNotEmpty(XWPFParagraphList)){
                for (XWPFParagraph paragraph : XWPFParagraphList) {
                    if (StringUtils.isBlank(paragraph.getText())) continue;
                    result.append(paragraph.getText());
                }
            }
            return result.toString();
        }
        return result.toString();
    }

    /**
     * DOCX文档字符串替换
     *
     * @param document
     * @param map
     */
    public static void replaceMap(XWPFDocument document, Map<String, String> map) {
        try {
            //对段落中的标记进行替换
            List<XWPFParagraph> parasList = document.getParagraphs();
            replaceInAllParagraphs(parasList, map);

            //对表格中的标记进行替换
            List<XWPFTable> tables = document.getTables();
            replaceInTables(tables, map);
        } catch (Exception e) {
            logger.error("操作WORD文件失败！", e);
            throw new BusinessException("操作WORD文件失败！");
        }
    }

    /**
     * 多个文档替换
     *
     * @param document
     * @param documentMap
     */
    public static void replaceDocument(XWPFDocument document, Map<String, XWPFDocument> documentMap) {
        Map<String, XWPFParagraph> paragraphMap = new HashMap<>();
        for (Entry<String, XWPFDocument> entry : documentMap.entrySet()) {
            if (null == entry.getValue()) {
                continue;
            }
            String str;
            List<XWPFParagraph> paragraphs = document.getParagraphs();
            for (XWPFParagraph paragraph : paragraphs) {
                str = paragraph.getText();
                if (StringUtils.isNotBlank(str) && str.contains(entry.getKey())) {
                    paragraphMap.put(entry.getKey(), paragraph);
                }
            }
            replaceInAllParagraphs(paragraphs, entry.getKey(), "");
        }
        for (Entry<String, XWPFParagraph> paragraphEntry : paragraphMap.entrySet()) {
            for (Entry<String, XWPFDocument> entry : documentMap.entrySet()) {
                if (paragraphEntry.getKey().equals(entry.getKey())) {
                    XWPFParagraph xwpfParagraph = paragraphEntry.getValue();
                    XWPFDocument xwpfDocument = entry.getValue();
                    // ctp = xwpfParagraph.getCTP();
                    // src2Body = xwpfDocument.getDocument().getBody();
                    // WordUtil.appendBody(ctp, src2Body);
                    try {
                        WordUtil.appendBody(xwpfParagraph, xwpfDocument);
                    } catch (Exception e) {
                        logger.error("word文档合并失败", e);
                    }
                }
            }
        }
    }

    /**
     * 替换所有段落中的标记
     *
     * @param XWPFParagraphList
     * @param oldString
     * @param newString
     */
    public static void replaceInAllParagraphs(List<XWPFParagraph> XWPFParagraphList, String oldString, String newString) {
        for (XWPFParagraph paragraph : XWPFParagraphList) {
            if (StringUtils.isBlank(paragraph.getText())) continue;
            if (paragraph.getText().contains(oldString)) {
                replaceInParagraph(paragraph, oldString, newString);
            }
        }
    }

    /**
     * 替换所有段落中的标记
     *
     * @param XWPFParagraphList
     * @param params
     */
    public static void replaceInAllParagraphs(List<XWPFParagraph> XWPFParagraphList, Map<String, String> params) {
        for (XWPFParagraph paragraph : XWPFParagraphList) {
            if (StringUtils.isBlank(paragraph.getText())) continue;
            for (String key : params.keySet()) {
                if (paragraph.getText().contains(key)) {
                    replaceInParagraph(paragraph, key, params.get(key));
                }
            }
        }
    }

    /**
     * 替换段落中的字符串
     *
     * @param xwpfParagraph
     * @param oldString
     * @param newString
     */
    public static void replaceInParagraph(XWPFParagraph xwpfParagraph, String oldString, String newString) {
        List<Map<String, Integer>> list = findAllSubRunPosInParagraph(xwpfParagraph, oldString);
        if (CollectionUtils.isEmpty(list)) return;
        for (Map<String, Integer> pos_map : list) {
            logger.info("替换字符串：{}，开始下标：{}，结束下标：{}", oldString, pos_map.get("start_pos"), pos_map.get("end_pos"));
            List<XWPFRun> runs = xwpfParagraph.getRuns();
            // 保留开始区域的样式，替换字体，将其余区域移除
            XWPFRun modelRun = runs.get(pos_map.get("start_pos"));
            modelRun.setText(newString, 0);
            for (int i = pos_map.get("end_pos"); i > pos_map.get("start_pos"); i--) {
                logger.info("替换字符串：{}，移除下标：{}", oldString, i);
                xwpfParagraph.removeRun(i);
            }
        }
    }

    /**
     * 找到段落中所有子串的起始XWPFRun下标和终止XWPFRun的下标
     *
     * @param xwpfParagraph
     * @param substring
     * @return
     */
    public static List<Map<String, Integer>> findAllSubRunPosInParagraph(XWPFParagraph xwpfParagraph, String substring) {
        List<Map<String, Integer>> posList = new ArrayList<>();
        Map<String, Integer> map;
        int start_pos;
        int end_pos;
        StringBuilder subTemp;
        List<XWPFRun> runs = xwpfParagraph.getRuns();
        for (int i = 0; i < runs.size(); i++) {
            subTemp = new StringBuilder();
            start_pos = i;
            for (int j = i; j < runs.size(); j++) {
                if (StringUtils.isBlank(runs.get(j).getText(runs.get(j).getTextPosition()))) {
                    break;
                }
                subTemp.append(runs.get(j).getText(runs.get(j).getTextPosition()));
                if (subTemp.toString().trim().equals(substring)) {
                    end_pos = j;
                    map = new HashMap<>();
                    map.put("start_pos", start_pos);
                    map.put("end_pos", end_pos);
                    posList.add(map);
                    break;
                }
            }
        }
        return posList;
    }

    /**
     * 替换所有的表格
     *
     * @param XWPFTableList
     * @param params
     */
    public static void replaceInTables(List<XWPFTable> XWPFTableList, Map<String, String> params) {
        for (XWPFTable table : XWPFTableList) {
            replaceInTable(table, params);
        }
    }

    /**
     * 替换一个表格中的所有行
     *
     * @param xwpfTable
     * @param params
     */
    public static void replaceInTable(XWPFTable xwpfTable, Map<String, String> params) {
        List<XWPFTableRow> rows = xwpfTable.getRows();
        replaceInRows(rows, params);
    }


    /**
     * 替换表格中的一行
     *
     * @param rows
     * @param params
     */
    public static void replaceInRows(List<XWPFTableRow> rows, Map<String, String> params) {
        for (XWPFTableRow row : rows) {
            replaceInCells(row.getTableCells(), params);
        }
    }

    /**
     * 替换一行中所有的单元格
     *
     * @param XWPFTableCellList
     * @param params
     */
    public static void replaceInCells(List<XWPFTableCell> XWPFTableCellList, Map<String, String> params) {
        for (XWPFTableCell cell : XWPFTableCellList) {
            replaceInCell(cell, params);
        }
    }

    /**
     * 替换表格中每一行中的每一个单元格中的所有段落
     *
     * @param cell
     * @param params
     */
    public static void replaceInCell(XWPFTableCell cell, Map<String, String> params) {
        List<XWPFParagraph> cellParagraphs = cell.getParagraphs();
        replaceInAllParagraphs(cellParagraphs, params);
    }

人生苦短，我用python。

工具

这里我们使用python-docx库, 关于这个库的使用可以参考官方文档

使用

• 第一种：如果不在乎原有文章的格式，比如把word文档里的需要替换的字符串替换成我是替换后的字符串可以使用以下代码

    doc = docx.Document('test.docx')
    for paragraph in doc.paragraphs:
        if '需要替换的字符串' in p.text:
            p.text = p.text.replace('需要替换的字符串', '我是替换后的字符串')
    doc.save('result_test.docx')
  

  这种替换方式有个问题就是，不能保持原有的格式， 比如需要替换的字符串是带下划线并、加粗、黑体，替换之后这些格式都不存在了，但这也是最简单部分的替换方式。
• 第二种: 既然第一种有问题，那么我们想要保持原有的文档格式，怎么办？我们只能更改里面的文字块，再python-docx库中文字块叫run，特殊就是这个run并不是我们我们想象的那样是连续的，这里盗了个图，这里感谢这位博主的图。
  

从图中可以看出，run是paragraph的最小单元，所以待会儿取得时候我们只能拿到段落我们才能找到run，再说run得特殊性, 比如需要替换的字符串这几个字可能是多个run, 可能是两个run，分别是’需要替换的’, ‘字符串’。直接上代码：

doc = docx.Document('my_template.docx')
for paragraph in doc.paragraphs:
    tmp = ''
    runs = paragraph.runs
    for i, run in enumerate(runs):
        tmp += run.text # 合并run字符串
        if '需要替换的字符串' in tmp:
            # 如果存在匹配得字符串，那么将当前得run替换成合并后得字符串
            run.text = run.text.replace(run.text, tmp)
            run.text = run.text.replace('需要替换的字符串', '我是替换后的字符串')
            tmp = ''
        else:
            # 如果没匹配到目标字符串则把当前run置空
            run.text = run.text.replace(run.text, '')
        if i == len(runs) - 1:
            # 如果是当前段落一直没有符合规则得字符串直接将当前run替换为tmp
            run.text = run.text.replace(run.text, tmp)

以上就是两种替换方式，可以看需求使用