Om aritmetiska operatorerAbout Arithmetic Operators

KORT BESKRIVNINGSHORT DESCRIPTION

Beskriver de operatorer som utför aritmetiska i PowerShell.Describes the operators that perform arithmetic in PowerShell.

LÅNG BESKRIVNINGLONG DESCRIPTION

Aritmetiska operatorer beräknar numeriska värden.Arithmetic operators calculate numeric values. Du kan använda en eller flera aritmetiska operatorer för att lägga till, subtrahera, multiplicera och dividera värden och för att beräkna resten (Modulus) av en divisions åtgärd.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.

Dessutom körs operatorn addition ( + ) och multiplikation ( * ) även på strängar, matriser och hash-tabeller.In addition, the addition operator (+) and multiplication operator (*) also operate on strings, arrays, and hash tables. Operatorn addition sammanfogar indatamängden.The addition operator concatenates the input. Operatorn multiplikation returnerar flera kopior av indatamängden.The multiplication operator returns multiple copies of the input. Du kan till och med blanda objekt typer i en aritmetisk instruktion.You can even mix object types in an arithmetic statement. Metoden som används för att utvärdera uttrycket bestäms av typen för objektet längst till vänster i uttrycket.The method that is used to evaluate the statement is determined by the type of the leftmost object in the expression.

Från och med PowerShell 2,0 fungerar alla aritmetiska operatorer på 64-bitars nummer.Beginning in PowerShell 2.0, all arithmetic operators work on 64-bit numbers.

Från och med PowerShell 3,0 -shr läggs (Shift-höger) och -shl (Shift-Left) till som stöd för bitvisa aritmetiska i PowerShell.Beginning in PowerShell 3.0, the -shr (shift-right) and -shl (shift-left) are added to support bitwise arithmetic in PowerShell.

PowerShell stöder följande aritmetiska operatorer:PowerShell supports the following arithmetic operators:

OperatorOperator BeskrivningDescription ExempelExample
+ Lägger till heltal; sammanfogarAdds integers; concatenates 6 + 2
strängar, matriser och hash-tabeller.strings, arrays, and hash tables. "file" + "name"
@(1, "one") + @(2.0, "two")
@{"one" = 1} + @{"two" = 2}
- Subtraherar ett värde från ett annatSubtracts one value from another 6 - 2
värdevalue
- Gör ett tal till ett negativt talMakes a number a negative number -6
(Get-Date).AddDays(-1)
* Multiplicera tal eller kopiera strängarMultiply numbers or copy strings 6 * 2
och matriser det angivna taletand arrays the specified number @("!") * 4
av gånger.of times. "!" * 3
/ Dividerar två värden.Divides two values. 6 / 2
% Modulus-returnerar resten avModulus - returns the remainder of 7 % 2
en divisions åtgärd.a division operation.
-band-band Bitvis ochBitwise AND 5 -band 3
-bnot-bnot Bitvis NOTBitwise NOT -bnot 5
– bor-bor Bitvis ellerBitwise OR 5 -bor 0x03
-bxor-bxor Bitvis XORBitwise XOR 5 -bxor 3
-shl-shl Flyttar bitar till vänsterShifts bits to the left 102 -shl 2
-shr-shr Flyttar bitar till högerShifts bits to the right 102 -shr 2

De bitvisa operatorerna fungerar bara på heltals typer.The bitwise operators only work on integer types.

PRIORITET FÖR OPERATOROPERATOR PRECEDENCE

PowerShell bearbetar aritmetiska operatorer i följande ordning:PowerShell processes arithmetic operators in the following order:

PrioritetPrecedence OperatorOperator BeskrivningDescription
11 () ParentesParentheses
22 - För en negativ siffra eller enställig operatorFor a negative number or unary operator
33 *, /, %*, /, % För multiplikation och divisionFor multiplication and division
44 +, -+, - För addition och subtraktionFor addition and subtraction
55 -band, -bnot-band, -bnot För bitvisa åtgärderFor bitwise operations
55 -bor, -bxor-bor, -bxor För bitvisa åtgärderFor bitwise operations
55 -shr, -shl-shr, -shl För bitvisa åtgärderFor bitwise operations

PowerShell bearbetar uttrycken från vänster till höger enligt prioritets reglerna.PowerShell processes the expressions from left to right according to the precedence rules. I följande exempel visas resultatet av prioritets reglerna:The following examples show the effect of the precedence rules:

UttryckExpression ResultatResult
3+6/3*4 11
3+6/(3*4) 3.5
(3+6)/3*4 12

Den ordning i vilken PowerShell utvärderar uttryck kan skilja sig från andra programmerings-och skript språk som du har använt.The order in which PowerShell evaluates expressions might differ from other programming and scripting languages that you have used. I följande exempel visas en komplicerad tilldelnings instruktion.The following example shows a complicated assignment statement.

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

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

I det här exemplet $a++ utvärderas uttrycket före $b[$a] .In this example, the expression $a++ is evaluated before $b[$a]. Utvärdering av $a++ ändringar av värdet $a efter det används i instruktionen, $c[$a++] men innan det används i $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]. Variabeln $a i $b[$a] är lika med 1 , 0 så tilldelar instruktionen ett värde till $b[1] , inte $b[0] .The variable $a in $b[$a] equals 1, not 0; so, the statement assigns a value to $b[1], not $b[0].

Ovanstående kod motsvarar:The above code is equivalent to:

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

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

DIVISION OCH AVRUNDNINGDIVISION AND ROUNDING

När kvoten för en divisions åtgärd är ett heltal, avrundar PowerShell värdet till närmaste heltal.When the quotient of a division operation is an integer, PowerShell rounds the value to the nearest integer. När värdet är .5 , avrundas det till närmaste jämna heltal.When the value is .5, it rounds to the nearest even integer.

I följande exempel visas effekterna av avrundning till närmaste jämna heltal.The following example shows the effect of rounding to the nearest even integer.

UttryckExpression ResultatResult
[int]( 5 / 2 ) 2
[int]( 7 / 2 ) 4

Observera hur 5/2 = 2,5 rundas av till 2.Notice how 5/2 = 2.5 gets rounded to 2. Men 7/2 = 3,5 rundas av till 4.But, 7/2 = 3.5 gets rounded to 4.

Du kan använda- [Math] klassen för att få olika avrundnings sätt.You can use the [Math] class to get different rounding behavior.

UttryckExpression ResultatResult
[int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero) 3
[int][Math]::Ceiling(5 / 2) 3
[int][Math]::Floor(5 / 2) 2

Mer information finns i metoden Math. Round .For more information, see the Math.Round method.

LÄGGA TILL OCH MULTIPLICERA ICKE-NUMERISKA TYPERADDING AND MULTIPLYING NON-NUMERIC TYPES

Du kan lägga till siffror, strängar, matriser och hash-tabeller.You can add numbers, strings, arrays, and hash tables. Du kan också multiplicera siffror, strängar och matriser.And, you can multiply numbers, strings, and arrays. Du kan dock inte multiplicera hash-tabeller.However, you cannot multiply hash tables.

När du lägger till strängar, matriser eller hash-tabeller sammanfogas elementen.When you add strings, arrays, or hash tables, the elements are concatenated. När du sammanfogar samlingar, till exempel matriser eller hash-tabeller, skapas ett nytt objekt som innehåller objekten från båda samlingarna.When you concatenate collections, such as arrays or hash tables, a new object is created that contains the objects from both collections. Om du försöker sammanfoga hash-tabeller som har samma nyckel, Miss lyckas åtgärden.If you try to concatenate hash tables that have the same key, the operation fails.

Följande kommandon skapar till exempel två matriser och lägger till dem: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

Du kan också utföra aritmetiska åtgärder på objekt av olika typer.You can also perform arithmetic operations on objects of different types. Den åtgärd som PowerShell utför bestäms av Microsoft .NET Framework-typen för objektet längst till vänster i åtgärden.The operation that PowerShell performs is determined by the Microsoft .NET Framework type of the leftmost object in the operation. PowerShell försöker konvertera alla objekt i åtgärden till den .NET Framework typen för det första objektet.PowerShell tries to convert all the objects in the operation to the .NET Framework type of the first object. Om det lyckas med att konvertera objekten utför den åtgärden som är lämplig för den .NET Framework typen för det första objektet.If it succeeds in converting the objects, it performs the operation appropriate to the .NET Framework type of the first object. Åtgärden Miss lyckas om det inte går att konvertera något av objekten.If it fails to convert any of the objects, the operation fails.

I följande exempel demonstreras användningen av operatorerna addition och multiplikation. i åtgärder som innehåller olika objekt typer.The following examples demonstrate the use of the addition and multiplication operators; in operations that include different object types. Antag $array = 1,2,3 :Assume $array = 1,2,3:

UttryckExpression ResultatResult
"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

Eftersom metoden som används för att utvärdera instruktioner bestäms av objektet längst till vänster, är addition och multiplikation i PowerShell inte strikt commutative.Because the method that is used to evaluate statements is determined by the leftmost object, addition and multiplication in PowerShell are not strictly commutative. Till exempel är (a + b) inte alltid lika med (b + a) , och (ab) är inte alltid lika med (ba) .For example, (a + b) does not always equal (b + a), and (ab) does not always equal (ba).

Följande exempel visar den här principen:The following examples demonstrate this principle:

UttryckExpression ResultatResult
"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 + "fil" "+ 16 + "file"`

Hash-tabeller skiljer sig något från versaler.Hash tables are a slightly different case. Du kan lägga till hash-tabeller i en annan hash-tabell, så länge som de tillagda hash-tabellerna inte har dubbla nycklar.You can add hash tables to another hash table, as long as, the added hash tables don't have duplicate keys.

I följande exempel visas hur du lägger till hash-tabeller till varandra.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

I följande exempel utlöses ett fel eftersom en av nycklarna dupliceras i båda hash-tabellerna.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

Du kan också lägga till en hash-tabell i en matris. Dessutom blir hela hash-tabellen ett objekt i matrisen.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

Du kan dock inte lägga till någon annan typ i en hash-tabell.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

Även om addition-operatörerna är mycket användbara använder du tilldelnings operatörerna för att lägga till element i hash-tabeller och matriser.Although the addition operators are very useful, use the assignment operators to add elements to hash tables and arrays. Mer information finns i about_assignment_operators.For more information see about_assignment_operators. I följande exempel används += tilldelnings operatorn för att lägga till objekt i en matris:The following examples use the += assignment operator to add items to an array:

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

SKRIV KONVERTERING FÖR ATT HANTERA RESULTATETTYPE CONVERSION TO ACCOMMODATE RESULT

PowerShell väljer automatiskt den .NET Framework numeriska typ som bäst uttrycker resultatet utan att förlora precisionen.PowerShell automatically selects the .NET Framework numeric type that best expresses the result without losing precision. Ett exempel:For example:

2 + 3.1

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

Om resultatet av en åtgärd är för stort för typen, utvidgas typen av resultat för att hantera resultatet, som i följande exempel: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

Resultat typen behöver inte nödvändigt vis vara samma som en av operanderna.The type of the result will not necessarily be the same as one of the operands. I följande exempel kan det negativa värdet inte omvandlas till ett osignerat heltal, och det osignerade heltalet är för stort för att kunna omvandlas till 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

I det här exemplet Int64 kan hantera båda typerna.In this example, Int64 can accommodate both types.

System.DecimalTypen är ett undantag.The System.Decimal type is an exception. Om någon av operanderna har decimal typen, blir resultatet av decimal typen.If either operand has the Decimal type, the result will be of the Decimal type. Om resultatet är för stort för decimal typen, kommer det inte att omvandlas till Double.If the result is too large for the Decimal type, it will not be cast to Double. I stället ett fel resultat.Instead, an error results.

UttryckExpression ResultatResult
[Decimal]::maxvalue 79228162514264337593543950335
[Decimal]::maxvalue + 1 Value was either too large or too small for a
Decimal.

ARITMETISKA OPERATORER OCH VARIABLERARITHMETIC OPERATORS AND VARIABLES

Du kan också använda aritmetiska operatorer med variabler.You can also use arithmetic operators with variables. Operatorerna fungerar på Variablernas värden.The operators act on the values of the variables. I följande exempel demonstreras användningen av aritmetiska operatorer med variabler:The following examples demonstrate the use of arithmetic operators with variables:

UttryckExpression ResultatResult
$intA = 6
$intB = 4
$intA + $intB
10
$a = "Power"
$b = "Shell"
$a + $b
PowerShell

ARITMETISKA OPERATORER OCH KOMMANDONARITHMETIC OPERATORS AND COMMANDS

Normalt använder du aritmetiska operatorer i uttryck med siffror, strängar och matriser.Typically, you use the arithmetic operators in expressions with numbers, strings, and arrays. Du kan dock också använda aritmetiska operatorer med de objekt som kommandona returnerar och med egenskaperna för dessa objekt.However, you can also use arithmetic operators with the objects that commands return and with the properties of those objects.

I följande exempel visas hur du använder de aritmetiska operatorerna i uttryck med PowerShell-kommandon:The following examples show how to use the arithmetic operators in expressions with PowerShell commands:

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

Parentes operatorn tvingar fram utvärderingen av get-date cmdleten och utvärderingen av new-timespan -day 1 cmdlet-uttrycket i den ordningen.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. Båda resultaten läggs sedan till med + operatorn.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

I uttrycket ovan multipliceras varje process arbets utrymme ( $_.ws ) av 2 och resultatet jämförs med 50mb för att se om det är större än.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.

Bitvisa operatorerBitwise Operators

PowerShell stöder bitvisa standardoperatorer, inklusive bitvis-AND ( -bAnd ), inkluderings-och Exclusive-eller operatorerna ( -bOr och -bXor ) och bitvis-not ( -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).

Från och med PowerShell 2,0 fungerar alla bitvisa operatorer med 64-bitars heltal.Beginning in PowerShell 2.0, all bitwise operators work with 64-bit integers.

Från och med PowerShell 3,0 -shr introduceras (Shift-höger) och -shl (Shift-Left) för att stödja bitvisa beräkningar i PowerShell.Beginning in PowerShell 3.0, the -shr (shift-right) and -shl (shift-left) are introduced to support bitwise arithmetic in PowerShell.

PowerShell stöder följande bitvisa operatorer.PowerShell supports the following bitwise operators.

OperatorOperator BeskrivningDescription UttryckExpression ResultatResult
-band Bitvis ochBitwise AND 10 -band 3 22
-bor Bitvis eller (inklusiv)Bitwise OR (inclusive) 10 -bor 3 1111
-bxor Bitvis eller (exklusiv)Bitwise OR (exclusive) 10 -bxor 3 99
-bnot Bitvis NOTBitwise NOT -bNot 10 -11-11
-shl Shift-vänsterShift-left 102 -shl 2 408408
-shr Shift-högerShift-right 102 -shr 1 5151

Bitvisa operatorer fungerar som ett värde i binärformat.Bitwise operators act on the binary format of a value. Bit strukturen för nummer 10 är till exempel 00001010 (baserat på 1 byte) och bit strukturen för talet 3 är 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. När du använder en bitvis operator för att jämföra 10 och 3 jämförs de enskilda bitarna i varje byte.When you use a bitwise operator to compare 10 to 3, the individual bits in each byte are compared.

I en bitvis och-åtgärd anges den resulterande biten till 1 endast när båda indataportarna är 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)

I en bitvis eller (inklusiv) åtgärd anges den resulterande biten till 1 när antingen eller båda indataportarna är 1.In a bitwise OR (inclusive) operation, the resulting bit is set to 1 when either or both input bits are 1. Den resulterande biten anges till 0 endast när båda indataportarna anges till 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)

I en bitvis eller (exklusiv) åtgärd anges den resulterande biten till 1 endast när en indataport är 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)

Den bitvis NOT-operatorn är en unär operator som producerar det binära komplettering svärdet.The bitwise NOT operator is a unary operator that produces the binary complement of the value. Bit-bit 1 är inställd på 0 och biten 0 har värdet 1.A bit of 1 is set to 0 and a bit of 0 is set to 1.

Till exempel binära komplementet 0 är-1, det maximala osignerade heltalet (0xFFFFFFFF) och det binära komplementet på-1 är 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)

I en bitvis Shift-Left-åtgärd flyttas alla bitar "n" dit till vänster, där "n" är värdet för den högra operanden.In a bitwise shift-left operation, all bits are moved "n" places to the left, where "n" is the value of the right operand. En nolla infogas på den plats där de finns.A zero is inserted in the ones place.

När den vänstra operanden är ett heltals värde (32-bitars) avgör de nedre 5 bitarna i den högra operanden hur många bitar av den vänstra operanden som flyttas.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.

När den vänstra operanden är ett Long (64-bitars) värde, bestämmer de nedre 6 bitarna i den högra operanden hur många bitar av den vänstra operanden som flyttas.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.

UttryckExpression ResultatResult Binära resultatBinary Result
21 -shl 0 2121 0001 01010001 0101
21 -shl 1 4242 0010 10100010 1010
21 -shl 2 8484 0101 01000101 0100

I en bitvis Shift-höger-åtgärd flyttas alla bitar "n" åt höger, där "n" anges av den högra operanden.In a bitwise shift-right operation, all bits are moved "n" places to the right, where "n" is specified by the right operand. Shift-höger-operatorn (-SHR) infogar en nolla på platsen längst till vänster när ett positivt eller osignerat värde flyttas till höger.The shift-right operator (-shr) inserts a zero in the left-most place when shifting a positive or unsigned value to the right.

När den vänstra operanden är ett heltals värde (32-bitars) avgör de nedre 5 bitarna i den högra operanden hur många bitar av den vänstra operanden som flyttas.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.

När den vänstra operanden är ett Long (64-bitars) värde, bestämmer de nedre 6 bitarna i den högra operanden hur många bitar av den vänstra operanden som flyttas.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.

UttryckExpression ResultatResult BinärBinary HexadecimalHex
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

SE ÄVENSEE ALSO