PowerShell har en inbyggd datatypomvandlare, vilket innebär att PowerShell själv definierar datatypen. Denna omvandlare kan ändra den ursprungliga in-data, men PowerShell är optimerat för att minimera dataförlust under omvandlingsprocessen.

Numeriska värden lagrade i variabler möjliggör genomförandet av matematiska uträkningar. Dock kan kombinationen av strängar och numeriska värden resultera i oönskade resultat. Ett numeriskt värde kan även tolkas som en sträng, vilket kan förhindra korrekt genomförande av matematiska beräkningar.

För att illustrera detta med några exempel, låt oss titta på hur PowerShell hanterar numeriska värden och strängar i olika situationer:

1. Skapa en variabel och bestäm datatyp samt presentera utdata i en tabell:
   • PS C:\> $uno = 1
   • PS C:\>$uno.GetType() | Format-Table -AutoSize
2. Utföra en addition med numeriska värden:
   • PS C:\> 1 + $uno
   • Utdata: 2
3. Konkatenera strängar:
   • PS C:\>”uno betyder ” + ”1”
   • Utdata: uno betyder 1
   • Observera att det numeriska värdet anges nu mellan citationstecken.
4. Lagra resultatet av en addition i en variabel:
   • PS C:\>$sum_a= 1 + 1
   • PS C:\>$sum_a
   • Utdata: 2
5. Addera 1 och ”1” och lagra resultatet i $sum_b:
   • PS C:\>$sum_b= 1 +” 1″
   • PS C:\>$sum_b
   • Utdata: 2
   • Utdata visar att variabeln $sum_b innehåller värdet 2. PS identifierade den första indata som heltal och därmed konverteras det andra värdet också till heltal.
6. Addera “1” och 1 och lagra resultatet i $sum_c:
   • PS C:\>$sum_c= ”1” + 1
   • PS C:\>$sum_c
   • Utdata: 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 själv definiera datatypen bör indata deklareras först genom att ange datatypen inom hakparenteser, till exempel [int]$sum eller [string]$mittNamn.

Det är viktigt att notera att även om datatypen har fördefinierats, kan PowerShell ändå konvertera den till en annan datatyp beroende på hur variablerna används. Tumregeln för konvertering är att den första termen avgör den andra. Låt oss illustrera detta med några exempel:

1. För att deklarera variabeln $mittNamn som System.String (alltså som sträng), exekvera:
   • PS C:\>[string]$mittNamn = ”Chalo Reyes”
   • PS C:\>$mittNamn
   • Utdata: Chalo Reyes
2. För att få ett numeriskt värde omvandlat till ett strängvärde, exekvera:
   • PS C:\>[string]$string_a = 123
   • PS C:\>$string_a
   • Utdata: 123
   • Kommandot ovan innebär att det numeriska värdet 123 för variabeln omvandlas till en textsträng eftersom det deklarerades som sådan. Detta kan verifieras med några kommandon:
   • PS C:\>[string]$string_b = $string_a + 4
   • PS C:\>$string_b
   • Utdata: 1234
   • Strängen 123 konkateneras med 4 (har konverteras till sträng)
   • Samma kommando som ovan, men nu 4 först:
   • PS C:\>[string]$string_c = 4 + $string_a
   • PS C:\>$string_c
   • Utdata: 127
   • PowerShell insisterar på att konvertera datatypen, därmed blir resultatet 4 + 123 = 127, men datatypen har deklarerats som en sträng!
3. För att definiera ett objekt som ska behandlas som heltal, exekvera:
   • PS C:\>[int]$Heltal = 20
   • PS C:\>$Heltal
   • Utdata: 20
   • Variabeln $Heltal har definierats som en Integer (heltal), varför alla numeriska indata skickas till System.Int32
4. Vad händer om definitionen är heltal, men tilldelat värdet är decimalt?
   • PS C:\>[int]$Heltal = 20.5
   • PS C:\$Heltal
   • Utdata: 20
   • PowerShell avrundar till heltal (20.1 till 20.5 avrundas till 20 och 20.6 till 20.9 avrundas till 21).
5. Om vi skickar in ett decimaltal till en variabel utan att deklarera dess typ, sköter PowerShell typomvandlingen åt oss.
   • PS C:\>$Nummer = 23.23
   • PS C:\>$Nummer.GetType().FullName
   • Utdata: System.Double