L'obtention de tous les Paramètres Nommés à partir de Powershell vides compris, et régler

J'essaie de trouver un moyen d'obtenir toutes les informations sur les paramètres d'un script powershell. Ex script:

function test()
{
    Param(
        [string]$foo,
        [string]$bar,
        [string]$baz = "baz"
    )

    foreach ($key in $MyInvocation.BoundParameters.keys)
    {
        write-host "Parameter: $($key) -> $($MyInvocation.BoundParameters[$key])"
    }
}
test -foo "foo!"

J'aimerais obtenir les valeurs de $bar et $baz de façon dynamique, sans connaître les noms des paramètres à l'avance.

J'ai regardé à travers $MyInvocation propriétés et de méthodes mais je ne vois pas autre chose que les paramètres définis/passé.

Mise à jour 1:

Je suis proche de l'obtenir avec:

function test()
{
    Param(
        [string]$foo,
        [string]$bar,
        [string]$baz = "baz"
    )
    foreach($var in (get-variable -scope private))
    {
        write-host "$($var.name) -> $($var.value)"
    }
}
test -foo "foo!"

Si je pouvais filtrer les paramètres de script vs les paramètres par défaut, je serais bon pour aller.

Mise à jour 2:
Le final de la solution de travail ressemble à ceci:

function test {
    param (
          [string] $Bar = 'test'
        , [string] $Baz
        , [string] $Asdf
    )
    $ParameterList = (Get-Command -Name $MyInvocation.InvocationName).Parameters;
    foreach ($key in $ParameterList.keys)
    {
        $var = Get-Variable -Name $key -ErrorAction SilentlyContinue;
        if($var)
        {
            write-host "$($var.name) > $($var.value)"
        }
    }
}

test -asdf blah;

OriginalL'auteur Eric Longstreet | 2014-02-04

  1. 18

    Cochez cette solution. Il utilise la CmdletBinding() attribut, qui fournit des métadonnées supplémentaires grâce à l'utilisation de la $PSCmdlet variable intégrée. Vous pouvez:

    1. Récupérer dynamiquement la commande du nom, à l'aide $PSCmdlet
    2. Obtenir une liste des paramètres pour la commande, à l'aide de Get-Command
    3. Examiner la valeur de chaque paramètre, à l'aide de la Get-Variable applet de commande

    Code:

    function test {
    [CmdletBinding()]
    param (
          [string] $Bar = 'test'
        , [string] $Baz
        , [string] $Asdf
    )
    # Get the command name
    $CommandName = $PSCmdlet.MyInvocation.InvocationName;
    # Get the list of parameters for the command
    $ParameterList = (Get-Command -Name $CommandName).Parameters;

    # Grab each parameter value, using Get-Variable
    foreach ($Parameter in $ParameterList) {
        Get-Variable -Name $Parameter.Values.Name -ErrorAction SilentlyContinue;
        #Get-Variable -Name $ParameterList;
    }
}

test -asdf blah;

    Sortie

    La sortie de la commande ressemble à ceci:

    Name                           Value                                           
----                           -----                                           
Bar                            test                                            
Baz                                                                            
Asdf                           blah
    Oui! Ce type d'approche est exactement ce que je cherchais. J'ai fini par avoir à retoucher le script un peu parce que j'ai continué à obtenir les valeurs null, mais c'est certainement le chemin à parcourir. Merci!
    Heureux d'entendre cela a fonctionné pour vous. 🙂
    Je pense que vous pouvez ignorer le $PSCmdlet et Get-Command et il suffit d'utiliser $MyInvocation.MyCommand.Parameters, et que vous pouvez simplement en boucle sur Parameters.Keys pour obtenir les noms des paramètres.
    Également intéressant de noter que $PSCmdlet ne fonctionne que si vous avez explicite [CmdletBinding()], alors que $MyInvocation.MyCommand fonctionne pour toutes les fonctions.

    OriginalL'auteur Trevor Sullivan

  2. 11

    La lecture de la valeur dynamiquement utiliser le get-variable fonction /applet de commande

    write-host (get-variable "foo")

    Pour imprimer tous les paramètres, procédez de la manière suivante 

    foreach ($key in $MyInvocation.BoundParameters.keys)
{
    $value = (get-variable $key).Value 
    write-host "$key -> $value"
}
    Merci pour ça, n'était pas conscient de ce que commandlet. Cependant, je suis à la recherche pour obtenir les valeurs de manière dynamique, sans connaître les noms des variables.
    ma mise à jour de l'échantillon ne pas utiliser toute la correction des noms. Il va tout droit à travers le paramètre de limite de la liste
    Désolé manqué, cependant, il ressemble $MyInvocation.BoundParameters.les touches ne contient pas de $bar et $baz, seule réelle bornée paramètres. Je suis vraiment intéressé à obtenir $baz qui pourraient avoir une valeur par défaut définie déjà et n'est jamais passé

    OriginalL'auteur JaredPar

  3. 2

    J'ai trouvé cela plus utile pour la PS4 (Windows 2012 R2) - il comprend par défaut les valeurs /paramètres optionnels:

    $cmdName = $MyInvocation.InvocationName
$paramList = (Get-Command -Name $cmdName).Parameters
foreach ( $key in $paramList.Keys ) {
    $value = (Get-Variable $key -ErrorAction SilentlyContinue).Value
    if ( $value -or $value -eq 0 ) {
        Write-Host "$key -> $value"
    }
}

    OriginalL'auteur cslotty

  4. 1

    J'ai joué avec les 2 solutions que j'ai aimé dans ce fil, ils travaillent tous les deux.
    cependant j'avais besoin pour produire une erreur sur le paramètre absent pour un script de compilation

       $cmdName = $MyInvocation.InvocationName 
   $paramList = (Get-Command -Name $cmdName).Parameters
     foreach ( $key in $paramList.Keys ) {
     $value = (Get-Variable $key -ErrorAction Stop)
     #Write-Host $value.Value #remove comment for error checking
        if ([string]::IsNullOrEmpty($value.Value)){ 
        $(throw ("$key is a mandatory value please declare with -$key <Required value> " ))
        }
       }

    OriginalL'auteur Kelly Davis

  5. 0

    Espérons-le, certains peuvent trouver ce one-liner utile:

    function test()
{
    Param(
        [string]$foo,
        [string]$bar,
        [string]$baz = "baz"
    )

    $MyInvocation.MyCommand.Parameters | Format-Table -AutoSize @{ Label = "Key"; Expression={$_.Key}; }, @{ Label = "Value"; Expression={(Get-Variable -Name $_.Key -EA SilentlyContinue).Value}; }
}
test -foo "foo!"

    Résultat

    Keys Value
---- -----
foo  foo! 
bar       
baz  baz

    OriginalL'auteur Janos