Variabler

Variabler i PowerShell tillåter oss lagra information som vid senare tillfällen kan återanvändas.  Att kombinera variabler med PowerShell kommando resulterar oftast i komplexa kod men samtidigt logiska på grund av att PowerShell fungerar som ett ramverk.

Variabler är som lådor i vilka sparas olika värde som i senare tillfälle kan användas. Värdena är oftast numeriska eller text. Text är en sekvens av bokstäver som utformar  ord och därmed är flera bokstäver som lagras i en variabel. Text kallas i detta sammanhang STRÄNG eller på engelska STRING. Strängar definieras som System.String och numeriska värd som System.Int32.

Det intressanta med dessa värden är att de kan också betraktas som både och. PowerShell kan avgöra värdetyper av indata åt oss, men det är bättre att vi gör det själva.

Variabler kan skapas lätt, man behöver ett namn och ett cmdlet. Dollartecknet föregår alltid namnet. Till exempel om jag vill att namnet Chalo Reyes ska sparas i en variabel skulle jag tänka mig döpa variabeln till $CRnamn.

För att skapa variabel med namn String (namnet antyder att i den ska lagras text eller numeriska värde som ska betraktas som text) exekvera:
PS C:\>$String = ”Detta är en TextSträng och därför omges med citationstecken.”
För att få fram variabelns värde exekvera:
PS C:\>$String
Detta är en TextSträng och därför omges med citationstecken.
För att skapa variabel ett och lagra i den nummer 1 exekvera:
PS C:\>$ett = 1
För att få fram variabelns värde exekvera:
PS C:\>$ett

Datatyp omvandlare

PowerShell har en inbyggd datatyp omvandlare som definierar själv värdet. PowerShell identifierar indata, omvandlar den till rätt typ och presenterar det. Omvandlingen kan ändra den ursprungliga in-data men PowerShell omvandlare är optimerat så att minst data går förlorad.

För att bekräfta om variabeln $ett innehåller ett numerisk värde exekvera:
PS C:\>$ett.GetType()
Kommandot ovan visar att variabelns värde är av typ Int32 (heltal)
För att lagra ett decimaltal i en variabel kan vi exekvera:
PS C:\>$Decimal = 1.5
För att få fram datatypen exekvera:
PS C:\>$Decimal.GetType()
Datatypen är definierat som System.Double

Numeriska värde i variabler ger möjlighet till matematiska uträkningar. Men strängar och numeriska värde tillsammans kan ge oönskade resultat. Ett nummer kan också betraktas som sträng, därmed kan nej utföras matematiska beräkningar.

För att skapa variabel $uno och samtidigt tilldela ett numeriska värde exekvera:
PS C:\> $uno = 1
För att få fram datatypen i en justerad tabell exekvera:
PS C:\> $uno.GetType() | ft -a
För att utföra additionen 1 + $uno exekvera:
PS C:\> 1 + $uno
2
För att utföra samma additionen, men utan dollartecken exekvera:
PS C:\> 1 + uno
Det genererar fel meddelande eftersom kan inte 1 adderas med text uno
För att placera ihop text uno-ett exekvera:
PS C:\> uno + -ett                                    (genererar felmeddelande)
För att placera ihop text uno-ett exekvera:
PS C:\> ”uno” + ”-ett”
För att placera ihop texten ”uno betyder ” och 1 exekvera
PS C:\> ”uno betyder ” + ”1”
uno betyder 1
För att lagra resultat av en addition i variabel $sum_a exekvera:
PS C:\>$sum_a= 1 + 1
PS C:\>$sum_a
2
För att addera 1 och ”1” och lagra resultatet i $sum_b exekvera:
PS C:\>$sum_b= 1 +” 1″
PS C:\>$sum_b
2
Utdata visar att variabeln $sum_b innehåller värdet 2. PS identifierade den första indata som heltal och den andra har konverteras också till heltal, därmed resultatet är 2.
För att addera ”1” och 1 och lagra resultatet i $sum_c exekvera:
PS C:\>$sum_c= ”1” + 1
PS C:\>$sum_c
11
utdata visar att variabeln $sum_c innehåller värdet 11, inte elva utan 1 bredvid 1. PS identifierar första termen som sträng och därmed också den andra termen.

Avgör du själv

För att definiera själv en datatyp ska indata deklareras antingen som string eller Int. När en variabel skapas anges först datatypen i hakparenteser exempelvis [int]$sum eller [string]$mittNamn. Även om datatypen har fördefinierats konverteras de av PS beroende på hur variablerna används. Tumregeln är att den första termen avgör den andra.

För att deklarera variabel $mittNamn till System.String exekvera:
PS C:\>[string]$mittNamn = ”Chalo Reyes”
PS C:\>$mittNamn
Chalo Reyes
För att få ett numeriskt värde omvandlat till ett strängvärde kan vi exekvera:
PS C:\>$num = 123
PS C:\>($num).GetType()
PS C:\>[string]$num = 123
PS C:\>($num).GetType()
PS C:\>$num
123
Kommandot ovan betyder att variabelns numeriska värde 123 omvandlas till textsträng! Det kan verifieras med några kommando:
PS C:\>[string]$string_b = $num + 4
PS C:\>$string_b
1234
Samma kommando som ovan men nu 4 först:
PS C:\>[string]$string_c = 4 + $num
PS C:\>$string_c
127
PS C:\>($string_c).GetType()
PS envisas att konvertera datatypen därmed resultatet 4 + 123 = 127, men datatypen är sträng!
För att definiera ett objekt som skall behandlas som heltal exekvera:
PS C:\>[int]$heltal = 20
PS C:\>$heltal
20
Variabeln $Heltal har definierats som Integer (heltal) därmed alla numeriska input skickas till System.Int32
Vad händer om definitionen är heltal, men tilldelat värde är decimalt?
PS C:\>[int]$heltal = 20.5
PS C:\$heltal
20
PS avrundar till heltal (20.1 fram till 20.5 avrundas 20 och 20.6 till 20.9 avrundas 21)
Om vi skickar in ett decimaltal till en variabel utan att deklarera dess typ sköter PowerShell typomvandlingen åt oss.
PS C:\>$decital = 23.23
PS C:\>$decital.GetType().FullName
System.Double

Miljövariabler

Windows PowerShell Environment låter dig komma åt, lägga till, ändra, rensa och ta bort Windows-miljövariabler. Ändringar i miljövariablerna påverkar endast den aktuella sessionen. För att spara ändringarna permanent lägger du till dessa i Windows PowerShell-profilen eller genom att exportera ändringarna med kommandot Export-Console.

Miljövariabler är tillgängliga via enheten env:

För att få en komplett lista på samtliga miljövariabler i vårt system exekvera:
PS C:\>Get-ChildItem env:
För att få fram datorns namn exekvera:
PS C:\>Get-ChildItem env:COMPUTERNAME
För att få fram datorns namn exekvera:
PS C:\>$env:COMPUTERNAME
För att få använda miljövariablerna i strängar exekvera:
PS C:\>”Min dators namn: $env:COMPUTERNAME”
Min dators namn: st-w8r2-dc1f
För att ändra datorns namn (miljövariabler) kan vi exekvera:
PS C:\>$env:COMPUTERNAME = ”Min dator”
PS C:\>$env:COMPUTERNAME
Min dator
Observera att förändringar av miljövariabler gäller endast i aktiv sessionen. Det kan bekräftas genom att starta ett nytt cmd.exe och exekvera kommandot %computername%

Inbyggda variabler

PowerShell innehåller, förutom miljövariabler, ett stort antal inbyggda variabler. Dessa variabler ger oss tillgång till information om exekveringsmiljön, fel som har uppstått och mycket mer. Inbyggda variabler finns tillgängliga i varje enhet (psdrive).

För att få fram en lista på samtliga automatiska variabler lagrade i PowerShell i enheten Variable, inklusive de vi själva har skapat, exekvera:
PS C:\>Get-ChildItem Variable:
Listan innehåller bland annat $Home, $Host, $Profile, $pshome
För att få fram PowerShell installationskatalog exekvera:
PS C:\>$PSHOME
C:\Windows\System32\WindowsPowerShell\v1.0:
För att få fram användarens hemmakatalog exekvera:
PS C:\>$HOME
För att få fram den inloggade användarens konsolinställningar, PS version, exekvera:
PS C:\>$HOST
För att få fram PS användarens profil exekvera
PS C:\>$Profile
c:\Users\Chalo\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1