Jak przekazać wiele parametrów do funkcji w PowerShell?

Jeśli mam funkcję, która akceptuje więcej niż jeden parametr łańcuchowy, pierwszy parametr wydaje się otrzymać wszystkie dane przypisane do niego, a pozostałe parametry są przekazywane jako puste.

Szybki skrypt testowy:

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

Test("ABC", "DEF")

Wygenerowane dane wyjściowe to

$arg1 value: ABC DEF
$arg2 value: 

Prawidłowe wyjście powinno być:

$arg1 value: ABC
$arg2 value: DEF

Wydaje się, że jest to spójne między wersją 1 i 2 na wielu komputerach, więc oczywiście robię coś złego. Czy ktoś może dokładnie wskazać, co?

Parametry wywołań funkcji w programie PowerShell (wszystkie wersje) są rozdzielane spacjami, a nie przecinkami . Ponadto nawiasy są całkowicie niepotrzebne i spowodują błąd analizy w programie PowerShell 2.0 (lub nowszym), jeśli Set-StrictModejest aktywny. Argumenty w nawiasach są używane tylko w metodach .NET.

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

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

Podano już prawidłową odpowiedź, ale ten problem wydaje się na tyle rozpowszechniony, że uzasadnia dodatkowe szczegóły dla osób chcących zrozumieć subtelności.

Dodałbym to tylko jako komentarz, ale chciałem załączyć ilustrację - oderwałem to od mojej skróconej tabeli funkcji programu PowerShell. Zakłada się, że sygnatura funkcji f to f($a, $b, $c):

W ten sposób można wywołać funkcję z parametrami pozycyjnymi oddzielonymi spacjami lub nazwanymi parametrami niezależnymi od kolejności . Inne pułapki ujawniają, że musisz być świadomy przecinków, nawiasów i białych znaków.

Więcej informacji można znaleźć w moim artykule W dół króliczej nory: studium potoków, funkcji i parametrów programu PowerShell . Artykuł zawiera również link do szybkiego odniesienia / tabeli ściennej.

Jest tu kilka dobrych odpowiedzi, ale chciałem zwrócić uwagę na kilka innych rzeczy. Parametry funkcji są w rzeczywistości miejscem, w którym świeci PowerShell. Na przykład możesz mieć parametry nazwane lub pozycyjne w funkcjach zaawansowanych, takich jak:

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

Następnie możesz albo wywołać go, podając nazwę parametru, albo możesz po prostu użyć parametrów pozycyjnych, ponieważ je wyraźnie zdefiniowałeś. Więc którykolwiek z nich działałby:

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

Pierwszy przykład działa, mimo że Namepodany jest drugi, ponieważ jawnie użyliśmy nazwy parametru. Drugi przykład działa jednak w oparciu o pozycję, więc Namemusiałby być pierwszy. Jeśli to możliwe, zawsze staram się zdefiniować pozycje, aby obie opcje były dostępne.

PowerShell ma również możliwość definiowania zestawów parametrów. Wykorzystuje to zamiast przeciążania metod i znów jest całkiem przydatne:

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
    )
}

Teraz funkcja przyjmie nazwę lub identyfikator, ale nie jedno i drugie. Możesz użyć ich pozycjonować lub według nazwy. Ponieważ są innego typu, PowerShell to rozwiąże. Wszystko to działałoby:

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

Możesz także przypisać dodatkowe parametry do różnych zestawów parametrów. (To był oczywiście dość prosty przykład.) Wewnątrz funkcji można określić, który zestaw parametrów został użyty za pomocą właściwości $ PsCmdlet.ParameterSetName. Na przykład:

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

Następnie, w powiązanej notatce dodatkowej, istnieje również sprawdzanie poprawności parametrów w PowerShell. Jest to jedna z moich ulubionych funkcji PowerShell i sprawia, że ​​kod w twoich funkcjach jest bardzo czysty. Istnieje wiele walidacji, których możesz użyć. Oto kilka przykładów:

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

W pierwszym przykładzie ValidatePattern akceptuje wyrażenie regularne, które zapewnia, że ​​podany parametr odpowiada oczekiwaniom. Jeśli nie, zgłaszany jest intuicyjny wyjątek, który mówi dokładnie, co jest nie tak. W tym przykładzie „Coś” działałoby dobrze, ale „Lato” nie przejdzie weryfikacji.

ValidateRange zapewnia, że ​​wartość parametru mieści się w zakresie oczekiwanym dla liczby całkowitej. Więc 10 lub 99 działałoby, ale 101 rzuciłoby wyjątek.

Kolejnym przydatnym jest ValidateSet, który pozwala jawnie zdefiniować tablicę dopuszczalnych wartości. W przypadku wprowadzenia czegoś innego zostanie zgłoszony wyjątek. Są też inne, ale prawdopodobnie najbardziej przydatnym jest ValidateScript. To wymaga bloku skryptu, który musi mieć wartość $ true, więc niebo jest granicą. Na przykład:

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

W tym przykładzie mamy pewność, że nie tylko istnieje $ Path, ale jest to plik (w przeciwieństwie do katalogu) i ma rozszerzenie .csv. ($ _ odnosi się do parametru, gdy znajduje się w twoim bloku skryptu.) Możesz również przekazać znacznie większe, wieloliniowe bloki skryptu, jeśli ten poziom jest wymagany, lub użyć wielu bloków skryptu, jak ja tutaj. Jest niezwykle przydatny i zapewnia ładne czyste funkcje i intuicyjne wyjątki.

Funkcje programu PowerShell wywoływane są bez nawiasów i bez przecinka jako separatora. Spróbuj użyć:

test "ABC" "DEF"

W PowerShell przecinek (,) jest operatorem tablicowym, np

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

Ustawia $ana tablicę z trzema wartościami.

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

Test "ABC" "DEF"

Jeśli jesteś programistą C # / Java / C ++ / Ruby / Python / Pick-A-Language-From-This-Century i chcesz wywołać swoją funkcję przecinkami, ponieważ zawsze tak robiłeś, potrzebujesz czegoś lubię to:

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

Teraz zadzwoń:

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

i zobaczysz

arg1 = ABC, and arg2 = DEF

Jeśli nie wiesz (lub nie obchodzi Cię), ile argumentów przekażesz funkcji, możesz również zastosować bardzo proste podejście;

Kod :

function FunctionName()
{
    Write-Host $args
}

To wypisze wszystkie argumenty. Na przykład:

FunctionName a b c 1 2 3

Wynik

a b c 1 2 3

Uważam to za szczególnie przydatne podczas tworzenia funkcji, które używają poleceń zewnętrznych, które mogą mieć wiele różnych (i opcjonalnych) parametrów, ale polegają na tym poleceniu, aby przekazywać opinie na temat błędów składniowych itp.

Oto kolejny przykład ze świata rzeczywistego (tworzenie funkcji do polecenia tracert, której nienawidzę, pamiętając skróconą nazwę);

Kod :

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

Jeśli spróbujesz:

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

dostajesz:

$arg1 value: ABC GHI
$arg2 value: DEF

Widzisz więc, że nawiasy oddzielają parametry

Jeśli spróbujesz:

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

dostajesz:

$arg1 value: ABC
$arg2 value: DEF

Teraz możesz znaleźć natychmiastową użyteczność nawiasów - spacja nie stanie się separatorem dla następnego parametru - zamiast tego masz funkcję eval.

Ponieważ jest to często zadawane pytanie, chcę wspomnieć, że należy użyć funkcji PowerShell zatwierdzonych czasowników ( rzeczownik-czasownik jako nazwa funkcji). Czasownikowa część nazwy identyfikuje akcję wykonywaną przez cmdlet. Rzeczownikowa część nazwy identyfikuje byt, na którym wykonywana jest akcja. Ta reguła upraszcza korzystanie z poleceń cmdlet dla zaawansowanych użytkowników PowerShell.

Możesz także określić takie rzeczy, jak parametr obowiązkowy i pozycję parametru:

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"
}

Aby przekazać parametr do funkcji, możesz użyć pozycji :

Test-Script "Hello" "World"

Lub określasz parametr nazwę :

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

Nie używasz nawiasów jak w przypadku wywoływania funkcji w języku C #.

Zalecam, aby zawsze podawać nazwy parametrów, gdy jest używany więcej niż jeden parametr, ponieważ jest to bardziej czytelne .

Nie wiem, co robisz z funkcją, ale spójrz na użycie słowa kluczowego „param”. Jest o wiele bardziej wydajny do przekazywania parametrów do funkcji i czyni go bardziej przyjaznym dla użytkownika. Poniżej znajduje się link do zbyt złożonego artykułu Microsoft na ten temat. To nie jest tak skomplikowane, jak brzmi ten artykuł.

Użycie Param

Oto przykład z pytania na tej stronie:

Sprawdź to.

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

Test("ABC") ("DEF")

Powiedziałem wcześniej:

Częstym problemem jest używanie formy pojedynczej $arg, co jest niepoprawne. Zawsze powinno być w liczbie mnogiej jak$args .

Problem nie jest taki. W rzeczywistości $argmoże być cokolwiek innego. Problem polegał na użyciu przecinka i nawiasów.

Uruchamiam następujący kod, który działał, a dane wyjściowe są następujące:

Kod:

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

Test „ABC” „DEF”

Wynik:

$var1 value: ABC
$var2 value: DEF

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

    Write-Host $arg1
    Write-Host $arg2
}

To jest właściwa paramsdeklaracja.

Zobacz about_Functions_Advanced_Parameters .

I to naprawdę działa.

Możesz przekazać parametry w funkcji takiej jak ta:

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

Nie widzę tu o tym wspominanych, ale splatanie argumentów jest przydatną alternatywą i staje się szczególnie przydatne, jeśli budujesz argumenty do polecenia dynamicznie (w przeciwieństwie do używania Invoke-Expression). Możesz splatać się z tablicami dla argumentów pozycyjnych i tablicami skrótów dla nazwanych argumentów. Oto kilka przykładów:

Ikona z tablicami (argumenty pozycyjne)

Połączenie testowe z argumentami pozycyjnymi

Test-Connection www.google.com localhost

Z rozpryskiwaniem szyku

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

Zauważ, że podczas rozpryskiwania odwołujemy się do zmiennej splatted @zamiast zamiast $. Podobnie jest w przypadku używania Hashtable do rozpryskiwania.

Ikona z Hashtable (nazwane argumenty)

Połączenie testowe z nazwanymi argumentami

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

Z Hashtable Splatting

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

Argumenty pozycyjne i nazwane jednocześnie

Połączenie testowe z argumentami pozycyjnymi i nazwanymi

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

Splatting Array i Hashtables Razem

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