Utilisation de la Cmdlet PowerShell Move-Item pour déplacer des fichiers

Dans le cadre d'une tâche routinière, les utilisateurs déplacent des éléments, tels que des fichiers et des dossiers, d'un endroit à un autre sur notre ordinateur, afin que les données soient triées et cohérentes. Bien que cela puisse être accompli avec de simples options de copier et coller depuis l'Explorateur de fichiers, les utilisateurs avancés peuvent préférer PowerShell pour son efficacité et sa précision.

Définition : Cmdlet Move-Item

Le cmdlet Move-Item dans PowerShell déplace un élément d'un emplacement à un autre dans l'Explorateur de fichiers, en conservant intactes ses propriétés, son contenu et ses éléments enfants. Il peut être utilisé comme suit :

• Déplacer un fichier ou un dossier d'un répertoire à un autre
• Déplacez plusieurs fichiers ou répertoires à la fois
• Déplacez une sous-clé de registre d'une clé vers une autre

Une fois ajouté au nouvel emplacement, un élément déplacé est retiré de son emplacement d'origine.

Comme condition préalable, le nouvel emplacement doit être pris en charge par le même fournisseur.

Syntaxe de base de Move-Item

La cmdlet Move-Item a la syntaxe de base suivante :

      Move-Item -Path "sourceFilePath" -Destination "destinationFilePath"
      

Un exemple de la syntaxe avec les paramètres pris en charge est :

      Move-Item
    [-Path] <String[]>
    [[-Destination] <String>]
    [-Force]
    [-Filter <String>]
    [-Include <String[]>]
    [-Exclude <String[]>]
    [-PassThru]
    [-Credential <PSCredential>]
    [-WhatIf]
    [-Confirm]
    [<CommonParameters>]
      

Déplacez un seul fichier avec Move-Item

Pour déplacer un fichier unique d'un emplacement à un autre via PowerShell, spécifiez le chemin du fichier source et le répertoire de destination dans l'applet de commande Move-Item. Cela se présente comme suit :

      Move-Item -Path <source file path>\<file name> -Destination <Destination path>
      

Vous pouvez également renommer le fichier lors du processus de move.

Scénario 1 – Déplacer un fichier unique sans le renommer

Cette cmdlet déplace le fichier Test.txt du répertoire C:\Temp vers le répertoire C:\Backup sans renommer le fichier :

      Move-Item -Path C:\Temp\test.txt -Destination C:\Backup
      

Scénario 2 – Déplacer un seul fichier et le renommer pendant le processus de déplacement

Cette cmdlet déplace le fichier Test.txt du répertoire C:\Temp vers le répertoire C:\Backup tout en le renommant en UseCase.txt:

      Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\UseCase.txt
      

Déplacer plusieurs fichiers

Vous pouvez utiliser des caractères génériques dans l'applet de commande Move-Item pour déplacer plusieurs éléments à la fois, tels que plusieurs fichiers, d'un emplacement à un autre. Par exemple, vous pouvez facilement déplacer tous les fichiers de la même extension d'un emplacement à un autre.

Scénario 1 – Déplacer tous les fichiers de la même extension en utilisant des caractères génériques

Cette cmdlet déplace tous les fichiers texte (*.txt) du répertoire C:\Temp vers le répertoire C:\Backup, en laissant tous les autres fichiers :

      Move-Item -Path C:\Temp\*.txt -Destination C:\Backup
      

Scénario 2 – Déplacer tous les fichiers quelle que soit l'extension

Utilisez le cmdlet Get-ChildItem avec le paramètre -File pour filtrer tous les fichiers (et non les dossiers) du répertoire source. Ensuite, transmettez les résultats au cmdlet Move-Item pour déplacer les fichiers filtrés vers le répertoire de destination, en laissant derrière tous les dossiers.

Dans le cmdlet suivant, le paramètre -File filtre uniquement les fichiers dans le répertoire C:\Temp. Le cmdlet Move-Item déplace ensuite ces fichiers de C:\Temp vers le répertoire C:\Backup, en laissant les dossiers dans C:\Temp :

      Get-ChildItem -Path C:\Temp\* -File | Move-Item -Destination C:\Backup
      

Scénario 3 – Déplacer des fichiers spécifiques

Il est également possible de déplacer des fichiers spécifiques ayant les mêmes extensions ou des extensions différentes. Dans ce cas, vous devez spécifier plusieurs fichiers en fournissant un tableau de chemins, en utilisant une virgule pour séparer les valeurs multiples.

Cette applet de commande déplace deux fichiers nommés Test.txt et UseCase.pdf du dossier C:\Temp vers le dossier C:\Backup :

      Move-Item -Path C:\Temp\test.txt, C:\Temp\UseCase.pdf -Destination C:\Backup
      

Déplacer un répertoire

Le cmdlet Move-Item de PowerShell est suffisamment puissant pour déplacer un répertoire avec tout son contenu – fichiers, dossiers, sous-dossiers – vers un autre répertoire. Ou vous pouvez choisir de déplacer tout le contenu, en laissant le répertoire vide derrière. Dans les deux cas, la structure des dossiers à la source est copiée vers la destination.

Scénario 1 – Déplacer un répertoire entier avec tout son contenu

Cette cmdlet déplace le dossier Temp avec son contenu vers le dossier C:\Backup.

      Move-Item -Path C:\Temp -Destination C:\Backup
      

Notez que le dossier Temp sera supprimé de C:\ et placé dans le répertoire Backup.

Scénario 2 – Déplacer tout le contenu d'un répertoire tout en laissant le répertoire derrière

Cette cmdlet déplace récursivement tous les fichiers et dossiers du répertoire Keys vers le dossier C:\Backup.

      Move-Item -Path C:\Temp\Keys\* -Destination C:\Backup
      

Remarquez que dans ce cas, le répertoire source (Keys) reste en place tandis que tout son contenu est déplacé. Cette cmdlet devrait laisser le répertoire source vide.

Déplacer des fichiers vers un emplacement réseau

Le cmdlet Move-Item peut également déplacer des fichiers vers un emplacement réseau. Il suffit de fournir le chemin réseau comme destination.

Considérez ce qui suit :

• Vous devez disposer des autorisations nécessaires pour accéder à l'emplacement réseau.
• Le chemin réseau doit être accessible depuis la machine où vous exécutez le cmdlet.
• Vous devez faire l'une des actions suivantes si l'emplacement réseau nécessite une authentification :
• Mappez d'abord le lecteur réseau en utilisant l'applet de commande New-PSDrive ou manuellement via l'Explorateur Windows
• Spécifiez les identifiants lors de l'accès à la ressource réseau

Scénario 1 – Déplacer un fichier vers un emplacement réseau

Cette cmdlet déplace le fichier Text.txt de C:\Temp vers un emplacement réseau, qui est un dossier nommé Backup sur un serveur nommé FileServer.

      Move-Item -Path C:\Temp\test.txt -Destination \\FileServer\Backup
      

Scénario 2 – Prévenir l'écrasement lors du déplacement d'un fichier

Lors du déplacement d'un fichier vers un emplacement réseau avec l'applet de commande Move-Item, PowerShell écrasera un fichier existant si le nom du fichier est identique, même lorsque le paramètre -Force n'est pas fourni.

Pour éviter l'écrasement, ajoutez une vérification avant de déplacer le fichier.

      if (-not (Test-Path "\\FileServer\Backup\test.txt")) {
    Move-Item -Path "C:\Temp\test.txt" -Destination "\\FileServer\Backup"
}
else {
    Write-Host "A file with the same name already exists in the destination."
}
      

Test-Path vérifie si le fichier existe déjà dans la destination. Si oui, il ne déplacera pas le fichier ad vous en informera à la place.

Déplacement récursif de fichiers

La cmdlet PowerShell Move-Item peut également fonctionner avec le paramètre -Recurse pour déplacer tous les fichiers d'un répertoire, ainsi que de tous les dossiers et sous-dossiers qu'il contient, vers un autre emplacement. Vous pouvez aussi limiter la fonction de déplacement aux fichiers d'une extension spécifique.

Scénario 1 – Déplacer récursivement tous les fichiers de la même extension

Cette cmdlet déplace récursivement tous les fichiers PDF du répertoire C:\Temp et de ses sous-dossiers vers le répertoire C:\Backup.

      Get-ChildItem -Path C:\Temp\*.pdf -Recurse | Move-Item -Destination C:\Backup
      

Ici, le cmdlet Get-ChildItem récupère les éléments enfants dans le répertoire C:\Temp et ses sous-dossiers qui ont une extension de fichier *.pdf. Il utilise le paramètre -Recurse pour rendre la récupération récursive.

Le tube (|) envoie les résultats au cmdlet Move-Item, qui déplace les fichiers pdf vers le répertoire Backup.

Note: Par défaut, Get-ChildItem ne déplace pas les fichiers cachés. Pour cela, utilisez le paramètre -Force avec Get-ChildItem, puis transférez les résultats à Move-Item.

Scénario 2 – Déplacer tous les fichiers de manière récursive

Utilisez le paramètre -Recurse avec le cmdlet Get-ChildItem pour déplacer des fichiers de manière récursive d'un répertoire à un autre.

Cette cmdlet déplace tous les fichiers du répertoire C:\Temp et de ses sous-répertoires vers le répertoire C:\Backup. Le paramètre -Recurse est utilisé pour rechercher dans tous les sous-répertoires du chemin spécifié tandis que le paramètre -File limite la cmdlet à la récupération de fichiers, en excluant les dossiers.

      Get-ChildItem -Path C:\Temp -Recurse -File | Move-Item -Destination C:\Backup
      

Notez que cette cmdlet déplace uniquement les fichiers. Aucun dossier ou sous-dossier n'est affecté. De plus, la cmdlet déplace les fichiers à la racine du répertoire de destination et ne crée pas la structure de dossiers du répertoire source à la destination.

Filtrer les fichiers

Vous pouvez filtrer des éléments en fonction de critères spécifiques tout en les déplaçant à l'aide de l'applet de commande Move-Item. Par exemple, vous pouvez souhaiter conserver un fichier spécifique dans le répertoire source ou déplacer des fichiers d'un nom ou d'une extension spécifique. Les paramètres -Filter, -Include et -Exclude sont pratiques pour de telles opérations.

• Le paramètre -Include est utilisé pour inclure des fichiers qui correspondent à un attribut spécifique, pour les déplacer. Par exemple, vous pouvez spécifier le(s) nom(s) de fichier (c:\temp\test*) ou l'extension(s) (*.txt) comme attributs, de sorte que seuls les fichiers correspondant à l'attribut donné soient déplacés vers l'emplacement de destination.
• Le paramètre -Exclude est utilisé pour exclure les fichiers correspondant à un attribut spécifique, afin qu'ils ne soient pas déplacés. Par exemple, vous pouvez spécifier des noms de fichier (c:\temp\test*) ou des extensions (*.txt) comme attributs, de sorte que les fichiers correspondant à l'attribut donné ne soient pas déplacés vers l'emplacement de destination.
• Le paramètre -Filter est similaire au paramètre -Include mais il est plus rapide et plus efficace que -Include.

Considérez ce qui suit :

• Vous devez utiliser le contenu entier du dossier pour inclure, exclure ou filtrer des données spécifiques.
• Ces paramètres peuvent fonctionner avec des caractères génériques.

Note :
Avant d'exécuter les cmdlets fournis dans les scénarios ci-dessous, assurez-vous d'utiliser la version la plus récente de PowerShell. Si ce n'est pas le cas, mettez à jour votre version de PowerShell pour des opérations fluides.

Scénario 1 – Exclure des fichiers d'une extension spécifique

Cette cmdlet déplace tous les fichiers du dossier C:\Temp vers le dossier Backup à l'exception de ceux qui ont une extension .txt.

      Move-Item -Path C:\Temp\* -Exclude *.txt -Destination C:\Backup
      

Encore une fois, dans le cmdlet suivant, le paramètre -Filter déplacera tous les fichiers .docx de C:\Temp vers C:\Backup.

      Move-Item -Path C:\Temp\* -Filter *.docx -Destination C:\Backup
      

Scénario 2 – Déplacer des fichiers d'une extension spécifique

Cette cmdlet déplace uniquement les fichiers texte (.txt) du dossier C:\Temp vers le dossier Backup.

      Move-Item -Path C:\Temp\* -Include *.txt -Destination C:\Backup
      

Consultez la section Déplacer plusieurs fichiers pour des fonctions similaires.

Scénario 3 – Déplacer des fichiers dont les noms commencent par une chaîne spécifique

Cette applet de commande déplace les fichiers dont les noms commencent par « log ». Elle ne déplacera pas les fichiers qui ne commencent pas par « log » de C:\Temp.

      Move-Item -Path C:\Temp\* -Include log* -Destination C:\Backup
      

Scénarios de déplacement avancés

La cmdlet PowerShell Move-Item peut également déplacer des fichiers en fonction de critères spécifiques, tels que la taille du fichier, la date de modification, et ainsi de suite. À cette fin, vous pouvez choisir l'une de ces méthodes :

• Utilisez le paramètre -Filter
• Utilisez Get-ChildItem avec Where-Object pour sélectionner des fichiers avec des attributs spécifiques ou des propriétés de date avant de les déplacer. Cela suit un processus en trois étapes :
• La cmdlet Get-ChildItem récupère des fichiers depuis un emplacement source.
• Pour filtrer selon des attributs, tels que la taille du fichier ou la date de dernière modification, transmettez le résultat au Where-Object cmdlet.
• Ensuite, redirigez la sortie vers la cmdlet Move-Item pour déplacer les fichiers filtrés.

Alors, pour déplacer des fichiers de plus de 5 Go, vous trouvez les fichiers avec Get-ChildItem, les filtrez avec Where-Object et les déplacez avec Move-Item.

Scénario 1 – Déplacer les fichiers et dossiers modifiés au cours des derniers X jours

Cette cmdlet déplace tous les fichiers et dossiers modifiés au cours des 30 derniers jours du répertoire C:\Temp vers le répertoire C:\RecentFiles.

      Get-ChildItem -Path C:\Temp\* | Where-Object {$_.LastWriteTime -gt (Get-Date).AddDays(-30)} | Move-Item -Destination C:\RecentFiles
      

Alors que vous devez être désormais assez familier avec les cmdlets Get-ChildItem et Move-Item, plongeons dans Where-Object. Cette cmdlet filtre les éléments modifiés au cours des 30 derniers jours.

• $_ représente chaque objet (fichier ou dossier) transmis par Get-ChildItem.
• LastWriteTime est une propriété du fichier/dossier qui indique la dernière fois que l'élément a été modifié ou écrit.
• (Get-Date).AddDays(-30) obtient la date actuelle et soustrait 30 jours.

Scénario 2 – Déplacer des fichiers et dossiers de taille supérieure à une taille spécifique

Cette cmdlet déplace tous les fichiers et dossiers de plus de 2 Go du répertoire C:\Temp vers le répertoire C:\LargeFiles.

      Get-ChildItem -Path C:\Temp\* | Where-Object {$_.Length -gt 2GB} | Move-Item -Destination C:\LargeFiles
      

Maintenir la structure des dossiers

La cmdlet Move-Item ne copie ni ne recrée intrinsèquement toute la structure de dossiers de la source vers le chemin de destination. Cependant, il existe certaines méthodes pour conserver la structure des dossiers lors du déplacement des fichiers vers la destination :

• Associez le cmdlet Move-Item avec d'autres cmdlets, comme Copy-Item et Remove-Item après vérification
• Recréez manuellement la structure des dossiers

Scénario 1 – Déplacer un répertoire avec son contenu et sa structure de dossiers intacte

Pour déplacer un répertoire avec tout son contenu et sa structure de dossiers intacte, consultez la section Déplacer un répertoire.

Scénario 2 – Déplacer des fichiers spécifiques tout en préservant la structure des dossiers

PowerShell supports more complex functions, where you can move specific files while recreating the folder structure at the destination.

      This script moves specific files (e.g., .pdf files) while keeping the folder structure intact:
Get-ChildItem -Path "C:\Temp" -Recurse -Filter "*.pdf" | ForEach-Object {
    $destinationPath = $_.FullName.Replace("C:\Temp", "C:\Backup")
    $destinationDir = Split-Path $destinationPath
    if (-not (Test-Path $destinationDir)) {
        New-Item -ItemType Directory -Path $destinationDir
    }
    Move-Item -Path $_.FullName -Destination $destinationPath
}
      

Ici, Get-ChildItem -Recurse obtient tous les fichiers .pdf dans le répertoire source, y compris les sous-dossiers. ForEach-Object passe en boucle à travers chaque fichier trouvé.

Replace(“C:\Temp”, “C:\Backup”) modifie le chemin source pour créer le chemin correspondant dans la destination, et New-Item -ItemType Directory crée la structure des dossiers si le répertoire de destination n'existe pas.

Gérer les écrasements

Parfois, vous pourriez avoir besoin de remplacer un fichier existant. À cette fin, utilisez le paramètre -Force avec l'applet de commande PowerShell Move-Item.

Scénario 1 – Écraser un fichier à la destination

Cette cmdlet déplace le fichier test.txt du dossier C:\Temp vers le dossier C:\Backup tout en écrasant tout fichier existant à la destination portant le même nom.

      Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\test.txt -Force
      

Scénario 2 – Écraser un fichier à la destination après confirmation

Utilisez le paramètre -Confirm pour obtenir une invite de confirmation avant d'écraser les fichiers.

• Cette cmdlet affiche une invite de confirmation si l'un des fichiers PDF existe déjà dans le dossier de destination.

      Move-Item -Path C:\Temp\*.pdf -Destination C:\Backup -Confirm -Force
      

• Cette cmdlet affiche une invite de confirmation si le fichier test.txt existe déjà dans le dossier de destination.

      Move-Item -Path C:\Temp\test.txt -Destination C:\Backup -Confirm -Force
      

Tapez Y et appuyez sur Entrée pour écraser les fichiers ou tapez N et appuyez sur Entrée pour les ignorer.

Testez les commandes avant exécution

Utilisez le paramètre -WhatIf avec le cmdlet Move-Item pour voir les résultats, c'est-à-dire vérifier ce qui se passerait si le cmdlet est exécuté. Avec ce paramètre, le cmdlet ne s'exécute pas mais les résultats attendus sont affichés. Vous pouvez donc être confiant que le cmdlet ne déplace aucun élément qui n'est pas censé être déplacé.

Scénario 1 – Visualisez le résultat attendu d'un cmdlet sans l'exécuter

Cette cmdlet affiche les résultats lorsque vous essayez d'utiliser la cmdlet Move-Item pour déplacer tous les éléments du dossier C:\Temp vers le dossier Backup.

      Move-Item -Path C:\Temp\* -Destination C:\Backup -WhatIf
      

Gestion des erreurs et journalisation

Vous devriez envisager de mettre en œuvre la gestion des erreurs et la journalisation lorsque vous utilisez le cmdlet Move-Item de PowerShell pour garantir que le script se comporte comme prévu et que les problèmes sont facilement suivis et identifiés. PowerShell fournit :

• Try-Catch pour la gestion des erreurs
• Write-Log pour écrire dans des fichiers journaux

Gestion basique des erreurs avec Try-Catch

Voici un bloc Try-Catch de base pour déplacer un fichier avec gestion des erreurs :

      Try {
    Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\test.txt -ErrorAction Stop
} Catch {
    Write-Output "Error moving file: $_"
}
      

Voici ce que vous devez savoir.

• Le bloc Try tente d'exécuter le cmdlet Move-Item.
• Le paramètre -ErrorAction Stop indique à PowerShell d'arrêter l'action et de lever une erreur en cas de problème (par exemple, le fichier n'existe pas ou il y a des problèmes de permission), et d'entrer dans le bloc Catch.
• -Le bloc Catch attrape l'erreur que la cmdlet Move-Item génère.
• Write-Output affiche le message d'erreur ($_ contient les détails de l'erreur). Vous pouvez également remplacer Write-Output par des fonctions de journalisation telles que Write-Log pour enregistrer l'erreur dans un fichier journal.

Le paramètre -ErrorAction spécifie ce qui doit se passer en cas d'erreur. Les valeurs possibles sont :

• Arrêt – L'opération s'arrêtera en cas d'erreur
• Continuez – L'opération se poursuivra après une erreur
• SilentlyContinue – L'opération ignorera l'erreur sans rien afficher
• Demander – Invite l'utilisateur à saisir des informations lorsqu'une erreur se produit
• Ignorer – Ignore l'erreur

Meilleures pratiques pour la gestion des fichiers avec PowerShell

Limitez le cmdlet à un dossier source et de destination

Le cmdlet Move-Item ne crée pas de dossier ni de structure de répertoire à la destination. Vous ne pouvez pas non plus déplacer deux fichiers portant le même nom provenant de deux emplacements sources différents en même temps. Il est donc préférable de spécifier un dossier source et un dossier de destination dans un cmdlet.

Planifiez l'organisation des fichiers

Vous devez être clair concernant la structure d'organisation de vos fichiers, surtout avant de déplacer des fichiers en masse. Premièrement, le répertoire source doit être organisé avec des fichiers et des dossiers correctement maintenus, ainsi lors du déplacement des éléments, vous savez ce qui est déplacé. Deuxièmement, la structure des dossiers à la destination doit être bien définie, afin que chaque élément se déplace comme souhaité. Cela vous aide à localiser facilement chaque fichier déplacé.

Testez les cmdlets sur des données d'exemple

Testez le cmdlet Move-Item sur des données d'exemple pour vous assurer que les résultats sont conformes aux attentes. Cela aidera à identifier tout oubli concernant les écrasements ou les conflits.

Si vous n'avez pas assez de données d'exemple ou si vous souhaitez gagner du temps, utilisez le paramètre -WhatIf pour simuler le déplacement sans exécuter réellement le cmdlet. De cette manière, vous pouvez tester les cmdlets et les scripts pour voir le résultat avant d'effectuer des modifications.

Gardez des sauvegardes

Par précaution, sauvegardez tous les fichiers et dossiers importants avant d'utiliser le cmdlet Move-Item, en particulier ceux qui écrasent – pour éviter d'être désorienté plus tard.

Mettez en œuvre la journalisation et la gestion des erreurs

La journalisation et la gestion des erreurs sont des outils utiles pour gérer les erreurs inattendues. Leur mise en œuvre aide à identifier et suivre toutes les erreurs dans les opérations Move-Item.

Vous pouvez utiliser soit le paramètre -ErrorAction soit les blocs try-catch dans vos cmdlets pour la gestion des erreurs.

Conclusion

La cmdlet PowerShell Move-Item détient la puissance d'un sorcier lorsqu'il s'agit de gérer et d'organiser des fichiers. Elle s'adresse aussi bien aux utilisateurs novices qu'aux utilisateurs avancés avec une syntaxe simple à sa base, que vous pouvez enrichir avec des paramètres et des scripts. Vous pouvez déplacer un seul fichier, plusieurs fichiers, des fichiers cachés et en lecture seule, un répertoire entier avec tout son contenu vers un autre emplacement, renommer un fichier en le déplaçant, gérer les écrasements, et bien plus encore. La cmdlet prend également en charge la journalisation et la gestion des erreurs pour garantir que les déplacements de fichiers soient fiables et sécurisés.

FAQ

Que se passe-t-il si un fichier portant le même nom existe déjà à la destination ?

Lorsque vous essayez de déplacer un fichier en utilisant la cmdlet Move-Item et qu'un fichier portant le même nom existe déjà dans la destination, alors l'une des situations suivantes se produit :

• La cmdlet Move-Item est exécutée sans le paramètre -Force :

      Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\test.txt
      

Le cmdlet génère une erreur et ne déplace pas le fichier.

• Avec le paramètre -Force :

      Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\test.txt -Force
      

PowerShell écrasera le fichier à destination sans demander de confirmation. Cela remplacera le fichier dans le répertoire de destination par le fichier que vous êtes en train de déplacer.

Consultez la section Handle Overwrites pour plus d'informations.

Puis-je déplacer plusieurs fichiers à la fois ?

Oui, c’est possible avec le Move-Item de PowerShell. Vous pouvez :

• Déplacez des fichiers de la même extension, des fichiers avec des extensions différentes, et tous les fichiers depuis la racine d'un répertoire source. Vous pouvez utiliser la cmdlet suivante pour déplacer tous les fichiers depuis la racine du répertoire source :

      Get-ChildItem -Path C:\Temp\* -File | Move-Item -Destination C:\Backup
      

Consultez la section Move Multiple Files pour plus de détails.

• Pour déplacer récursivement tous les fichiers de la même extension depuis le répertoire source, utilisez cette cmdlet :

      Get-ChildItem -Path C:\Temp\*.pdf -Recurse | Move-Item -Destination C:\Backup
      

Consultez la section Recursive File Moving pour plus de détails.

• Déplacez le répertoire source avec tout son contenu en utilisant cette cmdlet :

      Move-Item -Path C:\Temp -Destination C:\Backup
      

Consultez la section Move a Directory pour plus de détails.

Comment déplacer des fichiers avec des attributs spécifiques ?

Le cmdlet Move-Item peut déplacer des fichiers en fonction de critères spécifiques, tels que la taille du fichier, la date de modification, etc. Voici une liste des attributs communs sur lesquels vous pouvez filtrer :

• Caché
• ReadOnly
• Archive
• Compressé
• Chiffré

Utilisez-les dans le filtre Where-Object pour cibler les fichiers avec ces attributs. Vous pouvez également combiner plusieurs conditions en utilisant -and ou -or dans Where-Object pour filtrer les fichiers avec plusieurs attributs.

Consultez les rubriques Filtre de fichiers et Scénarios de déplacement avancés pour plus d'informations.

Puis-je utiliser Move-Item pour déplacer des fichiers entre différents lecteurs ?

La réponse simple est oui. Les fichiers seront déplacés vers l'emplacement que vous avez spécifié comme destination, que ce soit le même que le lecteur source ou un lecteur différent.

Comment déplacer un fichier et le remplacer en utilisant Move-Item ?

Si vous souhaitez écraser un fichier à la destination avec un fichier que vous déplacez, utilisez le paramètre -Force avec Move-Item. Par exemple :

      Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\test.txt -Force
      

PowerShell remplacera le fichier test.txt dans le dossier Backup par le fichier test.txt du dossier Temp sans demander de confirmation. Consultez la section Gérer les écrasements pour plus d'informations.

Comment puis-je déplacer des fichiers cachés en utilisant PowerShell ?

Lors du déplacement d'un dossier ou de plusieurs fichiers de la même extension, la cmdlet Move-Item ne déplace pas les fichiers cachés ou en lecture seule. Utilisez la cmdlet Get-ChildItem avec le paramètre -Force pour inclure les fichiers cachés et systèmes dans le résultat, puis redirigez les résultats vers Move-Item.

Vous pouvez utiliser cette cmdlet, par exemple, pour déplacer tous les fichiers, y compris les fichiers cachés.

      Get-ChildItem -Path C:\Temp\ -Force | Move-Item -Destination C:\Backup\
      

Pour déplacer spécifiquement les fichiers cachés (et non les fichiers visibles), utilisez cette applet de commande :

      Get-ChildItem -Path C:\Temp\ -Force | Where-Object { $_.Attributes -match 'Hidden' } | Move-Item -Destination C:\Backup\
      

Comme vous avez ajouté une condition pour filtrer les fichiers cachés, le cmdlet déplace uniquement les fichiers qui ont l'attribut « Hidden » défini.

Quelles sont les erreurs courantes lors de l'utilisation de Move-Item et comment puis-je les dépanner ?

Voici ci-dessous quelques erreurs courantes accompagnées de leur explication et solution.

Le fichier existe déjà

Lorsque vous essayez de déplacer un fichier ou un dossier vers une destination où un fichier portant le même nom existe déjà, l'erreur suivante s'affiche :

      Move-Item : Cannot create a file when that file already exists.
      

Utilisez le paramètre -Force pour écraser le fichier existant.

Accès refusé

Lorsque vous n'avez pas les autorisations nécessaires pour déplacer le fichier, l'erreur suivante s'affiche :

      Move-Item : Access to the path 'C:\Path\to\file.txt' is denied.
      

Il pourrait y avoir de nombreuses raisons à cela, comme le fait que le fichier soit protégé, que le dossier de destination nécessite des privilèges d'administrateur ou que le fichier soit utilisé par un autre processus.

Pour résoudre le problème, assurez-vous d'avoir les autorisations nécessaires. Il est recommandé d'exécuter PowerShell en tant qu'administrateur. De plus, assurez-vous que le fichier n'est pas utilisé par une autre application.

Fichier verrouillé par un autre processus

Lorsque le fichier à déplacer est utilisé par un autre programme ou processus, l'erreur suivante est affichée :

      Move-Item : The process cannot access the file because it is being used by another process.
      

Pour résoudre le problème, fermez toutes les applications utilisant le fichier.

Chemin trop long

Par défaut, Windows a une longueur maximale de chemin de 260 caractères, et Move-Item échouera si le chemin source ou de destination dépasse cette limite. PowerShell affiche l'erreur suivante :

      Move-Item : The specified path, file name, or both are too long.
      

Pour résoudre le problème, utilisez soit des noms de répertoire ou de fichier plus courts, soit activez la prise en charge des chemins longs dans Windows 10/11 ou Windows Server via Group Policy ou le registre.

Chemin ou nom de fichier invalide

Lorsque le chemin source ou le chemin de destination est incorrect, mal orthographié ou n'existe pas, l'erreur suivante s'affiche :

      Move-Item : Cannot find path 'C:\InvalidPath\file.txt' because it does not exist.
      

Vérifiez bien le chemin.

Le répertoire de destination n'existe pas

Lorsque le répertoire de destination n'existe pas, l'erreur suivante s'affiche :

      Move-Item : Could not find part of the path 'C:\Backup\'
      

Make sure the destination directory exists. Else create it before moving the files.

Déplacer un répertoire dans lui-même

PowerShell ne vous permet pas de déplacer un répertoire dans l'un de ses sous-répertoires. Lorsque vous essayez de le faire, l'erreur suivante s'affiche :

      Move-Item : Cannot move item 'C:\Temp\' to a subdirectory of itself, 'C:\Temp\Logs\'.
      

Assurez-vous que la destination n'est pas un sous-dossier du répertoire source.

Est-il possible de déplacer des fichiers en fonction de leur contenu ?

Par lui-même, la cmdlet Move-Item ne peut pas déplacer des fichiers en fonction de leur contenu. Vous pouvez cependant utiliser Get-Content ou d'autres méthodes de lecture de fichiers avec une logique conditionnelle (telle que des instructions If-Else) pour lire le contenu d'un fichier puis utiliser Move-Item pour déplacer le fichier en conséquence.

Voici un exemple de script qui vérifie si un fichier contient un mot ou une phrase spécifique. Si oui, il déplace le fichier.

Remarque : Effectuez les modifications suivantes avant d'exécuter le script :

• Modifiez la variable $searchString pour correspondre au contenu que vous souhaitez filtrer.
• Modifiez $sourceDirectory et $destinationDirectory par les chemins appropriés.

      $sourceDirectory = "C:\SourceFolder"
$destinationDirectory = "C:\DestinationFolder"
$searchString = "SpecificText"
# Get all files in the source directory
Get-ChildItem -Path $sourceDirectory -File | ForEach-Object {
    $filePath = $_.FullName
    # Read the content of the file
    $content = Get-Content -Path $filePath
    # Check if the file contains the search string
    if ($content -match $searchString) {
        # Move the file to the destination directory
        $destinationPath = Join-Path -Path $destinationDirectory -ChildPath $_.Name
        Move-Item -Path $filePath -Destination $destinationPath
        Write-Host "Moved file: $filePath to $destinationPath"
    }
    else {
        Write-Host "File does not contain search string: $filePath"
    }
}
      

Get-ChildItem récupère tous les fichiers du dossier source et ForEach-Object les parcourt un par un. Get-Content lit le contenu de chaque fichier pour vérifier si le contenu correspond à la chaîne spécifiée. Ensuite, Move-Item déplace les fichiers contenant la chaîne vers le dossier de destination.

Que se passe-t-il si le fichier que j'essaie de déplacer n'existe pas ou si le chemin source n'est pas valide ?

Dans les deux cas, PowerShell générera une erreur.

      Move-Item : Cannot find path 'C:\Temp\AppLog.txt' because it does not exist.
      

De même, si un élément du chemin de destination n'existe pas, la cmdlet échoue. Elle ne crée pas un répertoire manquant ni aucun élément du chemin.

Une bonne idée est d'exécuter Test-Path pour vérifier si le fichier existe. Cette cmdlet renvoie $true si tous les éléments du chemin existent et $false s'il en manque.

      Test-Path -Path C:\Backups\AppLogs
      

False