PowerShell
Variabler i PowerShell

Introduktion

Enkel variabel

Alla variabler i powershell börjar med ett US-tecken ( $ ). Det enklaste exemplet på detta är:

$foo = "bar"

Detta uttalande tilldelar en variabel som heter foo med ett strängvärde "bar".

Ta bort en variabel

För att ta bort en variabel från minnet kan man använda cmdleten Remove-Item objekt. Obs: Variabelns namn inkluderar INTE $ .

Remove-Item Variable:\foo

Variable har en leverantör som tillåter de flesta * -emem-cmdlets att fungera som filsystem.

En annan metod för att ta bort variabel är att använda Remove-Variable cmdlet och dess alias 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

Omfattning

Standard utrymme för en variabel är den omslutande behållare. Om utanför ett skript, eller annan behållare, är omfattningen Global . För att ange en räckvidd förhindras den till variabelnamnet $scope:varname som så:

$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

Produktion:

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

Läser en CmdLet-utgång

Som standard returnerar powershell utdata till den uppringande enheten. Tänk nedan exempel,

Get-Process -Name excel   

Detta skulle helt enkelt, returnera den löpande processen som matchar namnet excel, till den uppringande enheten. I detta fall PowerShell-värden. Det skriver ut något liknande,

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

Om du nu tilldelar utskriften till en variabel kommer den helt enkelt inte att skriva ut någonting. Och naturligtvis har variabeln utmatningen. (Var det en sträng, Objekt - Vilken typ som helst för den delen)

$allExcel = Get-Process -Name excel

Så låt oss säga att du har ett scenario där du vill tilldela en variabel med ett dynamiskt namn, du kan använda -OutVariable parametern

Get-Process -Name excel -OutVariable AllRunningExcel

Observera att '$' saknas här. En stor skillnad mellan dessa två uppdrag är att den också skriver ut utöver att tilldela den till variabeln AllRunningExcel. Du kan också välja att tilldela den till en annan variabel.

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

Men ovanstående scenario är mycket sällsynt, båda variablerna $ VarOne och $ VarTwo kommer att ha samma värde.

Tänk nu på detta,

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

Det första uttalandet skulle helt enkelt få excel-processen och tilldela den till MSOFFICE-variabeln, och nästa skulle få MS-ordprocesser att köra och "Bifoga" det till det befintliga värdet på MSOFFICE. Det skulle se ut så här,

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     

Lista tilldelning av flera variabler

Powershell tillåter flera tilldelning av variabler och behandlar nästan allt som en matris eller en lista. Detta betyder att istället för att göra något liknande:

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

Du kan helt enkelt göra detta:

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

Eftersom Powershell behandlar uppdrag på detta sätt som listor, om det finns fler värden i listan än objekt i din lista med variabler att tilldela dem, blir den sista variabeln en matris med de återstående värdena. Detta betyder att du också kan göra saker som detta:

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

arrayer

Arraydeklaration i Powershell är nästan densamma som att instansera någon annan variabel, dvs att du använder en $name = syntax. Objekten i arrayen deklareras genom att separera dem med komma ( , ):

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

Lägger till en arry

Att lägga till en matris är lika enkelt som att använda operatören + :

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

Kombinera matriser tillsammans

Återigen är detta lika enkelt som att använda + -operatören

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