Acerca de los operadores aritméticosAbout Arithmetic Operators

DESCRIPCIÓN BREVESHORT DESCRIPTION

Describe los operadores que realizan operaciones aritméticas en PowerShell.Describes the operators that perform arithmetic in PowerShell.

DESCRIPCIÓN LARGALONG DESCRIPTION

Los operadores aritméticos calculan valores numéricos.Arithmetic operators calculate numeric values. Puede utilizar uno o varios operadores aritméticos para sumar, restar, multiplicar y dividir valores, y para calcular el resto (módulo) de una operación de división.You can use one or more arithmetic operators to add, subtract, multiply, and divide values, and to calculate the remainder (modulus) of a division operation.

Además, el operador de suma ( + ) y el operador de multiplicación ( * ) también operan en cadenas, matrices y tablas hash.In addition, the addition operator (+) and multiplication operator (*) also operate on strings, arrays, and hash tables. El operador de suma concatena la entrada.The addition operator concatenates the input. El operador de multiplicación devuelve varias copias de la entrada.The multiplication operator returns multiple copies of the input. Incluso puede combinar tipos de objeto en una instrucción aritmética.You can even mix object types in an arithmetic statement. El método que se usa para evaluar la instrucción viene determinado por el tipo del objeto situado más a la izquierda en la expresión.The method that is used to evaluate the statement is determined by the type of the leftmost object in the expression.

A partir de PowerShell 2,0, todos los operadores aritméticos funcionan en números de 64 bits.Beginning in PowerShell 2.0, all arithmetic operators work on 64-bit numbers.

A partir de PowerShell 3,0, -shr se agregan (Mayús-derecha) y -shl (Mayús-izquierda) para admitir las operaciones aritméticas bit a bit en PowerShell.Beginning in PowerShell 3.0, the -shr (shift-right) and -shl (shift-left) are added to support bitwise arithmetic in PowerShell.

PowerShell admite los siguientes operadores aritméticos:PowerShell supports the following arithmetic operators:

OperadorOperator DescripciónDescription EjemploExample
+ Agrega enteros; ConcatenaAdds integers; concatenates 6 + 2
cadenas, matrices y tablas hash.strings, arrays, and hash tables. "file" + "name"
@(1, "one") + @(2.0, "two")
@{"one" = 1} + @{"two" = 2}
- Resta un valor de otro.Subtracts one value from another 6 - 2
valuevalue
- Convierte un número en un número negativo.Makes a number a negative number -6
(Get-Date).AddDays(-1)
* Multiplicar números o copiar cadenasMultiply numbers or copy strings 6 * 2
y matrices el número especificadoand arrays the specified number @("!") * 4
de veces.of times. "!" * 3
/ Divide dos valores.Divides two values. 6 / 2
% Módulo: devuelve el resto deModulus - returns the remainder of 7 % 2
operación de división.a division operation.
-banda-band AND bit a bitBitwise AND 5 -band 3
-bno-bnot NOT bit a bitBitwise NOT -bnot 5
-Bo-bor OR bit a bitBitwise OR 5 -bor 0x03
-bxor-bxor XOR bit a bitBitwise XOR 5 -bxor 3
-SHL-shl Desplaza los bits a la izquierda.Shifts bits to the left 102 -shl 2
-SHR-shr Desplaza los bits a la derecha.Shifts bits to the right 102 -shr 2

Los operadores bit a bit solo funcionan en tipos enteros.The bitwise operators only work on integer types.

PRECEDENCIA DE OPERADORESOPERATOR PRECEDENCE

PowerShell procesa los operadores aritméticos en el orden siguiente:PowerShell processes arithmetic operators in the following order:

PrioridadPrecedence OperadorOperator DescripciónDescription
11 () ParéntesisParentheses
22 - Para un número negativo o un operador unarioFor a negative number or unary operator
33 *, /, %*, /, % Para multiplicación y divisiónFor multiplication and division
44 +, -+, - Para sumar y restarFor addition and subtraction
55 -band, -bnot-band, -bnot Para las operaciones bit a bitFor bitwise operations
55 -bor, -bxor-bor, -bxor Para las operaciones bit a bitFor bitwise operations
55 -shr, -shl-shr, -shl Para las operaciones bit a bitFor bitwise operations

PowerShell procesa las expresiones de izquierda a derecha según las reglas de prioridad.PowerShell processes the expressions from left to right according to the precedence rules. En los siguientes ejemplos se muestra el efecto de las reglas de prioridad:The following examples show the effect of the precedence rules:

ExpresiónExpression ResultadoResult
3+6/3*4 11
3+6/(3*4) 3.5
(3+6)/3*4 12

El orden en el que PowerShell evalúa las expresiones podría diferir de otros lenguajes de programación y scripting que haya usado.The order in which PowerShell evaluates expressions might differ from other programming and scripting languages that you have used. En el ejemplo siguiente se muestra una instrucción de asignación complicada.The following example shows a complicated assignment statement.

$a = 0
$b = @(1,2)
$c = @(-1,-2)

$b[$a] = $c[$a++]

En este ejemplo, la expresión $a++ se evalúa antes que $b[$a] .In this example, the expression $a++ is evaluated before $b[$a]. $a++La evaluación de cambios cambia el valor de $a después de usarse en la instrucción $c[$a++] , pero antes de que se utilice en $b[$a] .Evaluating $a++ changes the value of $a after it is used in the statement $c[$a++]; but, before it is used in $b[$a]. La variable $a en $b[$a] es igual 1 a, no 0 ; por lo tanto, la instrucción asigna un valor a $b[1] , no a $b[0] .The variable $a in $b[$a] equals 1, not 0; so, the statement assigns a value to $b[1], not $b[0].

El código anterior es equivalente a:The above code is equivalent to:

$a = 0
$b = @(1,2)
$c = @(-1,-2)

$tmp = $c[$a]
$a = $a + 1
$b[$a] = $tmp

DIVISIÓN Y REDONDEODIVISION AND ROUNDING

Cuando el cociente de una operación de división es un entero, PowerShell redondea el valor al entero más próximo.When the quotient of a division operation is an integer, PowerShell rounds the value to the nearest integer. Cuando el valor es .5 , se redondea al entero par más cercano.When the value is .5, it rounds to the nearest even integer.

En el ejemplo siguiente se muestra el efecto de redondear al entero par más cercano.The following example shows the effect of rounding to the nearest even integer.

ExpresiónExpression ResultadoResult
[int]( 5 / 2 ) 2
[int]( 7 / 2 ) 4

Observe cómo 5/2 = 2,5 se redondea a 2.Notice how 5/2 = 2.5 gets rounded to 2. Pero 7/2 = 3,5 se redondea a 4.But, 7/2 = 3.5 gets rounded to 4.

Puede utilizar la [Math] clase para obtener un comportamiento de redondeo diferente.You can use the [Math] class to get different rounding behavior.

ExpresiónExpression ResultadoResult
[int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero) 3
[int][Math]::Ceiling(5 / 2) 3
[int][Math]::Floor(5 / 2) 2

Para obtener más información, vea el método Math. round .For more information, see the Math.Round method.

AGREGAR Y MULTIPLICAR TIPOS NO NUMÉRICOSADDING AND MULTIPLYING NON-NUMERIC TYPES

Puede agregar números, cadenas, matrices y tablas hash.You can add numbers, strings, arrays, and hash tables. Además, puede multiplicar números, cadenas y matrices.And, you can multiply numbers, strings, and arrays. Sin embargo, no puede multiplicar las tablas hash.However, you cannot multiply hash tables.

Al agregar cadenas, matrices o tablas hash, los elementos se concatenan.When you add strings, arrays, or hash tables, the elements are concatenated. Al concatenar colecciones, como matrices o tablas hash, se crea un nuevo objeto que contiene los objetos de ambas colecciones.When you concatenate collections, such as arrays or hash tables, a new object is created that contains the objects from both collections. Si intenta concatenar tablas hash que tienen la misma clave, se produce un error en la operación.If you try to concatenate hash tables that have the same key, the operation fails.

Por ejemplo, los siguientes comandos crean dos matrices y, a continuación, las agregan:For example, the following commands create two arrays and then add them:

$a = 1,2,3
$b = "A","B","C"
$a + $b
1
2
3
A
B
C

También puede realizar operaciones aritméticas en objetos de tipos diferentes.You can also perform arithmetic operations on objects of different types. La operación que realiza PowerShell viene determinada por el tipo de marco de Microsoft .NET del objeto situado más a la izquierda en la operación.The operation that PowerShell performs is determined by the Microsoft .NET Framework type of the leftmost object in the operation. PowerShell intenta convertir todos los objetos de la operación en el tipo de .NET Framework del primer objeto.PowerShell tries to convert all the objects in the operation to the .NET Framework type of the first object. Si se convierte correctamente en la conversión de los objetos, realiza la operación adecuada para el tipo de .NET Framework del primer objeto.If it succeeds in converting the objects, it performs the operation appropriate to the .NET Framework type of the first object. Si no puede convertir ninguno de los objetos, se produce un error en la operación.If it fails to convert any of the objects, the operation fails.

En los siguientes ejemplos se muestra el uso de los operadores de suma y multiplicación; en operaciones que incluyen tipos de objeto diferentes.The following examples demonstrate the use of the addition and multiplication operators; in operations that include different object types. Asuma $array = 1,2,3 :Assume $array = 1,2,3:

ExpresiónExpression ResultadoResult
"file" + 16 file16
$array + 16 1,2,3,161,2,3,16
$array + "file" 1,2,3,file1,2,3,file
$array * 2 1,2,3,1,2,31,2,3,1,2,3
"file" * 3 filefilefile

Dado que el método que se usa para evaluar las instrucciones viene determinado por el objeto situado más a la izquierda, la suma y la multiplicación en PowerShell no son estrictamente conmutables.Because the method that is used to evaluate statements is determined by the leftmost object, addition and multiplication in PowerShell are not strictly commutative. Por ejemplo, no (a + b) siempre es igual (b + a) a y no (ab) siempre es igual a (ba) .For example, (a + b) does not always equal (b + a), and (ab) does not always equal (ba).

En los siguientes ejemplos se muestra este principio:The following examples demonstrate this principle:

ExpresiónExpression ResultadoResult
"file" + 16 file16
16 + "file" Cannot convert value "file" to type "System.Int32".
Error: "Input string was not in a correct format."
At line:1 char:1
+ 16 + "archivo"+ 16 + "file"`

Las tablas hash son un caso ligeramente diferente.Hash tables are a slightly different case. Puede agregar tablas hash a otra tabla hash, siempre y cuando las tablas hash agregadas no tengan claves duplicadas.You can add hash tables to another hash table, as long as, the added hash tables don't have duplicate keys.

En el ejemplo siguiente se muestra cómo agregar tablas hash entre sí.The following example show how to add hash tables to each other.

$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

En el ejemplo siguiente se produce un error porque una de las claves está duplicada en ambas tablas hash.The following example throws an error because one of the keys is duplicated in both hash tables.

$hash1 = @{a=1; b=2; c=3}
$hash2 = @{c1="Server01"; c="Server02"}
$hash1 + $hash2
Item has already been added. Key in dictionary: 'c'  Key being added: 'c'
At line:3 char:1
+ $hash1 + $hash2
+ ~~~~~~~~~~~~~~~
    + CategoryInfo          : OperationStopped: (:) [], ArgumentException
    + FullyQualifiedErrorId : System.ArgumentException

Además, puede Agregar una tabla hash a una matriz; y la tabla hash completa se convierte en un elemento de la matriz.Also, you can add a hash table to an array; and, the entire hash table becomes an item in the array.

$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

Sin embargo, no puede agregar ningún otro tipo a una tabla hash.However, you cannot add any other type to a hash table.

$hash1 + 2
A hash table can only be added to another hash table.
At line:3 char:1
+ $hash1 + 2

Aunque los operadores de suma son muy útiles, utilice los operadores de asignación para agregar elementos a las tablas hash y a las matrices.Although the addition operators are very useful, use the assignment operators to add elements to hash tables and arrays. Para obtener más información, consulte about_assignment_operators.For more information see about_assignment_operators. En los ejemplos siguientes se usa el += operador de asignación para agregar elementos a una matriz:The following examples use the += assignment operator to add items to an array:

$array = @()
(0..9).foreach{ $array += $_ }
$array
0
1
2

CONVERSIÓN DE TIPOS PARA ACOMODAR EL RESULTADOTYPE CONVERSION TO ACCOMMODATE RESULT

PowerShell selecciona automáticamente el .NET Framework tipo numérico que mejor expresa el resultado sin perder precisión.PowerShell automatically selects the .NET Framework numeric type that best expresses the result without losing precision. Por ejemplo:For example:

2 + 3.1

(2). GetType().FullName
(2 + 3.1).GetType().FullName
5.1
System.Int32
System.Double

Si el resultado de una operación es demasiado grande para el tipo, el tipo del resultado se amplía para acomodar el resultado, como en el ejemplo siguiente:If the result of an operation is too large for the type, the type of the result is widened to accommodate the result, as in the following example:

(512MB).GetType().FullName
(512MB * 512MB).GetType().FullName
System.Int32
System.Double

El tipo del resultado no será necesariamente el mismo que uno de los operandos.The type of the result will not necessarily be the same as one of the operands. En el ejemplo siguiente, el valor negativo no se puede convertir en un entero sin signo y el entero sin signo es demasiado grande para convertirse en Int32 :In the following example, the negative value cannot be cast to an unsigned integer, and the unsigned integer is too large to be cast to Int32:

([int32]::minvalue + [uint32]::maxvalue).gettype().fullname
System.Int64

En este ejemplo, Int64 puede acomodar ambos tipos.In this example, Int64 can accommodate both types.

El System.Decimal tipo es una excepción.The System.Decimal type is an exception. Si alguno de los operandos tiene el tipo decimal, el resultado será del tipo decimal.If either operand has the Decimal type, the result will be of the Decimal type. Si el resultado es demasiado grande para el tipo decimal, no se convertirá en Double.If the result is too large for the Decimal type, it will not be cast to Double. En su lugar, se produce un error.Instead, an error results.

ExpresiónExpression ResultadoResult
[Decimal]::maxvalue 79228162514264337593543950335
[Decimal]::maxvalue + 1 Value was either too large or too small for a
Decimal.

OPERADORES ARITMÉTICOS Y VARIABLESARITHMETIC OPERATORS AND VARIABLES

También puede usar operadores aritméticos con variables.You can also use arithmetic operators with variables. Los operadores actúan sobre los valores de las variables.The operators act on the values of the variables. En los siguientes ejemplos se muestra el uso de operadores aritméticos con variables:The following examples demonstrate the use of arithmetic operators with variables:

ExpresiónExpression ResultadoResult
$intA = 6
$intB = 4
$intA + $intB
10
$a = "Power"
$b = "Shell"
$a + $b
PowerShell

OPERADORES ARITMÉTICOS Y COMANDOSARITHMETIC OPERATORS AND COMMANDS

Normalmente, se utilizan los operadores aritméticos en expresiones con números, cadenas y matrices.Typically, you use the arithmetic operators in expressions with numbers, strings, and arrays. Sin embargo, también puede usar operadores aritméticos con los objetos que devuelven los comandos y con las propiedades de esos objetos.However, you can also use arithmetic operators with the objects that commands return and with the properties of those objects.

En los siguientes ejemplos se muestra cómo usar los operadores aritméticos en expresiones con comandos de PowerShell:The following examples show how to use the arithmetic operators in expressions with PowerShell commands:

(get-date) + (new-timespan -day 1)

El operador de paréntesis fuerza la evaluación del get-date cmdlet y la evaluación de la new-timespan -day 1 expresión del cmdlet, en ese orden.The parenthesis operator forces the evaluation of the get-date cmdlet and the evaluation of the new-timespan -day 1 cmdlet expression, in that order. Ambos resultados se agregan mediante el + operador.Both results are then added using the + operator.

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

En la expresión anterior, cada espacio de trabajo del proceso ( $_.ws ) se multiplica por 2 ; y, el resultado, 50mb en comparación con para ver si es mayor que.In the above expression, each process working space ($_.ws) is multiplied by 2; and, the result, compared against 50mb to see if it is greater than that.

Operadores bit a bitBitwise Operators

PowerShell admite los operadores bit a bit estándar, incluidos and bit a bit ( -bAnd ), los operadores OR bit a bit inclusivos y exclusivos ( -bOr y -bXor ), y not bit a bit ( -bNot ).PowerShell supports the standard bitwise operators, including bitwise-AND (-bAnd), the inclusive and exclusive bitwise-OR operators (-bOr and -bXor), and bitwise-NOT (-bNot).

A partir de PowerShell 2,0, todos los operadores bit a bit funcionan con enteros de 64 bits.Beginning in PowerShell 2.0, all bitwise operators work with 64-bit integers.

A partir de PowerShell 3,0, -shr se introducen (Mayús-derecha) y -shl (Mayús + izquierda) para admitir operaciones aritméticas bit a bit en PowerShell.Beginning in PowerShell 3.0, the -shr (shift-right) and -shl (shift-left) are introduced to support bitwise arithmetic in PowerShell.

PowerShell admite los siguientes operadores bit a bit.PowerShell supports the following bitwise operators.

OperadorOperator DescripciónDescription ExpressionExpression ResultadoResult
-band AND bit a bitBitwise AND 10 -band 3 22
-bor OR bit a bit (inclusivo)Bitwise OR (inclusive) 10 -bor 3 1111
-bxor OR bit a bit (exclusivo)Bitwise OR (exclusive) 10 -bxor 3 99
-bnot NOT bit a bitBitwise NOT -bNot 10 -11-11
-shl Desplazar a la izquierdaShift-left 102 -shl 2 408408
-shr Desplazamiento a la derechaShift-right 102 -shr 1 5151

Los operadores bit a bit actúan sobre el formato binario de un valor.Bitwise operators act on the binary format of a value. Por ejemplo, la estructura de bits para el número 10 es 00001010 (basada en 1 byte) y la estructura de bits para el número 3 es 00000011.For example, the bit structure for the number 10 is 00001010 (based on 1 byte), and the bit structure for the number 3 is 00000011. Cuando se usa un operador bit a bit para comparar de 10 a 3, se comparan los bits individuales de cada byte.When you use a bitwise operator to compare 10 to 3, the individual bits in each byte are compared.

En una operación and bit a bit, el bit resultante se establece en 1 solo cuando ambos bits de entrada son 1.In a bitwise AND operation, the resulting bit is set to 1 only when both input bits are 1.

1010      (10)
0011      ( 3)
--------------  bAND
0010      ( 2)

En una operación OR bit a bit (inclusiva), el bit resultante se establece en 1 cuando uno o ambos bits de entrada son 1.In a bitwise OR (inclusive) operation, the resulting bit is set to 1 when either or both input bits are 1. El bit resultante se establece en 0 solo cuando ambos bits de entrada están establecidos en 0.The resulting bit is set to 0 only when both input bits are set to 0.

1010      (10)
0011      ( 3)
--------------  bOR (inclusive)
1011      (11)

En una operación OR bit a bit (exclusiva), el bit resultante se establece en 1 solo cuando un bit de entrada es 1.In a bitwise OR (exclusive) operation, the resulting bit is set to 1 only when one input bit is 1.

1010      (10)
0011      ( 3)
--------------  bXOR (exclusive)
1001      ( 9)

El operador NOT bit a bit es un operador unario que genera el complemento binario del valor.The bitwise NOT operator is a unary operator that produces the binary complement of the value. Un bit de 1 se establece en 0 y un bit de 0 se establece en 1.A bit of 1 is set to 0 and a bit of 0 is set to 1.

Por ejemplo, el complemento binario 0 es-1, el entero sin signo máximo (0xFFFFFFFF) y el complemento binario-1 es 0.For example, the binary complement of 0 is -1, the maximum unsigned integer (0xffffffff), and the binary complement of -1 is 0.

-bNot 10
-11
0000 0000 0000 1010  (10)
------------------------- bNOT
1111 1111 1111 0101  (-11, xfffffff5)

En una operación de desplazamiento a la izquierda bit a bit, todos los bits se mueven "n" a la izquierda, donde "n" es el valor del operando derecho.In a bitwise shift-left operation, all bits are moved "n" places to the left, where "n" is the value of the right operand. Un cero se inserta en los lugares.A zero is inserted in the ones place.

Cuando el operando izquierdo es un valor entero (32 bits), los 5 bits inferiores del operando derecho determinan el número de bits del operando izquierdo que se desplazan.When the left operand is an Integer (32-bit) value, the lower 5 bits of the right operand determine how many bits of the left operand are shifted.

Cuando el operando izquierdo es un valor largo (64 bits), los 6 bits inferiores del operando derecho determinan el número de bits del operando izquierdo que se desplazan.When the left operand is a Long (64-bit) value, the lower 6 bits of the right operand determine how many bits of the left operand are shifted.

ExpresiónExpression ResultadoResult Resultado binarioBinary Result
21 -shl 0 2121 0001 01010001 0101
21 -shl 1 4242 0010 10100010 1010
21 -shl 2 8484 0101 01000101 0100

En una operación de desplazamiento a la derecha bit a bit, todos los bits se mueven "n" a la derecha, donde "n" se especifica mediante el operando derecho.In a bitwise shift-right operation, all bits are moved "n" places to the right, where "n" is specified by the right operand. El operador de desplazamiento a la derecha (-SHR) inserta un cero en el lugar más a la izquierda al desplazarse un valor positivo o sin signo a la derecha.The shift-right operator (-shr) inserts a zero in the left-most place when shifting a positive or unsigned value to the right.

Cuando el operando izquierdo es un valor entero (32 bits), los 5 bits inferiores del operando derecho determinan el número de bits del operando izquierdo que se desplazan.When the left operand is an Integer (32-bit) value, the lower 5 bits of the right operand determine how many bits of the left operand are shifted.

Cuando el operando izquierdo es un valor largo (64 bits), los 6 bits inferiores del operando derecho determinan el número de bits del operando izquierdo que se desplazan.When the left operand is a Long (64-bit) value, the lower 6 bits of the right operand determine how many bits of the left operand are shifted.

ExpresiónExpression ResultadoResult BinaryBinary HexHex
21 -shr 0 2121 0001 01010001 0101 0x150x15
21 -shr 1 1010 0000 10100000 1010 0x0A0x0A
21 -shr 2 55 0000 01010000 0101 0x050x05
21 -shr 31 00 0000 00000000 0000 0x000x00
21 -shr 32 2121 0001 01010001 0101 0x150x15
21 -shr 64 2121 0001 01010001 0101 0x150x15
21 -shr 65 1010 0000 10100000 1010 0x0A0x0A
21 -shr 66 55 0000 01010000 0101 0x050x05
[int]::MaxValue -shr 1 10737418231073741823 0x3FFFFFFF0x3FFFFFFF
[int]::MinValue -shr 1 -1073741824-1073741824 0xC00000000xC0000000
-1 -shr 1 -1-1 0xFFFFFFFF0xFFFFFFFF

CONSULTE TAMBIÉNSEE ALSO