Powershell операторы сравнения: об операторах сравнения — PowerShell

Содержание

об операторах сравнения — PowerShell

Статья

01/24/2023

Чтение занимает 12 мин

Краткое описание

Операторы сравнения в PowerShell могут сравнивать два значения или фильтровать элементы коллекции по входным значениям.

Подробное описание

Операторы сравнения позволяют сравнивать значения или находить значения, соответствующие заданным шаблонам. PowerShell включает следующие операторы сравнения:

Равенство

-eq, -ieq, -ceq — равно
-ne, -ine, -cne — не равно
-gt, -igt, -cgt — больше
-ge, -ige, -cge — больше или равно
-lt, -ilt, -clt — меньше
-le, -ile, -cle — меньше или равно

Соответствующие

-like, -ilike, -clike — строка соответствует шаблону с подстановочными знаками
-notlike, -inotlike, -cnotlike — строка не соответствует шаблону с подстановочными знаками
-match, -imatch, -cmatch — строка соответствует шаблону регулярных выражений
-notmatch, -inotmatch, -cnotmatch — строка не соответствует шаблону регулярных выражений

Замена

-replace, -ireplace, -creplace — заменяет строки, соответствующие шаблону регулярных выражений.

Сдерживания

-contains, -icontains, -ccontains — коллекция содержит значение
-notcontains, -inotcontains, -cnotcontains — коллекция не содержит значения
-in — значение находится в коллекции
-notin — значение отсутствует в коллекции

Тип

-is — оба объекта имеют один и тот же тип
-isnot — объекты не совпадают с типом

Общие возможности

Сравнение строк не учитывает регистр, если не используется явный оператор с учетом регистра. Чтобы оператор сравнения учитывал регистр, добавьте c после -. Например, -ceq — это версия с учетом регистра -eq.
Чтобы сделать учет регистра явным, добавьте i после -. Например, -ieq — это версия без учета регистра -eq.

Если входные данные оператора являются скалярным значением, оператор возвращает логическое значение. Если входные данные являются коллекцией, оператор возвращает элементы коллекции, соответствующие значению выражения справа.
Если в коллекции нет совпадений, операторы сравнения возвращают пустой массив. Например:

$a = (1, 2) -eq 3
$a.GetType().Name
$a.Count

Object[]
0

Существует несколько исключений:

Операторы containment и type всегда возвращают логическое значение.
Оператор -replace возвращает результат замены.
-match Операторы и -notmatch также заполняют автоматическую $Matches переменную, если только левая часть выражения не является коллекцией.

Операторы равенства

-eq и -ne

Если левая сторона скалярна, возвращает значение True, -eq если правая сторона является точным совпадением, в противном случае -eq возвращает значение False. -ne делает обратное; он возвращает значение False , если обе стороны совпадают; -ne В противном случае возвращает значение True.

Пример

2 -eq 2                 # Output: True
2 -eq 3                 # Output: False
"abc" -eq "abc"         # Output: True
"abc" -eq "abc", "def"  # Output: False
"abc" -ne "def"         # Output: True
"abc" -ne "abc"         # Output: False
"abc" -ne "abc", "def"  # Output: True

Если слева является коллекцией, возвращает те элементы, -eq которые соответствуют правой стороне, а -ne фильтрует их.

Пример

1,2,3 -eq 2             # Output: 2
"abc", "def" -eq "abc"  # Output: abc
"abc", "def" -ne "abc"  # Output: def

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

"zzz", "def", "zzz" -eq "zzz"

zzz
zzz

Оператор равенства может сравнивать объекты разных типов. Важно понимать, что значение в правой части сравнения можно преобразовать в тип левого значения для сравнения.

Например, строка '1.0' преобразуется в целое число для сравнения со значением 1. В этом примере возвращается True.

PS> 1 -eq '1.0'
True

В этом примере значение 1 преобразуется в строку для сравнения со строкой '1.0'. В этом примере возвращается False.

PS> '1.0' -eq 1
False

Операторы равенства принимают любые два объекта, а не только скаляр или коллекцию.
Но результат сравнения не гарантируется, что он будет значимым для конечного пользователя.
В следующем примере демонстрируется проблема.

class MyFileInfoSet {
    [String]$File
    [Int64]$Size
}
$a = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$b = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$a -eq $b

False

В этом примере мы создали два объекта с одинаковыми свойствами. Тем не менее, результат проверки на равенство имеет значение False , так как они являются разными объектами. Чтобы создать сопоставимые классы, необходимо реализовать System.IEquatable<T> в классе. В следующем примере демонстрируется частичная реализация класса MyFileInfoSet , который реализует System.IEquatable<T> и имеет два свойства: File и Size. Метод Equals() возвращает значение True , если свойства File и Size двух объектов MyFileInfoSet совпадают.

class MyFileInfoSet : System.IEquatable[Object] {
    [String]$File
    [Int64]$Size
    [bool] Equals([Object] $obj) {
        return ($this.File -eq $obj.File) -and ($this.Size -eq $obj.Size)
    }
}
$a = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$b = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$a -eq $b

True

Ярким примером сравнения произвольных объектов является определение их значения NULL. Но если необходимо определить, является $nullли переменная , необходимо поместить $null в левую часть оператора равенства. Положив его на правую сторону, вы не делаете то, что вы ожидаете.

Например, пусть будет $a массивом, содержащим элементы NULL:

$a = 1, 2, $null, 4, $null, 6

Ниже приведены тесты, не $a имеющие значения NULL.

$null -ne $a

True

Однако следующие файлы извлекает все элементы NULL из $a:

$a -ne $null # Output: 1, 2, 4, 6

-gt, -ge, -lt и -le

-gt, -ge, -ltи -le ведут себя очень аналогично. Если обе стороны являются скалярными, они возвращают значение True или False в зависимости от того, как обе стороны сравниваются:

Оператор	Возвращает значение True, если…
`-gt`	Левая часть больше
`-ge`	Левая часть больше или равна
`-lt`	Левая часть меньше
`-le`	Левая сторона меньше или равна

В следующих примерах все операторы возвращают значение True.

8 -gt 6  # Output: True
8 -ge 8  # Output: True
6 -lt 8  # Output: True
8 -le 8  # Output: True

Примечание

В большинстве языков программирования оператором больше, чем является >. В PowerShell этот символ используется для перенаправления. Дополнительные сведения см . в разделе about_Redirection.

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

Пример

$a=5, 6, 7, 8, 9
Write-Output "Test collection:"
$a
Write-Output "`nMembers greater than 7"
$a -gt 7
Write-Output "`nMembers greater than or equal to 7"
$a -ge 7
Write-Output "`nMembers smaller than 7"
$a -lt 7
Write-Output "`nMembers smaller than or equal to 7"
$a -le 7

Test collection:
5
6
7
8
9
Members greater than 7
8
9
Members greater than or equal to 7
7
8
9
Members smaller than 7
5
6
Members smaller than or equal to 7
5
6
7

Эти операторы работают с любым классом, реализующим System. ‘,’&’,’*’,'(‘,’)’,’_’,’+’,’-‘,’=’,
‘{‘,’}’,'[‘,’]’,’:’,’;’,'»‘,»»,’\’,’|’,’/’,’?’,’.’,’>’,’,’,'<‘
$a -gt ‘a’
# Output: Nothing

Если обе стороны операторов не являются достаточно сопоставимыми, эти операторы вызывают неустранимую ошибку.

Операторы сопоставления

Соответствующие операторы (-like, -notlike, -matchи -notmatch) находят элементы, которые соответствуют или не соответствуют заданному шаблону. Шаблон для -like и -notlike — это выражение с подстановочными знаками (содержащее *, ?и [ ]), в то время как -match и -notmatch принимают регулярное выражение (регулярное выражение).

Синтаксис:

<string[]> -like    <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match    <regular-expression>
<string[]> -notmatch <regular-expression>

Если входные данные этих операторов являются скалярным значением, они возвращают логическое значение. Если входные данные являются коллекцией значений, операторы возвращают все соответствующие элементы. Если в коллекции нет совпадений, операторы возвращают пустой массив.

-like и -notlike

-like и -notlike ведут себя аналогично -eq и -ne, но справа может быть строка, содержащая подстановочные знаки.

Пример

"PowerShell" -like    "*shell"           # Output: True
"PowerShell" -notlike "*shell"           # Output: False
"PowerShell" -like    "Power?hell"       # Output: True
"PowerShell" -notlike "Power?hell"       # Output: False
"PowerShell" -like    "Power[p-w]hell"   # Output: True
"PowerShell" -notlike "Power[p-w]hell"   # Output: False
"PowerShell", "Server" -like "*shell"    # Output: PowerShell
"PowerShell", "Server" -notlike "*shell" # Output: Server

-match и -notmatch

-match и -notmatch используйте регулярные выражения для поиска шаблона в значениях слева. Регулярные выражения могут соответствовать сложным шаблонам, таким как адреса электронной почты, UNC-пути или форматированные номера телефонов. Power\w+’
# Output: PowerShell
«Rhell», «Chell», «Mel», «Smell», «Shell» -match «hell»
# Output: Rhell, Chell, Shell
«Bag», «Beg», «Big», «Bog», «Bug» -match ‘b[iou]g’
#Output: Big, Bog, Bug
«Bag», «Beg», «Big», «Bog», «Bug» -notmatch ‘b[iou]g’
#Output: Bag, Beg

-match и -notmatch поддерживают группы отслеживания регулярных выражений. Каждый раз, когда они выполняются на скалярных входных данных, и -match результат имеет значение True или -notmatchFalse, они перезаписывают автоматическую $Matches переменную. $Matches — это хэш-таблицей , которая всегда имеет ключ с именем «0», в котором хранится все совпадение.
Если регулярное выражение содержит группы записи, $Matches объект содержит дополнительные ключи для каждой группы.

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

Пример

$string = 'The last logged on user was CONTOSO\jsmith'
$string -match 'was (?<domain>.+)\\(?<user>.+)'
$Matches
Write-Output "`nDomain name:"
$Matches.domain
Write-Output "`nUser name:"
$Matches.user

True
Name                           Value
----                           -----
domain                         CONTOSO
user                           jsmith
0                              was CONTOSO\jsmith
Domain name:
CONTOSO
User name:
jsmith

-match Если результат имеет значение False или -notmatch имеет значение True или если входные данные являются коллекцией, $Matches автоматическая переменная не перезаписывается. Следовательно, он будет содержать ранее заданное значение или $null , если переменная не была задана. При ссылке $Matches после вызова одного из этих операторов рекомендуется убедиться, что переменная была задана текущим вызовом оператора с помощью оператора condition.

Пример

if ("<version>1.0.0</version>" -match '<version>(.*?)</version>') {
    $Matches
}

Дополнительные сведения см . в разделе about_Regular_Expressions и about_Automatic_Variables.

Оператор замены

Замена регулярными выражениями

Как и -match-replace , оператор использует регулярные выражения для поиска указанного шаблона. Но в отличие от -match, он заменяет совпадения другим указанным значением.

Синтаксис:

<input> -replace <regular-expression>, <substitute>

Оператор заменяет все или часть значения указанным значением с помощью регулярных выражений. Оператор можно использовать для многих административных задач, таких как переименование файлов. Например, следующая команда изменяет расширения имен всех .txt файлов на .log:

Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' }

По умолчанию -replace оператор не учитывает регистр. Чтобы обеспечить учет регистра, используйте .-creplace Чтобы явно не учитывать регистр, используйте .-ireplace

Примеры:

"book" -ireplace "B", "C" # Case insensitive
"book" -creplace "B", "C" # Case-sensitive; hence, nothing to replace

Cook
book

Начиная с PowerShell 7.2, когда левый операнд в -replace операторе оператора не является строкой, этот операнд преобразуется в строку.
PowerShell выполняет преобразование строк без учета языка и региональных параметров.

Например, если язык и региональные параметры заданы как французский (fr), строковое преобразование значения 1.2 с учетом языка и региональных параметров будет равно 1,2.

До PowerShell 7.2:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12

В PowerShell 7.2 и более поздних версиях:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2

Подстановки регулярных выражений

Кроме того, можно использовать регулярные выражения для динамической замены текста с помощью захватывающих групп и подстановок. (?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$’
$ReplaceExp = ‘${Username}@${DomainName}’
‘Contoso.local\John.Doe’ -replace $SearchExp, $ReplaceExp

[email protected]

Предупреждение

Символ $ имеет синтаксические роли как в PowerShell, так и в регулярных выражениях:

В PowerShell между двойными кавычками он обозначает переменные и выступает в качестве оператора subexpression.
В строках поиска регулярных выражений он обозначает конец строки.
В строках подстановки регулярных выражений он обозначает захваченные группы. Обязательно поместите регулярные выражения между одиночными кавычками или вставьте перед ними символ обратной связи (`).

Например:

$1 = 'Goodbye'
'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe
'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe

$$ в regex обозначает литерал $. Это $$ значение в строке подстановки для включения литерала $ в результирующую замену. Например:

'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1'  # Output: $1

Дополнительные сведения см. в статье about_Regular_Expressions и подстановок в регулярных выражениях.

Подстановка в коллекции

<input> Если оператор to -replace является коллекцией, PowerShell применяет замену к каждому значению в коллекции. Например:

"B1","B2","B3","B4","B5" -replace "B", 'a'
a1
a2
a3
a4
a5

Замена блоком скрипта

В PowerShell 6 и более поздних версиях оператор также принимает блок скрипта, -replace который выполняет замену. Блок скрипта выполняется один раз для каждого совпадения.

Синтаксис:

<String> -replace <regular-expression>, {<Script-block>}

В блоке скрипта используйте автоматическую $_ переменную для доступа к заменяемый входной текст и другим полезным сведениям. Тип класса этой переменной — System.Text.RegularExpressions.Match.

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

"072101108108111" -replace "\d{3}", {return [char][int]$_.Value}

Hello

Операторы вложения

Операторы вложения (-contains, -notcontains, -inи -notin) похожи на операторы равенства, за исключением того, что они всегда возвращают логическое значение, даже если входные данные являются коллекцией. Эти операторы перестают сравнивать, как только обнаруживают первое совпадение, в то время как операторы равенства оценивают все входные члены. В очень большой коллекции эти операторы возвращаются быстрее, чем операторы равенства.

Синтаксис:

<Collection> -contains <Test-object>
<Collection> -notcontains <Test-object>
<Test-object> -in <Collection>
<Test-object> -notin <Collection>

-contains и -notcontains

Эти операторы сообщают, включает ли набор определенный элемент. -contains Возвращает значение True , если правая сторона (тестовый объект) соответствует одному из элементов в наборе. -notcontains Вместо этого возвращает значение False. Если объект test является коллекцией, эти операторы используют равенство ссылок, т. е. проверяют, является ли один из элементов набора одним и тем же экземпляром тестового объекта.

Примеры:

"abc", "def" -contains "def"                  # Output: True
"abc", "def" -notcontains "def"               # Output: False
"Windows", "PowerShell" -contains "Shell"     # Output: False
"Windows", "PowerShell" -notcontains "Shell"  # Output: True
"abc", "def", "ghi" -contains "abc", "def"    # Output: False
"abc", "def", "ghi" -notcontains "abc", "def" # Output: True

Более сложные примеры:

$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
                 "ContosoDHCP","ContosoWSUS"
$thisComputer  = "ContosoDC2"
$DomainServers -contains $thisComputer
# Output: True
$a = "abc", "def"
"abc", "def", "ghi" -contains $a # Output: False
$a, "ghi" -contains $a           # Output: True

-in и -notin

Операторы -in и появились в PowerShell 3 как синтаксический обратный оператор и -contains-notcontains . -notin -in Возвращает значение True , если левая сторона <test-object> соответствует одному из элементов в наборе. -notin Вместо этого возвращает значение False . Если тестовый объект является набором, эти операторы используют равенство ссылок, чтобы проверить, является ли один из элементов набора одним и тем же экземпляром тестового объекта.

В следующих примерах выполняется то же самое, что в примерах для -contains и -notcontains , но они написаны с помощью -in и -notin .

"def" -in "abc", "def"                  # Output: True
"def" -notin "abc", "def"               # Output: False
"Shell" -in "Windows", "PowerShell"     # Output: False
"Shell" -notin "Windows", "PowerShell"  # Output: True
"abc", "def" -in "abc", "def", "ghi"    # Output: False
"abc", "def" -notin "abc", "def", "ghi" # Output: True

Более сложные примеры:

$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
                 "ContosoDHCP","ContosoWSUS"
$thisComputer  = "ContosoDC2"
$thisComputer -in $DomainServers
# Output: True
$a = "abc", "def"
$a -in "abc", "def", "ghi" # Output: False
$a -in $a, "ghi"           # Output: True

Сравнение типов

Операторы сравнения типов (-is и -isnot) используются для определения того, является ли объект определенным типом.

Синтаксис:

<object> -is <type-reference>
<object> -isnot <type-reference>

Пример.

$a = 1
$b = "1"
$a -is [int]           # Output: True
$a -is $b.GetType()    # Output: False
$b -isnot [int]        # Output: True
$a -isnot $b.GetType() # Output: True

См. также раздел

about_Booleans
about_Operators
about_Regular_Expressions
about_Wildcards
Compare-Object
Foreach-Object
Where-Object

Операторы сравнения Powershell — Системный Администратор

В данной статье мы рассмотрим не только операторы сравнения Powershell, но и операторы замены, логические операторы. Сравнивать можно не только данные с типом строка или число, но и дата, булево и т.п.

В Powershell используются операторы сравнения на основе букв, что поначалу не привычно. Очень хочется написать знак > вместо -gt или знак = вместо -eq. Но со временем к такому именованию привыкаешь. Перед оператором сравнения или логическим оператором обязательно нужно ставить знак —

Операторы сравнения

Оператор	Значение	Описание
-eq	Equal	Равно
-ne	Not equal	Не равно
-gt	Greater than	Больше
-ge	Greater than or equal	Больше или равно
-lt	Less than	Меньше
-le	Less than or equal	Меньше или равно
-like	Wildcard comparison	Используется подстановка символов для поиска по шаблону
-notlike	Wildcard comparison	Используется подстановка символов для поиска не соответствия указанному шаблону
-match	Regular expression comparison	Использование регулярных выражений для поиска по шаблону
-notmatch	Regular expression comparison	Использование регулярных выражений для поиска не соответствия указанному шаблону
-contains	Containment operator	Определяет, содержит ли значение слева от оператора значение справа
-notcontains	Containment operator	Определяет, что значение слева от оператора не содержит значение оператора справа
-in	Containment operator	Возвращает true если искомое значение содержится в коллекции
-notin	Containment operator	Возвращает *true* если искомое значение не содержится в коллекции
-replace	Replace operator	Заменяет часть или все значение слева от оператора
-is	Type	Возвращает *true* если оба объекта одинаковы
-isnot	Type	Возвращает *true* если оба объекта разные

По умолчанию все операторы сравнения нечувствительны к регистру. Чтобы сделать оператор сравнения чувствительным к регистру, перед именем оператора поставьте букву c. К примеру, чувствительной к регистру оператор -eq пишется как -ceq. Чтобы сделать нечувствительность к регистру явной, перед оператором ставится i. К примеру, явно нечувствительная к регистру версия оператора -eq это -ieq.

Когда входные данные для оператора являются скалярным значением (число), операторы сравнения возвращают логическое значение. Если входные данные представляют собой набор значений, операторы сравнения возвращают любые совпадающие значения. Если в коллекции нет совпадений, операторы сравнения возвращают пустой массив. Исключение составляют операторы contains, notcontains, in, notin, is, isnot которые всегда возвращают логическое значение.

1, 2, 4, 8 -eq 2
1, 2, 4, 8 -eq 3

В первом варианте при сравнении набора чисел с 2 такое число есть в массиве. Во втором варианте при сравнении с 3 возвращается пустой массив, такого числа нет.

Операторы равенства

Операторы равенства (-eq, -ne) возвращают значение TRUE или совпадения, когда одно или несколько входных значений идентичны указанному шаблону. Шаблон должен полностью соответствовать значению.

Рассмотрим несколько простых примеров

20 -eq 20
21 -eq 20
"Проверка" -eq "Проверка"
"Проверка" -eq "Проверка не прошла"
"Test_ne" -ne "Test"

Сравним между собой две даты.

(Get-Date) -eq [datetime]("09.15.2020")
(Get-Date).Date -eq [datetime]("09.15.2020")

Давайте посмотрим на окошко вывода и разберемся что произошло. В первой строке я воспользовался командлетом Get-Date для получения текущей даты и времени. И сравнил его со строкой преобразованной в дату. Однако результат сравнения отрицательный т.е. False. Как видно число полностью совпадает, но, не совпадает время. Поэтому я взял командлет Get-Date и вывел из него только текущую дату (в таком случае время устанавливается в 0). И уже второй строкой результат сравнения положительный.

Давайте посмотрим на следующий пример который наверняка пригодится в хозяйстве. Мы будем искать файлы больше определенного размера.

Get-ChildItem -Path c:\ -Recurse|Where-Object {$_.Length -ge 40000000}

Итак, командлетом Get-ChildItem я хочу вывести список всех файлов и папок на диске C включая подпапки. Далее отправляя по конвееру командлету Where-Object я фильтрую вывод, чтобы показывались только файлы больше или равные (оператор -ge) 40 Мбайт. Как видите очень удобный инструмент получается. Особенно в качестве автоматизации чистки логов.

Операторы сопоставления

Операторы сопоставления (-like и -notlike) находят элементы, которые соответствуют или не соответствуют заданному шаблону, используя подстановочные выражения.

Рассмотрим на примере списка запущенных процессов. Получим список запущенных процессов firefox

Get-Process|Where-Object {$_.ProcessName -like "fire*"}

Командлетом Where-Object я выбрал из списка процессов (при помощи оператора -like) все с названием fire и дальше любые символы (*-любое кол-во символов)

Очень удобная конструкция. Всегда её использую для поиска необходимых процессов.

Операторы соответствия

Операторы соответствия (-match и-notmatch) находят элементы, которые соответствуют или не соответствуют заданному шаблону, используя регулярные выражения.

Оператор сопоставляет строку с помощью регулярных выражений. Если данные на входе являются скалярными, они заполняют автоматическую переменную $Matches. Если входными данными является коллекция, операторы -match и -notmatch возвращают соответствующие члены этой коллекции, но при этом, оператор не заполняет переменную $Matches.

Перейдем к примерам

"Вася","Петя","Маша" -match "маш"
$Matches
"Маша" -match "маш"
$Matches

В случае сравнения с одной строкой -match возвращает логическое значение и заполняет автоматическую переменную $Matches. Автоматическая переменная $Matches — это хэш-таблица. Если группировка или захват не используются, заполняется только один ключ. Клавиша 0 представляет весь текст, который был сопоставлен.

Операторы сдерживания

Операторы сдерживания (-contains и -notcontains) аналогичны операторам равенства. Только операторы сдерживания всегда возвращают логическое значение, даже если входными данными является коллекция.
В отличие от операторов равенства, операторы сдерживания возвращают значение, как только они обнаруживают первое совпадение. Операторы равенства оценивают все входные данные, а затем возвращают все совпадения в коллекции.

Посмотрим на практике

"Вася","Петя","Маша" -contains "маш"
"Вася","Петя","Маша" -contains "маша"

Как видно из примера, в случае не полного совпадения имени результат False. Если имя совпадает результат True.

Оператор -in указывает, появляется ли тестовое значение в коллекции эталонных значений. Всегда возвращает логическое значение. Возвращает TRUE только в том случае, если тестовое значение точно соответствует хотя бы одному из эталонных значений. Когда тестовое значение является коллекцией, оператор -in использует ссылочное равенство. Он возвращает TRUE только в том случае, если одно из опорных значений является тем же экземпляром объекта. Оператор -in был введен в PowerShell 3.0

Примеры

"Лада" -in "УАЗ", "ЛадаКалина"
"Лада" -in "Лада", "ЛадаКалина"

Оператор замены

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

Рассмотрим пример по массовому переименованию файлов *.log в *.bak

Get-ChildItem *.log | Rename-Item -NewName { $_.name -replace '\.log$','.bak' }

И немного простых примеров с текстом

"Привет" -replace "ив",""
"Вася" -ireplace "я", "О"
"Насталя заря коммунизма" -replace "заря","эра"

Мы закончили рассматривать операторы сравнения Powershell. Теперь рассмотрим логические операторы.

Логические операторы Powershell

Оператор	Описание
-and	Оба условия должны быть истины, чтобы выражение было истинно
-or	Одно или оба условия должны быть истины, чтобы выражение было истинно
-xor	Одно условие должно быть истинно, а второе должно иметь значение ложь, чтобы выражение было истинно
-not	Указанные условия должны иметь значение ложь, чтобы выражение было истинно
!	Указанное условие должно иметь значение ложь, чтобы выражение было истинно

Логические операторы PowerShell соединяют выражения и операторы, позволяя использовать одно выражение для проверки нескольких условий.

Снова обратимся к примеру из жизни. Появилась у меня задача найти файлы определенного размера. А именно чтобы они были больше одного числа но меньше другого. Реализуем на Powershell

Get-ChildItem|Where-Object {$_.length -gt 30000 -and $_.Length -lt 40000}

В данном примере мы получили список файлов в папке Windows объемом больше 30 Кбайт но меньше 40 Кбайт.

Мы рассмотрели все операторы сравнения Powershell. Их более чем достаточно для любых задач.

Хотите отблагодарить автора статьи? Это даст ему дополнительный стимул к написанию новых статей.

об операторах сравнения — PowerShell

Статья
23. 01.2023
13 минут на чтение

Краткое описание

Операторы сравнения в PowerShell могут либо сравнивать два значения, либо фильтровать
элементы коллекции против входного значения.

Подробное описание

Операторы сравнения позволяют сравнивать значения или находить совпадающие значения.
заданные узоры. PowerShell включает следующие операторы сравнения:

Равенство

-eq , -ieq , -ceq — равно
-ne , -ine , -cne — не равно
-gt , -igt , -cgt — больше
-ге , -ige , -cge — больше или равно
-lt , -ilt , -clt — менее
-le , -ile , -cle — меньше или равно

Соответствие

-like , -ilike , -clike — строка соответствует подстановочному шаблону
-notlike , -inotlike , -cnotlike — строка не соответствует подстановочному шаблону
-match , -imatch , -cmatch — строка соответствует шаблону регулярного выражения
-notmatch , -inotmatch , -cnotmatch — строка не соответствует шаблону регулярного выражения

Замена

-replace , -ireplace , -creplace — заменяет строки, соответствующие регулярному выражению
шаблон

Защитная оболочка

-содержит , -icontains , -ccontains — коллекция содержит значение
-notcontains , -notcontains , -cnotcontains — коллекция не содержит
содержат значение
-in — значение находится в коллекции
-notin — значение отсутствует в коллекции

Тип

-есть — оба объекта одного типа
- не — объекты не одного типа

Общие функции

При сравнении строк не учитывается регистр, если вы не используете явный
регистрозависимый оператор. Чтобы сделать оператор сравнения чувствительным к регистру, добавьте
c после - . Например, -ceq — это версия -eq с учетом регистра.
Чтобы сделать нечувствительность к регистру явной, добавьте i после - . Например,
-ieq — это явно нечувствительная к регистру версия -eq ..

Когда ввод оператора является скалярным значением, оператор возвращает
Логическое значение . Когда ввод является коллекцией, оператор возвращает
элементы коллекции, соответствующие правому значению выражения.
Если в коллекции нет совпадений, операторы сравнения возвращают пустой
множество. Например:

 $a = (1, 2) -eq 3
$a.GetType().Имя
$a.Count

 Объект[]
0

Есть несколько исключений:

Операторы включения и типа всегда возвращают Булево значение
Оператор -replace возвращает результат замены
Операторы -match и -notmatch также заполняют автоматическое поле $Matches .
переменная, если только левая часть выражения не является коллекцией.

Операторы равенства

-eq и -ne

Когда левая часть является скалярной, -eq возвращает True , если правая часть
сторона является точным совпадением, иначе -eq возвращает False . -ne делает
противоположный; он возвращает False , когда обе стороны совпадают; в противном случае возвращается -ne
Правда .

Пример:

 2 -eq 2 # Вывод: True
2 -eq 3 # Вывод: False
"abc" -eq "abc" # Вывод: True
"abc" -eq "abc", "def" # Вывод: False
"abc" -ne "def" # Вывод: True
"abc" -ne "abc" # Вывод: False
"abc" -ne "abc", "def" # Вывод: True

Если левая часть является коллекцией, -eq возвращает те элементы, которые соответствуют
справа, а -ne отфильтровывает их.

Пример:

 1,2,3 -eq 2 # Вывод: 2
"abc", "def" -eq "abc" # Вывод: abc
"abc", "def" -ne "abc" # Вывод: def

Эти операторы обрабатывают все элементы коллекции. Пример:

 "zzz", "def", "zzz" -eq "zzz"

 ззз
ззз

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

Например, строка '1.0' преобразуется в целое число для сравнения с
значение 1 . Этот пример возвращает True .

 PS> 1 -eq '1.0'
Истинный

В этом примере значение 1 преобразуется в строку для сравнения с
строка '1.0' . В этом примере возвращается False .

 PS> '1.0' -eq 1
ЛОЖЬ

Операторы равенства принимают любые два объекта, а не только скаляр или набор.
Но не гарантируется, что результат сравнения будет значимым для конечного пользователя.
Следующий пример демонстрирует проблему.

 класс MyFileInfoSet {
    [Строка]$Файл
    [Int64]$Размер
}
$a = [MyFileInfoSet]@{File = "C:\Windows\explorer. exe"; Размер = 4651032}
$b = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Размер = 4651032}
$a-экв $b

 Ложь

В этом примере мы создали два объекта с одинаковыми свойствами. Тем не менее,
Результат теста на равенство Ложь , потому что это разные объекты. Создавать
сопоставимых классов, вам необходимо внедрить System.IEquatable в свой
сорт. Следующий пример демонстрирует частичную реализацию
Класс MyFileInfoSet , который реализует System.IEquatable и имеет два
свойства, Файл и Размер . Метод Equals() возвращает True , если
свойства File и Size двух объектов MyFileInfoSet одинаковы.

 класс MyFileInfoSet : System.IEquatable[Object] {
    [Строка]$Файл
    [Int64]$Размер
    [bool] Равно([Объект] $obj) {
        return ($this.File -eq $obj.File) -and ($this.Size -eq $obj.Size)
    }
}
$a = [MyFileInfoSet]@{File = "C:\Windows\explorer. exe"; Размер = 4651032}
$b = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Размер = 4651032}
$a-экв $b

 Правда

Ярким примером сравнения произвольных объектов является определение того, являются ли они
нулевой. Но если вам нужно определить, является ли переменная $null , вы должны поставить
$null в левой части оператора равенства. Положив его на
правая сторона не делает то, что вы ожидаете.

Например, пусть $a будет массивом, содержащим нулевые элементы:

 $a = 1, 2, $null, 4, $null, 6

Следующие тесты, которые $a не равно нулю.

 $null-ne $a

 Правда

Следующее, однако, удаляет все нулевые элементы из $a :

 $a -ne $null # Вывод: 1, 2, 4, 6

-gt, -ge, -lt и -le

-gt , -ge , -lt и -le ведут себя очень похоже. Когда обе стороны
скалярные, они возвращают True или False в зависимости от того, как две стороны
сравнить:

Оператор	Возвращает True, когда. ..
`-gt`	Левая часть больше
`-ге`	Левая часть больше или равна
`-л`	Левая сторона меньше
`-ле`	Левая часть меньше или равна

В следующих примерах все инструкции возвращают Верно .

 8 -gt 6 # Вывод: Истина
8 -ge 8 # Вывод: True
6 -lt 8 # Вывод: Истина
8 -le 8 # Вывод: True

Примечание

В большинстве языков программирования оператором «больше» является > . В
PowerShell этот символ используется для перенаправления. Подробнее см.
about_Redirection.

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

Пример:

 $a=5, 6, 7, 8, 9
Запись-вывод "Тестовая коллекция:"
$а
Write-Output "`nMembers больше 7"
$a-gt 7
Write-Output "`nMembers больше или равно 7"
$a-ge 7
Запись-вывод "`nMembers меньше 7"
$a -lt 7
Write-Output "`nMembers меньше или равно 7"
$а-ле 7

 Тестовая коллекция:
5
6
7
8
9
Члены больше 7
8
9
Члены больше или равны 7
7
8
9
Члены меньше 7
5
6
Члены меньше или равны 7
5
6
7

Эти операторы работают с любым классом, реализующим System. IComparable.

Примеры:

 # Сравнение дат
[DateTime]'2001-11-12' -lt [DateTime]'2020-08-01' # True
# Сравнение порядка сортировки
'a' -lt 'z' # Верно; «а» стоит перед «з»
'macOS' -ilt 'MacOS' # Ложь
'MacOS' -ilt 'macOS' # False
'macOS' -clt 'MacOS' # True; «м» стоит перед «м»

Следующий пример демонстрирует отсутствие символа на американском
QWERTY-клавиатура, которая сортируется после «а». Он питает множество, содержащее все такие
символы оператору -gt , чтобы сравнить их с ‘a’. Результат представляет собой
пустой массив. 9′,’&’,’*’,'(‘,’)’,’_’,’+’,’-‘,’=’,
‘{‘,’}’,'[‘,’]’,’:’,’;’,'»‘,»»,’\’,’|’,’/’,’?’,’ .’,’>’,’,’,’<' $а-gt 'а' # Вывод: ничего

Если две стороны операторов несопоставимы, эти операторы
вызвать непрерывную ошибку.

Операторы сопоставления

Операторы сопоставления ( - как , - не как , - как и - как ) найти
элементы, которые соответствуют или не соответствуют указанному шаблону. Узор на - как
а -notlike является выражением с подстановочными знаками (содержащим * , ? и [ ] ), в то время как
-match и -notmatch принимают регулярное выражение (Regex).

Синтаксис:

  -like 
 -notlike <выражение-шаблона>
 -match 
<строка[]> -notmatch <регулярное-выражение>

Когда ввод этих операторов является скалярным значением, они возвращают Булево значение
ценить. Когда вход представляет собой набор значений, операторы возвращают любое
совпадающие члены. Если совпадений в коллекции нет, операторы возвращают
пустой массив.

-подобно и -не похоже

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

Пример:

 "PowerShell" - как "*shell" # Вывод: True
"PowerShell" - не похоже на "*shell" # Вывод: False
"PowerShell" - как "Power?hell" # Вывод: True
"PowerShell" - не похоже на "Power?hell" # Вывод: False
"PowerShell" - как "Power[p-w]hell" # Вывод: True
"PowerShell" - не похоже на "Power[p-w]hell" # Вывод: False
"PowerShell", "Server" - как "*shell" # Вывод: PowerShell
"PowerShell", "Server" - notlike "*shell" # Вывод: Server

-match и -notmatch

-match и -notmatch использовать регулярные выражения для поиска шаблона в
левые значения. Power\w+’ # Вывод: True
‘bag’ -notmatch ‘b[iou]g’ # Вывод: True
9Мощность\w+’
# Вывод: PowerShell
«Релл», «Челл», «Мел», «Запах», «Панцирь» — соответствуют «аду»
# Результат: Релл, Челл, Шелл
«Мешок», «Бег», «Большой», «Болото», «Жук» — соответствует ‘b[iou]g’
#Вывод: Большой, Болото, Жук
«Мешок», «Бег», «Большой», «Болото», «Жук» — не соответствует ‘b[iou]g’
#Вывод: Мешок, попрошайничество

-match и -notmatch поддерживают группы захвата регулярных выражений. Каждый раз, когда они запускаются
скалярный ввод, а результат -match равен True , или результат -notmatch равен
Ложь , они перезаписывают автоматическую переменную $Matches . $Соответствует
Хэш-таблица , в которой всегда есть ключ с именем «0», в котором хранится все совпадение.
Если регулярное выражение содержит группы захвата, $Matches содержит
дополнительные ключи для каждой группы.

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

Пример:

 $string = 'Последним зарегистрированным пользователем был CONTOSO\jsmith'
$string -match 'было (?<домен>.+)\\(?<пользователь>.+)'
$ Совпадения
Запись-вывод "`nDomain name:"
$Matches.domain
Запись-вывод "имя nUser:"
$Matches.user

 Правда
Имя Значение
---- -----
домен CONTOSO
пользователь jsmith
0 был CONTOSO\jsmith
Доменное имя:
КОНТОСО
Имя пользователя:
Джейсмит

Если результат -match равен False , или результат -notmatch равен True ,
или когда вход представляет собой коллекцию, автоматическая переменная $Matches не является
перезаписано. Следовательно, он будет содержать установленное ранее значение, или $нуль
если переменная не была установлена. При ссылке на $Matches после вызова одного
из этих операторов, рассмотрите возможность проверки того, что переменная была установлена текущим
вызов оператора с использованием оператора условия.

Пример:

 if ("1.0.0" -match '(.*?)') {
    $ Совпадения
}

Подробнее см. about_Regular_Expressions и
about_Automatic_Variables.

Сменный привод

Замена регулярными выражениями

Подобно -match , оператор -replace использует регулярные выражения для поиска
указанный узор. Но в отличие от -match заменяет спички на другую
указанное значение.

Синтаксис:

  -replace ,

Оператор заменяет все или часть значения указанным значением, используя
обычные выражения. Вы можете использовать оператора для многих административных задач,
например, переименование файлов. Например, следующая команда изменяет файл
расширения имен всех .txt файлов в .log :

 Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' }

По умолчанию оператор -replace нечувствителен к регистру. Чтобы сделать это дело
чувствительный, используйте -замените . Чтобы сделать его явно нечувствительным к регистру, используйте
- заменить .

Примеры:

 "книга" - заменяет "B", "C" # Нечувствителен к регистру
"book" -заменить "B", "C" # С учетом регистра; значит нечем заменить

 Повар
книга

Начиная с PowerShell 7.2, когда левый операнд в - заменить
оператор оператора не является строкой, этот операнд преобразуется в строку.
PowerShell выполняет преобразование строк без учета языка и региональных параметров.

Например, если в качестве языка и региональных параметров выбран французский (fr),
преобразование строки значения 1.2 в 1,2 .

До PowerShell 7.2:

 PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 - заменить ','
12

В PowerShell 7.2 и более поздних версиях:

 PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 - заменить ','
1,2

Замена регулярных выражений

Регулярные выражения также можно использовать для динамической замены текста с помощью
группы захвата и замены. На группы захвата можно ссылаться в
строка со знаком доллара ( $ ) перед группой
идентификатор.

В следующем примере 9(?<ИмяДомена>[\w-.]+)\\(?<ИмяПользователя>[\w-.]+)$’
$ReplaceExp = ‘${имя пользователя}@${имя_домена}’
«Contoso.local\John.Doe» — заменить $SearchExp, $ReplaceExp

 [email protected]

Предупреждение

Символ $ имеет синтаксические роли как в PowerShell, так и в обычном
выражения:

В PowerShell между двойными кавычками обозначает переменные и
действует как оператор подвыражения.
В строках поиска Regex обозначает конец строки.
В строках подстановки Regex обозначает захваченные группы. Быть уверенным
чтобы либо поместить ваши регулярные выражения между одинарными кавычками, либо
вставьте перед ними символ обратной кавычки ( ` ).

Например:

 $1 = «До свидания»
'Hello World' - заменить '(\w+) \w+', "Вселенная $1"
# Вывод: Прощай, Вселенная
'Hello World' - заменить '(\w+) \w+', 'Вселенная $1'
# Вывод: Привет Вселенная

$$ в регулярном выражении означает литерал $ . это $$ в строке замены на
включить в полученную замену буквальные $. Например:

 '5.72' -заменить '(.+)', '$ $1' # Вывод: $ 5.72
'5.72' - заменить '(.+)', '$$$1' # Вывод: $5.72
'5.72' -заменить '(.+)', '$$1' # Вывод: $1

Чтобы узнать больше, см. about_Regular_Expressions и
Подстановки в регулярных выражениях.

Замена в коллекции

Когда оператор для -replace является коллекцией, PowerShell
применяет замену к каждому значению в коллекции. Например:

 «В1», «В2», «В3», «В4», «В5» - заменить «В», «а»
а1
а2
а3
а4
а5

Замена блоком сценария

В PowerShell 6 и более поздних версиях оператор -replace также принимает блок сценария
который выполняет замену. Блок сценария запускается один раз для каждого матча.

Синтаксис:

  -replace , {}

В блоке сценария используйте автоматическую переменную $_ для доступа к вводу
заменяемый текст и другая полезная информация. Тип класса этой переменной
Система.Текст.РегулярныеВыражения.Соответствие.

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

 "072101108108111" - заменить "\d{3}", {return [char][int]$_.Value}

 Привет

Операторы защитной оболочки

Операторы защитной оболочки ( — содержит , — не содержит , — в и — не в )
аналогичны операторам равенства, за исключением того, что они всегда возвращают
Логическое значение , даже если ввод представляет собой коллекцию. Эти операторы останавливаются
сравнивая, как только обнаруживают первое совпадение, тогда как равенство
операторы оценивают все элементы ввода. В очень большой коллекции эти
операторы возвращают значение быстрее, чем операторы равенства.

Синтаксис:

 <Коллекция> -содержит <тестовый объект>
<Коллекция> -notcontains <Тест-объект>
<Тест-объект> -в <Коллекции>
<Тест-объект> -notin <Коллекция>

-содержит и -не содержит

Эти операторы сообщают, включает ли набор определенный элемент. - содержит
возвращает True , когда правая часть (тестовый объект) соответствует одному из
элементы в наборе. -notcontains вместо этого возвращает False. Когда тестовый объект
является коллекцией, эти операторы используют ссылочное равенство, т.е. они проверяют
является ли один из элементов набора одним и тем же экземпляром тестового объекта.

Примеры:

 "abc", "def" - содержит "def" # Вывод: True
"abc", "def" -notcontains "def" # Вывод: False
«Windows», «PowerShell» — содержит «Shell» # Вывод: False
"Windows", "PowerShell" - не содержит "Shell" # Вывод: True
"abc", "def", "ghi" - содержит "abc", "def" # Вывод: False
"abc", "def", "ghi" -notcontains "abc", "def" # Вывод: True

Более сложные примеры:

 $DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
                 "ContosoDHCP", "ContosoWSUS"
$thisComputer = "ContosoDC2"
$DomainServers — содержит $thisComputer
# Вывод: Истина
$а = "абв", "защита"
"abc", "def", "ghi" - содержит $a # Вывод: False
$a, "ghi" - содержит $a # Вывод: True

-in и -notin

Операторы -in и -notin были представлены в PowerShell 3 как
синтаксическая инверсия числа - содержит и - не содержит операторов. -в
возвращает True , когда левая часть соответствует одному из
элементы в наборе. -notin вместо этого возвращает False . Когда тестовый объект
является набором, эти операторы используют ссылочное равенство, чтобы проверить, является ли один из
элементы набора — это тот же экземпляр тестового объекта.

Следующие примеры делают то же самое, что и примеры для - содержат и
— не содержит do, но они записываются с — в и — не в вместо этого.

 "def" -in "abc", "def" # Вывод: True
"def" -notin "abc", "def" # Вывод: False
«Shell» — в «Windows», «PowerShell» # Вывод: False
«Shell» — не в «Windows», «PowerShell» # Вывод: True
"abc", "def" -in "abc", "def", "ghi" # Вывод: False
"abc", "def" -notin "abc", "def", "ghi" # Вывод: True

Более сложные примеры:

 $DomainServers = "ContosoDC1", "ContosoDC2", "ContosoFileServer", "ContosoDNS",
                 "ContosoDHCP", "ContosoWSUS"
$thisComputer = "ContosoDC2"
$thisComputer — в $DomainServers
# Вывод: Истина
$а = "абв", "защита"
$a -in "abc", "def", "ghi" # Вывод: False
$a -in $a, "ghi" # Вывод: True

Сравнение типов

Операторы сравнения типов ( - is и - is not ) используются для определения того,
объект относится к определенному типу.

Синтаксис:

 <объект> -is <ссылка на тип>
<объект> - не <ссылка на тип>

Пример:

 $a = 1
$б = "1"
$a -is [int] # Вывод: True
$a -is $b.GetType() # Вывод: False
$b -isnot [int] # Вывод: True
$a -isnot $b.GetType() # Вывод: True

См. также

about_Booleans
about_Operators
about_Regular_Expressions
about_Wildcards
Объект сравнения
Foreach-Object
Где-Объект

Операторы сравнения — PowerShell — SS64.com

SS64
PowerShell
Практическое руководство

Следующие операторы по умолчанию нечувствительны к регистру:

 -экв равно
 -ne Не равно
 -ge Больше или равно
 -gt Больше, чем
 -lt Меньше чем
 -le Меньше или равно
 -как сравнение с подстановочными знаками
 - не похоже на сравнение с подстановочными знаками
 -match Сравнение регулярных выражений
 -notmatch Сравнение регулярных выражений
 -replace Заменить оператор
 -содержит оператор сдерживания
 -notcontains Оператор сдерживания
 -in Like – содержит, но с обратными операндами (PowerShell 3. 0).
 -notin Аналогично –notcontains, но с обратными операндами (PowerShell 3.0)

Чтобы выполнить сравнение с учетом регистра, просто добавьте к любому из приведенных выше слов префикс «c»
например, -ceq для чувствительного к регистру равенства или -creplace для чувствительного к регистру замены.

Аналогичным образом префикс «i» явно сделает оператор нечувствительным к регистру.
Кажется вероятным, что эти короткие имена, такие как -eq, были выбраны для операторов вместо символов (= / <> и т. д.), чтобы разрешить эти чувствительные к регистру параметры.

 Типы
 -is Типа
 -isnot Не относится к типу
 -as Как тип, без ошибок при сбое преобразования

Логические операторы
 -и логическое И
 -или Логическое ИЛИ
 -xor Логическое исключающее ИЛИ
 -не логично нет
  ! логическое не

Побитовые операторы
 -band Побитовое и
 -bor Побитовое или
 -bXor Побитовое ИЛИ (эксклюзивное)
 -bНе побитовое НЕ
 -shl Сдвинуть биты влево (PowerShell 3. 0)
 -shr Сдвинуть биты вправо — сохраняет знак для значений со знаком. (PowerShell 3.0)
 
Оператор формата
  format_string  "  -f   Объект1  ,  Объект2  ,...

Форматная_строка имеет вид: {0,-5} {1,-20} {2,-10}
В каждом наборе фигурных скобок первое число перед запятой
относится к столбцу.
Второе число после запятой определяет отступ (сколько символов)
Если второе число отрицательное, оно не только дополняет элемент, но и выравнивает его по вертикали. Опционально можно использовать второе число для форматирования :hh :mm :C :p

При применении к массиву операторы сравнения будут работать как фильтр, возвращающий все совпадающие значения.

Фильтр PowerShell будет принимать следующие операторы
-экв
-ne
-ge
-ГТ
-lt
-ле
-как
-не как
-ок
-бор
-группа
-рекурсивный матч

Обратите внимание, что в этом списке отсутствуют несколько полезных операторов, таких как -match и -contains, но их все же можно использовать путем передачи в предложение Where-Object:
.

об операторах сравнения — PowerShell

Краткое описание

Подробное описание

Общие возможности

Операторы равенства

-eq и -ne

-gt, -ge, -lt и -le

Операторы сопоставления

-like и -notlike

-match и -notmatch

Оператор замены

Замена регулярными выражениями

Подстановки регулярных выражений

Подстановка в коллекции

Замена блоком скрипта

Операторы вложения

-contains и -notcontains

-in и -notin

Сравнение типов

См. также раздел

Операторы сравнения Powershell — Системный Администратор

Операторы сравнения

Операторы равенства

Операторы сопоставления

Операторы соответствия

Операторы сдерживания

Оператор замены

Логические операторы Powershell

Рекомендую к прочтению:

Хотите отблагодарить автора статьи? Это даст ему дополнительный стимул к написанию новых статей.

об операторах сравнения — PowerShell

Краткое описание

Подробное описание

Общие функции

Операторы равенства

-eq и -ne

-gt, -ge, -lt и -le

Операторы сопоставления

-подобно и -не похоже

-match и -notmatch

Сменный привод

Замена регулярными выражениями

Замена регулярных выражений

Замена в коллекции

Замена блоком сценария

Операторы защитной оболочки

-содержит и -не содержит

-in и -notin

Сравнение типов

См. также

Операторы сравнения — PowerShell — SS64.com