Windows powershell запустить программу — Ваш верный помощник с OS Windows

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

Прямой запуск

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

Set-Location ″C:\Program Files″
.\Hello.exe

Обратите внимание, что даже находясь в нужном каталоге, требуется указывать относительный путь к исполняемому файлу. Исключение составляют файлы из директорий, перечисленных в переменной окружения (path). Например различные встроенные программы и утилиты (notepad, calc, ping и т.п.), находящиеся в директории Windows\System32, можно запускать без указания пути.

Оператор &

Если необходимо указать полный путь к исполняемому файлу, то можно воспользоваться оператором & (оператор вызова). Он позволяет выполнить строку текста, указанную в кавычках, как единую команду. Например:

& ′C:\Program Files\Hello.exe′

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

& ′C:\Program Files\Hello.exe′ ′Hello, world′

При желании можно указать нескольких аргументов через запятую:

& ′C:\Program Files\Hello.exe′ ′Hello,′, ′ world′

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

$exe = ′C:\Program Files\Hello.exe′
$arg1 = ′Hello′
$arg2 = ′world′
& $exe $arg1 $arg2

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

$exe = ′C:\Program Files\Hello.exe′
$allargs = @(′Hello,′,′world′)
& $exe $allargs

Invoke-Expression

Командлет Invoke-Expression работает примерно так-же, как и оператор & — берет текстовую строку и выполняет ее в виде команды. Например:

Invoke-Expression -Command ′C:\Windows\Hello.exe′

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

Invoke-Expression -Command ′C:\Program Files\Hello.exe′

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

Invoke-Expression -Command ″C:\′Program Files′\Hello.exe″

использование Invoke-Expression для запуска программы

Start-Process

Командлет Start-Process запускает указанный файл в виде процесса, используя метод Start .NET класса Process. Например:

Start-Process -FilePath ′C:\Program Files\Hello.exe′

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

Start-Process -FilePath ′C:\Program Files\Hello.exe′ -NoNewWindow -Wait

Также Start-Process позволяет передать в процесс дополнительные аргументы:

Start-Process -FilePath ′C:\Program Files\Hello.exe′ -ArgumentList ′Hello, world′ -NoNewWindow -Wait

По умолчанию командлет ничего не возвращает, но с помощью параметра -PassThru можно заставить его вернуть объект процесса. Этот объект очень удобно поместить в переменную:

$process = Start-Process -FilePath ′C:\Program Files\Hello.exe′ -Wait -PassThru

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

$process.HasExited

время:

$process.ExitTime

или код выполнения:

$process.ExitCode

.NET

В принципе .NET классом Process можно воспользоваться напрямую, без командлета Start-Process. К примеру, запустить процесс можно командой:

[System.Diagnostics.Process]::Start(′C:\Program Files\Hello.exe′)

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

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

$process = New-Object -TypeName System.Diagnostics.Process
$process.StartInfo.FileName = ″C:\Program Files\Hello.exe″
$process.StartInfo.Arguments = ″Hello,world″
$process.StartInfo.RedirectStandardOutput = $true
$process.StartInfo.UseShellExecute = $false
$process.Start()
$process.WaitForExit()
$process.StandatdOutput.ReadToEnd()

WMI

С помощью WMI можно сделать практически все, в том числе и запустить программу. Для этого вполне подойдет метод Create WMI-класса Win32_Process. Этот метод запускает процесс на локальном или удаленном компьютере через RPC. Например, для выполнения программы на локальном компьютере можно воспользоваться такой командой:

([wmiclass])″Win32_Process″).Create(′C:\Program Files\Hello.exe′)

А для выполнения на удаленном компьютере команда будет выглядеть так:

([wmiclass])″\\remotecomputer\root\cimv2:Win32_Process″).Create(′C:\Program Files\Hello.exe′)

Как вариант, можно воспользоваться командлетом Invoke-WmiMethod:

Invoke-WmiMethod -Class Win32_Process -Name Create -ArgumentList ″C:\Program Files\Hello.exe″

Либо командлетом Invoke-CimMethod:

Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine=″C:\Program Files\Hello.exe″}

использование командлета Invoke-CimMethod

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

0 — Sucsessful Completiom
2 — Access Denied
3 — Insufficient Privilege
8 — Uncnown Failure
9 — Path Not Found
21 — Invalid Parameter

Invoke-Command

Командлет Invoke-Command умеет выполнять команды на локальном или удаленном компьютере, используя WinRM. Например, для запуска нашей программы на локальном компьютере используем команду:

Invoke-Command -ScriptBlock {″C:\′Program Files′\Hello.exe″}

При необходимости в программу можно передать аргументы:

Invoke-Command -ScriptBlock {C:\′Program Files′\Hello.exe ″Hello,world″}

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

Invoke-Command -ScriptBlock {& ′C:\Program Files\Hello.exe′}

запуск программы с помощью Invoke-Command

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

Invoke-Command -ScriptBlock {″C:\′Program Files′\Hello.exe″} -ComputerName SRV1,SRV2,SRV3

Или так:

$scriptblock = {″C:\′Program Files′\Hello.exe″}
$Computers = @(′SRV1′,′SRV2′,′SRV3′)
Invoke-Command -ScriptBlock $scriptblock -ComputerName $Computers

По умолчанию командлет возвращает результат выполнения программы, а если запустить его в фоновом режиме (параметр -AsJob), то возвращает объект Job:

Invoke-Command -ScriptBlock {C:\′Program Files′\Hello.exe} -ComputerName localhost -AsJob -JobName Hello

Invoke-Item

Командлет Invoke-Item предназначен для применения к файлу действия по умолчанию. Так запустить исполняемый файл можно командой:

Invoke-Item -Path ″C:\Program Files\Hello.exe″

Однако наиболее удобно использовать Invoke-Item для открытия определенного типа файлов. Например так мы откроем текстовый файл:

Invoke-Item -Path ″C:\Files\test.txt″

А так все текстовые файлы в папке:

Invoke-Item -Path ″C:\Files\*.txt″

CMD

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

cmd /c ″C:\Program Files\Hello.exe″

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

Кстати, статья написана по мотивам PowerShell: Deep Dive and Best Practice. Рекомендую почитать, там еще много интересного.

Источник

Download Article

Open and run .exe files with PowerShell for Windows

Download Article

Using .\ (Dot Slash)

Using the Call (&) Operator

Using Start-Process Cmdlet

Using Invoke-Expression Cmdlet

If you need to launch an executable file from PowerShell, you have several options. If you’re in the same directory as the EXE file, type .\ before its filename (e.g., .\notepad.exe) and press Enter. You can run the EXE from a different directory using the PowerShell call operator (&), the Start-Process cmdlet, or the Invoke-Expression cmdlet. Each PowerShell run option is easy and can be used at the command line and in your PowerShell scripts.

Things You Should Know

Use .\filename.exe to run an EXE from the current directory in PowerShell.
To run an EXE from another directory, you can use & «C:\Windows\notepad.exe»
To use the Start-Process cmdlet to run the program, type Start-Process -FilePath «filename.exe»

Картинка с сайта: www.wikihow.com

For example, if you want to run notepad.exe from PowerShell, type cd "C:\Windows\" and press Enter.
Картинка с сайта: www.wikihow.com
To run an EXE file from the current directory in PowerShell, you’ll need to preface the filename with .\. For example, to run notepad.exe, type .\notepad.exe and press Enter.
- Typing the .\ before the filename tells PowerShell you want to run the EXE file from the current directory.
- If you want to run the EXE file from a different directory, use the call operator (&).
Advertisement
Картинка с сайта: www.wikihow.com
If you get an error that says, «The term (EXE file name) is not recognized as a name of a cmdlet, function, script file, or executable program,» you’re either entering the wrong file name or in the wrong directory. Get-ChildItem shows you all files and permissions in the current directory.
- To show only EXE files, use Get-ChildItem *.exe.^[1]
- You can also use Get-ChildItem to list files in other directories. For example, to show all executable files in C:\Program Files\Ableton\Live 11 Lite\Program, you’d use "C:\Program Files\Ableton\Live 11 Lite\Program\*.exe".

Картинка с сайта: www.wikihow.com

\Windows\notepad.exe". In PowerShell scripting, you can run any command that’s stored in a variable by prefacing its path with an ampersand (&).^[2] Similarly, you can use the call operator to run an EXE file from the PowerShell prompt.

Картинка с сайта: www.wikihow.com
. This command will run the executable file called filename.exe from the current directory. If you’re not already in the same directory as the EXE file, use the full path to the file, e.g., Start-Process -FilePath "C:\path to\filename.exe".
- If you need to run an EXE with parameters, enter the parameters after the executable’s name. For example, to open Notepad with the window maximized, you’d use Start-Process -FilePath "C:\Windows\notepad.exe" -Wait -WindowStyle Maximized.^[3]

Картинка с сайта: www.wikihow.com
\path to\filename.exe". Invoke-Expression is typically used in PowerShell scripts to evaluate expressions, run scripts, and run commands in variables. You can also use it to run any EXE file at the prompt.
- Microsoft cautions against using Invoke-Expression in PowerShell scripts that accept user input unless the script can verify that the command is safe to run.^[4]

Ask a Question

200 characters left

Include your email address to get a message when this question is answered.

Submit

Thanks for submitting a tip for review!

References

About This Article

Thanks to all authors for creating a page that has been read 100,229 times.

Is this article up to date?

Источник

.EXE files, or “executable files” are something we see often. Most downloaded files, especially setups, are executable files that are ready to be run and installed on your system. At other times, files may still be executable but have a different file extension, like “.msi”, “.bat”, or “.inf”.

Even though you can run such files by double-clicking them using File Explorer, the method may not be ideal for every situation. You can also run executable (.exe) files directly from Windows PowerShell. Some people may prefer the command-line method as you can run an executable without having to navigate here and there.

In this article, we show you 4 methods to run .exe files directly inside PowerShell. The commands discussed in the methods below can also be applied to PowerShell scripts. Moreover, some of them even allow you to send parameters/values to the executable file.

Table of Contents

How to Run EXE Files in PowerShell

In all of the methods discussed below, you must know the complete directory path to the file that you want to run in PowerShell. While one of the methods requires you to navigate to the .exe file directory and then execute the file, the other methods need complete file paths in the command.

In the example below, we will be running “Rufus.exe” located at “C:\Users\Subhan\Downloads.” Of course, this will change for you according to the file’s path and its name.

Run EXE File Directly from PowerShell

When we say “directly,” we mean that this method to run an executable file does not need any special PowerShell commands. All it needs is a path and the name of the file to run.

Launch an elevated PowerShell instance.
Use the “CD” command to change the directory to the executable file’s location:
```
CD "[PathToExecutableFile]"
```
Картинка с сайта: www.itechtics.com

Change directory using CD command
Alternatively, you can also jump one folder at a time using the following pattern:
```
# Change directory to the root of the current volume
CD\
# Change direcoty to root of the C drive
CD C:
CD Users
CD Subhan
CD Downloads
```
Now that you’re inside the directory of the file, use “.\” followed by the complete name of the executable file.

Note: Apart from the [FileName], you can also change the file type/extension depending on the actual file type.
```
.\[FileName].exe
```
Картинка с сайта: www.itechtics.com

Run the executable file from PowerShell directly
The executable file will now run.

You can also run the executable file whilst sending a parameter to the file, as in the example below:
```
.\Rufus.exe 10
```
In this example, the parameter “10” will be sent to Rufus.exe.

Note that it is crucial that you use “.\” while running an executable file directly. Otherwise, it will be considered a PowerShell command and you may see an error.

Additionally, if you find yourself lost while navigating/changing the directories, or are unsure of the file name, you can use the following cmdlet to get a list of the items inside the current directory:

Get-ChildItem

Get list of elements inside directory in PowerShell using Get-ChildItem

Run EXE File in PowerShell Using Invoke-Expression Command

Another way to run an executable file using PowerShell is by using the “Invoke-Expression” cmdlet. You can use this cmdlet directly in PowerShell, or insert the full command inside a PowerShell script (.ps1) to run an executable. This way, you can open a document file directly inside the app/program you are writing the script for.

To run an executable file in PowerShell or PowerShell script, use the following command syntax:

Invoke-Expression -Command “[PathToExecutableFile].exe”

Alternatively, the following syntax also works just as well:

“[PathToExecutableFile].exe” | Invoke-Expression

Run executable file from PowerShell using Invoke-Expression command

Run EXE File in PowerShell Using Start-Process Command

Like the Invoke-Expression cmdlet, you can also use the “Start-Process” command to run an executable file or a PowerShell script. Here’s how:

Launch an elevated PowerShell instance.
Use the following cmdlet to run an executable file:
```
Start-Process -FilePath ‘[PathToExecutableFile].exe’
```
Картинка с сайта: www.itechtics.com

Run executable file from PowerShell using Start-Process command
That’s it! The executable file should now run.

Alternatively, you can also change your strategy to a directory-first approach and use a different syntax of the “Start-Process” command to run an executable file. For that, you must first use the “CD” cmdlet to change your directory to the location where the executable file is located, then use the following command to run it:

Start-Process [ExecutableFileName].exe

Here is an example:

Run executable file from PowerShell using Start-Process command

Run EXE File in PowerShell Using “&” Call Operator

A Call Operator in Windows PowerShell allows you to run a command, function, or script. Anything followed by the “&” call operator is considered a command by PowerShell. You can use this logic of PowerShell to run an executable file simply by entering the file’s path prefixed with the call operator.

This is the syntax to be used to run an executable file in PowerShell:

& "[PathToExecutableFile].exe"

Run executable file from PowerShell using call operator

Run executable file from PowerShell using the “&” call operator

It is that simple.

Closing Thoughts

The easiest way to run an executable file, may it be a .exe, .ps1, or .msi file, is perhaps using the “&” call operator followed by the complete file path and extension. However, there are other ways to get the job done as well:

Run the executable in PowerShell directly by using “.\” followed by the file name.
Run the executable in PowerShell using the Invoke-Expression command.
Run the executable in PowerShell using the Start-Process command.

All of the 4 aforementioned methods will execute the file directly from PowerShell. This way, you do not have to browse through File Explorer to run a file each time you need to.

Источник

Как избежать распространенных ошибок при запуске исполняемых файлов в оболочке PowerShell

Оболочка Windows PowerShell построена с использованием интерактивного интерфейса командной строки (CLI). Одна из основных задач интерфейса CLI – предоставить пользователям возможность запускать программы. Однако я не раз сталкивался с такими вопросами как: «Необходимо запустить такую-то утилиту командной строки в оболочке PowerShell. Я безуспешно пытался различными способами заключить параметры в кавычки. Как заставить программу корректно работать в оболочке PowerShell?»

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

Однако в оболочке PowerShell задача немного усложняется, поскольку синтаксический анализатор командной строки здесь сложнее, чем в оболочке Cmd.exe. Команда Echo в оболочке PowerShell на самом деле является псевдонимом команды Write-Host, поэтому вы не можете задействовать ее в оболочке PowerShell для просмотра полной командной строки, как в оболочке Cmd.exe. В оболочке PowerShell отсутствует встроенный механизм просмотра полной командной строки для исполняемого файла.

Чтобы обойти данное ограничение, я написал короткую программу для командной строки, ShowArgs.exe. Цель этой программы — вывести на экран переданные ей параметры командной строки без анализа или интерпретации. Заменив ShowArgs.exe программу, которую вы пытаетесь запустить (но сохраняя параметры вашей программы), вы сможете увидеть именно те параметры командной строки, которые будет использовать оболочка PowerShell.

Используя приложение ShowArgs.exe (доступно для загрузки на нашем сайте), я покажу, как справляться с наиболее распространенными проблемами типа «как правильно заключить выражение в кавычки» при запуске исполняемых файлов в оболочке PowerShell. Для примеров, приведенных в этой статье, я создал каталог с именем C:\Sample Tools и скопировал файл ShowArgs.exe в него.

Запуск исполняемых файлов в оболочке PowerShell

Для запуска исполняемого файла в оболочке PowerShell достаточно просто указать его имя. Точно так же запускаются исполняемые файлы в оболочке Cmd.exe. На экране 1 приведены два примера запуска приложения ShowArgs.exe напрямую в оболочке PowerShell. На экране 1 для запуска приложения ShowArgs.exe требуется префикс «.\», так как оболочка PowerShell по умолчанию не запускает исполняемые файлы из текущего каталога.

Экран 1. Запуск исполняемого файла в PowerShell

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

Экран 2. Использование оператора вызова в некоторых случаях не является обязательным

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

Экран 3. Общие ошибки при использовании оператора вызова

Как показано на экране 4, вы можете сохранить результаты выполнения исполняемого файла в переменную. Первая команда на экране запускает файл Find.exe с параметром «/?» и сохраняет результат в переменную $findHelp. Вторая команда показывает, что переменная содержит массив, а последняя выводит на экран содержимое массива. Если программа возвращает только одну строку, переменная будет содержать отдельную строку, а не массив.

Экран 4. Сохранение результатов выполнения исполняемого файла в переменную

Командная строка исполняемого файла: заключение параметров в кавычки

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

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

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

. \ShowArgs «Gil Bates»

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

. \ShowArgs «`"Gil Bates`»«
. \ShowArgs '»Gil Bates«'
. \ShowArgs»«"Gil Bates»«"

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

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

$name =»Gil Bates«
. \ShowArgs $name

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

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

. \ShowArgs /name»Gil Bates«
. \ShowArgs»/nameGil Bates«

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

. \ShowArgs /name:»Gil Bates«
. \ShowArgs»/name:Gil Bates«

Следующие две команды также эквивалентны:

. \ShowArgs /name=»Gil Bates«
. \ShowArgs»/name=Gil Bates«

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

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

. \ShowArgs /name $name
. \ShowArgs /name$name
. \ShowArgs /name=$name
. \ShowArgs /name:$name

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

. \ShowArgs -name:$name

Вместо нее необходимо использовать одну из команд:

. \ShowArgs `-name:$name
. \ShowArgs»-name:$name«

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

. \ShowArgs -name:»Gil Bates«
. \ShowArgs»-name:Gil Bates«

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

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

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

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

Если требуется сформировать командную строку, зависящую от логических операторов, вам может потребоваться дополнительная гибкость. Например, рассмотрим сценарий Test.ps1 в листинге 1.

Если вы запустите сценарий Test1.ps1 с параметром -Test, оболочка PowerShell выполнит команду:

. \ShowArgs»/a:A B C /Test«

Однако на самом деле необходимо, чтобы оболочка PowerShell выполнила команду:

. \ShowArgs»/a:A B C«/Test

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

Одно решение заключается в использовании команды Start-Process (см. листинг 2). У команды Start-Process есть параметр -ArgumentList, который представляет собой массив параметров командной строки. Оболочка PowerShell автоматически не расставляет кавычки для этих параметров, так что вам придется вставить кавычки там, где нужно.

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

Если вы хотите перехватить выходные данные исполняемого файла, необходимо задействовать параметр -RedirectStandardOutput. Сценарий Test3.ps1 в листинге 3 иллюстрирует этот подход. Данный сценарий создает временный файл, запускает исполняемый файл (перенаправляя выходные данные во временный файл) и возвращает выходные данные с помощью команды Get-Content.
Команда Start-Process не обновляет переменную $LASTEXITCODE.

Чтобы добавить еще немного гибкости, вы можете задействовать функцию Start-Executable, описанную в листинге 4. Функция Start-Executable не использует временный файл и обновляет переменную $LASTEXITCODE. Параметр -ArgumentList данной функции работает аналогично параметру -ArgumentList команды Start-Process.

Составляйте команды корректно

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

Листинг 1. Test1.ps1

param(
[Switch] $Test
)
$arg =»A B C«
$params =»/a:$arg«
if ( $Test ) {
$params +=» /Test«
}
# Won't work as expected if using –Test
ShowArgs $params

Листинг 2. Test2.ps1

param(
[Switch] $Test
)
$arg =»A B C«
# You have to insert your own quotes
$params = @(»/a:`«$arg`»«)
if ( $Test ) {
$params +=»/Test«
}
Start-Process ShowArgs.exe -ArgumentList $params `
-NoNewWindow -Wait

Листинг 3. Test3.ps1

param(
[Switch] $Test
)
$arg =»A B C«
$params = @(»/a:`«$arg`»«)
if ( $Test ) {
$params +=»/Test«
}
$tempName = [IO.Path]::GetTempFileName()
$output =»«
$spArgs = @{
»FilePath«= "ShowArgs.exe»
«ArgumentList» = $params
«NoNewWindow» = $true
«Wait» = $true
«RedirectStandardOutput» = $tempName
}
Start-Process @spArgs
if ( test-path $tempName ) {
$output = get-content $tempName
remove-item $tempName
}

Листинг 4. Функция Start-Executable

function Start-Executable {
param(
[String] $FilePath,
[String[]] $ArgumentList
)
$OFS = «"
$process = New-Object System.Diagnostics.Process
$process.StartInfo.FileName = $FilePath
$process.StartInfo.Arguments = $ArgumentList
$process.StartInfo.UseShellExecute = $false
$process.StartInfo.RedirectStandardOutput = $true
if ( $process.Start() ) {
$output = $process.StandardOutput.ReadToEnd() `
-replace»\r\n$«,"»
if ( $output ) {
if ( $output.Contains(«`r`n») ) {
$output -split «`r`n»
}
elseif ( $output.Contains(«`n") ) {
$output -split»`n«
}
else {
$output
}
}
$process.WaitForExit()
&»$Env:SystemRoot\system32\cmd.exe" `
/c exit $process.ExitCode
}
}

Источник

In PowerShell, you can execute an executable file (`.exe`) by simply calling its path, as shown in the following example:

Start-Process "C:\Path\To\Your\File.exe"

Understanding EXE Files

What is an EXE File?

An EXE file (short for «executable») is a compiled program in Windows that the operating system can directly run. These files usually contain instructions for a computer to perform specific tasks, such as installing software, launching applications, or executing system commands.

Common use cases for EXE files include:

Installing software packages
Running system utilities
Managing configurations and settings

When to Use PowerShell to Execute EXE Files

Using PowerShell to run EXE files can significantly enhance your productivity. Here are some scenarios where running an EXE with PowerShell is particularly advantageous:

Automation Tasks: When you need to execute the same program multiple times or on a schedule.
Batch Processing: If you need to run multiple EXE files sequentially or concurrently in a single script.
Remote Execution: PowerShell allows for running commands on remote systems, which can be essential for network administrators.

PowerShell Script Remote Execution Made Simple

How to Run EXE with PowerShell

The Basic Command

The most straightforward way to execute an EXE file in PowerShell is to use the call operator `&`. This operator allows you to run the executable directly. The basic syntax is as follows:

& "C:\Path\To\YourExecutable.exe"

This command will execute the specified EXE file. Be sure to enclose the path in double quotes if it includes spaces.

Using Start-Process

Another powerful way to run EXE files is by using the `Start-Process` cmdlet. This cmdlet provides more features, such as starting a process in a new window or redirecting output. Here’s how to use it:

Start-Process -FilePath "C:\Path\To\YourExecutable.exe"

This command starts the specified executable in a new process.

PowerShell Script Template: Your Quick Start Guide

How to Run an Executable in PowerShell with Arguments

Passing Arguments to EXE Files

Many executable programs accept command-line arguments that perform specific actions or modify behavior. You can pass these arguments to an EXE file using PowerShell. Here’s an example:

Start-Process -FilePath "C:\Path\To\YourExecutable.exe" -ArgumentList "arg1", "arg2"

In this example, replace `»arg1″` and `»arg2″` with the actual arguments required by your EXE file.

Using StdOut and StdErr

Standard output (StdOut) and standard error (StdErr) are crucial for managing output from an EXE file. You can capture or redirect this output easily using PowerShell. Here’s an example of redirecting output to a file:

Start-Process -FilePath "C:\Path\To\YourExecutable.exe" -RedirectStandardOutput "output.txt" -NoNewWindow

This command runs the EXE and writes the output to `output.txt`, allowing you to easily review the results later.

Discovering PowerShell Script Location: A Quick Guide

Running EXE Files in PowerShell Scripts

Creating a PowerShell Script

Creating a PowerShell script that executes an EXE file is straightforward. Begin by opening a text editor and writing your script. Here’s a simple example:

# MyScript.ps1
& "C:\Path\To\YourExecutable.exe" -ArgumentList "arg1", "arg2"

Save this file with a `.ps1` extension. Your script is now ready to be executed.

Executing the Script

To run your PowerShell script, use the following command in the PowerShell console:

powershell -ExecutionPolicy Bypass -File "C:\Path\To\MyScript.ps1"

The `ExecutionPolicy Bypass` parameter allows the script to run without restrictions imposed by your system’s execution policy.

PowerShell Script Generator: Craft Your Scripts Effortlessly

Run EXE from PowerShell Script: Best Practices

Error Handling in PowerShell Scripts

Implementing robust error handling is essential for any PowerShell script. This practice ensures that your script can handle unexpected situations without crashing. Here’s an example using try/catch/finally blocks:

try {
    Start-Process -FilePath "C:\Path\To\YourExecutable.exe"
} catch {
    Write-Host "An error occurred: $_"
}

In this snippet, if an error occurs while attempting to run the EXE, the catch block will execute, providing you with valuable feedback about the issue.

Logging and Output Management

Maintaining logs of your program’s executions can help troubleshoot issues down the road. You can easily log output and errors to separate files. For example:

Start-Process -FilePath "C:\Path\To\YourExecutable.exe" -NoNewWindow -RedirectStandardOutput "log.txt" -RedirectStandardError "error.txt"

This command captures both standard output and errors, writing them to `log.txt` and `error.txt` respectively.

PowerShell Script to Create Users in Active Directory

Troubleshooting Common Issues

Common Errors in Executing EXE Files

While executing EXE files using PowerShell, you may encounter several common errors such as:

Permissions Issues: Make sure you have the appropriate permissions to execute the EXE file.
Path Not Found: Verify that the path to the EXE is correct. If it contains spaces, ensure it is wrapped in quotes.

Testing and Debugging PowerShell Scripts

Testing your PowerShell scripts is crucial for ensuring that your EXE files execute correctly. When debugging, consider using the `-WhatIf` parameter or write verbose outputs to help you track the execution flow. Collecting feedback along the way will guide you to identify and fix potential problems quicker.

PowerShell Script to Keep Screen Active: A Simple Guide

Conclusion

Using a PowerShell script to execute EXE files can greatly enhance your scripting capabilities, automate tedious tasks, and streamline system management. By understanding how to run executable files efficiently, you can leverage PowerShell to boost your productivity and deepen your command over IT automation.

PowerShell Script to Install EXE Silently and Remotely

Call to Action

We invite you to share your experiences with executing EXEs using PowerShell and how it has improved your workflows. If you found this article helpful, consider subscribing for more insights and tips on mastering PowerShell!

Mastering PowerShell Select-Object in a Nutshell

Additional Resources

For further exploration, consider checking out the official PowerShell documentation and a selection of books or online courses designed for advanced PowerShell users.

Источник