Операторы сравнения в PowerShell. Powershell операторы сравнения
Условия в PowerShell « Марк и Марта.Ру. Записки отца-программиста
Условия в PowerShell
Операторы сравнения
В отличие от многих языков программирования, в PowerShell отказались от использования символов «>», «<» или «=», заменив их выражениями –gt; -lt; -eq. Сначала идет знак «-», потом псевдокоманда eq – equal, gt – greater than, lt – less then.
Ниже в таблице приведен список базовых операторов сравнения.
| Команда | Значение на английском | Значение на русском |
| -eq | Equal | Равно |
| -ne | Not equal | Не Равно |
| -ge | Greater than or equal | Больше или Равно |
| -gt | Greater than | Больше |
| -lt | Less than | Меньше |
| -le | Less than or equal | Меньше или Равно |
| -like | Wildcard comparison | Поиск соответствия символов по заданному образцу, аналог SQL-ного LIKE |
| -notlike | Wildcard comparison | Поиска несоответствия символов образцу |
| -match | Regular expression comparison | Поиск соответствия образцу с использованием регулярных выражений |
| -notmatch | Regular expression comparison | Поиск несоответствия образцу с использованием регулярных выражений |
| -replace | Replace operator | Заменяет часть или все значение слева от оператора. Очень своеобразный оператор |
| -contains | Containment operator | Определение, содержит ли значение слева от оператора значение справа. Возвращает $true или $false |
| -notcontains | Containment operator | Определение того, что значение слева от оператора не содержит значение справа. Возвращает $true или $false |
$myvar = "This is an old string" $myvar | ForEach-Object {$_ -replace "old", "new"} | Set-Content $myvar Write-Host "Результат: " + $myvar
$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
Типы
| -is | Является типом |
| -isnot | Не является типом |
| -as | Как тип, без ошибки если возникает неудача преобразования |
Логические операторы PowerShell
| -and | Оба условия должны быть истины, чтобы выражение было истинно |
| -or | Одно или оба условия должны быть истины, чтобы выражение было истинно |
| -xor | Одно условие должно быть истинно, а второе должно иметь значение "ложь", чтобы выражение было истинно |
| -not | Указанные условия должны иметь значение "ложь", чтобы выражение было истинно |
| ! | Указанное условие должно иметь значение "ложь", чтобы выражение было истинно |
markimarta.ru
Операторы сравнения в PowerShell | Digital Cub — это я.
В powershell операторы сравнения отличаются от принятой номенклатуры используемой в других языках.Все популярные операторы сведены к нескольким таблицам
by Gistek
По умолчанию все операторы сравнения не являются чувствительными к регистру.
| -eq | Equal | Равно |
| -ne | Not equal | Не Равно |
| -ge | Greater than or equal | Больше или Равно |
| -gt | Greater than | Больше |
| -lt | Less than | Меньше |
| -le | Less than or equal | Меньше или Равно |
| -like | Wildcard comparison | |
| -notlike | Wildcard comparison | Использование символов подстановки для поиска несоответствия образцу |
| -match | Regular expression comparison | Использование регулярных выражений для поиска соответствия образцу, например Regexp для IP-адреса такой: «\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}» (правда он не распознает невалидные адреса, но это уже проблема логики скрипта, а не Regexp’а) |
| -notmatch | Regular expression comparison | Использование регулярных выражений для поиска несоответствия образцу. Подробнее про regexp в powershell можно почитать на Technet |
| -replace | Replace operator | Заменяет часть или все значение слева от оператора |
| -contains | Containment operator | Определение, содержит ли значение слева от оператора значение справа. В отличие от предыдущих операторов, результатом является булево значение |
| -notcontains | Containment operator | Определение того, что значение слева от оператора не содержит значение справа. Результатом является булево значение |
Для сравнения с учетом регистра к команде подставляется префикс “c“. Для примера, оператор -eq с зависимостью от регистра изменяется на “-ceq”.
Для явно заданного независящего от регистра сравнения к команде подставляется префикс “i“. Пример: оператор -replace без зависимости от регистра будет -ireplace
Типы
| -is | Является типом (e.g. $a -is [int] ) |
| -isnot | Не является типом (e.g. $a -isnot [int] ) |
| -as | Как тип, без ошибки если возникает неудача преобразования (e.g. 1 -as [string] treats 1 as a string ) |
Логические операторы PowerShell
| -and | Оба условия должны быть истины, чтобы выражение было истинно (e.g. ($a -ge 5 -AND $a -le 15) ) |
| -or | Одно или оба условия должны быть истины, чтобы выражение было истинно (e.g. ($a –eq “A” –OR $a –eq “B”) ) |
| -xor | Одно условие должно быть истинно, а второе должно иметь значение “ложь”, чтобы выражение было истинно |
| -not | Указанные условия должны иметь значение “ложь”, чтобы выражение было истинно |
| -band | binary and |
| -bor | binary or |
| -bnot | binary not |
| ! | Указанное условие должно иметь значение “ложь”, чтобы выражение было истинно |
| .. | Range operator (e.g. foreach ($i in 1..10) {$i } ) |
| & | call operator (e.g. $a = “Get-ChildItem” &$a executes Get-ChildItem) |
| . (dot followed by a space) | call operator (e.g. $a = “Get-ChildItem” . $a executes Get-ChildItem in the current scope) |
| -F | Format operator (e.g. foreach ($p in Get-Process) { “{0,-15} has {1,6} handles” –F $p.processname,$p.Handlecount } ) |
dcub.ru
Windows PowerShell: Windows PowerShell Constructs
- 08/19/2016
- Время чтения: 9 мин
В этой статье
Windows PowerShell Конструкции языка сценариев Windows PowerShell
Дон Джонс (Don Jones)
В прошлом месяце я показывал несколько способов использования Windows PowerShell для незамедлительного решения администраторских задач без написания каких бы то ни было сценариев. Но хоть Windows PowerShell и превосходна в роли интерактивной оболочки, выжать из неё максимум и автоматизировать более сложные задачи можно только с использованием простого, но мощного языка сценариев.
Вы можете задаться вопросом – а нужен ли был Майкрософт ещё один язык сценариев? В конце концов, она уже создала KiXtart, процессор сценариев входа, да и Visual Basic® Scripting Edition (VBScript). Ответ, однако же, "да". Майкрософт был нужен ещё один язык сценариев. Я объясню почему.
Язык Windows PowerShell™ должен был быть простым и интуитивно понятным, так, чтобы администраторы могли овладеть им без глубокого обучения. Он также должен был быть достаточно гибким, чтобы вобрать всю мощную функциональность, которую Windows PowerShell предоставляет пользователю.
Поскольку Windows PowerShell основана на Microsoft® .NET Framework, синтаксис её сценариев должен был быть совместим с .NET. Создавая этот язык, разработчики остановились на синтаксисе, в целом представляющим собой очень упрощённый C# (произносится "си-шарп"; один из языков, поставляемых с .NET Framework). Почему не оставить синтаксис, подобный VBScript? Отличия языка Windows PowerShell от VBScript не настолько уж велики, но при этом PowerShell даёт определённый толчок в изучении программирования под .NET Framework благодаря синтаксису, напоминающему C#. Если вы решите перейти на Visual Studio® и начать создавать приложения на C#, полученное благодаря сценариям Windows PowerShell знание синтаксиса вам пригодится.
Одна из самых важных частей языка сценариев Windows PowerShell — да и любого другого языка сценариев — его конструкции. Это элементы языка, позволяющие выполнить логическое сравнение и предпринять различные действия в зависимости от его результата, или дающие возможность повторять одну или несколько команд снова и снова.
Размышляя логически
Логические сравнения лежат в основе многих языков сценариев, и Windows PowerShell не исключение. При любом сравнении оцениваются два значения или объекта и определяется результат - True (истина) или False (ложь). К примеру, можно задаться вопросом: "Срок действия пароля этого пользователя истекает сегодня?". Результатом будет либо True, если две даты совпадают, либо False, если они различны. Я пишу True и False с большой буквы, поскольку это термины Windows PowerShell.
Вот небольшой пример логического сравнения, которое можно предпринять при помощи Windows PowerShell:
PS C:\> $a = 1 PS C:\> $b = 2 PS C:\> $a -eq $b FalseЗдесь я создаю переменную с именем $a и присваиваю ей значение 1. В Windows PowerShell имена переменных всегда начинаются со знака доллара, так что их легко отличить. Знак "=" называется оператором присваивания, поскольку используется для присваивания значения. Затем я создаю вторую переменную, $b, и присваиваю ей значение 2. А затем происходит и само логическое сравнение — я прошу Windows PowerShell сравнить содержимое $a и $b при помощи оператора равенства -eq. PowerShell производит сравнение, определяет, что значения не равны и отображает результат: False.
Операторы в Windows PowerShell несколько отличаются от операторов других языков сценариев и даже от операторов C#. В большинстве языков оператор "=" не только присваивает значения, но и выполняет сравнение на равенство. В Windows PowerShell эта неоднозначность устранена введением отдельного оператора для каждого действия. На рисунке 1 показаны операторы сравнения Windows PowerShell и соответствующие им операторы из других языков, с которыми вы можете быть уже знакомы (например VBScript).
Figure 1 Операторы сравнения PowerShell
| Оператор | Название | Описание |
| -eq | Равно | Сравнивает значения на равенство. В других языках может использоваться = или ==. |
| -ne | Не равно | Сравнивает значения на неравенство. В других языках может использоваться <> или !=. |
| -gt | Больше | Проверяет, что одно значение больше другого. В других языках может использоваться знак >. |
| -lt | Меньше | Проверяет, что одно значение меньше другого. В других языках может использоваться знак <. |
| -ge | Больше или равно | Проверяет, что одно значение больше или равно другому. Сходен с >= в VBScript и других языках. |
| -le | Меньше или равно | Проверяет, что одно значение меньше или равно другому. Сходен с <= в VBScript и других языках. |
У операторов сравнения есть и другая интересная особенность. Взгляните на этот пример:
PS C:\> $a = "TechNet" PS C:\> $b = "technet" PS C:\> $a -eq $b TrueПо умолчанию операторы сравнения нечувствительны к регистру, так что содержащая заглавные буквы строка "TechNet" оказывается равна "technet". Это весьма удобно, потому как в большинстве администраторских задач регистр букв не имеет значения. Но когда это не так, можно произвести и чувствительное к регистру сравнение, добавив букву "c" к оператору:
PS C:\> $a -ceq $b FalseЕсли вы забудете, какой тип сравнения используется по умолчанию, можно по тому же принципу добавить к оператору букву "i", тем самым явно указав нечувствительность к регистру:
PS C:\> $a -ieq $b TrueВсё, что нужно запомнить — это что операторы сравнения всегда возвращают одно из двух значений: True или False.
Принимая решения
Узнав, как составлять логические выражения, можно начать использовать их в конструкциях. Первая из них позволяет Windows PowerShell принять решение, основываясь на сравнении. Она называется конструкцией If, и у неё есть несколько вариантов. Вот простейший:
PS C:\> if ($a -eq $b) { >> Write-Host "They are equal" >> } >> They are equalЗдесь стоит отметить несколько интересных моментов. Прежде всего, переменные $a и $b всё ещё содержат значения "TechNet" и "technet" соответственно. Конструкция начинается с ключевого слова If. За ней, в скобках, идёт логическое сравнение, которое мне надо было произвести. Затем фигурная скобка, обозначающая начало "условного кода" — кода, который будет выполнен, если результатом сравнения будет True. Из предыдущего примера вы знаете, что это сравнение возвращает True, так что условный код очевидно будет выполнен. Печатаю свой условный код, Write-Host "They are equal", и нажимаю клавишу ВВОД. Наконец, закрывающая фигурная скобка отмечает конец секции с условным кодом. После неё нажимаю клавишу ВВОД дважды. Второе нажатие, на пустой строке, даёт анализатору понять, что я закончил код и хочу выполнить его.
Обратите внимание, что эта конструкция запускается не из файла сценария. Я просто печатал её в командной строке Windows PowerShell. Вот что делает этот продукт уникальным в мире сценариев Windows: сценарии можно создавать как интерактивно, так и помещая их в файл для долговременного хранения.
Как только я ввёл открывающую фигурную скобку и нажал ВВОД, Windows PowerShell отобразила приглашение >>. Так она сообщает: "Я вижу, что вы внутри конструкции, и жду, когда вы начнёте печатать то, что её составляет". После ввода закрывающей скобки и двойного нажатия ВВОД, она выполнила конструкцию, определив, что логическое сравнение возвращает True, и выполнив условный код. Это видно по тому, что "They are equal" появляется на экране прежде чем PowerShell возвращается к обычному приглашению командной строки. Использование Windows PowerShell для интерактивного написания сценариев позволяет быстро протестировать отрывки кода перед их включением в основной сценарий, что упрощает как отладку, так и обучение.
Следует отметить, что оболочка отнюдь не требует каждый раз нажимать клавишу ВВОД. Например, предыдущий сценарий можно переписать так:
PS C:\> if ($a -eq $b) { Write-Host "They are equal" } They are equalПоскольку я напечатал всё в одной строке, Windows PowerShell не потребовалось отображать специальное приглашение >>. Конструкция была выполнена, как только я нажал ВВОД в конце строки. Из чего следует, что выполнять её было можно сразу? Из того, что она была завершена — закрывающая фигурная скобка была на месте.
Выше я упомянул, что у конструкции If есть и другие варианты. Вот законченный пример, более характерный для файла сценариев PS1, чем для оболочки:
if ($a -eq $b) { Write-Host "They are equal" } elseif ($a -lt $b) { Write Host "One is less than the other" } else { Write Host "One is greater than the other" }Конструкция начинается точно так же, с ключевого слова If. Но здесь, если первое сравнение возвращает False, выполняется второе сравнение, обозначенное ключевым словом Elseif. Если же и оно вернёт False, тогда последнее ключевое слово — Else — обеспечит выполнение соответствующего ему кода.
Повторяясь
Windows PowerShell содержит несколько конструкций для выполнения кода до тех пор, пока некоторое условие не станет равным True или False. Программисты называют их циклами. А один из самых полезных циклов позволяет даже перечислять объекты в коллекции и выполнять одну или несколько строк кода для каждого объекта. Он вполне удачно назван foreach, и выглядит следующим образом:
PS C:\> $names = get-content "c:\computers.txt" PS C:\> foreach ($name in $names) { >> Write-Host $name >> } >> don-pc testbedВсё начинается с обращения к командлету Get-Content с целью получить содержимое созданного мною файла c:\computers.txt, в который я поместил имена компьютеров, по одному на каждую строку. Windows PowerShell трактует каждую строку как объект, а файл, таким образом, представляется коллекцией этих объектов. Сохранена она в переменной $names. С помощью ключевого слова Foreach я перечисляю элементы коллекции $names, используя переменную $name для хранения текущего объекта при каждом выполнении цикла. Код самого цикла находится в фигурных скобках. Каждое имя, взятое из файла, я хочу вывести в командную строку. И, как видно из результата выполнения, следующего за конструкцией, именно это Windows PowerShell и делает. Преимущества для администраторских задач очевидны: можно, например, запросто создать список серверов и использовать Windows PowerShell для получения информации от каждого сервера по очереди.
Примеры из жизни
Составим что-нибудь полезное из логических сравнений и конструкций If и foreach. Я хочу быстро проверить состояние службы сообщений у каждого из группы серверов. На большинстве серверов эта служба должна быть остановлена, так что я не хочу получить список серверов, где она и правда остановлена. Мне нужны только сервера, где служба сообщений запущена, и именно в их отношении я должен что-то предпринять.
Я знаю, что мог бы использовать командлет Get-Service для получения нужной информации с локального компьютера. Но к удалённому компьютеру он получить доступ не может. К счастью, ту же информацию можно получить с помощью WMI (Windows Management Instrumentation — инструментарий управления Windows), используя командлет Get-WMIObject, позволяющий работать с удалённым компьютером. Получается следующий сценарий:
$names = get-content c:\computers.txt foreach ($name in $names) { $svc = get-wmiobject win32_service ' -computer $name -filter "name='messenger'" if ($svc.started -eq $True ) { write-host "$name has Messenger running" } }Заметили символ ' в конце третьей строки? Он сообщает Windows PowerShell, что следующая строка — продолжение предыдущей. Это удобно в случаях вроде этого, когда вся строка целиком не поместилась бы на журнальной полосе без переноса. Обратите также внимание на сравнение $svc.started с $True в конструкции If. $True — особая переменная в Windows PowerShell, которая представляет логическое значение True. Обратная ей переменная $False представляет логическое False. В целом, я мог бы написать чуть более короткий код:
$names = get-content c:\computers.txt foreach ($name in $names) { $svc = get-wmiobject win32_service ' -computer $name -filter "name='messenger'" if ($svc.started) { write-host "$name has Messenger running" } }Ведь условие конструкции If должно быть просто True или False. Обычно True или False получаются в результате сравнения двух значений, как в первом варианте сценария. Но раз свойство Started может принимать значения только True или False, нет никакой нужды дополнительно сравнивать его с True или False.
Один полезный инструмент
Таков вот он — простой, удобный инструмент администратора, включающий различные конструкции для выполнения текущих задач. Набираете ли вы сценарий интерактивно в Windows PowerShell или сохраняете его в PS1-файл для последующего использования, вы одинаково удобно можете проверить состояние служб на различных компьютерах, что великолепно демонстрирует пользу конструкций в автоматизации задач администрирования.
Дон Джонс (Don Jones) — директор по проектам и услугам в SAPIEN Technologies и соавтор книги "Windows PowerShell: TFM" (SAPIEN Press, 2006). Связаться с ним можно через его веб-сайт ScriptingAnswers.com (на английском языке).
© 2008 Корпорация Майкрософт и компания CMP Media, LLC. Все права защищены; полное или частичное воспроизведение без разрешения запрещено.
technet.microsoft.com
about_Comparison_Operators
Вставьте сюда введение.
about_Comparison_Operators
Содержит описание операторов сравнения, используемых в Windows PowerShell®.
Операторы сравнения позволяют указать условия сравнения и поиска значений, удовлетворяющих указанным шаблонам. При использовании оператора сравнения необходимо указать значения, которые нужно сравнить, а также оператор, который будет разделять эти значения.
В Windows PowerShell имеются следующие операторы сравнения:
-eq -ne -gt -ge -lt -le -Like -NotLike -Match -NotMatch -Contains -NotContains -In -NotIn -ReplaceПо умолчанию во всех операторах сравнения не учитывается регистр символов. Для учета регистра символов в операторе сравнения необходимо указать перед именем оператора букву «c». Например, «-ceq» — это версия оператора «-eq», учитывающая регистр символов. Чтобы отменить учет регистра символов в явном виде, укажите перед именем оператора букву «i». Например, «-ieq» — это версия оператора «-eq», в которой явно отключен учет регистра символов.
Если входными данными является скалярное значение, операторы сравнения возвращают логическое значение. Если в качестве входных данных используется коллекция значений, операторы сравнения возвращают все соответствующие значения. Если в коллекции не найдено соответствий, эти операторы не вернут ничего.
Исключениями являются операторы вложения (-Contains, -NotContains), операторы In (-In, -NotIn) и операторы типа (-Is, -IsNot), которые всегда возвращают логическое значение.
В Windows PowerShell поддерживаются перечисленные ниже операторы сравнения.
-eq
Описание: равенство. Содержит совпадающее значение.
Пример:
PS C:\> "abc" -eq "abc" True PS C:\> "abc" -eq "abc", "def" False PS C:\> "abc", "def" -eq "abc" abc-ne
Описание: неравенство. Содержит несовпадающее значение.
Пример:
PS C:\> "abc" -ne "def" True PS C:\> "abc" -ne "abc" False PS C:\> "abc" -ne "abc", "def" True PS C:\> "abc", "def" -ne "abc" def-gt
Описание: больше.
Пример:
PS C:\> 8 -gt 6 True PS C:\> 7, 8, 9 -gt 8 9-ge
Описание: больше или равно.
Пример:
PS C:\> 8 -ge 8 True PS C:\> 7, 8, 9 -ge 8 8 9-lt
Описание: меньше.
Пример:
PS C:\> 8 -lt 6 False PS C:\> 7, 8, 9 -lt 8 7-le
Описание: меньше или равно.
Пример:
PS C:\> 6 -le 8 True PS C:\> 7, 8, 9 -le 8 7 8-Like
Описание: соответствие с использованием подстановочного знака (*).
Пример:
PS C:\> "Windows PowerShell" -like "*shell" True PS C:\> "Windows PowerShell", "Server" -like "*shell" Windows PowerShell-NotLike
Описание: несоответствие с использованием подстановочного знака (*).
Пример:
PS C:\> "Windows PowerShell" -NotLike "*shell" False PS C:\> "Windows PowerShell", "Server" -NotLike "*shell" Server-Match
Описание: соответствие строк с учетом регулярных выражений. Если в качестве входных данных используется скалярное значение, оператор заносит результат в автоматическую переменную $Matches.
Пример:
PS C:\> "Sunday" -Match "sun" True PS C:\> $matches Name Value ---- ----- 0 Sun PS C:\> "Sunday", "Monday" -Match "sun" Sunday-NotMatch
Описание: несоответствие строк. Используются регулярные выражения. Если в качестве входных данных используется скалярное значение, оператор заносит результат в автоматическую переменную $Matches.
Пример:
PS C:\> "Sunday" -NotMatch "sun" False PS C:\> $matches Name Value ---- ----- 0 sun PS C:\> "Sunday", "Monday" -NotMatch "sun" Monday-Contains
Описание: оператор вложения. Указывает, входит ли отдельное проверяемое значение в коллекцию контрольных значений. Всегда возвращает логическое значение. Возвращает значение TRUE только в том случае, если проверяемое значение точно совпадает по крайней мере с одним из контрольных значений.
Если тестовое значение является коллекцией, оператор Contains проверяет равенство ссылок. Значение TRUE возвращается только в том случае, если одно из контрольных значений является экземпляром объекта контрольного значения.
Синтаксис:
<Reference-values> -Contains <Test-value>Примеры:
PS C:\> "abc", "def" -Contains "def" True PS C:\> "Windows", "PowerShell" -Contains "Shell" False #Not an exact match # Does the list of computers in $domainServers # include $thisComputer? # ------------------------------------------- PS C:\> $domainServers -Contains $thisComputer True PS C:\> "abc", "def", "ghi" -Contains "abc", "def" False PS C:\> $a = "abc", "def" PS C:\> "abc", "def", "ghi" -Contains $a False PS C:\> $a, "ghi" -Contains $a True-NotContains
Описание: оператор вложения. Указывает, входит ли отдельное проверяемое значение в коллекцию контрольных значений. Всегда возвращает логическое значение. Возвращает значение TRUE в том случае, если проверяемое значение не совпадает в точности по крайней мере с одним из контрольных значений.
Если тестовое значение является коллекцией, оператор NotContains проверяет равенство ссылок.
Синтаксис:
<Reference-values> -NotContains <Test-value>Примеры:
PS C:\> "Windows", "PowerShell" -NotContains "Shell" True #Not an exact match # Get cmdlet parameters, but exclude common parameters function get-parms ($cmdlet) { $Common = "Verbose", "Debug", "WarningAction", "WarningVariable", ` "ErrorAction", "ErrorVariable", "OutVariable", "OutBuffer" $allparms = (Get-Command $Cmdlet).parametersets | foreach {$_.Parameters} | ` foreach {$_.Name} | Sort-Object | Get-Unique $allparms | where {$Common -NotContains $_ } } # Find unapproved verbs in the functions in my module # ------------------------------------------- PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb} PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb} PS C:\> $myVerbs | where {$ApprovedVerbs -NotContains $_} ForEach Sort Tee Where-In
Описание: оператор вхождения. Указывает, имеется ли контрольное значение в коллекции контрольных значений. Всегда возвращает логическое значение. Возвращает значение TRUE только в том случае, если проверяемое значение точно совпадает по крайней мере с одним из контрольных значений.
Если тестовое значение является коллекцией, оператор In проверяет равенство ссылок. Значение TRUE возвращается только в том случае, если одно из контрольных значений является экземпляром объекта контрольного значения.
Оператор In появился в Windows PowerShell 3.0.
Синтаксис:
<Test-value> -in <Reference-values>Примеры:
PS C:\> "def" -in "abc", "def" True PS C:\> "Shell" -in "Windows", "PowerShell" False #Not an exact match PS C:\> "Windows" -in "Windows", "PowerShell" True #An exact match PS C:\> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager" False #Using reference equality PS C:\> $a = "Windows", "PowerShell" PS C:\> $a -in $a, "ServerManager" True #Using reference equality # Does the list of computers in $domainServers # include $thisComputer? # ------------------------------------------- PS C:\> $thisComputer -in $domainServers True-NotIn
Описание: оператор NotIn. Указывает, имеется ли контрольное значение в коллекции контрольных значений. Всегда возвращает логическое значение. Возвращает значение TRUE в том случае, если проверяемое значение не совпадает в точности по крайней мере с одним из контрольных значений.
Если тестовое значение является коллекцией, оператор In проверяет равенство ссылок. Значение TRUE возвращается только в том случае, если одно из контрольных значений является экземпляром объекта контрольного значения.
Оператор NotIn появился в Windows PowerShell 3.0.
Синтаксис:
<Test-value> -NotIn <Reference-values>Примеры:
PS C:\> "def" -NotIn "abc", "def" False PS C:\> "ghi" -NotIn "abc", "def" True PS C:\> "Shell" -NotIn "Windows", "PowerShell" True #Not an exact match PS C:\> "Windows" -NotIn "Windows", "PowerShell" False #An exact match # Find unapproved verbs in the functions in my module # ------------------------------------------- PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb} PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb} PS C:\> $myVerbs | where {$_ -NotIn $ApprovedVerbs} ForEach Sort Tee Where-Replace
Описание: оператор замены. Изменяет указанные элементы значения.
Пример:
PS C:\> "Get-Process" -Replace "Get", "Stop" Stop-Process # Change all .GIF file name extension to .JPG PS C:\> dir *.gif | foreach {$_ -Replace ".gif", ".jpg"}ОПЕРАТОРЫ РАВЕНСТВА
Операторы равенства (-eq, -ne) возвращают значение TRUE или соответствующие элементы, если одно или несколько входных значений совпадают с указанным шаблоном. Весь шаблон должен соответствовать всему значению.
C:PS> 2 -eq 2 True C:PS> 2 -eq 3 False C:PS> 1,2,3 -eq 2 2 C:PS> "PowerShell" -eq "Shell" False C:PS> "Windows", "PowerShell" -eq "Shell" C:PS> PS C:\> "abc", "def", "123" -eq "def" def PS C:\> "abc", "def", "123" -ne "def" abc 123ОПЕРАТОРЫ ВЛОЖЕНИЯ
Операторы вложения (-Contains и -NotContains) сходны с операторами равенства. Однако операторы вложения всегда возвращают логическое значение, даже если в качестве входных данных использовалась коллекция.
Кроме того, в отличие от операторов равенства, операторы вложения возвращают значение при обнаружении первого совпадения. Операторы равенства оценивают все входные данные и затем возвращают все совпадения в коллекции. В примерах ниже показано функционирование оператора -Contains.
C:PS> 1,2,3 -contains 2 True C:PS> "PowerShell" -contains "Shell" False C:PS> "Windows", "PowerShell" -contains "Shell" False PS C:\> "abc", "def", "123" -contains "def" True PS C:\> "true", "blue", "six" -contains "true" TrueВ примере ниже продемонстрировано отличие операторов вложения от оператора равенства. Операторы вложения всегда возвращают значение TRUE при первом совпадении.
PS C:\> 1,2,3,4,5,4,3,2,1 -eq 2 2 2 PS C:\> 1,2,3,4,5,4,3,2,1 -contains 2 TrueПри обработке коллекции очень большого объема оператор -Contains возвращает результаты быстрее, чем оператор равенства.
Операторы совпадения
Операторы совпадения (-Match и -NotMatch) выполняют поиск элементов, которые соответствуют или не соответствуют указанному шаблону при использовании регулярных выражений.
Синтаксис:
<string[]> -Match <regular-expression> <string[]> -NotMatch <regular-expression>Ниже показаны примеры использования оператора -Match.
PS C:\> "Windows", "PowerShell" -Match ".shell" PowerShell PS C:\> (Get-Command Get-Member -Syntax) -Match "-view" True PS C:\> (Get-Command Get-Member -Syntax) -NotMatch "-path" True PS C:\> (Get-Content Servers.txt) -Match "^Server\d\d" Server01 Server02Операторы совпадения выполняют поиск только в строках. Они не могут выполнять поиск по массивам целых чисел и другим объектам.
Операторы -Match и -NotMatch заполняют автоматическую переменную $Matches, если входные данные (аргумент с левой стороны) оператора представляют собой один скалярный объект. Если входные данные являются скалярными, операторы -Match и -NotMatch возвращают логическое значение и устанавливают в качестве значения автоматической переменной $Matches совпавшие компоненты аргумента.
Если входные данные являются коллекцией, операторы -Match и -NotMatch возвращают соответствующие элементы коллекции, но не изменяют значение переменной $Matches.
Например, приведенная ниже команда отправляет коллекцию строк в оператор -Match. Оператор -Match возвращает элементы коллекции, которые соответствуют шаблону. При этом значение автоматической переменной $Matches не изменяется.
PS C:\> "Sunday", "Monday", "Tuesday" -Match "sun" Sunday PS C:\> $matches PS C:\>Напротив, приведенная ниже команда отправляет в оператор -Match одну строку. Оператор -Match возвращает логическое значение и изменяет значение автоматической переменной $Matches.
PS C:\> "Sunday" -Match "sun" True PS C:\> $matches Name Value ---- ----- 0 SunОператор -NotMatch устанавливает значение автоматической переменной $Matches, если входные данные являются скалярными, а результат выполнения оператора равняется False, т. е. при обнаружении совпадения.
PS C:\> "Sunday" -NotMatch "rain" True PS C:\> $matches PS C:\> PS C:\> "Sunday" -NotMatch "day" False PS C:\> $matches PS C:\> Name Value ---- ----- 0 dayОПЕРАТОР ЗАМЕНЫ
Оператор -Replace заменяет часть исходного значения или все значение целиком на указанное значение с использованием регулярных выражений. Оператор -Replace может оказаться полезным при выполнении многих административных задач, например при переименовании файлов. Например, приведенная ниже команда изменяет расширения всех файлов GIF на JPG.
Get-ChildItem | Rename-Item -NewName { $_ -Replace '.gif$','.jpg$' }Ниже описан синтаксис оператора -Replace, при этом <оригинал> соответствует символам, которые необходимо заменить, а <замена> — символам, которыми необходимо заменить оригинал.
<input> <operator> <original>, <substitute>По умолчанию оператор -Replace не учитывает регистр символов. Для учета регистра символов используйте -cReplace. Для явного отключения учета регистра символов используйте -iReplace. Рассмотрим следующие примеры:
PS C:\> "book" -Replace "B", "C" Cook PS C:\> "book" -iReplace "B", "C" Cook PS C:\> "book" -cReplace "B", "C" book PS C:\> '<command:parameter required="false" variableLength="true" globbing="false"'` | foreach {$_ -replace 'globbing="false"', 'globbing="true"'} <command:parameter required="false" variableLength="true" globbing="true"Побитовые операторы
Windows PowerShell поддерживает стандартные побитовые операторы, включая побитовое И (-bAnd), побитовое ИЛИ и побитовое исключающее ИЛИ (-bOr и -bXor), а также побитовое НЕ (-bNot).
Начиная с версии Windows PowerShell 2.0 все побитовые операторы работают с 64-разрядными целыми числами.
Начиная с версии Windows PowerShell 3.0 появились операторы -shr (сдвиг вправо) и -shl (сдвиг влево) для поддержки побитовых арифметических операций в Windows PowerShell.
В Windows PowerShell поддерживаются перечисленные ниже побитовые операторы.
Operator Description Example -------- ---------------------- ------------------- -bAnd Bitwise AND PS C:\> 10 -band 3 2 -bOr Bitwise OR (inclusive) PS C:\> 10 -bor 3 11 -bXor Bitwise OR (exclusive) PS C:\> 10 -bxor 3 9 -bNot Bitwise NOT PS C:\> -bNot 10 -11 -shl Shift-left PS C:\> 100 -shl 2 400 -shr Shift-right PS C:\> 100 -shr 1 50Побитовые операторы используют двоичный формат значений. Например, для числа 10 используется битовая структура 00001010 (на основе 1 байта), а для числа 3 — 00000011. При использовании побитового оператора для сравнения 10 и 3 выполняется сравнение отдельных битов в каждом байте.
При операции побитового И результирующий бит устанавливается в 1 только в том случае, если оба входных бита равняются 1.
1010 (10) 0011 ( 3) -------------- bAND 0010 ( 2)При операции побитового ИЛИ (включающего) результирующий бит устанавливается в 1, если любой из входных битов или они оба равняются 1. Результирующий бит устанавливается в 0 только в том случае, если оба входных бита равняются 0.
1010 (10) 0011 ( 3) -------------- bOR (inclusive) 1011 (11)При операции побитового ИЛИ (исключающего) результирующий бит устанавливается в 1 только в том случае, если один из входных битов равняется 1.
1010 (10) 0011 ( 3) -------------- bXOR (exclusive) 1001 ( 9)Побитовый оператор НЕ — это унарный оператор, результатом выполнения которого является дополнение до двоичного значения. Бит 1 устанавливается в 0, а бит 0 устанавливается в 1.
Например, двоичным дополнением 0 является –1, т. е. максимальное целое число без знака (0xffffffff), а двоичным дополнением –1 — 0.
PS C:\> -bNOT 10 -11 0000 0000 0000 1010 (10) ------------------------- bNOT 1111 1111 1111 0101 (-11, xfffffff5)В побитовой операции сдвига влево все биты перемещаются на «n» позиций влево, где «n» — значение правого операнда. Оставшиеся позиции заполняются нулями.
Если левый операнд является значением Integer (32-разрядным), 5 младших битов правого операнда определяют количество битов сдвига левого операнда.
Если левый операнд является значением Long (64-разрядным), 6 младших битов правого операнда определяют количество битов сдвига левого операнда.
PS C:\> 21 -shl 1 42 00010101 (21) 00101010 (42) PS C:\> 21 -shl 2 84 00010101 (21) 00101010 (42) 01010100 (84)При выполнении побитовой операции сдвига вправо все биты перемещаются на n позиций вправо, где n — это значение правого операнда. Оператор сдвига вправо (-shr) вставляет нуль в самую левую позицию, если выполняется сдвиг вправо положительного значения или значения без знака.
Если левый операнд является значением Integer (32-разрядным), 5 младших битов правого операнда определяют количество битов сдвига левого операнда.
Если левый операнд является значением Long (64-разрядным), 6 младших битов правого операнда определяют количество битов сдвига левого операнда.
PS C:\> 21 -shr 1 10 00010101 (21) 00001010 (10) PS C:\> 21 -shr 2 5 00010101 (21) 00001010 (10) 00000101 ( 5)technet.microsoft.com
По умолчанию все операторы сравнения не являются чувствительными к регистру.
Для сравнения с учетом регистра к команде подставляется префикс "c". Для примера, оператор -eq с зависимостью от регистра изменяется на "-ceq". Для явно заданного независящего от регистра сравнения к команде подставляется префикс "i". Пример: оператор -replace без зависимости от регистра будет -ireplace Типы
Логические операторы PowerShell
Примеры$myVar -is "String" $myVar -eq 123 $myVar -ceq $myVar2 "abcdef" -like "abc*" "abcdef" -replace "dEf","xyz" $myVar1 -is "String" -and $myVar2 -is "Int" (1 -eq 1) -and -not (2 -gt 2)Комментарии: |
vam.in.ua
about_Operators
Содержит описание операторов, поддерживаемых Windows PowerShell.
Оператор — это элемент языка, который можно использовать в команде или выражении. Windows PowerShell поддерживает несколько типов операторов для работы со значениями.
АРИФМЕТИЧЕСКИЕ ОПЕРАТОРЫ
Арифметические операторы (+, -, *, /, %) используются для вычисления значений в команде или выражении. С помощью этих операторов можно складывать, вычитать, умножать и делить значения, а также вычислять остаток от деления.
Арифметические операторы также можно использовать со строками, массивами и хэш-таблицами. Оператор сложения сцепляет элементы. Оператор умножения возвращает указанное количество копий каждого элемента.
Подробнее см. в разделе about_Arithmetic_Operators.
ОПЕРАТОРЫ ПРИСВАИВАНИЯ
Операторы присваивания (=, +=, -=, *=, /=, %=) используются для присвоения одного или нескольких значений переменным, для изменения значений переменных и для добавления значений в переменные. Вы также можете привести переменную к любому типу данных Microsoft .NET Framework, например к типу string, DateTime или Process.
Подробнее см. в разделе about_Assignment_Operators.
ОПЕРАТОРЫ СРАВНЕНИЯ
Операторы сравнения (-eq, -ne, -gt, -lt, -le, -ge) используются для сравнения значений и проверочных условий. Например, можно сравнить два строковых значения, чтобы определить, равны ли они.
К операторам сравнения относятся операторы соответствия (-match, -notmatch), которые служат для поиска шаблонов с помощью регулярных выражений, оператор замены (-replace), который использует регулярные выражения для изменения входных значений, операторы подобия (-like, -notlike), которые служат для поиска шаблонов с помощью подстановочных знаков (*), и операторы вложения (-in, -notin, -contains, -notcontains), которые определяют, входит ли проверяемое значение в эталонное множество.
К ним также относятся побитовые операторы (-bAND, -bOR, -bXOR, -bNOT) для работы с битовыми шаблонами в значениях.
Подробнее см. в разделе about_Comparison_Operators.
ЛОГИЧЕСКИЕ ОПЕРАТОРЫ
Логические операторы (-and, -or, -xor, -not, !) используются для объединения условных операторов в один сложный оператор. Например, с помощью логического оператора -and можно создать фильтр объектов с двумя разными условиями.
Подробнее см. в разделе about_Logical_Operators.
ОПЕРАТОРЫ ПЕРЕНАПРАВЛЕНИЯ
Операторы перенаправления (>, >>, 2>, 2> и 2>&1) используются для передачи выходных данных команды или выражения в текстовый файл. Операторы перенаправления работают как командлет Out-File (без параметров), но также позволяют перенаправлять выходные данные ошибок в указанные файлы. Для перенаправления выходных данных также можно использовать командлет Tee-Object.
Подробнее см. в разделе about_Redirection.
ОПЕРАТОРЫ РАЗДЕЛЕНИЯ И ОБЪЕДИНЕНИЯ
Операторы -split и -join служат для разделения и объединения подстрок. Оператор -split разделяет строку на подстроки. Оператор -join сцепляет несколько строк в одну строку.
Подробнее см. в разделах about_Split и about_Join.
ОПЕРАТОРЫ РАБОТЫ С ТИПАМИ
Операторы работы с типами (-is, -isnot, -as) используются для определения или изменения типа объекта .NET Framework.
Подробнее см. в разделе about_Type_Operators.
УНАРНЫЕ ОПЕРАТОРЫ
Унарные операторы используются для увеличения или уменьшения значений переменных или свойств объектов, а также для изменения целых чисел на положительные или отрицательные. Например, чтобы увеличить значение переменной $a с 9 до 10, введите $a++.
СПЕЦИАЛЬНЫЕ ОПЕРАТОРЫ
Специальные операторы используются для выполнения задач, которые нельзя выполнить с помощью операторов других типов. Например, специальные операторы позволяют выполнять такие операции, как выполнение команд и изменение типа данных значения.
Оператор вложенного выражения массива @( )
Возвращает результат одного или нескольких операторов в виде массива. Если имеется только один элемент, массив содержит только один член.
@(Get-WMIObject win32_logicalDisk)Оператор вызова &
Выполняет команду, сценарий или блок сценария. Оператор вызова позволяет выполнять команды, которые хранятся в переменных и представлены строками. Так как оператор вызова не анализирует синтаксис команды, он не может интерпретировать ее параметры.
C:\PS> $c = "get-executionpolicy" C:\PS> $c get-executionpolicy C:\PS> & $c AllSignedОператор приведения [ ]
Преобразует объекты в указанный тип или ограничивает их этим типом. Если преобразовать объекты нельзя, Windows PowerShell создает ошибку.
[datetime]$birthday = "1/20/88" [int64]$a = 34Оператор «запятая» (,)
Как бинарный оператор запятая создает массив. Как унарный оператор запятая создает массив с одним элементом. Поместите запятую перед элементом.
$myArray = 1,2,3 $SingleArray = ,1. Оператор вызова с использованием точки
Запускает сценарий в текущей области, так что все функции, псевдонимы и переменные, создаваемые сценарием, добавляются в текущую область.
Примечание. За оператором вызова с использованием точки следует пробел. Пробел служит для различения точки от символа точки (.), который представляет текущий каталог.
В примере ниже сценарий Sample.ps1 в текущем каталоге запускается в текущей области.
Оператор форматирования -f
Форматирует строки с помощью метода форматирования строковых объектов. Введите строку формата в левой части оператора, а форматируемые объекты — в правой части оператора.
C:\PS> "{0} {1,-10} {2:N}" -f 1,"hello",[math]::pi 1 hello 3.14Подробнее см. в разделе, посвященном методу String.Format (http://go.microsoft.com/fwlink/?LinkID=166450), и в разделе «Составное форматирование» (http://go.microsoft.com/fwlink/?LinkID=166451).
Оператор индекса [ ]
Выбирает объекты из индексированных коллекций, таких как массивы и хэш-таблицы. Индексы массивов отсчитываются от нуля, поэтому первый объект имеет индекс [0]. Для массивов (и только для них) также можно использовать отрицательные индексы для получения последних значений. Хэш-таблицы индексируются по значению ключа.
C:\PS> $a = 1, 2, 3 C:\PS> $a[0] 1 C:\PS> $a[-1] 3 C:\PS> (get-hotfix | sort installedOn)[-1] C:\PS> $h = @{key="value"; name="Windows PowerShell"; version="2.0"} C:\PS> $h["name"] Windows PowerShell C:\PS> $x = [xml]"<doc><intro>Once upon a time...</intro></doc>" C:\PS> $x["doc"] intro ----- Once upon a time...Оператор конвейера |
Передает («по конвейеру») выходные данные команды, предшествующей ему, в команду, следующую за ним. Если выходные данные содержат более одного объекта («коллекцию»), оператор конвейера передает по одному объекту за раз.
get-process | get-member get-pssnapin | where {$_.vendor -ne "Microsoft"}. Оператор разыменования свойств
Получает доступ к свойствам и методам объекта.
$myProcess.peakWorkingSet (get-process PowerShell).kill().. Оператор диапазона
Представляет последовательность целых чисел в целочисленном массиве с учетом верхней и нижней границ.
1..10 10..1 foreach ($a in 1..$max) {write-host $a}:: Оператор статических членов
Вызывает оператор статических свойств и методы класса .NET Framework. Чтобы определить статические свойства и методы объекта, используйте параметр Static командлета Get-Member.
Оператор части выражения $( )
Возвращает результат одного или нескольких операторов. Если результат один, возвращает скалярное значение. Если результатов несколько, возвращает массив.
$($x * 23) $(Get-WMIObject win32_Directory)technet.microsoft.com
НОУ ИНТУИТ | Лекция | Конвейеризация и управление выводом команд Windows PowerShell
Аннотация: Обсуждается процесс конвейеризации объектов в PowerShell. Рассматриваются процедуры фильтрации и сортировки потока объектов. Описываются командлеты для форматирования выводимых данных и перенаправления выходных потоков команд
Конвейеризация и управление выводом команд Windows PowerShell
Ранее в "лекции 2" мы рассматривали понятие конвейеризации (или композиции) команд интерпретатора Cmd.exe, когда выходной поток одной команды перенаправлялся во входной поток другой, объединяя тем самым две команды вместе. Подобные конвейеры команд используются в большинстве оболочек командной строки и являются средством, позволяющим передавать информацию между разными процессами.
Механизм композиции команд представляет собой, вероятно, наиболее ценную концепцию, используемую в интерфейсах командной строки. Конвейеры не только снижают усилия, прилагаемые при вводе сложных команд, но и облегчают отслеживание потока работы в командах. Полезной чертой конвейеров является то, что они не зависят от числа передаваемых элементов, так как конвейер действует на каждый элемент отдельно. Кроме того, каждая команда в конвейере (называемая элементом конвейера) обычно передает свой вывод следующей команде в конвейере, элемент за элементом. Благодаря этому, как правило, снижается потребление ресурсов для сложных команд и возникает возможность получать выводимую информацию немедленно.
В оболочке PowerShell также очень широко используется механизм конвейеризации команд, однако здесь по конвейеру передается не поток текста, как во всех других оболочках, а объекты. При этом с элементами конвейера можно производить различные манипуляции: фильтровать объекты по определенному критерию, сортировать и группировать объекты, изменять их структуру (ниже мы подробнее рассмотрим операции фильтрации и сортировки элементов конвейера).
Конвейеризация объектов в PowerShell
Конвейер в PowerShell – это последовательность команд, разделенных между собой знаком | (вертикальная черта). Каждая команда в конвейере получает объект от предыдущей команды, выполняет определенные операции над ним и передает следующей команде в конвейере. С точки зрения пользователя, объекты упаковывают связанную информацию в форму, в которой информацией проще манипулировать как единым блоком и из которой при необходимости извлекаются определенные элементы.
Передача данных между командами в виде объектов имеет большое преимущество над обычным обменом информацией посредством потока текста. Ведь команда, принимающая поток текста от другой утилиты, должна его проанализировать, разобрать и выделить нужную ей информацию, а это может быть непросто, так как обычно вывод команды больше ориентирован на визуальное восприятие человеком (это естественно для интерактивного режима работы), а не на удобство последующего синтаксического разбора.
При передаче по конвейеру объектов этой проблемы не возникает, здесь нужная информация извлекается из элемента конвейера простым обращением к соответствующему свойству объекта. Однако теперь возникает новый вопрос: каким образом узнать, какие именно свойства есть у объектов, передаваемых по конвейеру? Ведь при выполнении того или иного командлета мы на экране видим только одну или несколько колонок отформатированного текста. Например, запустим командлет Get-Process, который выводит информацию о запущенных в системе процессах:
PS C:\> Get-Process Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 158 11 45644 22084 126 159.69 2072 AcroRd32 98 5 1104 284 32 0.10 256 alg 39 1 364 364 17 0.26 1632 ati2evxx 57 3 1028 328 30 0.38 804 atiptaxx 434 6 2548 3680 27 21.96 800 csrss 64 3 812 604 29 0.22 1056 ctfmon 364 11 14120 9544 69 11.82 456 explorer 24 2 1532 2040 29 5.34 2532 FarФактически на экране мы видим только сводную информацию (результат форматирования полученных данных), а не полное представление выходного объекта. Из этой информации не понятно, сколько точно свойств имеется у объектов, генерируемых командой Get-Process, и какие имена имеют эти свойства. Например, мы хотим найти все "зависшие" процессы, которые не отвечают на запросы системы. Можно ли это сделать с помощью командлета Get-Process, какое свойство нужно проверять у выводимых объектов?
Для ответа на подобные вопросы нужно, прежде всего, научиться исследовать структуру объектов PowerShell, узнавать, какие свойства и методы имеются у этих объектов.
Просмотр структуры объектов
Для анализа структуры объекта, возвращаемого определенной командой, проще всего направить этот объект по конвейеру на командлет Get-Member (псевдоним gm ), например:
PS C:\> Get-Process | Get-Member TypeName: System.Diagnostics.Process Name MemberType Definition ---- ---------- ---------- Handles AliasProperty Handles = Handlecount Name AliasProperty Name = ProcessName NPM AliasProperty NPM = NonpagedSystemMemorySize PM AliasProperty PM = PagedMemorySize VM AliasProperty VM = VirtualMemorySize WS AliasProperty WS = WorkingSet . . . Responding Property System.Boolean Responding {get;} . . .Здесь мы видим имя .NET-класса, экземпляры которого возвращаются в ходе работы исследуемого командлета (в нашем примере это класс System.Diagnostic.Process), а также полный список элементов объекта (в частности, интересующее нас свойство Responding, определяющего "зависшие" процессы). При этом на экран выводится очень много элементов, просматривать их неудобно. Командлет Get-Member позволяет перечислить только те элементы объекта, которые являются его свойствами. Для этого используется параметр MemberType со значением Properties:
PS C:\> Get-Process | Get-Member -MemberType Property TypeName: System.Diagnostics.Process Name MemberType Definition ---- ---------- ---------- BasePriority Property System.Int32 BasePriority {get;} Container Property System.ComponentModel.IContainer... EnableRaisingEvents Property System.Boolean EnableRaisingEvents... ExitCode Property System.Int32 ExitCode {get;} ExitTime Property System.DateTime ExitTime {get;} Handle Property System.IntPtr Handle {get;} HandleCount Property System.Int32 HandleCount {get;} HasExited Property System.Boolean HasExited {get;} Id Property System.Int32 Id {get;} MachineName Property System.String MachineName {get;} . . . Responding Property System.Boolean Responding {get;} . . .Как мы видим, процессам операционной системы соответствуют объекты, имеющие очень много свойств, на экран же при работе командлета Get-Process выводятся лишь несколько из них (способы отображения объектов различных типов задаются конфигурационными файлами в формате XML, находящимися в каталоге, где установлен файл powershell.exe).
Теперь, когда мы знаем, какие свойства имеют объекты, передаваемые по конвейеру, перейдем к рассмотрению наиболее часто используемых операций над элементами конвейера: фильтрации и сортировки.
Фильтрация объектов в конвейере
В PowerShell поддерживается возможность фильтрации объектов в конвейере, т.е. удаление из конвейера объектов, не удовлетворяющих определенному условию. Данную функциональность обеспечивает командлет Where-Object, позволяющий проверить каждый объект, находящийся в конвейере, и передать его дальше по конвейеру, только если объект удовлетворяет условиям проверки.
Например, для вывода информации о "зависших" процессах (объекты, возвращаемые командлетом Get-Process, у которых свойство Responding равно False ) можно использовать следующий конвейер:
Get-Process | Where-Object {-not $_.Responding}Другой пример – оставим в конвейере только те процессы, у которых значение идентификатора (свойство Id ) больше 1000:
Get-Process | Where-Object {$_.Id -gt 1000}В блоках сценариев командлета Where-Object для обращения к текущему объекту конвейера и извлечения нужных свойств этого объекта используется специальная переменная $_, которая создается оболочкой PowerShell автоматически. Данная переменная используется и в других командлетах, производящих обработку элементов конвейера.
Условие проверки в Where-Object задается в виде блока сценария – одной или нескольких команд PowerShell, заключенных в фигурные скобки {}. Результатом выполнения данного блока сценария должно быть значение логического типа: True (истина) или False (ложь). Как можно понять из примеров, в блоке сценария используются специальные операторы сравнения.
Замечание
В PowerShell для операторов сравнения не используются обычные символы > или <, так как в командной строке они обычно означают перенаправление ввода/вывода.
Основные операторы сравнения приведены в табл. 17.1.
| -eq | равно | 10 -eq 10 |
| -ne | не равно | 9 -ne 10 |
| -lt | меньше | 3 -lt 4 |
| -le | меньше или равно | 3 –le 4 |
| -gt | больше | 4 -gt 3 |
| -ge | больше или равно | 4 -ge 3 |
| -like | сравнение на совпадение с учетом подстановочного знака в тексте | "file.doc" –like "f*.doc" |
| -notlike | сравнение на несовпадение с учетом подстановочного знака в тексте | "file.doc" –notlike "f*.rtf" |
| -contains | содержит | 1,2,3 –contains 1 |
| -notcontains | не содержит | 1,2,3 –notcontains 4 |
Операторы сравнения можно соединять друг с другом с помощью логических операторов (см. табл. 17.2).
| -and | логическое И | (10 -eq 10) –and (1 –eq 1) |
| -or | логическое ИЛИ | (9 -ne 10) –or (3 –eq 4) |
| -not | логическое НЕ | -not (3 –gt 4) |
| ! | логическое НЕ | !(3 -gt 4) |
Сортировка объектов
Сортировка элементов конвейера – еще одна операция, которая часто применяется при конвейерной обработке объектов. Данную операцию осуществляет командлет Sort-Object: ему передаются имена свойств, по которым нужно произвести сортировку, а он возвращает данные, упорядоченные по значениям этих свойств.
Например, для вывода списка запущенных в системе процессов, упорядоченного по затраченному процессорному времени (свойство cpu ), можно воспользоваться следующим конвейером:
PS C:\> Get-Process | Sort-Object cpu Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 0 0 0 16 0 0 Idle 36 2 728 32 23 0.05 1792 klswd 98 5 1104 764 32 0.09 252 alg 21 1 164 60 4 0.09 748 smss 30 2 672 724 27 0.11 1700 WinCinemaMgr 39 1 364 464 17 0.12 1644 ati2evxx 163 6 1536 1404 35 0.12 1612 svchost 55 3 1088 852 27 0.14 1220 svchost 22 2 504 712 23 0.14 772 winampa 120 4 2364 1228 35 0.26 1876 svchost 170 5 4516 796 44 0.27 1260 GoogleToolbarNotifier 193 5 2916 1488 59 0.29 1040 svchost 64 3 812 1080 29 0.30 1252 ctfmon 140 5 3208 1220 41 0.32 1524 spoolsv 281 14 1764 1688 37 0.34 1120 svchost 57 3 1028 996 30 0.39 932 atiptaxx 503 52 7296 3596 51 2.47 836 winlogon 259 6 1432 1340 19 2.48 880 services 341 8 3572 1856 40 5.36 892 lsass 240 158 29536 10388 175 5.58 1780 outpost 149 4 2940 1108 41 9.29 1248 kav 398 5 36140 26408 137 9.97 1984 powershell 375 12 15020 10456 75 14.03 1116 explorer 376 0 0 36 2 14.97 4 System 409 6 2500 3192 26 20.10 812 csrss 1513 54 13528 9800 95 25.78 1156 svchost 717 75 37432 704 145 56.97 1748 kavsvc 152 4 2372 2716 38 58.09 2028 wmiprvse 307 13 10952 27080 173 9128.03 1200 WINWORD 17.1.Для сортировки в обратном порядке используется параметр Descending:
PS C:\> Get-Process | Sort-Object cpu -Descending Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 307 13 10956 27040 173 9152.23 1200 WINWORD 152 4 2372 2716 38 59.19 2028 wmiprvse 717 75 37432 1220 145 57.15 1748 kavsvc 1524 54 13528 9800 95 26.13 1156 svchost 410 6 2508 3224 26 20.62 812 csrss 376 0 0 36 2 15.11 4 System 377 13 15020 10464 75 14.20 1116 explorer 374 5 36484 26828 137 10.53 1984 powershell 149 4 2940 1108 41 9.34 1248 kav 240 158 29536 10388 175 5.61 1780 outpost 344 8 3572 1856 40 5.40 892 lsass 512 53 7324 3608 51 2.51 836 winlogon 259 6 1432 1340 19 2.48 880 services 57 3 1028 996 30 0.39 932 atiptaxx 281 14 1764 1688 37 0.34 1120 svchost 140 5 3208 1220 41 0.32 1524 spoolsv 64 3 812 1080 29 0.30 1252 ctfmon 193 5 2916 1488 59 0.29 1040 svchost 170 5 4516 796 44 0.27 1260 GoogleToolbarNotifier 120 4 2364 1228 35 0.26 1876 svchost 22 2 504 712 23 0.15 772 winampa 55 3 1088 852 27 0.14 1220 svchost 39 1 364 464 17 0.13 1644 ati2evxx 163 6 1536 1404 35 0.12 1612 svchost 30 2 672 724 27 0.11 1700 WinCinemaMgr 21 1 164 60 4 0.09 748 smss 98 5 1104 764 32 0.09 252 alg 36 2 728 32 23 0.05 1792 klswd 0 0 0 16 0 0 Idle 17.2.В рассмотренных нами примерах конвейеры состояли из двух командлетов. Это не обязательное условие, конвейер может объединять и большее количество команд, например:
Get-Process | Where-Object {$_.Id -gt 1000} | Sort-Object cpu -Descendingwww.intuit.ru
