about_Arithmetic_Operators
Aplica-se a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Insira a introdução aqui.
TÓPICO
about_Arithmetic_Operators
DESCRIÇÃO BREVE
Descreve os operadores que executam aritmética em Windows PowerShell®.
DESCRIÇÃO LONGA
Operadores aritméticos calculam valores numéricos. Você pode usar um ou mais operadores aritméticos para adicionar, subtrair, multiplicar e dividir valores, e para calcular o resto (módulo) de uma operação de divisão.
Além disso, o operador de adição (+) e o operador de multiplicação (*) também operam em sequências de caracteres, matrizes e tabelas de hash. O operador de adição concatena a entrada. O operador de multiplicação retorna várias cópias da entrada. Você pode até mesmo combinar tipos de objeto em uma instrução de aritmética. O método que é usado para avaliar a instrução é determinado pelo tipo de objeto mais à esquerda na expressão.
A partir do Windows PowerShell 2.0, todos os operadores aritméticos funcionam em números de 64 bits.
A partir do Windows PowerShell3.0, - shr (deslocamento para a direita) e - shl (deslocamento para a esquerda) foram adicionados para dar suporte à aritmética bit a bit em Windows PowerShell.
O Windows PowerShell dá suporte aos seguintes operadores aritméticos:
Operator Description Example
-------- ----------- -------
+ Adds integers; concatenates strings, 6+2
arrays, and hash tables. "file" + "name"
- Subtracts one value from another 6-2
value. (get-date).date - 1
- Makes a number a negative number. -6+2
-4
* Multiplies integers; copies strings 6*2
and arrays the specified number of "w" * 3
times.
/ Divides two values. 6/2
% Returns the remainder of a division 7%2
operation.
-shl Shift-left 100 -shl 2
-shr Shift-right 100 -shr 1
PRECEDÊNCIA DO OPERADOR
O Windows PowerShell processa os operadores aritméticos na seguinte ordem:
Parentheses ()
- (for a negative number)
*, /, %
+, - (for subtraction)
O Windows 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:
C:\PS> 3+6/3*4
11
C:\PS> 10+4/2
12
C:\PS> (10+4)/2
7
C:\PS> (3+3)/ (1+1)
3
A ordem na qual Windows PowerShell avalia as expressões pode diferir em outras linguagens de programação e scripts que você usou. O exemplo a seguir mostra uma instrução de atribuição complicada.
C:\PS> $a = 0
C:\PS> $b = 1,2
C:\PS> $c = -1,-2
C:\PS> $b[$a] = $c[$a++]
C:\PS> $b
1
-1
Neste exemplo, a expressão $a++ é avaliada antes de $c[$a++]. Avaliar $a++ altera o valor de $a. A variável $a em $b[$a] é igual a 1, e não 0, para que a instrução atribua um valor para $b[1], não $b[0].
DIVISÃO E ARREDONDAMENTO
Quando o quociente de uma operação de divisão é um inteiro, o Windows PowerShell arredonda o valor para o inteiro mais próximo. Quando o valor é .5, ele é arredondado para o inteiro par mais próximo.
O exemplo a seguir mostra o efeito de arredondamento para o inteiro par mais próximo.
C:\PS> [int]( 5 / 2 )
2
C:\PS> [int]( 7 / 2 )
4
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, não é possível 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, é criado um novo objeto 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, em seguida, adiciona-os:
C:\PS> $a = 1,2,3
C:\PS> $b = "A","B","C"
C:\PS> $a + $b
1
2
3
A
B
C
Você também pode executar operações aritméticas em objetos de tipos diferentes. A operação que Windows PowerShell executa é determinada pelo tipo do Microsoft .NET Framework do objeto mais à esquerda na operação. O Windows PowerShell tenta converter todos os objetos na operação para o tipo do .NET Framework do primeiro objeto. Se tiver êxito na conversão de objetos, ele realiza a operação apropriada para o tipo do .NET Framework do primeiro objeto. Se ele falhar em converter qualquer um dos objetos, a operação falhará.
O exemplo a seguir demonstra o uso dos operadores de adição e multiplicação em operações que incluem diferentes tipos de objeto:
C:\PS> "file" + 16
file16
C:\PS> $array = 1,2,3
C:\PS> $array + 16
1
2
3
16
C:\PS> $array + "file"
1
2
3
file
C:\PS> "file" * 3
filefilefile
Como o método que é usado para avaliar instruções é determinado pelo objeto mais à esquerda, a adição e a multiplicação no Windows PowerShell não são estritamente comutativas. Por exemplo, (a + b) nem sempre é igual a (b + a), e (a * b) nem sempre é igual (b * a).
Os exemplos a seguir demonstram esse princípio:
C:\PS> "file" + 2
file2
C:\PS> 2 + "file"
Cannot convert value "file" to type "System.Int32". Error: "Input
string was not in a correct format."
At line:1 char:4
+ 2 + <<<< "file"
C:\PS> "file" * 3
filefilefile
C:\PS> 3 * "file"
Cannot convert value "file" to type "System.Int32". Error: "Input
string was not in a correct format."
At line:1 char:4
+ 3 * <<<< "file"
Tabelas de hash são um caso um pouco diferente. Você pode adicionar tabelas de hash. E você pode adicionar uma tabela de hash a uma matriz. No entanto, não é possível adicionar qualquer outro tipo a uma tabela de hash.
Os exemplos a seguir mostram como adicionar tabelas de hash umas às outras e a outros objetos:
C:\PS> $hash1 = @{a=1; b=2; c=3}
C:\PS> $hash2 = @{c1="Server01"; c2="Server02"}
C:\PS> $hash1 + $hash2
Name Value
---- -----
c2 Server02
a 1
b 2
c1 Server01
c 3
C:\PS> $hash1 + 2
You can add another hash table only to a hash table.
At line:1 char:9
+ $hash1 + <<<< 2
C:\PS> 2 + $hash1
Cannot convert "System.Collections.Hashtable" to "System.Int32".
At line:1 char:4
+ 2 + <<<< $hash1
Os exemplos a seguir demonstram que você pode adicionar uma tabela de hash a uma matriz. A tabela de hash inteira é adicionada à matriz como um único objeto.
C:\PS> $array = 1,2,3
C:\PS> $array + $hash1
1
2
3
Name Value
---- -----
a 1
b 2
c 3
C:\PS> $sum = $array + $hash1
C:\PS> $sum.count
4
C:\PS> $sum[3]
Name Value
---- -----
a 1
b 2
c 3
PS C:\ps-test> $sum + $hash2
1
2
3
Name Value
---- -----
a 1
b 2
c 3
c2 Server02
O exemplo a seguir mostra que você não pode adicionar tabelas de hash que contêm a mesma chave:
C:\PS> $hash1 = @{a=1; b=2; c=3}
C:\PS> $hash2 = @{c="red"}
C:\PS> $hash1 + $hash2
Bad argument to operator '+': Item has already been added.
Key in dictionary: 'c' Key being added: 'c'.
At line:1 char:9
+ $hash1 + <<<< $hash2
Embora os operadores de adição sejam muito úteis, use os operadores de atribuição para adicionar elementos a matrizes e tabelas de hash. 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:
C:\PS> $array
1
2
3
C:\PS> $array + "file"
1
2
3
file
C:\PS> $array
1
2
3
C:\PS> $array += "file"
C:\PS> $array
1
2
3
file
C:\PS> $hash1
Name Value
---- -----
a 1
b 2
c 3
C:\PS> $hash1 += @{e = 5}
C:\PS> $hash1
Name Value
---- -----
a 1
b 2
e 5
c 3
O Windows PowerShell seleciona automaticamente o tipo numérico do .NET Framework que melhor expressa o resultado sem perda de precisão. Por exemplo:
C:\PS> 2 + 3.1
5.1
C:\PS> (2). GetType().FullName
System.Int32
C:\PS> (2 + 3.1).GetType().FullName
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:
C:\PS> (512MB).GetType().FullName
System.Int32
C:\PS> (512MB * 512MB).GetType().FullName
System.Double
O tipo do resultado não necessariamente será o mesmo que um dos operandos. No exemplo a seguir, o valor negativo não pode ser convertido em um inteiro sem sinal, e o inteiro sem sinal é muito grande para ser convertido em Int32:
C:\PS> ([int32]::minvalue + [uint32]::maxvalue).gettype().fullname
System.Int64
Neste exemplo, Int64 pode acomodar ambos os tipos.
O tipo System.Decimal é uma exceção. Se qualquer operando tem o tipo Decimal, o resultado será do tipo Decimal. Se o resultado for muito grande para o tipo Decimal, ele não será convertido para Double. Em vez disso, ocorrerá um erro.
C:\PS> [Decimal]::maxvalue
79228162514264337593543950335
C:\PS> [Decimal]::maxvalue + 1
Value was either too large or too small for a Decimal.
At line:1 char:22
+ [Decimal]::maxvalue + <<<< 1
VARIÁVEIS E OPERADORES ARITMÉTICOS
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:
C:\PS> $intA = 6
C:\PS> $intB = 4
C:\PS> $intA + $intB
10
C:\PS> $a = "Windows "
C:\PS> $b = "PowerShell "
C:\PS> $c = 2
C:\PS> $a + $b + $c
Windows PowerShell2
COMANDOS E OPERADORES ARITMÉTICOS
Normalmente, você usa os operadores aritméticos em expressões com matrizes, cadeias de caracteres e números. 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 Windows PowerShell:
C:\PS> get-date
Wednesday, January 02, 2008 1:28:42 PM
C:\PS> $day = new-timespan -day 1
C:\PS> get-date + $day
Thursday, January 03, 2008 1:34:52 PM
C:\PS> get-process | where {($_.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
EXEMPLOS
Os exemplos a seguir mostram como usar os operadores aritméticos no Windows PowerShell:
C:\PS> 1 + 1
2
C:\PS> 1 - 1
0
C:\PS> -(6 + 3)
-9
C:\PS> 6 * 2
12
C:\PS> 7 / 2
3.5
C:\PS> 7 % 2
1
C:\PS> w * 3
www
C:\PS> 3 * "w"
Cannot convert value "w" to type "System.Int32". Error: "Input string was not in a correct format."
At line:1 char:4
+ 3 * <<<< "w"
PS C:\ps-test> "Windows" + " " + "PowerShell"
Windows PowerShell
PS C:\ps-test> $a = "Windows" + " " + "PowerShell"
PS C:\ps-test> $a
Windows PowerShell
C:\PS> $a[0]
W
C:\PS> $a = "TestFiles.txt"
C:\PS> $b = "C:\Logs\"
C:\PS> $b + $a
C:\Logs\TestFiles.txt
C:\PS> $a = 1,2,3
C:\PS> $a + 4
1
2
3
4
C:\PS> $servers = @{0 = "LocalHost"; 1 = "Server01"; 2 = "Server02"}
C:\PS> $servers + @{3 = "Server03"}
Name Value
---- -----
3 Server03
2 Server02
1 Server01
0 LocalHost
C:\PS> $servers
Name Value
---- -----
2 Server02
1 Server01
0 LocalHost
C:\PS> $servers += @{3 = "Server03"} #Use assignment operator
C:\PS> $servers
Name Value
---- -----
3 Server03
2 Server02
1 Server01
0 LocalHost
ARITMÉTICA BIT A BIT NO WINDOWS POWERSHELL
O Windows PowerShell dá suporte aos operadores -shl (deslocamento para a esquerda) e -shr (deslocamento para a direita) para aritmética bit a bit.
Esses operadores são introduzidos no Windows PowerShell 3.0.
Em uma operação de deslocamento para a esquerda bit a bit, todos os bits são movidos "n" casas à esquerda, em que "n" é o valor do operando à direita. Um zero é inserido nos locais.
Quando o operando esquerdo é um valor inteiro (32 bits), 5 bits inferiores do operando à direita determinam quantos bits do operando esquerdo são deslocados.
Quando o operando esquerdo é um valor longo (64 bits), 6 bits inferiores do operando à direita determinam quantos bits do operando esquerdo são deslocados.
PS C:\> 21 -shl 1
42
00010101 (21)
00101010 (42)
PS C:\> 21 -shl 2
84
00010101 (21)
00101010 (42)
01010100 (84)
Em uma operação de deslocamento para a direita bit a bit, todos os bits são movidos "n" casas à direita, em que "n" é o valor do operando à direita. O operador de deslocamento para a direita (-shr) insere um zero no local mais à esquerda ao deslocar um valor positivo ou não assinado à direita.
Quando o operando esquerdo é um valor inteiro (32 bits), 5 bits inferiores do operando à direita determinam quantos bits do operando esquerdo são deslocados.
Quando o operando esquerdo é um valor longo (64 bits), 6 bits inferiores do operando à direita determinam quantos bits do operando esquerdo são deslocados.
PS C:\> 21 -shr 1
10
00010101 (21)
00001010 (10)
PS C:\> 21 -shr 2
5
00010101 (21)
00001010 (10)
00000101 ( 5)
CONSULTE TAMBÉM
about_arrays
about_assignment_operators
about_comparison_operators
about_hash_tables
about_operators
about_variables
Get-Date
Get-Date
New-TimeSpan