Сведения об арифметических операторах

Статья
06/21/2023

КРАТКОЕ ОПИСАНИЕ

Описывает операторы, выполняющие арифметические действия в PowerShell.

ПОДРОБНОЕ ОПИСАНИЕ

Арифметические операторы вычисляют числовые значения. Один или несколько арифметических операторов можно использовать для сложения, вычитания, умножения и деления значений, а также для вычисления остатка (модуля) операции деления.

Кроме того, оператор сложения (+) и оператор умножения (*) также работают со строками, массивами и хэш-таблицами. Оператор сложения объединяет входные данные. Оператор умножения возвращает несколько копий входных данных. В арифметическом операторе можно даже смешивать типы объектов. Метод, используемый для вычисления инструкции, определяется типом крайнего левого объекта в выражении.

Начиная с PowerShell 2.0 все арифметические операторы работают с 64-разрядными числами.

Начиная с PowerShell 3.0 для поддержки -shr побитовой арифметики в PowerShell добавляются (shift-right) и -shl (shift-left).

PowerShell поддерживает следующие арифметические операторы:

Оператор	Описание	Пример
+	Добавляет целые числа; Сцепляет	`6 + 2`
	строки, массивы и хэш-таблицы.	`"file" + "name"`
		`@(1, "one") + @(2.0, "two")`
		`@{"one" = 1} + @{"two" = 2}`
-	Вычитает одно значение из другого	`6 - 2`
	значение
-	Делает число отрицательным числом	`-6`
		`(Get-Date).AddDays(-1)`
*	Умножение чисел или копирование строк	`6 * 2`
	и массивы указанного числа	`@("!") * 4`
	раз.	`"!" * 3`
/	Производит деление двух значений.	`6 / 2`
%	Модуль — возвращает остаток	`7 % 2`
	операция деления.
-Группа	Побитовое И	`5 -band 3`
-bnot	Побитовое НЕ	`-bnot 5`
-Бор	Побитовое ИЛИ	`5 -bor 0x03`
-bxor	Побитовое исключающее ИЛИ	`5 -bxor 3`
-Shl	Сдвиг битов влево	`102 -shl 2`
-Shr	Сдвиг битов вправо	`102 -shr 2`

Побитовые операторы работают только с целыми типами.

ПРИОРИТЕТ ОПЕРАТОРОВ

PowerShell обрабатывает арифметические операторы в следующем порядке:

Приоритет	Оператор	Описание
1	`()`	Круглые скобки
2	`-`	Для отрицательного числа или унарного оператора
3	`*`, `/`, `%`	Для умножения и деления
4	`+`, `-`	Для сложения и вычитания
5	`-band`, `-bnot`	Для побитовых операций
5	`-bor`, `-bxor`	Для побитовых операций
5	`-shr`, `-shl`	Для побитовых операций

PowerShell обрабатывает выражения слева направо в соответствии с правилами очередности. В следующих примерах показан эффект правил очередности:

Выражение	Результат
`3+6/3*4`	`11`
`3+6/(3*4)`	`3.5`
`(3+6)/3*4`	`12`

Порядок, в котором PowerShell оценивает выражения, может отличаться от других используемых вами языков программирования и сценариев. В следующем примере показана сложная инструкция присваивания.

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

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

В этом примере выражение $a++ вычисляется перед $b[$a]. При оценке $a++ изменяется значение $a после его использования в операторе $c[$a++]; но до его использования в $b[$a]. Переменная $a в $b[$a] равно 1, а не 0, поэтому оператор присваивает значение $b[1], а не $b[0].

Приведенный выше код эквивалентен:

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

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

ДЕЛЕНИЕ И ОКРУГЛЕНИЕ

Если коэффициент операции деления является целым числом, PowerShell округляет значение до ближайшего целого числа. Если значение равно .5, оно округляется до ближайшего четного целого числа.

В следующем примере показан эффект округления до ближайшего четного целого числа.

Выражение	Результат
`[int]( 5 / 2 )`	`2`
`[int]( 7 / 2 )`	`4`

Обратите внимание, что 5/2 = 2,5 округляется до 2. Но 7/2 = 3,5 округляется до 4.

Класс можно использовать для [Math] разного поведения округления.

Выражение	Результат
`[int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero)`	`3`
`[int][Math]::Ceiling(5 / 2)`	`3`
`[int][Math]::Floor(5 / 2)`	`2`

Дополнительные сведения см. в статье Метод Math.Round .

ДОБАВЛЕНИЕ И УМНОЖЕНИЕ НЕЧИСЛОВЫХ ТИПОВ

Вы можете добавлять числа, строки, массивы и хэш-таблицы. Кроме того, можно умножить числа, строки и массивы. Однако нельзя умножить хэш-таблицы.

При добавлении строк, массивов или хэш-таблиц элементы объединяются. При объединии коллекций, таких как массивы или хэш-таблицы, создается новый объект, содержащий объекты из обеих коллекций. Если попытаться сцепить хэш-таблицы с тем же ключом, операция завершится ошибкой.

Например, следующие команды создают два массива, а затем добавляют их:

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

1
2
3
A
B
C

Вы также можете выполнять арифметические операции с объектами разных типов. Операция, выполняемая PowerShell, определяется типом Microsoft платформа .NET Framework крайнего левого объекта в операции. PowerShell пытается преобразовать все объекты в операции в тип платформа .NET Framework первого объекта. При успешном преобразовании объектов выполняется операция, соответствующая типу платформа .NET Framework первого объекта. Если не удается преобразовать какой-либо из объектов, операция завершается ошибкой.

В следующих примерах показано использование операторов сложения и умножения. в операциях, которые включают различные типы объектов. Предположим, что $array = 1,2,3:

Выражение	Результат
`"file" + 16`	`file16`
`$array + 16`	`1`,`2`,`3`,`16`
`$array + "file"`	`1`,`2`,`3`,`file`
`$array * 2`	`1`,`2`,`3`,`1`,`2`,`3`
`"file" * 3`	`filefilefile`

Так как метод, используемый для вычисления операторов, определяется крайним левым объектом, сложение и умножение в PowerShell не являются строго коммутативными. Например, (a + b) не всегда равно (b + a), а (ab) не всегда равно (ba).

Этот принцип демонстрируется в следующих примерах:

Выражение	Результат
`"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 + "файл"

Хэш-таблицы немного отличаются. Вы можете добавить хэш-таблицы в другую хэш-таблицу, если у добавленных хэш-таблиц нет повторяющихся ключей.

В следующем примере показано, как добавлять хэш-таблицы друг к другу.

$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

В следующем примере возникает ошибка, так как один из ключей дублируется в обеих хэш-таблицах.

$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

Кроме того, можно добавить хэш-таблицу в массив; и вся хэш-таблица становится элементом в массиве.

$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

Однако вы не можете добавить в хэш-таблицу другие типы.

$hash1 + 2

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

Хотя операторы сложения очень полезны, используйте операторы присваивания для добавления элементов в хэш-таблицы и массивы. Дополнительные сведения см. в разделе about_assignment_operators. В следующих примерах используется += оператор присваивания для добавления элементов в массив:

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

0
1
2

ПРЕОБРАЗОВАНИЕ ТИПОВ ДЛЯ РАЗМЕЩЕНИЯ РЕЗУЛЬТАТА

PowerShell автоматически выбирает платформа .NET Framework числовой тип, который лучше всего выражает результат без потери точности. Пример:

2 + 3.1

(2). GetType().FullName
(2 + 3.1).GetType().FullName

5.1
System.Int32
System.Double

Если результат операции слишком велик для типа, тип результата расширяется в соответствии с результатом, как показано в следующем примере:

(512MB).GetType().FullName
(512MB * 512MB).GetType().FullName

System.Int32
System.Double

Тип результата не обязательно будет совпадать с типом одного из операндов. В следующем примере отрицательное значение не может быть приведено к целому значению без знака, а целое число без знака слишком велико для приведения к Int32:

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

System.Int64

В этом примере Int64 может вместить оба типа.

Тип System.Decimal является исключением. Если один из операндов имеет тип Decimal, результат будет иметь тип Decimal. Если результат слишком велик для типа Decimal, он не будет приведен к Double. Вместо этого возникает ошибка.

Выражение	Результат
`[Decimal]::maxvalue`	`79228162514264337593543950335`
`[Decimal]::maxvalue + 1`	`Value was either too large or too small for a`
	`Decimal.`

АРИФМЕТИЧЕСКИЕ ОПЕРАТОРЫ И ПЕРЕМЕННЫЕ

Можно также использовать арифметические операторы с переменными. Операторы действуют на значения переменных. В следующих примерах показано использование арифметических операторов с переменными:

Выражение	Результат
`$intA = 6` `$intB = 4` `$intA + $intB`	`10`
`$a = "Power"` `$b = "Shell"` `$a + $b`	`PowerShell`

АРИФМЕТИЧЕСКИЕ ОПЕРАТОРЫ И КОМАНДЫ

Как правило, арифметические операторы используются в выражениях с числами, строками и массивами. Однако можно также использовать арифметические операторы с объектами, возвращаемыми командами, и со свойствами этих объектов.

В следующих примерах показано, как использовать арифметические операторы в выражениях с командами PowerShell:

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

Оператор круглых скобок принудительно выполняет вычисление командлета get-date и вычисление выражения командлета new-timespan -day 1 в указанном порядке. Затем оба результата добавляются с помощью + оператора .

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

В приведенном выше выражении каждое рабочее пространство процесса ($_.ws) умножается на 2; и результат сравнивается 50mb с , чтобы увидеть, больше ли он.

Побитовые операторы

PowerShell поддерживает стандартные побитовые операторы, включая побитовые операторы И (-bAnd), операторы инклюзивного и исключающего побитового ИЛИ (-bOr и -bXor), а также побитовые операторы-NOT (-bNot).

Начиная с PowerShell 2.0 все побитовые операторы работают с 64-разрядными целыми числами.

Начиная с PowerShell 3.0, -shr для поддержки побитовой арифметики в PowerShell появились (shift-right) и -shl (shift-left).

PowerShell поддерживает следующие побитовые операторы.

Оператор	Описание	Выражение	Результат
`-band`	Побитовое И	`10 -band 3`	2
`-bor`	Побитовое ИЛИ (включительно)	`10 -bor 3`	11
`-bxor`	Побитовое ИЛИ (монопольное)	`10 -bxor 3`	9
`-bnot`	Побитовое НЕ	`-bNot 10`	-11
`-shl`	Сдвиг влево	`102 -shl 2`	408
`-shr`	Shift-right	`102 -shr 1`	51

Побитовые операторы действуют на двоичный формат значения. Например, битовая структура числа 10 00001010 (на основе 1 байта), а битовая структура числа 3 — 00000011. При использовании побитового оператора для сравнения от 10 до 3 отдельные биты в каждом байте сравниваются.

В побитовой операции AND результирующий бит имеет значение 1, только если оба входных бита равны 1.

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

В побитовой операции ИЛИ (включительно) результирующий бит имеет значение 1, если один или оба входных бита равны 1. Результирующий бит имеет значение 0, только если оба входных бита имеют значение 0.

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

В побитовой операции ИЛИ (монопольная) результирующий бит имеет значение 1, только если один входной бит равен 1.

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

Побитовый оператор NOT является унарным оператором, который создает двоичное дополнение значения. Бит 1 имеет значение 0, а бит 0 — значение 1.

Например, двоичное дополнение 0 равно -1, максимальное целое число без знака (0xffffffff), а двоичное дополнение -1 равно 0.

-bNot 10

-11

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

В побитовой операции сдвига влево все биты перемещаются "n" влево, где "n" — это значение правого операнда. В них вставляется ноль.

Если левый операнд является целочисленным (32-разрядным) значением, сколько битов левого операнда смещено, определяется нижними 5 битами правого операнда.

Если левый операнд имеет длинное (64-разрядное) значение, сколько битов левого операнда смещено, определяются нижними 6 битами правого операнда.

Выражение	Результат	Двоичный результат
`21 -shl 0`	21	0001 0101
`21 -shl 1`	42	0010 1010
`21 -shl 2`	84	0101 0100

В побитовой операции сдвига вправо все биты перемещаются на "n" местах вправо, где "n" задается правым операндом. Оператор shift-right (-shr) вставляет ноль в самое левое место при смещении положительного или неподписаного значения вправо.

Выражение	Результат	Двоичные данные	Hex
`21 -shr 0`	21	0001 0101	0x15
`21 -shr 1`	10	0000 1010	0x0A
`21 -shr 2`	5	0000 0101	0x05
`21 -shr 31`	0	0000 0000	0x00
`21 -shr 32`	21	0001 0101	0x15
`21 -shr 64`	21	0001 0101	0x15
`21 -shr 65`	10	0000 1010	0x0A
`21 -shr 66`	5	0000 0101	0x05
`[int]::MaxValue -shr 1`	1073741823		0x3FFFFFFF
`[int]::MinValue -shr 1`	-1073741824		0xC0000000
`-1 -shr 1`	-1		0xFFFFFFFF

Поделиться через