Comment supprimer des dossiers vides dans PowerShell

1. Cmdlet Get-ChildItem dans PowerShell
2. Cmdlet Where-Object dans PowerShell
3. Supprimer des éléments d’une collection dans PowerShell
4. Conclusion

La gestion efficace des répertoires est essentielle dans les scripts PowerShell, et le cmdlet Get-ChildItem sert de pierre angulaire pour naviguer dans les systèmes de fichiers. Lorsqu’il s’agit de nettoyer les dossiers vides, il est crucial de parcourir les hiérarchies de dossiers.

Cet article approfondit l’utilisation pratique de Get-ChildItem avec d’autres cmdlets pour identifier et supprimer systématiquement les répertoires vides dans des chemins spécifiés. En tirant parti des capacités de script puissantes de PowerShell, les utilisateurs peuvent gérer efficacement les répertoires, garantissant un système de fichiers bien organisé.

Cmdlet Get-ChildItem dans PowerShell

Le cmdlet Get-ChildItem récupère tous les éléments enfants (fichiers et dossiers) pour un emplacement spécifié. Lorsqu’il est nécessaire de supprimer tous les dossiers vides d’un chemin de dossier donné, il est impératif de parcourir la hiérarchie des dossiers.

Ainsi, le cmdlet Get-ChildItem serait utile. Ce cmdlet accepte des paramètres comme Recurse et Directory pour récupérer des éléments enfants de type répertoire et parcourir récursivement la structure des dossiers.

Syntaxe :

Get-ChildItem -Path -Directory -Recurse

Il existe de nombreux autres paramètres optionnels disponibles à utiliser. Créons une structure de dossiers comme indiqué dans ce qui suit.

somepath/testA
			testB
				testD
				testE
					a.txt
			testC
				testF
					b.txt
				testG
					testH

L’objectif est de supprimer tous les dossiers vides dans le dossier testA. Par conséquent, les dossiers suivants devraient être supprimés.

1. testD
2. testG
3. testH

Récupérons tous les sous-répertoires dans le chemin de dossier donné (somepath/testA).

$path = "D:\testA"
$fetchedDirList = Get-ChildItem $path -Directory -Recurse

Dans cet extrait, nous assignons la variable $path au chemin du répertoire "D:\testA", et nous utilisons le cmdlet Get-ChildItem avec les paramètres -Directory et -Recurse pour récupérer tous les répertoires de manière récursive à partir du chemin spécifié. La liste résultante de répertoires est stockée dans la variable $fetchedDirList, nous donnant une collection d’objets répertoire représentant tous les répertoires dans "D:\testA" et ses sous-répertoires.

Il est possible d’utiliser l’alias gci au lieu de Get-ChildItem.

$fetchedDirList = gci $path -directory -Recurse

En passant du code original à cette version révisée, nous continuons de capturer les objets répertoire récupérés à l’aide du cmdlet Get-ChildItem dans la variable $fetchedDirList. Cependant, dans ce code mis à jour, nous utilisons l’alias gci au lieu du nom complet du cmdlet Get-ChildItem.

Cette abréviation maintient la fonctionnalité de récupération des répertoires de manière récursive à partir du chemin spécifié $path et de les stocker dans $fetchedDirList.

Vérifions la variable $fetchedDirList.

$fetchedDirList

Sortie :

Tous les répertoires et sous-répertoires ont été récupérés comme prévu.

Cmdlet Where-Object dans PowerShell

Nous devons filtrer les répertoires vides à partir du résultat ci-dessus. Le cmdlet Where-Object filtre les objets d’une collection en fonction de leurs propriétés.

L’alias Where peut être utilisé à la place de la commande Where-Object. Nous devons filtrer la liste de répertoires ci-dessus en fonction du nombre d’éléments dans chaque répertoire.

La condition est indiquée comme suit.

where { (gci $_.fullName).count -eq 0 }

Lorsque l’objet donné de la collection a 0 sous-éléments, il est considéré comme un répertoire vide. Par conséquent, nous devrions le supprimer.

Pipons la sortie de l’étape précédente au cmdlet Where.

$emptyDirectoryList = $fetchedDirList | where { (gci $_.fullName).count -eq 0 }

Dans cette ligne de code, nous assignons la variable $emptyDirectoryList au résultat du filtrage des répertoires à partir de $fetchedDirList en utilisant l’alias Where. La condition de filtrage, définie dans un bloc de script, vérifie si le nombre d’éléments enfants dans chaque répertoire (récupéré en utilisant gci $_.FullName) est égal à 0.

Cette approche identifie et capture efficacement uniquement les objets répertoire représentant des répertoires vides dans $emptyDirectoryList.

Imprimons le $emptyDirectoryList.

$emptyDirectoryList

Sortie :

Le résultat est parfaitement correct. Nous avons uniquement deux dossiers appelés testD et testH avec un contenu vide.

Nous pouvons facilement supprimer chaque objet de la collection $emptyDirectoryList. Le cmdlet Remove-Item peut être utilisé pour supprimer un élément.

Avant cela, nous devons récupérer le chemin complet de chacun des objets à l’intérieur de $emptyDirectoryList. Le cmdlet Select-Object peut récupérer les objets avec sa propriété FullName.

$finalListToRemove = $emptyDirectoryList | select -ExpandProperty FullName

Dans cette ligne de code, nous créons une nouvelle variable $finalListToRemove en extrayant les chemins complets des répertoires stockés dans $emptyDirectoryList. Nous utilisons le cmdlet Select-Object avec le paramètre -ExpandProperty FullName, nous permettant de récupérer la valeur de la propriété FullName pour chaque objet répertoire dans $emptyDirectoryList.

Par conséquent, $finalListToRemove contient une liste de chemins complets vers les répertoires vides, les préparant à la suppression.

$finalListToRemove

Sortie de $finalListToRemove :

Maintenant, nous avons la liste des dossiers à supprimer.

Supprimer des éléments d’une collection dans PowerShell

Il est possible d’utiliser le cmdlet ForEach-Object pour boucler à travers les éléments d’une collection. À l’intérieur de la boucle, nous pouvons utiliser le cmdlet Remove-Item.

$finalListToRemove | ForEach-Object { Remove-Item $_ }

Le $_ désigne l’élément courant dans la collection. Cela supprimera les dossiers testD et testH.

Il y a un aspect délicat ici. Lorsque le dossier testH est supprimé, le répertoire testG devient également vide.

Par conséquent, nous devons modifier le script un peu. Nous devrions exécuter la procédure ci-dessus jusqu’à ce que nous restions avec des dossiers non vides.

Nous pouvons utiliser la boucle do...while pour cela.

$path = "D:\testA"
do {
    $fetchedDirList = Get-ChildItem $path -Directory -Recurse
    $emptyDirectoryList = $fetchedDirList | where { (gci $_.fullName).count -eq 0 }
    $finalListToRemove = $emptyDirectoryList | select -ExpandProperty FullName
    $finalListToRemove | ForEach-Object { Remove-Item $_ }
} while ( $finalListToRemove.count -gt 0 )

Dans ce bloc de code, nous mettons en place une boucle pour détecter et supprimer systématiquement les répertoires vides dans le chemin désigné et ses sous-répertoires. À l’intérieur de la boucle, nous utilisons d’abord le cmdlet Get-ChildItem pour récupérer tous les répertoires de manière récursive à partir du chemin spécifié.

Ensuite, nous filtrons les répertoires vides en utilisant le cmdlet Where-Object. Après avoir extrait les chemins complets de ces répertoires vides, nous procédons à leur suppression un par un en utilisant le cmdlet Remove-Item dans une boucle ForEach-Object.

Cette boucle itère tant qu’il reste des répertoires vides à supprimer, garantissant un nettoyage complet des répertoires vides dans le chemin spécifié et ses sous-répertoires.

Lorsque vous devez tenir compte des fichiers et dossiers cachés, nous pouvons passer le paramètre -Force au cmdlet Get-ChildItem, comme indiqué ci-dessous.

$emptyDirectoryList = $fetchedDirList | where { (gci $_.fullName -Force).count -eq 0 }

Sortie :

Conclusion

Dans PowerShell, identifier et supprimer efficacement les dossiers vides est vital pour maintenir un système de fichiers organisé. Grâce à l’utilisation stratégique de cmdlets comme Get-ChildItem, Where-Object et Remove-Item, les utilisateurs peuvent rationaliser les tâches de gestion des répertoires.

Ces cmdlets permettent un nettoyage complet des répertoires dans des chemins spécifiés, améliorant l’efficacité et l’organisation du système. En exploitant l’environnement de script de PowerShell, les utilisateurs peuvent automatiser les processus de gestion des répertoires, économisant temps et efforts tout en garantissant un système de fichiers sans encombre.

Avec les capacités robustes de PowerShell, la gestion des répertoires devient un aspect sans couture de l’administration système, donnant aux utilisateurs la capacité de maintenir des performances optimales du système.