Pulizia Cartella APPDATA

💻 Caccia ai Residui: Rimuovere in Sicurezza le Cartelle AppData Orfane

Ciao a tutti! Se il vostro PC sembra rallentare e lo spazio su disco scompare misteriosamente, la colpa potrebbe essere dei "residui" lasciati dalle applicazioni che avete disinstallato tempo fa. Questi file orfani si nascondono nelle cartelle AppData di Windows. 

Pulirli manualmente è rischioso, ma ho creato uno script PowerShell che automatizza il processo, includendo un backup di sicurezza (file ZIP) prima della cancellazione!

---

🛑 Avvertimenti Fondamentali

ATTENZIONE! L'utilizzo di script PowerShell richiede cautela.

• Backup Preventivo: Lo script crea un backup ZIP per ogni cartella, ma una revisione umana è essenziale.
• Valutazione Umana: Lo script identifica solo i potenziali residui. Dovete voi stessi confermare che la cartella non sia più in uso. Alcune Cartelle memorizzano dati importanti, fare una ricerca prima di eliminarla!!!
• Esecuzione Amministrativa: Lo script DEVE essere eseguito come Amministratore.

---

🚀 Istruzioni per l'Uso (PowerShell ISE)

1. Crea il file: Copia il codice completo (sotto) e incollalo in un Blocco Note. Salvalo come PulisciAppData.ps1.
2. Apri l'ISE: Clicca con il tasto destro sull'icona di PowerShell ISE e seleziona "Esegui come amministratore".
3. Carica lo Script: Nell'ISE, vai su File > Apri e carica il file PulisciAppData.ps1 salvato.
4. Avvia lo Script: Clicca sul pulsante "Esegui Script" (la freccia verde) all'interno dell'ISE.
5. Conferma: Lo script ti mostrerà l'elenco dei potenziali residui. Per ognuno, digita S (Sì per Backup e Cancella), N (No, salta) o A (Annulla tutte le operazioni e termina).

Liberamente ispirato al progetto KoKi7o/MS-Script su github

Esempio di Backup: Se cancelli AppData\Roaming\EASUS, verrà creato un file AppData\Roaming\EASUS.zip prima della cancellazione della cartella originale.

---

💻 Lo Script Completo (PulisciAppData.ps1)

Copia il codice seguente e salvalo nel tuo file .ps1:
NB. Se lo Script non dovesse funzionare digitare:
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

# App Leftover Finder - Trova i file residui delle applicazioni disinstallate.
# Esegui come Amministratore per i migliori risultati nella scansione del Registro di sistema.

Write-Host "=== App Leftover Finder ===" -ForegroundColor Cyan
Write-Host "Scansione per residui da applicazioni disinstallate...`n" -ForegroundColor Yellow

# --- FUNZIONI DI UTILITÀ ---
function Normalize-Name($name) {
    if ($name) {
        # Rimuove spazi, caratteri speciali e converte in minuscolo per il confronto
        return $name.ToLower().Trim() -replace '[^a-z0-9]', ''
    }
}

# --- 1/4 RACCOLTA E NORMALIZZAZIONE APPLICAZIONI INSTALLATE ---
Write-Host "[1/4] Acquisizione elenco applicazioni installate..." -ForegroundColor Green

# Percorsi comuni del Registro di sistema per le installazioni
$regPaths = @(
    "HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKLM:\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*"
)

# Ottiene i nomi delle app e li normalizza in un array di stringhe [string[]]
[string[]]$installedNames = $regPaths | ForEach-Object {
    Get-ItemProperty $_ -ErrorAction SilentlyContinue |
    Where-Object { $_.DisplayName } |
    ForEach-Object { Normalize-Name($_.DisplayName) }
}

# Aggiunge app di Windows Store (UWP)
$installedNames += Get-AppxPackage -ErrorAction SilentlyContinue | 
    ForEach-Object { Normalize-Name($_.Name) }

# Rimuove duplicati e valori vuoti
$installedNames = $installedNames | Select-Object -Unique | Where-Object { $_ }

Write-Host "Trovati $($installedNames.Count) nomi di applicazioni installate`n" -ForegroundColor White

# --- 2/4 & 3/4 SCANSIONE CARTELLE APPDATA ---
$appDataPaths = @(
    @{ Path = $env:LOCALAPPDATA; Location = "Local" },
    @{ Path = $env:APPDATA; Location = "Roaming" }
)

Write-Host "[2/4 & 3/4] Scansione cartelle AppData..." -ForegroundColor Green

$allFolders = @()
$appDataPaths | ForEach-Object {
    $location = $_.Location
    Get-ChildItem -Path $_.Path -Directory -ErrorAction SilentlyContinue |
    ForEach-Object {
        $allFolders += [PSCustomObject]@{
            Name = $_.Name
            FullName = $_.FullName
            Location = $location
            NormalizedName = Normalize-Name($_.Name)
        }
    }
}

Write-Host "Trovate $($allFolders.Count) cartelle da analizzare" -ForegroundColor White

# --- 4/4 ANALISI E IDENTIFICAZIONE DEI RESIDUI ---
Write-Host "[4/4] Analisi delle cartelle per residui...`n" -ForegroundColor Green

$leftovers = @()

foreach ($folder in $allFolders) {
    $folderName = $folder.NormalizedName
    
    $isInstalled = $false
    
    # Check 1: Corrispondenza esatta del nome normalizzato
    if ($installedNames -contains $folderName) {
        $isInstalled = $true
    }
    
    # Check 2: Controllo incrociato per nomi parziali/simili
    if (-not $isInstalled) {
        foreach ($appName in $installedNames) {
            if ($folderName -like "*$appName*" -or $appName -like "*$folderName*") {
                $isInstalled = $true
                break
            }
        }
    }
    
    if (-not $isInstalled) {
        # Calcolo delle dimensioni
        $size = (Get-ChildItem -Path $folder.FullName -Recurse -File -ErrorAction SilentlyContinue | 
                 Measure-Object -Property Length -Sum).Sum
        
        # Converte in MB e arrotonda
        $sizeMB = [math]::Round($size / 1MB, 2)
        
        if ($sizeMB -gt 0.01) { # Filtra le cartelle molto piccole (< 10 KB)
            $leftovers += [PSCustomObject]@{
                FolderName = $folder.Name
                Location = $folder.Location
                Path = $folder.FullName
                SizeMB = $sizeMB
            }
        }
    }
}

# --- RISULTATI E INIZIO CANCELLAZIONE ---
Write-Host "=== POTENTIAL LEFTOVERS FOUND ===" -ForegroundColor Cyan
Write-Host "Totale cartelle analizzate: $($allFolders.Count)" -ForegroundColor White
Write-Host "Residui potenziali: $($leftovers.Count)`n" -ForegroundColor Yellow

if ($leftovers.Count -eq 0) {
    Write-Host "Nessun residuo ovvio trovato!" -ForegroundColor Green
} else {
    # Ordina per dimensione (il più grande prima)
    $leftovers = $leftovers | Sort-Object -Property SizeMB -Descending
    
    Write-Host "Ecco l'elenco dei potenziali residui da analizzare:" -ForegroundColor Yellow
    $leftovers | Format-Table -AutoSize FolderName, Location, SizeMB, Path
    
    $totalSize = ($leftovers | Measure-Object -Property SizeMB -Sum).Sum
    Write-Host "`nSpazio totale occupato: $([math]::Round($totalSize, 2)) MB`n" -ForegroundColor Yellow
    
    # --- PROCESSO DI BACKUP E CANCELLAZIONE SICURA ---
    Write-Host "=== BACKUP E PULIZIA SICURA ===" -ForegroundColor Cyan
    Write-Host "Verrà chiesto di confermare la pulizia per ogni cartella. Il backup verrà creato come file ZIP nella stessa posizione della cartella." -ForegroundColor White
    
    $aborted = $false
    
    foreach ($item in $leftovers) {
        if ($aborted) { break }
        
        $zipPath = "$($item.Path).zip"
        
        Write-Host "`n------------------------------------------------------------" -ForegroundColor DarkGray
        Write-Host "Elaborazione: $($item.FolderName) | Dimensione: $($item.SizeMB) MB" -ForegroundColor Yellow
        Write-Host "Percorso: $($item.Path)" -ForegroundColor DarkGray
        
        $confirmation = Read-Host -Prompt "Vuoi effettuare il backup e cancellare questa cartella? (S)ì / (N)o / (A)nnulla tutto"
        
        switch ($confirmation.ToLower()) {
            "s" {
                Write-Host "-> Esecuzione Backup in: $zipPath" -ForegroundColor Green
                try {
                    # Compressione della cartella nel file ZIP
                    Compress-Archive -Path $item.Path -DestinationPath $zipPath -Force -ErrorAction Stop
                    
                    Write-Host "-> Backup completato. Cancellazione cartella originale..." -ForegroundColor Green
                    # Rimozione della cartella originale
                    Remove-Item -Path $item.Path -Recurse -Force -ErrorAction Stop
                    
                    Write-Host "-> Cancellazione di $($item.FolderName) completata con successo." -ForegroundColor Green
                } catch {
                    Write-Host "!!! ERRORE DURANTE L'OPERAZIONE per $($item.FolderName): $($_.Exception.Message)" -ForegroundColor Red
                    Write-Host "!!! La cartella originale potrebbe non essere stata cancellata. Procedi manualmente." -ForegroundColor Red
                }
            }
            "a" {
                $aborted = $true
                Write-Host "Pulizia annullata. Terminazione del processo." -ForegroundColor Red
            }
            "n" {
                Write-Host "-> Saltato: Nessuna azione intrapresa per $($item.FolderName)." -ForegroundColor Yellow
            }
            default {
                Write-Host "-> Input non valido. Saltato: Nessuna azione intrapresa per $($item.FolderName)." -ForegroundColor Yellow
            }
        }
    }
    
    Write-Host "`nPulizia completata." -ForegroundColor Cyan
}

# Correzione del metodo di pausa finale per la massima compatibilità
$null = Read-Host -Prompt "`nPremere Invio per uscire..."