Share via

about_Numeric_Literals

  • Artigo

Breve descrição

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

Descrição longa

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

Literais inteiros

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

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

Sufixo Significado Nota
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 curtos Adicionado no PowerShell 6.2
us Tipo de dados curtos não assinados 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 longos não assinados Adicionado no PowerShell 6.2
n Tipo de dados BigInteger Adicionado no PowerShell 7.0
kb Multiplicador de kilobytes
mb multiplicador de megabytes
gb multiplicador gigabyte
tb multiplicador de terabytes
pb multiplicador de petabytes

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

Para um literal inteiro sem sufixo de tipo:

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

Para um literal inteiro com um sufixo de tipo:

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

Literais reais

Literais reais só podem ser escritos em notação decimal. Esta notação pode incluir valores fracionários seguindo uma vírgula decimal e notação científica usando uma parte exponencial.

A parte exponencial inclui um «e» seguido de 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 decimais
kb Multiplicador de kilobytes
mb multiplicador de megabytes
gb multiplicador gigabyte
tb multiplicador de terabytes
pb multiplicador de petabytes

Existem dois tipos de literal real: duplo e decimal. Estes são indicados pela ausência ou presença, respectivamente, de sufixo do tipo decimal. O PowerShell não oferece suporte a uma representação literal de um [float] valor. Um literal real duplo tem tipo [double]. Um literal real decimal tem tipo [decimal]. Os zeros à direita na parte da fração de um literal real decimal são significativos.

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

Nota

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 por tipo [long]. Esse recurso foi mantido para compatibilidade com versões anteriores do PowerShell. No entanto, os programadores são desencorajados de usar literais inteiros desta forma, pois eles 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 são imediatamente óbvios.

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 é malformado, mas o literal 100Lgb é válido.

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

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 oferece suporte aos seguintes aceleradores de tipo:

Acelerador Nota Description
[byte] Byte (não assinado)
[sbyte] Byte (assinado)
[Int16] Inteiro de 16 bits
[short] alias para [int16] Inteiro de 16 bits
[UInt16] Inteiro de 16 bits (não assinado)
[ushort] alias para [uint16] Inteiro de 16 bits (não assinado)
[Int32] Inteiro de 32 bits
[int] alias para [int32] Inteiro de 32 bits
[UInt32] Inteiro de 32 bits (não assinado)
[uint] alias para [uint32] Inteiro de 32 bits (não assinado)
[Int64] Número inteiro de 64 bits
[long] alias para [int64] Número inteiro de 64 bits
[UInt64] Inteiro de 64 bits (não assinado)
[ulong] alias para [uint64] Inteiro de 64 bits (não assinado)
[bigint] Veja BigInteger Struct
[single] Ponto flutuante de precisão única
[float] alias para [single] Ponto flutuante de precisão única
[double] Ponto flutuante de precisão dupla
[decimal] Ponto flutuante de 128 bits

Nota

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 Type valor
100 Int32 100
100U UInt32 100
100D Decimal 100
100l Int64 100
100uL UInt64 100
100US UInt16 100
100uy Byte 100
100 anos SByte 100
1e2 Duplo 100
1.e2 Duplo 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

Trabalhar 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 sufixo n for especificado. Os bits de sinal ainda são respeitados acima dos intervalos pares [decimal] , no entanto:

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

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

No PowerShell 7.1, usar 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 se fosse 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 u e 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, uma vez que os bits de sinal são permitidos.

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

  • O hexadecimal sufixo BigInteger trata o bit alto de qualquer literal com um comprimento múltiplo de 8 caracteres como o bit de sinal. O comprimento não inclui o prefixo 0x ou quaisquer sufixos.
  • O binário 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, indicadores de formato hexadecimal adicionais são suportados. 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, é 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 nua padrão e podem ser interpretados como um nome de comando válido em contextos onde os comandos podem ser chamados.

Acessar propriedades 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 seguindo a vírgula 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 seguintes exemplos 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.

Análise de literais numéricos reais

Se o literal contiver um ponto decimal ou a notação eletrônica, a cadeia literal será analisada como um número real.

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

Análise de literais numéricos inteiros

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

  1. Determinar o formato radix
    • Para formatos binários, analise em [BigInteger].
    • Para formatos hexadecimais, analise o [BigInteger] uso de caixas especiais para manter comportamentos originais quando o valor estiver no [int] intervalo ou [long] .
    • Se nem binário nem hex, analise normalmente como um [BigInteger]arquivo .
  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 nesse tipo.
    • Se nenhum sufixo for usado, o valor será verificado na seguinte ordem, resultando no primeiro teste bem-sucedido determinando o tipo do número.
      • [int]
      • [long]
      • [decimal] (apenas literais de base 10)
      • [double] (apenas 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 explicitamente escritos usando o sufixo n para analisar o literal como um BigIntegerarquivo .

Análise de literais de grande valor

Anteriormente, valores inteiros mais altos eram analisados como duplos antes de serem convertidos para 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 cadeias de caracteres e, em seguida, convertê-los:

PS> [bigint]'111111111111111111111111111111111111111111111111111111'
111111111111111111111111111111111111111111111111111111

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

PS> 111111111111111111111111111111111111111111111111111111n
111111111111111111111111111111111111111111111111111111

Também 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.