Conversion par lots Word en Markdown: Scripts pour la conversion en masse de documents

La conversion d'un seul document Word en Markdown prend des secondes avec WordToMD. But what if you have 50, 100, or 500 .docx files to convert? That’s where batch conversion scripts come in. This guide covers the fastest approaches for conversion en vrac de Word en Markdown.

Lorsque vous avez besoin d'une conversion par lots

Si vous avez:

• Une bibliothèque de documentation ancienne au format Word
• Rapports hebdomadaires qui doivent devenir des pages Markdown
• Un projet de migration de contenu (Word → site statique, wiki ou base de connaissances)
• Plusieurs auteurs soumettant des documents Word qui publient à Markdown

Vous avez besoin d'une conversion par lots. Pour les fichiers individuels, WordToMD reste l'option la plus facile.

Pandoc: le noyau de la conversion par lots

Pandoc est le meilleur outil pour la conversion par lots. Installez-le une fois, puis écrivez-le pour n'importe quel volume de fichiers.

Scénario avec Windows PowerShell

# convert-all.ps1
# Converts all .docx files in current directory to .md

$docxFiles = Get-ChildItem -Path "." -Filter "*.docx" -Recurse

foreach ($file in $docxFiles) {
    $outputPath = [System.IO.Path]::ChangeExtension($file.FullName, ".md")
    
    pandoc `
        $file.FullName `
        -t gfm `
        --wrap=none `
        --extract-media="./media" `
        -o $outputPath
    
    Write-Host "✓ $($file.Name) → $([System.IO.Path]::GetFileName($outputPath))"
}

Write-Host "Done. Converted $($docxFiles.Count) files."

Faites-le voir:

.\convert-all.ps1

Écriture Bash (macOS / Linux)

#!/bin/bash
# convert-all.sh
# Converts all .docx files recursively

OUTPUT_DIR="./markdown-output"
mkdir -p "$OUTPUT_DIR"

find . -name "*.docx" | while read -r docx_file; do
    filename=$(basename "$docx_file" .docx)
    output="$OUTPUT_DIR/$filename.md"
    
    pandoc \
        "$docx_file" \
        -t gfm \
        --wrap=none \
        --extract-media="$OUTPUT_DIR/media" \
        -o "$output"
    
    echo "✓ $docx_file → $output"
done

echo "Done."

Faites-le voir:

chmod +x convert-all.sh
./convert-all.sh

Écriture Python pour les cas d'utilisation avancés

Les pythons python-docx bibliothèque et l'approche Pandoc sous-processus donne plus de contrôle:

#!/usr/bin/env python3
"""
batch_convert.py — Convert all .docx files to Markdown with frontmatter injection
"""

import os
import subprocess
import sys
from pathlib import Path
from datetime import datetime

INPUT_DIR = Path("./word-docs")
OUTPUT_DIR = Path("./markdown-output")
OUTPUT_DIR.mkdir(exist_ok=True)

def convert_file(docx_path: Path) -> Path:
    """Convert a .docx file to GFM Markdown using Pandoc."""
    output_path = OUTPUT_DIR / docx_path.with_suffix(".md").name
    
    result = subprocess.run(
        [
            "pandoc",
            str(docx_path),
            "-t", "gfm",
            "--wrap=none",
            f"--extract-media={OUTPUT_DIR}/media",
            "-o", str(output_path)
        ],
        capture_output=True,
        text=True
    )
    
    if result.returncode != 0:
        print(f"  ERROR: {result.stderr}", file=sys.stderr)
        return None
    
    return output_path

def add_frontmatter(md_path: Path, title: str) -> None:
    """Prepend YAML frontmatter to a Markdown file."""
    frontmatter = f"""---
title: "{title}"
date: {datetime.now().strftime('%Y-%m-%d')}
draft: false
---

"""
    content = md_path.read_text(encoding="utf-8")
    md_path.write_text(frontmatter + content, encoding="utf-8")

def main():
    docx_files = list(INPUT_DIR.glob("**/*.docx"))
    
    if not docx_files:
        print(f"No .docx files found in {INPUT_DIR}")
        return
    
    print(f"Converting {len(docx_files)} files...")
    
    success = 0
    for docx_path in docx_files:
        print(f"  Converting: {docx_path.name}")
        
        output_path = convert_file(docx_path)
        if output_path:
            # Use filename (without extension) as title, replace hyphens/underscores
            title = docx_path.stem.replace("-", " ").replace("_", " ").title()
            add_frontmatter(output_path, title)
            print(f"  ✓ → {output_path.name}")
            success += 1
        else:
            print(f"  ✗ Failed: {docx_path.name}")
    
    print(f"\nDone: {success}/{len(docx_files)} files converted.")

if __name__ == "__main__":
    main()

Faites-le voir:

python3 batch_convert.py

Ajout automatique de l'objet

Les générateurs statiques ont besoin de matériel. Le script Python ci-dessus ajoute un élément de base. Pour une approche plus complète, extraire le titre du document du premier titre H1:

def extract_title(md_content: str) -> str:
    """Extract the first H1 heading as the title."""
    for line in md_content.splitlines():
        if line.startswith("# "):
            return line[2:].strip()
    return "Untitled"

Alors mettez à jour le add_frontmatter l'appel à utiliser le titre extrait.

Préservation de la structure du répertoire

Lors de la conversion d'une structure de dossier imbriquée, maintenir la hiérarchie:

# Bash: preserve subdirectory structure
find ./word-docs -name "*.docx" | while read -r docx; do
    # Calculate relative path
    rel_path="${docx#./word-docs/}"
    output_dir="./markdown-output/$(dirname "$rel_path")"
    mkdir -p "$output_dir"
    
    output="$output_dir/$(basename "$docx" .docx).md"
    pandoc "$docx" -t gfm --wrap=none -o "$output"
    echo "✓ $rel_path"
done

Traitement de l'image en conversion par lots

Avec --extract-media, Pandoc extrait toutes les images dans un dossier. Le défi: plusieurs fichiers .docx peuvent produire des fichiers avec des noms identiques (e.g., image1.png) sont également mentionnées. Utilisez un sous-répertoire par document:

for docx_file in *.docx; do
    slug="${docx_file%.docx}"
    mkdir -p "./media/$slug"
    
    pandoc "$docx_file" \
        -t gfm \
        --wrap=none \
        --extract-media="./media/$slug" \
        -o "$slug.md"
done

Performance pour les grands ensembles

Pour les grands ensembles de documents (100+ fichiers):

• Pandoc traite un fichier par invocation c'est bien pour jusqu'à ~100 fichiers
• Pour plus de 500 fichiers, utilisez GNU Parallel pour le traitement simultané:

find . -name "*.docx" | \
parallel pandoc {} -t gfm --wrap=none -o {.}.md

Installez GNU parallèle: brew install parallel / sudo apt install parallel

Validation de la qualité des résultats

Après la conversion par lots, vérifiez votre sortie:

1. Échantillon aléatoire Ouvrez 5 à 10 fichiers convertis et comparez avec les originaux
2. Nombre de tables Comptez les tables dans un document et vérifiez qu'elles sont toutes converties
3. Niveaux de tête Garantir le maintien de la hiérarchie des rubriques
4. Liens cassés Recherchez les liens Markdown et vérifiez qu'ils sont résolus

Un simple script de vérification:

# Count files with no headings (might indicate conversion failure)
for md in ./markdown-output/*.md; do
    if ! grep -q "^#" "$md"; then
        echo "No headings found: $md"
    fi
done

FAQ

Puis-je convertir par lots des fichiers .doc (ancien format Word)? Sauvegardez-les comme .docx tout d'abord. La fonctionnalité de macro Words peut enregistrer par lots: Outils → Macros → exécuter une macro SaveAs sur tous les fichiers ouverts. LibreOffice peut également effectuer des conversions par lots via la ligne de commande: soffice --headless --convert-to docx *.doc.

Combien de temps dure la conversion des lots ? Pandoc convertit un document typique de 10 pages en moins d'une seconde. 100 fichiers = environ 1 à 2 minutes. Les documents très volumineux (plus de 100 pages) prennent plus de temps.

Je reçois pandoc: commande non trouvée dans mon script. Assurez-vous que Pandoc est installé et sur votre PATH. Je cours. which pandoc (macOS/Linux) ou Get-Command pandoc (PowerShell) pour vérifier.

Puis-je exécuter la conversion par lots sur Windows sans PowerShell ? Oui utilisez un .bat Fichier ou installez Git Bash pour exécuter les scripts bash.

Des guides connexes

• Pandoc Word à Markdown référence complète Pandoc
• Word au générateur de site statique Publier du contenu converti
• Word à GitBook Migrant vers le GitBook

Conclusion de l'enquête

Conversion par lots de Word à Markdown est simple avec Pandoc et quelques lignes de script. Les scripts PowerShell et Bash ci-dessus gèrent la plupart des scénarios. Pour le frontmatter personnalisé, la préservation de la structure du répertoire ou le traitement des images, le script Python vous donne un contrôle total. Pour les conversions ponctuelles, WordToMD reste l'option la plus rapide.