Validation de l’existence des fichiers PowerShell : Guide complet

Utilisez-vous PowerShell pour créer, lire, mettre à jour et supprimer des fichiers ? Si oui, vous avez probablement rencontré des erreurs lorsque les fichiers cibles n’existent pas ou existent déjà. Heureusement pour vous, il existe des moyens en PowerShell pour vérifier si un fichier existe avant de faire quoi que ce soit avec.

Par exemple, au lieu de laisser votre code créer le fichier immédiatement, il est préférable de vérifier si le fichier existe déjà. Comme le montre la capture d’écran ci-dessous, vous pouvez écrire un meilleur code et obtenir une sortie claire.

Dans cet article, vous apprendrez les différentes façons d’utiliser PowerShell pour vérifier si un fichier existe. Vous apprendrez également comment utiliser chacune de ces méthodes pour produire un meilleur code et des résultats avec une logique de gestion des erreurs.

Prérequis

Réduisez les appels au service desk et mettez à jour les informations d’identification du cache pour les utilisateurs distants même hors VPN avec une solution de réinitialisation de mot de passe en libre-service. Demandez une démo de Specops uReset !

Cet article est un guide pratique dans lequel vous apprendrez à partir de différents exemples. Et pour suivre les exemples, vous aurez besoin des éléments suivants :

• Éditeur de code. Les recommandés sont Visual Studio Code et Atom, qui fonctionnent sur différentes plateformes. Vous pouvez également utiliser Windows PowerShell ISE si vous travaillez sur un ordinateur Windows.
• Windows PowerShell 5.1 (Desktop) ou PowerShell 7.1 (Core). Les commandes et scripts de cet article s’appliquent aux deux éditions de PowerShell. Que vous utilisiez Windows, Linux ou macOS, vous serez bien tant que vous avez PowerShell installé.

Connexe : Comment télécharger et installer PowerShell 7 sur Windows, Linux et macOS

Utiliser PowerShell pour vérifier si un fichier existe

Cet article couvre trois méthodes avec lesquelles utiliser PowerShell pour vérifier si un fichier existe. L’utilisation de ces trois méthodes diffère, mais le concept et l’objectif final sont les mêmes. Ces trois façons sont les suivantes :

• Test-Path Cmdlet.
• Get-Item et Get-ChildItem Cmdlet.
• System.IO.File Class.

Il y aura des exemples et des démonstrations de chacune de ces trois méthodes, y compris comment les utiliser avec la gestion des erreurs.

Utiliser Test-Path

La première méthode est le cmdlet Test-Path, spécifiquement conçu pour déterminer si un chemin ou un fichier existe. Lorsque vous utilisez ce cmdlet pour vérifier si un fichier existe, le résultat est true ou false. Le résultat indique si le fichier existe ou non.

Voici la syntaxe de base pour faire fonctionner le cmdlet Test-Path avec la vérification d’un fichier.

Test-Path -Path <PATH to FILE> -PathType Leaf

Par exemple, si vous devez vérifier qu’un fichier portant le nom C:\temp\important_file.txt existe, utilisez le code ci-dessous. Remarquez que la partie -PathType Leaf indique à la cmdlet de vérifier explicitement s’il s’agit d’un fichier et non d’un répertoire.

Test-Path -Path C:\temp\important_file.txt -PathType Leaf

Lorsque vous exécutez la commande ci-dessus dans PowerShell, le résultat renvoie Vrai si le fichier existe. Sinon, le résultat serait Faux, comme vous pouvez le voir sur la capture d’écran ci-dessous.

Connexe: Comment utiliser la cmdlet Test-Path PowerShell

Exemple : Création d’un fichier si le fichier n’existe pas

Cet exemple est un cas d’utilisation typique pour créer des fichiers à un emplacement spécifié. Pour éviter l’erreur « le fichier existe déjà« , le script vérifie si le fichier existe déjà avant de le créer. Si le fichier existe, le script affiche un message et n’essaie pas de créer le fichier.

Copiez le code ci-dessous et enregistrez-le dans un fichier appelé Create-NewFile.ps1. Assurez-vous de changer la valeur de la variable $path si vous souhaitez modifier l’emplacement de sortie du fichier. Après avoir enregistré le script, exécutez-le dans PowerShell pour le tester.

# Create-NewFile.ps1

# Chemin complet du fichier
$file = 'c:\temp\important_file.txt'

# Si le fichier n'existe pas, créez-le.
if (-not(Test-Path -Path $file -PathType Leaf)) {
     try {
         $null = New-Item -ItemType File -Path $file -Force -ErrorAction Stop
         Write-Host "The file [$file] has been created."
     }
     catch {
         throw $_.Exception.Message
     }
 }
# Si le fichier existe déjà, affichez le message et ne faites rien.
 else {
     Write-Host "Cannot create [$file] because a file with that name already exists."
 }

La capture d’écran ci-dessous montre les deux sorties différentes. La première survient lors de l’exécution du script alors que le fichier n’existe pas. La seconde se produit après la création du fichier, lorsqu’il existe déjà.

Connexe : Retour aux bases : Comment exécuter un script PowerShell

Utilisation de Get-Item et Get-ChildItem

Le but de la cmdlet Get-Item est de récupérer l’élément à un emplacement spécifié. En comparaison, la cmdlet Get-ChildItem permet de récupérer les éléments et sous-éléments dans un ou plusieurs emplacements spécifiés. La fonctionnalité de ces deux cmdlets n’est pas explicitement de vérifier si les fichiers existent.

Que se passe-t-il lorsque vous utilisez Get-Item ou Get-ChildItem pour obtenir un élément qui n’existe pas ? Vous obtiendrez une erreur pour chaque fichier manquant. Prenez les commandes ci-dessous comme exemple.

$file = 'c:\temp\important_file.txt'
Get-Item -Path $file
Get-ChildItem -Path $file

Supposons que le fichier c:\temp\important_file.txt n’existe pas. Chacune des commandes ci-dessus renvoie une erreur. Comme le montre l’exemple ci-dessous, le message d’erreur pour les deux commandes est le même.

Exemple : Archiver le fichier existant et créer un nouveau fichier

Dans cet exemple, le script utilise les cmdlets Get-Item et Test-Path. La logique de ce script est la suivante :

• Testez si le dossier d’archive existe en utilisant Test-Path.
  • Si le dossier d’archive n’existe pas, le script crée un nouveau dossier d’archive dans ce format – yyyy-MMM-dd_hh-mm-ss-tt.
  • Ensuite, le script déplace l’ancien fichier vers le dossier d’archive.
• Testez si le fichier existe déjà en utilisant Get-Item.
  • Si le fichier existe, le script le déplace d’abord vers le dossier d’archive. Ensuite, le script crée le nouveau fichier à l’emplacement d’origine.
  • Si le fichier n’existe pas, le script crée le nouveau fichier.

Copiez le code ci-dessous et enregistrez-le sous Create-NewFileAfterArchive.ps1. Après avoir enregistré le script, exécutez-le dans PowerShell et vérifiez les résultats.

# Create-NewFileAfterArchive.ps1

# Chemin complet du fichier
$file = 'c:\temp\important_file.txt'

# Chemin complet vers le dossier d'archivage
$archiveFolder = "c:\temp\archive_$(get-date -Format 'yyyy-MMM-dd_hh-mm-ss-tt')\"

# Si le fichier existe, déplacez-le vers le dossier d'archivage, puis créez un nouveau fichier.
if (Get-Item -Path $file -ErrorAction Ignore) {
    try {
        ## Si le dossier d'archivage n'existe pas, créez-le maintenant.
        if (-not(Test-Path -Path $archiveFolder -PathType Container)) {
            $null = New-Item -ItemType Directory -Path $archiveFolder -ErrorAction STOP
        }
        ## Déplacer le fichier existant vers l'archive.
        Move-Item -Path $file -Destination $archiveFolder -Force -ErrorAction STOP
        Write-Host "The old file [$file] has been archived to [$archiveFolder]"
     } catch {
        throw $_.Exception.Message
     }
 }
 Create the new file
 try {
     $null = New-Item -ItemType File -Path $file -Force -ErrorAction Stop
     Write-Host "The new file [$file] has been created."
 } catch {
    Write-Host $_.Exception.Message
 }

Astuce : Le paramètre -ErrorAction Ignore supprime l’erreur (ne s’affiche pas dans la console) et ne la stocke pas non plus dans la variable automatique $error.

Dans la capture d’écran ci-dessous, le premier script exécuté a créé le fichier c:\temp\important_file.txt. Les exécutions de script suivantes ont créé un nouveau dossier d’archive à chaque fois, déplacé le fichier existant vers le dossier d’archive, puis créé un nouveau fichier dans c:\temp\important_file.txt.

Utilisation de la méthode .NET [System.IO.File]::Exists()

La dernière méthode à apprendre dans cet article est la classe .NET System.IO.File, en particulier la méthode Exists(). Une des forces de PowerShell est sa capacité à importer et à utiliser des classes et des méthodes .NET.

Par exemple, pour utiliser la méthode Exists() dans PowerShell pour vérifier si un fichier existe, utilisez le code ci-dessous.

[System.IO.File]::Exists("PATH")

La méthode ci-dessus produit un résultat booléen – vrai ou faux. Si le résultat renvoie vrai, cela signifie que le fichier cible existe. Sinon, le résultat renvoyé est faux lorsque le fichier cible n’existe pas.

Dans le code d’exemple ci-dessous, la commande vérifie l’existence du fichier c:\temp\important_file.txt.

$file = 'c:\temp\important_file.txt'
[System.IO.File]::Exists($file)

Comme vous pouvez le voir dans le résultat ci-dessous, le résultat renvoie vrai, confirmant que le fichier existe.

Avec cette méthode .NET, vous pouvez également utiliser des opérations ternaires comme dans l’exemple ci-dessous. Au lieu d’afficher les résultats vrais ou faux par défaut, vous pouvez personnaliser le message de résultat avec une implémentation plus courte. Cependant, l’opérateur ternaire dans cet exemple ne s’applique qu’à PowerShell 7+.

$file = 'c:\temp\important_file.txt'
[System.IO.File]::Exists($file) ? "The file exists." : "The file does not exist."

Exemple : Mise à jour du contenu du fichier si le fichier existe

Ce script d’exemple met à jour le fichier texte en ajoutant une nouvelle valeur GUID. Cependant, la mise à jour du contenu n’a lieu que si le fichier existe. Sinon, le script affiche un message et ne fait rien d’autre.

Copiez le script ci-dessous et enregistrez-le sous le nom Update-FileContents.ps1. Modifiez la valeur du chemin d’accès au fichier de la variable $file si nécessaire. Ensuite, exécutez le script dans PowerShell pour le tester.

# Mise à jour-FileContents.ps1

#Chemin complet du fichier
$file = 'c:\temp\important_file.txt'

#Si le fichier existe, ajoutez une nouvelle valeur GUID dans le fichier.
if ([System.IO.File]::Exists($file)) {
    try {
        $newValue = ((New-Guid).Guid)
        Add-Content -Path $file -Value $newValue -ErrorAction STOP
        Write-Host "The file [$file] has been updated with [$newValue]"
     } catch {
        throw $_.Exception.Message
     }    
 }

#Si le fichier n'existe pas, affichez un message et ne faites rien.
 else {
     Write-Host "The file [$file] could not be updated because it does not exist."
 }

Vous pouvez voir dans la capture d’écran ci-dessous que le script a mis à jour le fichier à chaque exécution. La mise à jour a eu lieu car la méthode [System.IO.File]::Exists() a confirmé que le fichier c:\temp\important_file.txt existe.

En fin de compte, en utilisant la commande gc c:\temp\important_file.txt pour lire le contenu du fichier, il a été confirmé que le script a mis à jour le fichier avec les valeurs GUID.

Connexe: Utilisation des accélérateurs de types de données PowerShell pour accélérer la codification

Conclusion

Réduisez les appels au service d’assistance et mettez à jour les informations d’identification du cache pour les utilisateurs distants même hors VPN avec une solution de réinitialisation de mot de passe en libre-service. Obtenez une démonstration de Specops uReset !

Dans cet article, vous avez appris qu’il existe plus d’une façon d’utiliser PowerShell pour vérifier si un fichier existe. Il est bon de vérifier la présence d’un fichier avant de procéder à des modifications liées aux fichiers.

Vous avez appris à utiliser les cmdlets Get-Item, Get-ChildItem et Test-Path. Ainsi que la méthode [System.IO.File]::Exists() .NET. Les exemples vous ont montré comment utiliser ces techniques et comment les combiner avec une logique de gestion des erreurs.

Arrêtez de subir ces messages d’erreur. Surmontez-les en ajoutant du code pour vérifier si un fichier existe avant toute opération liée aux fichiers. Les techniques que vous avez apprises ici ne couvrent que les bases, et il vous appartient maintenant de les améliorer.