# Detección de Archivos con Nombres Similares entre Subcarpetas con PowerShell

- Link: https://binariocero.com/windows/deteccion-de-archivos-con-nombres-similares-entre-subcarpetas-con-powershell
- Published: 2025-06-07T15:00:43+02:00
- Author: Juan José Fernández Durán

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

Cuando se trabaja con grandes volúmenes de archivos organizados en múltiples carpetas,
es común encontrarse con documentos duplicados o versiones similares con nombres
apenas diferentes. Este script de PowerShell está diseñado precisamente para detectar
archivos con nombres parecidos que se encuentren en diferentes subcarpetas de una
carpeta raíz determinada. Su finalidad es facilitar la gestión de archivos y evitar
duplicidades innecesarias.

    ```wp-block-code
    # --- Configuración ---
    $carpetaRaiz = "C:\Datos"
    $umbralSimilitud = 0.6
    $reporteCSV = "C:\Datos\reporte_similares.csv"

    # --- Función rápida de similitud de nombre ---
    function Get-FastNameSimilarity($n1, $n2) {
        $n1 = [System.IO.Path]::GetFileNameWithoutExtension($n1).ToLower().Replace(" ", "")
        $n2 = [System.IO.Path]::GetFileNameWithoutExtension($n2).ToLower().Replace(" ", "")

        if ($n1 -eq $n2) { return 1 }

        $longitudMax = [Math]::Max($n1.Length, $n2.Length)
        if ($longitudMax -eq 0) { return 0 }

        # Similitud basada en cuántos caracteres coinciden al inicio
        $comunes = 0
        for ($i = 0; $i -lt [Math]::Min($n1.Length, $n2.Length); $i++) {
            if ($n1[$i] -eq $n2[$i]) { $comunes++ } else { break }
        }

        return $comunes / $longitudMax
    }

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

    # --- Recolectar archivos ---
    $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) {
                if ($a1.NombreArchivo -eq $a2.NombreArchivo) { continue }

                $similitud = Get-FastNameSimilarity $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 resultados ---
    if ($resultados.Count -gt 0) {
        $resultados | Export-Csv -Path $reporteCSV -NoTypeInformation -Encoding UTF8
        Write-Host "`nReporte generado correctamente en: $reporteCSV"
    } else {
        Write-Host "`nNo se encontraron archivos similares según el criterio definido."
    }
    ```

### ¿Qué Hace Este Script?

Este script realiza una comparación entre los nombres de los archivos encontrados
en subcarpetas distintas de una carpeta principal (`C:\Datos` en el ejemplo), y 
genera un informe en formato CSV listando aquellos cuya similitud de nombres supere
un umbral definido.

### ¿Cómo Funciona?

 1.  **Parámetros de Configuración:**
 2.   * `$carpetaRaiz`: Ruta principal desde donde se analizan los archivos.
      * `$umbralSimilitud`: Nivel mínimo de coincidencia entre nombres de archivos 
        para considerarlos "similares" (por ejemplo, `0.6` = 60%).
      * `$reporteCSV`: Ruta donde se guardará el reporte de resultados en formato `.
        csv`.
 3.  **Función de Similitud Rápida:**
 4.   * La función `Get-FastNameSimilarity` compara dos nombres de archivo eliminando
        extensiones y espacios, convirtiéndolos a minúsculas.
      * Calcula la fracción de caracteres comunes al inicio de los nombres, en relación
        con la longitud del más largo.
 5.  **Recolección de Archivos:**
 6.   * Se recorren todas las subcarpetas de la carpeta raíz.
      * Se crea una lista de objetos que contienen el nombre del archivo, su ruta completa
        y la carpeta en la que se encuentra.
 7.  **Comparación de Archivos:**
 8.   * Se comparan los archivos entre sí, asegurando que no pertenezcan a la misma
        carpeta y que no tengan el mismo nombre exacto.
      * Si la similitud supera el umbral, se registra la coincidencia en la lista de
        resultados.
 9.  **Exportación del Reporte:**
 10.  * Si se encuentran coincidencias, se exportan a un archivo CSV para su revisión.
      * Si no se encuentran, se informa al usuario mediante un mensaje en consola.

### ¿Para Qué Sirve?

Este script es útil en múltiples escenarios:

 * Limpieza de archivos duplicados parcialmente renombrados.
 * Auditoría de documentos en entornos compartidos.
 * Verificación de versiones dispersas de un mismo documento.
 * Consolidación de carpetas y organización documental.

### Ejemplo de Salida en el CSV

| Archivo1 | Carpeta1 | Archivo2 | Carpeta2 | Similitud | 
| `informe2023.docx` | `C:\Datos\Depto1` | `informe2023v2.docx` | `C:\Datos\Depto2` | 76.9% |

### Conclusión

Este script es una herramienta liviana pero poderosa para identificar archivos con
nombres similares de forma rápida y eficaz usando PowerShell. Puede ser integrado
en tareas de mantenimiento periódico o ejecutado puntualmente cuando se sospecha
de desorganización en una estructura de carpetas.

Adaptarlo a tus necesidades es fácil: puedes mejorar el algoritmo de similitud, 
filtrar por extensiones específicas o agregar exclusiones personalizadas. En definitiva,
un recurso ideal para mejorar la higiene de datos en tus sistemas.