Powershell логические операторы: о логических операторах — PowerShell

Введение в операторы сравнения в PowerShell

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

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

Windows PowerShell использует приведенные ниже операторы сравнения и по умолчанию они не чувствительны к регистру. Чтобы выполнить операцию с учетом регистра, просто наберите ‘c’ перед операторами ниже. Например, -clike, -cne, -ceq и т. Д.

Примеры реализации операторов сравнения

Вот несколько примеров операторов сравнения, приведенных ниже с примерами:

1. –экв .: равно

Этот оператор используется для проверки равенства между значениями. Они должны точно соответствовать, и это без учета регистра. Выход будет True или False. Например,

Вы также можете сравнить два разных типа данных.

Вы можете сравнить несколько значений с одним значением.

Если вы используете оператор –ceq, то сравнение будет чувствительным к регистру.

2. –ne: не равно

Это противоречит равенству операции. Если значение совпадает, то оно вернет FALSE, иначе вернет TRUE.

Для нескольких значений

3. –gt: больше чем

Он сравнивает значение своей левой стороны с правой стороной, и вывод будет ИСТИНА или ЛОЖЬ на основе значений. В приведенном ниже примере он сравнивает 5 с 6 и проверяет, больше ли оно 6, и выдает ответ FALSE.

Когда вы сравниваете два символа, он проверяет свое значение ASCII и предоставляет результаты на его основе. ASCII-значение «а» равно 97, а «с» равно 99, поэтому «с» больше, чем «а». В результате второе предложение ИСТИНА.

Если вы сравниваете несколько символов вместе, он проверит значение ASCII первых символов с обеих сторон и даст соответствующие результаты. Например,

В приведенном выше первом предложении значение ASCII «d» больше, чем «a», а во втором предложении значение ASCII «a» меньше, чем «b». Для сравнения нескольких значений.

4. –ge: больше чем равно

Проверяет, является ли значение левой стороны больше или равно значению правой стороны.

5. –lt: меньше чем

Проверьте, меньше ли значение левой стороны, чем значение правой стороны.

6. –le: меньше или равно

Проверяет, меньше ли значение левой части, чем значение правой части.

7. –Как

Соответствует левой части значения правому значению с подстановочным знаком (*).

Подстановочный знак (*) при применении проверяет, содержится ли деталь в строке или нет. Если он применяется после определенного значения (т. Е. This *), то он проверяет, существует ли эта строка слово + преемник или нет. В первом примере.

• Слово: это
• Строка-преемник: это Powershell

Если применяется перед конкретным словом, то проверяется, существует ли конкретное слово + строка приоритета или нет. Во втором примере.

• Слово: Powershell
• Прецедентная строка: это

В третьем примере подстановочный знак (*) применяется после слова «Powershell», и слово совпадает, но нет строки-преемника, поэтому вывод False. В четвертом примере подстановочный знак (*) применяется с обеих сторон, поэтому он проверяет, существует ли строка до или после нее, другими словами, упомянутое слово является частью этой строки. Таким образом, здесь вывод ИСТИНА.

8. –Не нравится

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

9. –Матч

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

$ совпадений

Имя Значение

—— —–

0 прибывающих

Чтобы соответствовать хотя бы одному из символов, поместите их в ().

В приведенном выше примере символ «с» совпадает. Соответствовать хотя бы одному из символов в непрерывном диапазоне (диапазоне).

Здесь от символов n до r (без учета регистра) будут проверяться строки, а ‘o’ и ‘p’ совпадают. Следовательно, вывод ИСТИНА.

10. –NotMatch

В отличие от оператора Match. Если совпадение найдено, возвращается false или наоборот.

Имя Значение

—— —–

0 прибывающих

11. -Содержит

Сообщает, включает ли коллекция эталонных значений точное (без учета регистра) одно значение. Если да, то возвращает TRUE, иначе FALSE.

Синтаксис:

-Contains

Приведенный выше вывод — FALSE, потому что левая сторона содержит два значения. Но если вы сохраните их в переменную и сопоставите их, результат будет TRUE.

Для операций с учетом регистра используйте оператор –ccontains.

12. –notContains: оператор сдерживания (в отличие от Contains)

Если тестовое значение точно соответствует набору контрольных значений, тогда выводится FALSE. В противном случае вывод TRUE.

13. -в

Как и в случае с оператором контейнера, только синтаксис меняется на противоположный. — в операторе был представлен Powershell 3.0. Если тестовое значение соответствует контрольным значениям, тогда возвращается ИСТИНА, иначе ЛОЖЬ.

Синтаксис:

-in

В приведенном выше примере «Shell» не совсем совпадает с Powershell.

14. –notin: не в операторе (в отличие от оператора -in)

Если тестовое значение точно соответствует эталонному значению, тогда оно возвращает FALSE, иначе TRUE.

15. –Замена: изменяет указанное значение

Синтаксис:

-replace,

Заменить значение в переменной

16. Другие подобные операторы

Есть другие подобные операторы, как указано ниже.

а. Битовые операторы

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

Рекомендуемые статьи

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

1. Операторы PowerShell
2. Строковые функции PowerShell
3. Операторы сравнения в JavaScript
4. Команды PowerShell
5. Массив в PowerShell с примерами

Условия в PowerShell « Марк и Марта.Ру. Записки отца-программиста

Условия в PowerShell

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

В отличие от многих языков программирования, в PowerShell отказались от использования символов «>», «<» или «=», заменив их выражениями –gt; -lt; -eq. Сначала идет знак «-», потом псевдокоманда eq – equal, gt – greater than, lt – less then.

Ниже в таблице приведен список базовых операторов сравнения.

$myvar = "This is an old string"
$myvar | ForEach-Object {$_ -replace "old", "new"} | Set-Content $myvar

Write-Host "Результат: " + $myvar

В результате будет выдано:

Результат:  + This is an old string

Для сравнения с учетом регистра к команде подставляется префикс «c». Для примера, оператор -eq с зависимостью от регистра изменяется на «-ceq».

Для явно заданного независящего от регистра сравнения к команде подставляется префикс «i». Пример: оператор -replace без зависимости от регистра будет -ireplace

Типы

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

Арифметические операторы в Windows PowerShell 5

• Арифметические операторы в Windows PowerShell 5.

• Операторы присваивания в Windows PowerShell 5.

• Операторы сравнения в Windows PowerShell 5.

• Операторы сравнения и коллекции в Windows PowerShell 5.

• Операторы сравнения шаблона в Windows PowerShell 5.

• Регулярные выражения в Windows PowerShell 5.

• Операторы управления текстом в Windows PowerShell 5.

• Логические и побитовые операторы в Windows PowerShell 5.

• Методы Where() и ForEach() в Windows PowerShell 5.

Сегодня я представляю вашему вниманию первый веб-каст данной группы, в котором вы найдете описание операторов в целом и арифметических операторов в частности, а также демонстрации их применения в выражениях. Центральное место в веб-касте занимает оператор сложения (+) и его использование с числами, строками, хеш-таблицами и массивами (коллекциями), также рассматривается вопрос использования оператора сложения и разных типов данных. Не менее важное место занимает оператор умножения (*) и его использование с числами, строками и массивами (коллекциями). Дополнительно в веб-касте продемонстрированы операторы вычитания (—), деления (/) и вычисления модуля (%).

о логических операторах — PowerShell

• 27.09.2021
• 2 минуты на чтение

В этой статье

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

Описывает операторы, которые соединяют операторы в PowerShell.

Длинное описание

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

Например, в следующем операторе используются операторы and и or. соединить три условных оператора. Утверждение верно только тогда, когда значение $ a больше, чем значение $ b, и либо $ a, либо $ b меньше, чем 20.

  ($ a -gt $ b) -and (($ a -lt 20) -or ($ b -lt 20))
  

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

Примечание:

В предыдущих примерах также используется оператор сравнения -eq . Для дополнительную информацию см. about_Comparison_Operators.Примеры также используйте логические значения целых чисел. Целое число 0 имеет значение FALSE. Все другие целые числа имеют значение ИСТИНА.

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

  <заявление> {-И | -ИЛИ | -XOR} <утверждение>
{! | -NOT} <заявление>
  

Операторы, использующие логические операторы, возвращают логическое значение (ИСТИНА или ЛОЖЬ) ценности.

Логические операторы PowerShell оценивают только утверждения, необходимые для определить истинность утверждения.Если левый операнд в операторе , который содержит оператор и, является ЛОЖЬ, правый операнд не оценивается. Если левый операнд в операторе, содержащем оператор или, имеет значение ИСТИНА, правый операнд не оценивается. В результате вы можете использовать эти операторы в так же, как вы использовали бы оператор If .

См. Также

О компании_Операторы

Сравнить-Объект

about_Comparison_operators

о_Иф

логических операторов PowerShell — Javatpoint

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

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

1. -и (логическое И)
2. -или (логическое ИЛИ)
3. -xor (логический XOR)
4. -нет (логическое НЕ)
5. ! (То же, что и логическое НЕ)

-и (логическое И)

Оператор AND — это логический оператор, который возвращает логическое значение ИСТИНА, , если оба условия правильные в выражении.

Пример: В следующем примере описывается, как использовать логический оператор И:

$ a = 10 $ b = 20 ($ a -lt $ b) -и ($ a -eq 10)

Последняя команда в этом примере отображает логическое значение ИСТИНА , потому что оба условия верны.

-или (логическое ИЛИ)

Оператор ИЛИ — это логический оператор, который возвращает логическое значение ИСТИНА , если хотя бы одно из условий в выражении — правильно .

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

$ a = 5 $ b = 30 ($ a -lt $ b) -или ($ a -eq 11)

Последняя команда в этом примере отображает логическое значение ИСТИНА , потому что первое условие в этом операторе правильное.

-xor (логический XOR)

Оператор XOR — это логический оператор, который возвращает логическое значение ИСТИНА , если только одно условие правильное в выражении.Если в выражении верны несколько операторов, этот оператор возвращает FALSE .

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

$ a = 5 $ b = 30 ($ a -lt $ b) -xor ($ a -eq 11) -xor ($ b -eq 30)

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

-не (логическое НЕ)

Оператор НЕ — это логический оператор, который дает результат, противоположный выражению.Если выражение дает значение ИСТИНА , тогда этот оператор вернет ЛОЖЬ и наоборот.

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

$ a = 5 $ b = 30 -not ($ b -eq 30)

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

! (То же, что и логическое НЕ)

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

Пример: В следующем примере описывается, как использовать этот оператор:

$ a = 5 $ b = 30 ! ($ a -gt $ b)

Последняя команда в этом примере отображает логическое значение ИСТИНА , потому что в выражении условие неверно, но этот оператор меняет результат на противоположный.

Возможности логических операторов PowerShell

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

О логических операторах PowerShell

Логические операторы в PowerShell проверяют несколько условий, указанных в инструкции или выражении PowerShell. Например, проверка наличия двух файлов на сервере перед выполнением действия является логической операцией.Если вы хотите проверить, существуют ли две службы на сервере, прежде чем вы сможете выполнить действие, это также логическая операция. Другой пример: вы хотите запустить две службы Windows на компьютере, только если двоичные файлы служб существуют на компьютере. Теперь есть два способа проверить эти условия: 1) вы можете использовать несколько условий IF или 2) использовать логический оператор в операторе PowerShell. Приведенные ниже операторы IF могут помочь вам проверить условия без использования логических операторов:

• IF {Test-Path -Path «C: \ Temp \ Service1File.EXE ”)
• IF {Test-Path -Path «C: \ Temp \ Service2File.EXE»}
• Действуйте здесь

Как видно из приведенных выше операторов PowerShell, первое условие IF проверяет, существует ли C: \ Temp \ Service1File.EXE. Если это условие выполняется, выполняется следующий оператор IF (который должен проверить наличие C: \ Temp \ Service2File.EXE). Без логических операторов ваш сценарий PowerShell может быть длинным. Другими словами, вам придется потратить много времени на написание нескольких строк кода.Теперь давайте посмотрим на приведенный ниже оператор IF.

• IF {Test-Path -Path «C: \ Temp \ Service1File.EXE» –И Test-Path -Path «C: \ Temp \ Service2File.EXE»}
• Действуйте здесь

Как видно из приведенного выше оператора IF, мы используем «-AND», который на самом деле является логическим оператором. «-AND» указывает оператору IF на проверку обоих условий и выполнение « Take Action Here » только в том случае, если оба условия выполняются.Логические операторы весьма удобны и сокращают накладные расходы на написание сценариев.

Подключение операторов PowerShell

Мы используем логические операторы, чтобы вы могли подключать операторы PowerShell, которые, в свою очередь, позволяют использовать один оператор / выражение PowerShell для проверки нескольких условий. Например, приведенная ниже команда PowerShell использует оператор IF и может проверять два условия в одном операторе.
IF {$ ThisVM -eq «TestVM» –и $ ThisVMStatus –eq «Running»}
Как вы можете видеть в приведенной выше команде, мы проверяем, является ли виртуальная машина, хранящаяся в $ ThisVM, «TestVM» И убедитесь, что виртуальная машина работает.”Состояние виртуальной машины хранится в переменной $ ThisVMStatus. Точно так же, прежде чем команда PowerShell проверит, является ли сервер контроллером домена, дисковое пространство на диске C: \ должно быть не менее 10 ГБ.
IF {$ ThisServer -eq «Контроллер домена» –and $ DiskSpace –gt 10}
И если вы посмотрите на команду PowerShell ниже, она отличается от предыдущих команд PowerShell.
IF {$ ThisServer -eq «Контроллер домена» –ИЛИ $ ThisServer –eq «Рядовой сервер»}
Приведенная выше команда PowerShell должна гарантировать выполнение только одного условия из двух.Если переменная $ ThisServer содержит значение «Контроллер домена» или «Рядовой сервер», это означает, что условие выполнено.

Вы могли заметить использование «-И» и «-ИЛИ» в командах PowerShell. Они называются логическими операторами. «-И» используется, когда вам нужно убедиться, что все условия, указанные в инструкции / выражении PowerShell, ИСТИНА. В то время как «-ИЛИ» используется, когда вам нужно убедиться, что из множества указанных условий только одно условие является ИСТИННЫМ. Хотя в PowerShell есть четыре логических оператора, большую часть времени вы будете работать с логическими операторами «-И» и «-ИЛИ».

В этой таблице содержится описание логических операторов.

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

Команда 1: Результатом будет «Истина», поскольку выполняются оба условия.
(1 -eq 1) -and (2 -eq 2)
Command 2: Результатом будет «True», даже если оба условия не выполняются, потому что мы используем логический оператор «-OR».
(1 -eq 1) -or (1 -eq 2)
Command 3: Результатом будет «False», потому что оба условия не выполнены.
(1-экв 2) -и (1-экв 2)

Маленькие изящные устройства для экономии времени

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

Просмотры сообщений: 16 304

Другие статьи об основах PowerShell

Использование операторов PowerShell

Использование операторов PowerShell

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

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

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

Переменные часто используются в PowerShell и создаются с помощью оператора присваивания. Простейшим примером оператора присваивания является знак равенства ( = ), который используется для присвоения переменной. Здесь я присваиваю строку переменной $ Testvar:

  $ Testvar = 'Это строка'
  

Чтобы добавлять и удалять элементы для переменной, используйте операторы сложения-равно ( + = ) и вычитания-равно (? = ).В этом примере я сначала назначаю 1 $ a , затем добавляю 2 и удаляю 1 , что оставляет переменную со значением 2 .

  PS C: \> $ a = 1
PS C: \> $ a + = 2
PS C: \> $ a - = 1
PS C: \> $ a
2
  

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

  PS C: \> $ a.GetType ()
IsPublic IsSerial Имя
-------- -------- ----
Истина Истина Int32
  

Чтобы показать более стандартные арифметические операторы, а также то, как PowerShell дает приоритет, рассмотрим следующий пример. Сначала операция в круглых скобках обрабатывается ( 10-1 ), чтобы получить значение 9 . Затем 1 умножается на 5 , а затем 2 и 5 складываются. Наконец, эта сумма ( 7 ) складывается с 9 , чтобы получить результат 16 .

  PS C: \> 2 + 1 * 5 + (10-1) 16
  

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

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

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

Чтобы проиллюстрировать это, давайте сравним две переменные друг с другом.

  $ а = 5
$ b = 5
if ($ a -eq $ b) {
    "Они равны!"
}
еще{
    «Они не равны».
}
  

Поскольку $ a и $ b равны, на выходе будет Они равны!

В следующем примере два объекта даты сравниваются с оператором больше, чем , то есть -gt . Переменная $ Today получает немедленную дату и время, а $ Yesterday используется с методом AddDays для установки даты и времени на предыдущий день.Если вы скопируете и вставите его в консоль PowerShell, отобразится правильный результат, как на рис. 1 :

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

В таблице 1 показаны дополнительные примеры операторов равенства в PowerShell.

Операторы сопоставления в PowerShell используются для сравнения строк как с подстановочными знаками, так и с регулярными выражениями, чтобы найти совпадение.В этой категории четыре оператора: — как , — не как , — сопоставление, и — не совпадает, . В этом следующем фрагменте я создаю цикл foreach и просматриваю каждый процесс, запущенный в моей локальной системе, чтобы увидеть, соответствует ли какое-либо совпадение «Drop *», используя подстановочный знак.

  foreach ($ Process в Get-Process) {
    if ($ Process.Name -like "Drop *") {
        $ Process.Name
    }
}
Dropbox
Dropbox Web Hel
  

Выходные данные соответствуют процессам Dropbox и Dropbox Web Helper.

Для замены части значения в строке другой строкой используется оператор «-replace».

Операторы ограничения помогают определить, содержит ли коллекция объектов определенное значение, и если да, то после первого нахождения значения возвращает логическое значение. Например, -contains используется для поиска процесса «powershell» в списке процессов. В этом примере процесс «powershell» встречается дважды в списке процессов; «Истина» возвращается после обнаружения первого экземпляра.

  PS C: \> Get-Process powershell |
Выбрать имя объекта, идентификатор
Идентификатор имени
---- -
PowerShell 7300
PowerShell 22744
PS C: \> (Get-Process) .Name -содержит
"PowerShell"
Правда
  

Подобно -содержит и -notcontains операторов, PowerShell также предоставляет -in и -notin, , хотя они работают практически одинаково. Единственная разница — это порядок, в котором они используются по отношению к значению сбора и проверки.С -notin, перед сбором необходимо использовать контрольное значение:

  PS C: \> "powershell" -notin (Get-Process) .Name
Ложь
  

Для замены части значения в строке другой строкой используется оператор -replace . Простым примером является следующий фрагмент, который заменяет строку this на this. Обратите внимание, что первый параметр после -replace — это значение, которое нужно найти, а второй — значение, на которое его нужно заменить.

  PS C: \> "Только замените это."-заменить" это. "," то ".
Только замените это.
  

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

В PowerShell логические операторы используются для соединения и проверки нескольких выражений и операторов. Логические операторы отлично подходят, если требуется тестирование сложных выражений. Здесь вывод Get-Process передается по конвейеру Where-Object и фильтруется с помощью оператора -and для подключения для поиска процессов, которые начинаются с Drop и не запускаются с Dropbox Web .В результате Where-Object отфильтровывает процесс Dropbox Web Helper, но не Dropbox и DropboxUpdate, как показано на рис. 2 .

Два других логических оператора: -или и -не (которые также могут использоваться как ! ). В этом операторе if проверяется условие, если процесс «foo» или «powershell» не работает с Get-Process , на выходе возвращается True.Поскольку процесс «foo» не запущен (хотя процесс «powershell» запущен), вывод будет True.

  PS C: \> Get-Process powershell | Select-Object -Property ProcessName
Имя процесса
-----------
Powershell
PS C: \> if (-not (Get-Process foo) -or! (Get-Process powershell)) {
    "Правда"
}
еще {
    "Ложь"
}
Правда
  

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

  PS C: \> if (-not (Get-Process foo) -and! (Get-Process powershell)) {
    "Правда"
}
еще {
    "Ложь"
}
Ложь
  

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

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

Операторы разбиения и объединения

Для разделения и объединения строк в PowerShell используются операторы -split и -join . Эти два оператора очень часто используются в сценариях PowerShell, потому что этот тип операции необходим для управления строками. Простой пример — взять строку, отформатированную в предложение, и использовать -split для разделения строки на каждом пустом месте.

  PS C: \> «Это тестовое предложение на раскол»
-расколоть ' '
Этот
является
а
тестовое задание
приговор
к
расколоть
  

Чтобы лучше всего проиллюстрировать оператор -join , предыдущее строковое предложение можно поместить в переменную, а затем объединить для образования исходной строки.Обратите внимание, что разделитель после оператора -join — «», обозначающий пробел между строками.

  PS C: \> $ a = "Это тестовое предложение на разбиение"
-расколоть ' '
PS C: \> $ a -join ''
Это тестовое предложение разделить
  

Другой вариант использования -split — это добавление блока сценария после оператора. Например, чтобы разделить строку через запятую или точку, можно использовать оператор -или . На рис. 3 строка в $ test разбита именно таким образом.

Для разделения и присоединения строк к PowerShell используются операторы «-split» и «-join».

Сводка

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

Общие сведения об операторах сравнения PowerShell на примере

Как и многие другие языки программирования, PowerShell имеет различные операторы сравнения. Однако, в отличие от других языков, эти операторы сравнения могут выглядеть немного странно.Вместо == у вас будет экв . Вместо <> будет ne . Это может сбивать с толку новичков. Давайте рассмотрим операторы сравнения PowerShell в этой статье.

Тестирование на равенство с операторами

Чтобы проверить, равен ли один объект другому объекту в PowerShell, используется оператор eq . Оператор eq сравнивает простые объекты многих типов, такие как строки, логические значения, целые числа и т. Д.При использовании оператор eq либо вернет логическое значение True , либо False в зависимости от результата.

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

В следующем примере вы можете видеть, что мы присваиваем значение PowerShell переменной $ string .Затем, используя оператор eq , в примере сравнивается значение $ строка со строкой powershell . Достаточно просто, правда? Но подождите, это не на самом деле то же самое.

  PS> $ string = "PowerShell"
PS> $ string -eq "powershell"
Правда  

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

Тестирование чувствительности к регистру с помощью

В приведенном выше примере обратите внимание, как eq вернул логическое значение True выше, даже если строка не была точно такой же. Это происходит из-за того, что оператор eq нечувствителен к регистру. Чтобы проверить равенство с учетом регистра, используйте оператор ceq . Оператор ceq точно такой же, как eq , за исключением того, что он чувствителен к регистру.

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

  PS> $ string -ceq "PowerShell"
Правда
PS> $ string -ceq "powershell"
Ложь  

Тестирование на неравенство с

  PS> $ string = "PowerShell"
PS> $ string -ne "PowerShell"
Ложь
PS> $ string -cne "PowerShell"
Ложь
PS> $ string -cne "powershell"
Правда  

  PS> массив $ [электронная почта защищена] (1,2,3,4,5,6,7,8,9,9,9,9)
PS> $ array -eq 9
9
9
9
9
PS> ($ array -eq 9) .Count
4  

  PS> массив $ = @ (2,4,5,6,8,8,9,9,9)
PS> $ array -содержит 9
Правда
PS> $ array -notcontains 9
Ложь
PS> $ array -содержит 5  

  $ массив = @ (2,4,5,6,8,8,9,9,9)
9 -в $ массиве
Правда
9 -notin $ array
Ложь  

  PS> 7-GT 5
Правда
PS> 7-GT 7
Ложь
PS> 7 -ge 7
Правда  

  PS> массив $ [электронная почта защищена] (1,2,3,4,5,6,7,8,9,9,9,9)
PS> $ array -gt 5
6
7
8
9
9
9
9
PS> $ массив -ge 5
5
6
7
8
9
9
9
9  

  PS> массив $ [электронная почта защищена] (1,2,3,4,5,6,7,8,9,10)
PS> $ array -lt 5
1
2
3
4
PS> $ array -le 5
1
2
3
4
5  

  PS> $ string = "PowerShell"
PS> $ string-like "* Shell"
Правда
PS> $ array = @ ("PowerShell", "Microsoft")
PS> $ array-like "* Shell"
PowerShell
PS> $ array -clike "* Shell"
PowerShell  

  $ string = "PowerShell"
$ string -notlike "* Shell"
Ложь
$ array = @ ("PowerShell", "Microsoft")
$ array -notlike "* Shell"
Microsoft
$ array -cnotlike "* оболочка"
PowerShell
Microsoft  

  PS> $ string = "PowerShell"
PS> $ string -match "ow"
Правда

PS> $ array = @ ("PowerShell", "Microsoft")
PS> $ array -match "ow"
PowerShell

PS> $ string = "PowerShell"
PS> $ string -cmatch "po"
Ложь
PS> $ string -cmatch "Po"
Правда

PS> $ array = @ ("PowerShell", "Microsoft")
PS> $ array -cmatch "Po"
PowerShell  

 PS> (dir) .Count -ge 4
Истинно 

 PS> "Hello World" - матч "H. * World"
True 

 PS> "Hello World" - матч "Hello"
Правда
PS> "Hello World" - матч 'Hello $'
Ложь 

  -ceq ,  -cne ,  -cge ,  -cgt ,  -cin ,  -clt ,  -cle ,  -clike ,  - cnotlike ,
  -cmatch ,  -cnotmatch ,  -ccontains ,  -cnotcontains  

 PS> $ data = "Hello World"
PS> ($ data -like "* llo W *") -and ($ data.Length -gt 10)
Правда
PS> ($ data -like "* llo W *") -and ($ data.Длина -gt 20)
Ложь 

  $ а = 10
$ b = 10

$ a -eq $ b
  

  $ а = 10
$ b = 11

$ a -eq $ b
-not ($ a -eq $ b)
$ a -ne $ b
  

  $ а = 10
$ b = 11
$ a -lt $ b
$ b -gt $ a
  

  10 -ле 10
9 -ле 10
11 -ge 10
10 -ge 10
  

  $ str1 = "Привет"
$ str2 = "привет"
$ str1 -eq $ str2
$ str1 -ceq $ str2
$ str1 -ieq $ str2
  

  $ приветствие = "Привет, Боб, с тобой все в порядке?"
$ name = "Боб"
$ приветствие -match $ name
  

  $ совпадений
  

  $ правда
$ false

$ истина -не $ ложь
(10 -экв 11) -экв $ ложь

0 -экв $ ложь
1-экв. $ Истина
2-экв. $ Истина

$ false -eq 0
$ true -eq 1
$ true -eq 2

[int] $ true
[логическое] 2

[логическое] 2 -eq [логическое] $ true

"" -eq $ false
$ false -eq ""

[логическое] ""
[строка] $ false
  

  $ нет в наличии
$ notexisting -eq $ false
$ notexisting -eq $ true
$ notexisting -eq $ null
  

  $ а = 10
($ a -gt 5) -и ($ a -lt 100)
($ a -lt 20) -или ($ a -gt 100)
  

  [число] $ a = 3
[int] $ b = 5

if ($ a -eq $ b) {
    write-host "Они такие же"
} еще {
    write-host "Они не такие"
}
  

  [число] $ a = 3

if ($ a -eq 3) {
    write-host "А - три"
} elseif ($ a -eq 2) {
    write-host "А - два"
} еще {
    write-host "Я не знаю, как писать $ a"
}
  

  [число] $ a = 3

switch ($ a) {
    1 {
        write-host "A - это один"
    }
    2 {
        write-host "А - два"
    }
    3 {
        write-host "А - три"
    }
    дефолт {
        write-host "Я не знаю $ a"
    }
}
  

  $ i = 0
while ($ i -lt 10) {
    write-host "Шаг $ i"
    $ i ++
}
  

  для ($ i = 0; $ i -lt 10; $ i ++) {
    write-host "Повторение $ i"
}