Paramètres de fonction PowerShell

1. Définir les paramètres de la fonction PowerShell
2. Paramètres nommés dans la fonction PowerShell
3. Paramètres positionnels dans la fonction PowerShell
4. Changement de paramètres dans une fonction PowerShell
5. Splatting dans les paramètres de la fonction PowerShell
6. Attributs des paramètres PowerShell
7. Fonction avancée avec syntaxe de paramètre nommé

Les paramètres de fonction PowerShell rendent les fonctions plus puissantes en tirant parti des caractéristiques et des arguments pour empêcher les utilisateurs d’entrer des valeurs particulières. Il ajoute quelques règles et validations pour éviter d’avoir à écrire des scripts volumineux, et ils sont simples à utiliser.

Des arguments peuvent également être donnés via la ligne de commande une fois que les paramètres de la fonction ont été spécifiés. Les paramètres nommés, positionnels, de commutation et dynamiques sont tous des exemples de paramètres de fonction. Les paramètres de fonction peuvent également être utilisés pour transformer une fonction de base en une fonction plus complexe.

Définir les paramètres de la fonction PowerShell

Les paramètres sont définis comme suit.

param(
  $Parameter1
)

Les meilleures pratiques recommandent d’ajouter un type au paramètre et d’insérer un bloc Parameter() pour garantir que le paramètre prend uniquement le type d’entrée dont vous avez besoin et activera davantage de fonctionnalités à l’avenir. Par conséquent, cela se fait comme indiqué ci-dessous.

param(
     [Parameter()]
     [string]$Parameter1
 )

Même des paramètres supplémentaires peuvent être ajoutés à la syntaxe ci-dessus, comme indiqué ci-dessous.

param(
     [Parameter()]
     [string]$Param1,
 
     [Parameter()]
     [string]$Param2
 )
 
Write-Host "Param1 value is $Param1"
Write-Host "Param 2 value is $Param2"

Paramètres nommés dans la fonction PowerShell

Les paramètres nommés sont une technique pour utiliser les paramètres de fonction PowerShell dans un script. Utilisez le nom complet de l’argument lors de l’appel d’un script ou d’une fonction avec des paramètres nommés.

Supposons que le script PowerShell ci-dessus soit stocké dans test.ps1. Ici, nous fournirons des valeurs à param1 et param2 ; vous pouvez remarquer dans l’exemple ci-dessous que le nom complet du paramètre doit être passé.

./test.ps1 -Param1 'value' -Param2 'valuenext'

Production :

Lorsque vous exécutez ce script, vous verrez quelque chose comme ceci, où chaque variable d’argument est remplacée par la valeur fournie lors de l’exécution.

Paramètres positionnels dans la fonction PowerShell

Passer des éléments par position au lieu de leur nom est une autre façon d’utiliser les paramètres. Le nom du paramètre n’est pas utilisé lors du passage d’une valeur de paramètre via la position. Au lieu de cela, PowerShell compare les valeurs de chaque argument à son emplacement dans la fonction. PowerShell reconnaît que Param1 a été spécifié avant Param2 dans le code et fait correspondre les valeurs dans le bon ordre.

./test.ps1 'value' 'valuenext'

Sortir

Param1 value value
Param 2 value is valuenext

param1 et param2 ont été déclarés en tant que types de chaîne dans l’exemple ci-dessus, mais ce n’est pas le seul type que vous pouvez utiliser. N’importe quel type de la bibliothèque de classes .NET peut être utilisé.

Outre l’ordre d’origine, nous pouvons également avancer en donnant également la position à l’intérieur de la construction du paramètre. Il est illustré ci-dessous.

param(
     [Parameter(position = 1)]
     [string]$Param1,
 
     [Parameter(position = 0)]
     [string]$Param2
 )
 
Write-Host "Param1 value is $Param1"
Write-Host "Param 2 value is $Param2"

Ici, vous pouvez voir que l’ordre des paramètres est modifié.

./test.ps1 'param2' 'param1'

Changement de paramètres dans une fonction PowerShell

Ce paramètre est utilisé pour indiquer si quelque chose est activé ou désactivé à l’aide de valeurs binaires ou booléennes. Le type switch permet de le spécifier. En continuant avec l’exemple ci-dessus, nous allons ajouter un autre paramètre de commutateur nommé DisplayParam2.

param(
     [Parameter()]
     [string]$Param1,
 
     [Parameter()]
     [string]$Param2,
 
     [Parameter()]
     [switch]$DisplayParam2
 )
 
 Write-Host "Param1 value is $Param1"
 if ($DisplayParam2.IsPresent) {
     Write-Host "Param2 value is $Param2"
 }

Production :

Splatting dans les paramètres de la fonction PowerShell

Le splatting est principalement utilisé lorsqu’il y a beaucoup de paramètres. La configuration des paramètres d’un script avant l’exécution d’une commande est appelée splatting. Jusqu’à présent, vous avez défini et transmis des valeurs aux paramètres lors de l’exécution. Une fois que vous avez une collection de paramètres qui apparaissent ci-dessous, cela peut être un problème.

param(
     [Parameter()]
     [string]$Param1,
 
     [Parameter()]
     [string]$Param2,
 
     [Parameter()]
     [switch]$DisplayParam2,
 
     [Parameter()]
     [string]$Param3,
 
     [Parameter()]
     [string]$Param4,
 
     [Parameter()]
     [string]$Param5,
 
     [Parameter()]
     [string]$Param6,
 
     [Parameter()]
     [string]$Param7
 )
 
Write-Host "Param1 value is $Param1"
if ($DisplayParam2.IsPresent) {
 Write-Host "Param2 value is $Param2"
}
Write-Host "Param3 value is $Param3"
Write-Host "Param4 value is $Param4"
Write-Host "Param5 value is $Param5"
Write-Host "Param6 value is $Param6"
Write-Host "Param7 value is $Param7"

Plutôt que de glisser vers la droite, vous pouvez utiliser une table de hachage pour spécifier les valeurs des paramètres dans une phase distincte, comme illustré ci-dessous. Les valeurs des paramètres peuvent être parfaitement alignées, ce qui facilite grandement la compréhension de celles qui sont utilisées.

Une fois la table de hachage établie, vous pouvez spécifier le nom de la table de hachage suivi d’un caractère @ pour envoyer tous les arguments au script.

$params = @{
     Param1             = 'value'
     Param2             = 'valuenext'
     Param3             = 'somevalue'
     Param4             = 'somevalue'
     Param5             = 'somevalue'
     Param6             = 'somevalue'
     Param7             = 'somevalue'
     DisplayParam2 = $true
 }
 
 PS> ./test.ps1 @params

Attributs des paramètres PowerShell

Les caractéristiques des paramètres vous permettent de modifier la fonctionnalité des paramètres de différentes manières. Vous pouvez utiliser des expressions régulières pour adapter une expression régulière, rendre obligatoire l’utilisation d’un paramètre donné et vérifier les valeurs fournies à un paramètre.

Paramètres obligatoires

Dans PowerShell, nous pouvons mandater un ou plusieurs attributs s’exécutant dans une fonction en fonction de notre souhait. Par conséquent, nous pouvons utiliser l’attribut mandatory à l’intérieur de la construction Parameter().

param(
     [Parameter(Mandatory)]
     [string]$Param1,
 
     [Parameter()]
     [string]$Param2,
 
     [Parameter()]
     [switch]$DisplayParam2
 )
 
Write-Host "Param1 value is $Param1"
if ($DisplayParam2.IsPresent) {
    Write-Host "Param2 value is $Param2"
}

Production :

Validation des paramètres

Enfin, revérifiez que les valeurs fournies aux paramètres sont correctes. C’est idéal pour réduire au minimum la possibilité que quelqu’un donne une valeur unique à un paramètre. Par conséquent, nous pouvons spécifier les entrées que nous voulons en utilisant le ValidateSet() comme indiqué ci-dessous.

param(
     [Parameter(Mandatory)]
     [ValidateSet('x', 'y')]
     [string]$Param1,
 
     [Parameter()]
     [string]$Param2,
 
     [Parameter()]
     [switch]$DisplayParam2
 )
 
 Write-Host "Param1 value is $Param1"
 if ($DisplayParam2.IsPresent) {
     Write-Host "Param2 value is $Param2"
 }

Si nous donnons des valeurs autres que x et y à param1, une erreur apparaîtra.

Fonction avancée avec syntaxe de paramètre nommé

Lorsque l’attribut Cmdletbinding est ajouté à une fonction, il la transforme en une fonction avancée. D’autres arguments courants sont utilisés lors de la construction de la fonction avancée. La syntaxe est la suivante.

function testfunction
{
    [CmdletBinding (DefaultParameterSetName='Param1')]
    Param
    (
         [Parameter(Mandatory=$true, Position=0, ParameterSetName='Param1')]
         [string] Param1,
         [Parameter(Mandatory=$true, Position=0, ParameterSetName='Param2')]
         [string] Param2,
    )
}