Разное

Powershell вывод на экран переменной: Работа с переменными в Powershell объявление типов данных и вывод

29.05.2021

Содержание

Использование переменных для хранения объектов

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

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

Создание переменной

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

Эта команда не вернет никакой результат, потому что переменная $loc не имеет значения. Создать переменную и присвоить ей какое-либо значение можно одним действием. Windows PowerShell создает переменную, только если она еще не существует; в противном случае указанное значение присваивается существующей переменной. Для сохранения текущего местоположения в переменной $loc введите:

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


PS> $loc

Path
----
C:\temp

Для отображения сведений о содержимом переменных можно воспользоваться командлетом Get-Member. Передача переменной $loc по конвейеру командлету Get-Member показывает, что это объект класса PathInfo, так же как и вывод командлета Get-Location.


PS> $loc | Get-Member -MemberType Property


   TypeName: System. Management.Automation.PathInfo

Name		 MemberType Definition
----		 ---------- ----------
Drive		Property   System.Management.Automation.PSDriveInfo Drive {get;}
Path		 Property   System.String Path {get;}
Provider	 Property   System.Management.Automation.ProviderInfo Provider {...
ProviderPath Property   System.String ProviderPath {get;}

Управление переменными

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


Get-Command -Noun Variable | Format-Table -Property Name,Definition -AutoSize -Wrap

Кроме переменных, создаваемых пользователем в текущем сеансе Windows PowerShell, существует несколько системных переменных. С помощью командлета Remove-Variable можно очистить все переменные, не управляемые оболочкой Windows PowerShell. Введите следующую команду, чтобы очистить все переменные:


Remove-Variable -Name * -Force -ErrorAction SilentlyContinue

Это приведет к запросу подтверждения, как показано ниже:


Confirm
Are you sure you want to perform this action?
Performing operation "Remove Variable" on Target "Name: Error".
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help
(default is "Y"):A

Если после этого запустить командлет Get-Variable, будут показаны оставшиеся переменные Windows PowerShell. Поскольку в Windows PowerShell имеется еще и переменный диск, все переменные Windows PowerShell можно вывести командой:

Использование переменных Cmd.exe

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

Такие переменные передаются через диск с именем env:. Просмотреть переменные можно с помощью команды:

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


PS> $env:SystemRoot
C:\WINDOWS

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

Переменные в Windows PowerShell 2.0

Привет всем! Я Ro8 и сегодня мы с вами продолжим начатую в предыдущих статьях тему работы в Windows PowerShell 2.0, в этой статье мы поговорим об использовании переменных в сценариях Windows PowerShell.

«Переменная — одна из составляющих в сценариях Windows PowerShell.

В среде PowerShell имена переменных начинаются с символа $. Значение переменной задается с помощью оператора присваивания; в качестве оператора присваивания применяется символ =. Переменную можно создать, просто присвоив ей некоторое значение.»

 

Переменные в Windows PowerShell 2.0

 

Посмотрим информацию о командлете write-host, введя команду get-help write-host

Как видим, данный командлет отвечает за вывод информации на экран

Введем например последовательно друг за другом следующее: цифру 5, далее 5+5, 5-5, 5*5 и 5/5

Как видим, что мы вводим то и получаем на выходе, т.е введя число 5 получаем число 5, введя  5+5 получаем 10, введя 5-5 получаем 0, введя  5*5 получаем 25 и введя 5/5 получаем 1

Теперь попробуем сделать тоже самое используя write-host. Введем например команду write-host 5. После ввода команды получаем число 5

Также можно выполнить команду write-host www. remontcompa.ru. Как видим итог выполнения данной команды в качестве вывода получаем текст www.remontcompa.ru

Как говорилось выше, имена переменных начинаются с символа $

Создадим переменную $a и используя знак = присвоим ей значение 40. Для этого вводим следующее $a=40

Введя $a=40 мы создали переменную $a и присвоили ей значение равное 40

Теперь используя write-host выведем значение данной переменной введя write-host $a

Как видим, команда write-host $a вывела нам значение переменной  $a

Также значение переменной $a можно вывести просто обратившись к самой переменной, т.е ввести ее имя  $a. Результат — все то же число 40 

Переменная может содержать какое-либо арифметическое действие. Например зададим переменной $a значение равное 40+10, а именно  $a=40+10

Введя имя переменной  $a, получаем ее значение, а именно число 50

Или выведем значение переменной  $a введя write-host $a, также получаем число 50

Запустим среду для написания сценариев Windows PowerShell ISE

После запуска  Windows PowerShell ISE введем одну за другой следующие команды:

Clear — очистка экрана оболочки Windows PowerShell

write-host Числовые переменные PowerShell — вывод текста Числовые переменные PowerShell

$a=40 — создание переменной $a и присваивание ей значения 40

write-host $a — вывод значения переменной  $a

Введя данные команды выполним их, нажав на кнопку Выполнить сценарий (зеленый треугольник)

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

Напишем сценарий немного посложнее, используя три переменные

Вводим команды:

clear — очистка экрана оболочки Windows PowerShell 

write-host Числовые переменные PowerShell — вывод текста Числовые переменные PowerShell

$a=40 — создание переменной $a и присваивание ей значения 40

$b=20 — создание переменной $b и присваивание ей значения 20

$c=$a+$b — создание переменной $c и присваивание ей значения $a+$b

write-host $c — вывод значения переменной  $c

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

Напишем еще один сценарий, в котором переменная будет принимать значение командлета get-date

Вводим команды:

clear

write-host Время и дата

$a=»get-date» — создаем переменную $a и присваиваем ей значение командлета get-date, причем имя командлета пишем в двойных кавычках

&$a — выводим значение переменной  $a. Так как значением переменной  $a является командлет, для отображения значения перед именем переменной пишем знак &

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

Сохраним данные команды в виде сценария, выбрав Файл-Сохранить как…

Сохраняем сценарий в папке My_scripts

Указываем имя сценария (например Date), тип файла выбираем Скрипты PowerShell

Сохраненный сценарий Date

Переходим в папку My_scripts, введя команду cd C:\My_scripts

Используя команду get-childitem смотрим содержимое папки My_scripts. Как видим, в ней находится сценарий Date.ps1

После выполнения данного сценария выводится текст Время и дата и отображается время и дата на момент выполнения сценария

Метки к статье: Системные функции

PowerShell. Урок 5 | Windows IT Pro/RE

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

Встроенные переменные

Оболочка PowerShell дает возможность работать со многими встроенными переменными, содержащими такие данные, как сведения о главной папке ($PSHOME) и о текущей рабочей папке ($PWD).

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

dir variable: | sort name

Используя псевдоним dir, эта инструкция обращается к команде Get-ChildItem, которая в качестве аргумента принимает строку variable. Данный аргумент ссылается на накопитель Variable, один из нескольких накопителей, поддерживаемых средой PowerShell. Как многие, вероятно, догадались, упомянутый накопитель позволяет обращаться к встроенным и пользовательским переменным PowerShell, а также к их значениям.

Когда команда Get-ChildItem получит переменные и их значения, они будут переданы по конвейеру команде Sort-Object (представленной псевдонимом sort), и последняя отсортирует выходные данные по именам переменных. Если же операция сортировки не будет проведена, переменные будут отображаться в том же порядке, в каком они были считаны.

На экране 1 показана часть отсортированного списка переменных. Такой список может быть поистине бесценным ресурсом, если только вы будете помнить об одном важном обстоятельстве: при ссылке на встроенные и пользовательские переменные в коде PowerShell следует, как правило, перед именем переменной вводить символ доллара ($). К сожалению, в списке эти знаки перед именами переменных не указываются. Символы доллара позволяют легко отличать переменные от других элементов кода. Так, именно символ доллара помогает без труда отличать псевдоним pwd от встроенной переменной $PWD. В ряде случаев ставить знак доллара перед именем переменной не следует, но об этом мы поговорим несколько позже.

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

$pshome

то получим путь к главной папке оболочки PowerShell.

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

dir $pshome -filter *.dll

PowerShell поддерживает два типа встроенных переменных: приоритетные переменные (такие, как $MaximumErrorCount) и автоматические переменные (такие, как $PSHOME). Изменение значений приоритетных переменных допускается, тогда как значения автоматических переменных изменять нельзя. Если вы попытаетесь изменить значение автоматической переменной, то получите сообщение об ошибке. Список приоритетных переменных дан в справочном файле about_preference_variables. Если в вашей системе такого файла нет, его можно просмотреть в Internet по адресу technet.microsoft.com/en-us/library/bb978529.aspx. Список автоматических переменных дан в справочном файле about_automatic_variable. Дополнительные сведения о встроенных переменных можно найти в справочном файле about_shell_variable.

Чтобы изменить значение приоритетной переменной, достаточно указать ее новое значение с помощью оператора присваивания (=). Возьмем, к примеру, приоритетную переменную $MaximumErrorCount, которая определяет, сколько ошибок следует сохранять в журнале истории ошибок для текущего сеанса. По умолчанию эта переменная имеет значение 256. Чтобы заменить его на 260, выполните команду

$maximumerrorcount = 260

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

Переменные среды

В оболочке PowerShell для обращения к переменным среды используется накопитель Env. К примеру, следующая инструкция предписывает задействовать этот накопитель для получения переменных среды Windows, а также их значений, а затем ввести команду Sort-Object для сортировки выходных данных по именам переменных:

dir env: | sort name

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

$env: windir

Для получения списка файлов.dll в главной папке Windows нужно выполнить команду

dir $env: windir-filter *.dll

Значения переменных среды можно изменять. Допустим, переменная среды имеет значениеDocuments and Settingsadministrator и нам нужно присвоить ей новое значениеDocuments and Settingsadministratorhome. Мы можем с помощью оператора +, рассмотренного на уроке 3 (см. Windows IT Pro/RE № 5 за 2008 г.), присоединить строкуhome к значению переменной среды HOMEPATH:

$env: homepath =
$env: homepath + «home»

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

Пользовательские переменные

В отличие от некоторых языков сценариев, в среде PowerShell переменные можно использовать, предварительно не объявляя их явным образом. Достаточно просто указать значение переменной. В следующей инструкции переменной $var1 присваивается значение one two:

$var1 = «one two»

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

New-Variable var1 «one two»

Стоит отметить: в этой инструкции имя переменной не предваряется знаком доллара. Дело в том, что когда имя переменной передается в качестве аргумента команде New-Variable либо команде Set-Variable, Clear-Variable либо Remove-Variable (о них я расскажу ниже), символ доллара не используется.

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

New-Variable var1 «one two» `
-option ReadOnly

В данном случае в качестве аргумента параметра -option я указал ReadOnly. В этом качестве можно использовать и другие значения. При указании нескольких аргументов нужно разделять их запятыми. Полный список применяемых аргументов приведен в справочном файле New-Variable.

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

$var1 = «three»

Тот же результат можно получить с помощью команды Set-Variable:

Set-Variable var1 «three»

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

Set-Variable var1 «three» -force

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

А теперь давайте посмотрим, как сбрасывается значение переменной. Один из способов — присвоить ей значение null с помощью встроенной переменной $null:

$var1 = $null

Второй способ предполагает использование команды Clear-Variable:

Clear-Variable var1

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

Clear-Variable var1 `
-force

Наконец, если вы хотите вообще удалить переменную, можете использовать команду Remove-Variable:

Remove-Variable var1

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

Remove-Variable var1-force

Пожалуй, в большинстве случаев создавать, изменять и сбрасывать переменные можно просто с помощью оператора =. Однако, если вы хотите применять команды New-Variable, Set-Variable, Clear-Variable и Remove-Variable, обратите внимание, что дополнительные сведения о них содержатся в соответствующих справочных файлах.

Различные типы данных

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

$var1 = «one two»

Воссоздать переменную необходимо потому, что мы только что удалили ее с помощью команды Remove-Variable. Значения пользовательских переменных (как и значения встроенных переменных) можно получать, вводя с клавиатуры имя соответствующей переменной:

$var1

Переменной $var1 было присвоено строковое значение, поэтому в среде PowerShell оно хранится в виде строкового объекта. Для установления типа объекта мы можем воспользоваться методом GetType ():

$var1.gettype ()

На экране 2 показаны результаты выполнения всех этих инструкций.

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

$var1 = 123; $var1.gettype ()

PowerShell автоматически сохраняет это значение с использованием корректного типа (в данном случае Int32), как показано на экране 3. Обратите внимание, что в этом фрагменте кода имеется несколько инструкций. Как я уже отмечал на уроке 2 (см. Windows IT Pro/RE № 4 за 2008 г.), для завершения инструкции вручную можно использовать точку с запятой. Так что если вы будете пользоваться символами точки с запятой, то сможете размещать на одной строке несколько инструкций. В данном случае я расположил на одной строке две инструкции: в первой переменной присваивается числовое значение, а во второй возвращается тип данных.

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

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

$var1 = 12.34; $var1.gettype ()
$var1 = get-date; $var1.gettype ()

Первая строка кода предписывает сохранить переменную типа Double, а вторая строка — типа Date-Time, как показано на экране 3.

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

$var1 = «one two three»; $var1
$var1 = $var1 + «four»; $var1

Полученные результаты показаны на экране 4.

Теперь попытаемся проделать аналогичную операцию с числовыми значениями:

$var1 = 123; $var1
$var1 = $var1 + 4; $var1

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

$var1 = «123»; $var1
$var1 = $var1 + 4; $var1

Теперь число 4 присоединяется к исходному значению. Этот метод можно использовать применительно к любой строке:

$var1 = «one two three»; $var1
$var1 = $var1 + 4; $var1

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

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

$var1 = 123; $var1
$var1 = $var1 + «four»; $var1

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

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

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

Обратимся к примеру. Присвоим строковой переменной с именем $svc значение eventlog:

$svc = «eventlog»

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

Write-Output «The service is $svc».

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

Давайте теперь вместо двойных поставим одинарные кавычки:

Write-Output `
‘The service is $svc.’

На этот раз PowerShell рассматривает переменную как литеральное значение и выдает ее имя. Результат получается такой: The service is $svc.

Если вы хотите включить в строку как имя переменной, так и ее значение, можете использовать двойные кавычки (а не одинарные) и экранировать переменную, которую хотите использовать как литеральное значение, с помощью обратной кавычки (`):

Write-Output `
«The value of `$svc is $svc».

Отмечу, что обратная кавычка в конце первой строки используется здесь не как экранирующий символ, а как символ продолжения. При этом получается результат: The value of $svc is eventlog.

Если вы попробуете применить одинарные кавычки

Write-Output `
‘The value of `$svc is $svc.’

PowerShell включит в выходные данные всю строку в том виде, в каком она была введена — с обратной кавычкой и всем прочим: The value of `$svc is $svc.

Использование в качестве параметра одного только имени переменной

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

Get-Service $svc

Если заключить этот аргумент в двойные кавычки — вот так:

Get-Service «$svc»

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

Get-Service ‘$svc’

завершится ошибкой, поскольку PowerShell будет интерпретировать имя службы как ‘$svc’.

На следующих уроках

При создании эффективных сценариев переменные (будь то встроенные переменные, переменные среды или пользовательские переменные) играют жизненно важную роль. Вы сможете в этом убедиться, когда будете работать в окне командной строки или составлять сценарии. Рекомендую обязательно просмотреть справочные файлы PowerShell, где вы найдете дополнительные сведения о переменных, и поупражняться в их создании, а также в применении. Получите методы и свойства с помощью команды Get-Member. Поэкспериментируйте с ними. И когда вы будете работать с более сложным кодом, придется пользоваться переменными — а также их методами и свойствами — при составлении целого ряда сценарных решений.

Роберт Шелдон ([email protected]) — технический консультант и автор книг, статей и учебных материалов по Microsoft Windows, а также проблемам проектирования и реализации систем бизнес-аналитики


Экран 1. Считывание списка встроенных и пользовательских переменных

Экран 2. Создание строковой переменной

Экран 3. Присваивание переменной различных типов значений

Экран 4. Присоединение значений к переменной

PowerShell. Урок 5

Поделитесь материалом с коллегами и друзьями

powershell — PowerShell читает переменные из текстового файла

Я пытаюсь сделать программу, которая получает переменные из внешнего файла. Моя проблема заключается в том, что политика компании не позволяет пользователям запускать файлы ps1 (программа работает, потому что я компилирую ps1 в exe с помощью ps2exe), поэтому этот внешний файл должен быть в формате txt, csv или в другом текстовом формате. Я не хочу записывать эти переменные в исполняемый файл, потому что пользователям нужна некоторая гибкость в использовании значений, которые они используют.

Я попытался создать хеш-таблицу и получить переменные в нее с помощью ConvertFrom-StringData, но это испортило вывод.

File.txt

one = foo
two = bar

Prog.ps1

$variable = Get-Content ". \file.txt" | Out-String | ConvertFrom-StringData
Write-Host $variable.one
Write-Host "$variable.two"

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

Когда я хранил переменные в правильном формате в файле ps1 и вставил его в обычный

. .\file.ps1

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

Буду признателен за любые идеи о том, как заставить это работать. Я имею в виду, если это вообще возможно.

1

sgtGiggsy 29 Апр 2019 в 21:17

2 ответа

Лучший ответ

Ваша проблема — просто неправильное использование синтаксиса интерполяции внутри расширяемой строки ("...") :

"$variable.two" раскрывает $variable самостоятельно , за которым следует literal .two, поскольку для встраивания выражений в расширяемых строках вы должны заключить их в $(...) , т.е. в этом случае "$($variable.two)" — см. этот ответ для краткого изложения правил расширения строк PowerShell.

Возможно, что удивительно, Write-Host $variable.one без , включающий "..." — успешно получил доступ к значению свойства, поскольку это выражение значения , а не (неявно) расширяемое строка ; этот ответ содержит дополнительную информацию о том, как токены без кавычек анализируются в качестве аргументов команды.

Также:

  • Если вы работаете в PowerShell v3 или выше, Get-Content -Raw проще и эффективнее, чем . .. | Out-String, чтобы получить весь текстовый файл в виде одной многострочной строки.

  • Кроме того, Write-Host обычно неправильный инструмент для использования, если только цель не состоит в том, чтобы записать только на дисплей , минуя поток вывода об успешном завершении и, следовательно, возможность отправлять вывод другим командам, захватывать его в переменную , перенаправьте его в файл. В PSv5 + Write-Host пишет в информационный поток, чей вывод может быть захвачен, но только через 6>. См. Нижний раздел этого ответа для получения дополнительной информации.

Чтобы сложить все вместе:

$variable = Get-Content -Raw .\file.txt | ConvertFrom-StringData

'--- implicit output, to success stream'
$variable.one
$variable.two

'--- explicit to-host output, via expandable string'
write-host $variable.one
write-host "$($variable.two)"  # Note the $(...) around the property access

Вышеуказанные выходы:

--- implicit output, to success stream
foo
bar
--- explicit to-host output, via expandable string
foo
bar

0

mklement0 29 Апр 2019 в 18:40

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

Должен быть:

$variable = Get-Content ".\file.txt" | Out-String | ConvertFrom-StringData
Write-Host $variable.one
Write-Host "$($variable.two)"

Для получения дополнительной информации см. этот ответ.

0

Louis Matthijssen 29 Апр 2019 в 18:26

55908810

Как в PowerShell отфильтровать вывод командлета

Как в PowerShell фильтровать вывод командлета

Where-Object – фильтр. Сводим результаты PowerShell к самому необходимому

В предыдущих статьях рубрики я рассказывал о том, как с помощью конвейера (|), объединяющего несколько команд PowerShell в цепочку, можно создавать простые отчеты, например:

get-aduser –f * -pr lastlogondate | select samaccountname,lastlogondate | sort lastlogondate

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

Эту задачу позволяет решить команда where-object, которую практически никогда не вызывают по полному имени. В большинстве случаев для ее вызова используется where или знак вопроса (?). В предыдущих публикациях речь шла о парах команд PowerShell, состоящих из команды вывода учетных записей, соответствующих определенному критерию и команды-действия (применение определенного действия к извлеченному подмножеству AD). Рассматривались и некоторые команды, содержащие фильтры: get-aduser, search-adaccount и другие.

Where-object – это фильтр. Чтобы понять синтаксис команды, начнем с примера. Для вывода пользователей, не запускавших систему после 1 января 2013 года, построим следующий запрос:

get-aduser -f * | where {$_.lastlogondate -le «1 January 2013»}

Команда get-aduser извлекает все учетные записи пользователей домена. Результаты передаются по конвейеру команде where-object, которая проверяет каждый входящий объект на соответствие определенному критерию. Критерий, заключенный в фигурные скобки, заслуживает отдельного рассмотрения.

Запись –le означает «меньше или равно»; указанная справа дата также не вызывает вопросов. Остается разобраться, что такое $_.lastlogondate.

Как уже было сказано, where-object анализирует приходящие по конвейеру данные. Понятно, что утверждение (нечто) -le «1 January 2013» предполагает сопоставление этого (нечто) с указанной датой. Таким образом, данное (нечто) должно быть именно тем, что в данный момент приходит по конвейеру.

Для обозначения того, что передано по конвейеру, используется символ $_. Мы уже знаем, что PowerShell имеет переменные, позволяющие хранить временную информацию в памяти компьютера. Переменную можно узнать по первому символу – знаку доллара ($). Переменные можно создавать в ходе работы, но у PowerShell, как и у большинства сред построения сценариев, есть и встроенные переменные, например $true и $false, хранящие значения true и false. По аналогии логично было бы хранить текущее содержимое конвейера в переменной $pipeline, но вместо этого используется переменная $_, которая в данном случае хранит весь передаваемый по конвейеру объект – учетную запись пользователя.

Однако приведенный в нашем примере критерий предусматривает сопоставление с датой (1 января 2013 г.) не всего объекта пользователя, а лишь его свойства lastlogondate. Задачу извлечения лишь нужной информации решает добавление точки и имени свойства, в результате чего получается запись $_.lastlogondate. Итак, усовершенствованный с помощью where-object запрос будет выглядеть следующим образом:

get-aduser –f * -pr lastlogondate |? {$_.lastlogondate -le «1 January 2012»} | select samaccountname,lastlogondate | sort lastlogondate

С помощью where-object и $_ можно строить любые виды фильтров. Например, вывести имена всех пользователей, чье имя (SamAccountName) начинается с F, позволяет такой запрос:

get-aduser -f * | where {$_.samaccountname -like «f*»}

Может возникнуть вопрос: зачем было тратить столько времени на обсуждение параметра -filter команды get-aduser? Почему бы не применять для всех запросов единую форму:

get-aduser -f * | where {$_. -like»»}

С технической точки зрения, для этого нет противопоказаний, кроме одного: такой подход может привести к излишней трате полосы пропускания и времени сервера. Команда get-aduser с фильтром посылает команду контроллеру домена (DC), и DC возвращает лишь небольшое подмножество AD. Когда же результат get-aduser -f * подается на вход where-object, у DC запрашиваются все учетные записи пользователей, после чего локальный процессор отфильтровывает их, оставляя только нужные данные. Таким образом, where-object – отличный универсальный инструмент, однако следует избегать его применения, когда у исходной команды get-whatever уже есть встроенный фильтр.

Переменные Powershell — Системный Администратор

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

Создание переменных

Давайте создадим несколько новых переменных и проверим что все получилось

$a="Переменная1"
$b="12345"
$c=Переменная 3
$d=12345
Создание переменных

Мы видим что успешно созданы 3 переменные: $a, $b, $d . Переменная $c не создалась и вылезла ошибка. Дело в том что в переменной $c при объявлении мы добавили пробел но не поставили кавычки. Если необходимо занести в переменную текст с пробелом нужно обязательно использовать кавычки. Посмотрим тип созданных переменных.

$a.GetType().Fullname
$b.GetType().Fullname
$c.GetType().Fullname
$d.GetType().Fullname
Тип переменных

Переменная $a и $b имеют тип строка (System.String). Если с $a все понятно, там использовались буквы и цифра, то $b стала строкой только потому что мы занесли цифры в кавычки. А в переменной $d мы использовали цифры без кавычек, поэтому тип переменной стал число (System. Int32). Переменная $c выпала с ошибкой NULL потому как её не существует.

Важно помнить, если вы случайно попытаетесь присвоить значение переменной которая уже существует, старое значение в ней изменится на новое. Поэтому необходимо быть осторожным в именовании переменных, и перед созданием новой, просто введите в Powershell её название и нажмите Enter. Если переменная не существует то система ничего не выведет кроме пустой строки.

Хорошо, а если нам необходимо изменить тип переменной на нужный нам? Например сделать из переменной $d строку. Это возможно:

Мы просто указываем в квадратных скобках переменную string и на выходе получаем уже System.String

Типы данных Powershell

Рассмотрим какие типы данных бывают в Powershell

ТипКласс .NETОписание
[string]System.StringСтрока
[char]System.CharСимвол (как элемент кода UTF-16)
[bool]System.BooleanБулево (принимает значение $true или $false)
[int]System.Int3232-разрядное целое число
[long]System.Int6464-разрядное целое число
[decimal]System.Decimal128 битное десятичное число. В конце числа буква d обязательна
[single]System. SingleЧисло одиночной точности с плавающей запятой
[double]System.DoubleЧисло двойной точности с плавающей запятой
[DateTime]System.DateTimeПредставляет текущее время выраженное датой и временем суток.
[array]System.Object[]Массив. Предоставляет методы для создания, изменения, поиска и сортировки массивов
[hashtable]System.Collections.HashtableХеш-таблицы. Представляет коллекцию пар «ключ-значение», которые упорядочены по хэш-коду ключа. Отличие от массивов это использование именованных ключей вместо индексов.
Типы данных Powershell

Давайте присвоим переменной $e булево значение

Теперь $e имеет тип System.Boolean, добавим кавычки и посмотрим что будет

Переменная стала System.String. Сделаем из нее снова булево, но кавычки убирать не будем

Работаем с логикой

С датой также можно работать сделав преобразование из строки. Давайте создадим переменную $data и добавим текст “01/01/2001” это будет в формате строки

И теперь можно преобразовать эту строку в формат даты и посмотреть на вывод

Преобразуем строку в дату

Тут уже и без GetType видно что Powerhell преобразовал строку в дату, даже время поставил :). Данное преобразование может быть удобно для работы с таблицами. Когда необходимо импортировать таблицу с данными и позже преобразовать их из строк в другие типы данных.

Массив имеет тип System.Object[] и каждый элемент в массиве может иметь свой тип. Создадим переменную $massiv и добавим в неё 3 значения: два строковых и одно число. Затем определим тип каждого элемента обратившись к нему по очереди. Обратиться к элементу массива можно указав его порядковый номер в скобках []. Расчет начинается с 0.

$massiv="element1",2,"tri"
Работа с массивом

Рассмотрим последний тип данных это hashtable. Хеш-таблицы отличаются от массива тем что вместо индекса используют пару “ключ-значение”. Объявляется в таком формате: @{kluch2=”Nomer1″;kluch3=”Nomer2″;kluch4=”Nomer3″}. Давайте создадим переменную $hash и занесем в нее хеш-таблицу

[email protected]{kluch2="Nomer1";kluch3="Nomer2";kluch4="Nomer3"}
Хеш-таблица

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

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

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

Существует две области действия переменных: глобальная и локальная. Глобальная область действия используется на весь сеанс Powershell. Она состоит из переменных Powershell, системных переменных и переменных определенных в консоли (в рамках текущего сеанса Powershell). Локальные переменные работаю только в той области для которой они определены (функция или скрипт) не выходя за ее пределы.

Рассмотрим работу глобальной и локальной переменной на небольшом примере:

function func_test {
$test_local="LOCAL"
$test_local
$Global:test_global="GLOBAL"
$test_global
}

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

Локальная и глобальная переменные
Работа с переменными

Для работы с переменными существует 5 командлетов. Давайте посмотрим какие

Get-Command *Variable*

Для удобства сведем по ним данные в таблицу

НазваниеНазначениеОписание
Get-VariableПолучить значение переменойПозволяет получить значение переменной со всеми дополнительными параметрами. Если не указать название переменной, командлет выведет список всех текущих переменных Powershell.
New-VariableСоздать новую переменнуюСоздает новую переменную с возможностью задать дополнительные параметры. Можно создать переменную только для чтения, скрытую переменную или переменную с пробелом в имени
Set-VariableИзменить переменнуюИзменение значений в переменной. В случае отсутствия переменной с указанным именем, она будет создана.
Clear-VariableОчистить переменнуюУдаляет все значения в переменной, но не саму переменную. Тип переменой остается тот же что был до очистки значений.
Remove-VariableУдалить переменнуюУдаляет переменную со всеми ее значениями
Работа с переменными

Запустим командлет Get-Variable

Get-Variable

Мы видим список всех переменных Powershell, большая часть из них это системные переменные. Давайте посмотрим параметры переменной hash, та что чуть выше мы создали для хеш-таблицы.

Get-Variable hash

Видим что тут большее число параметров чем можно указать при заведение через знак $. Попробуем создать новую переменную только для чтения. После ее создания значение переменной нельзя будет изменить.

New-Variable -Name rd -Option ReadOnly -Value 100 -Description "Только для чтения"
Get-Variable -Name rd|Format-List
New-Variable rd

Попробуем изменить в ней значение

Set-Variable -Name rd -Value 200
Set-Variable rd

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

Remove-Variable -Name rd -Force

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

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

$fire=(Get-Process -Name firefox)|select Name, PagedMemorySize64
$fire

Мы можем продолжать дальше работать с этой переменной, можем выделить первый ее элемент

$fire|Select-Object -First 1
Переменные окружения

Переменные окружения Windows также доступны из Powershell. Доступ к ним можно получить через диск ENV:

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

Команда ECHO: вывод текста на экран консоли

Для вывода текста на экран консоли в Windows используется команда ECHO. Ещё одно её предназначение — переключение режима отображения команд на экране.

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

ECHO [ON | OFF]

Для вывода текста на экран консоли:

ECHO [Сообщение]

Взглянем на примеры использования команда echo.

Показать текущий режим отображения команд:

echo

Вывести на экран консоли сообщение «Привет!»:

echo Привет!

Вывод на экран имени текущего пользователя (значения переменной %USERNAME%):

echo %username%

Чаще всего команда echo используется в командных файлах. G > beepcmd.bat

Данная команда создаст файл beepcmd.bat, который выводит командой echo служебный символ 07 и включает писк динамика. При необходимости его можно вызывать в других командных файлах с помощью команды CALL.

Get-Variable (Microsoft.PowerShell.Utility) — PowerShell | Документы Microsoft

Получает переменные в текущей консоли.

В этой статье

Синтаксис

  Get-Variable
   [[-Name] ]
   [-ValueOnly]
   [-Include ]
   [-Exclude ]
   [-Scope ]
   [<Общие параметры>]  

Описание

Командлет Get-Variable получает переменные PowerShell в текущей консоли.Вы можете получить только значения переменных, указав параметр ValueOnly , и вы может фильтровать переменные, возвращаемые по имени.

Примеры

Пример 1: Получить переменные буквой

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

  Get-Variable m *  

Пример 2: Получить значения переменных буквой

Эта команда получает только значения переменных, имена которых начинаются с m.

  Get-Variable m * -ValueOnly  

Пример 3: Получить переменные двумя буквами

Эта команда получает информацию о переменных, которые начинаются либо с буквы M, либо с буквы. С.

  Get-Variable -Include M *, P *  

Пример 4: Получить переменные по области

Первая команда получает только те переменные, которые определены в локальной области. Он эквивалентен Get-Variable -Scope Local и может быть сокращен как gv -s 0 .

Вторая команда использует командлет Compare-Object для поиска переменных, определенных в родительская область (Область 1), но видны только в локальной области (Область 0).

  Get-Variable -Scope 0
Сравнить-объект (Get-Variable -Scope 0) (Get-Variable -Scope 1)  

Параметры

— исключить

Задает массив элементов, которые этот командлет исключает из операции. Подстановочные знаки разрешены.

Тип: Строка []
Позиция: Именованный
Значение по умолчанию: Нет
Принять ввод конвейера: Ложь
Принять подстановочные знаки: True

-включить

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

Тип: Строка []
Позиция: Именованный
Значение по умолчанию: Нет
Принять ввод конвейера: Ложь
Принять подстановочные знаки: True

-Имя

Задает имя переменной. Подстановочные знаки разрешены. Вы также можете передать имя переменной по конвейеру в Get-Variable .

Тип: Строка []
Позиция: 0
Значение по умолчанию: Нет
Принять ввод конвейера: True
Принять подстановочные знаки: True

— Область применения

Задает переменные в области действия. Допустимые значения для этого параметра:

  • Глобальный
  • Местный
  • Скрипт
  • Число, относящееся к текущей области (от 0 до числа областей, где 0 — текущий область, а 1 — ее родительский элемент)

Локальный — значение по умолчанию.Для получения дополнительной информации см. About_Scopes.

Тип: Строка
Позиция: Именованный
Значение по умолчанию: Нет
Ввод конвейера приема: Ложь
Принять подстановочные знаки: Ложь

— Только стоимость

Указывает, что этот командлет получает только значение переменной.

Тип: SwitchParameter
Позиция: Именованный
Значение по умолчанию: Нет
Прием конвейерного ввода: Ложь
Принятие подстановочных знаков: Ложь

Входы

Строка

Вы можете передать строку, содержащую имя переменной, в Get-Variable .

Выходы

PS Переменная

Этот командлет возвращает объект System.Management.AutomationPSVariable для каждой переменной, которую он получает. Тип объекта зависит от переменной.

Объект []

При указании параметра ValueOnly , если значение указанной переменной является коллекцией, Get-Variable возвращает [System.Object []] . Такое поведение предотвращает нормальную работу конвейера. обработка значений переменной по одному.Обходной путь для принудительного перечисления коллекций: заключите команду Get-Variable в скобки.

Банкноты

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

Запись-вывод — PowerShell — SS64.com

Запись-вывод — PowerShell — SS64.com

Записать объект в конвейер. Если команда является последней командой в конвейере, объекты отображаются в консоли.

 Синтаксис
      Запись-вывод [-inputObject]  Object  [] [ CommonParameters ]

Ключ
   -inputObject  Объект 
       Объект (ы) для отправки по конвейеру. 
       Переменная, команда или выражение, получающие объекты.
 

Стандартные псевдонимы для записи-вывода: echo, write

Write-Output записывает объекты в конвейер успеха. Чтобы вывод отображался только на экране, используйте вместо этого команду write-host или Write-Warning.

Если для записи-вывода передается строка символов без кавычек, они будут неявно обрабатываться как строка,
поэтому запись-вывод hello эквивалентна:
запись-вывод «привет»
, а запись-вывод hello world эквивалентна:
запись-вывод «привет» «мир»
Обратите внимание, это не то же самое, что запись-вывод «привет мир»

Write-Output может использоваться для отображения строк и других объектов на консоли. Однако, поскольку поведение по умолчанию — отображение объектов в конце конвейера, обычно нет необходимости использовать запись-вывод.Например, get-process | запись-вывод эквивалентна get-process

Установите размер буфера консоли как сверхширокий:

[Консоль] :: BufferWidth = 4096

запись и эхо — псевдонимы для записи-вывода

Примеры

Записать в конвейер строку, которая по умолчанию появится на экране:

PS C: \> $ myvar = «Быстрая коричневая лисица»
PS C: \> запись-вывод $ myvar

При запуске функции отобразится текст:

Test-function {Запись-вывод «вот какой-то текст»}
Тест-функция

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

$ результат = Тест-функция

«Мы привлекаем сердца своими качествами, мы их сохраняем. качествами, которыми мы обладаем «~ Жан Батист Антуан Суар

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

[Консоль] :: WriteLine («Hello world»)
Tee-Object — Отправляет входные объекты в два места.
Write-Debug — Записывает отладочное сообщение на дисплей хоста.
Write-Error — Записывает объект в конвейер ошибок.
Write-Host — Отображение объектов через пользовательский интерфейс хоста.
Write-Information — Запись в информационный поток данных (6).
Write-Progress — Отображение индикатора выполнения.
Write-Verbose — Записывает строку в подробный дисплей хоста.
Write-Warning — Напишите предупреждающее сообщение.


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

6 основных команд вывода Powershell

Привет, Дамиан Гарбус здесь.Я так рада, что вы здесь. Сегодня я хочу показать 6 самых основных команд Powershell для подготовки вывода. Если вы изучите Powershell, этот список поможет вам более эффективно использовать команды в вашем новом скрипте. На мой взгляд, изучение команд PowerShell похоже на изучение слов на иностранных языках. Если вы знаете больше, вы можете быстрее писать сценарии и автоматизировать свою работу.

Команды вывода Powershell

Хост записи

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

  Хост записи
Написать-Хост "Poshland"
Запись-Хост "Poshland" -ForegroundColor Green
$ x = Write-Host "Poshland" -ForegroundColor Green
$ x
(Write-Host "Poshland" -ForegroundColor Green) .GetType ()  
Хост чтения

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

  Read-Host "Пожалуйста, введите вашу строку"
$ x = Read-Host "Пожалуйста, введите свою строку"
 долларов США 
Запись-вывод

Эта команда очень похожа на Write-Host, но имеет очень важное значение. Результат этой команды может быть присвоен переменной, потому что это объект.

  Запись-вывод
Write-Output -InputObject "Poshland Blog"
$ x = Write-Output -InputObject "Poshland Blog"
$ x
$ x.GetType ()  
Подробная запись

Write-Verbose — это особая команда, очень важная при написании скриптов и функций Powershell. Он используется, когда вы хотите распечатать более подробную информацию о результатах скрипта, но только в подробном режиме. См. Пример:

  [cmdletbinding ()]
 Param ()
 Write-Verbose «Мой скрытый вывод только для подробного режима»
 Запись-вывод «Вывод сценария»  
Предупреждение о записи

Следующая очень важная команда в Powershell.Вы можете использовать эту команду в своем скрипте или функции, чтобы показать предупреждение. По умолчанию он только печатает вывод, и вы не можете присвоить результаты этой команды переменной. В будущем я напишу о командах «try {} catch {}», которые позволят вам более эффективно использовать команду Write-Warning.

  Предупреждение о записи - сообщение «Мое настраиваемое предупреждение»
$ x = Write-Warning -Message "My Custom Warning"  
Ошибка записи

Вы часто видели красную ошибку в консоли Powershell? Команда Write-Error помогает подготовить пользовательскую ошибку и отобразить ее в консоли Powershell.Как и команда Write-Warning, Write-Error также может быть расширена с помощью команды «try {} catch {}».

  Сообщение об ошибке записи «Мое собственное сообщение об ошибке»  

Заключение

Приведенный выше список поможет вам подготовить вывод в ваших скриптах или консоли Powershell. Вы можете протестировать все приведенные выше команды прямо сейчас в консоли Powershell. Какую из вышеперечисленных команд вы используете чаще всего?

Вывод на экран или в файл на кончиках ваших пальцев

Печать значений или текста — обычная функция, которую мы выполняем при программировании. Это значение может быть конечным результатом или даже промежуточным значением, позволяющим понять, работает ли ваша программа должным образом. Мы часто печатаем значения для отладки и понимания причины ошибки. Независимо от того, как вы ее используете, печать — важная функция в любой программе. В PowerShell есть несколько вариантов печати вывода / значений, и это именно то, что мы рассмотрим в этой статье.

Печать значений в командной строке

Один из наиболее распространенных способов проверки значения или вывода — это распечатать его в командной строке или в окне PowerShell.Для этого есть две команды: Write-Host и Write-Output

.

Вы можете использовать это так:

 Write-Host "Hello world!"
 
 Запись-вывод «Hello world!»
 

Обе команды напечатают «Hello world!» в командной строке.

Параметры записи-вывода

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

  • -InputObject: указывает объект, который вы хотите отправить следующей команде в конвейере
  • -NoEnumerate: запрещает командлету перечислять выходные данные

Параметры узла записи

Этот командлет является оболочкой для командлета Write-Information и был представлен в PowerShell 5.0. Его задача — записывать вывод прямо в информационный поток. Вот некоторые из параметров, которые вы можете использовать с ним:

  • -BackgroundColor: указывает цвет фона
  • -ForegroundColor: изменяет цвет текста
  • -NoNewLine: между строками вывода не вставляются пробелы
  • -Separator: указывает символ, который должен использоваться в качестве разделителя при выводе на печать

Итак, в чем разница между двумя командами? Чтобы понять эту разницу, давайте разберемся, как PowerShell работает с печатью значений.

Конвейер PowerShell

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

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

Разница между хостом записи и выходом записи

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

Write-Output отправляет значение механизму объектного потока PowerShell, который, в свою очередь, отправляет объект следующей команде. Если команд нет, значение выводится непосредственно на хост.

Давайте посмотрим на пример.

 Изменение функции Цвет
{
процесс {Write-Host $ _ -ForegroundColor Red}
}
Запись-вывод "Hello world!" | сменить цвет
 

Когда вы выполняете указанную выше команду, значение «Hello world!» будут напечатаны красным цветом, потому что функция Write-Output отправляет значение через механизм объектного потока PowerShell методу, изменяющему цвет.

Теперь, если вы просто напечатаете…

 Запись-вывод «Hello world!»
 

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

Аналогично, когда вы выполняете этот код…

 Write-Host "Hello world!" | сменить цвет
 

… вы заметите, что слова «Hello world!» печатаются цветом по умолчанию, а не красным, и в этом заключается разница.

В методе Write-Host значения не отправляются механизму objectFlow, а отправляются непосредственно на хост, как следует из названия. В этом случае все остальные инструкции игнорируются, и значение выводится прямо на экран.

Конечно, у вас есть выбор форматировать вывод так, как вы хотите, в методе Write-Host, используя множество опций, которые идут с ним. Чтобы изменить цвет шрифта на красный, необходимо написать:

 Write-Host "Hello world!" -ForegroundColor Красный
 

Понимание этой разницы — ключ к печати значений в командной строке.

Еще один пример. Вы также можете изменить цвет фона с помощью Write-Host:

 Изменение функции Цвет
{
процесс {Write-Host $ _ -BackgroundColor Red}}
Запись-вывод "Hello world!" | сменить цвет
 

Печать значений в файл

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

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

Например:

 Get-Process | Исходящий файл -Filepath \ testfile.txt
 

Этот код распечатает все процессы в файл с именем testfile.txt и создаст новый файл, если нет файлов с таким именем.

Так вот, это может стать поводом для беспокойства. Что делать, если существует другой файл с таким же именем, и вы не хотите, чтобы ваша команда перезаписывала этот файл? Просто используйте параметр NoClobber.

 Get-Process | Исходящий файл -Filepath \ testfile.txt -NoClobber
 

Эта команда выдаст ошибку, если файл с именем testfile.txt уже существует. Многие параметры параметров поставляются с командой Out-File, и некоторые из них:

  • -InputObject: позволяет указать переменную, которая должна быть записана в файл.
  • -Encoding: для кодирования вывода в определенном формате, таком как ASCII, Unicode, UTF7, UTF8, UTF32 и др.
  • -Ширина: ограничивает каждую строку файла указанными вами символами.
  • -Append: добавляет значение в конец файла.
  • -Подтвердить: Подтверждает с вами перед продолжением.
  • -FilePath: дает возможность указать конкретный путь к файлу.
  • -Force: перезаписывает существующий файл, доступный только для чтения.
  • -NoNewLine: гарантирует, что файл не заканчивается символом новой строки.

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

Печать PowerShell: экран или файл

Как видите, вы можете выводить значения в PowerShell на экран или в файл. В первом случае вы можете использовать Write-Host или Write-Output, в зависимости от ваших предпочтений и процесса программирования, а во втором — использовать командлет Out-File.

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

Рекомендуемое изображение: Shutterstock

Просмотры сообщений: 8,955

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


Главная »Учебники» Печать PowerShell: вывод на экран или в файл прямо у вас под рукой

Работа со значениями и переменными в PowerShell — Microsoft Certified Professional Magazine Online

Проф.Powershell

Работа со значениями и переменными в PowerShell

Один или несколько объектов — в руках PowerShell. Совет этой недели — хороший тому пример.

  • Джеффри Хикс
  • 02.10.2012

Если вы следили за мной какое-то время, вы, вероятно, слышали, как я упоминал, что PowerShell — это все об объектах. Работа с объектами в конвейере — вот что делает PowerShell таким замечательным механизмом автоматизации.Но иногда нам нужно работать с одним объектом, а иногда и с одним свойством этого объекта. Протеже PowerShell может быть непросто в этом разобраться.

Допустим, вы получили объект службы и сохранили его в переменной:

PS C: \> $ s = бит службы

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

PS C: \> $ s. DisplayName
Фоновая интеллектуальная служба передачи

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

PS C: \> Write-Host «Анализируем $ s.displayname» — передний план Зеленый
Анализируем System.ServiceProcess.ServiceController.displayname

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

PS C: \> $ display = $ s.DisplayName
PS C: \> Write-Host «Анализ $ display» -Foreground Green
Анализ фоновой интеллектуальной службы передачи

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

PS C: \> $ msg = «Анализ {0}» -f $ s.DisplayName
PS C: \> Write-Host $ msg -Foreground Green
Анализ фоновой интеллектуальной службы передачи

Или вы можете использовать подвыражение:

PS C: \> Write-Host «Анализ $ ($ s.displayname)» -foreground Зеленый
Анализ фоновой интеллектуальной службы передачи

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

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

PS C: \> get-process | сортировать Рабочий набор | выберите -последний 1 путь

Путь
—-
C: \ Users \ Jeff \ AppData \ Local \ Google \ Chrome \ Application \ chrome.exe

Но на самом деле я хочу сохранить только путь к переменной.

PS C: \> $ proc = get-process | сортировать Рабочий набор | select -last 1 path
PS C: \> get-item $ proc
get-item: Не удается найти диск. Диск с именем «@ {Path = C» не существует.
В строке: 1 символ: 9
+ get-item <<<< $ proc
+ CategoryInfo: ObjectNotFound:
(@ {Path = C: String) [Get-Item], DriveNotFoundException
+ FullyQualifiedErrorId:
DriveNotFound, Microsoft .PowerShell.Commands.GetItemCommand

Почему это не сработало? Что ж, посмотрим на $ proc:

PS C: \> $ proc

Обрабатывает NPM (K) PM (K) WS (K) VM (M) Идентификатор процессора (ов) Имя процесса
——- —— —— —— — — —— — ————
131 24 111196 112544 253444.96 2544 хром

У меня действительно есть полный объект. Зная это, я мог обойтись:

PS C: \> get-item $ proc.path

Каталог: C: \ Users \ Jeff \ AppData \ Local \ Google \ Chrome \ Application

Режим LastWriteTime Длина Имя
—- ————- —— —-
-a — 29.08.2012 22:58 1229848 хром .exe

Или, если мне действительно нужно только свойство path, я могу использовать параметр -ExpandProperty с Select-Object.В результате получается только значение:

PS C: \> $ proc = get-process | сортировать Рабочий набор | выберите -last 1 -ExpandProperty Path
PS C: \> $ proc

C: \ Users \ Jeff \ AppData \ Local \ Google \ Chrome \ Application

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

PS C: \> $ procpaths = get-process | где {$ _. path} | выберите -ExpandProperty Path -Unique

Массив $ procpaths теперь представляет собой набор строк, что упрощает выполнение чего-то вроде этого:

PS C: \> $ procpaths | группа {Split-Path $ _} | Выбрать — развернуть имя | Out-файл c: \ work \ procpathparents.txt

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


Об авторе

Джеффри Хикс — ветеран ИТ с более чем 25-летним опытом работы, большую часть которого он провел в качестве консультанта по ИТ-инфраструктуре, специализируясь на серверных технологиях Microsoft с упором на автоматизацию и эффективность.Он многолетний обладатель награды Microsoft MVP в области Windows PowerShell. Сегодня он работает как независимый автор, тренер и консультант. Джефф написал статьи для множества онлайн-сайтов и печатных изданий, работает редактором Petri.com и часто выступает на технологических конференциях и в группах пользователей.

переменных PowerShell — Javatpoint

Переменные — это фундаментальная часть Windows PowerShell.Мы можем хранить все типы значений в переменных PowerShell. Например, мы можем хранить результат команд и элементы, которые используются в выражениях и командах, такие как пути, имена, настройки и значения. Фактически, они хранят именно объекты, объекты Microsoft .NET Framework.

Переменная — это единица памяти, в которой хранятся данные. В Windows PowerShell имя переменной начинается со знака доллара ($) , например $ процесс , $ a .В именах переменных регистр не учитывается, они включают пробелы и специальные символы. По умолчанию значение всех переменных в PowerShell составляет $ null .

Примечание. В Windows PowerShell специальные символы имеют особое значение. Если мы используем специальные символы в именах переменных, нам нужно будет заключить их в фигурные скобки {}.
Допустимые имена переменных: Неверные имена переменных:
$ myVariable, моя переменная,
$ MyVariable_1, $ моя-переменная,
{моя-переменная} $ моя переменная

Создать переменную

Мы используем оператор присваивания (=), чтобы присвоить переменной заданное значение. Мы можем создать переменную, присвоив ей значение.

Следующие примеры используются для создания переменной:

Пример 1:

$ vrb = 201

Команда в этом примере присваивает целочисленное значение 201 переменной с именем $ vrb .

Пример 2:

$ mySubject = «PowerShell»

Команда в этом примере создает переменную с именем $ mySubject и присваивает ей строковое значение.В этом примере $ mySubject — это строковый объект.

Распечатать значение переменной

Чтобы отобразить значение переменной, введите имя переменной и знак доллара «$».

Следующий пример используется для печати значения переменной:

Пример:

Вторая команда $ a в этом примере отображает значение переменной как « javatpoint ».

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

Если вы хотите изменить значение переменной, присвойте этой переменной новое значение.

Пример:

Команда $ PowerShell на приведенном выше экране отображает значение переменной $ PowerShell .

Команды на следующем экране изменяют значение переменной $ PowerShell и отображают новое значение переменной $ PowerShell .

Удалить переменную

Если вы хотите удалить значение переменной, используйте командлет clear-variable или измените его значение на $ null .

Пример:


Тип переменной

Если вы хотите узнать тип переменной, вы можете использовать метод GetType () .

Диапазон изменения

Переменные

PowerShell могут иметь «область », которая определяет, где переменная доступна. Для обозначения переменной используйте следующий синтаксис:

$ [<модификатор-области>:] <имя> = <значение>

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

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

$ Global: переменная = <значение>

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

$ переменная = <значение>

  • Скрипт: Те переменные, которые создаются во время скрипта. Эти переменные доступны только для того сценария, в котором они созданы.Для обозначения переменной скрипта используйте следующий формат:

$ script: переменная = <значение>

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

Ниже приведены различные типы переменных в Windows PowerShell:

  1. Переменные, созданные пользователем.
  2. Автоматические переменные.
  3. Предпочтительные переменные.

Пользовательские переменные

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

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

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

Переменные предпочтений

Переменные

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


Как использовать объекты PowerShell и конвейерную передачу данных

Эта статья представляет собой текстовую версию урока из нашего видеокурса по PowerShell и Active Directory Essentials (используйте код «блог» для бесплатного доступа).

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

Получите бесплатный видеокурс PowerShell и Active Directory Essentials

Я бы порекомендовал это как новым, так и опытным пользователям PowerShell. Создание инструмента AD — отличный учебный опыт.

Что делает объект PowerShell?

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

Рассмотрим что-то вроде машины. Имеет:

  • Цвета
  • Двери
  • Фары
  • Колеса

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

Свойства: аспекты и детали объекта.
Методы: действий, которые может выполнять объект.

Что такое конвейер PowerShell?

Оболочка

PowerShell была вдохновлена ​​многими замечательными идеями, составляющими «Философию Unix» — наиболее заметными для нас сегодня являются два момента:

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

На практике эти несколько абстрактные точки философии означают, что вы должны создать множество небольших целенаправленных сценариев PowerShell, каждый из которых выполняет определенную задачу. Каждый раз, когда вы ставите If / Else, еще один флаг, еще одну часть логики ветвления, вы должны спрашивать себя: «Не лучше ли это использовать в виде отдельного скрипта?»

Пример: не создавайте скрипт, который загружает файл, а затем анализирует загруженные данные.Сделайте два скрипта:

  1. Тот, который скачивает данные — download.ps
  2. Секунда, которая обрабатывает данные для преобразования во что-то полезное — parse.ps

Чтобы получить данные из download.ps в parse.ps, вы должны «перенаправить» данные между двумя скриптами.

Как найти свойства и методы объекта PowerShell

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

Для этого вам понадобится командлет Get-Member, предоставленный Microsoft.

Как использовать Get-Member

  Get-Member
   [[-Имя] ]
   [-Сила]
   [-InputObject]
   [-MemberType]
   [-Static]
   [-Вид ]
   []  

Get-Member помогает укрепить идею, с которой я столкнулся с большими трудностями при переходе от bash к сценариям PowerShell, что все (буквально все) в PowerShell является объектом.Возьмем действительно простой пример:

1. Используйте командлет Write-Output, чтобы записать некоторую информацию в нашу консоль PowerShell.

Запись-вывод «Hello, World»

2. Назначьте этот вывод переменной с именем $ string

.

$ string = Запись-вывод `Hello, World`

3. Передайте строковую переменную $ (содержащую «Hello, World») командлету Get-Member

.

$ строка | Get-Member

Вы получите результат, похожий на снимок экрана ниже:

Список свойств и методов для этого объекта типа String.По мере изменения базовых данных объекта изменяются ответы методов и свойств.

Некоторые примеры:

Строковый объект «Hello, World» имеет длину (свойство) 13
Строковый объект «Hello, People of Earth!» имеет длину 24

Вызов методов и свойств с использованием точечной записи

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

ОБЪЕКТ.НЕДВИЖИМОСТЬ

Некоторые примеры:

$ строка. Длина
13

Методы вызываются указанным способом, но с добавлением скобок.

$ string.ToUpper ()
ПРИВЕТ, МИР!

$ string.ToLower ()
привет, мир!

Оба эти метода не принимают никаких «аргументов» — дополнительных команд, переданных как параметры в круглых скобках.

$ string.Replace («привет», «до свидания»)
До свидания, мир!

Метод Replace выполняет: первый аргумент — это то, что вы ищете в строке «hello», а второй — то, на что вы хотите его заменить.

Как создавать собственные объекты PowerShell

Созданная нами переменная $ string имеет тип System.String — но что, если мы хотим создать наш собственный тип объекта вместо того, чтобы полагаться на встроенные типы?

1. Создайте HashTable

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

$ hashtable = @ {Color = «Красный»; Трансмиссия = «Автоматическая»; Конвертируемый = $ false}

Если вы передадите это Get-Member по конвейеру, вы получите другой список методов и свойств, потому что это другой тип (это System.Collections.Hashtable вместо System.String).

2. Создание настраиваемого объекта PowerShell

Чтобы преобразовать это из хеш-таблицы в полноценный объект PowerShell, мы воспользуемся так называемым «ускорителем типов» -> pscustomobject — [pscustomobject] $ hashtable

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

Попадание в трубопровод

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

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

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

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

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

Get-Content импортирует текстовый файл как объект (все в PowerShell является объектом), а Measure-Object затем будет собирать для нас статистику об этом объекте.

Если сложить вместе, получится:

Get-Content c: \ documents \ myfile.txt | Измерение-объект-слово

Символ `|` между двумя командами — это «вертикальная черта», которая указывает, что вместо отображения вывода команды Get-Content в командном окне PowerShell она должна передавать эти данные в следующий сценарий (параметр Measure- Командлет объекта).

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

Вместо импорта одного файла, может быть, мы пишем роман с 60 разными главами (по одной главе на файл), мы могли бы объединить все эти файлы вместе и передать результат в Measure-Object и получить количество слов для всего забронировать за один раз.

Как использовать конвейер

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

Для этого мы будем использовать два командлета:

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

Сначала поищем Windows Audio Service

Get-Service -Name audiosrv

Если вы работаете в PowerShell (ищите приглашение PS), вы должны получить что-то вроде:

И обнаружив, что служба присутствует, мы можем перезапустить ее.

Restart-Service -Name audiosrv

Если мы используем конвейеры, мы могли бы вместо этого передать весь объект по конвейеру командлету Restart-Service.

Get-Service -Name audiosrv | Рестарт-Сервис

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

Чтобы расширить это, мы можем использовать команду -PassThru, чтобы продолжать передавать входной объект через каждый сценарий.

Get-Service -Name audiosrv | Restart-Service -PassThru | Стоп-Сервис

Благодаря этому мы можем применить несколько команд к одному и тому же исходному объекту.

Теперь более реальный пример.

Проверка набора компьютеров с помощью PowerShell

Для начала у нас есть несколько имен хостов компьютеров (по одному в каждой строке) в текстовом файле.

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

Ваш адрес email не будет опубликован. Обязательные поля помечены *