PowerShell
Variabelen in PowerShell

Invoering

Eenvoudige variabele

Alle variabelen in powershell beginnen met een Amerikaanse dollarteken ( $ ). Het eenvoudigste voorbeeld hiervan is:

$foo = "bar"

Deze instructie wijst een variabele toe met de naam foo met een tekenreekswaarde "bar".

Een variabele verwijderen

Om een variabele uit het geheugen te verwijderen, kan men de cmdlet Remove-Item . Opmerking: de variabelenaam bevat GEEN $ .

Remove-Item Variable:\foo

Variable heeft een provider waarmee de meeste * -item-cmdlets op dezelfde manier kunnen werken als bestandssystemen.

Een andere methode om de variabele te verwijderen, is het gebruik van de cmdlet Remove-Variable en zijn 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

strekking

De standaard scope een variabele is de omsluitende verpakking. Als het zich buiten een script of andere container bevindt, is het bereik Global . Om een bereik op te geven, wordt het voorafgegaan door de variabelenaam $scope:varname like so:

$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

Output:

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

Een CmdLet-uitvoer lezen

Standaard stuurt powershell de uitvoer terug naar de aanroepende entiteit. Beschouw het onderstaande voorbeeld,

Get-Process -Name excel   

Dit zou eenvoudigweg het lopende proces dat overeenkomt met de naam Excel, terugsturen naar de aanroepende entiteit. In dit geval de PowerShell-host. Het drukt zoiets af,

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

Als u nu de uitvoer toewijst aan een variabele, drukt deze gewoon niets af. En natuurlijk houdt de variabele de uitvoer vast. (Of het nu een string is, Object - Elk type wat dat betreft)

$allExcel = Get-Process -Name excel

Stel dat u een scenario hebt waarin u een variabele wilt toewijzen met een dynamische naam, u kunt de parameter -OutVariable

Get-Process -Name excel -OutVariable AllRunningExcel

Merk op dat de '$' hier ontbreekt. Een groot verschil tussen deze twee toewijzingen is dat het ook de uitvoer afdrukt, behalve deze toe te wijzen aan de variabele AllRunningExcel. U kunt er ook voor kiezen om het toe te wijzen aan een andere variabele.

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

Hoewel het bovenstaande scenario zeer zeldzaam is, hebben beide variabelen $ VarOne en $ VarTwo dezelfde waarde.

Overweeg dit nu,

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

De eerste instructie zou eenvoudig het excel-proces krijgen en toewijzen aan de variabele MSOFFICE, en vervolgens zou MS Word-processen actief worden en het aan de bestaande waarde van MSOFFICE toevoegen. Het zou er ongeveer zo uitzien,

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     

Lijsttoewijzing van meerdere variabelen

Powershell maakt meervoudige toewijzing van variabelen mogelijk en behandelt bijna alles als een array of lijst. Dit betekent dat in plaats van zoiets te doen:

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

U kunt dit eenvoudig doen:

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

Omdat Powershell toewijzingen op deze manier als lijsten behandelt, als de lijst meer waarden bevat dan items in uw lijst met variabelen waaraan ze worden toegewezen, wordt de laatste variabele een array van de resterende waarden. Dit betekent dat u dit soort dingen ook kunt doen:

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

arrays

Matrixdeclaratie in Powershell is bijna hetzelfde als het instantiëren van een andere variabele, dat wil zeggen dat u een $name = syntax gebruikt. De items in de array worden gedeclareerd door ze te scheiden door komma's ( , ):

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

Toevoegen aan een arry

Toevoegen aan een array is net zo eenvoudig als het gebruik van de operator + :

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

Arrays combineren

Nogmaals, dit is zo eenvoudig als het gebruik van de operator +

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