Compartilhar via

about_Numeric_Literals

  • Artigo

Descrição breve

Este artigo descreve a sintaxe e o uso de valores numéricos no PowerShell.

Descrição longa

Existem dois tipos de literais numéricos: inteiros e reais. Ambos podem ter sufixos de tipo e multiplicador.

Literais inteiros

Os literais inteiros podem ser escritos em notação decimal, hexadecimal ou binária. Os literais hexadecimais são prefixados com 0x e os literais binários são prefixados com 0b para distingui-los dos números decimais.

Os literais inteiros podem ter um sufixo de tipo e um sufixo multiplicador.

Sufixo Significado Observação
y Tipo de dados de byte assinado Adicionado no PowerShell 6.2
uy Tipo de dados de byte não assinado Adicionado no PowerShell 6.2
s Tipo de dados curto Adicionado no PowerShell 6.2
us Tipo de dados curto não assinado Adicionado no PowerShell 6.2
l Tipo de dados longo
u tipo de dados int ou long não assinado Adicionado no PowerShell 6.2
ul Tipo de dados longo não assinado Adicionado no PowerShell 6.2
n Tipo de dados BigInteger Adicionado no PowerShell 7.0
kb Multiplicador de Kibibyte (10241)
mb Multiplicador de mebibytes (10242)
gb Gigibyte (10243) Multiplicador
tb multiplicador teribyte (10244)
pb Multiplicador de petibytes (10245)

O tipo de um literal inteiro é determinado por seu valor, o sufixo de tipo e o sufixo do multiplicador numérico.

Para um literal inteiro sem sufixo de tipo:

  • Se o valor puder ser representado pelo tipo [int], esse é o seu tipo.
  • Caso contrário, se o valor puder ser representado pelo tipo [long], esse é o seu tipo.
  • Caso contrário, se o valor puder ser representado pelo tipo [decimal], esse é o seu tipo.
  • Caso contrário, ele é representado pelo tipo [double].

Para um literal inteiro com um sufixo de tipo:

  • Se o sufixo de tipo for u e o valor puder ser representado por tipo [uint] , então seu tipo é [uint].
  • Se o sufixo de tipo for u e o valor puder ser representado por tipo [ulong] , então seu tipo é [ulong].
  • Se seu valor puder ser representado pelo tipo especificado, esse será o seu tipo.
  • Caso contrário, esse literal será malformado.

Literais reais

Literais reais só podem ser escritos em notação decimal. Essa notação pode incluir valores fracionários após um ponto decimal e notação científica usando uma parte exponencial.

A parte exponencial inclui um 'e' seguido por um sinal opcional (+/-) e um número que representa o expoente. Por exemplo, o valor 1e2 literal é igual ao valor numérico 100.

Literais reais podem ter um sufixo de tipo e um sufixo multiplicador.

Sufixo Significado
d tipo de dados decimal
kb Multiplicador de Kibibyte (10241)
mb Multiplicador de mebibytes (10242)
gb Gigibyte (10243) Multiplicador
tb multiplicador teribyte (10244)
pb Multiplicador de petibytes (10245)

Há dois tipos de literal real: double e decimal. Estes são indicados pela ausência ou presença, respectivamente, de sufixo do tipo decimal. O PowerShell não dá suporte a uma representação literal de um [float] valor. Um literal real duplo tem tipo [double]. Um literal real decimal tem o tipo [decimal]. Zeros à direita na parte fracionária de um literal real decimal são significativos.

Se o valor dos dígitos da parte do expoente em um [double] literal real for menor que o mínimo suportado, o valor desse [double] literal real será 0. Se o valor dos dígitos da parte do expoente em um [decimal] literal real for menor que o mínimo suportado, esse literal estará malformado. Se o valor dos dígitos da parte do expoente em um [double] literal real ou [decimal] for maior que o máximo suportado, esse literal estará malformado.

Observação

A sintaxe permite que um literal real duplo tenha um sufixo de tipo longo. O PowerShell trata esse caso como um literal inteiro cujo valor é representado pelo tipo [long]. Esse recurso foi mantido para fins de compatibilidade com versões anteriores do PowerShell. No entanto, os programadores são desencorajados de usar literais inteiros desse formulário, pois podem facilmente obscurecer o valor real do literal. Por exemplo, 1.2L tem valor 1, 1.2345e1L tem valor 12 e 1.2345e-5L tem valor 0, nenhum dos quais é imediatamente óbvio.

Multiplicadores numéricos

Por conveniência, literais inteiros e reais podem conter um multiplicador numérico, que indica um de um conjunto de potências comumente usadas de 2. O multiplicador numérico pode ser escrito em qualquer combinação de letras maiúsculas ou minúsculas.

Os sufixos multiplicadores podem ser usados em combinação com qualquer sufixo de tipo, mas devem estar presentes após o sufixo de tipo. Por exemplo, o literal 100gbL está malformado, mas o literal 100Lgb é válido.

Se um multiplicador criar um valor que exceda os valores possíveis para o tipo numérico especificado pelo sufixo, o literal será malformado. Por exemplo, o literal 1usgb está malformado, pois o valor 1gb é maior do que o permitido para o [ushort] tipo especificado pelo us sufixo.

Exemplos de multiplicadores

PS> 1kb
1024

PS> 1.30Dmb
1363148.80

PS> 0x10Gb
17179869184

PS> 1.4e23tb
1.5393162788864E+35

PS> 0x12Lpb
20266198323167232

Aceleradores de tipo numérico

O PowerShell dá suporte aos seguintes aceleradores de tipo:

Acelerador Observação Descrição
[byte] Byte (sem sinal)
[sbyte] Byte (assinado)
[Int16] Inteiro de 16 bits
[short] alias para [int16] Inteiro de 16 bits
[UInt16] Inteiro de 16 bits (sem sinal)
[ushort] alias para [uint16] Inteiro de 16 bits (sem sinal)
[Int32] Inteiro de 32 bits
[int] alias para [int32] Inteiro de 32 bits
[UInt32] Inteiro de 32 bits (sem sinal)
[uint] alias para [uint32] Inteiro de 32 bits (sem sinal)
[Int64] Inteiro de 64 bits
[long] alias para [int64] Inteiro de 64 bits
[UInt64] Inteiro de 64 bits (sem sinal)
[ulong] alias para [uint64] Inteiro de 64 bits (sem sinal)
[bigint] Consulte BigInteger Struct
[single] Ponto flutuante de precisão única
[float] alias para [single] Ponto flutuante de precisão única
[double] Ponto flutuante de dupla precisão
[decimal] Ponto flutuante de 128 bits

Observação

Os seguintes aceleradores de tipo foram adicionados no PowerShell 6.2: [short], [ushort], [uint], [ulong].

Exemplos

A tabela a seguir contém vários exemplos de literais numéricos e lista seu tipo e valor:

Número Tipo Valor
100 Int32 100
100u UInt32 100
100D Decimal 100
100l Int64 100
100uL UInt64 100
100 nós UInt16 100
100uy Byte 100
100 anos 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

Trabalhando com números binários ou hexadecimais

Literais binários ou hexadecimais excessivamente grandes podem retornar como [bigint] em vez de falhar na análise, se e somente se o n sufixo for especificado. No entanto, os bits de sinal ainda são respeitados acima de intervalos pares [decimal] :

  • Se uma string binária tiver um múltiplo de 8 bits, o bit mais alto será tratado como o bit de sinal.
  • Se uma string hexadecimal, que tem um comprimento múltiplo de 8, tiver o primeiro dígito com 8 ou superior, o numeral será tratado como negativo.

Especificar um sufixo sem sinal em literais binários e hexadecimais ignora bits de sinal. Por exemplo, 0xFFFFFFFF retorna -1, mas 0xFFFFFFFFu retorna o [uint]::MaxValue de 4294967295.

No PowerShell 7.1, o uso de um sufixo de tipo em um literal hexadecimal agora retorna um valor assinado desse tipo. Por exemplo, no PowerShell 7.0, a expressão 0xFFFFs retorna um erro porque o valor positivo é muito grande para um [int16] tipo. O PowerShell 7.1 interpreta isso como -1 um [int16] tipo.

Prefixar o literal com um 0 ignorará isso e será tratado como não assinado. Por exemplo: 0b011111111. Isso pode ser necessário ao trabalhar com literais no [bigint] intervalo, pois os sufixos e u n não podem ser combinados.

Você também pode negar literais binários e hexadecimais usando o prefixo - . Isso pode resultar em um número positivo, pois os bits de sinal são permitidos.

Os bits de sinal são aceitos para numerais com sufixo BigInteger:

  • O hexadecimal com sufixo BigInteger trata o bit alto de qualquer literal com um múltiplo de comprimento de 8 caracteres como o bit de sinal. O comprimento não inclui o prefixo 0x ou quaisquer sufixos.
  • O binário com sufixo BigInteger aceita bits de sinal em 96 e 128 caracteres e a cada 8 caracteres depois.

Conversão de tipo numérico

Quando as cadeias de caracteres são convertidas em números, há suporte para indicadores de formato hexadecimal adicionais. Esses formatos adicionais não são reconhecidos como literais.

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

Comandos que se parecem com literais numéricos

Qualquer comando que se pareça com um literal numérico válido deve ser executado usando o operador de chamada (&), caso contrário, ele será interpretado como um número. Literais malformados com sintaxe válida como 1usgb resultarão no seguinte erro:

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

No entanto, literais malformados com sintaxe inválida como 1gbus serão interpretados como uma cadeia de caracteres padrão e podem ser interpretados como um nome de comando válido em contextos em que os comandos podem ser chamados.

Propriedades de acesso e métodos de objetos numéricos

Para acessar um membro de um literal numérico, há casos em que você precisa colocar o literal entre parênteses.

  • O literal não tem um ponto decimal
  • O literal não tem nenhum dígito após o ponto decimal
  • O literal não tem um sufixo

Por exemplo, o exemplo a seguir falha:

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

Os exemplos a seguir funcionam:

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

Os dois primeiros exemplos funcionam sem colocar o valor literal entre parênteses porque o analisador do PowerShell pode determinar onde o literal numérico termina e o método GetType começa.

Como o PowerShell analisa literais numéricos

O PowerShell v7.0 alterou a maneira como os literais numéricos são analisados para habilitar os novos recursos.

Analisando literais numéricos reais

Se o literal contiver um ponto decimal ou a notação e, a cadeia de caracteres literal será analisada como um número real.

  • Se o sufixo decimal estiver presente, diretamente em [decimal].
  • Caso contrário, analise como [Double] e aplique o multiplicador ao valor. Em seguida, verifique os sufixos de tipo e tente converter no tipo apropriado.
  • Se a string não tiver sufixo de tipo, analise como [Double].

Analisando literais numéricos inteiros

Os literais do tipo inteiro são analisados usando as seguintes etapas:

  1. Determinar o formato da base
    • Para formatos binários, analise em [BigInteger].
    • Para formatos hexadecimais, analise o uso de [BigInteger] casos especiais para manter os [int] comportamentos originais quando o valor estiver no intervalo ou [long] .
    • Se não for binário nem hexadecimal, analise normalmente como um [BigInteger].
  2. Aplique o valor do multiplicador antes de tentar qualquer conversão para garantir que os limites de tipo possam ser verificados adequadamente sem estouros.
  3. Verifique os sufixos de tipo.
    • Verifique os limites de tipo e tente analisar esse tipo.
    • Se nenhum sufixo for usado, o valor será verificado na ordem a seguir, resultando no primeiro teste bem-sucedido determinando o tipo do número.
      • [int]
      • [long]
      • [decimal] (somente literais de base 10)
      • [double] (somente literais de base 10)
    • Se o valor estiver fora do [long] intervalo para números hexadecimais e binários, a análise falhará.
    • Se o valor estiver fora do intervalo para o [double] número de base 10, a análise falhará.
    • Valores mais altos devem ser escritos explicitamente usando o n sufixo para analisar o literal como um BigInteger.

Analisando literais de valor grande

Anteriormente, valores inteiros mais altos eram analisados como double antes de serem convertidos em qualquer outro tipo. Isso resulta em uma perda de precisão nas faixas mais altas. Por exemplo:

PS> [bigint]111111111111111111111111111111111111111111111111111111
111111111111111100905595216014112456735339620444667904

Para evitar esse problema, você teve que escrever valores como strings e depois convertê-los:

PS> [bigint]'111111111111111111111111111111111111111111111111111111'
111111111111111111111111111111111111111111111111111111

No PowerShell 7.0, você deve usar o N sufixo.

PS> 111111111111111111111111111111111111111111111111111111n
111111111111111111111111111111111111111111111111111111

Além disso, os valores entre [ulong]::MaxValue e [decimal]::MaxValue devem ser indicados usando o sufixo D decimal para manter a precisão. Sem o sufixo, esses valores são analisados como [Double] usando o modo de análise real.