Come eliminare in modo ricorsivo un'intera directory con PowerShell 2.0?

Qual è il modo più semplice per eliminare forzatamente una directory e tutte le sue sottodirectory in PowerShell? Sto usando PowerShell V2 in Windows 7.

Ho appreso da diverse fonti che il comando più ovvio Remove-Item $targetDir -Recurse -Force, non funziona correttamente. Ciò include una dichiarazione nella guida in linea di PowerShell V2 (trovata usando Get-Help Remove-Item -Examples) che afferma:

... Poiché il parametro Recurse in questo cmdlet è errato, il comando utilizza il cmdlet Get-Childitem per ottenere i file desiderati e utilizza l'operatore della pipeline per passarli al cmdlet Remove-Item ...

Ho visto vari esempi che usano Get-ChildItem e lo inoltrano a Remove-Item , ma gli esempi rimuovono di solito un set di file basato su un filtro, non l'intera directory.

Sto cercando il modo più pulito per eliminare un'intera directory, file e directory secondarie, senza generare alcun messaggio di avviso dell'utente utilizzando la minima quantità di codice. Un one-liner sarebbe carino se fosse facile da capire.

Remove-Item -Recurse -Force some_dir

funziona davvero come pubblicizzato qui.

rm -r -fo some_dir

sono alias di stenografia che funzionano anche.

Per quanto ho capito, il -Recurseparametro non funziona correttamente quando si tenta di eliminare ricorsivamente un set di file filtrati. Per aver ucciso una sola directory e tutto quanto sotto sembra funzionare bene.

Ero solito:

rm -r folderToDelete

Questo funziona per me come un incantesimo (l'ho rubato da Ubuntu).

Quando si eliminano i file in modo ricorsivo usando un semplice, a Remove-Item "folder" -Recursevolte vedo un errore intermittente:[folder] cannot be removed because it is not empty.

Questa risposta tenta di prevenire tale errore eliminando singolarmente i file.

function Get-Tree($Path,$Include='*') { 
    @(Get-Item $Path -Include $Include -Force) + 
        (Get-ChildItem $Path -Recurse -Include $Include -Force) | 
        sort pspath -Descending -unique
} 

function Remove-Tree($Path,$Include='*') { 
    Get-Tree $Path $Include | Remove-Item -force -recurse
} 

Remove-Tree some_dir

Un dettaglio importante è l'ordinamento di tutti gli elementi in pspath -Descendingmodo che le foglie vengano eliminate prima delle radici. L'ordinamento viene eseguito sul pspathparametro poiché ha maggiori possibilità di lavorare per provider diversi dal file system. Il -Includeparametro è solo una comodità se si desidera filtrare gli elementi da eliminare.

È diviso in due funzioni poiché trovo utile vedere cosa sto per eliminare eseguendo

Get-Tree some_dir | select fullname

rm -r ./folder -Force    

... ha funzionato per me

Prova questo esempio. Se la directory non esiste, non viene generato alcun errore. Potrebbe essere necessario PowerShell v3.0.

remove-item -path "c:\Test Temp\Test Folder" -Force -Recurse -ErrorAction SilentlyContinue

Utilizzare il comando DOS old-school:

rd /s <dir>

Per qualche ragione la risposta di John Rees a volte non ha funzionato nel mio caso. Ma mi ha portato nella seguente direzione. Per prima cosa provo a eliminare la directory in modo ricorsivo con l'opzione buggy -recurse. Successivamente scendo in ogni sottodiretto rimasto ed elimino tutti i file.

function Remove-Tree($Path)
{ 
    Remove-Item $Path -force -Recurse -ErrorAction silentlycontinue

    if (Test-Path "$Path\" -ErrorAction silentlycontinue)
    {
        $folders = Get-ChildItem -Path $Path –Directory -Force
        ForEach ($folder in $folders)
        {
            Remove-Tree $folder.FullName
        }

        $files = Get-ChildItem -Path $Path -File -Force

        ForEach ($file in $files)
        {
            Remove-Item $file.FullName -force
        }

        if (Test-Path "$Path\" -ErrorAction silentlycontinue)
        {
            Remove-Item $Path -force
        }
    }
}

Per evitare gli errori "La directory non è vuota" della risposta accettata, basta usare il buon vecchio comando DOS come suggerito prima. La sintassi completa di PS pronta per il copia-incolla è:

& cmd.exe /c rd /S /Q $folderToDelete

Ho preso un altro approccio ispirato da @ john-rees sopra - specialmente quando il suo approccio ha iniziato a fallire per me ad un certo punto. Fondamentalmente ricorre alla sottostruttura e ordina i file in base alla loro lunghezza del percorso - elimina dal più lungo al più corto

Get-ChildItem $tfsLocalPath -Recurse |  #Find all children
    Select-Object FullName,@{Name='PathLength';Expression={($_.FullName.Length)}} |  #Calculate the length of their path
    Sort-Object PathLength -Descending | #sort by path length descending
    %{ Get-Item -LiteralPath $_.FullName } | 
    Remove-Item -Force

Per quanto riguarda la magia -LiteralPath, ecco un altro gotchya che potrebbe colpire te: https://superuser.com/q/212808

del <dir> -Recurse -Force # I prefer this, short & sweet

O

remove-item <dir> -Recurse -Force

Se hai una directory enorme, quello che faccio di solito è

while (dir | where name -match <dir>) {write-host deleting; sleep -s 3}

Eseguilo su un altro terminale PowerShell e si fermerà al termine.

L'eliminazione di un intero albero delle cartelle a volte funziona e talvolta non riesce con errori "Directory non vuota". Il tentativo successivo di verificare se la cartella esiste ancora può causare errori "Accesso negato" o "Accesso non autorizzato". Non so perché questo accada, anche se alcuni approfondimenti possono essere acquisiti da questa pubblicazione StackOverflow .

Sono stato in grado di aggirare questi problemi specificando l'ordine in cui gli elementi all'interno della cartella vengono eliminati e aggiungendo ritardi. Quanto segue funziona bene per me:

# First remove any files in the folder tree
Get-ChildItem -LiteralPath $FolderToDelete -Recurse -Force | Where-Object { -not ($_.psiscontainer) } | Remove-Item –Force

# Then remove any sub-folders (deepest ones first).    The -Recurse switch may be needed despite the deepest items being deleted first.
ForEach ($Subfolder in Get-ChildItem -LiteralPath $FolderToDelete -Recurse -Force | Select-Object FullName, @{Name="Depth";Expression={($_.FullName -split "\\").Count}} | Sort-Object -Property @{Expression="Depth";Descending=$true}) { Remove-Item -LiteralPath $Subfolder.FullName -Recurse -Force }

# Then remove the folder itself.  The -Recurse switch is sometimes needed despite the previous statements.
Remove-Item -LiteralPath $FolderToDelete -Recurse -Force

# Finally, give Windows some time to finish deleting the folder (try not to hurl)
Start-Sleep -Seconds 4

Un articolo di Microsoft TechNet sull'utilizzo delle proprietà calcolate in PowerShell mi è stato utile per ottenere un elenco di sottocartelle ordinate per profondità.

Problemi di affidabilità simili con RD / S / Q possono essere risolti eseguendo DEL / F / S / Q prima RD / S / Q e l'esecuzione del RD una seconda volta se necessario - idealmente con una pausa tra (vale a dire utilizzando ping come mostrato sotto).

DEL /F /S /Q "C:\Some\Folder\to\Delete\*.*" > nul
RD /S /Q "C:\Some\Folder\to\Delete" > nul
if exist "C:\Some\Folder\to\Delete"  ping -4 -n 4 127.0.0.1 > nul
if exist "C:\Some\Folder\to\Delete"  RD /S /Q "C:\Some\Folder\to\Delete" > nul

Davvero semplice:

remove-item -path <type in file or directory name>, press Enter

Un altro trucco utile:

Se trovi molti file con convenzione di nome uguale o simile (come file mac con nome prefisso punto ... quel famoso pull di file), puoi rimuoverli facilmente con una sola riga dalla PowerShell in questo modo:

ls -r .* | rm

Questa riga rimuoverà tutti i file con un punto all'inizio del nome all'interno della directory corrente e anche tutti i file con le stesse circostanze all'interno di altre cartelle all'interno di questa directory. Siate consapevoli durante l'utilizzo. : D

Per eliminare il contenuto completo inclusa la struttura delle cartelle, utilizzare

get-childitem $dest -recurse | foreach ($_) {remove-item $_.fullname -recurse}

L' -recurseaggiunta per remove-itemgarantire che i prompt interattivi siano disabilitati.

$users = get-childitem \\ServerName\c$\users\ | select -ExpandProperty name

foreach ($user in $users)

{
remove-item -path "\\Servername\c$\Users\$user\AppData\Local\Microsoft\Office365\PowerShell\*" -Force -Recurse
Write-Warning "$user Cleaned"
}

Scritto quanto sopra per pulire alcuni file di registro senza eliminare la directory principale e questo funziona perfettamente!

rm -r <folder_name>
c:\>rm -r "my photos"