Comment passer plusieurs paramètres dans une fonction dans PowerShell?

Si j'ai une fonction qui accepte plusieurs paramètres de chaîne, le premier paramètre semble obtenir toutes les données qui lui sont affectées et les paramètres restants sont passés comme vides.

Un script de test rapide:

Function Test([string]$arg1, [string]$arg2)
{
    Write-Host "`$arg1 value: $arg1"
    Write-Host "`$arg2 value: $arg2"
}

Test("ABC", "DEF")

La sortie générée est

$arg1 value: ABC DEF
$arg2 value: 

La sortie correcte doit être:

$arg1 value: ABC
$arg2 value: DEF

Cela semble être cohérent entre v1 et v2 sur plusieurs machines, donc évidemment, je fais quelque chose de mal. Quelqu'un peut-il indiquer exactement quoi?

Les paramètres des appels aux fonctions dans PowerShell (toutes les versions) sont séparés par des espaces et non par des virgules . En outre, les parenthèses sont entièrement inutiles et provoqueront une erreur d'analyse dans PowerShell 2.0 (ou version ultérieure) si Set-StrictModeest actif. Les arguments entre parenthèses sont utilisés dans les méthodes .NET uniquement.

function foo($a, $b, $c) {
   "a: $a; b: $b; c: $c"
}

ps> foo 1 2 3
a: 1; b: 2; c: 3

La bonne réponse a déjà été fournie, mais ce problème semble suffisamment répandu pour justifier certains détails supplémentaires pour ceux qui souhaitent comprendre les subtilités.

J'aurais ajouté cela juste en tant que commentaire, mais je voulais inclure une illustration - je l'ai arraché de mon tableau de référence rapide sur les fonctions PowerShell. Cela suppose que la signature de la fonction f est f($a, $b, $c):

Ainsi, on peut appeler une fonction avec des paramètres positionnels séparés par des espaces ou des paramètres nommés indépendants de l'ordre . Les autres pièges révèlent que vous devez être conscient des virgules, des parenthèses et des espaces blancs.

Pour en savoir plus, consultez mon article Down the Rabbit Hole: A Study in PowerShell Pipelines, Functions, and Parameters . L'article contient également un lien vers la référence rapide / graphique mural.

Il y a de bonnes réponses ici, mais je voulais souligner quelques autres choses. Les paramètres de fonction sont en fait un endroit où PowerShell brille. Par exemple, vous pouvez avoir des paramètres nommés ou positionnels dans des fonctions avancées comme ceci:

function Get-Something
{
    Param
    (
         [Parameter(Mandatory=$true, Position=0)]
         [string] $Name,
         [Parameter(Mandatory=$true, Position=1)]
         [int] $Id
    )
}

Ensuite, vous pouvez soit l'appeler en spécifiant le nom du paramètre, soit utiliser des paramètres positionnels, car vous les avez définis explicitement. Donc, l'un ou l'autre fonctionnerait:

Get-Something -Id 34 -Name "Blah"
Get-Something "Blah" 34

Le premier exemple fonctionne même s'il Nameest fourni en second, car nous avons explicitement utilisé le nom du paramètre. Le deuxième exemple fonctionne cependant en fonction de la position, doncName devrait donc être le premier. Lorsque cela est possible, j'essaie toujours de définir des positions afin que les deux options soient disponibles.

PowerShell a également la possibilité de définir des ensembles de paramètres. Il utilise cela à la place de la surcharge de méthode, et est encore très utile:

function Get-Something
{
    [CmdletBinding(DefaultParameterSetName='Name')]
    Param
    (
         [Parameter(Mandatory=$true, Position=0, ParameterSetName='Name')]
         [string] $Name,
         [Parameter(Mandatory=$true, Position=0, ParameterSetName='Id')]
         [int] $Id
    )
}

Maintenant, la fonction prendra un nom ou un identifiant, mais pas les deux. Vous pouvez les utiliser de manière positionnelle ou par nom. Puisqu'ils sont d'un type différent, PowerShell le découvrira. Donc, tout cela fonctionnerait:

Get-Something "some name"
Get-Something 23
Get-Something -Name "some name"
Get-Something -Id 23

Vous pouvez également affecter des paramètres supplémentaires aux différents jeux de paramètres. (C'était évidemment un exemple assez basique.) À l'intérieur de la fonction, vous pouvez déterminer quel ensemble de paramètres a été utilisé avec la propriété $ PsCmdlet.ParameterSetName. Par exemple:

if($PsCmdlet.ParameterSetName -eq "Name")
{
    Write-Host "Doing something with name here"
}

Ensuite, sur une note connexe, il y a également la validation des paramètres dans PowerShell. C'est l'une de mes fonctionnalités PowerShell préférées, et cela rend le code à l'intérieur de vos fonctions très propre. Il existe de nombreuses validations que vous pouvez utiliser. Quelques exemples sont:

function Get-Something
{
    Param
    (
         [Parameter(Mandatory=$true, Position=0)]
         [ValidatePattern('^Some.*')]
         [string] $Name,
         [Parameter(Mandatory=$true, Position=1)]
         [ValidateRange(10,100)]
         [int] $Id
    )
}

Dans le premier exemple, ValidatePattern accepte une expression régulière qui garantit que le paramètre fourni correspond à ce que vous attendez. Si ce n'est pas le cas, une exception intuitive est levée, vous indiquant exactement ce qui ne va pas. Donc, dans cet exemple, «Quelque chose» fonctionnerait bien, mais «Summer» ne passerait pas la validation.

ValidateRange garantit que la valeur du paramètre se situe entre la plage attendue pour un entier. Donc 10 ou 99 fonctionneraient, mais 101 lèverait une exception.

Un autre utile est ValidateSet, qui vous permet de définir explicitement un tableau de valeurs acceptables. Si quelque chose d'autre est entré, une exception sera levée. Il y en a d'autres aussi, mais le plus utile est probablement ValidateScript. Cela prend un bloc de script qui doit être évalué à $ true, donc le ciel est la limite. Par exemple:

function Get-Something
{
    Param
    (
         [Parameter(Mandatory=$true, Position=0)]
         [ValidateScript({ Test-Path $_ -PathType 'Leaf' })]
         [ValidateScript({ (Get-Item $_ | select -Expand Extension) -eq ".csv" })]
         [string] $Path
    )
}

Dans cet exemple, nous sommes assurés non seulement que $ Path existe, mais qu'il s'agit d'un fichier (par opposition à un répertoire) et possède une extension .csv. ($ _ fait référence au paramètre, à l'intérieur de votre bloc de script.) Vous pouvez également passer des blocs de script à plusieurs lignes beaucoup plus grands si ce niveau est requis, ou utiliser plusieurs blocs de script comme je l'ai fait ici. Il est extrêmement utile et offre de belles fonctions propres et des exceptions intuitives.

Vous appelez des fonctions PowerShell sans les parenthèses et sans utiliser la virgule comme séparateur. Essayez d'utiliser:

test "ABC" "DEF"

Dans PowerShell, la virgule (,) est un opérateur de tableau, par exemple

$a = "one", "two", "three"

Il définit $aun tableau avec trois valeurs.

Function Test([string]$arg1, [string]$arg2)
{
    Write-Host "`$arg1 value: $arg1"
    Write-Host "`$arg2 value: $arg2"
}

Test "ABC" "DEF"

Si vous êtes un développeur C # / Java / C ++ / Ruby / Python / Pick-A-Language-From-This-Century et que vous souhaitez appeler votre fonction avec des virgules, car c'est ce que vous avez toujours fait, alors vous avez besoin de quelque chose comme ça:

$myModule = New-Module -ascustomobject { 
    function test($arg1, $arg2) { 
        echo "arg1 = $arg1, and arg2 = $arg2"
    }
}

Appelez maintenant:

$myModule.test("ABC", "DEF")

et vous verrez

arg1 = ABC, and arg2 = DEF

Si vous ne savez pas (ou ne vous souciez pas) du nombre d'arguments que vous passerez à la fonction, vous pouvez également utiliser une approche très simple comme;

Code :

function FunctionName()
{
    Write-Host $args
}

Cela imprimerait tous les arguments. Par exemple:

FunctionName a b c 1 2 3

Production

a b c 1 2 3

Je trouve cela particulièrement utile lors de la création de fonctions qui utilisent des commandes externes qui pourraient avoir de nombreux paramètres différents (et facultatifs), mais s'appuie sur cette commande pour fournir des commentaires sur les erreurs de syntaxe, etc.

Voici un autre exemple du monde réel (création d'une fonction pour la commande tracert, que je déteste devoir me souvenir du nom tronqué);

Code :

Function traceroute
{
    Start-Process -FilePath "$env:systemroot\system32\tracert.exe" -ArgumentList $args -NoNewWindow
}

Si tu essayes:

PS > Test("ABC", "GHI") ("DEF")

vous obtenez:

$arg1 value: ABC GHI
$arg2 value: DEF

Vous voyez donc que les parenthèses séparent les paramètres

Si tu essayes:

PS > $var = "C"
PS > Test ("AB" + $var) "DEF"

vous obtenez:

$arg1 value: ABC
$arg2 value: DEF

Vous pouvez maintenant trouver une utilité immédiate des parenthèses - un espace ne deviendra pas un séparateur pour le paramètre suivant - à la place, vous avez une fonction eval.

Comme il s'agit d'une question fréquemment consultée, je tiens à mentionner qu'une fonction PowerShell doit utiliser des verbes approuvés ( Verb-Noun comme nom de fonction). La partie verbale du nom identifie l'action que l'applet de commande effectue. La partie nominale du nom identifie l'entité sur laquelle l'action est effectuée. Cette règle simplifie l'utilisation de vos applets de commande pour les utilisateurs avancés de PowerShell.

De plus, vous pouvez spécifier des choses comme si le paramètre est obligatoire et la position du paramètre:

function Test-Script
{
    [CmdletBinding()]
    Param
    (
        [Parameter(Mandatory=$true, Position=0)]
        [string]$arg1,

        [Parameter(Mandatory=$true, Position=1)]
        [string]$arg2
    )

    Write-Host "`$arg1 value: $arg1"
    Write-Host "`$arg2 value: $arg2"
}

Pour passer le paramètre à la fonction, vous pouvez soit utiliser la position :

Test-Script "Hello" "World"

Ou toi spécifiez le nom du paramètre :

Test-Script -arg1 "Hello" -arg2 "World"

Vous n'utilisez pas de parenthèses comme vous le faites lorsque vous appelez une fonction dans C #.

Je recommanderais de toujours passer les noms de paramètres lorsque vous utilisez plusieurs paramètres, car cela est plus lisible .

Je ne sais pas ce que vous faites avec la fonction, mais jetez un œil à l'utilisation du mot-clé 'param'. Il est un peu plus puissant pour passer des paramètres dans une fonction et la rend plus conviviale. Vous trouverez ci-dessous un lien vers un article trop complexe de Microsoft à ce sujet. Ce n'est pas aussi compliqué que l'article le donne.

Utilisation des paramètres

Aussi, voici un exemple d' une question sur ce site:

Vérifiez-le.

Function Test([string]$arg1, [string]$arg2)
{
    Write-Host "`$arg1 value: $arg1"
    Write-Host "`$arg2 value: $arg2"
}

Test("ABC") ("DEF")

J'ai déclaré ce qui suit plus tôt:

Le problème courant est l'utilisation de la forme singulière $arg, qui est incorrecte. Il doit toujours être pluriel comme$args .

Le problème n'est pas ça. En réalité,$arg peut être autre chose. Le problème était l'utilisation de la virgule et des parenthèses.

J'exécute le code suivant qui a fonctionné et la sortie suit:

Code:

Function Test([string]$var1, [string]$var2)
{
    Write-Host "`$var1 value: $var1"
    Write-Host "`$var2 value: $var2"
}

Test "ABC" "DEF"

Production:

$var1 value: ABC
$var2 value: DEF

Function Test {
    Param([string]$arg1, [string]$arg2)

    Write-Host $arg1
    Write-Host $arg2
}

Ceci est un bon params déclaration .

Voir about_Functions_Advanced_Parameters .

Et cela fonctionne en effet.

Vous pouvez également transmettre des paramètres dans une fonction comme celle-ci:

function FunctionName()
{
    Param ([string]$ParamName);
    # Operations
}

Je ne le vois pas mentionné ici, mais répartir vos arguments est une alternative utile et devient particulièrement utile si vous construisez les arguments d'une commande dynamiquement (par opposition à l'utilisationInvoke-Expression ). Vous pouvez répartir des tableaux pour les arguments positionnels et des tables de hachage pour les arguments nommés. Voici quelques exemples:

Splat avec des tableaux (arguments positionnels)

Test de connexion avec des arguments positionnels

Test-Connection www.google.com localhost

Avec éclaboussure de tableau

$argumentArray = 'www.google.com', 'localhost'
Test-Connection @argumentArray

Notez qu'en éclaboussant, nous référençons la variable éclaboussée avec un @au lieu d'un $. Il en va de même lorsque vous utilisez un Hashtable pour splatter également.

Splat With Hashtable (arguments nommés)

Test de connexion avec des arguments nommés

Test-Connection -ComputerName www.google.com -Source localhost

Avec éclaboussures de table de hachage

$argumentHash = @{
  ComputerName = 'www.google.com'
  Source = 'localhost'
}
Test-Connection @argumentHash

Splat arguments positionnels et nommés simultanément

Test-Connection avec les arguments positionnels et nommés

Test-Connection www.google.com localhost -Count 1

Splatting Array and Hashtables Together

$argumentHash = @{
  Count = 1
}
$argumentArray = 'www.google.com', 'localhost'
Test-Connection @argumentHash @argumentArray