about_Arithmetic_Operators
Descrição breve
Descreve os operadores que executam aritmética no PowerShell.
Descrição longa
Os operadores aritméticos calculam valores numéricos. Você pode usar um ou mais operadores aritméticos para adicionar, subtrair, multiplicar e dividir valores e calcular o restante (módulo) de uma operação de divisão.
O operador de adição (+
) e o operador de multiplicação (*
) também operam em cadeias de caracteres, matrizes e hashtables. O operador de adição concatena a entrada.
O operador de multiplicação retorna várias cópias da entrada. Você pode até mesmo misturar tipos de objeto em uma instrução aritmética. O método usado para avaliar a instrução é determinado pelo tipo do objeto mais à esquerda na expressão.
A partir do PowerShell 2.0, todos os operadores aritméticos trabalham em números de 64 bits.
A partir do PowerShell 3.0, o (shift-right) e -shl
(-shr
shift-left) são adicionados para dar suporte à aritmética bit a bit no PowerShell. Os operadores bit a bit só funcionam em tipos inteiros.
O PowerShell oferece suporte aos seguintes operadores aritméticos:
Adição (
+
) - Adiciona números, concatena cadeias de caracteres, matrizes e tabelas de hash6 + 2 # result = 8 "file" + "name" # result = "filename" @(1, "one") + @(2.0, "two") # result = @(1, "one", 2.0, "two") @{"one" = 1} + @{"two" = 2} # result = @{"one" = 1; "two" = 2}
Subtração (
-
) - Subtrai ou anula números6 - 2 # result = 4 - -6 # result = 6 (Get-Date).AddDays(-1) # Yesterday's date
Multiplicação (
*
) - Multiplique números ou copie cadeias de caracteres e matrizes o número especificado de vezes6 * 2 # result = 12 @("!") * 4 # result = @("!","!","!","!") "!" * 3 # result = "!!!"
Divisão (
/
) - Divide números6 / 2 # result = 3
Módulo (
%
) - retorna o restante de uma operação de divisão.7 % 2 # result = 1
Bitwise E (
-band
)5 -band 3 # result = 1
Bitwise NÃO (
-bnot
)-bnot 5 # result = -6
Bitwise OU (
-bor
)5 -bor 0x03 # result = 7
XOR Bitwise (
-bxor
)5 -bxor 3 # result = 6
Desloca bits para a esquerda (
-shl
)102 -shl 2 # result = 408
Desloca bits para a direita (
-shr
)102 -shr 2 # result = 25
Precedência do operador
O PowerShell processa operadores aritméticos na seguinte ordem:
Precedência | Operador | Descrição |
---|---|---|
1 | () |
Parênteses |
2 | - |
Para um número negativo ou operador unário |
3 | * , / , % |
Para multiplicação e divisão |
4 | + , - |
Para adição e subtração |
5 | -band , -bnot |
Para operações bit a bit |
5 | -bor , -bxor |
Para operações bit a bit |
5 | -shr , -shl |
Para operações bit a bit |
O PowerShell processa as expressões da esquerda para a direita de acordo com as regras de precedência. Os exemplos a seguir mostram o efeito das regras de precedência:
3+6/3*4 # result = 11
3+6/(3*4) # result = 3.5
(3+6)/3*4 # result = 12
A ordem em que o PowerShell avalia expressões pode ser diferente de outras linguagens de programação e script que você usou. O exemplo a seguir mostra uma instrução de atribuição complicada.
$a = 0
$b = @(1,2)
$c = @(-1,-2)
$b[$a] = $c[$a++]
Neste exemplo, a expressão $a++
é avaliada antes $b[$a]
de . A avaliação $a++
altera o valor de depois que ele é usado na instrução $c[$a++]
, mas antes de $a
ser usado no $b[$a]
. A variável $a
em $b[$a]
igual 1
, não 0
. Portanto, a instrução atribui um valor a $b[1]
, não $b[0]
.
O código acima é equivalente a:
$a = 0
$b = @(1,2)
$c = @(-1,-2)
$tmp = $c[$a]
$a = $a + 1
$b[$a] = $tmp
Divisão e arredondamento
Quando o quociente de uma operação de divisão é um inteiro, o PowerShell arredonda o valor para o inteiro mais próximo. Quando o valor é .5
, ele arredonda para o número inteiro par mais próximo.
O exemplo a seguir mostra o efeito de arredondamento para o número inteiro par mais próximo.
PS> [int]( 5 / 2 ) # Result is rounded down
2
PS> [int]( 7 / 2 ) # Result is rounded up
4
Você pode usar a [Math]
classe para obter um comportamento de arredondamento diferente.
PS> [int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero)
3
PS> [int][Math]::Ceiling(5 / 2)
3
PS> [int][Math]::Floor(5 / 2)
2
Para obter mais informações, consulte o método Math.Round .
Conversão de tipo para acomodar o resultado
O PowerShell seleciona automaticamente o tipo numérico .NET que melhor expressa o resultado sem perder a precisão. Por exemplo:
2 + 3.1
(2).GetType().FullName
(2 + 3.1).GetType().FullName
5.1
System.Int32
System.Double
Se o resultado de uma operação for muito grande para o tipo, o tipo do resultado será ampliado para acomodar o resultado, como no exemplo a seguir:
(512MB).GetType().FullName
(512MB * 512MB).GetType().FullName
System.Int32
System.Double
O tipo do resultado nem sempre é o mesmo que um dos operandos. No exemplo a seguir, o valor negativo não pode ser convertido em um inteiro não assinado e o inteiro não assinado é muito grande para ser convertido em Int32
:
([int32]::minvalue + [uint32]::maxvalue).gettype().fullname
System.Int64
Neste exemplo, Int64
pode acomodar ambos os tipos.
O System.Decimal
tipo é uma exceção. Se um dos operando tiver o tipo Decimal , o resultado será o tipo Decimal . Qualquer resultado muito grande para o valor decimal é um erro.
PS> [Decimal]::maxvalue
79228162514264337593543950335
PS> [Decimal]::maxvalue + 1
RuntimeException: Value was either too large or too small for a Decimal.
Perda potencial de precisão
Sempre que você tiver um resultado que exceda o intervalo do tipo, você corre o risco de perder a precisão devido à conversão de tipo. Por exemplo, adicionar um suficientemente grande [long]
e [int]
resulta na conversão dos operandos em [double]
. Neste exemplo, 9223372036854775807
é o valor máximo de um [long]
inteiro.
A adição de valor transborda o intervalo de [long]
.
PS> (9223372036854775807 + 2).GetType().FullName
System.Double
Lançar o resultado para [ulong]
produz um resultado impreciso, porque os operandos foram coagidos a [double]
primeiro.
PS> [ulong](9223372036854775807 + 2)
9223372036854775808
Definir o valor maior como [ulong]
primeiro evita o problema e produz o resultado correto.
PS> 9223372036854775807ul + 2
9223372036854775809
No entanto, exceder o intervalo de [ulong]
resultados em um [double]
.
PS> ([ulong]::MaxValue + 1).GetType().FullName
System.Double
Aritmética de Bigint
Quando você executa operações aritméticas em [bigint]
números, o PowerShell usa converte todos os operandos em , o [bigint]
que resulta no truncamento de valores não inteiros. Por exemplo, o valor 1.9
é truncado [double]
para 1
quando convertido em [bigint]
.
PS> [bigint]1 / 1.9
1
PS> 1 / [bigint]1.9
1
Esse comportamento é diferente do comportamento de outros tipos numéricos. Neste exemplo, um [int]
dividido por um [double]
resulta em um [double]
arquivo . O lançamento 1.9
para um [int]
arredonda o valor para 2
.
PS> 1 / 1.9
0.526315789473684
PS> 1 / [int]1.9
0.5
Adicionando e multiplicando tipos não numéricos
Você pode adicionar números, cadeias de caracteres, matrizes e tabelas de hash. Além disso, você pode multiplicar números, cadeias de caracteres e matrizes. No entanto, você não pode multiplicar tabelas de hash.
Quando você adiciona cadeias de caracteres, matrizes ou tabelas de hash, os elementos são concatenados. Quando você concatena coleções, como matrizes ou tabelas de hash, um novo objeto é criado que contém os objetos de ambas as coleções. Se você tentar concatenar tabelas de hash que têm a mesma chave, a operação falhará.
Por exemplo, os comandos a seguir criam duas matrizes e as adicionam:
$a = 1,2,3
$b = "A","B","C"
$a + $b
1
2
3
A
B
C
Você também pode executar operações aritméticas em objetos de diferentes tipos. A operação que o PowerShell executa é determinada pelo tipo Microsoft .NET do objeto mais à esquerda na operação. O PowerShell tenta converter todos os objetos na operação para o tipo .NET do primeiro objeto. Se ele conseguir converter os objetos, ele executará a operação apropriada para o tipo .NET do primeiro objeto. Se ele não conseguir converter qualquer um dos objetos, a operação falhará.
Os exemplos a seguir demonstram o uso dos operadores de adição e multiplicação em operações que incluem diferentes tipos de objeto.
$array = 1,2,3
$red = [ConsoleColor]::Red
$blue = [ConsoleColor]::Blue
"file" + 16 # result = "file16"
$array + 16 # result = 1,2,3,16
$array + "file" # result = 1,2,3,"file"
$array * 2 # result = 1,2,3,1,2,3
"file" * 3 # result = "filefilefile"
$blue + 3 # result = Red
$red - 3 # result = Blue
$blue - $red # result = -3
+ '123' # result = 123
Como o método usado para avaliar instruções é determinado pelo objeto mais à esquerda, a adição e a multiplicação no PowerShell não são estritamente comutativas. Por exemplo, (a + b)
nem sempre é igual (b + a)
e (ab)
nem sempre é igual (ba)
.
Os exemplos a seguir demonstram esse princípio:
PS> "file" + 16
file16
PS> 16 + "file"
InvalidArgument: can't convert value "file" to type "System.Int32". Error:
"Input string wasn't in a correct format."
As tabelas de hash são um caso ligeiramente diferente. Você pode adicionar tabelas de hash a outra tabela de hash, desde que as tabelas de hash adicionadas não tenham chaves duplicadas.
O exemplo a seguir mostra como adicionar tabelas de hash umas às outras.
$hash1 = @{a=1; b=2; c=3}
$hash2 = @{c1="Server01"; c2="Server02"}
$hash1 + $hash2
Name Value
---- -----
c2 Server02
a 1
b 2
c1 Server01
c 3
O exemplo a seguir gera um erro porque uma das chaves é duplicada em ambas as tabelas de hash.
$hash1 = @{a=1; b=2; c=3}
$hash2 = @{c1="Server01"; c="Server02"}
$hash1 + $hash2
OperationStopped:
Line |
3 | $hash1 + $hash2
| ~~~~~~~~~~~~~~~
| Item has already been added. Key in dictionary: 'c' Key being added: 'c'
Além disso, você pode adicionar uma tabela de hash a uma matriz; e, a tabela de hash inteira se torna um item na matriz.
$array1 = @(0, "Hello World", [datetime]::Now)
$hash1 = @{a=1; b=2}
$array2 = $array1 + $hash1
$array2
0
Hello World
Monday, June 12, 2017 3:05:46 PM
Key : a
Value : 1
Name : a
Key : b
Value : 2
Name : b
No entanto, você não pode adicionar nenhum outro tipo a uma tabela de hash.
$hash1 + 2
InvalidOperation: A hash table can only be added to another hash table.
Embora os operadores de adição sejam muito úteis, use os operadores de atribuição para adicionar elementos a tabelas de hash e matrizes. Para obter mais informações, consulte about_assignment_operators. Os exemplos a seguir usam o +=
operador de atribuição para adicionar itens a uma matriz:
$array = @()
(0..2).foreach{ $array += $_ }
$array
0
1
2
Operadores aritméticos e variáveis
Você também pode usar operadores aritméticos com variáveis. Os operadores atuam sobre os valores das variáveis. Os exemplos a seguir demonstram o uso de operadores aritméticos com variáveis:
PS> $intA = 6
PS> $intB = 4
PS> $intA + $intB
10
PS> $a = "Power"
PS> $b = "Shell"
PS> $a + $b
PowerShell
Operadores e comandos aritméticos
Normalmente, você usa os operadores aritméticos em expressões com números, cadeias de caracteres e matrizes. No entanto, você também pode usar operadores aritméticos com os objetos que os comandos retornam e com as propriedades desses objetos.
Os exemplos a seguir mostram como usar os operadores aritméticos em expressões com comandos do PowerShell:
(Get-Date) + (New-TimeSpan -day 1)
O operador de parêntese força a avaliação do Get-Date
cmdlet e a New-TimeSpan -Day 1
avaliação da expressão do cmdlet, nessa ordem. Ambos os resultados são então adicionados usando o +
operador.
Get-Process | Where-Object { ($_.ws * 2) -gt 50mb }
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
1896 39 50968 30620 264 1,572.55 1104 explorer
12802 78 188468 81032 753 3,676.39 5676 OUTLOOK
660 9 36168 26956 143 12.20 988 PowerShell
561 14 6592 28144 110 1,010.09 496 services
3476 80 34664 26092 234 ...45.69 876 svchost
967 30 58804 59496 416 930.97 2508 WINWORD
Na expressão acima, cada espaço de trabalho do processo ($_.ws
) é multiplicado por 2
; e, o resultado, comparado com 50mb
para ver se é maior do que isso.
Operadores bit a bit
O PowerShell oferece suporte aos operadores bitwise padrão, incluindo bitwise-AND (-band
), os operadores bitwise-OR inclusivos e exclusivos (-bor
e -bxor
) e bitwise-NOT (-bnot
).
A partir do PowerShell 2.0, todos os operadores bit a bit funcionam com inteiros de 64 bits.
A partir do PowerShell 3.0, o (shift-right) e -shl
o -shr
(shift-left) são introduzidos para dar suporte à aritmética bit a bit no PowerShell.
O PowerShell oferece suporte aos seguintes operadores bit a bit.
Operador | Descrição | Expressão | Resultado |
---|---|---|---|
-band |
AND bit a bit | 10 -band 3 |
2 |
-bor |
Bitwise OU (inclusive) | 10 -bor 3 |
11 |
-bxor |
Bitwise OU (exclusivo) | 10 -bxor 3 |
9 |
-bnot |
NOT bit a bit | -bNot 10 |
-11 |
-shl |
Teste | 102 -shl 2 |
408 |
-shr |
Teste | 102 -shr 1 |
51 |
Os operadores bit a bit agem no formato binário de um valor. Por exemplo, a estrutura de bits para o número 10 é 00001010 (com base em 1 byte) e a estrutura de bits para o número 3 é 00000011. Quando você usa um operador bit a bit para comparar 10 a 3, os bits individuais em cada byte são comparados.
Em uma operação bit a bit AND, o bit resultante é definido como 1 somente quando ambos os bits de entrada são 1.
1010 (10)
0011 ( 3)
-------------- bAND
0010 ( 2)
Em uma operação bit a bit OU (inclusive), o bit resultante é definido como 1 quando um ou ambos os bits de entrada são 1. O bit resultante é definido como 0 somente quando ambos os bits de entrada são definidos como 0.
1010 (10)
0011 ( 3)
-------------- bOR (inclusive)
1011 (11)
Em uma operação bit a bit OU (exclusiva), o bit resultante é definido como 1 somente quando um bit de entrada é 1.
1010 (10)
0011 ( 3)
-------------- bXOR (exclusive)
1001 ( 9)
O operador bit a bit NOT é um operador unário que produz o complemento binário do valor. Um pouco de 1 é definido como 0 e um pouco de 0 é definido como 1.
Por exemplo, o complemento binário de 0 é -1, o inteiro não assinado máximo (0xFFFFFFFF) e o complemento binário de -1 é 0.
-bNot 10
-11
0000 0000 0000 1010 (10)
------------------------- bNOT
1111 1111 1111 0101 (-11, 0xFFFFFFF5)
Em uma operação bit a bit shift-left, todos os bits são movidos "n" lugares para a esquerda, onde "n" é o valor do operando direito. Um zero é inserido no lugar.
Expressão | Resultado | Resultado binário |
---|---|---|
21 -shl 0 |
21 | 0001 0101 |
21 -shl 1 |
42 | 0010 1010 |
21 -shl 2 |
84 | 0101 0100 |
Em uma operação bit a bit shift-right, todos os bits são movidos "n" lugares para a direita, onde "n" é especificado pelo operando direito. O operador shift-right (-shr
) copia o bit de sinal para o lugar mais à esquerda ao deslocar um valor assinado. Para valores não assinados, um zero é inserido na posição mais à esquerda.
Expressão | Resultado | Binary | Hex |
---|---|---|---|
21 -shr 0 |
21 | 00010101 | 0x15 |
21 -shr 1 |
10 | 00001010 | 0x0A |
21 -shr 2 |
5 | 00000101 | 0x05 |
21 -shr 31 |
0 | 00000000 | 0x00 |
21 -shr 32 |
21 | 00010101 | 0x15 |
21 -shr 64 |
21 | 00010101 | 0x15 |
21 -shr 65 |
10 | 00001010 | 0x0A |
21 -shr 66 |
5 | 00000101 | 0x05 |
[int]::MaxValue -shr 1 |
1073741823 | 00111111111111111111111111111111 | 0x3FFFFFFF |
[int]::MinValue -shr 1 |
-1073741824 | 11000000000000000000000000000000 | 0xC0000000 |
-1 -shr 1 |
-1 | 11111111111111111111111111111111 | 0xFFFFFFFF |
(-21 -shr 1) |
-11 | 11111111111111111111111111110101 | 0xFFFFFFF5 |
(-21 -shr 2) |
-6 | 11111111111111111111111111111010 | 0xFFFFFFF4 |
Confira também
Comentários
https://aka.ms/ContentUserFeedback.
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulteEnviar e exibir comentários de