Bonnes pratiques pour les scripts PowerShell

I. Présentation

Ce chapitre synthétise l'ensemble des bonnes pratiques pour l'écriture des scripts PowerShell, ce qui permettra de clôturer ce module sur la rédaction de scripts PowerShell et servir de résumer.

II. Résumé des bonnes pratiques PowerShell

Voici un ensemble de bonnes pratiques et recommandations que je souhaitais mettre en avant dans le cadre de ce cours. Il est important de suivre certaines bonnes pratiques pour garantir la clarté, la lisibilité, la cohérence et la maintenabilité de vos scripts.

• Consulter l'aide de PowerShell

Lorsque vous rédigez un script PowerShell, prenez le temps de consulter l'aide de chaque cmdlet que vous utilisez afin de bien comprendre son fonctionnement, l'utilité des paramètres, etc... Avec l'habitude et la réutilisation de certains cmdlets, vous allez bien entendu gagner en efficacité.

Surtout, ceci vous permettra de prioriser l'utilisation de cmdlets natifs à PowerShell, plutôt que de chercher, potentiellement, à réécrire un code qui effectue une action déjà couverte par un cmdlet.

• Nommer vos scripts, vos fonctions et vos variables

Les noms des scripts, des fonctions et des variables doivent être à la fois clairs et descriptifs. Pour les noms de scripts et de fonctions, vous devez respecter les règles de Microsoft, à savoir l'utilisation d'un verbe approuvé et d'un nom approuvé.

Pour les variables (notion qui sera étudiée dans le prochain module), vous avez plus de liberté, mais le nom de chaque variable doit être évocateur. Ceci permettra de mieux s'y retrouver quand vous aurez une multitude de variables dans un même script. Si la variable se nomme "UtilisateurNom", nous pouvons nous douter qu'elle soit utilisée pour stocker le nom d'un utilisateur, alors que si cette même variable s'appelle tout simplement "u" ou "utilisateur", c'est moins explicite.

• Utiliser des commentaires

Un bon script est un script bien documenté. Les commentaires vous permettent de décrire le but de votre script et de chaque bloc de code. Ils aident les autres (et vous-même, à l'avenir) à comprendre rapidement ce que fait votre code. Pour rappel, pour ajouter un commentaire dans PowerShell, utilisez le caractère dièse (#) et tout le texte qui suit (sur la même ligne) sera intégré au commentaire. L'intégration d'une aide basée sur les commentaires est également une bonne pratique.

• Indenter son code

L'indentation du code va permettre d'améliorer la mise en forme de votre code PowerShell, dans le but de le rendre plus lisible. Comme nous l'avons vu précédemment, en PowerShell, l'indentation se fait généralement avec des tabulations, ou éventuellement avec des espaces.

• Aérer votre code

En plus des commentaires et de l'indentation, vous pouvez aussi aérer votre code grâce à l'ajout de saut de lignes, mais aussi d'espaces. Par exemple, lorsque vous déclarez une variable, écrivez plutôt ceci :

$MaVariable = "MaValeur"

À la place de ça :

$MaVariable="MaValeur"

Qu'est-ce qui change ? La présence d'un espace après le nom de la variable (et donc avant le signe "=") et avant la valeur à affecter à la variable. Ainsi, chaque "partie" de la ligne est facilement identifiable.

• Utiliser l'autocomplétion

L'autocomplétion, ou saisie-automatique, est un excellent moyen de limiter les erreurs de frappe et de gagner du temps lors l'écriture de code PowerShell. En effet, avec PowerShell, l'autocomplétion va permettre de bénéficier de suggestions lors de la saisie des noms de cmdlets, des noms de paramètres, ou encore lorsque vous allez appeler une variable.

• Utiliser des fonctions

Les fonctions sont des blocs de code réutilisables qui effectuent une tâche spécifique. En regroupant votre code en fonctions, vous pouvez réduire la duplication et améliorer la lisibilité de votre script. Attention à ne pas créer une fonction qui effectue une tâche déjà accomplie par un cmdlet PowerShell intégré.

• Gérer les erreurs

PowerShell offre plusieurs mécanismes pour gérer les erreurs. Grâce à eux, vous pouvez vous assurer que votre script se comporte correctement en cas d'erreur et donne des informations utiles pour le dépannage. Ceci peut aussi permettre d'agir en cas d'erreur : "Si la commande précédente retourne une erreur, que fait-on ?". Dans un prochain chapitre, nous allons approfondir ce sujet grâce à l'utilisation de Try-Catch-Finally.

• Ne pas utiliser d'alias

Lorsque vous utilisez un cmdlet PowerShell, utilisez son nom complet. Autrement dit, évitez d'utiliser les alias comme nous l'avons suggéré dans le chapitre sur les alias, et c'est aussi une règle intégrée dans le module PSScriptAnalyzer.

• Limiter la longueur des lignes

Certaines lignes de code peuvent être très longues, notamment si nous utilisons un cmdlet avec un grand nombre de paramètres, ou si nous utilisons le pipeline pour enchainer plusieurs commandes ou filtrer le résultat d'une première commande. Dans certains cas, ceci implique de scroller horizontalement (vers la droite puis vers la gauche) pour naviguer dans le script. C'est un point négatif pour la lisibilité d'un script, car une partie du code peut être invisible à l'écran (tout dépend de la résolution, de la taille de l'écran, etc.).

Par défaut, la console PowerShell a une largeur de 120 caractères, mais nous devons penser aussi au fait que les scripts peuvent être partagés sur d'autres plateformes telles que GitHub. De ce fait, il est recommandé de limiter la longueur d'une ligne à 115 caractères pour assurer une bonne lisibilité sur un maximum d'appareils et de plateformes.

Sachez que vous pouvez décomposer une ligne sur plusieurs lignes grâce à l'apostrophe inversée. Prenons un exemple :

Get-Service | Where-Object { $_.Status -eq "Running" } | Select-Object DisplayName, Status | Out-GridView

Nous pourrions marquer un point de rupture avec le caractère "`" (sur la touche 7 d'un clavier AZERTY) et écrire ceci :

Get-Service | Where-Object { $_.Status -eq "Running" } `
            | Select-Object DisplayName, Status | Out-GridView

Et, si besoin, nous pourrions même aller plus loin et enchainer plusieurs fois ce caractère :

Get-Service | Where-Object { $_.Status -eq "Running" } `
            | Select-Object DisplayName, Status `
            | Out-GridView

Ainsi, nous pouvons conserver une bonne lisibilité lorsque la commande est trop longue. Il convient de faire attention à l'indentation dans ce cas, et aussi à ne pas ajouter le caractère "`" lorsque l'on arrive à la fin de la commande.

• Écrire une commande par ligne

Vous l'ignorez probablement, mais vous pouvez écrire plusieurs commandes sur la même ligne en les séparant par un point-virgule (";"). Bien que ce soit possible, c'est une mauvaise pratique, car cela va impacter la lisibilité de votre code. Prenez l'habitude d'écrire une commande par ligne, sauf lorsque vous utilisez le pipeline et que la commande n'est pas trop longue (recommandation précédente).

Pour illustrer cette recommandation, voici un exemple dans lequel trois commandes sont écrites sur la même ligne et séparées par un point-virgule. Ce bout de code est correct et sera exécuté par PowerShell. Néanmoins, il n'est pas facile à lire.

Write-Output "Début du script - Voici la liste des utilisateurs locaux" ; Get-LocalUser ; Write-Output "Fin du script"

Dans ce cas, il est préférable d'utiliser cette syntaxe :

Write-Output "Début du script - Voici la liste des utilisateurs locaux"
Get-LocalUser
Write-Output "Fin du script"

Lors de l'exécution, le résultat sera identique, mais le bout de code est plus facilement lisible et compréhensible. C'est un détail important. Je tiens également à préciser qu'il n'est pas nécessaire d'ajouter un point-virgule à la fin des lignes pour marquer la fin de la commande ; le retour à la ligne est suffisant.

III. Conclusion

En suivant ces bonnes pratiques, vos scripts seront plus facilement lisibles, compréhensibles et maintenables. Autrement dit, vos scripts seront bonifiés par le respect de ces quelques règles élémentaires.