Detección de Archivos con Nombres Similares en Distintas Carpetas usando PowerShell

En entornos corporativos o de gestión documental, es frecuente encontrarse con archivos con nombres similares distribuidos en distintas ubicaciones. Esto puede deberse a duplicidades, versiones no controladas o simplemente errores humanos. Para automatizar la detección de estos casos y facilitar su análisis, presentamos un script en PowerShell que compara los nombres de archivos entre subcarpetas distintas y genera un informe CSV con aquellos que tienen una similitud significativa.

# --- Configuración ---
$carpetaRaiz = "C:\Datos\GPOS_limpias"
$umbralSimilitud = 0.8
$reporteCSV = "C:\Datos\reporte_similares.csv"

# --- Función para calcular la similitud entre cadenas (Levenshtein) ---
function Get-LevenshteinSimilarity($s1, $s2) {
    $len1 = $s1.Length
    $len2 = $s2.Length
    $matrix = @()

    # Inicializar matriz bidimensional
    for ($i = 0; $i -le $len1; $i++) {
        $row = New-Object int[] ($len2 + 1)
        $row[0] = $i
        $matrix += ,$row
    }
    for ($j = 0; $j -le $len2; $j++) {
        $matrix[0][$j] = $j
    }

    for ($i = 1; $i -le $len1; $i++) {
        for ($j = 1; $j -le $len2; $j++) {
            $cost = if ($s1[$i - 1] -eq $s2[$j - 1]) { 0 } else { 1 }
            $matrix[$i][$j] = [Math]::Min(
                [Math]::Min($matrix[$i - 1][$j] + 1, $matrix[$i][$j - 1] + 1),
                $matrix[$i - 1][$j - 1] + $cost
            )
        }
    }

    $distance = $matrix[$len1][$len2]
    return 1 - ($distance / [Math]::Max($len1, $len2))
}

# --- Obtener las subcarpetas ---
$subcarpetas = Get-ChildItem -Path $carpetaRaiz -Directory

# --- Recolectar archivos de cada subcarpeta ---
$archivos = @()
foreach ($sub in $subcarpetas) {
    $archivos += Get-ChildItem -Path $sub.FullName -File | ForEach-Object {
        [PSCustomObject]@{
            NombreArchivo = $_.Name
            RutaCompleta = $_.FullName
            Carpeta = $sub.FullName
        }
    }
}

# --- Comparar archivos entre carpetas distintas ---
$resultados = @()

for ($i = 0; $i -lt $archivos.Count; $i++) {
    for ($j = $i + 1; $j -lt $archivos.Count; $j++) {
        $a1 = $archivos[$i]
        $a2 = $archivos[$j]

        if ($a1.Carpeta -ne $a2.Carpeta) {
            $similitud = Get-LevenshteinSimilarity $a1.NombreArchivo $a2.NombreArchivo
            if ($similitud -ge $umbralSimilitud) {
                $resultados += [PSCustomObject]@{
                    Archivo1  = $a1.NombreArchivo
                    Carpeta1  = $a1.Carpeta
                    Archivo2  = $a2.NombreArchivo
                    Carpeta2  = $a2.Carpeta
                    Similitud = "{0:P1}" -f $similitud
                }
            }
        }
    }
}

# --- Exportar reporte ---
if ($resultados.Count -gt 0) {
    $resultados | Export-Csv -Path $reporteCSV -NoTypeInformation -Encoding UTF8
    Write-Host "Reporte generado correctamente en: $reporteCSV"
} else {
    Write-Host "No se encontraron archivos con similitud mayor o igual al $($umbralSimilitud * 100)%"
}

¿Qué hace este script?

Este script recorre todas las subcarpetas dentro de una ruta raíz especificada ($carpetaRaiz), recopila los nombres de archivos y luego los compara entre sí usando el algoritmo de Levenshtein para calcular un índice de similitud. Si dos archivos tienen un nombre similar por encima de un umbral definido (por defecto, el 80%), se registran en un reporte CSV para su revisión.

Configuración inicial

Estas son las variables clave al comienzo del script:

$carpetaRaiz = "C:\Datos"
$umbralSimilitud = 0.8
$reporteCSV = "C:\Datos\reporte_similares.csv"

carpetaRaiz: Directorio principal donde buscar las subcarpetas.
umbralSimilitud: Porcentaje mínimo de similitud (de 0 a 1) para considerar que dos archivos son parecidos.
reporteCSV: Ruta donde se guardará el informe en formato CSV.

Comparación con Levenshtein

El corazón del script es la función Get-LevenshteinSimilarity, que implementa el algoritmo Levenshtein para calcular la distancia entre dos cadenas de texto. Esta distancia se convierte en un valor de similitud entre 0 y 1, donde 1 representa una coincidencia exacta.

Proceso de análisis

Listar subcarpetas del directorio raíz.
Recopilar archivos en cada subcarpeta.
Comparar los nombres de archivos solo entre carpetas distintas, evitando comparaciones dentro de la misma carpeta.
Calcular la similitud y verificar si supera el umbral definido.
Exportar los resultados a un archivo CSV si se encuentran coincidencias.

Resultado del informe

Si se detectan archivos similares, se genera un informe en CSV con las siguientes columnas:

Archivo1: Nombre del primer archivo.
Carpeta1: Ubicación del primer archivo.
Archivo2: Nombre del segundo archivo.
Carpeta2: Ubicación del segundo archivo.
Similitud: Porcentaje de similitud entre ambos nombres.

En caso contrario, se muestra un aviso indicando que no se encontraron coincidencias relevantes.

Ejecución exitosa

Al final de la ejecución, el script muestra un mensaje como:

Reporte generado correctamente en: C:\Datos\reporte_similares.csv

O, si no se detectaron similitudes:

No se encontraron archivos con similitud mayor o igual al 80%

Casos de uso

Detección de posibles duplicados de archivos con nombres similares.
Análisis de consistencia en nomenclatura de documentos.
Apoyo en procesos de limpieza y normalización de estructuras de carpetas.

Requisitos

PowerShell (versión incluida por defecto en sistemas Windows modernos).
Permisos de lectura en las carpetas a analizar.
Conocimientos básicos de scripting si se desea modificar el umbral o añadir más lógica.

Este script es una herramienta sencilla pero poderosa para auditar estructuras de archivos y detectar posibles incoherencias. Se puede adaptar fácilmente para incluir filtros por extensión, fecha o contenido, convirtiéndose en un recurso útil en tareas de gestión documental o soporte técnico.

¿Quieres adaptarlo a una estructura más grande o incluir análisis por contenido? Estaré encantado de ayudarte a extenderlo.