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

- Link: https://binariocero.com/windows/deteccion-de-archivos-con-nombres-similares-en-distintas-carpetas-usando-powershell
- Published: 2025-06-08T15:05:32+02:00
- Author: Juan José Fernández Durán

![Loading](https://binariocero.com/wp-content/plugins/page-views-count/ajax-loader-
2x.gif)

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.

    ```wp-block-code
    # --- 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:

    ```wp-block-preformatted
    $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

 1. **Listar subcarpetas** del directorio raíz.
 2. **Recopilar archivos** en cada subcarpeta.
 3. **Comparar los nombres de archivos** solo entre carpetas distintas, evitando comparaciones
    dentro de la misma carpeta.
 4. **Calcular la similitud** y verificar si supera el umbral definido.
 5. **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:

    ```wp-block-preformatted
    Reporte generado correctamente en: C:\Datos\reporte_similares.csv
    ```

O, si no se detectaron similitudes:

    ```wp-block-preformatted
    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.