Comment diviser des commandes en plusieurs lignes dans PowerShell

1. Commande Multiligne de Windows PowerShell
2. Rompre de Longues Lignes de Code en Utilisant des Opérateurs Spécifiques
3. Conclusion

Un code lisible communique très facilement son but de fonctionnalité aux utilisateurs. Les noms de variables et les noms de méthodes doivent respecter les conventions de nommage appropriées pour la lisibilité du code.

D’autres attributs qui contribuent à la lisibilité du code sont l’indentation et le style de formatage cohérents. La commande multiligne de Windows PowerShell aide à diviser de longues lignes de commande en plusieurs déclarations pour améliorer la lisibilité.

Dans Windows PowerShell, les commandes multiligne peuvent être facilement créées en utilisant le caractère de backtick pour diviser de longues commandes ou des commandes sur une seule ligne en déclarations multiligne.

Le caractère de backtick est utilisé comme une sorte de caractère d’échappement. Il échappe le caractère de nouvelle ligne et permet une continuation de ligne.

Cet article expliquera l’importance des commandes multiligne de Windows PowerShell pour diviser de longues commandes sur plusieurs lignes.

Commande Multiligne de Windows PowerShell

Pour diviser une longue commande en plusieurs lignes, utilisez le caractère de backtick pour la rompre en plusieurs lignes.

Par exemple, nous voulons obtenir les informations sur l’espace disque libre sur l’ordinateur local. Malheureusement, le script pour obtenir cette information spécifique est une commande étendue, ce qui le rend difficile à lire et à gérer.

Exemple de code :

 powershellCopyGet-WmiObject -Class win32_logicaldisk | Format-Table DeviceId, MediaType, @{n = "Size"; e = { [math]::Round($_.Size / 1GB, 2) } }, @{n = "FreeSpace"; e = { [math]::Round($_.FreeSpace / 1GB, 2) } }

Cela peut sembler que la syntaxe est divisée dans cet article, mais lorsqu’elle est copiée dans l’interface de ligne de commande, l’exemple ci-dessus est un script unitaire très long.

Nous pouvons facilement diviser de longues commandes en plusieurs lignes en utilisant des caractères de backtick de Windows PowerShell pour une rupture de ligne dans une commande donnée.

Exemple de code :

 powershellCopyGet-WmiObject -Class win32_logicaldisk `
| Format-Table DeviceId, `MediaType, @{n = "Size"; e = { [Math]::Round($_.Size / 1GB, 2) } }, `
@{n = "FreeSpace"; e = { [Math]::Round($_.FreeSpace / 1GB, 2) } }

Dans notre code, nous utilisons des backticks comme caractères de continuation de ligne dans PowerShell pour améliorer la lisibilité en divisant une longue commande sur plusieurs lignes. Nous commençons avec Get-WmiObject -Class win32_logicaldisk, qui récupère des informations sur les disques logiques du système.

Le backtick à la fin de cette ligne indique que la commande continue à la ligne suivante. Nous redirigeons ensuite (|) la sortie vers Format-Table, un cmdlet qui formate la sortie sous forme de tableau.

Ici, nous choisissons spécifiquement d’afficher DeviceId et MediaType. Pour les propriétés Size et FreeSpace, nous utilisons des champs calculés (notés par la syntaxe @{n = "Name"; e = { Expression }}).

Dans ces champs calculés, nous utilisons à nouveau des backticks pour la continuation de ligne. Les expressions utilisent [Math]::Round($*.Size / 1GB, 2) et [Math]::Round($*.FreeSpace / 1GB, 2) pour convertir la taille et l’espace libre de bytes en gigaoctets et les arrondir à deux décimales.

En décomposant cette commande complexe avec des backticks, nous rendons le script plus gérable et son intention plus claire, aidant à la fois à sa maintenance et à sa lisibilité.

Sortie :

La structure du code est facilement lisible et facile à maintenir dans Windows PowerShell en utilisant la commande multiligne. Cependant, le caractère de backtick n’est généralement pas recommandé car le caractère est difficile à lire et attire des bogues.

Nous avons donc une méthode alternative pour rompre de longues lignes de code.

Rompre de Longues Lignes de Code en Utilisant des Opérateurs Spécifiques

PowerShell est intuitif lorsqu’il s’agit de continuation de ligne. Certains opérateurs et structures de syntaxe signalent intrinsèquement à l’interpréteur qu’une commande s’étend sur plusieurs lignes.

Ceci est particulièrement utile dans des scripts complexes où la lisibilité peut avoir un impact significatif sur la facilité de maintenance et de compréhension.

Rompre de Longues Lignes de Code en Utilisant le Pipeline (|)

En général, vous obtenez une continuation de ligne automatique lorsqu’une commande ne peut pas être syntaxiquement complétée à ce moment-là.

Un exemple serait de commencer un nouvel élément de pipeline (|). Le pipeline fonctionnera sans problème puisque, après l’opérateur de pipeline, la commande ne peut pas être complétée car il manque un autre élément de pipeline.

Donc, ce que notre interpréteur fait est de chercher le prochain élément de pipeline dans la ligne de commande suivante.

Exemple de code :

 powershellCopyGet-Process |
    Where-Object { $_.ProcessName -like "powershell" } |
    Select-Object Id, ProcessName, CPU

Dans notre script, nous commençons par Get-Process, qui récupère tous les processus en cours d’exécution. La sortie de Get-Process est ensuite transmise à Where-Object, où nous filtrons les processus dont le nom inclut powershell.

Cela est réalisé en utilisant l’opérateur -like dans un bloc de script {} pour faire correspondre les noms des processus.

Ensuite, nous redirigeons les résultats filtrés vers Select-Object. Ici, nous spécifions que nous voulons uniquement conserver l’Id, le ProcessName, et l’utilisation du CPU de ces processus filtrés.

En utilisant le pipeline, nous avons effectivement décomposé la commande en parties gérables, chacune sur une ligne séparée. Cela rend non seulement notre script plus lisible, mais simplifie également le débogage et les modifications futures.

Sortie :

Rompre de Longues Lignes de Code en Utilisant une Virgule (,)

Une virgule (,) fonctionnera également dans certains contextes, comme l’opérateur de pipeline.

Dans certains contextes, tels que dans une commande ou un bloc de script, l’opérateur virgule peut également servir de signal de continuation de ligne. Cela est particulièrement utile dans le formatage des commandes ou lors du passage d’une liste d’éléments.

Exemple de code :

 powershellCopyGet-EventLog -LogName Application -Newest 5 |
    Format-Table TimeGenerated, 
    EntryType, 
    Source, 
    @{n = 'Message'; e = { $_.Message.Split("`n")[0] } }

Dans notre script, nous utilisons Get-EventLog pour récupérer les 5 dernières entrées du journal d’application. Cette sortie est transmise à Format-Table pour formatage.

Nous utilisons ensuite la méthode de la virgule pour lister les propriétés que nous souhaitons dans le tableau : TimeGenerated, EntryType, Source, et une expression personnalisée pour Message. L’expression personnalisée pour Message utilise une propriété calculée (@{n='Message'; e= { $_.Message.Split("n")[0] } }) pour afficher uniquement la première ligne du message, améliorant ainsi la lisibilité.

En divisant cette commande en plusieurs lignes en utilisant des virgules, nous avons rendu le script plus lisible, surtout lorsqu’il s’agit de plusieurs propriétés ou expressions complexes.

Sortie :

Rompre de Longues Lignes de Code en Utilisant des Accolades ({})

De plus, les accolades ({}) lors de la définition de blocs de script permettront une continuation de ligne directe. Elles sont indispensables dans des scénarios impliquant des boucles, des instructions conditionnelles ou lors du passage d’un bloc de commandes à des cmdlets.

Exemple de code :

 powershellCopy$processes = Get-Process
$filteredProcesses = $processes | Where-Object {
    $_.WorkingSet -gt 100MB
} | ForEach-Object {
    $_.ProcessName
}
$filteredProcesses

Nous commençons par obtenir une liste de tous les processus en utilisant le cmdlet Get-Process. Le pipeline transmet ensuite ces processus à Where-Object, où un bloc de script filtre les processus ayant un ensemble de travail supérieur à 100MB.

Les processus restants sont transmis à un autre bloc de script dans ForEach-Object, qui extrait et affiche leurs noms. L’utilisation des accolades pour les blocs de script permet un flux clair, concis et fonctionnel des données à travers le pipeline.

Sortie :

Conclusion

Tout au long de cet article, nous avons exploré diverses méthodes pour améliorer la lisibilité des scripts PowerShell. La lisibilité est cruciale pour une compréhension et une maintenance faciles des scripts, surtout dans Windows PowerShell, où les scripts peuvent souvent devenir longs et complexes.

Nous avons commencé par discuter de la pratique courante d’utiliser le caractère de backtick pour les commandes multiligne, qui, bien que efficace, peut parfois conduire à des problèmes de lisibilité et à des bogues potentiels en raison de sa nature subtile.

Cependant, PowerShell offre des méthodes plus intuitives pour rompre de longues lignes de code, que nous avons ensuite examinées. L’utilisation d’opérateurs spécifiques comme le pipeline (|), la virgule (,), et les accolades ({}) offrent une approche plus lisible et maintenable pour l’écriture de scripts.

Ces méthodes améliorent non seulement la structure visuelle du code, mais aussi le flux logique, rendant les scripts plus faciles à déboguer et à modifier.