Разное

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

04.06.1971

Содержание

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

  • Чтение занимает 11 мин

В этой статье

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

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

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

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

Тип Оператор Тест сравнения
Равенство -eq equals
-ne не равно
-gt больше чем
-ge больше или равно
-lt меньше чем
-le меньше или равно
Matching -like строка соответствует шаблону шаблона
-notlike строка не соответствует шаблону шаблона
-match строка соответствует шаблону регулярного выражения
-notmatch строка не соответствует шаблону регулярного выражения
Замена -Replace заменяет строки, соответствующие шаблону регулярного выражения
Containment -contains Коллекция содержит значение
-notcontains Коллекция не содержит значение
-in значение находится в коллекции
-notin значение не находится в коллекции
Тип — имеет Оба объекта имеют одинаковый тип
-IsNot объекты имеют разные типы

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

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

-eq .

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

$a = (1, 2 -eq 3)
$a.GetType().Name
$a.Count
Object[]
0

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

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

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

-eq и -ne

Если левая часть является скалярной, -eq возвращает значение true , если правая часть является точным совпадением, в противном случае -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

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

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> в своем классе. В следующем примере демонстрируется частичная реализация класса

мифилеинфосет , который реализует System. IEquatable <T> и имеет два свойства: File и size. Equals()Метод возвращает значение true , если свойства File и size двух объектов мифилеинфосет одинаковы.

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
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. IComparable.

Примеры:

# Date comparison
[DateTime]'2001-11-12' -lt [DateTime]'2020-08-01' # True

# Sorting order comparison
'a' -lt 'z'           # True; 'a' comes before 'z'
'macOS' -ilt 'MacOS'  # False
'MacOS' -ilt 'macOS'  # False
'macOS' -clt 'MacOS'  # True; 'm' comes before 'M'

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

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

Соответствующие операторы

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

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

Синтаксис выглядит следующим образом.

<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 используют регулярные выражения для поиска шаблона в левой части значений.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 или -notmatch результат имеет значение false, они перезаписывают $Matches автоматическую переменную. $Matches — Это хэш-таблица , которая всегда содержит ключ с именем «0», в котором сохраняется все совпадение. Если регулярное выражение содержит группы захвата, $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 оператор не учитывает регистр.(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$’ $ReplaceExp = ‘${Username}@${DomainName}’ ‘Contoso.local\John.Doe’ -replace $SearchExp,$ReplaceExp

[email protected]

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

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

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

Например:

$1 = 'Goodbye'

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

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

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

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

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

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

Если <input> -replace оператор to является коллекцией, 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. Если объект теста является коллекцией, эти операторы используют равенство ссылок, т. е. они проверяют, является ли один из элементов набора одним и тем же экземпляром тестового объекта.

Примеры:

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

Следующие примеры выполняют те же действия, что и примеры для -contains и -notcontains Do, но они записываются с помощью -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

СМ. ТАКЖЕ

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

С помощью операторов сравнения в powershell мы можем выяснить содержит ли значение какую-то строку, равно, больше или меньше какого-то значения и т.д. Обычно мы привыкли использовать <, >, !=, = и другие символы, но в powershell все работает иначе. 

У нас есть такие операторы в powershell:

Операторы возвращают True, если утверждение верно и False, если нет

 

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

На примере сравнения дат:


(Get-Date).Day -eq 8

Вернет True, т.к. сегодня 8-ой день месяца и оба значения равны. Даты, за исключением дня месяца, должны быть в специальном формате datetime.

Или иначе:


(Get-Date) -eq ((Get-Date).AddDays(-15))

Вернет False т.к. слева сегодняшняя дата с права 15 дней до.

Так мы можем найти файлы, которые были 7 дней назад:


Get-ChildItem | where {$_.CreationTime -eq ((Get-Date).AddDays(-7))}

 

Оператор сравнения Powershell LT и LE

Опять же сравним даты powershell:


$today = Get-Date
$next_week = Get-Date -Day 15 -Year 2019 -Month 7
$today -lt $next_week

Вернет False т.к. дата справа меньше чем слева.


$last_year = Get-Date -Year 2018
$today_year = (Get-Date).Year
$last_year.Year -lt $today_year

Вернет True.

Оператор LE в отличие от LT вернет True так же, если значение равно:


2018 -le 2018

Так мы найдем файлы, которые были созданы менее чем 7 дней назад или созданные в 18 день месяца:


Get-ChildItem | where {$_.CreationTime -le ((Get-Date).AddDays(-7)) -or ($_.CreationTime).Day -eq 18 }

 

Оператор сравнения Powershell GT и GE

Работает аналогично:


1 -GT 2

Вернет False т.к. 1 не больше 2


1 -GE 1

Вернут True т.к. мы проверяем еще и равенство.


"Four".length -GE 4

Тоже вернет True т.к. длина строки Four 4.

На примере поиска процессов:


Get-Process | where {$_.Processname -eq "svchost" -and $_.CPU -gt 5}

Т.е. мы ищем процессы, где имя равно svchost и значение CPU больше 5.

 

Оператор сравнения Powershell Like и Match

Like от Match отличается в тем, что в Like мы ищем строчки используя Wildcardr *, а в Match мы можем использовать регулярные выражения:


"fixmypc" -like "*fix*"

Вернет True, т.к. * говорит что слева и справа может находиться еще символы.

Если добавить букву c, получится -clike, что значит Case-Sensetive (чувствителен к регистру). В этом случае буква А и а будут разными. По умолчанию, в windows регистр не имеет значение:


"Fixmypc" -clike "fix"

Так мы уберем из вывода все процессы, которые не содержат sv в начале и t в конце строки:


Get-Process | where {$_.Name -notlike "sv*t"}

В этом случае вернется True:


"TestWord" -match "estW"

А в этом только строковые значения:


"Один", 1 ,"два", 2, "три", 3 -match "[А-я]"

В этом только значения, где есть числа от 2 до 9:


"Один1", 1, "два2", 2, "три3", 3 -match "[2-9]"

Теги: #powershell

Почему равно » — eq «в PowerShell, а не просто»=»?



Конструкции -ne, -eq и -gt выглядят по меньшей мере странно.

if ($true -eq $true){}

но не

if ($true = $true){}

Каково же объяснение?

powershell syntax
Поделиться Источник Mike Chaliy     23 апреля 2012 в 23:59

3 ответа


  • Почему ‘true’ равно $true

    Я не совсем уверен, является ли этот точный вопрос дубликатом, но я не смог найти свой конкретный вопрос в stackoverflow, так что, думаю, это не так. $true -это логический тип: ($true).getType() IsPublic IsSerial Name BaseType ——— ——— —- ——— True True Boolean System.ValueType…

  • Почему этот маленький фрагмент PowerShell не возвращает false?

    как раз в тот момент, когда я думал, что знаю PowerShell, мне стало интересно, что здесь происходит. Compare-Object работает для обоих этих примеров, и второй пример вернет различия, если я не проверю $null,, но у меня самое плохое время для простого сравнения. Почему второй пример не возвращает…



38

В основном ответ заключается в том, что именно так Unix сделал это навсегда. Конечно, если вы напишете несколько сценариев Bash, это то, что вы будете использовать, и на самом деле приятно, когда ваши знания синтаксиса PowerShell передаются один за другим в Bash.

На него подробно дан ответ в книге Брюса Пайетта Windows PowerShell in Action , Второе издание (Kindle Location 3391).

Давайте поговорим о самом спорном дизайнерском решении в мире. PowerShell язык.

И победитель: почему, черт возьми, мы не использовали обычные символы для сравнения, такие как >, >=, <, <=, ==, и !=?

Ответ заключается в том, что символы > и < используются для перенаправления вывода. Потому что PowerShell-это shell, и все shell языка за последние 30 лет использовали > и < для перенаправления ввода-вывода, люди ожидали, что PowerShell должен делать то же самое. Во время первой публичной бета-версии PowerShell эта тема вызвала дискуссии, которые продолжались в течение нескольких месяцев.

Мы посмотрели на разнообразие альтернатив, таких как модальный синтаксический анализ, где иногда > означало больше, чем, а иногда это означало перенаправление. Мы рассмотрели альтернативные последовательности символов для таких операторов, как :> или ->, либо для перенаправления, либо для сравнения. Мы провели юзабилити-тесты, провели фокус-группы и в конце концов остановились на том, с чего начали.

Операторами перенаправления являются > и <,, а операторы сравнения взяты из команды Unix test(1). Мы ожидаем этого, потому что эти операторы имеют 30-летнюю родословную, они адекватны и подходят для использования в PowerShell. (Мы также ожидаем, что люди будут продолжать жаловаться на это решение, хотя, надеюсь, не в течение еще 30 лет.)

Поделиться Andy Arismendi     24 апреля 2012 в 00:43



7

Потому что > и < являются операторами перенаправления потока в большинстве оболочек. Ну, за исключением того, что PowerShell не поддерживает перенаправление ввода потока. Кроме того, было бы сложнее проанализировать/интерпретировать > в некоторых случаях, чтобы перенаправить stdout, а в других случаях greater than . Кроме того, используя подход -<operator_name> , вы можете иметь гораздо больше операторов, чем интуитивно понятных символов, например-содержит,- не содержит,- есть,- заменить,- разделить,- сопоставить и т. Д. Выполните man about_operators в качестве отправной точки для explorer всех операторов, поддерживаемых PowerShell.

Поделиться Keith Hill     24 апреля 2012 в 00:05



2

Оператор = уже является оператором присваивания. Чтобы не путать сравнение и оператор присваивания, они выбирают для другого оператора. В данном случае для-eq, потому что это уже используется в других (UNIX) языках сценариев.

Поделиться Conrad     30 июля 2014 в 08:26


  • Поведение PowerShell — eq vs compare-object

    Почему Compare-Object работает так, как ожидалось, где -EQ не может точно сравнить массивы строк? У меня был скрипт PowerShell, который заполнял массив строк и использовал оператор -EQ для проверки ожидаемых значений — это всегда было неудачно — я думаю, что следующий код иллюстрирует эти проблемы…

  • Почему команда работает в Windows CMD, а не в PowerShell?

    У меня есть скрипт, который сохраняет исполняемый файл и .ps1 в список удаленных компьютеров. Затем он запускает исполняемый файл на каждом компьютере. Я должен вызвать исполняемый файл с .ps1 из-за того, как он настроен при бесшумном запуске. Я заметил, что одна из моих команд быстро запускается…


Похожие вопросы:


Почему ‘$true-eq «string» ‘ возвращает $true?

В powerShell вы сравниваете логическое значение со строкой с помощью оператора- eq, он всегда будет возвращать то же самое логическое значение, которое я использовал для сравнения. E.g….


Сравнение свойств в powershell

Я использую powershell для импорта файла csv, содержащего информацию о книгах. Например: название, idnum, автор и т. д… Я пытаюсь сравнить каждое свойство, чтобы увидеть, равно ли оно или null….


PowerShell многомерная логика сбора данных для-eq

Благодаря логике PowerShell я знаком с некоторыми тонкостями работы -eq , когда левый операнд является коллекцией-вместо логического значения -eq вернет массив элементов, равных правому операнду. Из…


Почему ‘true’ равно $true

Я не совсем уверен, является ли этот точный вопрос дубликатом, но я не смог найти свой конкретный вопрос в stackoverflow, так что, думаю, это не так. $true -это логический тип: ($true).getType()…


Почему этот маленький фрагмент PowerShell не возвращает false?

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


Поведение PowerShell — eq vs compare-object

Почему Compare-Object работает так, как ожидалось, где -EQ не может точно сравнить массивы строк? У меня был скрипт PowerShell, который заполнял массив строк и использовал оператор -EQ для проверки…


Почему команда работает в Windows CMD, а не в PowerShell?

У меня есть скрипт, который сохраняет исполняемый файл и .ps1 в список удаленных компьютеров. Затем он запускает исполняемый файл на каждом компьютере. Я должен вызвать исполняемый файл с .ps1 из-за…


Содержит ли PowerShell Substiture-eq for-contains при сравнении строки и массива

Сравнивая строку с массивом в PowerShell сегодня, я по ошибке использовал -eq, а не-contains, но все равно получил ожидаемый результат. Пример Кода: $arr = Fred,Bob if($arr -eq Bob) { Return $true }…


Почему PowerShell не может соответствовать $env:image в AppVeyor?

Я пытаюсь интегрировать CMake сборок в AppVeyor. Наш проект основан на Visual Studio для Windows, но мы стараемся поддерживать CMake для пользователей, которые предпочитают его. Наш сценарий…


Powershell скрипт просто возвращается без вывода журнала

PSA: в первый раз, когда я использую PowerShell, мой go-to-это Bash или Python, извините, если это выглядит странно. Я создал сценарий Powershell, который, если наш сервер Windows 2019…

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

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

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

Операторы сравнения
ОператорЗначениеОписание
-eqEqualРавно
-neNot equalНе равно
-gtGreater thanБольше
-geGreater than or equalБольше или равно
-ltLess thanМеньше
-leLess than or equalМеньше или равно
-likeWildcard comparisonИспользуется подстановка символов для поиска по шаблону
-notlikeWildcard comparisonИспользуется подстановка символов для поиска не соответствия указанному шаблону
-matchRegular expression comparisonИспользование регулярных выражений для поиска по шаблону
-notmatchRegular expression comparisonИспользование регулярных выражений для поиска не соответствия указанному шаблону
-containsContainment operatorОпределяет, содержит ли значение слева от оператора значение справа
-notcontainsContainment operatorОпределяет, что значение слева от оператора не содержит значение оператора справа
-inContainment operatorВозвращает true если искомое значение содержится в коллекции
-notinContainment operatorВозвращает true если искомое значение не содержится в коллекции
-replaceReplace operatorЗаменяет часть или все значение слева от оператора
-isTypeВозвращает true если оба объекта одинаковы
-isnotTypeВозвращает 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 — Операторы сравнения » Pechenek.NET

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

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

Equal / -eq

Начнем с самого известного и часто встречающегося. Оператор equal. Он проводит сравнение сравнение двух выражений и определяет равны ли они. Давайте попробуем использовать его самым простым способом:

Здесь все просто. Equal в своей сущности эквивалентен оператору = в других языках программирования. Рассмотрим более сложный пример и попробуем сравнить строки:

$a = «123» $b = 123 $a -eq $b True

$a = «123»

$b = 123

$a -eq $b

True

Здесь сложнее, казалось бы, переменные имеют разный тип с одинаковым значением. Разве не должно ли вернуться false? Нет, потому что equal ищет совпадения, а не проверяет тип данных. Оператором equal можно пользоваться в циклах. Например:

if ($a -eq $b) { «переменные равны» } else { «переменные неравны» } переменные равны

if ($a -eq $b) {

   «переменные равны»

} else {

   «переменные неравны»

}

переменные равны

В такой ситуации проверяется условие находящееся в скобках. Так как переменные по значениям не отличаются возвращается True и выполняется первый блок кода.

Not equal / -ne

Здесь все работает с точностью, да наоборот. Если переменные не равны, возвращается true, если равны возвращается false. Пример:

Думаю понятно. Применение такое же – любые логические сравнения. Перейдем к следующему оператору.

Greater than or equal / -ge

Этот оператор вычисляет равно или больше левое выражение правому. Здесь важно понимать логику. Если выражение слева равно правому, возвращается True. Если выражение слева больше, возвращает тоже True. Тоже самое работает и в обратную сторону. То есть если выражение слева, меньше возвращается false. Например:

if (3 -ge 2) { «выражение слева больше или равно» } else { «выражение слева меньше» } выражение слева больше или равно if (2 -ge 2) { «выражение слева больше или равно» } else { «выражение слева меньше» } выражение слева больше или равно if (2 -ge 3) { «выражение слева больше или равно» } else { «выражение слева меньше» } выражение слева меньше

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

if (3 -ge 2) {

«выражение слева больше или равно»

} else {

«выражение слева меньше»

}

выражение слева больше или равно

 

if (2 -ge 2) {

«выражение слева больше или равно»

} else {

«выражение слева меньше»

}

выражение слева больше или равно

 

if (2 -ge 3) {

«выражение слева больше или равно»

} else {

«выражение слева меньше»

}

выражение слева меньше

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

Greater Than / -gt

Этот оператор вычисляет больше ли левое выражение, чем правое или нет. Эквивалентен оператору > в других языках программирования. Что интересно, если попробовать выяснить одинаковые ли значения по обе стороны от оператора, то вернется false. Этот оператор не сравнивает, а выясняет больше или нет. Пример:

if (3 -gt 2) { «выражение слева больше» } else { «выражение слева меньше» } выражение слева больше if (3 -gt 4) { «выражение слева больше» } else { «выражение слева меньше» } выражение слева меньше if (3 -gt 3) { «выражение слева больше» } else { «выражение слева меньше» } выражение слева меньше

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

if (3 -gt 2) {

«выражение слева больше»

} else {

«выражение слева меньше»

}

выражение слева больше

 

if (3 -gt 4) {

«выражение слева больше»

} else {

«выражение слева меньше»

}

выражение слева меньше

 

if (3 -gt 3) {

«выражение слева больше»

} else {

«выражение слева меньше»

}

выражение слева меньше

Less Than / -lt

Противоположность Greater Than. Выясняет меньше ли левое значение, чем правое. Возвращает True, если левое выражение меньше, и false, если левое выражение больше. Например:

1 -lt 2 True 3 -lt 2 False

1 -lt 2

True

 

3 -lt 2

False

Less than or equal / -le

Меньше или равно. Противоположность оператору Greater than or equal. Возвращает значение True, если левое выражение меньше или равно, чем правое. Возвращает false, если левое выражение больше, чем правое. Пример:

3 -le 2 False 1 -le 2 True 2 -le 2 True

3 -le 2

False

 

1 -le 2

True

 

2 -le 2

True

Все это были простые логические операторы. Теперь перейдем к более сложным.

Wildcard comparison / -like

Допустим у вас есть выборка сервисов, из которых вам нужен только единственный. Из его названия вы знаете только часть. В таком случае на помощь приходит оператор -like. В той же статье, про оператор Where мы использовали его. Like ищет соответствия в исходной строке, и выводит все, которые полностью или частично подходят:

get-service | Where Name -like «search»

get-service | Where Name -like «search»

Обратите внимание, сейчас вывода никакого не последовало. В такой конструкции like будет искать исключительно точные совпадения. Чтобы найти все неточные, нужно поставить звездочки вокруг целевого имени:

get-service | Where Name -like «*search*» Status Name DisplayName —— —- ———— Running WSearch Windows Search

get-service | Where Name -like «*search*»

 

Status   Name               DisplayName

——   —-               ————

Running  WSearch            Windows Search

Еще пример:

ls | Where Name -like «D*» Каталог: C:\Users\Дом Mode LastWriteTime Length Name —- ————- —— —- d-r— 29.01.2020 19:51 Desktop d-r— 18.01.2020 20:38 Documents d-r— 27.01.2020 19:15 Downloads

ls | Where Name -like «D*»

 

    Каталог: C:\Users\Дом

 

 

Mode                LastWriteTime         Length Name

—-                ————-         —— —-

d-r—       29.01.2020     19:51                Desktop

d-r—       18.01.2020     20:38                Documents

d-r—       27.01.2020     19:15                Downloads

Обратный Wildcard comparison / -notlike

Этот оператор работает наоборот. Ищет все несовпадения. Допустим нам нужны файлы где нет буквы D:

ls | Where Name -notlike «*D*» Каталог: C:\Users\Дом Mode LastWriteTime Length Name —- ————- —— —- d—— 26.08.2019 21:04 .config d—— 26.08.2019 21:38 .nuget d—— 18.01.2020 20:39 .oracle_jre_usage d—— 26.08.2019 18:58 .templateengine d—— 26.08.2019 18:56 .vsts d—— 26.08.2019 20:02 .WebStorm2019.1 d—— 30.11.2019 20:10 ansel d-r— 17.11.2019 11:30 Contacts d-r— 17.11.2019 11:30 Favorites d-r— 17.11.2019 11:30 Links d-r— 17.11.2019 11:30 Music d-r— 17.11.2019 11:30 Pictures d-r— 17.11.2019 11:30 Searches d—— 26.08.2019 21:09 WebstormProjects -a—- 24.09.2019 21:24 121 .yarnrc -a—- 26.08.2019 21:08 90 yarn.lock

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

ls | Where Name -notlike «*D*»

 

    Каталог: C:\Users\Дом

 

Mode                LastWriteTime         Length Name

—-                ————-         —— —-

d——       26.08.2019     21:04                .config

d——       26.08.2019     21:38                .nuget

d——       18.01.2020     20:39                .oracle_jre_usage

d——       26.08.2019     18:58                .templateengine

d——       26.08.2019     18:56                .vsts

d——       26.08.2019     20:02                .WebStorm2019.1

d——       30.11.2019     20:10                ansel

d-r—       17.11.2019     11:30                Contacts

d-r—       17.11.2019     11:30                Favorites

d-r—       17.11.2019     11:30                Links

d-r—       17.11.2019     11:30                Music

d-r—       17.11.2019     11:30                Pictures

d-r—       17.11.2019     11:30                Searches

d——       26.08.2019     21:09                WebstormProjects

-a—-       24.09.2019     21:24            121 .yarnrc

-a—-       26.08.2019     21:08             90 yarn.lock

Получаем соответствующий вывод.

Regular expression comparison / -match

Оператор match может быть использован по-разному. Например так:

«powershell» <strong>-match</strong> «power» True «powershell» <strong>-match</strong> «powerstring» False

«powershell» <strong>-match</strong> «power»

True

 

«powershell» <strong>-match</strong> «powerstring»

False

Или вот так:

$WMI = Get-WmiObject -List | Where-Object {$_.name <strong>-Match</strong> «network»} $WMI NameSpace: ROOT\cimv2 Name Methods Properties —- ——- ———- Win32_NetworkLoginProfile {} {AccountExpires, AuthorizationFlags, BadPasswordCount, Capt… Win32_NetworkAdapterConfiguration {EnableDHCP, Rene… {ArpAlwaysSourceRoute, ArpUseEtherSNAP, Caption, DatabasePa… Win32_NetworkAdapterSetting {} {Element, Setting}

$WMI = Get-WmiObject -List | Where-Object {$_.name <strong>-Match</strong> «network»}

$WMI

NameSpace: ROOT\cimv2

 

Name                                Methods              Properties

—-                                ——-              ———-

Win32_NetworkLoginProfile           {}                   {AccountExpires, AuthorizationFlags, BadPasswordCount, Capt…

Win32_NetworkAdapterConfiguration   {EnableDHCP, Rene… {ArpAlwaysSourceRoute, ArpUseEtherSNAP, Caption, DatabasePa…

Win32_NetworkAdapterSetting         {}                   {Element, Setting}

Обратный Regular expression comparison / -notmatch

Оператор -notmatch делает все наоборот, если совпадений выводится True и False, если совпадения есть. Пример:

«powershell» -notmatch «powerstring» True

«powershell» -notmatch «powerstring»

True

Есть еще операторы -replace, -contains и -not-contains. Но их мы рассмотрим позднее.

Так же есть операторы проверяющие принадлежность переменной к типу -is, -isnot и -as. Например:

$a=»123″ $b=123 $a -is «Int» False $a -is «String» True $b -is «String» False $b -is «Int» True $b -as «Int» 123 $b -as «Bool» True $b -isnot «Bool» True $b -isnot «String» True $b -isnot «Int» False

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

$a=»123″

$b=123

 

$a -is «Int»

False

 

$a -is «String»

True

 

$b -is «String»

False

 

$b -is «Int»

True

 

$b -as «Int»

123

 

$b -as «Bool»

True

 

$b -isnot «Bool»

True

 

$b -isnot «String»

True

 

$b -isnot «Int»

False

Оператор -as представляет выражение в типе, который вы ему укажете.

$b -as «Int» 123 $b -as «String» 123 $b -as «Boolean» True

$b -as «Int»

123

 

$b -as «String»

123

 

$b -as «Boolean»

True

Итог

В данной статье мы рассмотрели все операторы сравнения в powershell. В следующих двух мы выделим для операторов -replace, -contains и -notcontains, а так же -and, -or, -not, xor и !. Надеюсь данная статья была для вас полезной! Если у вас остались вопросы, тогда пишите их в комментариях, ответим на все. Подписывайтесь на нашу группу в ВК, канал на ютубе, а так же канал в телеграме! Благодарим за проявленный интерес.

Сгенерировать список доступных внешних (белых) IP адресов

Пришла в голову задачка, без явного практического применения, скорее как разминка для ума, и воссоздание в памяти и практических навыков в стэке используемых технологий. Задача формулируется следующим образом: написать скрипт, который бы сгенерировал все белые IP адреса. С одной стороны все просто, берем 4 цикла и методом перебора генерируем адреса. Да, в целом почти все так, если не смотреть в документацию. А в документации, есть не мало ньюансов на этот счет, про какие-то знал, но забыл, а о каких-то даже не слышал.

Список зарезервированных адресных диапазонов ipv4

Итак, если посмотреть на документацию, то можно увидеть большой список выделенных адресных блоков, которые не могут быть публичными адресами, а имеют специальное предназначение:
 
Блок адресовДиапазон адресовКоличество адресовНазначениеRFCОписание
0.0.0.0/80.0.0.0–0.255.255.25516777216SoftwareRFC 6890Может использоваться только как исходный адрес
10.0.0.0/810.0.0.0–10.255.255.25516777216Private networkRFC 1918Частная сеть
100.64.0.0/10100.64.0.0–100.127.255.2554194304Private networkRFC 6598Сеть сервис провайдера
127.0.0.0/8127.0.0.0–127.255.255.25516777216HostRFC 6890Cсылка на себя (loopback)
169.254.0.0/16169.254.0.0–169.254.255.25565536SubnetRFC 3927Немаршрутизируемая сеть
172.16.0.0/12172.16.0.0–172.31.255.2551048576Private networkRFC 1918Частная сеть
192.0.0.0/24192.0.0.0–192.0.0.255256Private networkRFC 6890для протокола IETF
192.0.2.0/24192.0.2.0–192.0.2.255256DocumentationRFC 5737Для документации и примеров
192.88.99.0/24192.88.99.0–192.88.99.255256InternetRFC 3068сеть трансляции IPv6 в IPv4
192.168.0.0/16192.168.0.0–192.168.255.25565536Private networkRFC 1918Частная сеть
198.18.0.0/15198.18.0.0–198.19.255.255131072Private networkRFC 2544Сеть тестирования между подсетями
198.51.100.0/24198.51.100.0–198.51.100.255256DocumentationRFC 5737Для документации и примеров
203.0.113.0/24203.0.113.0–203.0.113.255256DocumentationRFC 5737Для документации и примеров
224.0.0.0/4224.0.0.0–239.255.255.255268435456InternetRFC 5771Сеть для Многоаресной рассылки (MultiCast)
240.0.0.0/4240.0.0.0–255.255.255.254268435455InternetRFC 1700Зарезервировано
255.4=4294967296), 592708864 IPv4 адресов относятся к зарезервированным блокам, остается всего 3702258432 IPv4 адресов, которые различные компании и провайдеры могут использовать по своему усмотрению.

Количество адресов

Всего адресов

4294967296

Исключаемые из внешних

592708864

Остается адресов

3702258432


С учетом всех ограничений из RFC, скрипт для генерации всех белых ip адресов, может выглядеть следующим образом:
$StartIP=0 # С какого адреса начинать
$MaxIP=255 # Максимальное число в октете в IP адреса
$cnt=0 # Счетчик IP адресов

for ($a=$StartIP; $a -le $MaxIP; $a++) { 
    if (!(
        ($a -eq 0) -or #! 0.0.0.0/8  Current network (only valid as source address)  RFC 6890
        ($a -eq 10) -or #! 10.0.0.0/8 Private network RFC 1918
        ($a -eq 127) -or #! 127.0.0.0/8    Loopback    RFC 6890
        ($a -ge 224)
                    #! 224.0.0.0/4    IP multicast (former Class D network)   RFC 5771
                    #! 240.0.0.0/4    Reserved (former Class E network)   RFC 1700
                    #! 255.255.255.255    Broadcast   RFC 919
       )) 
    {
        for ($b=0; $b -le $MaxIP; $b++) {
            if (!(
                ((($a -eq 100) -and ($b -ge 64)) -and (($a -eq 100) -and ($b -le 127))) -or    #! 100.64.0.0/10  Shared Address Space    RFC 6598
                (($a -eq 169) -and ($b -eq 254)) -or                                          #! 169.254.0.0/16 Link-local  RFC 3927
                ((($a -eq 172) -and ($b -ge 16)) -and (($a -eq 172) -and  ($b -le 31))) -or     #! 172.16.0.0/12  Private network RFC 1918
                (($a -eq 192) -and ($b -eq 168)) -or                                          #! 192.168.0.0/16 Private network RFC 1918
                ((($a -eq 198) -and ($b -ge 18)) -and (($a -eq 198) -and ($b -le 19)))          #! 198.18.0.0/15  Network benchmark tests RFC 2544
               )) 
             {
                for ($c=0; $c -le $MaxIP; $c++) {
                    if  (!(
                           (($a -eq 192) -and ($b -eq 0) -and ($c -eq 0)) -or #! 192.0.0.0/24   IETF Protocol Assignments   RFC 6890
                           (($a -eq 192) -and ($b -eq 0) -and ($c -eq 2)) -or #! 192.0.2.0/24   TEST-eqT-1, documentation and examples  RFC 5737
                           (($a -eq 192) -and ($b -eq 88) -and ($c -eq 99)) -or #! 192.88.99.0/24 IPv6 to IPv4 relay (includes 2002::/16) RFC 3068
                           (($a -eq 198) -and ($b -eq 51) -and ($c -eq 100)) -or # 198.51.100.0/24    TEST-eqT-2, documentation and examples  RFC 5737
                           (($a -eq 203) -and ($b -eq 0) -and ($c -eq 113)) # 203.0.113.0/24 TEST-eqT-3, documentation and examples  RFC 5737
                        ))
                    {
 
                            for ($d=0; $d -le $MaxIP; $d++) {
             
                                $ip = $a.ToString() + "." + $b.ToString() + "." + $c.ToString() + "." + $d.ToString()
                                $ip
                               $cnt++
                            }
                        }
                    }
            }
        }
    }
}

Write-host "всего адресов: " $cnt
Выполнение скрипта, по последовательному перечислению всех доступных внешних ip адресов, заняло около 8,5 часов.

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

Отчет об объектах AWS в PowerShell

Для тех кто пользуется Amazon Web Services было бы полезным иметь инструмент для выгрузки списка используемых ресурсов в виде таблицы. Для решения этой задачи я написал скрипт на Powershell.

Для того, чтобы воспользоваться скриптом, нужно:
— Установить библиотеки AWS SDK for .NET, которые будут вызываться из скрипта PowerShell.
— Создать служебного пользователя в сервисе IAM консоли AWS.
— Назначить служебному пользователю права на чтение объектов EC2 и RDS (права описаны ниже).
— В скрипте PowerShell обозначить входные данные: номер аккаунта AWS, регион, учетные данные служебного пользователя.

Листинг скрипта для получения отчета по объектам EC2 и RDS из консоли AWS:

# AWS variables
$AWSAccountID = [your AWS account number]
$AWSRegion = [AWS region to report]
$AWSProfileAccessKey = "service user access key"
$AWSProfileSecretKey = "service user secret key"

# Registering AWS libraries
Add-Type -Path "C:\Program Files (x86)\AWS SDK for .NET\bin\Net45\AWSSDK.Core.dll"

Function Write-ScriptLog {
 Param(
   [CmdletBinding()]
   [Parameter(ValueFromPipeline=$true,ValueFromPipelineByPropertyName=$true)]
   [String]$Message,
   [Parameter(ValueFromPipeline=$true,ValueFromPipelineByPropertyName=$true)]
   [String]$LogFile
 )
 Process {
   $LogMessage = Get-Date -uformat "%d.%m.%Y %H:%M:%S"
   $LogMessage += "`t"
   $LogMessage += $Message
   $LogMessage | Out-File -FilePath $LogFile -Append
 }
}#End Function

# --- Start ---

# Calculating variables
$CurrentDate = Get-Date
$ScriptFolder = $MyInvocation.MyCommand.Path.SubString(0,($MyInvocation.MyCommand.Path.Length - $MyInvocation.MyCommand.Name.Length))

# Reset report
$EC2Report = @()
$RDSReport = @()

# Get list of VPCs
$VPCs = Get-EC2Vpc -Region $AWSRegion -AccessKey $AWSProfileAccessKey -SecretKey $AWSProfileSecretKey

# Get list of instances
$EC2Instances = (Get-EC2Instance -Region $AWSRegion -AccessKey $AWSProfileAccessKey -SecretKey $AWSProfileSecretKey).Instances

# Create the report per VPC
ForEach ($VPC in $VPCs) {
 $EC2Instances | Where-Object {$_.VpcId -eq $VPC.VpcId} | ForEach {
   $EC2InstanceProperties = New-Object -TypeName PSObject -Property @{
     'VPC-Id' = $_.VpcId
     'VPC-Name' = ($VPC.Tags | Where-Object {$_.Key -eq 'Name'}).Value
     'Instance-Id' = $_.InstanceId
     'Instance-Name' = ($_.Tags | Where-Object {$_.Key -eq 'Name'}).Value
     'Instance-LaunchTime' = $_.LaunchTime
     'Instance-Type' = $_.InstanceType
     'Instance-PrivateIpAddress' = $_.PrivateIpAddress
     'Instance-State' = $_.State.Name
     'Instance-Key' = $_.KeyName
     'Instance-Description' = ($_.Tags | Where-Object {$_.Key -eq 'Description'}).Value
     'Instance-Project' = ($_.Tags | Where-Object {$_.Key -eq 'Project code'}).Value
     'Instance-ProjectName' = ($_.Tags | Where-Object {$_.Key -eq 'Project name'}).Value
     'Instance-Responsible' = ($_.Tags | Where-Object {$_.Key -eq 'Responsible'}).Value
     'Instance-Platform' = $_.Platform
   }
   $EC2Report += $EC2InstanceProperties
 }
}

$EC2Report | Select 'Instance-Name', 'Instance-Description', 'Instance-Project', 'Instance-Id', 'Instance-Platform', 'Instance-Type', `
 'VPC-Name', 'VPC-Id', 'Instance-PrivateIpAddress', 'Instance-LaunchTime', 'Instance-State', 'Instance-ProjectName', 'Instance-Key', `
 'Instance-Responsible' | Sort -Property ('VPC-Name', 'Instance-Name') | Export-Csv -Path ($ScriptFolder + 'AWS-EC2Instances.csv') `
 -Encoding UTF8 -NoTypeInformation


$RDSInstances = Get-RDSDBInstance -Region $AWSRegion -AccessKey $AWSProfileAccessKey -SecretKey $AWSProfileSecretKey

ForEach ($VPC in $VPCs) {
 $RDSInstances | Where-Object {$_.DBSubnetGroup.VpcId -eq $VPC.VpcId} | ForEach {
   $RDSInstanceTags = Get-RDSTagForResource -ResourceName $_.DBInstanceArn -Region $AWSRegion -AccessKey $AWSProfileAccessKey `
     -SecretKey $AWSProfileSecretKey
   $RDSInstanceProperties = New-Object -TypeName PSObject -Property @{
     'VPC-Id' = $_.DBSubnetGroup.VpcId
     'VPC-Name' = ($VPC.Tags | Where-Object {$_.Key -eq 'Name'}).Value
     'Instance-Name' = $_.DBInstanceIdentifier
     'Instance-EndPoint' = $_.Endpoint.Address
     'Instance-CreateTime' = $_.InstanceCreateTime
     'Instance-Type' = $_.DBInstanceClass
     'Instance-StorageSize' = $_.AllocatedStorage
     'Instance-AvailabilityZone' = $_.AvailabilityZone
     'Instance-State' = $_.DBInstanceStatus
     'Instance-Platform' = $_.Engine
     'Instance-IOps' = $_.Iops
     'Instance-Description' = ($RDSInstanceTags | Where-Object {$_.Key -eq 'Description'}).Value
     'Instance-Project' = ($RDSInstanceTags | Where-Object {$_.Key -eq 'Project code'}).Value
     'Instance-ProjectName' = ($RDSInstanceTags | Where-Object {$_.Key -eq 'Project name'}).Value
     'Instance-Responsible' = ($RDSInstanceTagss | Where-Object {$_.Key -eq 'Responsible'}).Value
   }
   $RDSReport += $RDSInstanceProperties
 }
}

$RDSReport | Select 'Instance-Name', 'Instance-Description', 'Instance-Project', 'Instance-IOps', 'Instance-Platform', 'Instance-Type', `
 'VPC-Name', 'VPC-Id', 'Instance-EndPoint', 'Instance-CreateTime', 'Instance-State', 'Instance-ProjectName', 'Instance-StorageSize', `
 'Instance-AvailabilityZone', 'Instance-Responsible' | Sort -Property ('VPC-Name', 'Instance-Name') | `
 Export-Csv -Path ($ScriptFolder + 'AWS-RDSInstances.csv') -Encoding UTF8 -NoTypeInformation

(Get-RDSTagForResource -ResourceName $RDSInstances[1].DBInstanceArn -Region $AWSRegion -AccessKey $AWSProfileAccessKey `
 -SecretKey $AWSProfileSecretKey).Key['Projectcode']

# --- Stop---

 Листинг прав IAM для служебного пользователя, который используется для выгрузки данных из консоли AWS:

 {
   "Version": "2012-10-17",
   "Statement": [
       {
           "Sid": "VisualEditor0",
           "Effect": "Allow",
           "Action": [
               "ec2:DescribeInstances",
               "ec2:DescribeTags",
               "ec2:DescribeRegions",
               "ec2:DescribeSnapshots",
               "ec2:StopInstances",
               "ec2:DescribeSecurityGroups",
               "ec2:DescribeVolumeAttribute",
               "ec2:DescribeImages",
               "ec2:StartInstances",
               "ec2:DescribeAvailabilityZones",
               "ec2:DescribeVpcs",
               "ec2:DescribeVolumes",
               "ec2:DescribeSubnets",
               "ec2:DescribeKeyPairs",
               "ec2:DescribeInstanceStatus",
               "rds:ListTagsForResource",
               "rds:DescribeDBInstances"
           ],
           "Resource": "*"
       }
   ]
}

Примечание. Здесь для служебного пользователя выданы дополнительные полномочия, чтобы этот пользователь имел возможность перезагружать серверы EC2. Эта опция используется в другом скрипте, предназначенном для быстрого управления серверами без входа в консоль AWS.

Пример отчета по серверам EC2 — файл AWS-EC2Instances.csv

"Instance-Name","Instance-Description","Instance-Project","Instance-Id","Instance-Platform","Instance-Type","VPC-Name","VPC-Id",
 "Instance-PrivateIpAddress","Instance-LaunchTime","Instance-State","Instance-ProjectName","Instance-Key","Instance-Responsible"
"SERVER1","AWS TEST server","INF","i-08993683117971400",,"t2.xlarge","vpc-i-TST","vpc-43a84000",
 "192.168.1.12","09.05.2018 13:29:59","running",,,"Ivanov Vladimir"

Пример отчета по базам данным RDS — файл AWS-RDSInstances.csv

"Instance-Name","Instance-Description","Instance-Project","Instance-IOps","Instance-Platform","Instance-Type","VPC-Name","VPC-Id",
 "Instance-EndPoint","Instance-CreateTime","Instance-State","Instance-ProjectName","Instance-StorageSize","Instance-AvailabilityZone",
 "Instance-Responsible"
"dbs-i-tst",,,"0","postgres","db.t2.large","vpc-i-TST","vpc-43a84000",
 "dbs-i-tst.ctpuy7pji400.eu-west-1.rds.amazonaws.com","27.04.2018 16:44:14","available",,"250","eu-west-1a",
 

Пример отчета об объектах AWS, сконвертированный в Excel

Общие сведения о Powershell -Eq -Ne и других операторах сравнения

Вы изо всех сил пытаетесь понять операторы сравнения PowerShell, такие как eq , ne , ceq и cne . Если да, читайте дальше.

Исходя из опыта разработки программного обеспечения, в первый раз у меня возник вопрос «А?» Был момент, когда я впервые увидел операторы сравнения PowerShell eq , ceq , cne и т. д. Во всех других языках есть операторы сравнения, но не совсем как в PowerShell.Я привык к == и <> .

Не только синтаксис выглядит совершенно иначе, чем ваш типичный язык программирования, но и ведет себя иначе при сравнении наборов значений.

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

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

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

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

В этом посте я собираюсь рассказать об операторах равенства и о том, как их использует PowerShell. Это eq и ne с их чувствительными к регистру аналогами ceq и cne . Для получения полного списка вы можете перейти на сайт Technet или просто использовать Get-Help about_comparison_operators в консоли Powershell.

PowerShell -EQ и -CEQ

Если вам когда-нибудь понадобится проверить, равен ли объект другому объекту, вы должны использовать операторы eq (без учета регистра) или ceq (с учетом регистра).Эти операторы проверяют ценность каждого объекта, с которым вы хотите сравнить.

Когда я впервые начал изучать PowerShell, я постоянно делал что-то вроде этого

  $ строка = 'Адам'
if ($ string = 'Адам') {
    'строка равна Адаму'
}  

Вскоре ты будешь достаточно шлепан, чтобы этого не делать. Знак = — это оператор присваивания, НЕ оператор сравнения. Вы не можете использовать знак = для сравнения одного значения с другим.

Правильный способ сделать это — определить значение для проверки в левой части выражения и использовать оператор eq .Вот пример операторов eq и ceq и их использования.

Эквивалент PowerShell против ceq

Обратите внимание, как eq вернул логическое значение True при сравнении нашей переменной с adam , но ceq вернул логическое значение False ? Это отображает разницу чувствительности к регистру между двумя операторами.

Это все хорошо и хорошо для скалярных (одиночных) значений, но вы также можете найти все экземпляры определенных значений, используя эти операторы.Например, используйте оператор PowerShell -eq для фильтрации элементов в массиве:

Использование Eq для поиска по массивам

Если у вас есть переменная с набором значений, например массив, вы можете использовать eq и ceq , чтобы найти все экземпляры значений внутри коллекции.

Обратите внимание, что он нашел все экземпляры целого числа 9, с которыми мы пытались сравнить. Я постоянно использую этот удобный метод.

-NE и -CNE

На противоположной стороне у вас есть ne и cne .Они полностью противоположны eq и ceq , но демонстрируют точно такое же поведение, только противоположное. Они не проверяют равенство, они проверяют неравенство.

PowerShells ne против cne

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

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

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

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

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

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

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

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

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

Побитовые операторы
 -band Побитовый и
 -bor Побитовое или
 -bXor Побитовое ИЛИ (исключающее)
 -b Не побитовое НЕ
 -shl Сдвиг бит влево (PowerShell 3.0)
 -shr Сдвиг бит вправо - сохраняет знак для значений со знаком.(PowerShell 3.0)
 
Оператор формата
 " format_string "  -f   Object1 ,  Object2 , ...
 

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

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

Фильтры

Фильтр PowerShell принимает следующие операторы
-eq
-ne
-ge
-gt
-lt
-le
-вроде
-не как
-приблизительно
-бор
-полос
-рекурсивное совпадение

Обратите внимание, что в этом списке отсутствуют некоторые полезные операторы, такие как -match и -contains, но их можно использовать, передавая по конвейеру предложение Where-Object:
… | Где {$ _. Name –match ‘value’}

Примеры

$ демо = $ null
if ( -Not ($ demo) ) {напишите «Zero, null or Empty»}
if (! ($ demo) ) {напишите «Ноль, ноль или пустой»}

$ myVar -is «Строка»
$ myVar -eq 123
$ myVar -ceq $ myVar2
«abcdef» -подобный «abc *»
«abcdef» -заменить «dEf», «xyz»
$ myVar1 -is «String» -and $ myVar2 -is «Int»
«{2: N}» -f 24.4567
(1 -eq 1) -and -not (2 -gt 2)

$ mycmd = ps | выберите идентификатор, ProcessName
foreach ($ proc в $ mycmd) { «{0, -8} {1, -20}» -f $ proc.id, $ proc.ProcessName }

«Правило 50-50-90: каждый раз, когда у вас есть 50-50 шансов сделать что-то правильно, существует 90% -ная вероятность, что вы сделаете это неправильно» ~ Энди Руни

Связанные командлеты PowerShell:

if — Условно выполнить команду.
Операторы присваивания ($ переменная = X, $ переменная + = Y)
Регулярные выражения PowerShell
Таблица форматов


Авторские права © 1999-2021 SS64.com
Некоторые права защищены.

PowerShell -eq, -ceq и -ieq Операторы сравнения

Эта статья поможет вам понять операторы сравнения -eq, -ceq, -ieq в Windows PowerShell, которые используются для сравнения. Примеры использования оператора PowerShell -eq в этой статье позволяют лучше понять его использование.

Резюме

Windows PowerShell — одна из замечательных оболочек, которые когда-либо проектировала и разрабатывала Microsoft. С помощью PowerShell администраторы и разработчики Windows получают большие преимущества, поскольку он упрощает автоматизацию в операционной системе Windows. Вы можете узнать больше о PowerShell и ее использовании на сайте TechNet.

Поскольку цель этой статьи — узнать больше об операторе PowerShell -eq, давайте начнем с него.

Оператор сравнения (-eq):

PowerShell похож на любой другой язык программирования.При разработке сценариев с использованием PowerShell нам необходимо использовать операторы. Оператор -eq (называемый равным) — один из них. Как видно из названия, цель этого оператора -eq — выполнить сравнение в PowerShell. Мы можем сравнивать строки, числа и символы, используя оператор -eq. Этот оператор используется для сравнения скалярных значений. Результатом этого оператора -eq является логическое значение (True или False), которое указывает, равны ли входные скалярные значения или нет.

Примеры:

Теперь давайте рассмотрим несколько примеров, чтобы понять, как использовать этот оператор -eq в Windows PowerShell для сравнения.

Сравнение строк:

Две строки можно сравнить с помощью оператора -eq в PowerShell, чтобы проверить, равны они или нет.

«abc» -eq «abc»

«abc» -eq «xyz»

Приведенный выше код сравнивает одну строку с другой и возвращает True или False в зависимости от того, равны ли строки или нет. Вам придется делать это много раз при написании сценариев PowerShell в соответствии с вашими требованиями.

Посмотрите на приведенный ниже пример, где оператор PowerShell -eq используется для определения, правильно ли ввел пользователь ПИН-код или нет.

$ UserPIN = Read-Host «Введите свое имя»

if ($ UserPIN -eq «Стив») {

Write-Host «Добро пожаловать, Стив !!»

} остальное {

Write-Host «Извините, $ UserPIN, разрешен только Стив»

}

Этот оператор -eq в PowerShell также может принимать переменные типа коллекций, но вариантов его использования меньше, и я не хочу создавать путаницу, обсуждая его здесь.

Числовое сравнение:

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

100 -экв. 100

100 -экв. 110

0100 -экв. 100

10,1 -экв 10,1

10,2 -экв 10,1

Он сравнил оба переданных ему операнда и вернул результат. Вы можете задаться вопросом, откуда он знает, являются ли операнды, переданные оператору -eq, строками или числовыми значениями. В этом вся прелесть PowerShell. Он способен понять тип переменной и затем выполнить сравнение.

Также вы могли заметить, что -eq также может сравнивать десятичные числа.

Сравнение символов:

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

‘c’ -eq ‘c’

‘c’ -eq ‘z’

См. Пример выше для сравнения символов. Если оба символа равны, возвращается True, в противном случае — False.

С учетом регистра и без учета регистра для сравнения:

Пока что все примеры, которые мы видели выше, являются сравнениями без учета регистра.Да, оператор PowerShell -eq предназначен для выполнения операторов сравнения без учета регистра. Но ваши требования к сценарию PowerShell могут потребовать сравнения с учетом регистра, а также для точного сравнения строк.

Для решения таких задач в PowerShell есть еще два оператора для сравнения строк.

  1. Сравнение с учетом регистра (-ceq)
  2. Сравнение без учета регистра (-ieq)

Сравнение с учетом регистра (-ceq):

Этот оператор работает аналогично оператору -eq, но возвращает false, если сравниваемые строки различаются по регистру.Например, он возвращает false, когда вы пытаетесь сравнить Windows с Windows . Потому что в первом члене заглавная буква W.

См. Ниже пример, чтобы увидеть, как это работает:

«Окна» -экв. «Окна»

«Окна» -ceq «окна»

Сравнение без учета регистра (-ieq):

Несмотря на то, что оператор -eq выполняет сравнение строк без учета регистра, вы все равно хотите обеспечить сравнение без учета регистра, вы можете использовать -ieq.Этот параметр используется гораздо реже, потому что большинство людей используют -eq, который делает то же самое. Если вы знаете какой-либо случай, когда -ieq предпочтительнее -eq, напишите в комментариях к этой статье, чтобы я добавил его сюда.

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

«Linux» -экв. «Linux»

«Linux» -ieq «Linux»

«Linux» -ceq «Linux»

Сравнение без учета регистра (-ieq) и обычный оператор сравнения (-eq) вернули True в обоих случаях.Но сравнение с учетом регистра (-ceq) вернуло значение False.

Этот тип операторов, чувствительных к регистру или чувствительных к регистру, применим только к строкам и символам. Числовые значения не имеют регистра, поэтому достаточно использовать только оператор -eq.

У вас есть вопросы по использованию любого из этих операторов -eq, -ceq или -ieq? Не стесняйтесь размещать это в разделе комментариев под этой статьей.

Работа с оператором If — Microsoft Certified Professional Magazine Online

Конвейер PowerShell

Основы PowerShell: работа с оператором If

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

У каждого языка программирования и сценариев был какой-то способ выполнения условной операции с использованием оператора If как части управления потоком в сценарии или программе. PowerShell определенно ничем не отличается, и я собираюсь потратить некоторое время, чтобы охватить основы PowerShell, взглянув на операторы If / Else / ElseIf, которые помогут вам узнать, когда и где их использовать.

При работе в PowerShell будет время, когда вам потребуется выполнить какое-то сравнение, чтобы определить, какое действие должно произойти.Для этого можно использовать оператор If, а также оператор Else, который обычно сопровождает его, чтобы обработать результат, которого нет в If. Иногда на основе сравнения будет несколько ожидаемых результатов. В этом случае вы можете использовать несколько операторов ElseIf для обработки каждого из них.

Это работает так: вы берете свой элемент, который хотите сравнить с другим, и используете оператор сравнения, такой как –eq (это означает, что вы хотите увидеть, совпадает ли что-то с тем, с чем вы его сравниваете; подробнее об этом позже), который затем возвращает логическое значение True (соответствует сравнению) или False (не соответствует сравнению).

Быстрый пример, показывающий это в действии, просто посмотрим, равно ли число 1 или нет 1.

 Если (1 -экв. 1) {
  'Это число 1' 
} Иначе {
'Это число не 1'
}

Результат того, что произойдет, должен казаться довольно очевидным. Мы всегда будем получать строку, в которой указано, что значение равно 1. Если бы число было чем-то другим, кроме 1, мы бы вернули строку из блока Else, заявив, что значение не равно 1.

Помните, что все, что идет в блок сценария после оператора If, всегда должно иметь значение True — если только вы не ожидаете обратного, используя оператор –NOT в операторе If, как показано ниже.

 If (-NOT (1 -eq 1)) {
'Это число не равно 1'
} Else {
'Это число равно 1'
}

Добавление –NOT означает, что верно обратное, поэтому теперь блок сценария Else будет запущен, когда мы выполним приведенный выше код.

До сих пор мы рассматривали простые операторы If / Else, в которых рассматривалась только одна вещь. Мы можем легко объединить несколько сравнений, а затем предоставить соответствующий блок сценария для обработки того, что происходит, когда результат либо истинный, либо ложный.

 $ Data1 = 'Apple' 
$ Data2 = 'Red'

If ($ Data1 -eq 'Apple' -AND $ Data2 -eq 'Red') {
'Это красное яблоко'
}

If ($ Data1 -eq 'Banana' -AND $ Data2 -eq 'Red') {
'Это красное яблоко'
}

Рисунок 1. Пример того, где If будет отображать выходные данные, а также не отображать выходные данные.

Здесь мы видим, что если $ Data1 — это Apple, а $ Data2 — красный, что первый пример сценария возвращается с заявлением, что «Это красное яблоко», поскольку оба сравнения верны, а второй пример ничего не выводит, потому что не соответствует требованиям оператора If ($ Data1 не является ‘Banana’), даже если одна из переменных была истинной ($ Data2 ‘красный’).Это важно, когда вы устраняете неполадки в потоке вашего скрипта и задаетесь вопросом, почему правильный блок скрипта не запускается в вашем блоке If / Else. Использование оператора –AND означает, что оба этих значения должны быть $ True с соответствующими сравнениями, прежде чем это позволит мне использовать блок сценария If. Если бы это было не так, вместо этого использовался бы блок сценария для Else. Если мы заботимся только о том, чтобы одно из двух (или оба все еще) сравнения было истинным, мы могли бы заменить –AND на –OR, и пока один из результатов будет истинным, будет выполняться блок сценария для If.

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

 $ Data = 'Apple' 
If ($ Data -eq 'orange') {
'This is a orange'
} ElseIf ($ Data -eq 'grape') {
'This is a grape'
} ElseIf ( $ Data -eq 'Apple') {
'Это яблоко'
} Иначе {
'Не могу определить, что это такое'
}

В этом примере мы знаем, что результатом будет то, что данные принадлежат Apple, но в отличие от ранее, когда у нас было только два варианта, здесь у нас есть несколько вариантов и, наконец, наш Else, который является универсальным, если ни один из других ElseIfs способны обрабатывать сравнения.Последний пример этого ниже:

 $ Data = 1..7 
$ Data | ForEach {
Если ([int] $ _ -gt 3) {
"$ ($ _) больше 3"
} ElseIf ([int] $ _ -lt 3) {
"$ ($ _) меньше чем 3 "
} ElseIf ([int] $ _ -eq 3) {
" $ ($ _) is 3 "
} Else {
" Понятия не имею, что это; не число "
}
}
Рисунок 2. Еще один взгляд на использование управления потоком If / ElseIf / Else.

Используя ElseIf, мы можем обрабатывать, является ли число больше, меньше или равно тому, что мы ему бросаем, и мы можем обрабатывать его соответствующим образом.

Как вы заметили, я исключил –gt (больше чем) и –lt (меньше чем) в качестве возможных операторов сравнения. Фактически, есть несколько операторов, которые мы можем использовать для сравнения.

-экв.

равно

-ne

Не равно

-GT

Больше

-ge

Больше или равно

-lt

Менее

-le

Меньше или равно

— как

Соответствие подстановочного знака

— не похоже на

Не соответствует подстановочному знаку

-матч

Соответствие регулярному выражению

— несоответствие

Не соответствует шаблону регулярного выражения

-содержит

Коллекция содержит предмет

-не содержит

Коллекция не содержит предмета

Товар в коллекции

.

— кроме

Товар отсутствует в коллекции

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

 Get-Help about_Comparison_Operators 

Теперь, когда вы лучше понимаете управление потоком с помощью If / Else / ElseIf, вы можете применить это к своим скриптам, чтобы лучше обрабатывать данные, которые им отправляются.


Об авторе

Бо Прокс — специалист по Microsoft MVP в Windows PowerShell и старший системный администратор Windows.Он работает в сфере информационных технологий с 2003 года и поддерживает множество различных платформ. Он является соавтором PowerShell Deep Dives с главами о WSUS и TCP-коммуникациях. Он модератор сайта Hey, Scripting Guy! форум, и он был судьей Scripting Games. Он выступал с докладами на темы WSUS и PowerShell, а также о пространствах выполнения для групп пользователей PowerShell. Он является почетным сценаристом и отправил ряд сообщений в Microsoft’s Hey, Scripting Guy! У него также есть несколько проектов с открытым исходным кодом, доступных на Codeplex и GitHub.Его личный блог находится на http://learn-powershell.net.

PowerShell, оператор Not Equal: приложения, примеры

Оператор PowerShell Not Equal сравнивает два значения. Он возвращает Истинно , если два значения не равны.

Кроме того, если сравниваемые значения равны, оператор PowerShell Not Equal (NE) возвращает False .

Из этого руководства вы узнаете все, что вам нужно знать об операторе сравнения «Not Equal (NE)».Кроме того, в руководстве много реальных примеров системного администратора.

Начнем с синтаксиса Not Equal (NE)…

Синтаксис PowerShell, оператор «Не равно»

Синтаксис оператора «Не равно (NE)»: ..

 "п.1" -не "п.2" 

Если вы хотите сравнить несколько значений, используйте оператор « и» или « или ». Синтаксис для сравнения нескольких значений:

 ("элемент 1" -ne "элемент 2") -или ("элемент 3" -ne "элемент 4") 
 ("элемент 1" -ne "элемент 2") -and ("элемент 3" -ne "элемент 4") 

Первый синтаксис оператора PowerShell Not Equal перенастраивает True , если элемент 1 НЕ равен элемент 2 .Более того, во втором синтаксисе команда вернет Истина , если либо сравнений «Не равно» с обеих сторон оператора « Или » равно Истинно .

В отличие от второго синтаксиса с оператором « или », третий синтаксис — с оператором «и» — вернет Истина только в том случае, если «Не равно» на сравнивает обе стороны от « и ». оператор Истинный .

Наконец, оператор «ne» нечувствителен к регистру (он нечувствителен к регистру).Однако, если вы хотите сделать его чувствительным к регистру, используйте синтаксис ниже:

 "элемент 1" -cne "элемент 2" 

Разница между этой последней командой и первой в том, что «c» добавляется после «-».

Как использовать оператор PowerShell Not Equal для проверки нулевых или пустых значений

В сценариях PowerShell есть много причин, по которым вы можете захотеть проверить нулевые или пустые значения. Вы можете использовать «ne», чтобы проверить, является ли значение нулевым.

Для проверки нулевого значения используйте автоматическую переменную $ null.Более того, вы также можете использовать тест оператора PowerShell «Не равно» для пустого значения в PowerShell с «» (2 двойные кавычки без чего-либо внутри кавычек).

Начнем с простых примеров…

Откройте командную строку PowerShell и выполните следующую команду:

 Get-Process 

Команда возвращает все процессы, запущенные на вашем локальном компьютере. Я выделил столбец CPU (s) .

Для некоторых процессов столбец CPU (s) пуст (ноль, пустой).

Чтобы отобразить только результаты, в которых столбец CPU (s) НЕ является пустым или пустым, выполните следующую команду:

 Get-Process | Где-Объект {$ _. CPU -ne $ null} 

Если вы теперь посмотрите на столбец CPU (s) , все результаты с нулевым значением были удалены!

Вы также можете применить тот же принцип, чтобы вернуть все службы на вашем компьютере со статусом «работает». Вот команда PowerShell:

 Get-Service | Где-Объект -FilterScript {$ _.status -ne "Остановлен"} 

Вот результат выполнения команды в PowerShell:

Чтобы результат выглядел лучше, мы можем направить вывод в Format-Table , а затем переупорядочить заголовки. Вот измененная команда:

 Get-Service | Where-Object -FilterScript {$ _. Status -ne "Остановлен"} | Имя форматной таблицы, отображаемое имя, статус 

А вот результат в PowerShell…

Как использовать оператор PowerShell Not Equal для проверки $ True или $ False

Это может быть неочевидным, однако каждый раз, когда вы используете в команде оператор PowerShell «Не равно», он возвращает значение $ True или $ False.Затем значение $ True или $ False используется для выполнения любых дальнейших команд.

$ True, $ False — автоматические переменные, которые означают True и False соответственно.

В качестве примера, в примере Get-Process в последнем разделе оператор « $ _. CPU -ne $ null » в Where-Object просто вернул все процессы, которые вернули True для оператора , « $ _. CPU -ne $ null ».

 Get-Process | Где-Объект {$ _. CPU -ne $ null} 

Кроме того, все процессы, которые вернули Ложь для « $ _.CPU -ne $ null »не был возвращен.

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

 1 -ne 2 

Очевидно, что 1 НЕ равно 2, поэтому мы ожидаем, что результат вернет True. И вот результат в PowerShell…

А как насчет…

 1 -ne 1 

Он вернул Ложь , потому что это утверждение НЕ соответствует действительности.

Примеры операторов «Не равно» в PowerShell

В этом разделе я рассмотрю два практических примера оператора PowerShell «Не равно».В первом примере я покажу вам, как использовать оператор «ne» для проверки нескольких значений или условий.

Наконец, во втором разделе вы узнаете, как использовать оператор PowerShell «Not Equal» в операторе IF.

PowerShell, пример нескольких значений оператора неравенства

Чтобы проиллюстрировать, как использовать оператор «ne» PowerShell для проверки нескольких значений, давайте вернемся к примеру команды Get-Service в предыдущем разделе.

 Get-Service | Где-Объект -FilterScript {$ _.status -ne "Остановлен"} 

В этой команде мы использовали оператор PowerShell «Not Equal» для проверки единственного условия. Команда вернула только те службы, которые НЕ имеют статус «Остановлен».

Условие проверяется в части команды Where-Object . Вот результат команды:

Как и ожидалось, команда вернула ВСЕ службы со статусом «Выполняется».

Что делать, если я хочу удалить некоторые службы, даже если их статус «Выполняется»?

Я могу добиться этого, добавив несколько значений (или условий) в часть команды Where-Object .Например, допустим, я не хочу возвращать следующие службы — AJRouter , ALG и AppMgmt .

Чтобы удалить эти службы из результата, я изменю предыдущую команду, как показано ниже:

 Get-Service | Where-Object -FilterScript {($ _. Status -ne "Остановлен") -and ($ _. Name -ne " AJRouter ") -and ($ _. Name -ne "  ALG  ") - и ($ _. Name -ne "  AppMgmt  ")} 

Результат измененной команды не включает эти 3 службы!

Кроме того, вы можете изменить результат последней команды, используя «или» вместо «и».

Например, чтобы вернуть все серверы без имени «AppIDSvc» ИЛИ все службы со статусом НЕ равным «работает», выполните следующую команду:

 Get-Service | Where-Object -FilterScript {($ _. Status -ne "работает") -or ($ _. Name -ne "AppIDSvc")} 

К сожалению, результат не очень полезный. Причина, по которой это не очень полезно, заключается в следующем: хотя я хотел исключить службы со статусом НЕ равно остановлен, у меня есть второе условие, связанное с «или» — результат включал обе службы со статусом «Выполняется» и «Остановлен».

В любом случае, я просто хотел проиллюстрировать, как тестировать несколько условий с помощью оператора PowerShell «Не равно»!

Как использовать PowerShell, НЕ равный заявлению if

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

Вот сценарий, который создает папки, используя имена, показанные в текстовом файле, показанном выше:

 $ FolderPath = "D: \ PS-Tutorial \ NewFolders"
$ TextFilePath = "D: \ PS-Tutorial \ имена-папок.текст"
$ folderNames = Get-Content $ TextFilePath
 ForEach ($ folderName в $ folderNames) {
 $ checkPath = Test-Path $ FolderPath \ $ имя папки
     Если ($ checkPath -ne $ true) {
  New-Item -Path $ FolderPath -Name $ folderName -ItemType "каталог" | Out-Null}
 } 

Перед запуском сценария вот папка, сохраненная в переменной FolderPath (строка 1 кода). Папка пуста.

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

$ FolderPath : путь к папке, в которой вы хотите создать новые папки.
$ TextFilePath : полный путь к текстовому файлу с именами папок, которые вы хотите создать.

Наконец, чтобы выполнить сценарий, скопируйте его в PowerShell ISE и запустите.

После запуска сценария папки были созданы в папке, указанной в переменной FolderPath .

Ниже я объяснил, что делает каждая строка скрипта. Обратите внимание на путь к оператору PowerShell «Не равно» — «$ checkPath -ne $ true», часть — строка 6.

 $ FolderPath = "D: \ PS-Tutorial \ NewFolders"
$ TextFilePath = "D: \ PS-Tutorial \ имена-папок.текст"
$ folderNames = Get-Content $ TextFilePath
 ForEach ($ folderName в $ folderNames) {
 $ checkPath = Test-Path $ FolderPath \ $ имя папки
     Если ($ checkPath -  ne  $ true) {
  New-Item -Path $ FolderPath -Name $ folderName -ItemType "каталог" | Out-Null}
 } 

Вот объяснение каждой строчки скрипта:

  1. Строка 1 : Сохраняет путь, по которому вы хотите сохранить новые папки, в переменной с именем FolderPath .
 $ FolderPath = "D: \ PS-Tutorial \ NewFolders" 
  1. Строка 2 : Сохраняет путь к текстовому файлу с именами папок в переменной с именем TextFilePath .
 $ TextFilePath = "D: \ PS-Tutorial \ folder-names.txt" 
  1. Строка 3 : Извлекает содержимое текстового файла (имена папок) с помощью команды Get-Content . Затем сохраняет результат в переменной folderNames .
 $ folderNames = Get-Content $ TextFilePath 
  1. Строка 4 : открывает блок операторов ForEach . Оператор ForEach выполняет итерацию результата текстового файла (сохраненного в переменной folderNames ).Затем на каждой итерации он сохраняет имя папки во временной переменной имя_папки .
 ForEach ($ folderName в $ folderNames)  { 
  1. Строка 5 : Выполняется в блоке операторов ForEach : использует команду Test-Path , чтобы проверить, существует ли путь к папке в пути к папке, сохраненной в переменной FolderPath .

    Результатом команды Test-Path является $ True или $ False.

 $ checkPath = Test-Path $ FolderPath \ $ folderName 
  1. Строка 6 : вводит оператор IF (все еще в блоке операторов ForEach ). Здесь мы используем оператор PowerShell «Not Equal», чтобы проверить, является ли результат команды Test-Path $ True или $ False.
 Если ($ checkPath -  ne  $ true)  { 
  1. Строка 7 : В этой строке, если «$ checkPath -ne $ true» НЕ равно Истина , используйте команду New-Item , чтобы создать папку с именем, сохраненным во временной переменной, имя_папки .

    Кроме того, чтобы команда New-Item не отображала какие-либо результаты, передайте ее команде Out-Null по конвейеру.

    Наконец, закройте блок операторов IF закрытой скобкой «}».

 New-Item -Path $ FolderPath -Name $ folderName -ItemType "directory" | Out-Null }  

Если вы запустите команду New-Item , не связав ее с командой Out-Null , отобразятся сведения о созданной папке.

  1. Строка 8 : Закройте блок операторов ForEach закрывающей скобкой «}».
} 

Вот и все! Наше обновленное руководство оператора PowerShell «Не равно» (ne).

Надеюсь, это руководство было для вас полезным. Если вы нашли его полезным, проголосуйте за Да на вопрос «Был ли этот пост полезным» ниже.

Кроме того, вы можете задать вопрос, оставить комментарий или оставить отзыв с помощью формы «Оставить ответ» в конце этой страницы.

Наконец, дополнительные технические Itechguides по PowerShell можно найти на нашей странице практических рекомендаций по Windows PowerShell. Вы также можете найти нашу страницу Работа с домашней страницы очень полезной.

Эта статья была полностью переписана и дополнена новыми примерами.

Ссылки и дополнительная литература

  1. Об операторах сравнения
  2. О логических операторах
  3. Where-Object

PowerShell — объяснение условных операторов и операторов сравнения

Некоторое время назад мне задали вопрос, что означают операторы ‘-eq’, ’-lt’ и ‘-ne’, что это еще за операторы и что еще я мог о них рассказать.Я думаю, что это хорошая тема для сообщения в блоге, поскольку большинство начинающих сценаристов PowerShell не знают, какие операторы им доступны … и для вашего удобства я привел несколько примеров из реальной жизни

Есть два вида: операторы сравнения и логические операторы.

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

Оператор -экв
Имя: Равно.
Описание: Используется для сравнения идентичного значения.
Пример: Get-childitem | где {$ _. Name –eq «PowerShell notes»}
Пояснение: Найдет все файлы, в которых имя файла равно «PowerShell notes».
Оператор -ne
Имя: Не равно.
Описание: Используется для сравнения другого значения.
Пример: Get-childitem | где {$ _. Name –ne «PowerShell notes»}
Пояснение: Найдет все файлы, имя которых не равно «PowerShell notes».
Оператор -GT
Имя: Больше
Описание: Используется для сравнения другого значения по размеру.
Пример: Get-childitem | где {$ _.Длина –gt 1 МБ}
Пояснение: Найдет все файлы, размер которых превышает 1 МБ.
Оператор -ge
Имя: Больше или равно
Описание: Используется для сравнения другого или идентичного значения по размеру.
Пример: Get-childitem | где {$ _. Length –ge 1MB}
Пояснение: Найдет все файлы, размер которых равен или больше 1 МБ.
Оператор -lt
Имя: Менее
Описание: Используется для сравнения другого значения по размеру.
Пример: Get-childitem | где {$ _. Length –lt 1MB}
Пояснение: Найдет все файлы размером менее 1 МБ.
Оператор -le
Имя: Меньше или равно
Описание: Используется для сравнения другого или идентичного значения по размеру.
Пример: Get-childitem | где {$ _. Length –le 1MB}
Пояснение: Найдет все файлы, размер которых равен или меньше 1 МБ.
Оператор — как
Имя: Нравится
Описание: Сопоставьте идентичное значение с использованием подстановочного знака.
Пример: Get-childitem | где {$ _.Имя — как «PowerShell *»}
Пояснение: Найдет все файлы, имя которых начинается с «PowerShell».
Оператор — не как
Имя: Не похоже на
Описание: Не совпадает с идентичным значением, использующим подстановочный знак.
Пример: Get-childitem | где {$ _. Name — в отличие от «PowerShell *»}
Пояснение: Найдет все файлы, имя которых не начинается с «PowerShell».
Оператор -матч
Имя: Матч
Описание: Используется для сравнения строки с использованием регулярного выражения.
Пример: Get-childitem | где {$ _. Name –match «Power»}
Пояснение: Найдет все файлы, имя которых содержит «Power».
Оператор — несоответствие
Имя: не соответствует
Описание: Используется для сравнения строки с использованием регулярного выражения.
Пример: Get-childitem | где {$ _. Name –notmatch «Power»}
Пояснение: Найдет все файлы, в названии которых нет «Power».
Оператор -содержит
Имя: Содержит
Описание: Используется для проверки, все ли предоставленные объекты содержат определенное значение.
Пример: «Microsoft», «Windows», «PowerShell» — содержит «Power»
Пояснение: Проверяет, включена ли строка «Power» во все предоставленные объекты, и поэтому отвечает «False» на этот вопрос.
Оператор -не содержит
Имя: Не содержит
Описание: Используется для проверки, все ли предоставленные объекты не содержат определенного значения.
Пример: «Windows», «PowerShell» — не содержит «Power»
Пояснение: Проверяет, включена ли строка «Power» во все предоставленные объекты, и поэтому ответит «True» на этот вопрос.
Оператор -заменить
Имя: Заменить
Описание: Используется для изменения значения элемента.
Пример: Get-childitem –include * .doc | где {$ _ –replace «.doc», «.docx»}
Пояснение: Найдет все файлы * .doc и изменит их расширение с .doc на .docx
Примечание: Эта команда только изменила расширение, она не конвертирует файл в новый формат!

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

Оператор
Имя: и
Описание: Логическое «и». Верно только тогда, когда верны оба утверждения.
Пример: Get-childitem | где {($ _. Length -gt 1MB) -and ($ _. Length -lt 10MB)}
Пояснение: Найдет все файлы размером от 1 до 10 МБ.
Оператор -или
Имя: или
Описание: Логическое «или». Верно только тогда, когда одно или оба утверждения верны.
Пример: Get-childitem | где {($ _. Name –как «* Microsoft *») –или ($ _. Name –как “* Citrix *”)}
Пояснение: Найдет все файлы, в названии которых есть «Microsoft» или «Citrix».
Оператор -xor
Имя: Эксклюзив или
Описание: Логическое «исключающее или». Верно только тогда, когда одно из утверждений верно, а другое — ложно.
Пример: Get-childitem | где {($ _. Name –вроде «* Microsoft *») –xor ($ _. Name – like “* RDS *”)}
Пояснение: Найдет все файлы, имя которых включает «Microsoft», но не включает «RDS».
Оператор -не
Имя: Не
Описание: Логическое «нет». Отменяет следующее утверждение.
Пример: Get-childitem | где {($ _. Name –вроде «* Microsoft *») –and –not ($ _. Length –gt 1MB)}
Пояснение: Найдет все файлы, имя которых включает «Microsoft», а размер файла не превышает 1 МБ.
Оператор !
Имя: Не
Описание: То же, что и оператор — не
Пример: Get-childitem | где {($ _. Name –вроде «* Microsoft *») –and! ($ _. Length –gt 1MB)}
Пояснение: То же, что и оператор — не

AWS CLI -eq PowerShell

руб.
AWS IAM Access Analyzer анализатор доступа IAMAA
AWS Certificate Manager акм ACM
Частный центр сертификации AWS Certificate Manager acm-pca PCA
Alexa для бизнеса alexaforbusiness ALXB
Amazon Managed Service для Prometheus усилитель ПРОМ
AWS Amplify усилить AMP
Серверная часть AWS Amplify усилитель бэкэнд AMPB
Amazon API Gateway apigateway AG
Управление шлюзом Amazon API apigatewaymanagementapi AGM
Amazon API Gateway apigatewayv2 AG2
AWS AppConfig appconfig APPC
Amazon AppFlow приложение AF
Amazon AppIntegrations API приложений AIS
AWS Auto Scaling автоматическое масштабирование приложений AAS
Amazon CloudWatch Application Insights аналитика приложений CWAI
Профилировщик стоимости приложений AWS заявка ACP
AWS App Mesh приложений АМШ
Средство выполнения приложений AWS аппраннер AAR
Amazon AppStream 2.0 поток приложений APS
AWS AppSync appsync ASYN
Amazon Athena Афина ATH
AWS Audit Manager auditmanager AUDM
AWS Auto Scaling автомасштабирование КАК
AWS Auto Scaling планы автомасштабирования ASP
Резервное копирование AWS резервное копирование БАК
AWS Партия партия летучая мышь
Амазонка Braket скоба BRKT
Бюджеты AWS бюджетов BGT
Cost Explorer ce CE
Амазонский звонок звонок ЧМ
AWS Cloud9 облако9 C9
Amazon Cloud Directory облачный каталог CDIR
AWS Cloud Formation облачная информация CFN
Amazon CloudFront облачный фронт CF
AWS CloudHSM облакоhsm HSM
AWS CloudHSM облакоhsmv2 HSM2
Amazon CloudSearch cloudsearch CS
Amazon CloudSearch cloudsearchdomain CSD
AWS CloudTrail облака CT
Amazon CloudWatch облачные часы CW
Артефакт AWS кодартефакт CA
AWS CodeBuild код сборки CB
AWS CodeCommit codecommit CC
Рецензент Amazon CodeGuru codeguru-reviewer CGR
Amazon CodeGuru Profiler код CGP
AWS CodePipeline код трубопровода CP
AWS CodeStar codestar CST
Соединения AWS CodeStar codestar-соединения CSTC
Уведомления AWS CodeStar codestar-уведомления CSTN
Amazon Cognito однозначно идентифицирует когнитоидентичность CGI
Amazon Cognito Identity Provider когнито-idp CGIP
Amazon Cognito Sync когнито-синхронизация CGIS
Amazon Comprehend понять КОМП
Amazon Comprehend понять медицинские CMPM
AWS Compute Optimizer оптимизатор вычислений CO
Конфигурация AWS configservice CFG
настроить Настройте параметры интерфейса командной строки AWS.
Amazon Connect подключение СОЕДИНЕНИЕ
Контактная линза для Amazon Connect соединительная контактная линза CCL
Служба участников Amazon Connect подключитьсяучастник СОЕДИНЕНИЕ
Отчет о расходах и использовании AWS сред
Профили клиентов Amazon Connect профили клиентов CPF
AWS Glue DataBrew databrew GDB
Обмен данными AWS обмен данными DTEX
Конвейер данных AWS трубопровод DP
AWS DataSync синхронизация данных DSYN
Ускоритель Amazon DynamoDB dax DAX
Amazon DynamoDB ddb DDB Команды DynamoDB высокого уровня.
AWS CodeDeploy развернуть CD
Amazon Detective детектив DTCT
AWS Device Farm устройство фермы DF
Amazon DevOps Guru DevOps-Guru ДГУРУ
AWS Прямое подключение прямое соединение DC
AWS Application Discovery Service открытие ADS
Amazon Data Lifecycle Manager длм DLM
AWS Database Migration Service дмс DMS
Amazon DocumentDB docdb DOC
AWS Directory Service DS DS
Amazon DynamoDB динамодб DDB
Потоки Amazon DynamoDB динамодетчиков DDB
Amazon Elastic Block Store ebs EBS
Amazon EC2 ec2 EC2
AWS EC2 Connect Service ec2-instance-connect EC2IC
Amazon Elastic Container Registry ecr ECR
Amazon Elastic Container Registry Public ecr-public ECRP
Amazon Elastic Container Service ecs ECS
Amazon Elastic File System efs EFS
Amazon Elastic Container Service для Kubernetes экс ЭКС
Amazon Elastic Inference эластичный вывод EI
Amazon ElastiCache резинка EC
AWS Elastic Beanstalk эластичный стебель EB
Amazon Elastic Transcoder эластичный транскодер ETS
Упругая балансировка нагрузки elb ELB
Упругая балансировка нагрузки elbv2 ELB2
Amazon EMR emr EMR
Amazon EMR на Amazon EKS емр-контейнеров EMRC
Amazon Elasticsearch Service es ES
События Amazon CloudWatch событий CWE
Amazon FinSpace пространство для плавников FINSP
Amazon FinSpace finspace-data ФНСП
Amazon Kinesis Data Firehose пожарный шланг КИНФ
Amazon Fault Injection Simulator fis FIS
AWS Firewall Manager fms ФМС
Amazon Forecast прогноз FRC
Amazon Forecast Query Service запрос прогноза FRCQ
Детектор мошенничества Amazon детектор мошенничества FD
Amazon FSx fsx FSX
Amazon GameLift геймлифт GML
Ледник Амазонки S3 ледник GLC
AWS Global Accelerator globalaccelerator GACL
Клей AWS клей КЛЕЙ
AWS IoT Greengrass гринграсс GG
AWS IoT Greengrass зеленая траваv2 GGV2
Наземная станция AWS наземная станция GS
Amazon Guard Duty дежурный GD
AWS Health здоровья HLTH
Amazon HealthLake Healthlake AHLFHIR
история Команды для взаимодействия с историей команд интерфейса командной строки AWS выполнялись с течением времени.
Amazon Honeycode код меда HC
AWS Управление идентификацией и доступом iam IAM
AWS SSO Identity Store identitystore IDS
EC2 Image Builder редактор изображений EC2IB
AWS Import / Export импорт-экспорт IE
Amazon Inspector инспектор INS
AWS IoT iot IOT
AWS IoT-Data iot-data
Задания AWS IoT iot-jobs-data IOTJ
AWS IoT 1-Click Devices iot1click-устройств
AWS IoT 1-Click Project iot1click-проектов
AWS IoT Analytics иотаналитика
AWS IoT Core Device Advisor iotdeviceadvisor IOTDA
События AWS IoT iotevents IOTE
События AWS IoT iotevents-data IOTED
Fleet Hub для AWS IoT Device Management iotfleethub IOTFH
AWS IoT Secure Tunneling iotsecuretunneling IOTST
Amazon IoT SiteWise iotsitewise IOTSW
График вещей AWS IoT iotthingsgraph IOTTG
AWS IoT Wireless беспроводной связи IOTW
Amazon Interactive Video Service ivs ИВС
Amazon Managed Streaming для Kafka кафка мск
Amazon Kendra Кендра КНДР
Amazon Kinesis кинез КИН
Amazon Kinesis kinesis-video-archived-media
Amazon Kinesis Video Streams Media кинезис-видео-медиа KVM
Каналы видеосигнала Amazon Kinesis кинезис-видеосигнал КВСК
Amazon Kinesis кинезизаналитика КИНА
Amazon Kinesis кинезисаналитика v2 КИНА2
Amazon Kinesis kinesisvideo кВ
AWS Key Management Service км KMS
AWS Lake Formation формация озера LKF
AWS Лямбда лямбда LM
Amazon Lex lex-модели ЛМБ
Amazon Lex lex-runtime LEX
Amazon Lex lexv2-модели LMBV2
Amazon Lex lexv2-среда выполнения LRSV2
AWS License Manager менеджер лицензий LICM
Amazon Lightsail световой парус LS
Amazon Расположение расположение LOC
Журналы Amazon CloudWatch журналов CWL
Amazon Lookout для оборудования lookoutequipment L4E
Amazon Lookout for Metrics Lookoutmetrics LOM
Amazon Lookout for Vision Lookoutvision LFV
Машинное обучение Amazon машинное обучение мл
Amazon Macie маки MAC
Amazon Macie macie2 MAC2
Управляемый блокчейн Amazon управляемый блокчейн МБК
Сервис каталога AWS Marketplace маркетплейс-каталог MCAT
AWS Marketplace Entitlement Service маркетплейс-право MES
AWS Marketplace Commerce Analytics торговая площадкакоммерческая аналитика MCA
AWS Elemental MediaConnect mediaconnect EMCN
AWS Elemental MediaConvert медиаконвертеров ЭМС
AWS Elemental MediaLive средний EML
AWS Elemental MediaPackage медиапакет EMP
AWS Elemental MediaPackage VOD mediapackage-vod EMPV
AWS Elemental MediaStore mediastore EMS
Уровень данных AWS Elemental MediaStore mediastore-data EMSD
AWS Elemental MediaTailor медицинский работник ЕМТ
AWS Marketplace Metering Service Метрмаркетплейс ММ
Центр миграции AWS мгн MH
AWS Application Migration Service mgn MGN
Конфигурация концентратора миграции AWS migrationhub-config MHC
AWS Mobile мобильный MOBL
Amazon MQ кв.м. MQ
Amazon Mechanical Turk мтюрк MTR
Amazon Managed Workflows для Apache Airflow mwaa MWAA
Амазонка Нептун нептун NPT
Сетевой брандмауэр AWS сетевой брандмауэр NWFW
Сетевой менеджер AWS Transit Gateway сетевой менеджер НМГР
Amazon Nimble Studio шустрый
AWS OpsWorks opsworks OPS
AWS OpsWorks для управления конфигурацией opsworks-cm OWCM
AWS Организации организаций ORG
Аванпосты AWS застав ВЫХОД
Amazon Personalize персонализировать PERS
Amazon Personalize персонализировать-события ПЕРСА
Amazon Personalize персональная среда выполнения PERSR
AWS Performance Insights пи PI
Amazon Pinpoint точечный ПИН
Электронная почта Amazon Pinpoint адрес электронной почты СОСНА
Amazon Pinpoint SMS и голосовые сообщения pinpoint-sms-voice СОСНА
Amazon Polly полли ПОЛ
Прейскурант услуг AWS цена PLS
AWS Proton протон
База данных Amazon Quantum Ledger (QLDB) qldb QLDB
Сеанс Amazon QLDB qldb-сессия QLDBS
Amazon QuickSight quicksight QS
AWS Resource Access Manager ползун RAM
Amazon Relational Database Service патронов RDS
Amazon Relational Database Service rds-data RDSD
Amazon Redshift красное смещение RS
Amazon Redshift данные красного смещения RSD
Amazon Rekognition признание РЭК
Группы ресурсов AWS ресурсных групп RG
AWS Resource Groups Tagging resourcegroupstaggingapi RGT
AWS RoboMaker робот-робот ROBO
Amazon Route 53 маршрут53 R53
Amazon Route 53 Домены route53domains R53D
Amazon Route 53 Resolver route53резольвер R53R
Amazon S3 с3 S3 * В настоящее время не удалось создать список…
Amazon S3 s3api S3 * В настоящее время не удалось создать список…
Amazon S3 s3control S3C
Amazon S3 на аванпостах s3 аванпосты S3O
Amazon SageMaker шалфей СМ
Amazon Augmented AI sagemaker-a2i-время выполнения A2IR
Amazon SageMaker Edge Manager кромка sagemaker МСБ
Магазин функций Amazon SageMaker sagemaker-featurestore-runtime СМФС
Amazon SageMaker среда выполнения sagemaker SMR
Планы экономии AWS планов экономии SP
Схемы AWS EventBridge схемы СЧМ
Amazon SimpleDB SDB
AWS Secrets Manager менеджер секретов SEC
AWS Security Hub ступица безопасности КОЛПАЧОК
Репозиторий бессерверных приложений AWS без сервера, репо SAR
Квоты на обслуживание AWS сервисных квот SQ
Сервисный каталог AWS каталог услуг SC
Реестр приложений AWS Service Catalog сервискаталог-приложениереестр SCAR
Amazon Route 53 Автоматическое именование сервисное открытие SD
Amazon Simple Email Service ses SES
Amazon Simple Email Service V2 sesv2 SES2
AWS Shield щит SHLD
AWS Signer подписант
AWS Sever Migration Service смс SMS
AWS Snowball снежок СНЕГ
Amazon Simple Notification Service sns СНС
Amazon Simple Queue Service кв.м. SQS
AWS Systems Manager ССМ SSM
Контакты менеджера систем AWS ssm-контакты SMC
AWS Systems Manager Incident Manager ssm-инцидентов SSMI
AWS Single Sign-On sso ССО
AWS Single Sign-On sso-admin SSOADMN
AWS Single Sign-On OIDC sso-oidc SSOOIDC
AWS Step Functions ступенчатые функции SFN
AWS Storage Gateway шлюз для хранения SG
AWS Security Token Service пет СТС
Поддержка AWS поддержка ASA
Amazon Simple Workflow swf SWF
Amazon CloudWatch Synthetics синтетика CWSYN
Amazon Textract текстракт TXT
Amazon Timestream запрос временного потока TSQ
Amazon Timestream запись временного потока TSW
Amazon Transcribe расшифровать TRS
Перенос AWS для SFTP передача СКР
Amazon Translate перевести TRN
AWS WAF ваф WAF
AWS WAF Regional waf-региональный WAFR
AWS WAF V2 wafv2 WAF2
Инструмент AWS Well-Architected Tool хорошоархитектура WAT
Amazon WorkDocs рабочие документы WD
Amazon WorkLink рабочая ссылка WL
Amazon WorkMail рабочая почта WM
Поток сообщений Amazon WorkMail рабочая почта поток сообщений WMMF
Amazon WorkSpaces рабочих мест WKS
AWS X-Ray рентген XR
.

Добавить комментарий

Ваш адрес email не будет опубликован.