如何递归删除 PowerShell 中的所有空文件夹？

Question

我需要在 PowerShell 中递归删除特定文件夹的所有空文件夹（检查任何级别的文件夹和子文件夹）。

目前我使用这个脚本没有成功。

你能告诉我如何解决吗？

$tdc='C:\a\c\d\'
$a = Get-ChildItem $tdc -recurse | Where-Object {$_.PSIsContainer -eq $True}
$a | Where-Object {$_.GetFiles().Count -eq 0} | Select-Object FullName

我在 Windows 8.1 版本上使用 PowerShell。

Answer 1

你可以使用这个：

$tdc="C:\a\c\d"
$dirs = gci $tdc -directory -recurse | Where { (gci $_.fullName).count -eq 0 } | select -expandproperty FullName
$dirs | Foreach-Object { Remove-Item $_ }

$dirs 将是 Get-ChildItem 命令过滤后返回的空目录数组。然后您可以遍历它以删除项目。

更新

如果要删除包含空目录的目录，只需保留运行脚本，直到它们全部消失。您可以循环直到 $dirs 为空：

$tdc="C:\a\c\d"
do {
  $dirs = gci $tdc -directory -recurse | Where { (gci $_.fullName).count -eq 0 } | select -expandproperty FullName
  $dirs | Foreach-Object { Remove-Item $_ }
} while ($dirs.count -gt 0)

如果要确保隐藏的文件和文件夹也将被删除，请包含 -Force 标志：

do {
  $dirs = gci $tdc -directory -recurse | Where { (gci $_.fullName -Force).count -eq 0 } | select -expandproperty FullName
  $dirs | Foreach-Object { Remove-Item $_ }
} while ($dirs.count -gt 0)

Answer 2

ls c:\temp -rec |%{ if ($_.PSIsContainer -eq $True) {if ( (ls $_.fullname -rec | measure |select -expand count ) -eq "0"  ){ ri $_.fullname -whatif}  }  }

Answer 3

在查看这样的问题时，您需要牢记一些关键事项：

Get-ChildItem -Recurse 执行头部递归，这意味着它在遍历树时一找到文件夹就 returns 文件夹。由于您要删除空文件夹，如果在删除空文件夹后它们为空，则还要删除它们的父文件夹，因此您需要改用尾递归，它处理从最深的子文件夹到根目录的文件夹。通过使用尾递归，将无需重复调用删除空文件夹的代码——一次调用即可完成所有操作。
Get-ChildItem 默认不 return 隐藏文件或文件夹。因此，您需要采取额外的步骤来确保您不会删除看起来为空但包含隐藏文件或文件夹的文件夹。 Get-Item 和 Get-ChildItem 都有一个 -Force 参数，可用于检索隐藏文件或文件夹以及可见文件或文件夹。

考虑到这些要点，这里有一个使用尾递归并正确跟踪隐藏文件或文件夹的解决方案，确保删除为空的隐藏文件夹，并确保保留可能包含一个或更多隐藏文件。

首先这是完成任务的脚本块（匿名函数）：

# A script block (anonymous function) that will remove empty folders
# under a root folder, using tail-recursion to ensure that it only
# walks the folder tree once. -Force is used to be able to process
# hidden files/folders as well.
$tailRecursion = {
    param(
        $Path
    )
    foreach ($childDirectory in Get-ChildItem -Force -LiteralPath $Path -Directory) {
        & $tailRecursion -Path $childDirectory.FullName
    }
    $currentChildren = Get-ChildItem -Force -LiteralPath $Path
    $isEmpty = $currentChildren -eq $null
    if ($isEmpty) {
        Write-Verbose "Removing empty folder at path '${Path}'." -Verbose
        Remove-Item -Force -LiteralPath $Path
    }
}

如果你想测试它，这里的代码将创建有趣的测试数据（确保你还没有文件夹 c:\a 因为它将被删除):

# This creates some test data under C:\a (make sure this is not
# a directory you care about, because this will remove it if it
# exists). This test data contains a directory that is hidden
# that should be removed as well as a file that is hidden in a
# directory that should not be removed.
Remove-Item -Force -Path C:\a -Recurse
New-Item -Force -Path C:\a\b\c\d -ItemType Directory > $null
$hiddenFolder = Get-Item -Force -LiteralPath C:\a\b\c
$hiddenFolder.Attributes = $hiddenFolder.Attributes -bor [System.IO.FileAttributes]::Hidden
New-Item -Force -Path C:\a\b\e -ItemType Directory > $null
New-Item -Force -Path C:\a\f -ItemType Directory > $null
New-Item -Force -Path C:\a\f\g -ItemType Directory > $null
New-Item -Force -Path C:\a\f\h -ItemType Directory > $null
Out-File -Force -FilePath C:\a\f\test.txt -InputObject 'Dummy file'
Out-File -Force -FilePath C:\a\f\h\hidden.txt -InputObject 'Hidden file'
$hiddenFile = Get-Item -Force -LiteralPath C:\a\f\h\hidden.txt
$hiddenFile.Attributes = $hiddenFile.Attributes -bor [System.IO.FileAttributes]::Hidden

这是您的使用方法。请注意，这将删除顶级文件夹（本例中的 C:\a 文件夹，如果您使用上面的脚本生成测试数据，则会创建该文件夹），如果该文件夹在删除其下的所有空文件夹后最终为空。

& $tailRecursion -Path 'C:\a'

Answer 4

也可以使用 "For Loop".

递归删除空子目录

在我们开始之前，让我们在 $HOME\Desktop\Test

中创建一些子目录和文本文件

MD $HOME\Desktop\Test[=10=] 
MD $HOME\Desktop\Test\A\B\C\D\E\F
MD $HOME\Desktop\Test\A\B\C\DD\EE\FF
MD $HOME\Desktop\Test\Q\W\E\R\T\Y
MD $HOME\Desktop\Test\Q\W\E\RR
"Hello World" > $HOME\Desktop\Test[=10=]\Text1.txt
"Hello World" > $HOME\Desktop\Test\A\B\C\D\E\Text2.txt
"Hello World" > $HOME\Desktop\Test\A\B\C\DD\Text3.txt
"Hello World" > $HOME\Desktop\Test\Q\W\E\RR\Text4.txt

首先，将以下脚本块存储在变量$SB 中。稍后可以使用 &SB 命令调用该变量。 &SB 命令将输出 $HOME\Desktop\Test

中包含的空子目录列表

$SB = {
    Get-ChildItem $HOME\Desktop\Test -Directory -Recurse |
    Where-Object {(Get-ChildItem $_.FullName -Force).Count -eq 0}
}

注意：-Force 参数非常重要。它确保包含隐藏文件和子目录但在其他方面为空的目录不会在 "For Loop".

中被删除

现在使用 "For Loop" 递归删除 $HOME\Desktop\Test

中的空子目录

For ($Empty = &$SB ; $Empty -ne $null ; $Empty = &$SB) {Remove-Item (&$SB).FullName}

经测试可在 PowerShell 4.0 上运行

Answer 5

假设您在感兴趣的父文件夹中

gci . -Recurse -Directory | % { if(!(gci -Path $_.FullName)) {ri -Force -Recurse $_.FullName} }

对于 $tdc 的情况，它将是

gci $tdc -Recurse -Directory | % { if(!(gci -Path $_.FullName)) {ri -Force -Recurse $_.FullName} }

Answer 6

如果您只是想确保只删除可能包含子文件夹但不删除自身及其子文件夹中的文件的文件夹，这可能是一种更简单快捷的方法。

$Empty = Get-ChildItem $Folder -Directory -Recurse |
Where-Object {(Get-ChildItem $_.FullName -File -Recurse -Force).Count -eq 0}

Foreach ($Dir in $Empty)
{
    if (test-path $Dir.FullName)
    {Remove-Item -LiteralPath $Dir.FullName -recurse -force}
}

Answer 7

我改编了RichardHowells的剧本。如果有 thumbs.db.

，它不会删除文件夹

##############
# Parameters #
##############
param(
    $Chemin = "" ,  # Path to clean
    $log = ""       # Logs path
)




###########
# Process #
###########


if (($Chemin -eq "") -or ($log-eq "") ){

    Write-Error 'Parametres non reseignes - utiliser la syntaxe : -Chemin "Argument"  -log "argument 2" ' -Verbose 
    Exit
}



#loging 
$date = get-date -format g
Write-Output "begining of cleaning folder : $chemin at $date" >> $log
Write-Output "------------------------------------------------------------------------------------------------------------" >> $log


<########################################################################
    define a script block that will remove empty folders under a root folder, 
    using tail-recursion to ensure that it only walks the folder tree once. 
    -Force is used to be able to process hidden files/folders as well.
########################################################################>
$tailRecursion = {
    param(
        $Path
    )
    foreach ($childDirectory in Get-ChildItem -Force -LiteralPath $Path -Directory) {
        & $tailRecursion -Path $childDirectory.FullName
    }
    $currentChildren = Get-ChildItem -Force -LiteralPath $Path
    Write-Output $childDirectory.FullName



    <# Suppression des fichiers Thumbs.db #>
    Foreach ( $file in $currentchildren )
    {
        if ($file.name -notmatch "Thumbs.db"){break}
        if ($file.name -match "Thumbs.db"){
            Remove-item -force -LiteralPath $file.FullName}

    }



    $currentChildren = Get-ChildItem -Force -LiteralPath $Path
    $isEmpty = $currentChildren -eq $null
    if ($isEmpty) {
        $date = get-date -format g
        Write-Output "Removing empty folder at path '${Path}'.  $date" >> $log
        Remove-Item -Force -LiteralPath $Path
    }
}

# Invocation of the script block
& $tailRecursion -Path $Chemin

#loging 
$date = get-date -format g
Write-Output "End of cleaning folder : $chemin at $date" >> $log
Write-Output "------------------------------------------------------------------------------------------------------------" >> $log

Answer 8

我不会把 comments/1st post 放在心上，除非您还想删除嵌套在一个以上文件夹深处的文件。您将最终删除可能包含可能包含文件的目录的目录。这个比较好：

$FP= "C:\Temp\"

$dirs= Get-Childitem -LiteralPath $FP -directory -recurse

$Empty= $dirs | Where-Object {$_.GetFiles().Count -eq 0 **-and** $_.GetDirectories().Count -eq 0} | 

Select-Object FullName

以上检查以确保该目录实际上是空的，而 OP 仅检查以确保没有文件。这反过来又会导致几个文件夹下的文件也被删除。

您可能需要运行多次执行上述操作，因为它不会删除具有嵌套目录的目录。所以它只删除最深的层次。所以循环它直到它们都消失了。

我不做的另一件事是使用 -force 参数。这是设计使然。如果实际上 remove-item 命中了一个不为空的目录，您希望得到提示作为额外的安全措施。

Answer 9

Get-ChildItem $tdc -Recurse -Force -Directory | 
    Sort-Object -Property FullName -Descending |
    Where-Object { $($_ | Get-ChildItem -Force | Select-Object -First 1).Count -eq 0 } |
    Remove-Item -Verbose

这里唯一新颖的贡献是使用 Sort-Object 按目录的全名反向排序。这将确保我们始终在处理 parents 之前处理 children（即，"tail recursion"，如 Kirk Munro 的回答所述）。这使得它递归地删除空文件夹。

副手，我不确定 Select-Object -First 1 是否会显着提高性能，但它可能会。

Answer 10

像这样的东西对我有用。该脚本删除空文件夹和仅包含文件夹（无文件，无隐藏文件）的文件夹。

$items = gci -LiteralPath E:\ -Directory -Recurse
$dirs = [System.Collections.Generic.HashSet[string]]::new([string[]]($items |% FullName))
for (;;) {
    $remove = $dirs |? { (gci -LiteralPath $_ -Force).Count -eq 0 }
    if ($remove) {
        $remove | rm
        $dirs.ExceptWith( [string[]]$remove )
    }
    else {
        break
    }
}

Answer 11

$files = Get-ChildItem -Path c:\temp -Recurse -Force | where psiscontainer ; [array]::reverse($files)

[Array]::reverse($files) 将反转您的项目，因此您首先获得层次结构中最低的文件。我用它来处理文件路径太长的文件名，然后再删除它们。

Answer 12

这是一个简单的方法

dir -Directory | ? { (dir $_).Count -eq 0 } | Remove-Item

Answer 13

只是想我会为这里已经很长的答案列表做出贡献。

许多答案都有自己的怪癖，比如需要运行不止一次。其他的对于普通用户来说过于复杂（比如使用尾递归来防止重复扫描等）。

这是我多年来一直使用的一种非常简单的单线笔，效果很好...

它不考虑隐藏的 files/folders，但您可以通过将 -Force 添加到 Get-ChildItem 命令来解决这个问题

这是完全限定的长 cmdlet 名称版本：

Get-ChildItem -Recurse -Directory | ? { -Not ($_.EnumerateFiles('*',1) | Select-Object -First 1) } | Remove-Item -Recurse

所以基本上...事情是这样的：

Get-ChildItem -Recurse -Directory - 开始递归扫描寻找目录
$_.EnumerateFiles('*',1) - 对于每个目录...枚举文件
- EnumerateFiles 将输出它的发现，GetFiles 将在完成时输出......至少，这就是它应该在 .NET 中工作的方式......对于PowerShell GetFiles 中的某些原因立即开始吐出。但我仍然使用 EnumerateFiles 因为在测试中它确实更快。
- ('*',1)表示递归查找所有文件。
| Select-Object -First 1 - 在找到的第一个文件处停止
- 这很难测试它有多大帮助。在某些情况下它有很大的帮助，其他时候它根本没有帮助，在某些情况下它会稍微减慢速度。所以我真的不知道。我想这是可选的。
| Remove-Item -Recurse - 递归删除目录（确保删除包含空子目录的目录）

如果您要计算字符数，则可以缩短为：

ls -s -ad | ? { -Not ($_.EnumerateFiles('*',1) | select -First 1) } | rm -Recurse

-s - -Recurse
-ad - -Directory

如果你真的不关心性能，因为你没有那么多文件....更重要的是：

ls -s -ad | ? {!($_.GetFiles('*',1))} | rm -Recurse

旁注：在解决这个问题时，我开始使用 Measure-Command 对具有数百万个文件和数千个目录的服务器测试各种版本。

这比我一直在使用的命令（上面）更快：

(gi .).EnumerateDirectories('*',1) | ? {-Not $_.EnumerateFiles('*',1) } | rm -Recurse

Answer 14

这将删除指定目录中的所有空文件夹$tdc。它也快了很多，因为不需要多次运行。

    $tdc = "x:\myfolder" # Specify the root folder
    gci $tdc -Directory -Recurse `
        | Sort-Object { $_.FullName.Length } -Descending `
        | ? { $_.GetFiles().Count -eq 0 } `
        | % {
            if ($_.GetDirectories().Count -eq 0) { 
                Write-Host " Removing $($_.FullName)"
                $_.Delete()
                }
            }

Answer 15

#By Mike Mike Costa Rica
$CarpetasVacias = Get-ChildItem -Path $CarpetaVer -Recurse -Force -Directory | Where {(gci $_.fullName).count -eq 0} | select Fullname,Name,LastWriteTime
$TotalCarpetas = $CarpetasVacias.Count
$CountSu = 1
ForEach ($UnaCarpeta in $CarpetasVacias){
    $RutaCarp = $UnaCarpeta.Fullname
    Remove-Item -Path $RutaCarp -Force -Confirm:$False -ErrorAction Ignore
    $testCar = Test-Path $RutaCarp
    if($testCar -eq $true){ 
        $Datem = (Get-Date).tostring("MM-dd-yyyy HH:mm:ss")
        Write-Host "$Datem ---> $CountSu de $TotalCarpetas Carpetas Error Borrando Directory: $RutaCarp" -foregroundcolor "red"
    }else{
        $Datem = (Get-Date).tostring("MM-dd-yyyy HH:mm:ss")
        Write-Host "$Datem ---> $CountSu de $TotalCarpetas Carpetas Correcto Borrando Directory: $RutaCarp" -foregroundcolor "gree"
    }
    $CountSu += 1
}

如何递归删除 PowerShell 中的所有空文件夹？

How to recursively remove all empty folders in PowerShell?

powershell

windows-8.1

更新