Dela via

about_Numeric_Literals

  • Artikel

Kort beskrivning

Den här artikeln beskriver syntaxen och användningen av numeriska värden i PowerShell.

Lång beskrivning

Det finns två typer av numeriska literaler: heltal och verkliga. Båda kan ha typ- och multiplikatorsuffix.

Heltalsliteraler

Heltalsliteraler kan skrivas i decimaler, hexadecimala eller binära noteringar. Hexadecimala literaler prefix med 0x och binära literaler prefix med 0b för att skilja dem från decimaltal.

Heltalsliteraler kan ha ett typsuffix och ett multiplikatorsuffix.

Suffix Innebörd Anteckning
y signerad bytedatatyp Har lagts till i PowerShell 6.2
uy osignerad bytedatatyp Har lagts till i PowerShell 6.2
s kort datatyp Har lagts till i PowerShell 6.2
us osignerad kort datatyp Har lagts till i PowerShell 6.2
l lång datatyp
u osignerad int- eller långdatatyp Har lagts till i PowerShell 6.2
ul osignerad lång datatyp Har lagts till i PowerShell 6.2
n BigInteger-datatyp Har lagts till i PowerShell 7.0
kb kilobyte-multiplikator
mb megabyte-multiplikator
gb gigabyte-multiplikator
tb terabyte-multiplikator
pb petabyte-multiplikator

Typen av en heltalsliteral bestäms av dess värde, typsuffixet och det numeriska multiplikatorsuffixet.

För en heltalsliteral utan typsuffix:

  • Om värdet kan representeras av typen [int]är det dess typ.
  • Om värdet annars kan representeras av typen [long]är det dess typ.
  • Om värdet annars kan representeras av typen [decimal]är det dess typ.
  • Annars representeras den av typen [double].

För en heltalsliteral med ett typsuffix:

  • Om typsuffixet är u och värdet kan representeras av typ [uint] är [uint]dess typ .
  • Om typsuffixet är u och värdet kan representeras av typ [ulong] är [ulong]dess typ .
  • Om dess värde kan representeras av den angivna typen är det dess typ.
  • Annars är den literalen felaktig.

Verkliga literaler

Verkliga literaler kan bara skrivas i decimalnotation. Den här notationen kan innehålla bråkvärden efter en decimal och en vetenskaplig notation med hjälp av en exponentiell del.

Den exponentiella delen innehåller ett "e" följt av ett valfritt tecken (+/-) och ett tal som representerar exponenten. Till exempel är literalvärdet 1e2 lika med det numeriska värdet 100.

Verkliga literaler kan ha ett typsuffix och ett multiplikatorsuffix.

Suffix Innebörd
d decimaldatatyp
kb kilobyte-multiplikator
mb megabyte-multiplikator
gb gigabyte-multiplikator
tb terabyte-multiplikator
pb petabyte-multiplikator

Det finns två typer av verklig literal: dubbel och decimal. Dessa indikeras av frånvaro eller närvaro av decimal-typ suffix. PowerShell stöder inte en literal representation av ett [float] värde. En dubbel verklig literal har typen [double]. En verklig decimalliteral har typen [decimal]. Avslutande nollor i bråkdelen av en verklig decimalliteral är betydande.

Om värdet för exponentdelens siffror i en [double] verklig literal är mindre än det minsta som stöds är värdet för den [double] verkliga literalen 0. Om värdet för exponentdelens siffror i en [decimal] verklig literal är mindre än det minsta som stöds är den literalen felaktigt formulerad. Om värdet för exponentdelens siffror i en [double] eller [decimal] en verklig literal är större än det högsta som stöds, är den literalen felaktig.

Anteckning

Syntaxen tillåter att en dubbel verklig literal har ett suffix av lång typ. PowerShell behandlar det här fallet som en heltalsliteral vars värde representeras av typen [long]. Den här funktionen har behållits för bakåtkompatibilitet med tidigare versioner av PowerShell. Programmerare avråder dock från att använda heltalsliteraler i det här formuläret eftersom de enkelt kan dölja literalens faktiska värde. Till exempel 1.2L har värdet 1, 1.2345e1L har värdet 12 och 1.2345e-5L har värdet 0, varav inget är omedelbart uppenbart.

Numeriska multiplikatorer

För enkelhetens skull kan heltal och verkliga literaler innehålla en numerisk multiplikator, vilket indikerar en av en uppsättning vanliga krafter på 2. Den numeriska multiplikatorn kan skrivas i valfri kombination av versaler eller gemener.

Multiplikatorsuffixen kan användas i kombination med valfri typsuffix, men måste finnas efter typsuffixet. Literalen 100gbL är till exempel felaktig, men literalen 100Lgb är giltig.

Om en multiplikator skapar ett värde som överskrider de möjliga värdena för den numeriska typ som suffixet anger, är literalen felaktig. Literalen 1usgb är till exempel felaktigt, eftersom värdet 1gb är större än vad som tillåts för den [ushort] typ som anges av suffixet us .

Multiplikatorexempel

PS> 1kb
1024

PS> 1.30Dmb
1363148.80

PS> 0x10Gb
17179869184

PS> 1.4e23tb
1.5393162788864E+35

PS> 0x12Lpb
20266198323167232

Numeriska typacceleratorer

PowerShell stöder följande typacceleratorer:

Accelerator Anteckning Description
[byte] Byte (osignerad)
[sbyte] Byte (signerad)
[Int16] 16-bitars heltal
[short] alias för [int16] 16-bitars heltal
[UInt16] 16-bitars heltal (osignerat)
[ushort] alias för [uint16] 16-bitars heltal (osignerat)
[Int32] 32-bitars heltal
[int] alias för [int32] 32-bitars heltal
[UInt32] 32-bitars heltal (osignerat)
[uint] alias för [uint32] 32-bitars heltal (osignerat)
[Int64] 64-bitars heltal
[long] alias för [int64] 64-bitars heltal
[UInt64] 64-bitars heltal (osignerat)
[ulong] alias för [uint64] 64-bitars heltal (osignerat)
[bigint] Se BigInteger Struct
[single] Flyttal med enkel precision
[float] alias för [single] Flyttal med enkel precision
[double] Flyttal med dubbel precision
[decimal] 128-bitars flyttals

Anteckning

Följande typacceleratorer lades till i PowerShell 6.2: [short], [ushort], [uint], [ulong].

Exempel

Följande tabell innehåller flera exempel på numeriska literaler och visar deras typ och värde:

Tal Typ Värde
100 Int32 100
100u UInt32 100
100D Decimal 100
100l Int64 100
100uL UInt64 100
100us UInt16 100
100uy Byte 100
100y SByte 100
1e2 Double 100
1.e2 Double 100
0x1e2 Int32 482
0x1e2L Int64 482
0x1e2D Int32 7725
482D Decimal 482
482gb Int64 517543559168
482ngb BigInteger 517543559168
0x1e2lgb Int64 517543559168
0b1011011 Int32 91
0xFFFFs Int16 -1
0xFFFFFFFF Int32 -1
-0xFFFFFFFF Int32 1
0xFFFFFFFFu UInt32 4294967295

Arbeta med binära eller hexadecimala tal

Alltför stora binära eller hexadecimala literaler kan returneras som [bigint] i stället för att misslyckas med parsningen, om och endast om suffixet n har angetts. Teckenbitar respekteras dock fortfarande över jämna [decimal] intervall:

  • Om en binär sträng är en multipel av 8 bitar behandlas den högsta biten som teckenbiten.
  • Om en hexsträng, som har en längd som är en multipel av 8, har den första siffran med 8 eller högre behandlas siffran som negativ.

Om du anger ett osignerat suffix för binärt och hexlitraler ignoreras teckenbitar. Returnerar till exempel 0xFFFFFFFF , men 0xFFFFFFFFu returnerar [uint]::MaxValue 4294967295.-1

I PowerShell 7.1 returneras nu ett signerat värde av den typen med hjälp av ett typsuffix på en hexliteral. I PowerShell 7.0 returnerar uttrycket 0xFFFFs till exempel ett fel eftersom det positiva värdet är för stort för en [int16] typ. PowerShell 7.1 tolkar detta som -1 en [int16] typ.

Prefixet literal med a 0 kringgår detta och behandlas som osignerat. Exempel: 0b011111111. Detta kan vara nödvändigt när du arbetar med literaler i [bigint] intervallet, eftersom suffixen u och n inte kan kombineras.

Du kan också negera binära och hexliterala tecken med hjälp av prefixet - . Detta kan resultera i ett positivt tal eftersom teckenbitar tillåts.

Teckenbitar accepteras för BigInteger-suffixade siffror:

  • BigInteger-suffixed hex behandlar den höga biten av alla literaler med en längd på flera av 8 tecken som teckenbiten. Längden innehåller inte prefixet 0x eller några suffix.
  • Binärt BigInteger-suffix accepterar teckenbitar med 96 och 128 tecken och var 8:e tecken efter.

Konvertering av numerisk typ

När strängar konverteras till tal stöds ytterligare hexadecimala formatindikatorer. Dessa ytterligare format känns inte igen som literaler.

[int] '0xF' -eq 0xF
[int] '&hF' -eq 0xF
[int] '#F' -eq 0xF
[int] '0b1111' -eq 0b1111
[int] '0b1111' -eq 15

Kommandon som ser ut som numeriska literaler

Alla kommandon som ser ut som en giltig numerisk literal måste köras med hjälp av anropsoperatorn (&), annars tolkas det som ett tal. Felaktiga literaler med giltig syntax som 1usgb resulterar i följande fel:

PS> 1usgb
At line:1 char:6
+ 1usgb
+      ~
The numeric constant 1usgb is not valid.
+ CategoryInfo          : ParserError: (:) [], ParentContainsErrorRecordException
+ FullyQualifiedErrorId : BadNumericConstant

Felaktiga literaler med ogiltig syntax som 1gbus tolkas dock som en standardsträng utan tecken och kan tolkas som ett giltigt kommandonamn i kontexter där kommandon kan anropas.

Åtkomstegenskaper och metoder för numeriska objekt

För att få åtkomst till en medlem i en numerisk literal finns det fall då du behöver omsluta literalen inom parenteser.

  • Literalen har ingen decimalpunkt
  • Literalen har inga siffror efter decimaltecknet
  • Literalen har inget suffix

Följande exempel misslyckas till exempel:

PS> 2.GetType().Name
At line:1 char:11
+ 2.GetType().Name
+           ~
An expression was expected after '('.
+ CategoryInfo          : ParserError: (:) [], ParentContainsErrorRecordException
+ FullyQualifiedErrorId : ExpectedExpression

Följande exempel fungerar:

PS> 2uL.GetType().Name
UInt64
PS> 1.234.GetType().Name
Double
PS> (2).GetType().Name
Int32

De första två exemplen fungerar utan att omsluta literalvärdet inom parentes eftersom PowerShell-parsern kan avgöra var den numeriska literalen slutar och GetType-metoden startar.

Så här parsar PowerShell numeriska literaler

PowerShell v7.0 ändrade hur numeriska literaler parsas för att aktivera de nya funktionerna.

Parsa verkliga numeriska literaler

Om literalen innehåller ett decimaltecken eller en e-notation parsas strängliteralen som ett reellt tal.

  • Om decimalsuffixet finns direkt i [decimal].
  • Annars parsar du som [Double] och tillämpar multiplikator på värdet. Kontrollera sedan typsuffixen och försök att omvandla till lämplig typ.
  • Om strängen inte har något typsuffix parsar du som [Double].

Parsa numeriska heltalsliteraler

Literaler av heltalstyp parsas med hjälp av följande steg:

  1. Fastställa radixformatet
    • För binära format parsar du till [BigInteger].
    • För hexadecimala format parsar du till [BigInteger] att använda särskilda casies för att behålla ursprungliga beteenden när värdet finns i [int] intervallet eller [long] .
    • Om varken binärt eller hexigt parsas normalt som en [BigInteger].
  2. Använd multiplikatorvärdet innan du försöker utföra några kast för att säkerställa att typgränsarna kan kontrolleras korrekt utan spill.
  3. Kontrollera typsuffix.
    • Kontrollera typgränsen och försök parsa till den typen.
    • Om inget suffix används kontrolleras värdet i följande ordning, vilket resulterar i det första lyckade testet som avgör typen av tal.
      • [int]
      • [long]
      • [decimal] (endast base-10-literaler)
      • [double] (endast base-10-literaler)
    • Om värdet ligger utanför [long] intervallet för hexadecimala och binära tal misslyckas parsningen.
    • Om värdet ligger utanför [double] intervallet för bas 10-tal misslyckas parsningen.
    • Högre värden måste uttryckligen skrivas med hjälp av suffixet n för att parsa literalen som en BigInteger.

Parsa stora värdeliteraraler

Tidigare parsades högre heltalsvärden som dubbla innan de omvandlades till någon annan typ. Detta resulterar i en förlust av precision i de högre intervallen. Exempel:

PS> [bigint]111111111111111111111111111111111111111111111111111111
111111111111111100905595216014112456735339620444667904

För att undvika det här problemet var du tvungen att skriva värden som strängar och sedan konvertera dem:

PS> [bigint]'111111111111111111111111111111111111111111111111111111'
111111111111111111111111111111111111111111111111111111

I PowerShell 7.0 måste du använda suffixet N .

PS> 111111111111111111111111111111111111111111111111111111n
111111111111111111111111111111111111111111111111111111

Även värden mellan [ulong]::MaxValue och [decimal]::MaxValue ska anges med hjälp av decimalsuffixet D för att upprätthålla noggrannheten. Utan suffixet parsas dessa värden som [Double] att använda verkligt parsningsläge.