PowerShell et tout ce que vous devez savoir sur cet utilitaire

Et si votre PC pouvait gérer les tâches les plus simples à votre place ? Avec Windows PowerShell, c'est possible. Voici comment utiliser PowerShell pour automatiser les tâches quotidiennes répétitives que personne ne souhaite répéter sans cesse.

Table des matières

• Qu'est-ce que PowerShell ?
• Un bref historique des utilitaires de ligne de commande Windows
• Présentation des outils, commandes et modules PowerShell
  • Outils PowerShell
  • applets de commande dans PowerShell
  • Modules dans PowerShell
  • Gestion des fichiers et des dossiers
• Paramètres PowerShell expliqués
• Créer un pipeline
• Enregistrer le pipeline en tant que script PS1
• Exemple de script PowerShell
• Comment PowerShell vous aide à automatiser tout sur votre PC
  • Écrire des scripts PowerShell simples
  • Écrivez un script PowerShell pour organiser automatiquement les fichiers quotidiennement
  • Planifier et exécuter des tâches

Qu'est-ce que PowerShell ?

Microsoft PowerShell est un utilitaire de ligne de commande et un langage de script puissant permettant aux administrateurs d'automatiser un large éventail de tâches sur les ordinateurs et les réseaux. PowerShell intègre des composants de l'invite de commande et repose sur le framework .NET. Si vous lisez l'article de WebTech360, sachez que PowerShell est l'outil de prédilection des administrateurs informatiques pour gérer de grands réseaux.

Apprendre à utiliser PowerShell simplifiera de nombreuses tâches quotidiennes fastidieuses. Vous pouvez également apporter des modifications à l'échelle du système sur le réseau sans avoir à configurer chaque serveur individuellement. PowerShell devient un élément essentiel de l'exploitation d'environnements cloud hybrides .

PowerShell offre de nombreuses possibilités pour vous aider à travailler plus efficacement et à assurer le bon fonctionnement de votre réseau. Parmi les utilisations les plus courantes, on peut citer : la planification de mises à jour quotidiennes des systèmes, la génération de rapports sur les processus en cours, les services périodiques, etc. Si la plupart de ces tâches peuvent être effectuées via l'interface graphique, l'objectif de PowerShell est de les accélérer.

Si vous avez une tâche de maintenance de routine qui prend quelques minutes à configurer, vous pouvez scripter la même fonctionnalité dans une seule commande, appelée PowerShell. Ainsi, à la prochaine ouverture de ce script, il s'exécutera en arrière-plan. Maîtriser la logique de script PowerShell, comprendre le fonctionnement des objets et des variables (var) et le déployer intelligemment sur votre réseau vous fera vous demander pourquoi vous n'avez pas utilisé PowerShell plus tôt.

Ce tutoriel présente les bases de PowerShell, utiles aux débutants en informatique, notamment ceux qui maîtrisent l'invite de commandes Windows. Il explique comment utiliser les outils et commandes de base, gérer les fichiers et les dossiers, comprendre les objets, utiliser les variables et gérer les serveurs distants.

Un bref historique des utilitaires de ligne de commande Windows

Après la sortie de Windows NT, CMD.EXE est devenu l'utilitaire de ligne de commande de Windows. Bien que CMD.EXE ait hérité de certains éléments de son prédécesseur DOS (COMMAN.COM), il reposait toujours sur un langage de script plutôt « primitif » : l'utilisation de fichiers de commandes Windows (.CMD et .BAT). L'ajout de Windows Scripting Host et des langages VBScript et JScript a considérablement amélioré les capacités de script de l'utilitaire.

Ces technologies constituent un mélange équilibré d'utilitaires de ligne de commande avancés et d'environnements de script. Le véritable problème n'est pas le nombre de fichiers CMD.EXE, .CMD et Windows Scripting Host qu'elles permettent de manipuler. Leur principale préoccupation réside dans l'exécution de tâches apparemment simples.

Utilisant un « framework » d'outils de ligne de commande et de script, tout script relativement complet nécessite une combinaison de commandes batch, de Windows Scripting Host et d'exécutables autonomes. Chaque script utilise des conventions différentes pour l'exécution, les requêtes, l'analyse et le retour de données.

Une faible prise en charge des variables dans CMD.EXE, des interfaces incohérentes et un accès limité aux paramètres Windows, combinés à une autre faiblesse, rendent les scripts en ligne de commande difficiles à implémenter et à utiliser. Quelle est cette « autre faiblesse », me direz-vous ? Le texte. Dans ces technologies, tout est texte. Le résultat d'une commande ou d'un script est du texte et doit être analysé et reformaté pour servir d'entrée à la commande suivante. C'est le point de départ de PowerShell, issu de tous les shells traditionnels.

Présentation des outils, commandes et modules PowerShell

Les trois concepts présentés dans cette section constituent les bases essentielles pour comprendre les concepts clés de PowerShell. Vous devrez consacrer plus de temps à l'apprentissage et à la maîtrise des concepts plus avancés à mesure que vous maîtriserez les commandes PowerShell.

Outils PowerShell

PowerShell est installé par défaut sous Windows 10, Windows 7, Windows Server 2008 R2 et les versions plus récentes de Windows. Les versions plus récentes de PowerShell ajoutent de nouvelles fonctionnalités et des « applets de commande » (terme Microsoft désignant les commandes PowerShell, prononcé « command-lets ») et sont installées avec la version correspondante de Windows Management Framework (WMF).

Actuellement, WMF 5.1 est la dernière version recommandée. Dans certains cas, certaines nouvelles fonctionnalités dépendent du système d'exploitation, en plus de la version de WMF. Par exemple, Windows 8 et Windows Server 2012 prennent en charge l'applet de commande Test-NetConnection, qui permet de tester la connectivité à un port TCP/IP spécifique . Cependant, cette applet de commande n'est pas disponible sous Windows 7, même avec la dernière version de WMF.

Sur la plupart des systèmes Windows, les utilisateurs disposent de deux environnements PowerShell : la console PowerShell et l'environnement de script intégré (ISE). La console PowerShell ressemble à une ligne de commande classique, mais avec toutes les fonctionnalités de PowerShell. Les noms de variables, les boucles, la saisie semi-automatique des commandes et le piping sont tous disponibles depuis la console PowerShell.

Pour une utilisation plus avancée (comme la création de scripts), PowerShell ISE propose la saisie semi-automatique des commandes, la mise en surbrillance du code et la saisie semi-automatique Intellisense de Microsoft pour vous aider à créer et tester du code PowerShell. PowerShell ISE vous permet également d'utiliser plusieurs scripts PowerShell simultanément grâce à la navigation par onglets.

applets de commande dans PowerShell

La base des commandes PowerShell est l'applet de commande. Microsoft a adopté plusieurs stratégies de conception lors de la création d'applets de commande dans PowerShell.

Le premier avantage est la possibilité de déduire facilement les noms des applets de commande, ou du moins de les rendre plus faciles à repérer. Les commandes ou applets de commande PowerShell sont également conçues pour être plus faciles à utiliser, avec une syntaxe standardisée, ce qui facilite la création de scripts depuis l'interface de ligne de commande.

Les applets de commande utilisent le format verbe-nom, comme dans Get-Service, Stop-Service ou Import-Csv. La partie verbale du nom de l'applet de commande indique l'action effectuée sur le nom. Généralement, les applets de commande utilisées pour récupérer des informations contiennent le verbe « Get », comme Get-Process ou Get-Content . Les commandes de modification commencent généralement par le verbe « Set » , et celles permettant d'ajouter une nouvelle entité commencent généralement par « Add » ou « New » .

Deuxièmement, les paramètres couramment utilisés dans PowerShell reçoivent également des noms standardisés. Par exemple, le paramètre -ComputerName permet d'exécuter l'applet de commande sur un ou plusieurs ordinateurs distants. -Credential permet de fournir un objet d'authentification contenant les informations d'identification de l'utilisateur, afin d'exécuter la commande sous un nom d'utilisateur spécifique.

Modules dans PowerShell

Vous pouvez utiliser des alias pour les applets de commande et les paramètres afin d'économiser les frappes et de raccourcir la longueur globale de la commande (utile pour enchaîner plusieurs commandes). Bien que ces alias n'utilisent pas toujours les conventions de nommage standard, ils reflètent néanmoins les utilitaires de ligne de commande traditionnels.

Dans PowerShell, les alias tels que DIR, CD, DEL et CLS correspondent respectivement aux applets de commande Get-ChildItem, Set-Location, Remove-Item et Clear-Host. Les alias de paramètres peuvent fonctionner de deux manières : ils peuvent utiliser un alias prédéfini fourni par l'applet de commande, ou être créés en saisissant suffisamment de caractères pour créer une correspondance unique entre les paramètres pris en charge par l'applet de commande.

Gestion des fichiers et des dossiers

La plupart des administrateurs système sont amenés à manipuler des fichiers et des dossiers dans le cadre de leur travail, qu'il s'agisse de déplacer un dossier vers un autre emplacement sur le serveur, d'archiver des fichiers journaux ou de rechercher des fichiers volumineux. Lorsque les mêmes opérations sont répétées sur de nombreux fichiers, l'utilisation de PowerShell pour les automatiser constitue une solution efficace et rapide.

Pour rechercher des fichiers et des dossiers, l'un des premiers outils en ligne de commande qu'un administrateur utilisait autrefois était la commande dir. Dir liste les fichiers et dossiers contenus dans le répertoire spécifié.

PowerShell propose une commande similaire : l'applet de commande Get-ChildItem . Get-ChildItem permet de créer rapidement une liste de fichiers dans un répertoire, de manière à pouvoir les manipuler via une commande pipe ou affecter la sortie à une variable.

Get-ChildItem peut être utilisé simplement en fournissant un chemin, soit via un pipeline, soit avec le paramètre -Path , soit directement après le nom de l'applet de commande. Pour modifier la réponse renvoyée par Get-ChildItem, il est nécessaire de prendre en compte certains paramètres fournis par l'applet de commande.

Le paramètre -Filter permet de rechercher des fichiers. Par défaut, Get-ChildItem ne renvoie que les enfants directs du répertoire cible. Cette fonctionnalité peut être étendue grâce au paramètre -Recurse , qui recherche de manière récursive les répertoires contenus dans le répertoire courant.

Dans PowerShell 4.0, Get-ChildItem permet désormais de limiter les résultats aux fichiers ou aux répertoires à l'aide des commutateurs –File ou –Directory . Les versions précédentes de PowerShell devaient transmettre les résultats à Where-Object, en filtrant sur la propriété PSIsContainer pour effectuer cette détermination. Un exemple des deux techniques utilisées pour renvoyer les répertoires contenus dans C:\Users est présenté ici :

Get-ChildItem C:Users -Directory Get-ChildItem C:Users | Where-Object {$_.PSIsContainer –eq $true}

Pour détecter les fichiers cachés ou système, utilisez l'option  -Force . Get-ChildItem dans PowerShell 4.0 et versions ultérieures permet également de renvoyer uniquement les fichiers cachés, en lecture seule ou système, à l'aide des options -Hidden, -ReadOnly et –System respectivement. Une fonctionnalité similaire était possible dans les versions précédentes en filtrant la propriété Mode avec Where-Object :

Get-ChildItem C:Users | Where-Object {$_.Mode -like '*R*'}

Vérifier si le fichier existe

Normalement, lorsque nous travaillons avec des fichiers, il suffit de savoir si le fichier existe ou si le chemin d'accès au répertoire est valide. PowerShell fournit une applet de commande pour cela : Test-Path, qui renvoie la valeur true ou false.

Test-Path est utilisé comme mesure de précaution avant de tenter de copier ou de supprimer un fichier spécifique.

Copier, déplacer et supprimer des fichiers

Copy-Item : copie un ou plusieurs fichiers ou répertoires d'un emplacement, spécifié par le paramètre -Path, vers l'emplacement spécifié par l'option -Destination.

Déplacer l'élément : déplacer un fichier ou un dossier.

Lors de la copie ou du déplacement d'une structure de répertoire, l'option -Recurse doit être utilisée pour que l'applet de commande exécute l'action sur le répertoire et son contenu. Dans certains cas, l'option -Force est également requise , par exemple lorsqu'un fichier en lecture seule est écrasé par une opération de copie.

Supprimer l'élément : supprimer un fichier, un dossier.

Le commutateur -Force doit être utilisé lors de la rencontre d'un fichier en lecture seule et -Recurse doit être utilisé lors de la suppression d'un répertoire et de son contenu.

Utilisation de PowerShell -WhatIf et -Confirm

Avant d'effectuer une suppression massive et importante, utilisez -WhatIf . -WhatIf vous permet d'anticiper les conséquences de l'exécution d'un script ou d'une commande, et d'anticiper les conséquences négatives potentielles de la suppression de données métier importantes. Il est également important de noter que -WhatIf ne se limite pas aux opérations sur les fichiers : il est largement utilisé dans PowerShell.

Pour les scripts que vous souhaitez exécuter manuellement, ou pire, dont les commandes dépendantes s'exécutent manuellement, pensez à utiliser -Confirm . Cela vous permet de demander une intervention de l'utilisateur avant que l'opération ne soit réellement effectuée.

Scripts PowerShell = fichiers batch sur stéroïdes

PowerShell est écrit en langage .NET et s'appuie fortement sur le .NET Framework. Il est ainsi conçu comme un shell orienté objet et un langage de script. Tout dans PowerShell est traité comme un objet, bénéficiant de toutes les fonctionnalités du .NET Framework. Une commande expose une collection d'objets exploitables grâce aux propriétés et méthodes de ce type d'objet. Lorsque vous souhaitez canaliser la sortie d'une commande vers une autre, PowerShell transmet l'objet, et pas seulement le texte de la première commande. La commande suivante bénéficie ainsi d'un accès complet à toutes les propriétés et méthodes de l'objet dans le pipeline.

Traiter tout comme un objet et accepter des objets entre les commandes constitue un changement majeur dans la théorie des utilitaires en ligne de commande. Cela dit, PowerShell fonctionne toujours comme un shell traditionnel. Les commandes, scripts et exécutables peuvent être saisis et exécutés depuis la ligne de commande, et les résultats sont affichés sous forme de texte. Les fichiers Windows .CMD et .BAT, les VBScripts, les JScripts et les exécutables exécutés dans CMD.EXE fonctionnent toujours dans PowerShell. Cependant, n'étant pas orientés objet, ils n'ont pas un accès complet aux objets créés et utilisés dans PowerShell. Ces anciens scripts et exécutables traiteront toujours tout comme du texte, mais vous pouvez combiner PowerShell avec plusieurs autres technologies. Ceci est particulièrement important si vous souhaitez commencer à utiliser PowerShell avec un ensemble de scripts existants que vous ne pouvez pas tous convertir en une seule fois.

Paramètres PowerShell expliqués

Les applets de commande peuvent accepter des paramètres pour modifier leur comportement. Lors de l'exécution d'une applet de commande ou d'une fonction, vous pouvez fournir des valeurs de paramètres pour spécifier quoi, quand, où et comment chaque commande PowerShell s'exécute.

Par exemple, Get-Process récupérera et listera tous les processus en cours d'exécution dans votre système d'exploitation :

Mais que faire si vous souhaitez obtenir un processus spécifique ? Vous pouvez le faire à l'aide de paramètres. Par exemple, pour obtenir tous les processus Slack, vous pouvez utiliser le paramètre Name avec l'applet de commande Get-Process :

Get-Process -Name Slack

Vous ne verrez alors que les processus nommés « slack » :

Astuce : Certains paramètres sont « positionnels », ce qui signifie que leurs noms sont facultatifs. Dans ce cas, Get-Process -Name Slack et Get-Process Slack effectuent la même tâche.

Chaque applet de commande accepte différents types de paramètres. Utilisez la commande Get-Help pour afficher les paramètres acceptés de l'applet de commande dans la section SYNTAXE.

Get-Help Get-Process

Vous verrez une liste de toutes les manières possibles d’exécuter l’applet de commande donnée :

Dans ce cas, l'applet de commande Get-Process accepte des paramètres tels que Name, Id, ComputerName, Module, FileVersionInfo et d'autres paramètres courants. Les symboles ici signifient :

Les paramètres acceptent un ensemble de valeurs indiquant le type de données requis, comme une chaîne, un entier, un booléen ou une date/heure. Par exemple, la commande suivante :

Get-Process [[-Name] ]

... signifie que le paramètre Nom accepte une ou plusieurs valeurs de chaîne, alors que cette commande :

Get-Process -Id 

... signifie que le paramètre Id accepte une ou plusieurs valeurs entières.

L'exemple Get-Process précédent utilisait le paramètre Name pour affiner les résultats. Cependant, pour affiner la recherche sur un processus plus spécifique, vous pouvez utiliser le paramètre ID , qui requiert un entier, comme indiqué dans sa syntaxe.

Get-Process -Id 3016

Vous ne verrez alors qu’un seul processus dans la liste :

Créer un pipeline

PowerShell traite toutes les données comme des objets. Pour créer un script, ces objets sont exécutés via une série d'applets de commande ou de fonctions connectées par le symbole de la barre verticale (|). Choisir les applets de commande appropriées et les connecter dans une séquence logique à l'aide d'un pipeline est essentiel pour un script efficace.

Imaginez que vous créiez un script pour trier et afficher les cinq fichiers les plus volumineux d'un répertoire. Il existe des méthodes plus performantes pour écrire un script de tri de fichiers, mais celle-ci est simple et facile à comprendre :

Pour ce faire dans PowerShell, utilisez un pipeline qui ressemble à ceci :

Get-ChildItem -Path "C:\Directory" -File | Sort-Object Length -Descending `
 | Select-Object -First 5 | Format-Table Name, Length -AutoSize

Enregistrer le pipeline en tant que script PS1

Maintenant que nous avons un pipeline fonctionnel, vous pouvez l'enregistrer en tant que fichier de script PS1 afin de ne pas avoir à l'importer à chaque fois que vous l'utilisez.

Le moyen le plus simple de créer un fichier PS1 est de coller votre script dans le Bloc-notes et d'enregistrer le fichier avec une extension .ps1.

Une fois que vous avez créé le fichier PS1, vous pouvez l'utiliser dans PowerShell en exécutant ./ScriptName.ps1 :

Astuce : si vous obtenez une erreur d’autorisations, la solution la plus rapide consiste à exécuter PowerShell avec des droits d’administrateur lors de l’exécution de votre script.

Félicitations ! Vous pouvez désormais créer des scripts PowerShell PS1.

Exemple de script PowerShell

Lire et comprendre les merveilles des nouvelles technologies est une chose, mais les utiliser concrètement en est une autre ! Dans la suite de cet article, nous allons développer un script PowerShell pour démontrer ses capacités et son utilisation.

DIR est l'une des commandes les plus courantes de CMD.EXE . Elle affiche tous les fichiers et sous-répertoires contenus dans un répertoire parent (comme illustré à la figure 1). Outre le nom de chaque objet, les informations fournies incluent la date et l'heure de la dernière mise à jour, ainsi que la taille de chaque fichier. DIR affiche également la taille totale de tous les fichiers du répertoire, ainsi que le nombre total de fichiers et de sous-répertoires.

Figure 1

L'exécution de DIR dans PowerShell produit également une liste de répertoires similaire à la figure 2, mais d'une manière légèrement différente. PowerShell ne dispose pas de commande DIR, mais de Get-ChildItem, qui remplit la même fonction. Dans PowerShell, DIR est un alias de Get-ChildItem. Je n'ai pas l'intention d'aborder les alias dans cet article. Dans PowerShell, DIR est l'abréviation de Get-ChildItem.

Dans PowerShell, DIR fournit la plupart des informations mentionnées ci-dessus : la liste des fichiers et dossiers, la date et l'heure de leur dernière modification, ainsi que la taille de chaque fichier. Cependant, il lui manque les informations récapitulatives fournies par DIR dans CMD.EXE : la taille totale de tous les fichiers du dossier, le nombre total de fichiers et le nombre total de sous-dossiers.

Figure 2

Pour l'exemple, vous devrez créer un script PowerShell simulant la commande CMD.EXE DIR. Je détaille ci-dessous les éléments essentiels d'un script.

DIR.PS1 : En-tête

Un script PowerShell est constitué de commandes PowerShell dans un fichier texte portant l'extension .PS1. Au lieu de DIR, utilisez un fichier texte nommé DIR.PS1.

Pour exécuter le script, tapez la commande suivante dans l’écran PowerShell :

.DIR.PS1 X:Folder

Où X est la lettre de partition du lecteur (comme C, D, E) et Folder est le nom du dossier.

Pour obtenir des informations sur la partition d'un lecteur, vous devez utiliser Windows Management Instrumentation (WMI). Les détails de WMI dépassent le cadre de cet article ; nous ne les détaillerons donc pas ici. Cependant, le code PowerShell ci-dessous est assez simple à comprendre sans utiliser WMI. Vous pouvez créer une variable « $filter » à utiliser avec la commande Get-WmiObject. Ce filtre indique à la commande Get-WmiObject que vous souhaitez uniquement obtenir des informations sur un lecteur spécifique. Les résultats de la commande Get-WmiObject sont stockés dans une variable appelée $volInfo. N'oubliez pas que dans PowerShell, tout est un objet ; $volInfo est désormais un objet renvoyé par Get-WmiObject.

$filter = "DeviceID = '" + $drive + ":'"
$volInfo = Get-WmiObject -Class Win32_LogicalDisk -Filter $filter

Vous avez maintenant accès à tous les objets et méthodes associés à l'objet. Le numéro de série du volume est accessible via la propriété VolumeSerialNumber. Le numéro renvoyé est une chaîne de huit caractères. Cependant, il est souvent préférable de le formater sous forme de quatre chiffres, séparés par un tiret. Ceci peut être réalisé de la même manière que pour la ligne suivante. Le tiret à la fin de la première ligne est le caractère de continuation de ligne dans PowerShell. Il indique à PowerShell que la ligne ne se coupe pas et qu'elle inclut la ligne suivante. Les sauts de ligne ne sont pas obligatoires lors de l'écriture de code, mais pour réduire la largeur et améliorer la lisibilité du code, il est conseillé de les utiliser.

$serial = $volInfo.VolumeSerialNumber.SubString(0, 4) + "-" + `
$volInfo.VolumeSerialNumber.SubString(4, 4)

Maintenant que vous disposez d'un objet $volInfo, vous pouvez afficher les informations de l'en-tête DIR à l'écran. Si le lecteur n'a pas de nom, le texte affiché à l'écran sera légèrement différent de celui affiché s'il en a un. Une simple instruction If-Else permet de vérifier si la propriété VolumeName est une chaîne vide. L'instruction Write-Host permet d'afficher chaque ligne de texte à l'écran.

If ($volInfo.VolumeName -eq "") { Write-Host (" Volume in drive " + $drive + " has no label") } Else { Write-Host (" Volume in drive " + $drive + " is " + $volInfo.VolumeName) } Write-Host (" Volume Serial Number is " + $serial) Write-Host ("`n Directory of " + $args[0] + "`n")

Le caractère « `n » au début et à la fin de la commande Write-Host permet d'insérer une nouvelle ligne avant et après le texte. La commande Write-Host ajoute une nouvelle ligne à la fin de chaque ligne. Ainsi, « `n » crée une ligne vide avant et après le texte.

Avez-vous remarqué le « -eq » dans la commande If ? Il s'agit d'un opérateur de comparaison d'égalité. Le tableau ci-dessous présente tous les opérateurs de comparaison :

Le caractère -i avant les opérateurs de comparaison indique que l'opérateur n'est pas sensible à la casse.

Figure 3 : Données de sortie du script dont vous disposez actuellement

DIR.PS1 : Liste des fichiers/dossiers

Vous êtes maintenant prêt à afficher le contenu et les propriétés de ce dossier. Commencez par appeler la commande PowerShell Get-ChildItem pour obtenir une collection de fichiers et la passer en paramètre au script. La commande Get-ChildItem récupère une collection d'objets fichiers et dossiers, non seulement leurs noms, mais les transmet directement à la commande Sort-Object pour les trier. Par défaut, la commande Sort-Object trie les objets en fonction de la propriété Name. Aucun autre paramètre n'est donc requis. La collection d'objets triés est ensuite stockée dans une variable nommée $items.

$items = Get-ChildItem $args[0] | Sort-Object

Une fois que vous disposez d'une collection d'objets fichiers et dossiers, vous devez les parcourir et afficher les propriétés appropriées. La commande pour cela est ForEach. Pour chaque fichier ou dossier, les propriétés affichées sont la date et l'heure de dernière modification, le nom, la longueur ou la taille du fichier. Les chaînes étranges entre parenthèses sont des codes de format de chaîne .NET. Ils servent à aligner les champs à gauche/droite et à formater les dates, les heures et les nombres. La compréhension de ces codes de format de chaîne n'est pas essentielle, car ils ne sont pas essentiels à la nature de ce script.

L'instruction If permet de déterminer si un objet est un répertoire ou non. Si le premier caractère de l'attribut Mode est « d », l'objet est un répertoire. Il est important de vérifier, car le code des répertoires est souvent différent de celui des fichiers.

Notez la ligne $totalDirs++ dans l'instruction If. Il s'agit d'un compteur qui enregistre le nombre de répertoires. De même, la variable $totalFiles permet de suivre la taille totale de tous les fichiers. Ces valeurs sont toujours calculées pendant l'exécution, mais elles ne s'affichent qu'une fois le listage des fichiers terminé.

ForEach ($i In $items)
{
$date = "{0, -20:MM/dd/yyyy hh:mm tt}" -f $i.LastWriteTime
$file = $i.Name
If ($i.Mode.SubString(0, 1) -eq "d")
{
$totalDirs++
$list = $date + " {0, -15}" -f "
" + " " + $file
}
Else
{
$totalFiles++
$size = "{0, 18:N0}" -f $i.Length
$list = $date + $size + " " + $file
}
$totalSize += $i.Length
Write-Host $list
}

Figure 4 : Affiche les données de sortie du script mis à jour.

DIR.PS1 : Pied de page

Il ne reste plus qu'à afficher à l'écran le nombre total de fichiers, de répertoires, leur taille totale et l'espace libre sur cette partition. Pour cela, vous devrez utiliser les variables de compteur ($totalFiles, $totalDirs, $totalSize) créées dans la section précédente. Vous pouvez connaître l'espace libre grâce à la variable $volInfo créée au début du script.

Write-Host ("{0, 16:N0}" -f $totalFiles + " File(s)" + `
"{0, 15:N0}" -f $totalSize + " bytes")
Write-Host ("{0, 16:N0}" -f $totalDirs + " Dir(s)" + `
"{0, 16:N0}" -f $volInfo.FreeSpace + " bytes free`n")

Figure 5 : Affiche les données de sortie complètes du script.

Les prévisions et les améliorations peuvent être

Bien que le script que vous créez produise une sortie presque identique à la commande CMD.EXE DIR, il existe certaines mises en garde dont vous devez être conscient et certaines améliorations qui peuvent être apportées.

• Ce script n'effectue aucune vérification d'erreur.
• Si un chemin valide n’est pas transmis au script, le script échouera avec un message d’erreur PowerShell.
• Le nombre total de répertoires donné dans le script est inférieur de 2 au résultat de la commande CMD.EXE DIR car la commande Get-ChildItem ne compte pas les deux répertoires « . » et « .. » comme dans CMD.EXE.
• Votre script trie uniquement par nom de fichier, nom de dossier et ne fournit aucun autre tri par attributs.
• Votre script n'est pas en mesure d'afficher le contenu du dossier et de tous les sous-dossiers.

Comment PowerShell vous aide à automatiser tout sur votre PC

Écrire des scripts PowerShell simples

Vous pouvez utiliser PowerShell pour automatiser presque tout, comme renommer des fichiers par lots pour plus de cohérence ou lancer automatiquement des applications. Écrivons quelques scripts Windows PowerShell simples pour comprendre son fonctionnement.

Remarque : si vous rencontrez une erreur lors de l'exécution du script concernant la stratégie d'exécution, vous devrez peut-être autoriser temporairement l'exécution du script en exécutant « Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass »

Renommer par lots des fichiers dans un dossier

Vous pouvez utiliser PowerShell pour copier, déplacer et supprimer des fichiers sur votre PC. Vous pouvez également renommer des fichiers d'un type spécifique en bloc. Par exemple, voici comment renommer plusieurs fichiers texte en remplaçant le préfixe « oldco » par « newco » dans leurs noms :

Get-ChildItem -Path "C:\CompanyFiles" -Filter "*.txt" | Rename-Item -NewName {$_.Name -replace "oldco","newco"}

Dans le script ci-dessus, « .txt » est le filtre d'extension de fichier. Vous pouvez le modifier et le définir sur .jpg, .docx, etc. pour rechercher différents types de fichiers.

Lancement automatique de l'application

Si vous ouvrez le même ensemble d’applications tous les jours, vous pouvez écrire un script PowerShell pour les lancer en un seul clic :

#Open multiple apps with a single click
Start-Process "notepad.exe"
Start-Process "calc.exe"
Start-Process "Chrome.exe"
Start-Process "slack.exe"

Collez le script dans un fichier Bloc-notes et enregistrez-le sous le nom LaunchFavoriteApps.ps1. Double-cliquez ensuite sur le fichier pour lancer toutes les applications répertoriées dans le script.

Copier les fichiers importants vers un emplacement de sauvegarde

Vous pouvez sauvegarder régulièrement vos fichiers importants vers un emplacement de sauvegarde à l'aide du script suivant. Veillez à modifier les chemins source et de destination si nécessaire :

#Copy MyFiles folder contents to MyFilesBackup in D:\
Copy-Item -Path "C:\Documents\MyFiles" -Destination "D:\MyFilesBackup" -Recurse

Écrivez un script PowerShell pour organiser automatiquement les fichiers quotidiennement

Étant donné que de nombreux types de fichiers sont téléchargés chaque jour, le dossier « Téléchargements » peut rapidement devenir encombré par des fichiers de toutes sortes éparpillés. Pour résoudre ce problème, nous pouvons écrire un script PowerShell qui trie les fichiers téléchargés dans des dossiers par type à la fin de chaque journée.

Ouvrez un nouveau fichier Bloc-notes et collez le script suivant. Veillez à modifier le chemin du dossier source dans le script pour qu'il corresponde à celui du dossier Téléchargements :

# Change the source folder path below
$sourcePath = "E:\Downloads"
# Add file mapping folder names; the Others folder includes all the files that do not match file types in the other categories
$fileTypes = @{
"Documents" = @("*.docx", "*.pdf", "*.txt")
"Images" = @("*.jpg", "*.png", "*.gif")
"Media" = @("*.mp4", "*.mp3", "*.mov")
"Zip" = @("*.zip", "*.rar")
"ISO" = @("*.iso")
"Others" = @("*")
}
# Iterate through each folder type and prepare a destination folder for organizing files
foreach ($folder in $fileTypes.Keys) {
# Create the destination folder path
$destPath = Join-Path -Path $sourcePath -ChildPath $folder
# Check if the destination folder exists, and create it if it doesn't
if (!(Test-Path -Path $destPath)) {
New-Item -ItemType Directory -Path $destPath | Out-Null
}
# Move matching files from the source folder to the destination folder based on file type patterns
foreach ($pattern in $fileTypes[$folder]) {
Get-ChildItem -Path $sourcePath -Filter $pattern -File -ErrorAction SilentlyContinue | ForEach-Object {
try {
Move-Item -Path $_.FullName -Destination $destPath -Force -ErrorAction Stop
Write-Output "Moved: $($_.FullName) to $destPath"
} catch {
Write-Warning "Failed to move file: $($_.FullName). Error: $_"
}
}
}
}
Write-Output "Files organized successfully!"

Pour enregistrer le fichier, cliquez sur Fichier > Enregistrer sous et saisissez OrganizeDownloadsFolder.ps1 comme nom de fichier. Cliquez ensuite sur Type de fichier et sélectionnez Tous les fichiers . Double-cliquez sur le fichier OrganizeDownloadsFolder.ps1 pour exécuter le script.

Planifier et exécuter des tâches

Bien sûr, l'écriture d'un script constitue une partie du processus d'automatisation. La deuxième étape consiste à s'assurer que le script peut être exécuté automatiquement pour effectuer la tâche. Pour ce faire, nous pouvons créer des tâches planifiées pour exécuter le script quotidiennement ou selon les besoins.

Ouvrez PowerShell, copiez-collez le script suivant et appuyez sur Entrée . Veillez à remplacer « J:\OrganizeDownloadsFolder.ps1 » par le chemin d'accès complet à votre script OrganizeDownloadsFolder.ps1 .

$action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File 'J:\OrganizeDownloadsFolder.ps1'"
$trigger = New-ScheduledTaskTrigger -Daily -At "5:00 PM"
Register-ScheduledTask -Action $action -Trigger $trigger -TaskName "OrganizeDownloadsFolderDaily"

Une fois terminé, appuyez sur Entrée . Le script créera une tâche planifiée dans le Planificateur de tâches pour exécuter le script d'organisation des fichiers tous les jours à 17h00. Si vous préférez une heure différente, vous pouvez la modifier dans le script ci-dessus.

De plus, vous pouvez utiliser PowerShell pour automatiser d’autres tâches quotidiennes, telles qu’un script de surveillance de l’espace qui vous avertit lorsque vous manquez d’espace libre sur votre lecteur principal, la protection par mot de passe de lots de documents PDF et même l’application de fonds d’écran animés à partir de votre dossier d’images.

Bien que PowerShell soit un utilitaire et un langage de script puissant, sa compréhension et son utilisation demandent un certain temps, surtout si vous n'êtes pas familier avec l'environnement .NET Framework. J'espère que cet article et l'exemple de script seront utiles à tous ceux qui souhaitent comprendre PowerShell. Cependant, l'exemple de script créé dans cet article est assez simple. Je pense qu'il peut être construit et développé de manière plus complète pour des applications plus complexes.