MyTetra Share
Делитесь знаниями!
Медицинская лицензия открытие рентген http://rospotreb.com/rentgen-mrt/.
Написание скриптов Windows Power Shell (обзор языка)
27.04.2015
12:11
Текстовые метки: Windows Power Shell, PowerShell, документация, скрипт, синтаксис
Раздел: Компьютер - Windows - Windows Power Shell

Написание скриптов Windows Power Shell

(обзор языка)


Вы уже знаете, что в простейшем смысле сценарий Windows PowerShell представляет собой цепочку последовательных команд, которые выполняются в порядке строгой очередности. Сценарий такого типа во многом схож с командными файлами или пакетными скриптами, которые используются в большинстве других оболочек, включая Cmd.exe в Windows. На более сложном уровне сценарии Windows PowerShell могут напоминать программы, написанные на таких языках как Microsoft Visual Basic Scripting Edition (VBScript), JavaScript, JScript, Perl и так далее. При необходимости можно создавать такие сценарии, которые будут предугадывать и исправлять конкретные ошибки – в этом случае вам потребуется потратить немало времени на настройку ваших скриптов, чтобы добиться их безупречной работы. Также сценарии можно моделировать, составляя их из отдельных блоков, чтобы использовать тот или иной блок в конкретной ситуации. В данном модуле вы узнаете, как использовать эти более сложные скриптовые элементы.

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


Хранение данных

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


Переменные

Задумайтесь на минуту о ярлыках в Windows Explorer. Вам, несомненно, приходилось создавать ярлыки для файлов и папок, а меню «Пуск» представляет собой нечто большее, нежели просто набор папок и ярлыков. Ярлыки обладают несколькими важными признаками:

• У них есть свойства, такие как текущий каталог, который устанавливается, когда ярлык открыт и путь файла, на который ярлык указывает.

• Ими можно манипулировать: перемещать, удалять, копировать, и.т.д.

• Сами по себе ярлыки не представляют интереса – они лишь указывают на что-либо, представляющее интерес (приложение или документ).

• Они указывают на то, что физически хранится в определенном месте.

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

Как и большинство динамически создаваемых элементов в оболочке, переменная существует только до тех пор, пока текущая сессия оболочки не завершена. Windows PowerShell создает диск variable:, на котором хранятся все переменные, которые были определены в оболочке. Этот диск содержит не только переменные, которые вы создаете, но и огромное количество переменных, которые определяются оболочкой и используются для хранения параметров конфигурации, влияющих на поведение оболочки. Оболочка предоставляет множество командлетов для управления переменными: увидеть их все можно, запустив команду:

Get-Command –noun variable

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

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

Remove-Variable –name var

Если вы поставите символ $ перед именем переменной, оболочка передаст параметру содержимое этой переменной:

$var = 'computername'

Remove-Variable –name $var

Данная команда удалит переменную $computername, а не переменную $var.

Имена переменных могут содержать пробелы и другие символы, но для этого имя следует заключить в фигурные скобки:

${My Variable} = 5

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

Windows PowerShell использует знак равенства (=) в качестве оператора присваивания. Это означает, что все, что находится справа от этого знака, является значением того, что находится справа:

$var = 5

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

На заметку: Если вы знакомы с VBScrip, у вас может возникнуть вопрос, есть ли здесь эквивалент Option Explicit. Об этом мы поговорим чуть позже.

К переменной можно привязать любой объект или группу объектов:

$services = Get-Service

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

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

$var = 100

$var

$var = "Hello"

Обратите внимание, что очистка переменной – это не то же самое, что ее удаление. В следующем примере переменная $var существует, но имеет нулевое значение:

$var = 100

$var = ''

$var = $null

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

New-Variable –name var –value (Get-Process)

Set-Variable –name var –value $null

Clear-Variable –name var

Remove-Variable –name var

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

Get-Variable

Или изучив содержимое диска variable:

Dir variable

Переменные могут передаваться по конвейеру другим командлетам; при этом в действительности передаются не сами переменные, а их содержимое:

$services | Sort Status | Select –first 10

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

$wmi = Get-WmiObject Win32_OperatingSystem

$wmi.Caption

$wmi.Reboot()


Строки

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

$var = "Hello"

$var = 'World'

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

PS C:\> $var = 'Hello'

PS C:\> $var2 = "$var World"

PS C:\> $var3 = '$var World'

PS C:\> $var2

Hello World

PS C:\> $var3

$var World

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

Как и во многих других оболочках, в Windows PowerShell есть символ перехода (экранирующий символ). Под символом перехода подразумевают обратный апостроф или `. На английской клавиатуре этот символ обычно расположен вверху слева под или рядом с клавишей Esc или Escape, как правило, на одной клавише со знаком тильды (~), но на других клавиатурах его расположение может варьироваться. По ссылке, указанной ниже, можно посмотреть раскладку клавиатуры в разных странах.

На заметку: при использовании некоторых шрифтов бывает сложно отличить обратный апостроф ` от обычного ‘. Старайтесь не путать их. Обратный апостроф может отменять особенное значение символов, которые идут вслед за ним. Например, в Windows PowerShell символ пробела имеет особое значение и используется в качестве разделителя. Однако при использовании обратного апострофа пробел теряет это значение и превращается в обычный буквенный символ:

Cd c:\program` files

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

PS C:\> $var = 'Hello'

PS C:\> $var2 = "$var World"

PS C:\> $var3 = "`$var contains $var"

PS C:\> $var2

Hello World

PS C:\> $var3

$var contains Hello

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

$var = "This `

is a `

singe line"

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

И, наконец, символ перехода может придавать особенные значения отдельным символам, которые обычно не имеют никакого значения. Например, `t может обозначать табуляцию, `n – новую строку, `r – возврат каретки в исходное положение, и.т.д. Более подробную информацию обо всех возможных значениях можно найти в соответствующем разделе справочника.

Ссылка: Windows International Keyboard Layouts, http://go.microsoft.com/fwlink/?LinkId=200517.


Массивы

Массив – это переменная, которая содержит более одного объекта. Например:

$var = 5

В данном примере $var не является массивом, так как она содержит всего один объект – число 5. Однако данная команда помещает массив объектов в переменную.

$var = Get-Service

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

$myarray = 1,2,3,4,5,6,7,8,9,0

Существует и более формальный способ обозначения новой переменной: использование символа @ и заключение списка значений в круглые скобки:

$myarray = @(1,2,3,4,5,6,7,8,9,0)

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

Работая с массивом, можно использовать порядковые номера для того, чтобы ссылаться на отдельные элементы. Первый объект в массиве имеет порядковый номер (индекс) 0. Использование индексов с отрицательным значением обеспечивает доступ к объектам с конца: -1 будет обозначать последний объект, -2 – предпоследний, и.т.д:

$services = Get-Service

$services[0]

$services[1]

$services[-1]

Массивы также обладают свойством Count, которое показывает количество объектов в массиве:

$services.count


Хеш-таблица

Вы уже знаете, как использовать хеш-таблицы с такими командлетами, как Select-Object и Format-Table. Хеш-таблица представляет собой разновидность массива. Каждый элемент в этом массиве состоит из ключа и значения, формируя пару ключ-значение. Например, когда вы использовали хеш-таблицу с командлетом Select-Object, вы имели два элемента: Lable (ключ) и Expression (значение):

Get-Process | Select @{Label='TotalMem';Expression={$_.VM + $_.PM}}

Символ @ в сочетании с фигурными скобками используется для создания хеш-таблицы. Когда вы создаете свою хеш-таблицу, вы можете использовать любые ключи и значения – ваш выбор не ограничивается только Label и Expression. После того, как вы создали хеш-таблицу, вы можете использовать ключи для извлечения значений:

PS C:\> $hash = @{"Server1"="192.168.15.4";"Server2"="192.168.15.11";

"Server3"="192.168.15.26"}

PS C:\> $hash.Server1

192.168.15.4

Символ @ используется в качестве оператора для создания как массивов, так и хеш-таблиц (которые, также, называются ассоциативными массивами); в простых массивах перечень значений указывается в скобках, тогда как в хеш-таблицах используются пары ключ-значение в фигурных скобках. Обращайте внимание на это различие. Хеш-таблица, как и любой массив, имеет свойство Count:

$hash.count

Вы можете передать объекты хеш-таблицы по конвейеру командлету Get-Member, чтобы увидеть другие свойства и методы.


Сплаттинг

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

$parms = @{"ComputerName"="Server-R2";

"Class"="Win32_BIOS";

"Namespace"="root\cimv2"

}

Затем используем символ @ в качестве сплат-оператора (оператора подстановки) и имя переменной без символа $ для передачи этой хеш-таблицы командлету:

Get-WmiObject @parms

Командлет работает как обычно, принимая имена параметров и значения из хеш-таблицы.

На заметку: Различные примеры использования символа @ могут сбить с толку. Его конкретное предназначение зависит от контекста, в котором он используется, но в любом случае, его использование так или иначе связано с массивами или хеш-таблицами (ассоциативными массивами).


Арифметические операторы

Арифметические символы используются для осуществления подсчетов в оболочке. Они оцениваются оболочкой в соответствии со стандартными правилами в порядке старшинства:

• Умножение (*) и деление (/) слева направо

• Сложение (+) и вычитание (-) слева направо

• Выражения в скобках рассчитываются слева направо и изнутри наружу.

Оболочка распознает такие величины как Кб, Мб, Гб и Тб. Кб равен 1,024, Мб - 1,048,576 и.т.д. Обратите внимание, что эти значения являются двоичными, а не десятичными (это означает, что 1 Кб не равняется ровно 1000). Символ + также является оператором для сцепления строк:

$var1 = "One "

$var2 = "Two"

$var3 = $var1 + $var2

$var3

One Two


Типы переменных

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

PS C:\> $a = 5

PS C:\> $b = "5"

PS C:\> $a + $b

10

PS C:\> $b + $a

55

Переменная $ - это целое число, однако, переменная $b – это строка, так как ее значение было ограничено кавычками. В данном примере конструкция $a + $b дает в результате 10. Объект в $b был временно конвертирован в целое число, чтобы арифметическая операция была успешно завершена. Оболочка самостоятельно решила сделать это, так как первая переменная содержала целое число, а вторая содержала объект, который не мог быть воспринят как целое число.

В примере $b + $a можно наблюдать обратную ситуацию. Оболочка сначала «увидела» строку, после чего скорректировала вторую переменную, превратив ее в подходящую для сцепления строк форму.

Такое поведение оболочки может иногда сбить с толку и привести к неожиданным результатам. Решением проблемы может стать детальное информирование оболочки о том, какой тип объекта вы планируете использовать в переменной. Это делается путем уточнения имени типа .NET Framework в квадратных скобках:

PS C:\> [int]$a = "5"

PS C:\> $a | gm

TypeName: System.Int32

В данном примере, несмотря на то, что "5" – это строка, оболочка в принудительном порядке конвертировала ее в целое число, чтобы поместить в переменную $a. Если бы конвертация была невозможна, вы увидели бы ошибку:

PS C:\> $a = "Hello"

Cannot convert value "Hello" to type "System.Int32". Error: "Input string was not in a correct format."

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

PS C:\> [string]$a = "Hello"

Наиболее распространенными видами объектов являются:

• String (строка)

• Int (integer) (целое число)

• Single и Double (плавающие числа)

• Boolean (Булев или логический тип данных)

• Array (Массив)

• Hashtable (хеш-таблица)

• XML

• Char (одинарный символ).

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


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

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

Оператор –contains позволяет узнать, содержится ли тот или иной объект в массиве. При этом он не просто сравнивает строки, например, он не скажет, содержит ли строка “Server1” подстроку “ver”. Вместо этого, происходит проверка всего объекта целиком:

$collection = "One","Two","Three"

$collection –contains "One"

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

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

$var = "Server1"

$var –like "server*"

Чувствительной к регистру является версия –clike. Опять же, для использования обратной логики применяются операторы –notlike и –cnotlike. Все четыре оператора в качестве подстановочного знака используют *.

Оператор –is определяет, относится ли объект к определенному типу:

$var = "CONTOSO"

$var –is [string]

Тесно связан с ним оператор –as, который пытается конвертировать данный объект в объект другого типа. Если конвертация невозможна, он обычно выдает пустое значение, такое как пустая строка или ноль:

PS C:\> $var = "CONTOSO"

PS C:\> $var2 = $var -as [int]

PS C:\> $var2

PS C:\>


Области действия

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

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

Область действия верхнего уровня в оболочке называется глобальной. Когда вы работаете непосредственно в командной строке, а не в сценарии, вы работаете в глобальной области действий. Эта область действий содержит определенные псевдонимы, отображения PSDrive, переменные и даже определенные функции. Все остальные области являются «детьми» или «внуками» (или даже «правнуками») глобальной области действий. Новая область действий появляется каждый раз, когда вы запускаете сценарий или выполняете функцию. Это может привести к образованию огромного количества вложенных областей и разветвленной иерархии. Например, представьте, что вы:

• Запустили сценарий;

• Сценарий содержит функцию;

• Функция выполняет другой сценарий

Этот последний сценарий будет уже областью действий четвертого поколения: глобальная область действия – область действия для первого сценария, область действия для функции – область действия для второго сценария.

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

• Переменные

• Функции

• Псевдонимы

 • PSDrives

Оболочка устанавливает по умолчанию ряд правил, касающихся областей действия.

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

• Если элемент не существует в текущей области действия, оболочка обращается к «родительской» области действия и ищет элемент уже там.

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

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

Gwmi win32_service

Каждая область действия начинает работу в виде пустой, «свежей» сессии. Вы не указали псевдоним Gwmi в этой области действия, поэтому, когда вы используете его, оболочка обращается к «родительской», глобальной области действия, чтобы проверить, существует ли этот псевдоним там. По умолчанию он существует, и оболочка использует псевдоним Gwmi, который указывает на Get-WmiObject. Такое поведение области действия является причиной того, что все псевдонимы, PSDrive диски и переменные, присутствующие в оболочке по умолчанию, работают в вашем сценарии: они обнаруживаются в глобальной области действия.

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

$var = 100

Вы получаете переменную $var внутри глобальной области действия, и эта переменная содержит целое число 100. Иерархия области действия будет выглядеть так:

• Global: $var = 100

Далее вы запускаете сценарий, который содержит следующее:

Write $var

Эта область действия не содержит переменную $var, поэтому, оболочка обращается к «родительской» области действия – глобальной. Переменная $var обнаруживается там, поэтому, целое число 100 возвращается в сценарий и сценарий выдает 100 в качестве выходных данных. Предположим, далее вы запустили сценарий, который содержит следующее:

$var = 200

write $var

Переменная $var сейчас создается в области действия сценария, и целое число 200 помещается в нее. Иерархия области действия сейчас выглядит так:

• Global: $var = 100

• Script: $var = 200

Новая переменная с именем $var сейчас была создана в области действия сценария, но переменная в глобальной области действия осталась неизменной. Сценарий выдает в качестве выходных данных 200, так как $var содержит именно это число. Это не влияет на глобальную область действия. Если, после того как сценарий будет выполнен, вы запустите из командной строки команду:

Write $var

Выходными данными будет являться число 100, так как переменная $var в глобальной области действия содержит именно его. Такая модель поведения относится ко всему, что создается в «дочерней» области действия. Здесь необходимо запомнить два базовых правила:

• Если вы читаете что-либо, не существующее в текущей области действия, оболочка пытается извлечь это из «родительской» области действия.

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

Запомните следующие общие правила:

• «Дочерняя» область действия может ЧИТАТЬ элементы, находящиеся в «родительской» области действия.

• «Родительская» область действия никогда не сможет прочитать или написать что-либо в «дочерней».

• Вы можете ПИСАТЬ только в текущей области действия.

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

Windows PowerShell не запрещает изменять элементы в «родительской» области действия. Однако обычно это считается не очень удачным методом работы. Если сценарий изменяет что-либо в глобальной области действия, бывает сложно предугадать, как эти изменения скажутся на работе других элементов оболочки. Все командлеты, имеющие отношение к элементам областей действия, имеют параметр –scope. К таким командлетам относятся:

• New-Alias

• New-PSDrive

• New-Variable

• Set-Variable

• Remove-Variable

• Clear-Variable

• Get-Variable

Параметр –scope может принимать несколько значений:

• Global – означает, что командлет относится к глобальной области действия.

• Script – означает, что командлет относится к области действия сценария. Если командлет запущен внутри скрипта, он влияет на область действия этого скрипта. Если он запущен в дочерней по отношению к скрипту области действия, он будет влиять на этот скрипт.

• Local – означает, что командлет относится к текущей области действия, которая запущена в данный момент.

• Также значением может быть целое число, где 0 обозначает текущую область действия, 1 – область действия, являющуюся родительской по отношению к текущей, и.т.д.

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

New-Variable –name var –value 100 –scope 1

Также вы можете использовать специальный синтаксис:

• $global:var относится к переменной $var в глобальной области действия.

• $script:var относится к переменной $var в текущей области действия (если текущая область действия - сценарий), или к ближайшей родительской области действия, являющейся сценарием.

• $local:var относится к переменной $var в текущей области действия.

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

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

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

• Никогда не пытайтесь модифицировать псевдонимы, PSDrive элементы, функции или переменные в «родительской» области действия. Изменения можно производить только в текущей области действия.

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


Объявление переменных и Strict Mode

Нет необходимости объявлять переменные заранее. Этот вопрос часто интересует администраторов, имеющих опыт работы с VBScript, так как в этом языке предусмотрена команда Option Explicit, которая требует заблаговременного объявления переменных. В Windows PowerShell нет точного аналога Option Explicit, однако, здесь есть командлет Set-StrictMode. Set-StrictMode позволяет задавать строгий режим, а версия 2.0 выполняет функции, сходные с Option Explicit. Сама команда выглядит так:

Set-StrictMode –version 2

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

Function MyFunction {

Write $var

$var = 1

Write $var

}

MyFunction

Write $var

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

Set-StrictMode -version 2.0

Function MyFunction {

Write $var

$var = 1

Write $var

}

MyFunction

Write $var

Ошибка возникает из-за того, что переменная $var упоминается дважды до того, как ей было присвоено значение в данной области действий (вы узнаете больше об областях действия на следующем занятии). Целью отображения ошибки является предупреждение простых синтаксических ошибок. Например, рассмотрим команду:

Function MyFunction {

$computer = 'Server2'

gwi Win32_ComputerSystem -comp $compter

}

MyFunction

В этом примере переменная $computer во второй раз была напечатана с ошибкой. Данный скрипт будет выполняться, но скорее всего появится сообщение об ошибке, указывающее на то, что WMI не мог установить соединение, так как пытался связаться с пустым значением имени компьютера. Это сообщение об ошибке может ввести в заблуждение, так как корректное имя сервера присутствует в скрипте, а команда Get-WmiObject была напечатана правильно, отдельно от переменной. Решить проблему поможет следующее изменение:

Set-StrictMode -version 2.0

Function MyFunction {

$computer = 'Server2'

gwi Win32_ComputerSystem -comp $compter

}

MyFunction

Сейчас оболочка выдает ошибку об использовании неинициализированной переменной $compter. Эта ошибка заставит вас обратить более пристальное внимание на настоящую проблему – опечатку в имени переменной.

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

Set-StrictMode -off

Function MyFunction {

Write $var

$var = 1

Write $var

}

$var = 3

MyFunction

Write $var

Он работает потому, что в первой выполняемой строчке кода переменной $var присваивается значение 3. Когда функция запущена, она может извлечь это значение из родительской области действия. Другими словами, переменной $var было присвоено значение в области действия скрипта и всех дочерних областях, поэтому, ошибки не возникает.


Управляющие операторы языка

Windows PowerShell предлагает языковые конструкции, которые являются идентичными многим другим скриптовым языкам. В основе ее синтаксиса лежит язык C#, хотя имеются сходства и со многими другими языками на основе C, такими как Java, JavaScript или PHP. У многих администраторов получается использовать Windows PowerShell для выполнения сложных задач даже без использования этих скриптовых конструкций. Данные конструкции необходимы, в первую очередь, для написания скриптов, предназначенных для выполнения сложного, многоэтапного процесса, где требуется принятие решений или выполнение повторяющихся мелких подзадач. Также они могут быть полезны для переходящих скриптов, основанных на более старых технологиях, таких как VBScript.

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

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


If….ElseIf…..Else

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

$octet = Read-Host 'Enter the third octet of an IP address'

if ($octet –lt 15 –and $octet –gt 1) {

$office = 'New York'

} elseif ($octet –ge 15 –and $octet –lt 20) {

$office = 'London'

} elseif ($octet –ge 21 –and $octet –lt 34) {

$office = 'Sydney'

} else {

throw 'Unknown octet specified'

}

Несколько замечаний, касающихся этой конструкции:

• Конструкция должна начинаться с блока if.

• Она может не включать блока elseif, а может включать несколько.

• Блоком else можно заканчивать конструкцию.

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

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

Условие или сравнительная часть скриптовой конструкции помещается в скобки. Условие может быть любой сложности и может содержать подвыражения в скобках. Однако целая конструкция должна в обязательном порядке иметь одно из двух решений: True (верное) или False (ложное). Обратите внимание, что Windows PowerShell отображает значение False в виде нуля, а значение True любым другим числом. Поэтому, если результатом сравнения будет ноль, утверждение будет признано ложным (False). Например, следующая конструкция будет иметь результат True:

if (5+5) {

write 'True'

} elseif (5-5) {

write 'False'

}

Код условия, он же код команды, которая выполняется, когда результатом сравнения будет значение True, заключен в фигурные скобки. При этом оболочка не устанавливает жестких правил форматирования – например, следующее оформление конструкции будет вполне приемлемым:

if (5+5) { write 'True' } elseif (5-5) { write 'False' }

Однако такую конструкцию не очень удобно читать. Поэтому, чаще всего рекомендуется структурировать код и располагать скобки в соответствии с общепринятыми стандартами. Например, распространенным стандартом форматирования является расположение открывающей фигурной скобки в новой строке после условия, а закрывающей – в новой строке после последнего условного утверждения или команды. Именно такой формат мы чаще всего использовали в данном курсе ранее и будем использовать в дальнейшем. Еще один часто используемый формат выглядит так:

if (5+5)

{

write 'True'

}

elseif (5-5)

{

write 'False'

}

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


Вложенные конструкции

Все конструкции могут быть вложенными в другие. Единственное правило здесь заключается в том, что они должны быть полностью вложенными. Это означает, что внутренняя конструкция должна быть закрыта раньше внешней. Написание каждого условного уровня с новой строки поможет вам убедиться, что вы все сделали правильно; многие сторонние редакторы предлагают дополнительные визуальные ключи, которые помогают контролировать правильность вложения конструкций. Вот пример вложенной конструкции If:

If ($ping.pingstatus –eq 0) {

$wmi = gwmi win32_operatingsystem –computer $computer

if ($wmi.buildnumber –ne 7600) {

write 'Incorrect build – ignoring computer'

}

}

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

If ($ping.pingstatus –eq 0) {

$wmi = gwmi win32_operatingsystem –computer $computer

if ($wmi.buildnumber –ne 7600) {write 'Incorrect build – ignoring computer'}}


Набор операторов

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

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

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

PS C:\> if ($var -eq 5) {

>>

Когда вы закончили ввод конструкции и закрыли ее, снова нажмите Return, чтобы запустить выполнение кода:

PS C:\> if ($var -eq 5) {

>> write 'is 5'

>> } else {

>> write 'is not 5'

>> }

>>

is not 5

PS C:\>

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

gwmi win32_logicaldisk | select deviceid, @{Label='DriveType';Expression={ if ($_.drivetype -eq 3) { write 'LocalFixed' } else { write 'NonFixed' }}}, Size

Эта однострочная команда включает командлет Select-Object, который использует пользовательские колонки. Выражение для этих колонок включает конструкцию If, но она не отформатирована в соответствии с рекомендациями. Выходные данные этой команды будут выглядеть примерно так:

deviceid                 DriveType             Size

--------                   ---------                  ----

A:                          NonFixed

C:                          LocalFixed           64317550592

D:                         NonFixed

Z:                          NonFixed             413256384512

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


Switch

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

$computer = 'LON-DC1'

switch ($computer) {

'LON-DC1' {

write 'London Domain Controller 1'

}

'SEA-DC1' {

write 'Seattle Domain Controller 1'

}

'LON-DC1' {

write 'London Domain Controller 1'

}

default {

write 'Unknown'

}

}

Несколько замечаний по поводу этой конструкции:

• Обратите внимание, что в выходных данных London Domain Controller 1 присутствует дважды, так как здесь есть два удовлетворяющих критерию предложения.

• Блок default является опционным и выполняется только в том случае, если в предыдущих блоках не было найдено удовлетворяющих критерию предложения.

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


Break

Ключевое слово Break прерывает выполнение любой конструкции кроме If…ElseIf…Else. Break можно использовать в сочетании с Switch для того, чтобы убедиться, что выполняется только первое удовлетворяющее критерию предложение.

$computer = 'LON-DC1'

switch ($computer) {

'LON-DC1' {

write 'London Domain Controller 1'

break

}

'SEA-DC1' {

write 'Seattle Domain Controller 1'

break

}

'LON-DC1' {

write 'London Domain Controller 1'

break

}

default {

write 'Unknown'

}

}

Выходными данными в этом примере является один London Domain Controller 1, так как ключевое слово Break немедленно прервало конструкцию после первого удовлетворяющего критерию предложения.


Опции Switch

Конструкция Switch включает несколько опций, влияющих на ее поведение. Одной из них является использование параметра –wildcard switch, который позволяет удовлетворяющему критерию предложению, являющемуся строкой, обрабатываться как строке с подстановочным символом. В следующем примере выходными данными будут “London” и “Domain Controller.” Обратите внимание, что ключевое слово Break не используется, а значит возможно несколько вариантов предложений, удовлетворяющих критериям:

$computer = 'LON-DC1'

switch -wildcard ($computer) {

'LON*' {

write 'London'

}

'SEA*' {

write 'Seattle Domain Controller 1'

}

'*DC*' {

write 'Domain Controller'

}

'*SRV*' {

write 'Member Server'

}

default {

write 'Unknown'

}

}

О других возможностях конструкции Switch можно узнать в соответствующем разделе справочника.


For

Эта конструкция обычно используется для повторения одной и той же команды указанное количество раз:

For ($i=0; $i –lt 10; $i++) {

Write $i

}

Несколько замечаний по поводу конструкции:

• Условия или критерии сравнения конструкции в действительности состоят из трех частей, разделенных точкой с запятой.

• В первой части задается стартовое условие, в данном случае $i=0.

• Вторая часть представляет собой условие, при котором цикл должен повторяться, в данном случае он будет повторяться до тех пор, пока $i меньше 10.

• Третья часть – это операция, которая будет выполняться каждый раз при завершении цикла, в данном случае это увеличение $i на один.

Разрешается менять переменную counter внутри самого цикла:

For ($i=0; $i –lt 10; $i++) {

Write $i

$i = 10

}

В данном примере цикл будет выполняться только один раз, так как в процессе выполнения $i выйдет за пределы обозначенного диапазона (меньше 10).

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

For ($i; $i –lt 10; $i++) {

Write $i

}

В данном примере $i идентифицирована как переменная цикла, но ей не присвоено стартовое значение. Оболочка вынуждена передвигаться по областям действия вверх и проверять, определена ли переменная $i в какой-либо из родительских областей. Если нет – переменной $i присваивается значение по умолчанию, ноль. Однако если $i была создана в одной из родительских областей действия, она может получить ненулевое значение или даже значение, не являющееся числом. Это может привести к неожиданным результатам и к длительным поискам ошибки. Поэтому, всегда рекомендуется задавать стартовое значение числовой переменной.


While-Do-Until

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

$var = 1

while ($var -lt 10) {

write $var

$var++

}

 

$var = 1

do {

write $var

$var++

} while ($var -lt 10)

 

$var = 20

do {

write $var

$var--

} until ($var -lt 10)


Несколько заметок об этих конструкциях:

• Когда критерии сравнения или условие находятся в конце конструкции, условный код внутри конструкции всегда выполняется как минимум один раз.

• Когда критерии сравнения или условие находятся в начале конструкции, Условный код внутри конструкции выполнятся только в том случае, если сравнение начинается с True. Это означает, что в некоторых ситуациях код не выполняется вообще.

• While может использоваться как в начале, так и в конце конструкции, а Until – только в конце.

• While и Until в конце конструкции выполняют одну и ту же функцию, но имеют противоположную логику.


ForEach

Данная конструкция выполняет ту же самую базовую задачу, что и командлет ForEach-Object: перечисляет ряд объектов. Условный код конструкции выполняется один раз для каждого входящего объекта. Во время каждого выполнения цикла следующий объект извлекается из набора и помещается в обозначенную вами переменную. Например:

$services = Get-Service

ForEach ($service in $services) {

Write $service.name

}

Обратите внимание, что синтаксис здесь слегка отличается от командлета ForEach-Object. Эта конструкция не содержит переменной $_, а ее условие содержит ключевое слово in. Это различие иногда вызывает путаницу, так как оболочка предусматривает псевдоним ForEach для командлета ForEach- Object. Это означает, что “foreach” является одновременно скриптовой конструкцией и псевдонимом для командлета. Оболочка может различить их, исходя из того, где они используются. Псевдоним используется только в цепочке команд, и обычно обладает объектами, которые передаются ему по конвейеру.

Get-Service | ForEach { Write $_.name }

Важно не путать эти две формы синтаксиса. Но действительно ли вам так нужен ForEach? Во многих случаях администраторы, имеющие некоторый опыт в программировании, в частности, в VBScript, используют ForEach- Object или конструкцию ForEach даже тогда, когда в этом нет острой необходимости. Конечно, в этом нет ничего страшного, кроме того, что они делают лишнюю работу. Например, рассмотрим отрывок кода, который удаляет все объекты в папке, если их размер превышает указанный:

$folder = 'c:\demo'

$files = dir $folder

foreach ($file in $files) {

if ($file.length –gt 100MB) {

del $file

}

}

Это очень «скриптовый» подход к созданию кода, который часто можно встретить в таких языках как VBScript. Однако Windows PowerShell позволяет создать куда более простую модель, так как большинство командлетов могут обрабатывать наборы объектов, не требуя их перечисления:

Dir c:\demo | where { $_.Length –gt 100MB } | Del

Каждый раз, когда вы собираетесь использовать ForEach или ForEach-Object, не забывайте подумать – а действительно ли это так необходимо? В некоторых случаях, например в тех, которые были рассмотрены в модуле, посвященном Windows Management Instrumentation, это необходимо. Однако во многих других ситуациях можно обойтись и другими средствами.


Стиль работы

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

gwmi win32_logicaldisk | select deviceid, @{Label='DriveType';Expression={ switch ($_.drivetype) { 2 { Write 'Floppy'; break } 3 { Write 'Fixed'; break } 4 { Write 'Optical'; break } 5 { Write 'Network'; break }}}}, Size, FreeSpace

Обратите внимание, что точка с запятой используется для разделения команд Write и Break внутри каждого блока, содержащего условие. Несмотря на то, что это все можно напечатать так, как показано в примере, при использовании форматирования блок будет легче читаться:

gwmi win32_logicaldisk |

select deviceid, @{Label='DriveType';Expression={

switch ($_.drivetype) {

2 { Write 'Floppy'; break }

3 { Write 'Fixed'; break }

4 { Write 'Optical'; break }

5 { Write 'Network'; break }

}

}

}, Size, FreeSpace

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

PS C:\> gwmi win32_logicaldisk |

>> select deviceid, @{Label='DriveType';Expression={

>>      switch ($_.drivetype) {

>>               2 { Write 'Floppy'; break }

>>               3 { Write 'Fixed'; break }

>>               4 { Write 'Optical'; break }

>>               5 { Write 'Network'; break }

>>      }

>> }

>> }, Size, FreeSpace

>>

Если вы ранее работали со скриптовыми языками, то, возможно, при изучении Windows PowerShell вы будете использовать те же подходы, которые применяются в этих языках. В этом нет ничего страшного – скриптовые конструкции Windows PowerShell созданы специально для того, чтобы вы могли перенести свои старые знания в новые условия. Однако не забывайте, что зачастую Windows PowerShell предлагает более простые способы выполнения тех же самых задач. Изучение этих способов позволить сделать работу с Windows PowerShell более эффективной, а также узнать о новых возможностях, предлагаемых оболочкой. В целом можно порекомендовать стараться чаще использовать цепочки команд вместо формальных скриптов. Для очень сложных задач написание сценария может стать верным решением, но во многих случаях можно обойтись более простыми и короткими командами.


Обработка ошибочных ситуаций

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

В сценарии a Windows PowerShell выделяют три большие категории ошибок:

• Синтаксические ошибки, которые, как правило, являются результатом опечаток или неправильного написания.

• Логические ошибки, которые означают, что сценарий выполняется верно, но результаты получаются не те, которые были запланированы.

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

Синтаксические ошибки проще всего выявить и предупредить. Сообщения об ошибках обычно направляют вас в нужное место – вам остается лишь пристально взглянуть на неправильно набранное слово, определить ошибку и устранить ее. Логические ошибки являются более сложными и требуют настройки сценария – об этом вы узнаете чуть позже. Логические ошибки обычно возникают, когда переменная или свойство имеет значение, несущее не ту информацию, которую вы ожидаете. Например, вы предполагаете, что свойство DriveType содержит строку Removable, а в действительности оно содержит числовое значение «5». И, наконец, ошибки выполнения по степени сложности решения находятся примерно посередине между синтаксическими и логическими. Ошибки выполнения не всегда можно предсказать заранее. Например, вы можете написать скрипт для подключения к удаленному компьютеру, но при попытке подключения выяснится, что у вас нет на это разрешения. На этом уроке мы остановимся на ошибках выполнения, которые не всегда можно предупредить, но можно предугадать возможность их возникновения во время написания скрипта.


$ErrorActionPreference

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

Get-WmiObject Win32_Service –computer Server1,Server2,Server3

Предположим, что во время запуска команды Server2 оказался в режиме оффлайн. Командлет успешно установил соединение с Сервером 1, но попытка подключения к Серверу 2 оказалась неудачной. Это непрерывающая ошибка. Командлет не может выполнить действие для Сервера 2, но он не прекращает работу и переходит к Серверу 3. Когда командлет сталкивается с ошибкой такого типа, он проверяет, что можно предпринять для ее решения. Информация о действиях, предпринимаемых для решения бесконечных ошибок, хранится во встроенной в оболочку переменной $ErrorActionPreference. Эта переменная может принимать одно из четырех значений:

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

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

• SilentlyContinue дает командлету инструкцию продолжать работу без отображения сообщения об ошибке.

• Inquire – дает командлету инструкцию обратиться к пользователю с запросом, чтобы пользователь мог самостоятельно выбрать, что следует сделать – остановить работу или продолжить.

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


Порочная практика

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

$ErrorActionPreference = "SilentlyContinue"

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


ErrorAction

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

Help about_commonparameters

Один из общих параметров - это –ErrorAction, имеющий псевдоним EA. Этот параметр может принимать те же четыре значения, что и переменная $ErrorActionPreference. Однако, в отличие от этой переменной, данный параметр осуществляет выявление и отображение ошибок только для одного командлета. Поэтому, если вы используете командлет, например, Get-WmiObject, вы можете отключить уведомления об ошибках именно для этого командлета с использованием параметра –ErrorAction или –EA:

Gwmi Win32_Service –computer Server1,Server2,Server3

–EA SilentlyContinue


Перехват ошибок

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

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

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

Если вы используете –ErrorAction Inquire, перехватываемое исключение генерируется только в том случае, если пользователь выбирает опцию «остановить командлет». После того, как вы дали командлету инструкцию превращать непрерывающие ошибки в прерывающие перехватываемые исключения посредством –EA Stop, у вас есть два варианта перехвата ошибки: с помощью конструкции Trap или конструкции Try…Catch

Прежде, чем мы перейдем к конструкциям Trap и Try…Catch, вспомните, что вы знаете об областях действия в Windows PowerShell.

Сама оболочка – это глобальная область действия. Каждый скрипт, который вы запускаете, создает свою собственную область действия. Функции (которые мы рассмотрим чуть позже) тоже содержатся в своих областях действия. Поэтому, если вы выполняете сценарий, который содержит функцию, вы имеете дело с деревом областей действия, которое выглядит примерно так:

• Глобальная область действия

• Область действия скрипта

• Область действия функции

Область действия функции является дочерней по отношению к скриптовой, а скриптовая, в свою очередь, является дочерней по отношению к глобальной. Если прерывающее исключение происходит внутри функции, оболочка сначала проверяет, собираетесь ли вы перехватить это исключение внутри этой же области, т.е. внутри функции. Если у вас нет способа сделать это, оболочка покидает область действия функции и переносит прерывающее исключение в родительскую область действия, в данном случае в скриптовую. С точки зрения скрипта, функция сама сгенерировала это исключение, поэтому, оболочка проверяет, есть ли внутри скрипта инструменты для того, чтобы перехватить и исправить исключение. Если таких инструментов не обнаружено, оболочка покидает область действия скрипта и обращается к глобальной области действия. С точки зрения глобальной области действия, исключение было сгенерировано всем скриптом, и оболочка начинает искать инструменты для перехвата и исправления ошибки в глобальной области действия. Это может показаться довольно сложным, но очень важно решить, какие действия предпринять в отношении ошибки. Говоря в общем, вы должны стараться перехватить и исправить ошибку в той области действия, в которой она возникла. Например, если функция содержит командлет Get-WmiObject, и вы хотите перехватить и исправить ошибки для этого командлета, конструкция перехвата ошибок должна быть включена в функцию. Таким образом, оболочке не придется выходить за пределы области действия функции для исправления ошибки.


Trap

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

trap {

write-host "Exception trapped!" -fore yellow -back black

continue

}

get-wmiobject win32_process -comp NotOnline -ea stop

В конце конструкции вы можете указать одно или два ключевых слова:

Continue – продолжает выполнение команды, которая указана в скрипте после исключения, не выходя за пределы текущей области действия.

Break – выходит за пределы текущей области действия и ищет средства для перехвата ошибки и ее исправления в родительской области действия.

Например, рассмотрим короткий скрипт:

trap {

write-host "Exception trapped in the script"

-fore green -back black

continue

}

function test {

trap {

write-host "Exception trapped in the function"

-fore yellow -back black

break

}

write-host "I am inside the function"

get-wmiobject win32_process -comp NotOnline -ea stop

write-host "I am still inside the function"

}

write-host "Running the function"

test

write-host "Finished running the function"

Ошибка возникает в командлете Get-WmiObject. Так как перехват ошибки указан в области действия функции, этот перехват выполняется. Перехват заканчивается ключевым словом break, поэтому оболочка выходит за пределы области действия функции и передает ошибку в родительскую область. Перехват определен и здесь, поэтому он выполняется. Перехват заканчивается ключевым словом continue, поэтому оболочка переходит к выполнению команды, указанной после перехвата. С точки зрения скрипта, ошибка произошла в функции test, поэтому выполнение команды продолжается в этой же области действий. Выходные данные скрипта будут выглядеть так:

Running the function

I am inside the function

Exception trapped in the function

Exception trapped in the script

Finished running the function

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

Ниже вы видите тот же самый скрипт с одной небольшой разницей: Перехват внутри функции сейчас заканчивается ключевым словом continue, а не break:

trap {

write-host "Exception trapped in the script"

-fore green -back black

continue

}

function test {

trap {

write-host "Exception trapped in the function"

-fore yellow -back black

continue

}

write-host "I am inside the function"

get-wmiobject win32_process -comp NotOnline -ea stop

write-host "I am still inside the function"

}

write-host "Running the function"

test

write-host "Finished running the function"

Выходные данные сейчас выглядят так:

Running the function

I am inside the function

Exception trapped in the function

I am still inside the function

Finished running the function

Вы поняли, почему? Когда произошла ошибка, был выполнен перехват внутри функции. Однако эта команда заканчивалась ключевым словом continue, поэтому, оболочка не вышла за пределы области действия функции и продолжила выполнений следующей команды. Поэтому, на этот раз отобразилась строчка I am still inside the function. Функция была выполнена до конца, а ошибка не была передана в скрипт. Поэтому, перехват в скрипте не был выполнен.

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

Конструкция перехвата, с которой вы только что познакомились, была общей, то есть, она подходит для любого типа прерывающих исключений. Windows PowerShell также позволяет определять перехват особых видов исключений, но для этого вы должны знать определенные типы классов исключений .NET Framework. Например:

trap [System.Management.Automation.CommandNotFoundException]

{"Command error trapped"}

Этот перехват выполняется только для исключений типа System.Management.Automation.CommandNotFoundException. Оболочка позволяет указывать несколько конструкций для перехвата, каждая из которых предназначена для конкретного типа исключений. Это один из способов выбирать разные инструменты для решения разных проблем. Однако определить нужное имя класса .NET Framework может оказаться сложно.

Также обратите внимание, что перехват – это отдельная область действия, как и функция. Перехват может получать доступ к переменным за пределами своей области действия, по общим правилам. Однако любые переменные, которые создаются или устанавливаются перехватом, относятся только к нему. Если вы используете перехват, чтобы изменить переменную, расположенную в родительской для него области действия, используйте командлет Set- Variable с параметром –scope.


Try…. Catch

Конструкция Try…Catch является более простой в использовании, чем конструкция Trap. Типичная конструкция такого типа выглядит так:

try {

gwmi win32_service -comp notonline -ea stop

} catch {

write-host "Error!"

}

Блок Try определяет команду, при выполнении которой, как вы предполагаете, может произойти ошибка, и для которой вы задали ErrorAction команды Stop. Если ошибка произошла, начинает выполняться код, указанный внутри блока Catch.

Так же, как и в случае с конструкцией Trap, вы можете указать несколько блоков Catch, каждый из которых будет выявлять определенный тип ошибок. Чтобы узнать больше об этой технике, запустите Help about_try_catch_finally.

После того, как выполнение кода внутри блока Catch закончилось, начинается выполнение команды, указанной после блока Try…Catch. Также вы можете задать блок Finally:

try {

gwmi win32_service -comp notonline -ea stop

} catch {

write-host "Error!"

} finally {

write-host "This executes either way"

}

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


Извлечение ошибок

При использовании конструкций Trap и Try вам, возможно, понадобится доступ к тому исключению, которое стало причиной запуска этой конструкции. Существует два способа добиться этого. Встроенная переменная $error содержит ошибки, встречающиеся в оболочке. $Error[0] – это последняя ошибка, $Error[1] – предпоследняя и.т.д. Также вы можете использовать параметр -ErrorVariable (или –EV) для того чтобы выявить ошибку, сгенерированную этим командлетов в переменную. Например:

Get-Content does-not-exist.txt –EA Stop –EV myerr

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

try {

gwmi win32_service -comp notonline -ea stop -ev myerr

} catch {

$myerr | out-file c:\errors.txt -append

}

Обратите внимание, что myerr не включает значок доллара, когда указывается в сочетании с параметром –EV, потому что на этом этапе вы лишь указываете имя переменной, а $ технически не является частью ее имени. Позже, когда вы действительно будете использовать саму переменную, знак доллара будет ставиться перед ее названием, чтобы указать оболочке, что это именно переменная, а не что-то другое.


Отладка

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

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

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

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


Отладочный вывод

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

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

$var = Read-Host "Enter a computer name"

Write-Debug "`$var contains $var

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

If ($var –notlike "*srv*") {

Write-Host "Computer name is not a server"

}

You might modify this as follows:

If ($var –notlike "*srv*") {

Write-Debug "$var does not contain ‘srv’"

Write-Host "Computer name $var is not a server"

} else {

Write-Debug "$var contains ‘srv’"

}

Обратите внимание, что был добавлен блок Else, поэтому скрипт будет генерировать трассировочные сообщения независимо от того, какое логическое решение будет принято. По умолчанию оболочка скрывает выходные данные Write-Debug. Чтобы они отображались, поместите переменную $DebugPreference в начало скрипта:

$DebugPreference = 'Continue'

Теперь выходные данные Write-Debug будут отображаться. Когда вы закончите отладку скрипта, удалять команды Write-Debug будет не нужно. Вместо этого снова скройте их выходные данные:

$DebugPreference = 'SilentlyContinue'

Таким образом, команда Write-Debug останется в скрипте на тот случай, если в дальнейшем она снова понадобится для отладки.

На заметку: Выходные данные Write-Debug отличаются от обычных выходных данных в окне консоли Windows PowerShell. Сторонние скриптовые редакторы могут перенаправить эти данные в другую панель, окно или страницу, позволяя таким образом отделить трассировочные сообщения от других данных.


Пошаговый отладчик

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

Set-PSDebug –step

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

Set-PSDebug –off

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


Контрольные точки

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

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

Условия контрольных точек могут быть следующими:

• Остановить выполнение сценария при достижении определенной строки.

• Остановить выполнение сценария при чтении определенной переменной.

• Остановить выполнение сценария, когда определенная переменная изменяется или пишется.

• Остановить выполнение сценария, когда определенная переменная читается или пишется.

• Остановить выполнение сценария при выполнении опрделенной команды или функции.

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

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

• Set-PSBreakpoint – создание нового условия контрольной точки.

• Remove-PSBreakpoint – удаление условия контрольной точки.

• Disable-PSBreakpoint - прекратить действие условия контрольной точки без его удаления.

• Enable-PSBreakpoint – возобновить действие остановленного условия контрольной точки.

• Get-PSBreakpoint – извлечь одно или несколько условий контрольной точки.

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


Отладка в ISE

Отладчик Windows PowerShell обеспечивает базовую визуальную поддержку для отладки, в первую очередь, в сочетании с контрольными точками. Визуальных средств для создания контрольной точки нет. Однако когда вы создаете контрольную точку по номеру строки для сценария (используя параметр –script командлета Set-PSBreakpoint), ISE отображает эту контрольную точку внутри скрипта, подчеркивая соответствующую строку. Когда вы запускаете этот скрипт, ISE позволяет наводить курсор мышки на имена переменных, чтобы увидеть их содержимое.


Модуляризация

По мере того, как вы будете создавать все более сложные и полезные сценарии, вам все чаще будет требоваться повторное использование одних и тех же фрагментов. Модуляризация – это технология запаковки фрагментов кода в более простые и легко читаемые единицы. Windows PowerShell предлагает несколько уровней модуляризации, каждый из которых сложнее предыдущего, и в то же время обеспечивает больше гибкости и функциональности.

Модуляризация предназначена для создания полезных, независимых компонентов для многократного использования. Цель модуляризации – ускорить процесс написания скриптов, позволяя повторно использовать готовые фрагменты из предыдущих проектов. В Windows PowerShell базовой формой модуляризации является функция. Вы уже встречались с понятием функции ранее – сейчас мы рассмотрим их назначение более подробно.

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

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

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

Для выполнения своей задачи функция должна получить особенный вид входящих данных. Функция никогда не должна пытаться получить доступ к информации, находящейся за пределами себя самой – это во многом снизит возможность ее повторного использования. Например, предположите, что вы имеете скрипт, содержащий функцию Get-ServerName. Если предполагается, что эта функция может читать переменные, содержащиеся в родительской оболочке, любой скрипт, в котором используется эта функция, должен содержать соответствующие переменные. Такая зависимость усложняет многократное использование функции в разных сценариях. Однако, поддерживая автономность функции, вы сможете с легкостью использовать ее в самых разных ситуациях.

Функции должны выдавать данные таким образом, чтобы их можно было использовать в разных ситуациях. В общем, это означает возможность передачи выходных данных по конвейеру. Например, функция, которая выводит данные напрямую в CSV файл, может использоваться только тогда, когда вам нужен результат в виде CSV файла. Функция, которая выводит выходные данные в конвейер, может использоваться в различных ситуациях, так как вы можете передать эти данные таким командлетам как Export- CSV, Export-CliXML, ConvertTo-HTML и другим.


Базовые функции

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

Function Do-Something {

# function code goes here

}

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

Do-Something

Командлет Write-Output – это верный способ извлечения выходных данных из функции. Этот командлет с псевдонимом Write отправляет объекты в конвейер, где они могут быть использованы другими командлетами. Существует три способа использования Write-Output. Предположим, вы имеете выходные данные в виде переменной с именем $var. Все три примера будут идентичными с функциональной точки зрения:

Write-Output $var

Write $var

$var

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

Return $var

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

Не используйте Write-Host для извлечения выходных данных из функции. Write-Host не передает данные в конвейер, напротив, он отправляет текст напрямую в окно консоли. Текст нельзя передать по конвейеру другому командлету, а значит, возможность повторного использования функции ограничивается.


Параметризованные функции

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

Существует два способа определить входящие параметры функции. Первый – это часть указание их как части функции:

Function Do-Something ($computername,$domainname) {

# function code goes here

}

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

Второй, и более предпочтительный способ определения входящих параметров функции выглядит так:

Function Do-Something {

Param(

$computername,

$domainname

)

# function code goes here

}

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

Function Do-Something {

Param($computername,$domainname)

# Function code goes here

}

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

Function Do-Something {

Param(

[string]$computername = 'localhost',

[string]$domainname = 'contoso.com'

)

# function code goes here

}

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

Function Do-Something {

Param(

[string]$computername = $(Read-Host 'Computer name'),

[string]$domainname = $(throw 'Domain name required.')

)

# function code goes here

}

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

Do-Something localhost 'contoso.com'

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

Do-Something –domainname contoso –computername localhost


Передача данных конвейером

Итак, вы узнали, как передать входящие значения функции с помощью параметров. Но функции также могут принимать данные по конвейеру. В нормальной параметризованной функции оболочка автоматически входящие по конвейеру данные в специальную переменную, которая называется $input. Указывать $input в качестве параметра не нужно. Однако имеет смысл перечислить элементы в $input, так как зачастую она содержит несколько объектов. Для этого лучше всего использовать конструкцию ForEach. Например:

function Do-Something {

param (

$domain = 'contoso.com'

)

foreach ($computer in $input) {

write "Computer $computer is in domain $domain"

}

}

'localhost','server1' | do-something -domain adatum

Обратите внимание, что входящие по конвейеру данные о двух именах компьютера помещаются в $input, тогда как "adatum" помещается в стандартный параметр $domain.

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


Функции-фильтры

Функции-фильтры предназначены специально для приема входящих данных из конвейера. Такая функция включает в себя три именованных скриптовых блока:

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

• PROCESS: этот блок выполняется один раз для каждого объекта, входящего по конвейеру. Внутри блока специальная переменная $_ содержит текущий объект.

• END: этот блок выполняется один раз, после того как все входящие объекты были обработаны. Его можно использовать для завершения работы, например, для закрытия базы данных.

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

function Do-Something {

param (

$domain = 'contoso.com'

)

BEGIN {}

PROCESS {

$computer = $_

write "Computer $computer is in domain $domain"

}

END {}

}

'localhost','server1' | do-something -domain adatum

Скриптовый блок PROCESS обычно работает так же, как встроенная конструкция ForEach, автоматически перечисляя входящие объекты, и помещая каждый объект по очереди в переменную $_. Обратите внимание, что обычные параметры тоже поддерживаются.


Cамостоятельное конструирование выходных данных

Функции-фильтры, с которыми вы только что познакомились, запускали команды Windows PowerShell и позволяли этим командам помещать выходные данные в конвейер. Таким образом, выходные данные этих команд превращались в выходные данные функций. Например, в предыдущих примерах сюда входили одно или два обращения к Get-WmiObject.

Windows PowerShell не всегда хорошо справляется с отображением выходных данных, когда в конвейере содержится несколько разных типов объектов, например, Win32_OperatingSystem и Win32_BIOS одновременно. Одним из способов исправления ситуации может стать самостоятельное конструирование выходных данных. Например, вы можете вывести текст и сформировать заголовки столбца, а затем заполнить каждую строку выходными данными. Windows PowerShell даже предлагает специального оператора форматирования –f, который упрощает процесс создания данных такого типа.

В двух предыдущих примерах выходными данными являлся текст, точнее, объекты String. Проблема здесь заключается в том, что текст сложно использовать повторно. Например, вам может понадобиться вывести данные в файл CSV, а не в текстовую экранную таблицу. Используя в качестве отправной точки два вышеописанных подхода, вы будете вынуждены переписывать часть функции, чтобы вывести данные в файл CSV. А если позже вам понадобятся выходные данные в формате XML, вы будете переписывать ее снова.

Как вы уже знаете, Windows PowerShell – это объектоориентированная оболочка, которая работает с объектами гораздо лучше, чем с текстом. В двух предыдущих примерах извлекались два класса WMI: Win32_OperatingSystem и Win32_BIOS. Поскольку это два разных класса, оболочка не может просто отобразить их в одной строчке таблицы – по крайней мере, с использованием средств форматирования, предлагаемых по умолчанию. Решением может стать вывод данных в виде текста, но, как мы знаем, это не лучший способ для Windows PowerShell.

Еще одним способом скомбинировать информацию разных типов может стать создание пустого пользовательского объекта:

$obj = New-Object PSObject

"PSObject" – это очень простой объект, который выступает в роли пустого, чистого холста или полотна. Ему можно придавать любые свойства. Например, свойство ComputerName добавляется следующим образом:

$obj | Add-Member NoteProperty ComputerName $computername

Таким образом добавляется новое свойство типа NoteProperty. NoteProperty – это статическое значение, придаваемое объекту. Новое свойство NoteProperty называется ComputerName, а его значением может быть все, что вы поместите в переменную $computername.

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

Write $obj

Так как вы отправляете в конвейер всего один объект, Windows PowerShell может с легкостью сформировать выходные данные. Также вы можете передать этот объект другим командлетам для того, чтобы сформировать CSV-файл, затем HTML, и.т.д. Используя выходные данные функции в виде объектов, вы упрощаете использование этой функции в дальнейшем в различных ситуациях.


Разные способы решения

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

Так, в предыдущем примере вы видели, как с помощью New-Object и Add-Member можно создать новый пользовательский объект. Еще одним подходом является использование Select-Object для придания пользовательских свойств новому пустому объекту:

function Get-Inventory {

PROCESS {

$computer = $_

$os = gwmi win32_operatingsystem -comp $computer

$bios = gwmi win32_bios -comp $computer

$obj = new-object psobject

$obj | select @{Label='ComputerName';Expression={$computer}},

@{Label='SPVersion';Expression={$os.servicepackmajorversion}},

@{Label='BIOSSerial';Expression={$bios.serialnumber}},

@{Label='BuildNo';Expression={$os.buildnumber}}

}

}

gc names.txt | get-inventory

Нельзя сказать, что какой-то один из этих подходов является верным – они оба работают и оба обеспечивают одни и те же результаты. Так что можете смело использовать тот, который кажется вам более удобным. Когда вы лучше познакомитесь с работой Windows PowerShell, вы поймете, что многие задачи можно выполнить с помощью одной-единственной команды, хотя эта команда может быть довольно сложной. Например, всю функцию Get-Inventory, показанную ранее, можно заменить одной сложной командой:

gwmi win32_operatingsystem -computer (gc names.txt) |

select @{Label='ComputerName';Expression={$_.__SERVER}},

@{Label='BuildNo';Expression={$_.BuildNumber}},

@{Label='SPVersion';Expression={$_.ServicePackMajorVersion}},

@{Label='BIOSSerial';Expression={

(gwmi win32_bios -comp $_.__SERVER).serialnumber

}}

Здесь первым запускается командлет Get-WmiObject. Его параметр –computerName получает выходные данные Get-Content, который читает текстовый файл, содержащий по одному имени компьютера в каждой строчке. WMI объект передается командлету Select-Object.

Первые три элемента в Select-Object создают пользовательские свойства объекта, которые используют свойства из Win32_OperatingSystem WMI объекта. Смысл этого – обеспечить пользовательские имена свойств, такие как ComputerName и BuildNo вместо того, чтобы использовать родные имена свойств класса WMI. Последний элемент в Select-Object создает пользовательское свойство, которое называется BIOSSerial. Это выражение свойства в действительности выполняет второй командлет Get-WmiObject для извлечения класса Win32_BIOS. Имя компьютера, передаваемое в этот Get-WmiObject, будет свойством __SERVER первого WMI объекта – это свойство содержит имя компьютера. Обратите внимание, что вся команда Get-WmiObject помещена в скобки – это заставляет оболочку выполнять команду, а скобки обозначают объект, который получится на выходе. Вслед за скобками идет точка, которая указывает на то, что мы хотим получить доступ к одному из элементов объекта, а затем имя этого элемента SerialNumber. Конечным результатом является то, что свойство SerialNumber объекта Win32_BIOS помещается в пользовательское свойство BIOSSerial в Select-Object.

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


Расширенные функции

Расширенная функция является чуть более «продвинутой» по сравнению с функцией-фильтром. Точнее говоря, расширенная функция – это функция-фильтр, которая имеет дополнительные атрибуты для параметров, которые принимают входящие данные. За счет этих атрибутов расширенные функции выглядят и ведут себя практически так же, как командлеты, написанные на языке .NET Framework. Так указывается функция и параметр для очень простой расширенной функции:

function Get-ComputerDetails {

[CmdletBinding()]

param (

[parameter(Mandatory=$true,ValueFromPipeline=$true)]

[string[]]$computername

)

BEGIN {}

PROCESS {

Вы заметите, что главное различие между расширенной функцией и фильтром заключается в наличии дополнительных атрибутов, таких как [CmdletBinding()], [parameter] и так далее. В данном примере параметр $computername был создан для приема одной или нескольких строк в качестве входных данных из конвейера, и является обязательным. При использовании этой технологии переменная $_ внутри блока PROCESS не является обязательной. Вместо нее входные данные могут помещаться в параметр $computername. Скриптовый блок PROCESS помещает один входящий объект в параметр $computername за один раз и выполняется один раз для каждого объекта.

Расширенные функции являются завершающим элементом модуляризации в Windows PowerShell: использование атрибутов параметров, которые выглядят как командлеты, позволит вам написать структуру, которая будет действовать практически так же, как и настоящие командлеты оболчки. При желании вы даже можете поместить справочник в функцию – как это сделать, вы узнаете в следующих разделах.

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


Так же в этом разделе:
← Содержание ...
 
MyTetra Share v.0.35
Яндекс индекс цитирования