Как вызовать объект класса в powershell jobs

PowerShell is a powerful tool for task automation and configuration management, mainly in the Windows operating system. Penetration testers and ethical hackers can use PowerShell scripting to automate many activities.

In simple terms, PowerShell makes it easier to automate and manage tasks on Windows systems, enhancing cybersecurity efforts.

What Is PowerShell?

PowerShell refers to two related Microsoft Windows products: a scripting language and a command-line shell for executing PowerShell scripts. (Microsoft Learn, 2023) First released in 2006, PowerShell was originally developed only for the Windows operating system to replace the Command Prompt. However, it is also available for the macOS and Linux operating systems via the cross-platform PowerShell Core framework.

What Is PowerShell Scripting?

PowerShell is a full-fledged scripting language that supports variables, conditional statements, loops, functions, error handling, and more. This makes it suitable for many use cases (as we’ll see later).

Some Common Use Cases

1. System Administration

• Creating, modifying, or deleting user accounts and groups in Active Directory.
• Configuring and managing devices on Windows servers.
• Creating, deleting, and moving files and folders.
• Changing Windows Registry keys and values.

2. Task Automation

• Automating repetitive tasks such as data backup, log deletion, and software installation.
• Scheduling tasks to run at specific times or after specific intervals.
• Processing large amounts of files or data in bulk (e.g., moving or renaming all the files in a folder).

3. Configuration Management

It can be used to tweak many aspects of Windows settings and configurations, such as:

• Defining environment variables, system parameters, and network settings.
• Applying configurations to multiple users at once using Group Policy.
• Standardizing Windows configurations across multiple workstations or servers.

4. Monitoring and Reporting

PowerShell scripts can provide visibility into the events within an IT environment. The monitoring and reporting use cases of PowerShell include:

• Collecting, processing, and analyzing data about system performance.
• Searching and filtering Windows logs for specific events or anomalies.
• Automatically generate reports and send them to key decision-makers.

5. Security and Compliance

Last but not least, PowerShell scripting can help organizations ensure that they are properly detecting cybersecurity weaknesses and remaining compliant with laws and regulations:

• Auditing and securing user credentials (e.g., by enforcing password policies).
• Conducting IT security scans and vulnerability assessments.
• Enforcing compliance with data privacy and security regulations and standards.

PowerShell Scripting in Penetration Testing

The role of penetration testers is to probe an IT machine or ecosystem for vulnerabilities by simulating a real cyberattack against it. Penetration testers can use PowerShell scripts to automate many of their activities when scanning for security weaknesses in Windows environments:

• Reconnaissance: Before conducting a penetration test, pen testers perform surveillance on the target, gathering information such as open ports and running services. PowerShell scripts can automate the reconnaissance task, collecting data to help identify the most promising avenues of attack.
• Vulnerability scanning: During a simulated attack, penetration testers scan for many vulnerabilities: SQL injection, cross-site scripting (XSS), insecure direct object references (IDOR), and more. Pen testers can write PowerShell scripts that automate scanning using various cybersecurity tools and libraries.
• Exploitation and privilege escalation: After penetration testers detect security weaknesses, the next step is to exploit them and extend the attacker’s reach throughout the IT ecosystem. PowerShell scripts can help testers escalate privileges, perform lateral movement throughout the network, and exfiltrate sensitive data.
• Reporting and documentation: Once a penetration test is complete, testers need to report their findings to key decision-makers and make recommendations for resolving any vulnerabilities detected. PowerShell scripting can help gather data from multiple sources and generate reports summarizing the vulnerabilities detected and the extent to which they could be exploited.

References

1. Microsoft Learn. (2023). Powershell Documentation – Microsoft Learn. https://learn.microsoft.com/en-us/powershell/
2. Microsoft Learn. (2021). Cmdlet Overview – Microsoft Learn. https://learn.microsoft.com/en-us/powershell/scripting/developer/cmdlet/cmdlet-overview?view=powershell-7.3
3. Microsoft Learn. (2021). Introducing the Windows PowerShell ISE – PowerShell | Microsoft Learn. https://learn.microsoft.com/en-us/powershell/scripting/windows-powershell/ise/introducing-the-windows-powershell-ise?view=powershell-7.3

Author Bio

David Tidmarsh is a programmer and writer. He’s worked as a software developer at MIT, has a B.A. in history from Yale, and is currently a graduate student in computer science at UT Austin

In my last article, I introduced the Practical PowerShell series. When working on PowerShell scripts, there might come a point where a set of instructions repeats code elsewhere in the script. It is also possible that you might want to incorporate code from elsewhere into your script so that you can easily call the code.

This description might remind you about cmdlets, which have names and, optionally, one or more parameters to control their operation. But what if you want the same thing for your code, like some code with a high reusability factor? Welcome to the world of PowerShell functions. Before we get too deep, let’s define exactly what we are talking about.

Scripts

A script is a text file with a .ps1 extension containing PowerShell code. The code consists of cmdlets and (optionally) functions. You can call scripts in various ways:

• Using the ampersand (& .\Process-Something.ps1). The code runs in a child session with its scope. This means any definitions, such as variables or functions in the script, disappear when the script terminates. When you run interactive PowerShell scripts, you usually omit the ampersand, but when you want to run code pointed to in a variable, you must use this invocation method, e.g., & { Get-ChildItem }

  Make sure to understand the difference between using the ampersand at the start and end of a command. Using an ampersand at the end instructs PowerShell to run the code in a background job.

• Using dot-sourcing (e.g. .\Helper-Functions.ps1)., the code runs in the current PowerShell session. This means that any variables or functions you define in the script become available in the session. If these definitions existed before, they would simply be overwritten.

The ability to run PowerShell scripts depends on the local machine’s current execution policy. This is a security measure to prevent malicious scripts from running. Scripts from Microsoft are generally signed, but many community-sourced scripts downloaded from the internet are usually not. You may need to run Set-ExecutionPolicy unrestricted before you can run scripts created by others, provided company policies do not prevent you from modifying the execution policy.

Reusable Code

Function Get-MyReport {
    #reusable code
}

If you create a function that redefines an existing command, the existing definition is overwritten in the current session. The code’s output will be returned to the caller, and you can output the result to the screen or assign it to a variable for further processing.

In addition to the function itself, you can also define parameters for the code contained in the function. The code within the function can then perform its task using information passed through the parameters, as the parameters become variables usable in the context of the function’s code.

Function Get-DistributionGroupInfo( $Identity, $MemberCount)
{
    Get-DistributionGroup $Identity | Select-Object Identity,PrimarySmtpAddress, @{n='MemberCount';e={ If( $MemberCount) { (Get-DistributionGroupMember -Identity $_ | Measure-Object).Count } }}}
}

This code is acceptable when drafting a script or working on a proof of concept. However, issues might become apparent when using the function later or somebody else who is less familiar with the use case takes responsibility for the code.

Among the issues with this function are:

• The distribution group passed in the variable $Identity can be unspecified ($null). This can lead to unintended side effects, as many Get cmdlets happily return all objects when you specify $null as a value. Take the following code:

Function Process-Mailbox( $Id) {
    Get-Mailbox -Identity $Id | Set-Mailbox -HiddenFromAddressListEnabled $True
}

Can you guess what happens if you do not pass the ID parameter or when the ID is empty? All mailboxes are returned and Set-Mailbox will happily hide all the mailboxes from address lists. It is probably not something you intended.

• In the example above, Identity and Members can be anything; they do not need to be a distribution group or switch, respectively. You might add code that checks if $Identity is a distribution group and if Members is a Boolean ($true or $false), but that would require additional code. The code might become quite complex if it must process multiple parameters.

Function Get-DistributionGroupInfo {
    [CmdletBinding()]
    Param(
        [Parameter(Position= 0, Mandatory= $true, ValueFromPipeline= $true, ValueFromPipelineByPropertyName=$true, HelpMessage= 'Please provide a Distribution Group')]
        [String]$Identity,
        [Parameter(HelpMessage= 'Output member count')]
        [Switch]$MemberCount
    )
    Process {
        Write-Verbose ('Fetching Distribution Group {0}' -f $Identity)
        Get-DistributionGroup $Identity | Select-Object Identity,PrimarySmtpAddress, @{n='MemberCount';e={ If( $MemberCount) { (Get-DistributionGroupMember -Identity $_ | Measure-Object).Count } }}
    }
}

• [CmdletBinding()] before the first parameter definition tells PowerShell that the function supports common parameters. Examples of common parameters are Verbose and Confirm. You can then include code in your function to support this. For example, if you pass -Verbose and your function contains Write-Verbose commands, verbose output will be displayed. When you omit -Verbose, the output is not displayed.
• Position=0 in the first parameter specification instructs PowerShell that the first unnamed parameter passed to Get-DistributionGroupInfo is treated as the Identity. So, the following two commands are the same:

Get-DistributionGroupInfo -Identity 'DG-X'

Get-DistributionGroupInfo 'DG-X'

Additional unnamed parameters can be specified as Position=1, etc.

• Mandatory=$true tells PowerShell that this parameter is mandatory. When a user omits the Identity when running the script, PowerShell will ask for it. Parameters can be optional by setting Mandatory to $false or omitting the condition.
• We want to be able to pass the Identity when the function is called in a pipeline. You can enable pipeline usage for this parameter by specifying ValueFromPipeline. You can use the property of passed objects by specifying ValueFromPipelineByPropertyName. Calling the function in a pipeline can then look like this:

Get-DistributionGroup -Identity 'DG-X' | Get-DistributionGroupInfo

• When you omit a mandatory parameter, HelpMessage defines help information. This help information is displayed when you enter !? when PowerShell asks you for input, and it is also displayed when you use:

Get-Help Get-DistributionGroupInfo -Full

I do not know anyone who uses !?, but you can if you want.

• After specifying the constraints, you define the parameter itself. You do this by giving it a name or, in this case, an identity. This name contains the value passed as a parameter when the function is called, making it available within its scope. You can optionally define the type of object the parameter will accept. In this case, we specify [String], which equals [System.String], but PowerShell has some type accelerators (short aliases) for built-in types.

Function Test {
    param(
        [int]$A
    )
    Write-Output ($A)
}
❯ test -A 123
123
❯ test -A 'string'
Test: Cannot process argument transformation on parameter 'A'. Cannot convert value "string" to type "System.Int32". Error: "The input string 'string' was not in a correct format."

I recommend using strict typing with parameters whenever possible. Typing helps with troubleshooting usage and also helps to document the code, as explained later. One thing to consider is that values might get converted through interpretation. For example, if you pass a parameter value 123, and a string is expected, PowerShell will happily convert this to a string representation, ‘123’.

• The second parameter (note the comma after Identity) is a Switch named MemberCount. Since this parameter is not mandatory and pipeline usage is unnecessary, these are not specified in the definition. The nice thing with switches is that you can use them just by mentioning, e.g. –MemberCount ; will set the MemberCount variable to $true. When you do not, it will be $false. You cannot use -MemberCount $true, as PowerShell will interpret $true as the next parameter since MemberCount is a switch. If needed, for example when $true or $false is stored in a variable, you can set it using a variable by specifying <Switch>:<value>, e.g. -MemberCount:$false. You might already be using this syntax when avoiding having to confirm certain commands, e.g. Set-Mailbox … -Confirm:$False
• By putting the code performing the actual task in a Process script block {}, we make the function work for objects passed through the pipeline. If we omit this and leave the code as-is, it will not support pipelining, and the code will only execute once for the last object received through the pipeline. Note that the current object in the pipeline is available through the automatic variable $_, if needed, within the Process script block.

When we put the code for this function in a script file, for example, MyDemo.ps1, it becomes available within our PowerShell session. To accomplish this, we need to dot source it to define it in our session. We can then call it – provided the Exchange Online Management Shell is loaded and connected – and inspect its definition by calling Get-Help, which also includes documentation.

PS❯ . .\MyDemo.ps1
PS❯ Get-DistributionGroupInfo -Identity MyDG -MemberCount -Verbose
VERBOSE: Fetching Distribution Group MyDG
Identity PrimarySmtpAddress MemberCount
-------- ------------------ -----------
MyDG MyDG@contoso.com 2
PS❯ Get-DistributionGroup | Get-DistributionGroupInfo -MemberCount
Identity PrimarySmtpAddress MemberCount
-------- ------------------ -----------
MyDG MyDG@contoso.com 2
OtherDG OtherDG@contoso.com 8
PS❯ Get-Help Get-DistributionGroupInfo -Full
NAME Get-DistributionGroupInfo
SYNTAX Get-DistributionGroupInfo [-Identity] <string> [-MemberCount] [<CommonParameters>]
PARAMETERS -Identity <string> Please provide a Distribution Group. Required? True Position? 0 Accept pipeline input? true (ByValue) Parameter set name (All) Aliases None Dynamic? False Accept wildcard characters? False -MemberCount Output member count Required? False Position? Named Accept pipeline input? False Parameter set name (All) Aliases None Dynamic? False Accept wildcard characters? False <CommonParameters> This cmdlet supports the common parameters: Verbose, Debug, ErrorAction, ErrorVariable, WarningAction, WarningVariable, OutBuffer, PipelineVariable, and OutVariable. For more information, see about_CommonParameters (https://go.microsoft.com/fwlink/?LinkID=113216).

Begin, Process, End

Begin {
        # Initialize
        $Items=0
    }
    Process {
        # Do Something
        $Items++
    }
    End {
        # Cleanup
        Write-Host ('We processed {0} object(s)' -f $Items)
    }

An example is when you want to count how many objects you have processed, as the number of objects passed through a pipeline is unknown upfront. Another example of this would be the Sort-Object command, which can only sort objects when all objects have been passed to it.

Script Parameters

[CmdletBinding()]
Param(
    [parameter( Mandatory= $true)
    [ValidateScript({ Test-Path -Path $_ -PathType Leaf})]
    [String]$CSVFile,
    [ValidateSet(',', ';')]
    [string]$Delimiter=',',
    [System.Security.SecureString]$Password
)
Function X {
    # …
}
#etc.

• Ask to provide a value for $CSVFile when one has not been given (Mandatory= $true). You will notice a ValidateScript line as part of the CSVFile parameter definition. When specifying parameters, you can have PowerShell perform certain validations against the values provided. Some of the possible tests are:
  • ValidateScript is used to execute a script block that needs to result in $true for the parameter value to be accepted. In the example, we check if the filename is valid using Test-Path specifying the automatic variable $_ (the actual filename).
  • ValidateSet to test the value against a set of predefined values. In the example, we use ValidateSet only to allow a comma or semi-colon for the $Delimiter parameter.
• The delimiter parameter can be specified. If it is not specified (not mandatory), we set it to a default value of ‘,.’
• A $Password parameter can be provided. When specified, it needs to be of the type [System.Security.SecureString]. You are not limited to PowerShell’s built-in types; you can also use other (.NET) types, such as SecureString or a credential of the type [PSCredential].

Make PowerShell Work for You

It is ambitious to discuss functions and parameters in PowerShell in one article. I have not touched on other subjects, such as command sets and dynamic parameters. These might be topics for another article.

I hope that I have encouraged you to write reusable code, not only to leverage scripts and functions but also to correctly define code. Make PowerShell work for you when possible, letting it handle parameter validation and checking other constraints such as types. This enables you to focus on the task while making code less complex and improving readability.

If you have questions or comments, feel free to reach out in the comments. If not, wait until the next article, where I will discuss flow control.

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

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

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

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

С начала 2016 года язык получил кросс-платформенную поддержку. Теперь его можно применять не только в операционных системах Windows 7, 8, 10, и 11, но и на macOS (начиная с версии 10.13), а также на различных популярных дистрибутивах Linux (подробная информация о совместимых дистрибутивах доступна в официальной документации).

Как открыть PowerShell в Windows

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

PowerShell является независимым от версии операционной системы инструментом и работает одинаково стабильно как на Windows 10, так и на Windows Server.

Существует два основных метода для запуска PowerShell или PowerShell ISE в системе Windows: через меню «Пуск» и с помощью приложения «Выполнить».

• Для того чтобы открыть PowerShell через меню «Пуск», пройдите к папке Windows PowerShell, откройте её и выберите необходимое приложение. В этой директории доступны как 32-разрядные версии (отмечены как x86 в скобках), так и 64-разрядные версии терминала и ISE.

• Чтобы запустить PowerShell через приложение «Выполнить», используйте комбинацию клавиш Win + R. Когда появится окно, введите powershell или powershell ise (в зависимости от того, какое приложение вам нужно) и нажмите кнопку ОК.

Команды (командлеты) PowerShell

В языке программы PowerShell команды носят название командлеты (от английского «cmdlet»). Все они формируются с использованием шаблона «Глагол-Существительное», или «Действие-Объект». Например, Get-Services и Start-Process. Благодаря такой структуре, можно легко понять предназначение команды, даже если вы с ней ещё не работали ранее.

Синтаксис командлетов

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

Set-Location -LiteralPath C:\ -PassThru

Разберем его на составные части:

• Set-Location — буквально «вызвать команду». Этот командлет позволяет выполнять указанный блок сценария.
• -LiteralPath C:\ — здесь передаем блок сценария, в котором используется команда Set-Location для перехода в каталог C:\.
• -PassThru — по умолчанию командлет Invoke-Command не возвращает результат выполнения. Этот параметр указывает на необходимость вывода информации о местоположении, в которое был выполнен переход с помощью команды Set-Location.

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

sEt-loCATion -PATH c:\ -passthru

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

Иногда команда может быть слишком длинной. Для разделения на несколько строк можно использовать символ обратного апострофа ` в месте переноса. Новую строку можно создать, нажав Shift + Enter (для переноса строки ниже текущей) или Ctrl + Enter (для переноса строки выше текущей).

Разделим предыдущую команду:

Set-Location `
-LiteralPath C:\ `
-PassThru

Алиасы

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

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

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

Get-Alias -Definition Set-Location

Если вам нужно узнать полное название командлета по его алиасу, используйте параметр -Name. Этот параметр необязателен, так как он является аргументом по умолчанию.

# Оба следующих варианта эквивалентны:
Get-Alias -Name clear
Get-Alias clear

Особенности обработки путей к каталогам

Для многих командлетов необходимо предоставить путь к файлу или каталогу. Это делается с использованием строки, например: C:\Windows\System32.

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

# Следующая команда не будет выполнена корректно
Set-Location C:\Program Files

PowerShell «воспринимает» пробел и интерпретирует его так, будто путь к папке закончился на слове Program, а files — это уже значение другого параметра.

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

• Экранировать символы с помощью обратного апострофа `: C:\Program` Files. Однако это может быть неудобным, если путь длинный.
• Поместить весь путь в одинарные или двойные кавычки: 'C:\Program Files' или "C:\Program Files" (желательнее использовать одинарные кавычки).

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

• Точка . указывает на текущий каталог. Например, Get-ChildItem . позволяет просмотреть содержимое текущего местоположения.
• Две точки .. указывают на родительский каталог. Например, Set-Location .. позволяет перейти к родительскому каталогу. Это может быть полезно, если вы находитесь в глубоко вложенной директории.

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

Get-Help: как изучать новые командлеты

Для получения подробной информации о конкретном командлете воспользуйтесь командой Get-Help Название-Командлета. Пример:

Get-Help Get-Childitem

У команды Get-Help имеется несколько полезных параметров:

• -Detailed предоставляет более подробную справку по командлету.
• -Full предоставляет полную справку.
• -Examples демонстрирует примеры использования командлета.
• -Online перенаправляет пользователя на веб-страницу с соответствующей документацией.

Объекты и конвейеры (пайплайны) в PowerShell

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

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

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

Пример работы конвейера в PowerShell

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

Рассмотрим пример, где вызываем запущенный процесс PowerShell:

Get-Process powershell

Мы получаем объект и таблицу, отображающую некоторые его свойства. Чтобы узнать все свойства и методы, давайте передадим этот объект командлету Get-Member. Для этого используется конвейер:

Get-Process powershell | Get-Member

Команда Get-Member получает объект от команды Get-Process и выводит таблицу со всеми его свойствами и методами. Результат работы Get-Member также представляет собой объект (точнее, список объектов), который можно передать по конвейеру дальше.

Допустим, нужно вывести только те строки, в которых MemberType равно Property. Для этого используем команду Where-Object:

Get-Process powershell | Get-Member | Where-Object {$_.MemberType -eq 'Property'}

Команда Where-Object последовательно обходит каждый объект, полученный от команды Get-Member. Выражение в фигурных скобках — логическое:

• $_ ссылается на текущий объект (то есть на отдельную строку в таблице);
• .MemberType обращается к значению свойства MemberType в этом объекте;
• -eq выполняет сравнение между выражением слева и выражением справа от него;
• 'Property' представляет значение, которое ожидаем увидеть у свойства MemberType.

Более подробно о логических выражениях рассказано ниже.

Форматирование таблиц с помощью конвейеров

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

Форматируем таблицу, полученную с помощью командлета Get-Member. Следует использовать следующий синтаксис:

Get-Process powershell | Get-Member | Format-Table -AutoSize -Wrap -GroupBy MemberType -Property Name, Definition

Разберем параметры командлета Format-Table:

• -AutoSize выравнивает ширину столбцов в соответствии с размерами их содержимого. Это позволяет оптимально использовать ширину экрана.
• -Wrap переносит содержимое ячейки на новую строку, если оно не помещается в текущих размерах экрана. По умолчанию, если текст не помещается, он обрезается.
• -GroupBy позволяет разделить одну таблицу на несколько, сгруппированных по значению определенного свойства. В данном случае, для каждого значения MemberType будет создана отдельная таблица.
• -Property определяет, какие свойства объекта будут отображены в таблице в качестве столбцов. В данном примере, мы указали свойства Name и Definition.

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

Сортировка таблиц с помощью конвейеров

Командлет Sort-Object в PowerShell позволяет сортировать список объектов (таблицу) по значениям их свойств (столбцов). Давайте отсортируем результат, полученный с помощью командлета Get-Member, по столбцу Name в алфавитном порядке. Для этого  воспользуемся параметром -Property, который действует аналогично параметру у командлета Format-Table:

Get-Process powershell | Get-Member | Sort-Object -Property Name

Командлет Sort-Object в PowerShell имеет также другие полезные параметры:

• -Descending сортирует объекты в порядке убывания. Например:

Get-Process powershell | Get-Member | Sort-Object -Property Name -Descending

• -Unique удаляет дубликаты и возвращает только уникальные объекты. Например:

Get-Process powershell | Get-Member | Sort-Object -Property Name -Unique

• Параметр -Top получает число N и отображает первые N объектов в таблице. Например:

Get-Process | Sort-Object -Property CPU -Top 10

• Параметр -Bottom получает число N и отображает последние N объектов в таблице. Например:

Get-Process | Sort-Object -Property Memory -Descending -Bottom 5

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

Фоновое выполнение команд

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

Рассмотрим пример: предположим, нужно найти файл powershell.exe на всем диске C. Для этой цели  воспользуемся командлетом Get-ChildItem с параметром -Recurse. Это позволит ему искать файл не только в текущем каталоге, но и во всех его подкаталогах.

Следует учитывать, что PowerShell может столкнуться с папками, к которым у него нет доступа. Чтобы обойти возможные ошибки, добавим параметр -ErrorAction SilentlyContinue. Это означает, что в случае ошибки команда не будет генерировать уведомления, а просто продолжит выполнение.

Таким образом, данная ситуация выглядит следующим образом:

Get-ChildItem -Path C:\ -Name powershell.exe -Recurse -ErrorAction SilentlyContinue

Очевидно, что во время выполнения задачи, командная строка становится недоступной. Для принудительного прерывания выполнения задачи можно воспользоваться сочетанием клавиш Ctrl + C. Важно убедиться, что при этом ничего не выделено, чтобы избежать возможного восприятия компьютером как команды «Копировать».

Start-Job {Get-ChildItem -Path C:\ -Name powershell.exe -Recurse -ErrorAction SilentlyContinue}

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

• Get-Job предоставляет отчет о состоянии фоновых задач.
• Wait-Job блокирует консоль до завершения фоновой задачи.
• Stop-Job прекращает выполнение фоновой задачи.
• Receive-Job выводит результаты выполнения фоновой задачи и очищает их из памяти. Для сохранения результатов в памяти используйте параметр -Keep.

Опции Wait-Job, Stop-Job и Receive-Job требуют указания имени Name или идентификатора Id конкретной задачи или задач (в случае нескольких). Это можно сделать непосредственно или в связке с командлетом Get-Job.

Get-Job Job1

Работа с файлами

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

Для создания файла используйте командлет New-Item с указанием пути к файлу:

New-Item -Path "C:\путь\к\файлу\новыйфайл.txt" -ItemType File

Чтобы записать данные в файл, используйте Out-File или Set-Content:

"Содержимое файла" | Out-File -FilePath "C:\путь\к\файлу\новыйфайл.txt"
Set-Content -Path "C:\путь\к\файлу\новыйфайл.txt" -Value "Новое содержимое файла"

Для чтения содержимого файла в массив используйте Get-Content:

$содержимое = Get-Content -Path "C:\путь\к\файлу\новыйфайл.txt"

Для получения информации о файле (размер, дата создания и др.) используйте Get-Item:

$информацияОФайле = Get-Item -Path "C:\путь\к\файлу\новыйфайл.txt"

Для копирования файла в другое место используйте Copy-Item:

Copy-Item -Path "C:\путь\к\файлу\новыйфайл.txt" -Destination "C:\путь\к\копия\новыйфайл.txt"

Для удаления файла воспользуйтесь командлетом Remove-Item:

Remove-Item -Path "C:\путь\к\файлу\новыйфайл.txt" -Force

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

Работа в PowerShell ISE

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

PowerShell ISE представляет собой инструмент, состоящий из трех основных панелей:

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

Комментарии в коде

Вот пример PowerShell скрипта с комментариями:

# Это комментарий в одну строку, начинается с символа '#' и продолжается до конца строки.
# Пример переменной
$имя = "John"
$возраст = 30
# Вывод информации
Write-Host "Привет, $имя! Тебе $возраст лет."
# Это многострочный комментарий, который начинается с '<#' и заканчивается '#>'.
<#
Этот блок комментария может быть многострочным и располагаться
на нескольких строках, чтобы объяснить более сложные участки кода.
#>
# Функция для сложения двух чисел
function Сложить-Числа { param( [int]$число1, [int]$число2 ) $результат = $число1 + $число2 return $результат
}
# Вызов функции и вывод результата
$результатСложения = Сложить-Числа -число1 5 -число2 7
Write-Host "Результат сложения: $результатСложения"

Хорошая практика — комментировать код таким образом, чтобы другие разработчики (или вы в будущем) могли легко понять, как работает код и какие цели преследовались при его написании.

Советы по написанию хорошего кода:

• Применяйте нотацию PascalCase для названий командлетов, функций, параметров, свойств, методов, переменных и классов. Разработчики Powershell выпустили для этого гайд. Не рекомендуется: get-service, Get-service, GET-SERVICE. Рекомендуется: Get-Service.
• Используйте полные названия командлетов. Алиасы удобны для интерактивного режима, но в скриптах они могут затруднить понимание. Не рекомендуется: dir, gci, ls. Рекомендуется: Get-ChildItem.
• Применяйте стиль One True Brace для форматирования вложенных блоков кода. Если вы используете фигурные скобки, внутренний код отделяется табуляцией (четыре пробела), а фигурные скобки размещаются следующим образом:

if ($var1 -eq $var2) {
    # Код внутри условия
} else {
    # Код внутри else
    # Еще код внутри else
}

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

Get-ChildItem | Where-Object { $_.Length -gt 10mb }

Запуск скриптов

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

Также существует возможность запуска скрипта из оболочки. Например, предположим, у вас есть файл скрипта test_script.ps1 в каталоге C:\Scripts. Вы можете выполнить его двумя способами:

1. Используя команду PowerShell -File C:\Scripts\test_script.ps1 из любого места. Это позволяет запустить скрипт, указав полный путь к файлу.
2. Используя команду .\test_script.ps1, если вы находитесь в каталоге C:\Scripts. Это запустит скрипт, находясь в том же каталоге, что и файл скрипта.

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

Политика выполнения. Как разрешить выполнения скриптов

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

• Restricted (Установлена по умолчанию) — запрещено выполнение любых скриптов. Это означает, что нельзя будет запустить ни один скрипт.
• AllSigned — разрешено выполнение только тех скриптов, которые были подписаны доверенным разработчиком. Это обеспечивает повышенный уровень безопасности, так как только подписанные и проверенные скрипты могут быть выполнены.
• RemoteSigned — разрешено выполнение подписанных доверенным разработчиком скриптов, а также собственных скриптов. Это предоставляет баланс между безопасностью и удобством, позволяя запускать свои скрипты.
• Unrestricted — разрешено выполнение любых скриптов без каких-либо ограничений. Это предоставляет наивысший уровень гибкости, но может повысить риск безопасности.

Чтобы ваши файлы с расширением .ps1 запускались, вам следует изменить политику выполнения на RemoteSigned. Для этого выполните следующие шаги:

• Откройте PowerShell от имени администратора. Для этого щелкните правой кнопкой мыши по значку PowerShell на панели задач или в меню «Пуск» и выберите «Запуск от имени администратора».
• В открывшемся окне PowerShell введите следующую команду и нажмите Enter:

Set-ExecutionPolicy RemoteSigned

• Подтвердите изменение политики выполнения, нажав клавишу Y (Yes).

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

Переменные

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

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

Создадим переменную со строкой 2023 и преобразуем её в число. Для того чтобы узнать тип данных, воспользуемся методом .GetType():

$stringValue = "2023"
$intValue = [int]$stringValue
$intValue.GetType()

Для удаления переменной используется метод .Clear().

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

$number = 42
Write-Host "The number is $number"   # Вывод: The number is 42
Write-Host 'The number is $number'   # Вывод: The number is $number

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

Кроме пользовательских переменных, существуют и системные переменные. Например, $PSVersionTable содержит информацию о версии PowerShell.

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

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

• + — сложение;
• - — вычитание;
• * — умножение;
• / — деление;
• % — деление по модулю;
• ( и ) — скобки для группировки операций.

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

• -eq — равно (от «equal»);
• -ne — не равно (от «not equal»);
• -gt — больше (от «greater than»);
• -ge — больше либо равно (от «greater than or equal»);
• -lt — меньше (от «less than»);
• -le — меньше либо равно (от «less than or equal»).

Работа со строками в PowerShell

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

1. Объединение строк: Чтобы объединить строки, используйте оператор + или метод .Concat(). Пример:

$firstString = "Привет, "
$secondString = "мир!"
$combinedString = $firstString + $secondString

2. Форматирование строк: Используйте оператор -f или метод .Format() для вставки значений в строку. Пример:

$name = "Alice"
$age = 30
$formattedString = "Привет, меня зовут {0} и мне {1} лет." -f $name, $age

3. Интерполяция строк: С помощью символа $ и фигурных скобок {} можно вставлять значения переменных в строки. Пример:

$city = "Москва"
$interpolatedString = "Я живу в городе $($city)."

4. Разделение строк: Метод .Split() используется для разделения строки на подстроки. Пример:

$text = "яблоко,груша,банан"
$fruits = $text.Split(",")

5. Замена подстрок: С помощью метода .Replace() можно заменить подстроку в строке. Пример:

$text = "Привет, мир!"
$modifiedText = $text.Replace("мир", "вселенная")

6. Обрезка строк: Методы .Trim(), .TrimStart() и .TrimEnd() удаляют пробелы и другие символы в начале и конце строки.

Примеры использования методов для обрезки строк в PowerShell:

# Обрезка пробелов в начале и конце строки
$rawString = " Пример строки с пробелами "
$trimmedString = $rawString.Trim()
Write-Host "Исходная строка: '$rawString'"
Write-Host "Обрезанная строка: '$trimmedString'"
# Обрезка только в начале строки
$leftTrimmedString = $rawString.TrimStart()
Write-Host "Строка после обрезки в начале: '$leftTrimmedString'"
# Обрезка только в конце строки
$rightTrimmedString = $rawString.TrimEnd()
Write-Host "Строка после обрезки в конце: '$rightTrimmedString'"

При выполнении этого кода в консоли PowerShell вы увидите следующий вывод:

Исходная строка: ' Пример строки с пробелами '
Обрезанная строка: 'Пример строки с пробелами'
Строка после обрезки в начале: 'Пример строки с пробелами '
Строка после обрезки в конце: ' Пример строки с пробелами'

В данном примере видно, как методы .Trim(), .TrimStart() и .TrimEnd() удаляют пробелы в начале и конце строки, соответственно.

Условия

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

$Number = 123
if ($Number -gt 0) {
    Write-Host 'Число больше нуля'
} elseif ($Number -lt 0) {
    Write-Host 'Число меньше нуля'
} else {
    Write-Host 'Число равно нулю'
}
Результат выполнения кода: Число больше нуля

Кроме того, условия также можно задавать с помощью ключевого слова switch. Например:

$Day = 5
switch ($Day) {
    1 { Write-Host 'Понедельник' }
    2 { Write-Host 'Вторник' }
    3 { Write-Host 'Среда' }
    4 { Write-Host 'Четверг' }
    5 { Write-Host 'Пятница' }
    6 { Write-Host 'Суббота' }
    7 { Write-Host 'Воскресенье' }
}
Результат выполнения кода: Пятница

Циклы

В PowerShell существует несколько видов циклов:

• Цикл с предусловием while:

$counter = 0
while ($counter -lt 5) { Write-Host "Counter is $($counter)" $counter++
}

• Цикл с постусловием истинным do while:

$counter = 0
do { Write-Host "Counter is $($counter)" $counter++
} while ($counter -lt 5)

• Цикл с постусловием ложным do until:

$counter = 0
do { Write-Host "Counter is $($counter)" $counter++
} until ($counter -ge 5)

• Цикл с известным числом итераций for:

for ($i = 0; $i -lt 5; $i++) { Write-Host "Iteration is $i"
}

• Цикл с перебором элементов коллекции foreach:

$numbers = 1..5
foreach ($num in $numbers) { Write-Host "Number is $num"
}

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

Массивы, хеш-таблицы, функции и классы

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

• Массивы (Arrays): позволяют хранить набор элементов одного типа. Элементы могут быть доступны по индексам. Создаются массивы с использованием квадратных скобок [ ].

$fruits = "Apple", "Banana", "Orange"
$fruits[0]  # Доступ к элементу массива по индексу

• Хеш-таблицы (Hash Tables): представляют собой пары ключ-значение, где ключи уникальны. Они полезны для хранения и быстрого доступа к данным по ключу.

$person = @{
    Name = "John"
    Age = 30
    City = "New York"
}
$person["Name"]  # Доступ к значению по ключу

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

function Get-Sum {
    param($a, $b)
    return $a + $b
}
$result = Get-Sum 5 3

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

class Person {
    [string] $Name
    [int] $Age
    Person([string] $name, [int] $age) {
        $this.Name = $name
        $this.Age = $age
    }
    [string] GetInfo() {
        return "$($this.Name), $($this.Age) years old"
    }
}
$person = [Person]::new("Alice", 25)
$info = $person.GetInfo()

Похожее:

Управление VirtualBox из командной строки | Информационный портал К2® Else заявления с выражениями в таможенных свойствах Power shell и его возможности в уходящем году Руководство по команде setblock — Официальная Minecraft Wiki