Conversión por lotes de Word a Markdown: guiones para la conversión masiva de documentos

La conversión de un único documento Word a Markdown toma segundos con 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 Conversión a granel de Word a Markdown.

Cuando se necesita una conversión por lotes

Si usted tiene:

• Una biblioteca de documentación heredada en formato Word
• Informes semanales que deben convertirse en páginas Markdown
• Un proyecto de migración de contenido (Word → sitio estático, wiki o base de conocimiento)
• Múltiples autores que envían Word documentos que publican a Markdown

Necesitas una conversión por lotes. En el caso de los archivos individuales, WordToMD sigue siendo la opción más fácil.

Pandoc: La columna vertebral de la conversión por lotes

Pandoc es la mejor herramienta para la conversión por lotes. Instala una vez, luego escribe para cualquier volumen de archivos.

Escrito de PowerShell de Windows

# 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."

Lo ejecuté:

.\convert-all.ps1

Escrito de 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."

Lo ejecuté:

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

Escrito Python para casos de uso avanzados

Python s y sus derivados python-docx la biblioteca y Pandoc subproceso enfoque da más control:

#!/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()

Lo ejecuté:

python3 batch_convert.py

Añadir contenido automáticamente

Los generadores de sitios estáticos necesitan material frontal. El script de Python de arriba agrega el frente básico. Para un enfoque más completo, extrae el título del documento del primer título 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"

Entonces actualiza el add_frontmatter Llamada para utilizar el título extraído.

Preservación de la estructura del directorio

Al convertir una estructura de carpetas anidadas, mantenga la jerarquía:

# 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

Manejo de imágenes en conversión por lotes

En el caso de: --extract-media, Pandoc extrae todas las imágenes a una carpeta. El desafío: múltiples archivos .docx pueden producir archivos con nombres idénticos (e.g., image1.png) en el sector de las telecomunicaciones. Utilizar un subdirectorio por documento:

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

Desempeño para grandes conjuntos

Para conjuntos de documentos de gran tamaño (más de 100 archivos):

• Pandoc procesa un archivo por invocación esto está bien para hasta ~ 100 archivos
• Para más de 500 archivos, utilice GNU Parallel para el procesamiento simultáneo:

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

Instalación de GNU paralelo: brew install parallel / sudo apt install parallel

Validación de la calidad de los resultados

Después de la conversión por lotes, compruebe su salida:

1. Muestra aleatoria Abrir 5-10 archivos convertidos y comparar con los originales
2. Cuenta de las tablas Cuente las tablas en un documento y compruebe que todas se han convertido
3. Niveles de las rutas Asegurar la preservación de la jerarquía de los títulos
4. Enlaces rotos Buscar enlaces Markdown y comprobar que se resuelven

Un sencillo guión de comprobación:

# 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

¿Puedo convertir por lotes los archivos .doc (antiguo formato Word)? Guárdalas como .docx primero. La función de macro Words puede guardar por lotes: Herramientas → Macros → ejecutar una macro SaveAs en todos los archivos abiertos. LibreOffice también puede convertir por lotes a través de la línea de comandos: soffice --headless --convert-to docx *.doc.

¿Cuánto tiempo toma la conversión por lotes? Pandoc convierte un documento típico de 10 páginas en menos de un segundo. 100 archivos = aproximadamente 1-2 minutos. Los documentos muy grandes (más de 100 páginas) toman más tiempo.

Estoy recibiendo pandoc: comando no encontrado en mi script. Asegúrese de que Pandoc está instalado y en su PATH. ¡ Corremos ! which pandoc (macOS/Linux) o también Get-Command pandoc (PowerShell) para comprobar.

¿Puedo ejecutar la conversión por lotes en Windows sin PowerShell? Sí utilizar una .bat archivo o instalar Git Bash para ejecutar los scripts bash.

Guías relacionadas

• Pandoc, mensaje para Markdown. Referencia Pandoc completa
• Word al generador de sitio estático Publicación de contenido convertido
• Palabra para GitBook Migración a GitBook

Conclusión

Conversión de lote Word a Markdown es sencillo con Pandoc y unas pocas líneas de scripting. Los scripts PowerShell y Bash de arriba manejan la mayoría de los escenarios. Para el frontal personalizado, la preservación de la estructura del directorio o el manejo de imágenes, el script de Python le da el control total. Para las conversiones únicas, WordToMD sigue siendo la opción más rápida.