PowerShell
Zmienne w PowerShell

Wprowadzenie

Prosta zmienna

Wszystkie zmienne w PowerShell zaczynają się od znaku dolara amerykańskiego ( $ ). Najprostszym przykładem tego jest:

$foo = "bar"

Ta instrukcja przydziela zmienną o nazwie foo o wartości ciągu „bar”.

Usuwanie zmiennej

Aby usunąć zmienną z pamięci, można użyć polecenia cmdlet Remove-Item . Uwaga: Nazwa zmiennej NIE zawiera $ .

Remove-Item Variable:\foo

Variable ma dostawcę, który pozwala większości poleceń cmdlet * na elementach działać podobnie jak systemy plików.

Inną metodą usunięcia zmiennej jest użycie polecenia cmdlet Remove-Variable i jego aliasu rv

$var = "Some Variable" #Define variable 'var' containing the string 'Some Variable'
$var #For test and show string 'Some Variable' on the console

Remove-Variable -Name var
$var 

#also can use alias 'rv'
rv var

Zakres

Domyślnym zakresem dla zmiennej jest otaczający kontener. Jeśli znajduje się poza skryptem lub innym kontenerem, wówczas zakres jest Global . Aby określić zakres , jest on poprzedzony nazwą zmiennej $scope:varname tak:

$foo = "Global Scope"
function myFunc {
    $foo = "Function (local) scope"
    Write-Host $global:foo
    Write-Host $local:foo
    Write-Host $foo
}
myFunc
Write-Host $local:foo
Write-Host $foo

Wynik:

    Global Scope
    Function (local) scope
    Function (local) scope
    Global Scope
    Global Scope

Odczytywanie wyniku CmdLet

Domyślnie program PowerShell zwraca dane wyjściowe do wywołującej jednostki. Rozważ poniższy przykład,

Get-Process -Name excel   

To po prostu zwróci działający proces, który pasuje do nazwy excel, do jednostki wywołującej. W takim przypadku host programu PowerShell. Drukuje coś takiego,

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id  SI ProcessName                                                                                                                     
-------  ------    -----      ----- -----   ------     --  -- -----------                                                                                                                     
   1037      54    67632      62544   617     5.23   4544   1 EXCEL 

Teraz, jeśli przypiszesz wynik do zmiennej, po prostu nic nie wydrukuje. I oczywiście zmienna zawiera dane wyjściowe. (Czy to ciąg znaków, Object - Dowolny typ w tym zakresie)

$allExcel = Get-Process -Name excel

Załóżmy, że masz scenariusz, w którym chcesz przypisać zmienną nazwę dynamiczną, możesz użyć parametru -OutVariable

Get-Process -Name excel -OutVariable AllRunningExcel

Zauważ, że brakuje tutaj „$”. Główną różnicą między tymi dwoma przypisaniami jest to, że drukuje również dane wyjściowe oprócz przypisywania ich do zmiennej AllRunningExcel. Możesz także przypisać ją do innej zmiennej.

$VarOne = Get-Process -Name excel -OutVariable VarTwo

Chociaż powyższy scenariusz jest bardzo rzadki, obie zmienne $ VarOne i $ VarTwo będą miały tę samą wartość.

Rozważ to teraz,

Get-Process -Name EXCEL -OutVariable MSOFFICE
Get-Process -Name WINWORD -OutVariable +MSOFFICE

Pierwsza instrukcja po prostu pobierałaby proces Excel i przypisywała go do zmiennej MSOFFICE, a następnie uruchamiałaby procesy tekstowe ms i „dołączała” ją do istniejącej wartości MSOFFICE. To wyglądałoby mniej więcej tak

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id  SI ProcessName                                                                                                                     
-------  ------    -----      ----- -----   ------     --  -- -----------                                                                                                                     
   1047      54    67720      64448   618     5.70   4544   1 EXCEL                                                                                                                           
   1172      70    50052      81780   584     1.83  14968   1 WINWORD     

Przypisanie listy wielu zmiennych

Program PowerShell umożliwia wielokrotne przypisywanie zmiennych i traktuje prawie wszystko jak tablicę lub listę. Oznacza to, że zamiast robić coś takiego:

$input = "foo.bar.baz"
$parts = $input.Split(".")
$foo = $parts[0]
$bar = $parts[1]
$baz = $parts[2]

Możesz po prostu to zrobić:

$foo, $bar, $baz = $input.Split(".")

Ponieważ Powershell traktuje przypisania w ten sposób jak listy, jeśli na liście jest więcej wartości niż elementów na liście zmiennych do przypisania, ostatnia zmienna staje się tablicą pozostałych wartości. Oznacza to, że możesz także wykonywać takie czynności:

$foo, $leftover = $input.Split(".") #Sets $foo = "foo", $leftover = ["bar","baz"]
$bar = $leftover[0] # $bar = "bar"
$baz = $leftover[1] # $baz = "baz"

Tablice

Deklaracja tablicy w Powershell jest prawie taka sama jak tworzenie dowolnej innej zmiennej, tzn. Używasz składni $name = . Elementy w tablicy są deklarowane przez rozdzielenie ich przecinkami ( , ):

$myArrayOfInts = 1,2,3,4
$myArrayOfStrings = "1","2","3","4"

Dodawanie do arry

Dodawanie do tablicy jest tak proste, jak użycie operatora + :

$myArrayOfInts = $myArrayOfInts + 5
//now contains 1,2,3,4 & 5!

Łączenie tablic razem

Ponownie jest to tak proste, jak użycie operatora +

$myArrayOfInts = 1,2,3,4
$myOtherArrayOfInts = 5,6,7
$myArrayOfInts = $myArrayOfInts + $myOtherArrayOfInts
//now 1,2,3,4,5,6,7