PowerShell har en inbyggd datatypomvandlare, vilket betyder att PowerShell själv avgör vilken datatyp ett värde ska ha. Denna automatiska konvertering kan ibland ändra den ursprungliga indata, men PowerShell är designat för att minimera dataförlust under omvandlingsprocessen.

Automatiska omvandlingar

Numeriska värden som lagras i variabler kan användas i matematiska beräkningar. Men när man blandar strängar och tal i samma uttryck kan PowerShell ibland göra oväntade tolkningar. Till exempel kan ett tal som skrivs inom citattecken (t.ex. ”5”) tolkas som en sträng i stället för ett numeriskt värde. Detta kan påverka hur PowerShell utför beräkningar.

Exempel på PowerShells beteende med olika datatyper

1) Skapa en variabel och visa dess datatyp

$uno = 1
$uno.GetType() | Format-Table -AutoSize

• Utdata visar att $uno är av typen System.Int32 (heltal).

2) Utföra en addition med numeriska värden

1 + $uno

• Utdata: 2
• Eftersom båda värdena är numeriska utförs en vanlig addition.

3) Konkatenera (slå ihop) strängar

"uno betyder " + "1"

• Utdata: uno betyder 1
• Här används textsträngar, och PowerShell utför sträng konkatenering (sammanslagning) i stället för addition.
• Observera att talet 1 här betraktas som text eftersom det står inom citattecken.

4) Lagra en addition i en variabel

$sum_a = 1 + 1
$sum_a

• Utdata: 2
• Variabeln $sum_a innehåller ett numeriskt värde.

5) Blanda numeriskt värde och sträng – ordningen spelar roll

a) Först tal, sedan sträng

$sum_b = 1 + "1"
$sum_b

• Utdata: 2
• PowerShell ser första värdet som ett heltal och försöker därför konvertera även det andra till ett heltal innan additionen.

b) Först sträng, sedan tal

$sum_c = "1" + 1
$sum_c

• Utdata: 11
• Den här gången identifierar PowerShell första värdet som sträng, och därför konverteras även den andra termen till en sträng.
  Resultatet blir texten ”11”, det vill säga ett ett och inte siffran elva.
• Tumregel: Den första termen i ett uttryck avgör hur resten av värdena tolkas.

Manuell typdeklaration

Du kan själv bestämma datatypen för en variabel genom att ange den inom hakparenteser före variabeln, till exempel:

[int]$sum
[string]$mittNamn

• Detta kallas explicita typdeklarationer. Men även om du anger datatypen själv kan PowerShell ibland konvertera den under körning beroende på sammanhanget.

Deklarera en sträng

[string]$mittNamn = "Chalo Reyes"
$mittNamn

• Utdata: Chalo Reyes
• Variabeln har nu datatypen System.String.

Omvandla ett tal till sträng

[string]$string_a = 123
$string_a

• Utdata: 123
• Här konverteras det numeriska värdet 123 till en textsträng eftersom datatypen [string] har angetts.
  Det kan verifieras med:

$string_a.GetType()

Strängkonkatenering kontra addition

a) När sträng kommer först (kom ihåg att variabeln $string_a innehåller värdet 123 som sträng):

[string]$string_b = $string_a + 4
$string_b

• Utdata: 1234
• PowerShell konkatenerar här texten ”123” med ”4”, eftersom båda behandlas som strängar.

b) När talet kommer först ($string_a innehåller texten 123):

[string]$string_c = 4 + $string_a
$string_c

• Utdata: 127
• Här gör PowerShell en automatisk typomvandling.
• Den första termen (4) tolkas som tal, så ”123” konverteras till tal, och resultatet blir 4 + 123 = 127.
  Trots att datatypen definierades som sträng returneras ett numeriskt resultat.

Heltal och avrundning

Definiera ett heltal

[int]$Heltal = 20
$Heltal

• Utdata: 20
• Variabeln $Heltal är nu ett System.Int32-objekt.

Tilldela ett decimalt värde till en heltals variabel

[int]$Heltal = 20.5
$Heltal

• Utdata: 20
• PowerShell avrundar till närmaste heltal:
• Alla tall mellan 20.1 och 20.5 avrundas till 20
• Alla tal mellan 20.6 och 20.9 avrundas till 21

PowerShells automatiska hantering av flyttal

Om du tilldelar ett decimalt värde utan att deklarera datatypen, kommer PowerShell automatiskt att använda System.Double:

$Nummer = 23.23
$Nummer.GetType().FullName

Utdata: System.Double