Разное

Powershell работа со строками: Все, что вы хотели знать о подстановке переменных в строках — PowerShell

19.07.1972

Содержание

Разбор строки, выборка по условию. PowerShell

В этом примере PowerShell я покажу как можно произвести парсинг строки string, не прибегая к регулярным выражениям regex в первом примере и используя их — во втором.

Определим условия задачи

Есть некоторая строка «Something([FindThis(SomethingElse[FindThisToo([]Something)», в которой необходимо найти любые данные, находящиеся между скобками » [ » и » ( «, стоящими в указанной последовательности и исключая сами скобки:

Something([FindThis(SomethingElse[FindThisToo([]Something)

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

Решение без использования регулярных выражений

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

 # Объявили строковую переменную и загнали в нее текст для последующего разбора
[string]$var = 'Something([FindThis(SomethingElse[FindThisToo([]Something)'

Write-Host  
Write-Host 'Original and comments: http://vam.
in.ua/index.php/it/25-ms-powershell/152-powershell-parse-string.html' Write-Host 'Feedback: http://vam.in.ua/index.php/contacts/2-admins/1-aleksey.html' Write-Host # Удалим используемые переменные для чистоты работы Remove-Variable first,second -ErrorAction SilentlyContinue # Устанавливаем переменную для перебора в значение, соответствующее началу строки $plunk = 0 # Объявляем переменную конечного результата, пока ничего не содержащую $result = '' # Цикл: пока переменная перебора меньше чем длина строки, выполнять блок кода while ($plunk -lt $var.length) { # Если символ с индексом, равным переменной перебора, соответствует "[" if ($var[$plunk] -eq '[') { # Занесем в переменную first индекс символа "[" для последующей работы $first = $plunk } # Если переменная first определена и символ с индексом, равным переменной перебора, соответствует "(" if ($first -and ($var[$plunk] -eq '(')) { # Занесем в переменную second индекс символа "(" для последующей работы $second = $plunk } # Если определены обе переменные first и second, начинаем выборку нужных нам фрагментов между скобками "[" и "(" if ($first -and $second) { # Увеличим числовую переменную на единицу, т.
к. нам нужно исключить скобку "[" из результата $first++ # Выдернем из строковой переменной var все что начинается с индекса first и составляет длину (second минус first). Добавим итог к результирующей переменной $result = $result + $var.Substring($first,($second - $first)) + '; ' # Удалим вспомогательные переменные для того чтобы не выполнялось условие в строке кода под номером 30 до тех пор, пока не будут обнаружены две новые скобки "[" и "(" Remove-Variable first,second } # Увеличим числовую переменную на единицу для перебора $plunk++ } Write-Host ------ # Выводим результат на экран Write-Host $result
Что в итоге
PS D:\> .\Script.Ps1

------
FindThis; FindThisToo; 

Решение с использованием регулярных выражений

$var = 'Something([FindThis(SomethingElse[FindThisToo([]Something)'
[Regex]::Matches($var,'(?<=\[). *?(?=\()')-join';'

где:

?<=\[ — позитивный просмотр назад

?=\( — позитивный просмотр вперед

).*?( — не жадная или non-greedy выборка (до первого попавшегося условного символа; иначе выберет всё между первым и самым последним условным символом в тексте)

Что в итоге
PS D:\> .\RegEx.Ps1

FindThis;FindThisToo

powershell — Замена символов в середине строки в текстовом файле с помощью PowerShell

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

Например, строка, которую я заменяю, может быть

123xxx или 123aaa и т. Д. , Но значение, на которое я ее заменяю, всегда будет известно. Как мне заменить 123xxx, если я не всегда знаю, что такое xxx?

((Get-Content -path $ConfPath -Raw) -replace $OldVersion,$NewVersion) | Set-Content -Path $ConfPath

0

Steve 14 Авг 2020 в 00:03

2 ответа

Лучший ответ

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

любой символ в регулярном выражении).

$OldVersion = 'jre1\.8\.0_\d{3}'  # backslash escape the dots.  \d{3} means 3 digits
$NewVersion = 'jre1.8.0_261'      # this is just a string to replace with; not regex
((Get-Content -path $ConfPath -Raw) -replace $OldVersion,$NewVersion) | Set-Content -Path $ConfPath

0

Theo 14 Авг 2020 в 14:19

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

((Get-Content -path $ConfPath -Raw) -replace 'jre1.8.0_...',$NewVersion) | Set-Content -Path $ConfPath

0

Steve 14 Авг 2020 в 14:21

Работа со строками в командных файлах Windows 7

Позавчера мне пришлось написать простенький командный файл, бекапящий профиль приложения. В качестве имени папки с резервной копией мне возжелалось использовать переменные окружения %date% и %time%. Если вы проходили в институте начальный курс информатики, вы должны знать, что %time%  в этом случае является ничем иным, как граблями, остро торчащими на пути, так значение содержит недопустимый символ «:». Я никогда не занимался разбором строк в командных файлах, и случай как нельзя лучше подходил для того, чтобы прокачать свои скилы.

Я хочу поделиться с вами своими изысканиями, и анонсирую скучную, унылую техническую статью. Дочитавшему до конца — покажу котика.

В современных ОС интерпретатор командной строки позволяет выполнять простейшие строковые операции:

Замена символов/подстроки в переменной командной строки


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

Решается очень просто:

[code]set mytime=%time::=_%[/code]

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

[code]%Переменная:ЧтоНайти=НаЧтоЗаменить%[/code]

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

Само собой, можно заменять не отдельные символы, а целые словосочетания:

Как ещё можно воспользоваться функцией замены? Например:

Удалить все пробелы из значения переменной

[code]echo %var: =%[/code]

Замена какой-либо части строки

Вы можете использовать символ «*» для определения того, что обработке подлежит часть строки, предшествующая указанному выражением. Я не знаю, как написать это по-человечески, вот что я имею ввиду:

К сожалению, «звёздочкой» нельзя указать, что отсечь надо часть строки после указанного выражения. Эта задача решается в два этапа:

  1. в отдельную переменную помещается строка, из которой удалено всё, что находится до ключевого выражения. Т.е. в ней остается «хвост», искомое выражение плюс всё, что после него.
  2. затем из оригинальной переменной удаляется значение переменной, полученной на первом шаге. Здесь потребуется вызов команды СALL:

Инструкция CALL необходима для разворачивания значения переменной, подлежащей замене. Без неё интерпретатор отработает неверно, и вот эта конструкция не сработает:

[code]echo %var1:%var%=%[/code]

Необходимо писать:

[code]call echo %var1:%var%=%[/code]

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

[code]rem Работаем внутри командного файла

call echo %%var1:%var%=%%[/code]

Поиск подстроки


Используя опыт, полученный выше, можно написать простейшую проверку вида «содержит/не содержит».

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

[code]set var1=Мама мыла раму
set var2=%var1:Мама=%

if NOT «%var1%» == «%var2%» (echo Подстрока найдена)[/code]

Или

[code]set var1=Мама мыла раму
set var2=%var1:Мама=%

if NOT «%var1%» == «%var2%» (echo Подстрока найдена)  else  (echo Подстрока не найдена) [/code]

Выделение подстроки из переменной


Для получения подстроки из строки командный интерпретатор предоставляет  такую конструкцию:

[code]set var2=%var1:~начальная_позиция%
set var2=%var1:~начальная_позиция,-отбросить_символов_с_конца_строки%
set var2=%var1:~начальная_позиция,длина%[/code]

Синтаксис очень простой, поэтому сразу перейдем к примерам.

Выделение подстроки с начиная определенной позиции

Выделение части строки, например, «середины»

Выделение определенного количества символов

Начальная позиции строки  — нулевая.

Работа с наборами «ключ — значение»


Здесь, в общем-то, тоже никакой магии нет.

В основе разбора лежит всё та же рассмотренная выше замена подстроки на пустое значение.

Алгоритм действий такой:

  • Создается переменная, содежащая в себе значения вида <ключ><разделитель значения><значение><разделитель пары>. Назовем её условно «словарь».
  • В переменную, которая будет содержать значение, записывается всё, что следует после ключа. По аналоги с заменой части строки, нужно использовать звездочку перед выражением <ключ><разделитель значения>.
  • Полученный результат нужно «почистить», так как он может содержать в себе остаток словаря. Для этого прибегнем к хитрости и выполним составную команду.
    Предположим, мы в качестве разделителя пары словаря используем точку с запятой. Тогда мы сможем довольно изящно «убить» оставшуюся часть словаря, поместив его в комментарии командой rem.
    [code]set value=%value:;=&rem %[/code]
    После rem — пробел, это важно(rem /?)

Теперь практический пример:


Я надеюсь, эта информация оказалась для вас полезной и сэкономит вам время, если у вас появится задача обработки строк. Впрочем, тему я раскрыл не полностью, и если у вас есть какие-то дельные личные наработки и приёмы обработки строк в командном интерпретаторе Windows, я совсем не против увидеть их в комментариях.

Материалы по теме:

http://ss64.com/nt/

Форум о скриптах на OSZone — рекомендую.

Спасибо, что дочитали до конца.

 

💡Узнавайте о новых статьях быстрее. Подпишитесь на наши каналы в Telegram и Twitter.

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

Вы здесь: Главная страница » Windows » Windows 7 » Работа со строками в командных файлах Windows 7

Как построить ракетный ускоритель для скриптов PowerCLI

Рано или поздно любой системный администратор VMware доходит до автоматизации рутинных задач. Начинается все с командной строки, потом идет PowerShell или VMware PowerCLI.

Допустим, вы освоили PowerShell чуть дальше запуска ISE и использования стандартных командлетов из модулей, которые работают за счет “какой-то магии”. Когда вы начнете считать виртуальные машины сотнями, то обнаружите, что скрипты, которые выручали на малых масштабах, работают заметно медленнее на больших.

В этой ситуации выручат 2 инструмента:

  • PowerShell Runspaces – подход, который позволяет распараллелить выполнение процессов в отдельных потоках;
  • Get-View – базовая функция PowerCLI, аналог Get-WMIObject в Windows. Этот командлет не тянет за собой сопутствующие сущности объекты, а получает информацию в виде простого объекта с простыми типами данных. Во многих случаях выходит быстрее.

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

Первая ступень: Runspace

Итак, Runspace предназначен для параллельной обработки задач вне основного модуля. Конечно, можно запустить еще один процесс, который съест сколько-то памяти, процессора и т. д. Если ваш скрипт отрабатывает за пару минут и тратит гигабайт памяти, скорее всего, Runspace вам не потребуется. А вот для скриптов на десятки тысяч объектов он нужен.

Что дает использование Runspace:

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

Вот пример из интернета, когда Runspace помогает:

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

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

Скрипт использует PowerShell runspaces, чтобы каждый хост ESXi собирал информацию по потреблению его собственных ВМ в отдельном Runspace и сразу сообщал о завершении. Это позволяет PowerShell сразу закрывать джобы, а не перебирать последовательно хосты и не ждать, пока каждый завершит свой запрос”.

Источник: How to Show Virtual Machine I/O on an ESXi Dashboard

В случае ниже Runspace уже не у дел:

“Пытаюсь написать скрипт, который собирает много данных с ВМ и при необходимости записывает новые данные. Проблема в том, что ВМ достаточно много, и на одну машину тратится по 5-8 секунд”.

Источник: Multithreading PowerCLI with RunspacePool

Здесь уже понадобится Get-View, перейдем к нему.

Вторая ступень: Get-View 

Чтобы разобраться, чем полезен Get-View, стоит вспомнить, как работают командлеты вообще.

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

Теперь для сравнения с Get-View возьмем командлет Get-VM: он обращается к виртуальной машине и возвращает составной объект, то есть прикладывает к нему другие сопутствующие объекты: VMHost, Datastore и т. д. 

Get-View на его месте не прикручивает в возвращаемый объект ничего лишнего. Более того, он позволяет жестко указать, какая именно информация нам нужна, что облегчит объект на выходе. В Windows Server в целом и в Hyper-V, в частности, прямым аналогом является командлет Get-WMIObject – идея абсолютно та же.

Get-View неудобен в рутинных операциях над точечными объектами. Но когда речь заходит о тысячах и десятках тысяч объектов, ему нет цены.

Сейчас все покажу на реальном кейсе.

Пишем скрипт для выгрузки ВМ

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

Задача – обычная рутина: найти все ВМ с дублирующимся параметром cloud.uuid (да, такое возможно при клонировании ВМ в vCloud Director).

Очевидный вариант решения, который приходит на ум:

  1. Получить список всех ВМ.
  2. Каким-то образом распарсить список.

Исходным вариантом был такой незамысловатый скрипт:

function Get-CloudUUID1 {
   # Получаем список всех ВМ
   $vms = Get-VM
   $report = @()
 
   # Обрабатываем каждый объект, получая из него только 2 свойства: Имя ВМ и Cloud UUID.
   # Заносим данные в новый PS-объект с полями VM и UUID
   foreach ($vm in $vms)
   {
       $table = "" | select VM,UUID
 
       $table.VM = $vm.name
       $table.UUID = ($vm | Get-AdvancedSetting -Name cloud.uuid).Value
          
       $report += $table
   }
# Возвращаем все объекты
   $report
}
# Далее РУКАМИ парсим полученный результат

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

Но замерим время:

2 минуты 47 секунд при обработке почти 10k ВМ. Бонусом – отсутствие фильтров и необходимость вручную сортировать результат. Очевидно, что скрипт просит оптимизации.

Ранспейсы первыми приходят на помощь, когда нужно единовременно получить метрики хостов с vCenter или требуется обработать десятки тысяч объектов. Посмотрим, что даст этот подход.

Включаем первую скорость: PowerShell Runspaces

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

Но есть проблема:  PowerCLI не позволит нам открывать множество независимых сессий к vCenter и выкинет веселую ошибку:

You have modified the global:DefaultVIServer and global:DefaultVIServers system variables. This is not allowed. Please reset them to $null and reconnect to the vSphere server.

Чтобы ее решить, надо сначала передать внутрь потока информацию о сессии. Вспоминаем, что PowerShell работает с объектами, которые можно передавать в качестве параметра хоть в функцию, хоть в ScriptBlock. Передадим сессию в виде такого объекта в обход $global:DefaultVIServers (Connect-VIServer с ключом -NotDefault):

$ConnectionString = @()
foreach ($vCenter in $vCenters)
   {
       try {
           $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -AllLinked -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
       }
       catch {
           if ($er. Message -like "*not part of a linked mode*")
           {
               try {
                   $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
               }
               catch {
                   throw $_
               }
              
           }
           else {
               throw $_
           }
       }
   }

Теперь реализуем мультипоточность через Runspace Pools. 

Алгоритм следующий:

  1. Получаем список всех ВМ.
  2. В параллельных потоках получаем cloud.uuid.
  3. Данные из потоков собираем в один объект.
  4. Фильтруем объект через группировку по значению поля CloudUUID: те, где количество уникальных значений больше 1, и есть искомые ВМ.

В итоге получаем скрипт:

function Get-VMCloudUUID {
   param (
       [string[]]
       [ValidateNotNullOrEmpty()]
       $vCenters = @(),
       [int]$MaxThreads,
       [System. Management.Automation.PSCredential]
       [System.Management.Automation.Credential()]
       $Credential
   )
 
   $ConnectionString = @()
 
   # Создаем объект с сессионным ключом
   foreach ($vCenter in $vCenters)
   {
       try {
           $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -AllLinked -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
       }
       catch {
           if ($er.Message -like "*not part of a linked mode*")
           {
               try {
                   $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
               }
               catch {
                   throw $_
               }
              
           }
           else {
               throw $_
           }
       }
   }
 
   # Получаем список всех ВМ
   $Global:AllVMs = Get-VM -Server $ConnectionString
 
   # Поехали!
   $ISS = [system. management.automation.runspaces.initialsessionstate]::CreateDefault()
   $RunspacePool = [runspacefactory]::CreateRunspacePool(1, $MaxThreads, $ISS, $Host)
   $RunspacePool.ApartmentState = "MTA"
   $RunspacePool.Open()
   $Jobs = @()
 
# ScriptBlock с магией!)))
# Именно он будет выполняться в потоке
   $scriptblock = {
       Param (
       $ConnectionString,
       $VM
       )
 
       $Data = $VM | Get-AdvancedSetting -Name Cloud.uuid -Server $ConnectionString | Select-Object @{N="VMName";E={$_.Entity.Name}},@{N="CloudUUID";E={$_.Value}},@{N="PowerState";E={$_.Entity.PowerState}}
 
       return $Data
   }
# Генерируем потоки
 
   foreach($VM in $AllVMs)
   {
       $PowershellThread = [PowerShell]::Create()
# Добавляем скрипт
       $null = $PowershellThread.AddScript($scriptblock)
# И объекты, которые передадим в качестве параметров скрипту
       $null = $PowershellThread.AddArgument($ConnectionString)
       $null = $PowershellThread.AddArgument($VM)
       $PowershellThread.RunspacePool = $RunspacePool
       $Handle = $PowershellThread. BeginInvoke()
       $Job = "" | Select-Object Handle, Thread, object
       $Job.Handle = $Handle
       $Job.Thread = $PowershellThread
       $Job.Object = $VM.ToString()
       $Jobs += $Job
   }
 
# Ставим градусник, чтобы наглядно отслеживать выполнение заданий
# И здесь же прибиваем отработавшие задания
   While (@($Jobs | Where-Object {$_.Handle -ne $Null}).count -gt 0)
   {
       $Remaining = "$($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False}).object)"
 
       If ($Remaining.Length -gt 60) {
           $Remaining = $Remaining.Substring(0,60) + "..."
       }
 
       Write-Progress -Activity "Waiting for Jobs - $($MaxThreads - $($RunspacePool.GetAvailableRunspaces())) of $MaxThreads threads running" -PercentComplete (($Jobs.count - $($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False}).count)) / $Jobs.Count * 100) -Status "$(@($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False})).count) remaining - $remaining"
 
       ForEach ($Job in $($Jobs | Where-Object {$_. Handle.IsCompleted -eq $True})){
           $Job.Thread.EndInvoke($Job.Handle)     
           $Job.Thread.Dispose()
           $Job.Thread = $Null
           $Job.Handle = $Null
       }
   }
 
   $RunspacePool.Close() | Out-Null
   $RunspacePool.Dispose() | Out-Null
}
 
 
function Get-CloudUUID2
{
   [CmdletBinding()]
   param(
   [string[]]
   [ValidateNotNullOrEmpty()]
   $vCenters = @(),
   [int]$MaxThreads = 50,
   [System.Management.Automation.PSCredential]
   [System.Management.Automation.Credential()]
   $Credential)
 
   if(!$Credential)
   {
       $Credential = Get-Credential -Message "Please enter vCenter credentials."
   }
 
   # Вызов функции Get-VMCloudUUID, где мы распараллеливаем операцию
   $AllCloudVMs = Get-VMCloudUUID -vCenters $vCenters -MaxThreads $MaxThreads -Credential $Credential
   $Result = $AllCloudVMs | Sort-Object Value | Group-Object -Property CloudUUID | Where-Object -FilterScript {$_.Count -gt 1} | Select-Object -ExpandProperty Group
   $Result
}

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

Замеряем время:

55 секунд. Уже лучше, но все равно можно быстрее.

Переходим на вторую скорость: GetView

Выясняем, что не так.

Первое и очевидное: командлет Get-VM выполняется долго.
Второе: командлет Get-AdvancedOptions выполняется еще дольше.

Сначала разберемся со вторым.

Get-AdvancedOptions удобен на отдельных объектах ВМ, но очень неповоротлив при работе со множеством объектов. Ту же самую информацию мы можем получить из самого объекта виртуальной машины (Get-VM). Просто она хорошо зарыта в объекте ExtensionData. Вооружившись фильтрацией, ускоряем процесс получения нужных данных.

Легким движением руки это:

VM | Get-AdvancedSetting -Name Cloud.uuid -Server $ConnectionString | Select-Object @{N="VMName";E={$_.Entity.Name}},@{N="CloudUUID";E={$_.Value}},@{N="PowerState";E={$_.Entity.PowerState}}

Превращается в это:

$VM | Where-Object {($_.ExtensionData. Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value -ne $null} | Select-Object @{N="VMName";E={$_.Name}},@{N="CloudUUID";E={($_.ExtensionData.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value}},@{N="PowerState";E={$_.summary.runtime.powerstate}}

Вывод тот же, что и у Get-AdvancedOptions, но работает в разы быстрее.

Теперь к Get-VM. Он выполняется не быстро, так как имеет дело со сложными объектами. Встает логичный вопрос: а зачем нам в данном случае лишняя информация и монструозный PSObject, когда нам всего-то нужно имя ВМ, ее состояние и значение хитрого атрибута? 

К тому же, из скрипта ушел тормоз в лице Get-AdvancedOptions. Применение Runspace Pools теперь выглядит излишеством, так как больше нет необходимости в распараллеливании медленной задачи в потоках с приседаниями при передаче сессии. Инструмент хороший, но не для этого кейса.

Смотрим на вывод ExtensionData: это не что иное, как объект Get-View.

Призовем древнюю технику мастеров PowerShell: one line с применением фильтров, сортировок и группировки. Весь предыдущий ужас элегантно схлопывается в одну строку и выполняется в одной сессии:

$AllVMs = Get-View -viewtype VirtualMachine -Property Name,Config.ExtraConfig,summary.runtime.powerstate | Where-Object {($_.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value -ne $null} | Select-Object @{N="VMName";E={$_.Name}},@{N="CloudUUID";E={($_.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value}},@{N="PowerState";E={$_.summary.runtime.powerstate}} | Sort-Object CloudUUID | Group-Object -Property CloudUUID | Where-Object -FilterScript {$_.Count -gt 1} | Select-Object -ExpandProperty Group

Замеряем время:

9 секунд для почти 10k объектов с фильтрацией по нужному условию. Отлично!

Вместо заключения

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

P.S.

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

Что такое PowerShell? Назначение компонента Windows Power Shell Что такое powershell в windows 8

С загадочными письменами и настойчиво мигающим курсором? Это командная строка. Утилита присутствует во всех версиях Windows. С ее помощью удобно управлять системой, вызывать программы, находить файлы. Но для профессиональной работы cmd недостаточно функциональна. Поэтому компания Microsoft решила исправить все минусы консоли и выпустила продукт под названием Windows PowerShell. Что это и как использовать разработку, читайте дальше.

Что такое PowerShell от Windows

PowerShell — это интерактивная объектно-ориентированная командная среда с функциями языка сценариев. Официальный релиз PowerShell 1.0 от «Майкрософт» состоялся 14 ноября 2006 года. Разработчики объединили интерфейс обычной командной строки CLI с платформой для управления локальными и удаленными сетями.NET Framework.

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

18 августа 2016 года Microsoft объявила, что Windows PowerShell — это теперь продукт с открытым исходным кодом, доступный каждому разработчику. Также компания добавила поддержку Unix-ориентированных операционных систем, включая дистрибутивы Linux и OS X.

Как управлять PowerShell

Для выполнения задач используются cmdlets, или командлеты. Это небольшие команды, записанные в виде исполняемых файлов. В версии 2.0 PowerShell для Windows XP и Server 2008 R2 создатели добавили модули, позволяющие управлять большим количеством ресурсов, включая Active Directory и Exchange Server.

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

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

Учитывая, что Windows PowerShell — это расширяемая среда, пользователи могут создавать свои команды, писать «авторские» модули с использованием языка.Net.

Начало работы с PowerShell

В 2016 году была выпущена последняя бета-версия 6.0 PowerShell. В Windows 7, 8 и 10 утилита является встроенной. Если вы пользуетесь другой операционной системой, приложение придется скачать. Для этого зайдите на официальный сайт microfoft. com и в окне поиска введите Installing Windows PowerShell. Система автоматически переведет на страницу с последними релизами продукта. Выберете из списка свою ОС и нажмите Download.

Когда файл полностью загрузится, откройте его двойным щелчком мышки. По умолчанию среда установится в ProgramFiles\PowerShell\ и создаст ярлык в меню «Пуск». Если вы являетесь счастливым пользователем Windows, нажмите на значок системы в нижнем левом углу и введите PowerShell в «Найти программы и файлы». Запускайте приложение, вводите свой первый командлет и начинайте работу.

Список необходимых команд и инструкций для PowerShell

Имя каждого командлета представлено в форме «глагол-существительное» или «действие-объект». Предлагаем список наиболее важных cmdlets PowerShell для Windows 10 и предыдущих версий, начиная с XP. Они будут полезны даже начинающим пользователям, которые только вчера научились сохранять текстовые документы.

  1. Get-Help. Встроенный в ядро оболочки командлет. Предназначен для вызова справки и предоставляет полезную информацию о синтаксисе, программах, их назначении, других командлетах. Если в обычном командном интерпретаторе вы писали ipconfig /?, то в PowerShell нужно набрать Get-Help Get-Process.
  2. Get-Content. Упрощает процедуру чтения файлов для новичков и системных администраторов. Если раньше необходимо было открывать дескриптор и читать поочередно все строки документа, то теперь достаточно передать файл командлету. Для этого пропишите в консоли C:\> Get-Content C:\…\«имя файла».«расширение».
  3. Get-Service. Доступ к информации об установленных на компьютере службах.
  4. Get-Member. Выдает информацию о возвращаемом командлетом объекте, позволяет увидеть его свойства и методы.
  5. Get-Command. Выполняет поиск командлетов, возвращает о них всю информацию, включая данные о функциях, скриптах, приложениях и других элементах. В версии 5.0 PowerShell для Windows 10 в Get-Command добавлен столбец Version, и теперь команлдет отображает сразу несколько версий одного и того же модуля.
  6. Stop-\Start-Service. Незаменимый помощник для администраторов. Командлет запускает и останавливает службы на удаленных и локальных компьютерах.

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

Помимо командлетов, утилита PowerShell в Windows 7 и выше включает специальные символы, такие как $_ или {}. Наибольшее недоумение значки вызывают у новичков, не имевших дело с Linux-подобными системами или программированием.

  1. Вертикальная черта «|». Этот символ используется для программ с конвейерной передачей данных. При работе с консолью его включают, когда хотят указать команде справа от вертикальной черты принять выходные данные от команды слева. В PowerShell вертикальную черту применяют практически с той же целью, комбинируя сразу несколько команд. Например, создать новое имя пользователя, добавить его в группу и сбросить пароль по умолчанию.
  2. Знак функции «{}». Позволяет эффективно контролировать процесс выполнения сценариев. Как и в C-подобных языках программирования, функция в PowerShell образуется посредством заключения нескольких командлетов в фигурные скобки и готова запускаться необходимое количество раз.
  3. Специальный символ $_. Используется для написания скриптовых блоков, фильтров и процедурных выражений. $_ принимает значение текущего объекта и передает его следующему. С помощью знака доллара без нижнего подчеркивания можно обозначить или ввести переменную: $var = «Hello».

Что такое PowerShell ISE

В комплекте с утилитой PowerShell идет графическое приложение Windows PowerShell ISE. Это оболочка, или интегрированная среда, для написания скриптов. ISE предоставляет разработчикам огромный спектр возможностей. С ее помощью можно создавать, отлаживать и редактировать скрипты, открывать текстовые и XML-файлы. Цветная подсветка синтаксиса существенно облегчает тестирование и поиск ошибок в коде.

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

Чтобы попробовать среду ISE, в меню «Пуск» введите PowerShell ISE. Если вы используете не Windows, а другую ОС, скачайте и установите дистрибутив с официального сайта. После запуска приложения откроется окно из трех частей. Вверху пишутся скрипты, внизу — команды PowerShell, а в середине виден результат.

Начните знакомство с ISE и в нижнем окне введите Get-Process. Нажмите несколько раз Tab. Рядом с командлетом появятся его параметры, которые будут меняться после каждого нажатия клавиши. Это и будет ваш первый сеанс работы со скриптовой средой от Microsoft.

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

Если на вашем компьютере установлена Windows 10, то, пожалуй, ещё более быстрый способ открыть PowerShell — нажать правой кнопкой мыши по кнопке «Пуск» и выбрать нужный пункт меню (там присутствует сразу два пункта — для простого запуска и от имени администратора). Это же меню можно вызвать, нажав клавиши Win+X на клавиатуре.

Примечание: если в этом меню вместо Windows PowerShell у вас отображается командная строка, то заменить её на PowerShell вы, при желании, можете в Параметры — Персонализация — Панель задач, включив пункт «Заменить командную строку оболочкой Windows Powershell» (в последних версиях Windows 10 параметр включен по умолчанию).

Запуск PowerShell с помощью диалогового окна «Выполнить»

Еще один простой способ запуска PowerShell — использовать окно «Выполнить»:

  1. Нажмите клавиши Win+R на клавиатуре.
  2. Введите powershell и нажмите Enter или Ок.

При этом в Windows 7 можно установить отметку запуска от имени администратора, а в последней версии Windows 10, если при нажатии Enter или Ok удерживать клавиши Ctrl + Shift, то утилита также запуститься от имени администратора.

Видео инструкция

Другие способы открыть PowerShell

Выше перечислены далеко не все способы открытия Windows PowerShell, но, уверен, что их будет вполне достаточно. Если же нет, то:

Также, бывает, спрашивают, а что такое PowerShell ISE и PowerShell x86, которые находятся, например, при использовании первого способа. Отвечаю: PowerShell ISE — «Интегрированная среда сценариев PowerShell». По сути, с её помощью можно выполнять все те же команды, но, помимо этого, в ней присутствуют дополнительные возможности, облегчающие работу со скриптами PowerShell (справка, инструменты отладки, цветовая разметка, дополнительные горячие клавиши и т.п.). В свою очередь версии x86 нужны в случае, если вы работаете с 32-битными объектами или с удаленной системой x86.

После перехода на операционную систему Windows 10 многие пользователи заметили в интерфейсе Проводника кнопку «Запустить PowerShell». В связи с этим в сети появилось много вопросов, пользователей интересовало, что это за программа Windows PowerShell и для чего она нужна. Если вас также интересует этот вопрос, то данный материал должен вам помочь.

Windows PowerShell – это скриптовый язык и программа с интерфейсом командной строки для выполнения этих скриптов. Данный язык был выпущен в 2006 году в составе второго сервис-пака для Windows XP и с тех пор PowerShell является частью всех операционных систем от Microsoft. В 2008 году появилась вторая версия данного языка, и начиная с Windows 7 используется именно она. Файлы со скриптами Windows PowerShell имеют расширение PS1 и могут запускаться как привычные всем BAT и CMD файлы.

Windows PowerShell – это скриптовый язык, который разрабатывался в первую очередь для бизнес-клиентов Microsoft, которым нужно мощные инструменты для автоматизации задач по управлению серверами и компьютерами на базе Windows. В качестве основы для данного языка была использована платформа.NET, разрабатываемая компанией Microsoft с 2002 года.

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

Командлеты (на английском cmdlets) формируются по правилу Глагол-Существительное, например, Get-Help. Ознакомиться с основами Windows PowerShell можно с помощью справки (командлет «Get-Help»). Для получения общей информации просто введите команду «Get-Help», для получения справки о конкретном командлете введите «Get-Help Имя-командлета». Например, если ввести команду «Get-Help Get-Process», то мы получим справку о командлете Get-Process.

Как запустить программу Windows PowerShell

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

Также можно с помощью комбинации клавиш Windows-R и ввести команду «powershell».

В Windows 10 программу PowerShell можно запустить из любой папки. Для этого нужно нажать на кнопку «Файл» в верхнем левом углу Проводника и выбрать «Запустить Windows PowerShell».

Как пользоваться программой Windows PowerShell

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

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

Clear-RecycleBin c:

На скриншоте внизу видно, как выполняется данный командлет. После введения команды «Clear-RecycleBin c: » появляется запрос на подтверждение. Для того чтобы продолжить выполнение командлета нужно ввести букву «Y» и нажать Enter.

Если к командлету «Clear-RecycleBin c: » добавить «-Force », то очистка корзины выполнится без запроса на подтверждение. Скриншот внизу.

Архивация файлов . Для архивации и распаковки файлов предусмотрены командлеты «Compress-Archive » и «Expand-Archive «. Например, для того чтобы архивировать папку «C:\test\» в архив «C:\archive\test2.zip» нужно выполнить следующий командлет:

Compress-Archive -LiteralPath C:\test\ -DestinationPath C:\archive\test2.zip

В результате выполнения показанной выше команды, в папке «C:\archive\» появится файл «test2.zip», в котором будет заархивировано содержимое папки «C:\test\».

Список командлетов для Windows PowerShell

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

  • Get-Help – получение справки;
  • Update-Help – обновление справки;
  • Get-Command – поиск командлетов;
  • Get-Alias – поиск псевдонимов для командлетов;
  • Get-PSDrive – просмотр подключенных дисков;
  • Get-Member – просмотр свойств и методов, которые есть у объекта;
  • Get-WindowsFeature – просмотр сведений о доступных ролях и компонентах сервера;
  • Install-WindowsFeature (аналог Add-WindowsFeature) — устанавливает роли или компоненты на нужный сервер;
  • Uninstall-WindowsFeature (аналог Remove-WindowsFeature) – удаляет роли или компонента сервера;
  • Get-History – просмотр истории команд, которые вводились в этой сессии;
  • Get-Variable – просмотр списка переменных и их значений;
  • New-Variable – создание новой переменной;
  • Set-Variable – установка значения переменной;
  • Clear-Variable – удаление значения переменной;
  • Remove-Variable – удаление переменной и ее значения;
  • Format-List – просмотр результата команды в виде списка свойств, где в каждой строке отдельное свойство;
  • Format-Table — просмотр результата команды в формате таблицы;
  • Format-Wide — просмотр результата команды в виде широкой таблицы, в которой показывается только одно свойство для каждого объекта;
  • Format-Custom – просмотр результата команды с использованием пользовательского представления;
  • Export-Csv – экспорт данных в формат CSV;
  • Import-Csv – импорт данных из CSV файла;
  • Export-Clixml — экспорт данных в формат XML;

Полный список командлетов для Windows PowerShell вы можете получить, выполнив командлет «Get-Command -CommandType cmdlet».

Пользователи, находящиеся в процессе изучения начального экрана Windows 8.1 или Windows 7, нередко запускают в работу совсем незнакомые им приложения. Одним из таковых является Power Shell – продукт от компании Microsoft.

Что такое Power Shell

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

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

Функционал инструмента администрирования

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

Оболочка Power Shell имеет собственный набор команд, как и консоль CMD, называемых командлетами. Синтаксис языка, определения командлетов и их параметров в этой программе отличается от привычного, хотя утилита способна распознавать многие команды CMD.

Прекрасно понимаемые Power Shell команды вроде cd, dir, copy и им подобные в этой оболочке являются псевдонимами или, как принято говорить, алиасами, служащими просто для удобства. Пример: команда dir, вводимая пользователем с целью просмотра файловой системы, соответствует командлету Get-ChildItem.

Как разобраться в программе

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

Решаясь начать изучение скриптового языка Power Shell, целесообразно ознакомиться с руководством, созданным Франком Кохом, или обратиться к справочной системе самой программы. Последняя является довольно мощной, с большим количеством конкретных примеров. Основная информация здесь откроется для просмотра после ввода командлета Get-Help.


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

Определение PowerShell

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

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

Первая версия инструмента PowerShell появилась еще в 2006 году для Windows XP, Server 2003 и Vista. На данный момент последняя версия инструмента 4.0. Выпущена в 2013 году вместе с Windows 8.1.

Какие функции выполняет PowerShell?

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

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

В том случае, если вы являетесь администратором сети, то PowerShell сможет вам помочь в работе, например, с Active Directory. Также, стоит заметить, что утилита содержит более 100 команд. Это говорит о том, что она поможет решить вам большинство задач.

Запуск PowerShell на Windows 7

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

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

Запуск PowerShell на Windows 8.1

Для открытия PowerShell в Windows 8.1 необходимо в поиске ввести ключевое слово «», чтобы открыть поиск, нажмите Win+Q .

Другой способ открытия – через окно «Выполнить ». Нажимаем Win+R , открывается окно, в которое вы вводите .

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

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

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

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

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

Windows powershell: что это?

Первые операционные системы не содержали никакого интерфейса взаимодействия с пользователем, кроме командной строки. MS-DOS, например, позволяла общаться с собой только так. Графический интерфейс пользователя требовал от машины значительно большей мощности, чем имелось у компьютеров того времени. Появление GUI, казалось бы, устранило потребность в консоли. Однако командная строка – лишь кажущееся излишество.

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

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

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

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

PowerShell на смену «батникам»

Со временем командные оболочки сильно эволюционировали. Процессору «батников» (.bat-файлов) DOS пришел на смену командный процессор 4DOS, в Windows происходили аналогичные изменения – перечень исполнимых инструкций значительно расширился, приобретая сходство с современными скриптовыми языками программирования.

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

Также у них появились конкуренты, наподобие скриптов JScript и VBScript, функционирующих на базе языковой машины WHS(Windows Script Host). Казалось бы, эволюция «батников» зашла в тупик, и они должны были вымереть, как динозавры. Но не тут то было.

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

Net со всеми вытекающими из этого последствиями (что такое классы в современном программировании, думается, объяснять не нужно) и получили новое имя – «командлеты». Можно еще много рассуждать на тему отличий оболочки PowerShell от прочих скриптовых оболочек, но лучше предложить краткий перечень ее функций, чтобы вы поняли, что такое PS.

Функциональность PowerShell

Функциональность оболочки такова:

  • Командлеты предоставляют интерфейс для работы с сущностями из следующего списка: реестром, процессами, журналом, службами, WMI. То есть идеально подходят для нужд системного администратора.
  • PowerShell – это развитый скриптовый язык программирования на основе объектной парадигмы.
  • Унифицированный дизайн языка PowerShell на концепции хранилищ системных данных с единообразной структурой. Для программиста это означает возможность использовать одни и те же командлеты при работе с различными хранилищами.
  • В язык включена мощная система навигации по файловой системе и системным хранилищам. Причем навигация по тем и другим осуществляется одинаково.
  • Ориентация на объекты означает не только инкапсуляцию различных методов в одном объекте, но и возможность сохранять экземпляры объектов на диске или в СУБД.
  • Интерфейс PowerShell может быть легко расширен разработчиком, что означает возможность создавать целые программные пакеты PoweShell для решения специальных прикладных задач системного программирования.


Получение контроля над строками в PowerShell — Microsoft Certified Professional Magazine Online

Конвейер PowerShell

Контроль над строками в PowerShell

Вот как форматировать и использовать строки в вашем коде.

Строки — это очень распространенная вещь, которую можно увидеть и использовать в PowerShell. Параметры могут принимать строки, и часто объекты, которые выводятся различными командами, имеют строки в качестве своих свойств.Фактически, все в PowerShell можно преобразовать в строку. Под приведением я подразумеваю, что мы можем преобразовать все (целые числа, объекты и т. Д.) В строку, даже если это может выглядеть не так, как до преобразования строки.

Работа со строками
Первое, о чем я расскажу, — это работа со строками. Это включает в себя форматирование и различия между двойными и одинарными кавычками (да, между ними есть большая разница).

Когда я думаю о строке, я думаю о кучке текста вроде этого:


[Щелкните изображение, чтобы увеличить его.] Рисунок 1. Отображение строк в PowerShell.

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

 $ MyName = "Boe Prox" 
"Привет, $ ($ MyName), сегодня $ ((Get-Date) .DayOfWeek)"
[Щелкните изображение, чтобы увеличить его.] Рисунок 2. Оценка переменных в строковом выводе.

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

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

[Щелкните изображение, чтобы увеличить.] Рисунок 3. Вывод строки не отображается должным образом.

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

 $ MyName = 'Boe Prox' 
'Привет, $ ($ MyName), сегодня $ ((Get-Date).День недели)'
[Щелкните изображение, чтобы увеличить его.] Рисунок 4. Отображение буквальных значений в строке.

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

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

 $ MyName = "Boe Prox" 
("Здравствуйте, $ ($ MyName), сегодня $ ((Get-Date) .DayOfWeek)"). Длина
[Щелкните изображение, чтобы увеличить его.] Рисунок 5. Отображение длины строки.

Here-Strings — отличный способ использовать, если вы хотите, чтобы текст занимал несколько строк. Использование HTML-кода — отличный тому пример.

 @ "
Это пример
некоторых строк текста
, которые были созданы на
$ (Get-Date)
" @
Рисунок 6. Пример использования Here-String.

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

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

 # Показать день недели 
"Сегодня {0: dddd}" -f (Get-Date)

#Percentage
"{0: P}" -f (5/10)

#Currency
"{0: C}" -f 5

# Преобразовать в шестнадцатеричный
"0x {0: x}" -f 55

[Щелкните изображение, чтобы увеличить его.] Рисунок 7. Использование форматирования .Net в строковом выводе.

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

Если по какой-то причине вы хотите поместить весь текст заглавными буквами, вы можете использовать метод ToUpper (), доступный в строке.

 $ Text = "Привет!" 
$ Text.ToUpper ()
[Щелкните изображение, чтобы увеличить его.] Рисунок 8. Перевод всех символов в верхний регистр.

То же самое можно сделать с ToLower (), чтобы ничего не было написано с заглавной буквы.

 $ Text = "ЭТО ВСЕ ЗАПИСИ" 
$ Text.ToLower ()
[Щелкните изображение, чтобы увеличить.] Рисунок 9. Перевод всех символов в нижний регистр.

Допустим, у вас есть строка, разделенная запятыми, но вместо этого вы хотите превратить ее в массив элементов. Мы можем использовать метод .Split () или оператор –Split для выполнения этого действия.Важно помнить, что использование метода .Split () является буквальным подходом и учитывает регистр. Итак, то, о чем вы просите, вы получаете. Использование –Split предполагает, что вместо этого вы используете регулярные выражения, поэтому вам необходимо убедиться, что вы понимаете этот метод. Хотя в большинстве случаев с –Split вы можете просто использовать аналогичный символ, например запятую в этом случае.

 $ Text = 'кошка, собака, птица, черепаха, лягушка' 
$ Text.Split (',')

$ Текст -split ','

[Щелкните изображение, чтобы увеличить его.] Рисунок 10. Разделение строки на массив по символам.

Мы также можем найти расположение символа в строке, посмотрев на IndexOf () и указав символ. В этом случае мы видим, что буква «y» является 37-м символом в следующей строке.

 $ Text = 'Быстрая коричневая лиса перепрыгивает через ленивую собаку' 
$ Index = $ Text.IndexOf ('y')
$ Index
[Щелкните изображение, чтобы увеличить.] Рисунок 11. Определение индекса символа.

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

 $ Text = 'Быстрая коричневая лиса перепрыгивает через ленивую собаку' 
$ Index = $ Text.IndexOf ('y')
$ Text.Substring (0, $ Index)
[Щелкните изображение, чтобы увеличить его.] Рисунок 12. Отображение определенного набора символов с помощью SubString.

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

Пример того, как чувствительность к регистру может сыграть на использовании.Заменить ()

 $ Text = "Это Бо, но его сейчас нет" 
$ Text.Replace ('Бо', 'Джефф')
[Щелкните изображение, чтобы увеличить.] Рисунок 13. Замена буквального текста с помощью метода.

В этом примере показано, как можно использовать регулярные выражения с –Split, чтобы обеспечить большую гибкость в том, что можно заменить. В этом случае я хочу заменить первые два октета в IP-адресе на xxx, чтобы он не был полностью известен.

 $ IPs = "168.192.1.1, 185.25.26.59, 10.15.1.12, 158.128.2.45 "
$ IP-адресов - заменить '\ d {1,3} \. \ D {1,3} \.', 'Xxx.xxx.'
[Щелкните изображение, чтобы увеличить.] Рисунок 14. Замена октетов IP.

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


Об авторе

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

Как использовать и создавать

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

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

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

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

Наша цель — дать вам хорошее представление о работе с массивами в PowerShell. Освоив эти основы, вы можете прочитать наш курс по PowerShell, чтобы узнать больше.

Массивы PowerShell

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

Массивы в PowerShell могут содержать один или несколько элементов. Элемент может быть строкой, целым числом, объектом или даже другим массивом, и один массив может содержать любую комбинацию этих элементов. У каждого из этих элементов есть индекс, который всегда начинается (иногда сбивает с толку) с 0.Таким образом, первому элементу в массиве присваивается индекс 0, второму — 1 и так далее.

Массивы

PowerShell являются такой фундаментальной частью PowerShell, что они появляются в каждом учебнике PowerShell, и хорошее знание того, как с ними работать, имеет решающее значение для многих аспектов использования PowerShell, от настройки Office 365 до использования PowerShell для пентестинга.

Пример массива PowerShell

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

Существует несколько способов создания массивов в Powershell, но самый простой — выполнить эту команду:

 @ () 

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

 $ fruit = @ ('Яблоки', 'Апельсины', 'Бананы') 

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

 PS / Users / ваше имя> $ fruit 

Что теперь вернет:

 Яблоки

Апельсины

Бананы 

Как видите, этот массив представляет собой группу отдельных фрагментов данных. PowerShell автоматически проиндексирует их так, как мы объяснили выше: «Яблоко» будет проиндексировано как 0, «Апельсины» — как 1, а «Бананы» — как 2.

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

Основы работы с массивами

В этом разделе мы рассмотрим самые простые способы создания массивов и работы с ними в PowerShell.

Создать массив

Сначала мы создадим массив. Стандартный способ сделать это — использовать @ (), хотя есть и другие способы.

А пока давайте создадим массив под названием «данные».Для этого запустите:

 $ data = @ () 

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

 $ data.count 

Что в настоящий момент вернет 0, потому что в нашем массиве нет элементов. Чтобы создать массив с некоторыми данными, мы помещаем эти данные в круглые скобки после @:

.
 $ data = @ ('Ноль', 'Один', 'Два', 'Три') 

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

 $ данные 

В котором будут перечислены элементы, которые мы помещаем в массив.

Доступ к элементам

Теперь у нас есть массив, нам нужно получить доступ к элементам из него. Есть несколько способов сделать это. Первый — использовать индекс элементов в массиве. Как мы уже говорили, индексы начинаются с 0, поэтому для получения первого элемента в нашем массиве нам нужно будет указать PowerShell, чтобы он посмотрел на элемент, индекс которого равен нулю. Мы делаем это, запустив:

 $ данные [0] 

Это вернет «ноль», потому что это первая строка, которую мы поместили в наш массив.

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

 $ данные [0,2,3] 

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

 $ данные [1..3] 

Вернет все элементы с индексом от 1 до 3 (включительно). И:

 $ данные [-1] 

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

Замена предметов

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

 $ data [2] = 'секунда' 

Это дает нам прямой доступ к элементам внутри массива.

Итерационные действия

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

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

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

 $ данные | ForEach-Object {"Item: [$ PSItem]"} 

Эта команда сообщает PowerShell, что нужно брать элементы в $ data по одному, а затем для каждого из них добавлять в начало «Item:», за которым следует исходное значение.

Существует несколько других способов выполнения повторяющихся действий в PowerShell, многие из которых будут вам знакомы, если вы использовали другие языки программирования: PowerShell включает циклы ForEach, циклы For и циклы Switch. Дополнительные сведения об этом см. В документации Microsoft.

Массивы объектов

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

Создание массива объектов

Мы можем создать массив объектов так же, как и со строками, используя функцию @ (). Например, чтобы составить тестовый список сотрудников, мы можем использовать:

 $ data = @ (

[pscustomobject] @ {FirstName = 'Kevin'; LastName = 'Marquette'}

[pscustomobject] @ {FirstName = 'Джон'; LastName = 'Doe'}

) 

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

Доступ к объектам из массивов

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

 $ данные [0] 

Вернется:

 Имя Фамилия

----- ----

Кевин Маркетт 

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

 $ data [0].Имя 

Который вернет «Кевин».

Обновление свойств объекта в массивах

Идя дальше, тот же синтаксис дает нам возможность обновлять отдельные свойства в объектах, которые хранятся в массивах. Например:

 $ data [0] .FirstName = 'Джей' 

Обновит свойство FirstName в первом элементе нашего массива до «Jay».

Доступ к каждому свойству в массиве объектов

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

 $ данные | ForEach-Object {$ _. LastName} 

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

 $ data.LastName 

И вы увидите тот же список. PowerShell фактически принимает каждый объект по очереди, как и раньше, но скрывает от нас эту сложность.

Операторы для массивов

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

-присоединиться к

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

Возьмем пример. Сначала создайте простой массив:

 $ data = @ (1,2,3,4) 

Затем используйте -join, чтобы вставить дефис между каждым элементом и вывести результат:

 $ data -join '-' 

Что вернет «1-2-3-4». Оператор -join также можно использовать без разделителя, в котором элементы массива будут выводиться как серия неразделенных значений.

-содержит

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

 PS> $ data = @ ('красный', 'зеленый', 'синий')

PS> $ data -contains 'зеленый'

Правда 

Равенства

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

Например:

 PS> $ data = @ ('красный', 'зеленый', 'синий')

PS> $ data -eq 'зеленый'

зеленый 

Оператор -ne работает примерно так же, за исключением того, что он выдаст вам все значения, которые не равны указанному вами значению. Итак:

 PS> $ data = @ ('красный', 'зеленый', 'синий')

PS> $ data -ne 'зеленый'

красный

синий 

Однако вы можете использовать оператор if (), чтобы сравнить выходные данные этих операторов с ожидаемыми выходными данными и вернуть результат «Истина» или «Ложь».

Как добавить значения в массив

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

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

Добавление массива

PowerShell может складывать два массива вместе с помощью оператора «+», который скрывает сложность того, что на самом деле делает система. Например, если вы сделаете два таких тестовых массива:

 $ первый = @ (

'Нуль'

'Один'

)

$ секунда = @ (

'Два'

'Три'

) 

Затем вы можете сложить их вместе, используя всего:

 PS> первый + второй 
$

Это создаст новый массив со всеми четырьмя значениями и выведет результаты.Обратите внимание, однако, что это не даст этому новому массиву новое имя. Для этого мы используем оператор + =.

плюс равно для объединения массивов

Вместо использования оператора «+» в приведенном выше примере мы могли бы использовать оператор «+ =», который даст нам совершенно новый массив:

 $ первый + = "два, три" 

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

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

Типы массивов

До сих пор мы имели дело с массивами по умолчанию в PowerShell. Хотя в то время PowerShell не сообщал нам об этом, каждый созданный нами массив относится к одному типу — типу [PSObject []].Этот тип массива может содержать любой тип значения данных.

Строго типизированные массивы

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

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

 PS> [int []] $ numbers = 1,2,3 

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

ArrayList

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

Чтобы создать список ArrayList и затем добавить в него элементы, выполните следующее:

 $ myarray = [System.Collections.ArrayList] :: new ()

[void] $ myArray.Добавить ('Значение') 

Здесь мы можем использовать конструктор .Net по умолчанию для создания нового списка ArrayList, а затем с помощью оператора -Add добавлять в него элементы. Оператор [void] существует потому, что иногда эти команды выдают странные выходные данные, которые могут испортить код.

Идем дальше

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

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

Расширенные функции для работы с массивами

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

Массивы предварительно заданного размера

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

Это можно сделать так:

 $ data = [Объект []] :: новый (4) 

Если вы запустите запрос .count к этому массиву, он вернет «4», потому что даже если в нем нет данных, он заполнит пространство нулем. Это действительно очень полезно, если вам нужно инициализировать новый массив, который заполняется нулями, потому что массив предварительно заданного размера изначально будет заполнен нулями.

Умножение массивов

Умножение объектов в массиве — и особенно строк — это то, что сбивает с толку большинство людей, когда им впервые приходится это делать. Мы видели чрезвычайно сложные сценарии if () для достижения такого результата, но есть гораздо более простой способ:

 PS> $ data = @ ('красный', 'зеленый', 'синий')

PS> $ данные * 3 

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

Вложенные массивы

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

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




$ data2 = @ (

@ (1,2,3),

@ (4,5,6),

@ (7,8,9)

) 

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

Например, чтобы получить доступ к значению «3», мы должны использовать это:

 PS> $ снаружи = 0

PS> $ внутри = 2

PS> $ data [$ снаружи] [$ внутри]

3 

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

Последнее слово

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

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

Естественных продолжений строк в PowerShell

PowerShell — это язык, который позволяет использовать длинные строки кода.Рекомендуемая передовая практика (RBP) заключается в том, что функции и командлеты вместе с их параметрами называются описательно и без сокращений. Также RBP не использует псевдонимы для них в вашем коде. Кроме того, RBP должно использовать полные имена для переменных в регистре Pascal или Camel Case. Смысл этой практики в том, чтобы сделать код более похожим на рассказ, а не на руководство по сборке дешевой мебели. Что касается RBP, я полностью согласен с этим. В дополнение к многословию ключевых слов объединение нескольких команд в конвейер также значительно увеличит количество символов в строке.

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

Я говорю здесь о обратной кавычке (или обратной кавычке, или серьезном ударении).Вы знаете, этот трудно различимый символ:

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

В этом сообщении блога я расскажу, почему длина строки имеет значение, почему мы должны избегать обратных кавычек для продолжения строки, а также различные альтернативные методы и стратегии для уменьшения длины строки и разделения строк кода.Этот пост должен быть подходящим для новых и опытных пользователей PowerShell. Некоторая терминология может быть чужой для новых пользователей. Основными версиями PowerShell, на которые намечено это сообщение, являются 5 и 6. Методы, описанные в этом сообщении, могут работать в более поздних или более ранних версиях, но не были протестированы или проверены в этих версиях.

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

Моя основная проблема с длинными строками кода заключается в том, что мне нужно прокручивать по горизонтали.Я ленив, и современные графические интерфейсы предназначены для облегчения вертикальной прокрутки. Но о горизонтальной прокрутке часто думают позже. Это очень очевидно на GitHub. Например, посмотрите строку 75 файла ClearRecycleBinCommand.cs в исходном коде PowerShell. Некоторые аргументы метода не отображаются, если вы не выделите линию и не перетащите вправо.

Это может показаться незначительным неудобством для просмотра кода, но на самом деле это большая проблема для редактирования и отладки кода (особенно кода, написанного другими).Когда вы работаете в своем любимом редакторе кода (кого я шучу, мы все сейчас используем VS Code с расширением PowerShell, верно?), Вы заметите, что даже на широкоэкранном мониторе большую часть горизонтального пространства часто занимает различные инструменты и меню. У вас все еще может быть большой объем кода на видимой длинной строке, но как насчет кода, который не отображается? Насколько легко обнаружить ошибки в этом коде? Возможно, у вас есть строка, которая в редакторе выглядит так:

Invoke-SomeFunction -SomeParameter ‘Некоторое значение’ -AnotherParameter ‘Другое значение’

Но на самом деле это:

Invoke-SomeFunction -SomeParameter ‘Некоторое значение’ -AnotherParameter «Другая ценность» | Invoke-UnseenFunction -UnseenParameter ‘Unseen Value’

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

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

Корова Собака Кошка Утка Гусь Эчинда Дикобраз Нарвал Шайа ЛаБаф

или

Корова

Собака

Кошка

Утка

Гусь

Эчинда

00030002 Эчинда

000300030003

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

Вам может быть интересно, какой должна быть максимальная длина строки в PowerShell.Это хороший вопрос. Многие другие языки рекомендуют 80 символов, но для PowerShell это может быть слишком ограничительно. Я видел рекомендуемые 120 и 150 символов, и я лично использую и рекомендую 120. Это не жесткое правило, но любая строка, длина которой превышает 120 символов, — это то, что я всегда смотрю на рефакторинг или введение разрыва строки.

Мы знаем, что длинные строки кода нежелательны, но мы также знаем, что PowerShell естественным образом создает длинные строки кода. Так как же нам с этим справиться? Допустим, вы новичок в PowerShell и вы погуглите что-то вроде «многострочной команды PowerShell».Лучшие результаты будут зависеть от обратной кавычки. К чести Дона Джонса, у него также есть небольшая запись в блоге, осуждающая обратную кавычку, которая появляется в результатах, но остальное — море серьезных акцентов.

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

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

# Рассмотрите возможность использования вместо одинарных кавычек

«This` «string`» `$ useses` r`n Backticks ‘«’ «

Вот и все! Это его единственная работа. Этот escape-символ можно использовать вне двойных кавычек точно так же, как для escape-символов в командных строках.

# Никогда не делайте этого в производственном коде

Write-Host `$ Hello` «` `


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

# Никогда не делайте этого в производственном коде

Invoke-WebRequest -Uri ‘http: // get-powershellblog.blogspot.com/ ‘

-Method’ GET ‘

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

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

Обратные кавычки легко пропустить

Посмотрите на саму обратную кавычку:

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

В / r / PowerShell раз в несколько месяцев мы получаем вопрос от OP (Original Poster) о фрагменте кода, скопированном со слайдов PowerPoint профессора колледжа, где код, по-видимому, скопирован дословно, но не выполняется. Для многих из нас, кто часто отвечает на вопросы, проблема очевидна, поскольку код, публикуемый OP, имеет параметр в отдельной строке. Наконец, у нас был OP, включающий слайд от их профессора, и он выглядел примерно так:

# Professor’s Code

Invoke-WebRequest -Uri ‘http: // get-powershellblog.blogspot.com/ ‘

-Method’ GET ‘

# OP’s Code

Invoke-WebRequest -Uri’ http://get-powershellblog.blogspot.com/ ‘

-Method’ GET ‘

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

Обратные кавычки не создают продолжения строк

«Но вы только что сказали, что они сделали?» Нет, я сказал, что обратная кавычка служит для экранирования.Они не столько создают продолжение строки, сколько экранируют символ новой строки, что фактически приводит к продолжению строки. Это важное различие, потому что это…

# Никогда не делайте этого в производственном коде

Invoke-WebRequest -Uri ‘http://get-powershellblog.blogspot.com/’

-Method ‘GET’

and this …

# Никогда не делайте этого в производственном коде

Invoke-WebRequest -Uri ‘http://get-powershellblog.blogspot.com/’

-Method ‘GET’

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

Обратные кавычки делают код, трудно поддерживаемый

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

Допустим, у вас есть следующий код:

# Никогда не делайте этого в производственном коде

Invoke-WebRequest -Uri ‘http://get-powershellblog.blogspot.com/’

-Method ‘GET’ ‘

-UseBasicParsing

$ Date = Get-Date

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

# Никогда не делайте этого в производственном коде

Invoke-WebRequest -Uri ‘http://get-powershellblog.blogspot.com/’

-Method ‘GET’ ‘

$ Date = Get-Date

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

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

# Никогда не делайте этого в производственном коде

Invoke-WebRequest -Uri ‘http: // get-powershellblog.blogspot.com/ ‘`-UseBasicParsing

| -Method ‘GET’

$ Date = Get-Date

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

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

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

# Это

«` $, `» и « r`nСпециальные символы! «

# Становится этим

‘$,» и `{0} Специальные символы’ -f [Environment] :: NewLine

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

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

$ IntList = [System.Collections.Generic.List«1 [[System.Int32, System.Private.CoreLib, Version = 4.0.0.0]]]: : new ()

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

Отлично! Больше никаких обратных кавычек! Однако у нас все еще есть проблема или склонность PowerShell к длинным строкам vs.RBP. Хорошая новость заключается в том, что существует множество способов разбить длинные строки на несколько строк, для которых не требуется обратная кавычка. Я не уверен, каковы точные технические термины для них, но я называю их «Естественные продолжения линий». Это части языка PowerShell, которые, естественно, позволяют перейти к следующей строке без каких-либо специальных символов или соображений. Естественные продолжители строк в PowerShell появляются после большинства операторов (с заметными исключениями: оператор поиска точек , , оператор вызова & и операторы перенаправления вывода, такие как > и >>).

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

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

5 *

5/

5%

5 +

5 —

5 -shl

5 -shr

5

Это вернет 0, но демонстрирует разрыв строки после каждой операции. В качестве другого примера:

# Рассчитать общее количество аниме-эпизодов в серии Monogatari

$ TotalMonogatariEpisodes =

$ Kizumongatari.Episodes.Count +

$ Bakemonogatari.Episodes.Count +

$ Nekomonogatari.Episodes.Count +

$ Nisemonogatari.Episodes.Count +

$ SecondSeason.Episodes.Count +

$ Tsukimonogatari.Episodes3.

$ Koyomimonogatari.Episodes.Count

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

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

# Не делайте этого в производственном коде

$ Int = 5

++

$ Int

# $ Int теперь 6

$ Int

# $ Int снова 5

В то время как это будет иметь ошибку:

$ Int

++

# Ошибка: Отсутствует выражение после унарного оператора ‘++’

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

Остальные, однако, очень пригодятся. Я продемонстрировал, как использовать = в разделе «Арифметические операторы». Я использую тот, который немного выходит

$ FileNames =

1..15 | ForEach-Object {

‘Bakemonogatari — s01e {0: D2} .mkv’ -f $ _

}

+ = также довольно удобен

$ FileNames + =

1..11 | ForEach-Object {

‘Nisemonogatari — s01e {0: D2} .mkv’ -f $ _

}

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

$ Object.Context.SubContext.Localization.Content =

Invoke-WebRequest -Uri $ Uri -UseBasicParsing -Headers $ Headers -Body $ Body -Method ‘POST’ |

Select-Object -ExpandProperty Content

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

Операторы сравнения сравнивают два значения и возвращают истину или ложь, если условие выполняется или не выполняется. Хотя я не перечислил их в заголовке раздела, операторы обратного сравнения ( -notmatch -notlike -notin, -notconatins ) и варианты чувствительности к регистру ( -ieq -ceq -ine -cne -imatch -cmatch ) также работают. . Документация PowerShell включает -replace , но на самом деле это не оператор сравнения, и вы пострадаете, если поместите его в условие if.

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

# Сравните время выполнения первых глав первых эпизодов

$ Kizumongatari.Episodes [0] .Chapters [0] .RunTime -lt

$ Bakemonogatari.Episodes [0] .Chapters [

] .RunTime [0] .RunTime [0] .RunTime [0]. Однако использование -replace в качестве продолжения строки может действительно улучшить читаемость в некоторых случаях, особенно с очень сложными шаблонами регулярных выражений.Вероятно, было бы лучше определить шаблоны поиска и замены как отдельные переменные и использовать их, но некоторые могут возразить против этого. Вот пример использования -replace в качестве продолжения строки:

# Удалите URL-адрес из текста

‘Это какой-то текст с https://someurl.com/ посередине’ -Replace

‘( https?: \ / \ /)? ([\ da-z \ .-] +) \. ([az \.] {2,6}) ([\ / \ w \ .-] *) * \ / ? ‘,

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

# Удалить URL-адрес из текста

$ SearchString = ‘Это текст с https: // someurl.com / посередине ‘

$ SearchPattern =’ (https?: \ / \ /)? ([\ da-z \ .-] +) \. ([az \.] {2,6}) ([ \ / \ w \ .-] *) * \ /? ‘

$ ReplacePattern = ‘

$ SearchString -Replace $ SearchPattern, $ ReplacePattern



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

Если (

$ Kizumongatari.Episodes.Count -lt $ Bakemonogatari.Episodes.Count -and

$ Kizumongatari.Episodes.Count -lt $ Nekomonogatari.Episodes.Countlt2.Episodes. $ Nisemonogatari.Episodes.Count -and

$ Kizumongatari.Episodes.Count -lt $ SecondSeason.Episodes.Count -and

$ Kizumongatari.Episodes.Count -lt $ Tsukimonogatari.Episodes.Count -and

$ Kizumongatari.Episodes.Count -lt $ Owarimonogatari.Episodes.Count -and

$ Kizumongatari.Episodes.Count -lt $ Koyomimonogatari.Episodes.Episodes

.Count 9000 на

000 (

0002) количество эпизодов ».

}

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

Другой пример из сценария сборки psake:

if (

$ ENV: BHBuildSystem -ne ‘Unknown’ -and

$ ENV: BHBranchName -eq «master» -and

$ ENV: BHCommitMessage -match ‘! развернуть ‘

) {

#…

}

Сравните это с этим:

if ($ ENV: BHBuildSystem -ne ‘Unknown’ -and $ ENV: BHBranchName -eq «master» -and $ ENV: BHCommitMessage -match ‘! Deploy’) {

# …

}

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

Оператор -split и оператор -join работают со строками и коллекциями, чтобы разбить строку на коллекцию или объединить коллекцию в строку. Этот раздел также относится к вариантам чувствительности к регистру -isplit и -csplit .Оба эти оператора используются в унарном и двоичном форматах. Использование их в их унарном использовании действительно хорошо было продолжением линии.

$ Strings = -split

‘Эта действительно длинная строка станет набором строк, разделенных пробелами’

$ String = -join

(

‘Это довольно длинный абзац строк.’ ,

‘Они будут объединены в одну строку.’,

«Это не лучший способ объединения таких длинных строк»,

‘, однако, это вариант.’

)

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

$ Strings = $ SomeString -split

$ SomePattern,

0,

‘RegexMatch, IgnorePatternWhitespace, IgnoreCase, Multiline, ExplicitCapture’

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

$ Strings = $ SomeString -split $ DelimiterPatern, $ MaxSubStrings, $ SplitOptions

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

$ ViewXML = $ ViewNames -join

@ ‘

«>

10

11

50

< / View>

Операторы PowerShell: полное руководство

Понимание того, как работают операторы, приведет к более эффективному коду.

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

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

Получите глубокие знания об автоматизации задач и управлении конфигурацией с нашим курсом PowerShell

Различные типы операторов PowerShell

1. Арифметический оператор

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

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

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

Предположим, что целочисленная переменная A содержит 30, а переменная B содержит 10, тогда —

Оператор Описание Пример
+ (Дополнение) Этот оператор используется для добавления значений по обе стороны от оператора. A + B даст 40
— (вычитание) Этот оператор используется для вычитания правого операнда из левого операнда. А — Б даст -20
* (умножение) Этот оператор используется для умножения значений по обе стороны от оператора. A * B даст 300
/ (Отдел) Этот оператор используется для деления левого операнда на правый операнд. Б / А даст 3
% (модуль) Этот оператор используется для деления левого операнда на правый операнд и возвращает остаток. B% A даст 0

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

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

Оператор Описание Пример
= Это простой оператор присваивания, который присваивает значения из правых операндов левым операндам. Z = X + Y присвоит значение X + Y Z
— = Оператор Subtract AND используется для вычитания правого операнда из левого операнда и присваивает результат левому операнду.

Z- = X аналогично Z = Z- X

+ = Оператор Add AND используется для добавления правого операнда к левому операнду и присваивает результат левому операнду. Z + = X аналогично Z = Z + X

Есть и другие операторы присваивания (* =,% =, / =,), которые используются для изменения значения переменной.

Связанная статья: Учебное пособие по PowerShell

3.

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

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

Логические операторы соединяют условные операторы в одно сложное условное выражение. Предположим, что логические переменные X имеют значение true, а переменная Y — false, тогда —

Оператор Описание Пример
И (логическое И) Обозначается оператором логического И.Условие истинно, если оба операнда не равны нулю. (X -И Y) ложно
ИЛИ (логическое ИЛИ) Именуется оператором логического ИЛИ. Условие истинно, если любой из двух операндов не равен нулю. (X-ИЛИ Y) верно
НЕ (логическое НЕ) Обозначается оператором логического НЕ. Он используется для изменения логического состояния операнда. Если условие истинно, оно возвращает ложь.

-НЕТ (X -И Y) верно

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

4.

Сравнение Операторы

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

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

4.1. Оператор равенства

Тип Оператор Описание
Равенство -экв. Сравнивает два значения, чтобы быть равными или нет.
-ne Сравните два значения, чтобы убедиться, что они не равны.
-GT Сравнивает первое значение с большим, чем второе.
-ge Сравните первое значение, чтобы оно было больше или равно второму.
-lt Сравните первое значение меньше второго.
-le Сравнивает первое значение с меньшим или равным второму.

Все операторы равенства возвращают логическое значение ($ true или $ false).Операторы возвращают значение ИСТИНА или совпадает, если входные значения идентичны указанному шаблону. Весь шаблон должен соответствовать целому значению.

Пример:

  PS> 4-экв 3  
Выход: ложь
  PS> "xyz" -eq "xyz"  
Выход: True
  PS> "xyz" -eq "xyz", "def"  
Выход: ложь

Пример:

  PS> "xys" -ne "ghu"  
Выход: True
  PS> "xys" -ne "xys"  
Выход: ложь
  PS> "xys" -ne "xys", "def"  
Выход: True

Пример:

  PS> 7, 8, 9-GT 8  
Выход: 9

Пример:

  PS> 7, 8, 9 -ge 8  
Выход:

8

9

Пример:

  PS> 8-л. 6  
Выход: ложь
  PS> 7, 8, 9 -lt 8  
Выход: 7

Пример:

Выход:

7

8

4.2. Операторы матча:

Операторы сопоставления: «-like», «-notlike», «-match» и «-notmatch».

Оператор

Описание Пример

— как

Этот оператор вернет истинное значение, если строка соответствует подстановочному знаку

узор

PS> «PowerShell» -подобный «* shell»

Правда

-не нравится Этот оператор вернет истинное значение, если строка не соответствует шаблону подстановки

PS> «PowerShell» — в отличие от «* shell»

Ложь

-матч Этот оператор вернет истинное значение, если строка соответствует шаблону регулярного выражения

PS> «Good Dog» -матч «Dog»

Правда

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

Этот оператор вернет истинное значение, если строка не соответствует

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

PS> «Воскресенье» — не матч «солнышко»

Ложь

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

Синтаксис:

  <строка []> -подобный <выражение-дикой карты>
<строка []> -notlike   

В то время как операторы «-match» и «-notmatch» используют регулярные выражения для поиска элементов, которые соответствуют или не соответствуют указанному шаблону.

Синтаксис:

  <строка []> -match <регулярное-выражение>
<строка []> -notmatch <регулярное-выражение>?  

4.3. Операторы содержания:

В PowerShell есть два оператора включения, такие как «-contains» и «-notcontains», которые похожи на операторы равенства. Они всегда возвращают логическое значение в зависимости от того, существует ли значение в правой части оператора в наборе значений в левой части оператора (истина или ложь).

Этот оператор сообщает, включает ли набор эталонных значений одно тестовое значение

Синтаксис:

  <Справочные-значения> -содержит <Тестовое-значение>  

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

Пример:

  PS> "xyz", "abc" - содержит "abc"  
Выход: True
  PS> «Linux», «Windows» - содержит «Диск»  
Вывод: False # Не точное совпадение

Этот оператор сообщает, включает ли набор контрольных значений одно тестовое значение. Кроме того, возвращает ИСТИНА, если тестовое значение не является точным совпадением хотя бы с одним из эталонных значений.

Синтаксис:

  <ссылочные- значения> -notcontains   

Пример:

  PS> «Linux», «Windows» - не содержит «Drive»  
Вывод: True # Не точное совпадение.

Оператор -in был введен в PowerShell 3.0. Этот оператор сообщает, появляется ли тестовое значение в наборе справочных значений. Возвращает ИСТИНА, только если тестовое значение точно соответствует хотя бы одному из эталонных значений.

Синтаксис:

  <тестовое-значение> -в <ссылочные-значения>  

Пример:

  PS> «xyz» -в «dfg», «xyz»  
Выход: True
  PS> «Диск» - в «Windows», «Linux»  
Вывод: False # Не точное совпадение
  PS> «Диск» - в «Диске», «Винда»  
Вывод: True # точное совпадение

Оператор «-notin» был введен в PowerShell 3.0. Этот оператор сообщает, появляется ли тестовое значение в наборе эталонных значений. Возвращает ИСТИНА, если тестовое значение не является точным совпадением хотя бы с одним из эталонных значений

.

Синтаксис:

  <Тестовое-значение> -notin <Ссылочные-значения>  
Пример:
  PS> "xyz" -notin "dfg", "xyz"  
Выход: ложь
  PS> "abc" -notin "hjk", "oip"  
Выход: True

4.4. Оператор замены:

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

Давайте взглянем на вопросы для собеседований по PowerShell

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

  <вход> <оператор> <оригинал>, <заменитель>  

По умолчанию оператор -replace не чувствителен к регистру.Мы можем использовать -creplace, чтобы сделать его чувствительным к регистру. Используйте -ireplace, чтобы явно регистрировать регистр.

Пример:

  PS> «Мэдди» -заменить «М», «Д»  
Выход: папа
  «Мэдди» - камин «М», «Д»  
Выход: папа
  «Мэдди» - заменитель «М», «Д»  
Выход: maddy

Статья по теме: Вопросы для собеседования по PowerShell

5. Сравнение типов:

Чтобы определить, принадлежит ли объект определенному типу, в PowerShell используются операторы сравнения типов.Есть два оператора сравнения типов, такие как «-is» и «-isnot».

Синтаксис:

  <объект> -is <ссылка на тип>  

Пример:

  PS> $ a = 5
PS> $ b = "5"
PS> $ a -is [число]
Истинный
PS> $ a -is $ b.GetType ()
Ложь?  

Синтаксис:

  <объект> -isnot <ссылка на тип>  

Пример:

  PS> $ a = 5
PS> $ b = "5"
PS> $ a - это не $ b.GetType ()
Истинный
PS> $ b -isnot [int]
Истинный?  

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

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

7. Оператор перенаправления:

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

Оператор

Описание

В наличии

>

Этот оператор используется для перенаправления стандартного вывода (без ошибок) в файл

Все версии PowerShell

>>

Этот оператор используется для перенаправления вывода и добавления его в файл

Все версии PowerShell

2>

Этот оператор используется для перенаправления вывода ошибок в файл

Все версии PowerShell

2 >>

Этот оператор используется для перенаправления вывода ошибки и добавления его в файл

Все версии PowerShell

2> & 1

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

Все версии PowerShell

3>

Этот оператор используется для перенаправления вывода предупреждения в файл

PowerShell 3.0 и выше

3 >>

Этот оператор используется для перенаправления вывода предупреждения и добавления его в файл

PowerShell 3.0 и выше

4>

Этот оператор используется для перенаправления подробного вывода в файл

PowerShell 3.0 и выше

4 >>

Этот оператор используется для перенаправления подробного вывода и добавления его в файл

PowerShell 3.0 и выше

5>

Этот оператор используется для перенаправления вывода отладки в файл

PowerShell 3.0 и выше

5 >>

Этот оператор используется для перенаправления вывода отладки и добавления его в файл

PowerShell 3.0 и выше

n> & 1

Этот оператор используется для перенаправления вывода предупреждения (n = 3), подробного (n = 4) или отладочного (n = 5) вывода в то же место, что и стандартный вывод

PowerShell 3.0 и выше

*>

Этот оператор используется для перенаправления всех выходных потоков (стандартных, предупреждений об ошибках, подробных и отладочных) в файл

PowerShell 3.0 и выше

* >>

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

PowerShell 3.0 и выше

Статья по теме: Изучите список основных команд PowerShell

8. Унарные операторы:

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

Например, чтобы увеличить переменную $ a с 20 до 21, мы набираем $ a ++.

9. Специальные операторы:

Специальные операторы

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

Давайте посмотрим на различные специальные операторы, используемые в PowerShell.

Этот оператор используется для запуска сценария, команды или блока сценария. Оператор & используется для запуска программы, путь или имя которой содержит пробелы.

Например, для следующей команды

  "D: Program Files (x86) Test AppMyApp.exe"  

Он просто отображает строку на экране, но не запускает программу MyApp.исполняемый. Чтобы запустить MyApp.exe как программу, просто поместите оператор & перед строкой:

  & "D: Program Files (x86) Test AppMyApp.exe"  

Используется для оценки выражения между символами $ (и). Этот оператор используется для возврата одного или нескольких операторов. Он возвращает скаляр для одного оператора и возвращает массив для нескольких операторов. Для использования выражения в другом выражении мы используем этот оператор.

Пример: встроить результаты команды в строковое выражение

  PS> «Сегодня $ (Get-Date)»  
Сегодня 26.06.2020 13:15:20
  PS> "Список папок: $ ((dir c: -dir).Имя -join ',') " 
Список папок: Program Files, Program Files (x86), Users, Windows

Этот оператор возвращает результат одного или нескольких операторов в виде массива. Если есть только один элемент, массив имеет только один член.

  @ (Get-CimInstance win32_logicalDisk)  

Для доступа к статическому члену класса .NET мы используем оператор статического члена

Класс — это тип объекта, а статический член — это свойство или метод класса. Например, выражение

  [DateTime] :: Сейчас  
относится к статическому свойству Now объекта DateTime.NET-класс.

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

Например, выражение 3..6 выводит массив из четырех элементов (3,4,5,6), а выражение 6..4 выводит массив из трех элементов (6,5,4).

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

Например, выражение

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

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

  $ items = "X", "Y", "Z"  
назначает трехэлементный массив переменной $ items.

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

Например,

  "{0} {1, -10} {2: N}" -f 1, "привет", [математика] :: pi  

Выход:

1 привет 3.14

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

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

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

Функции, определенные в Sample.ps1, теперь будут доступны после завершения сценария.

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

Например,

  $ x = $ null
$ x ?? = 200
$ x?  

Выход:

200

В следующем примере правый операнд не оценивается.

  [строка] $ todaysDate = '27.06.2020 '
$ todaysDate ?? = (Get-Date) .ToShortDateString ()?  

Выход:

27.06.2020

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

Например:

Выход: 200

В следующем примере правый операнд не оценивается.

  [строка] $ todaysDate = '27.06.2020 '
$ todaysDate ?? (Get-Date) .ToShortDateString ()?  

Вывод: 27.06.2020

Заключение:

В этом блоге мы рассмотрели множество операторов PowerShell. Вам всегда полезно знать заранее, с каким типом оператора вы работаете в PowerShell, чтобы повысить эффективность вашего кода.

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

  PS> 7, 8, 9 -le 8  

Создание URL-адреса HTML из строки PowerShell — # SQLNewBlogger — SQLServerCentral

Еще одно сообщение для меня, простое и, надеюсь, служит примером для людей, пытающихся вести блог под номером #SQLNewBlogger s.

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

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

 $ folder = "E: DocumentsgitSQLSatArchiveSQLSatArchiveSQLSatArchiveClientApppublicAssetsPDF" 
 $ код = ""
$ list = Get-ChildItem -Path $ folder
ForEach ($ File в $ list) {
# write-host ($ File.name)
$ code = $ code + "
  • $ ($ File.BaseName)
  • " } write-host ($ code)

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

    I

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

     $ folder = "E: DocumentsgitSQLSatArchiveSQLSatArchiveSQLSatArchiveClientApppublicAssetsPDF" 
     $ код = ""
    $ list = Get-ChildItem -Path $ folder
    ForEach ($ File в $ list) {
    # write-host ($ File.name)
    $ code = $ code + '
  • $ ($ File.BaseName)
  • ' } write-host ($ code)

    выдал следующий тип вывода:

     
  • $ ($ File.BaseName)
  • Не совсем первоклассный HTML.

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

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

     $ code = $ code + "
  • $ ($ File.BaseName)
  • "

    И я затем получил то, что хотел:

     
  • 1019
  • Строки в PoSh могут быть забавными, поэтому полезно уделить немного внимания избеганию вещей и знанию переменных и двойных кавычек.

    SQLNewBlogger

    Это заняло около 15 минут беспорядка с Google и PoSh для решения, но на это уходит около 10 минут.

    Хороший пример, демонстрирующий некоторые исследования, инициативы и исследования в дополнение к решению проблемы.

    Функция Powershell Join-String — Geoff @ UVM

    Обновление : еще лучше, прочтите об операторах PowerShell -Join и -Split .Живи и учись.
    —Геофф

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

    Вот он в действии:

     
    PS C: \ & gt; $ array = 3.14, 'Щенок', $ false, '', 'Зеленый', $ null, 'foo'
    PS C: \ & gt; $ массив | Строка соединения
    3.14, Щенок, Ложь ,, Зеленый ,, foo
    PS C: \ & gt; $ массив | Join-String -collapse
    3.14, Щенок, Зеленый, foo
    PS C: \ & gt; $ массив | Строка соединения -collapse '-'
    3.14 - Щенок - Зеленый - foo 

    Обновление: Теперь поддерживает использование элементов списка в качестве параметра (без конвейера):

     
    PS C: \ & gt; $ y = Join-String $ array -collapse
    PS C: \ & gt; $ y
    3.14, Щенок, Ложь, Зеленый, foo
    PS C: \ & gt; $ y.gettype ()
    
    IsPublic IsSerial Имя BaseType
    -------- -------- ---- --------
    Система True True String.Объект
     

    Вот код:

     
    # Join-String - Простая конвейерная функция для
    # объединяем кучу строк вместе с разделителем
    # [email protected] ср 17.11.2010
    # обновлено от 11 июля 2013 г. для обработки использования, не связанного с конвейером.
    
    функция Join-String
    (
    [строка []] $ список,
    [строка] $ separator = ',',
    [переключатель] $ Свернуть
    )
    {
    
    [строка] $ строка = ''
    $ first = $ true
    
    # если вызывается с параметром списка, а не в конвейере ...
    if ($ list.count -ne 0) {
    $ input = $ list
    }
    
    foreach ($ element в $ input) {
    # Пропускать пустые элементы, если указано -Collapse
    if ($ Collapse -and [строка] :: IsNullOrEmpty ($ element)) {
    Продолжать
    }
    
    if ($ first) {
    $ строка = $ элемент
    $ first = $ false
    }
    еще {
    $ строка + = $ разделитель + $ элемент
    }
    }
    
    запись-вывод $ строка
    }
     

    Если у вас есть идеи, как это можно улучшить, прокомментируйте.

    Использование функции списка цитат PowerShell для работы с массивом строк

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

    $ servers = ‘server1’, ‘server2’, ‘server3’, ‘server4’, ‘server5’, ‘server6’. $ Servers

    $ servers = ‘server1’, ‘server2’, ‘server3’, ‘server4’, ‘server5’, ‘server6’

    $ servers

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

    $ servers = ‘server1, server2, server3, server4, server5, server6’ -split ‘,’ $ servers

    $ servers = ‘server1, server2, server3, server4, server5, server6’ -split ‘,’

    $ servers

    Я немного изменил пример Рона, так как предпочитаю разделить на пробелы, но это в основном тот же пример:

    $ servers = ‘server1 server2 server3 server4 server5 server6’ -split » $ Servers

    $ servers = ‘server1 server2 server3 server4 server5 server6’ -split ‘

    $ servers

    При дальнейшем тестировании я решил, что могу сначала использовать параметр разделения и сохранить еще несколько символов, хотя расширению с вкладками или intellisense в ISE это не нравилось, оно все равно работало:

    $ servers = -split ‘сервер1 сервер2 сервер3 сервер4 сервер5 сервер6’ $ Servers

    $ servers = -split ‘server1 server2 server3 server4 server5 server6’

    $ servers

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

    функция ql {$ args} $ servers = ql server1 server2 server3 server4 server5 server6 $ servers

    function ql {$ args}

    $ servers = ql server1 server2 server3 server4 server5 server6

    $ servers

    Я решил записать короткое видео этого процесса: