Como executar um arquivo EXE no PowerShell com parâmetros com espaços e aspas

333

Como você executa o seguinte comando no PowerShell?

C: \ Arquivos de programas \ IIS \ Microsoft Web Deploy \ msdeploy.exe -verb: sync -source: dbfullsql = "Fonte de dados = mysource; Segurança integrada = false; ID do usuário = sa; Pwd = sapass!; Database = mydb;" -dest: dbfullsql = "Fonte de dados =. \ mydestsource; Segurança integrada = false; ID do usuário = sa; Pwd = sapass!; Banco de dados = mydb;", nome do computador = 10.10.10.10, nome do usuário = administrador, senha = adminpass "

Vans
fonte
Veja também stackoverflow.com/questions/6224638/…
Ruben Bartelink 2/12/12
Se você quer dizer literalmente "no PowerShell" (que eu interpreto como "dentro de um prompt existente do PowerShell), o exemplo a seguir pode ser facilmente adaptado para atender às suas necessidades. Observe que não há necessidade de separar o comando de seus parâmetros: # Show any available updates to globally installed npm packages using the npm-check-updates tool [string] $cmd = 'ncu -g' Write-Verbose -Message $cmd Invoke-Command -ScriptBlock ([ScriptBlock]::Create($cmd))
user3785010
Não tenho idéia de como usar a "minmarcação" para editar o comentário acima e fazer com que cada linha de código apareça em uma linha separada, e o prazo de 5 minutos para editar o comentário original expirou. Se alguém souber agora usar "mini-Markdown" para corrigir o problema, repassarei de forma mais legível. A primeira linha deve ser apenas o seguinte: # Mostrar todas as atualizações disponíveis para os pacotes NPM instalados globalmente usando a ferramenta NPM-check-atualizações
user3785010

Respostas:

347

Quando o PowerShell vê um comando que começa com uma string, ele apenas avalia a string, ou seja, normalmente faz eco na tela, por exemplo:

PS> "Hello World"
Hello World

Se você deseja que o PowerShell interprete a sequência como um nome de comando, use o operador de chamada (&) da seguinte forma:

PS> & 'C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe'

Depois disso, você provavelmente só precisará citar pares de parâmetros / argumentos que contêm espaços e / ou caracteres de cotação. Quando você invoca um arquivo EXE como este com argumentos complexos de linha de comando, geralmente é muito útil ter uma ferramenta que mostre como o PowerShell envia os argumentos para o arquivo EXE. As extensões da comunidade do PowerShell possuem essa ferramenta. É chamado eco. Você acabou de substituir o arquivo EXE por echoargs - deixando todos os argumentos no lugar, e ele mostrará como o arquivo EXE receberá os argumentos, por exemplo:

PS> echoargs -verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass

Arg 0 is <-verb:sync>
Arg 1 is <-source:dbfullsql=Data>
Arg 2 is <Source=mysource;Integrated>
Arg 3 is <Security=false;User>
Arg 4 is <ID=sa;Pwd=sapass!;Database=mydb;>
Arg 5 is <-dest:dbfullsql=Data>
Arg 6 is <Source=.\mydestsource;Integrated>
Arg 7 is <Security=false;User>
Arg 8 is <ID=sa;Pwd=sapass!;Database=mydb; computername=10.10.10.10 username=administrator password=adminpass>

Usando ecos, você pode experimentar até acertar, por exemplo:

PS> echoargs -verb:sync "-source:dbfullsql=Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;"
Arg 0 is <-verb:sync>
Arg 1 is <-source:dbfullsql=Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;>

Acontece que eu estava tentando muito antes manter as aspas duplas em torno da cadeia de conexão. Aparentemente, isso não é necessário porque mesmo o cmd.exe os removerá.

BTW, tiramos o chapéu para a equipe do PowerShell. Eles foram bastante úteis para me mostrar o encantamento específico de aspas simples e duplas para obter o resultado desejado - se você precisasse manter as aspas duplas internas no lugar. :-) Eles também percebem que essa é uma área de dor, mas são motivados pelo número de pessoas afetadas por um problema específico. Se essa é uma área problemática para você, vote neste envio de bug do PowerShell .

Para obter mais informações sobre como o PowerShell analisa, confira a série de blogs do PowerShell efetivo - especificamente o item 10 - "Compreendendo os modos de análise do PowerShell"

ATUALIZAÇÃO 4/4/2012: Essa situação fica muito mais fácil de lidar no PowerShell V3. Veja esta postagem do blog para obter detalhes .

Keith Hill
fonte
1
se usar como segundo exemplo, recebo este erro: Erro: Argumento não reconhecido '"-source: dbfullsql =" "" Data ". Todos os argumentos devem começar com "-".
Vans
2
Me desculpe, eu não entendo. Vejo que, atualmente, 6 pessoas votaram positivamente na resposta, então estou perdendo algo óbvio, mas qual é a resposta real? Existe uma regra especial para saber sobre parâmetros com espaços com o PowerShell, ou você está apenas sugerindo fazê-lo caso a caso, usando o EchoArgs para ajudar?
Tyler Collier
Citar os argumentos geralmente é suficiente, mas nem sempre. Nos casos em que não funciona, o uso echoargsfornece uma indicação de como o PowerShell está interpretando os argumentos antes de transmiti-los ao EXE.
121111 Keith Hill
1
Você sabe como eu faria isso em um arquivo .bat? Estou tentando & 'C:\Program Files\Sublime Text 3\sublime_text.exe'diretamente no console e ele está funcionando, mas em um arquivo em lotes recebo um erro dizendo '& foi inesperado no momento'.
Joe Zim
Deixa pra lá. Encontrado:START C:\"Program Files"\"Sublime Text 3"\sublime_text.exe
Joe Zim
61

Basta adicionar o operador & antes do nome .exe. Aqui está um comando para instalar o SQL Server Express no modo silencioso:

$fileExe = "T:\SQLEXPRADV_x64_ENU.exe"
$CONFIGURATIONFILE = "T:\ConfSetupSql2008Express.ini"

& $fileExe  /CONFIGURATIONFILE=$CONFIGURATIONFILE
nonolde1er
fonte
53

Eu tinha espaços no comando e nos parâmetros, e é isso que funcionou para mim:

$Command = "E:\X64\Xendesktop Setup\XenDesktopServerSetup.exe"
$Parms = "/COMPONENTS CONTROLLER,DESKTOPSTUDIO,DESKTOPDIRECTOR,LICENSESERVER,STOREFRONT /PASSIVE /NOREBOOT /CONFIGURE_FIREWALL /NOSQL"

$Prms = $Parms.Split(" ")
& "$Command" $Prms

É basicamente o mesmo que a resposta do Akira, mas isso funciona se você construir dinamicamente seus parâmetros de comando e colocá-los em uma variável.

Microb
fonte
2
imho este é o melhor! nenhuma base64, nenhuma sintaxe% estranha que alterna a substituição, regras normais de substituição do PowerShell, nenhuma confusão, muito legível.
AnneTheAgile
1
Isso não funciona. Se o seu parâmetro tiver um nome de caminho, o nome do caminho será dividido em vários parâmetros.
BrainSlugs83
1
Boa resposta. No entanto, ele funcionará com aspas nos parâmetros?
Akira Yamamoto
Por favor, tente isso, depois de tudo isso realmente funcionou. E também use a extensão PowershellEchoArgs
Jeremy Thompson
34

Isso funcionou para mim:

& 'D:\Server\PSTools\PsExec.exe' @('\\1.1.1.1', '-accepteula', '-d', '-i', $id, '-h', '-u', 'domain\user', '-p', 'password', '-w', 'C:\path\to\the\app', 'java', '-jar', 'app.jar')

Basta colocar caminhos ou cadeias de conexão em um item da matriz e dividir as outras coisas em um item da matriz cada.

Existem muitas outras opções aqui: https://social.technet.microsoft.com/wiki/contents/articles/7703.powershell-running-executables.aspx

A Microsoft deve tornar esse caminho mais simples e compatível com a sintaxe do prompt de comando.

Akira Yamamoto
fonte
2
Matriz é definitivamente a melhor opção - isso funcionou muito bem para mim. Exceto que eu passei uma variável de matriz porque meus argumentos eram dinâmicos. Obrigado.
Jon Barker
Melhor solução IMHO
Vasin Yuriy
25

Existem alguns métodos que você pode usar para fazer isso.

Existem outros métodos, como usar o cmdlet Operador de chamadas ( & ), Invoke-Expression etc. Mas eles são considerados inseguros. A Microsoft recomenda o uso do Start-Process .

Método 1

Um exemplo simples

Start-Process -NoNewWindow -FilePath "C:\wamp64\bin\mysql\mysql5.7.19\bin\mysql" -ArgumentList "-u root","-proot","-h localhost"

No seu caso

Start-Process -NoNewWindow -FilePath "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe" -ArgumentList "-verb:sync","-source:dbfullsql=`"Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`"","-dest:dbfullsql=`"Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`"","computername=10.10.10.10","username=administrator","password=adminpass"

Nesse método, você separa cada parâmetro no ArgumentList usando vírgulas.

Método 2

Exemplo Simples

Start-Process -NoNewWindow -FilePath "C:\wamp64\bin\mysql\mysql5.7.19\bin\mysql" -ArgumentList "-u root -proot -h localhost"

No seu caso

Start-Process -NoNewWindow -FilePath "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe" -ArgumentList "-verb:sync -source:dbfullsql=`"Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`" -dest:dbfullsql=`"Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`",computername=10.10.10.10,username=administrator,password=adminpass"

Este método é mais fácil, pois permite digitar seus parâmetros de uma só vez.

Observe que no powershell para representar as aspas (") em uma string, você deve inserir o acento grave (`) (esta é a tecla acima da tecla Tab no teclado dos EUA).

O parâmetro -NoNewWindow é usado para exibir o novo processo na janela atual do console. Por padrão, o Windows PowerShell abre uma nova janela.

Referências: PowerShell / Scripting / Start-Process

Missaka Iddamalgoda
fonte
Simples sempre vence! Obrigado.
Mike Casas
Obrigado pela nota final sobre como escapar das aspas!
Paolo
13

Caso alguém esteja se perguntando como executar um arquivo executável:

.....>. \ file.exe

ou

......> completo \ caminho \ para \ arquivo.exe

olhar escuro
fonte
2
Essa deve ser a resposta para essa pergunta. É o que procuramos quando pesquisamos com as palavras-chave "Iniciar EXE do PowerShell". Obrigado !
Jean-Daniel Gasser
2
Que tal correr com argumentos?
SereneWizard
1
@SereneWizard Bem, adicione-os após .exe com um espaço entre eles. Exemplo:. \ File.exe param1 param2 param3
darkgaze 14/11
9

Consegui fazer meu comando semelhante funcionar usando a seguinte abordagem:

msdeploy.exe -verb=sync "-source=dbFullSql=Server=THESERVER;Database=myDB;UID=sa;Pwd=saPwd" -dest=dbFullSql=c:\temp\test.sql

Para o seu comando (não que isso ajude muito agora), as coisas seriam mais ou menos assim:

msdeploy.exe -verb=sync "-source=dbfullsql=Server=mysource;Trusted_Connection=false;UID=sa;Pwd=sapass!;Database=mydb;" "-dest=dbfullsql=Server=mydestsource;Trusted_Connection=false;UID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass

Os pontos principais são:

  • Use aspas ao redor do argumento de origem e remova as aspas incorporadas ao redor da cadeia de conexão
  • Use os nomes de chave alternativos na construção da cadeia de conexão SQL que não possui espaços. Por exemplo, use "UID" em vez de "ID do usuário", "Servidor" em vez de "Fonte de dados", "Conexão confiável" em vez de "Segurança integrada" e assim por diante. Só consegui fazê-lo funcionar depois de remover todos os espaços da cadeia de conexão.

Eu não tentei adicionar a parte "nomedocomputador" no final da linha de comando, mas espero que essas informações ajudem outras pessoas que estão lendo isso a se aproximarem do resultado desejado.

G-Mac
fonte
2
Tentei todas as outras respostas, mas essa foi a única resposta que funcionou para mim! Obrigado por fornecer este caminho alternativo.
Senciente
6

Nova string de escape no PowerShell V3, citada em Novos Recursos do Idioma V3 :

Reutilização mais fácil de linhas de comando do cmd.exe

A web está cheia de linhas de comando escritas para o Cmd.exe. Essas linhas de comando funcionam com bastante frequência no PowerShell, mas quando incluem determinados caracteres, por exemplo, um ponto-e-vírgula (;), um sinal de dólar ($) ou chaves, você precisa fazer algumas alterações, provavelmente adicionando algumas aspas. Esta parecia ser a fonte de muitas dores de cabeça menores.

Para ajudar a resolver esse cenário, adicionamos uma nova maneira de "escapar" da análise de linhas de comando. Se você usar um parâmetro mágico -%, interromperemos a análise normal da sua linha de comando e mudaremos para algo muito mais simples. Não combinamos aspas. Não paramos no ponto e vírgula. Não expandimos variáveis ​​do PowerShell. Expandimos as variáveis ​​de ambiente se você usar a sintaxe Cmd.exe (por exemplo,% TEMP%). Fora isso, os argumentos até o final da linha (ou canal, se você estiver canalizando) são passados ​​como estão. Aqui está um exemplo:

PS> echoargs.exe --% %USERNAME%,this=$something{weird}
Arg 0 is <jason,this=$something{weird}>
Loïc MICHEL
fonte
6

Você pode usar:

Start-Process -FilePath "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe" -ArgumentList "-verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass"

O principal a ser observado aqui é que o FilePath deve estar na posição 0, de acordo com o Guia da Ajuda. Para chamar o guia de Ajuda de um commandlet, basta digitar Get-Help <Commandlet-name> -Detailed. Nesse caso, é Get-Help Start-Process -Detailed.

CyrilDex
fonte
5

Tentei todas as sugestões, mas ainda não consegui executar msiexec.execom parâmetros que continham espaços. Então, minha solução acabou usando System.Diagnostics.ProcessStartInfo:

# can have spaces here, no problems
$settings = @{
  CONNECTION_STRING = "... ..."
  ENTITY_CONTEXT = "... ..."
  URL = "..."
}

$settingsJoined = ($settings.Keys | % { "$_=""$($settings[$_])""" }) -join " "
$pinfo = New-Object System.Diagnostics.ProcessStartInfo
$pinfo.WorkingDirectory = $ScriptDirectory
$pinfo.FileName = "msiexec.exe"
$pinfo.RedirectStandardError = $true
$pinfo.RedirectStandardOutput = $true
$pinfo.UseShellExecute = $false
$pinfo.Arguments = "/l* install.log /i installer.msi $settingsJoined"
$p = New-Object System.Diagnostics.Process
$p.StartInfo = $pinfo
$p.Start() | Out-Null
$p.WaitForExit()
$stdout = $p.StandardOutput.ReadToEnd()
Daniel Lidström
fonte
3

Isso funcionou para mim:

PowerShell.exe -Command "& ""C:\Some Script\Path With Spaces.ps1"""

A chave parece ser que todo o comando está entre aspas externas, o "e" "comercial" é usado para especificar que outro arquivo de comando filho está sendo executado e, finalmente, as aspas com escape (dobrado-duplo-) ao redor do caminho / nome do arquivo com espaços em que você queria executar em primeiro lugar.

Isso também é a conclusão da única solução alternativa para o problema de conexão do MS que -File não repassa códigos de retorno diferentes de zero e -Command é a única alternativa. Mas até agora, pensava-se que uma limitação do comando era que não suportava espaços. Também atualizei esse item de feedback.

http://connect.microsoft.com/PowerShell/feedback/details/750653/powershell-exe-doesn-t-return-correct-exit-codes-when-using-the-file-option

Tony Wall
fonte
1
Isso não tem relação com a questão das operações, ele perguntou especificamente como executar o longo comando em seu posto no PowerShell. Não é como executar um script do PowerShell com espaços no caminho do arquivo.
leinad13
Leia o título da pergunta, os espaços não são longos. Esta é uma resposta válida para esses problemas, portanto vale a pena compartilhar. Você teve o mesmo problema e realmente tentou? Se você quiser melhorá-lo, envie uma edição que inclua o comando real na pergunta e eu o aceitarei.
28516 Tony Wall
3

Uma resposta alternativa é usar uma opção de comando codificado em Base64 :

powershell -EncodedCommand "QwA6AFwAUAByAG8AZwByAGEAbQAgAEYAaQBsAGUAcwBcAEkASQBTAFwATQBpAGMAcgBvAHMAbwBmAHQAIABXAGUAYgAgAEQAZQBwAGwAbwB5AFwAbQBzAGQAZQBwAGwAbwB5AC4AZQB4AGUAIAAtAHYAZQByAGIAOgBzAHkAbgBjACAALQBzAG8AdQByAGMAZQA6AGQAYgBmAHUAbABsAHMAcQBsAD0AIgBEAGEAdABhACAAUwBvAHUAcgBjAGUAPQBtAHkAcwBvAHUAcgBjAGUAOwBJAG4AdABlAGcAcgBhAHQAZQBkACAAUwBlAGMAdQByAGkAdAB5AD0AZgBhAGwAcwBlADsAVQBzAGUAcgAgAEkARAA9AHMAYQA7AFAAdwBkAD0AcwBhAHAAYQBzAHMAIQA7AEQAYQB0AGEAYgBhAHMAZQA9AG0AeQBkAGIAOwAiACAALQBkAGUAcwB0ADoAZABiAGYAdQBsAGwAcwBxAGwAPQAiAEQAYQB0AGEAIABTAG8AdQByAGMAZQA9AC4AXABtAHkAZABlAHMAdABzAG8AdQByAGMAZQA7AEkAbgB0AGUAZwByAGEAdABlAGQAIABTAGUAYwB1AHIAaQB0AHkAPQBmAGEAbABzAGUAOwBVAHMAZQByACAASQBEAD0AcwBhADsAUAB3AGQAPQBzAGEAcABhAHMAcwAhADsARABhAHQAYQBiAGEAcwBlAD0AbQB5AGQAYgA7ACIALABjAG8AbQBwAHUAdABlAHIAbgBhAG0AZQA9ADEAMAAuADEAMAAuADEAMAAuADEAMAAsAHUAcwBlAHIAbgBhAG0AZQA9AGEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIALABwAGEAcwBzAHcAbwByAGQAPQBhAGQAbQBpAG4AcABhAHMAcwAiAA=="

Quando decodificado, você verá que é o snippet original do OP com todos os argumentos e aspas duplas preservados.

powershell.exe -EncodedCommand

Accepts a base-64-encoded string version of a command. Use this parameter
to submit commands to Windows PowerShell that require complex quotation
marks or curly braces.

O comando original:

 C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe -verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass"

Isso se transforma quando codificado como Base64:

QwA6AFwAUAByAG8AZwByAGEAbQAgAEYAaQBsAGUAcwBcAEkASQBTAFwATQBpAGMAcgBvAHMAbwBmAHQAIABXAGUAYgAgAEQAZQBwAGwAbwB5AFwAbQBzAGQAZQBwAGwAbwB5AC4AZQB4AGUAIAAtAHYAZQByAGIAOgBzAHkAbgBjACAALQBzAG8AdQByAGMAZQA6AGQAYgBmAHUAbABsAHMAcQBsAD0AIgBEAGEAdABhACAAUwBvAHUAcgBjAGUAPQBtAHkAcwBvAHUAcgBjAGUAOwBJAG4AdABlAGcAcgBhAHQAZQBkACAAUwBlAGMAdQByAGkAdAB5AD0AZgBhAGwAcwBlADsAVQBzAGUAcgAgAEkARAA9AHMAYQA7AFAAdwBkAD0AcwBhAHAAYQBzAHMAIQA7AEQAYQB0AGEAYgBhAHMAZQA9AG0AeQBkAGIAOwAiACAALQBkAGUAcwB0ADoAZABiAGYAdQBsAGwAcwBxAGwAPQAiAEQAYQB0AGEAIABTAG8AdQByAGMAZQA9AC4AXABtAHkAZABlAHMAdABzAG8AdQByAGMAZQA7AEkAbgB0AGUAZwByAGEAdABlAGQAIABTAGUAYwB1AHIAaQB0AHkAPQBmAGEAbABzAGUAOwBVAHMAZQByACAASQBEAD0AcwBhADsAUAB3AGQAPQBzAGEAcABhAHMAcwAhADsARABhAHQAYQBiAGEAcwBlAD0AbQB5AGQAYgA7ACIALABjAG8AbQBwAHUAdABlAHIAbgBhAG0AZQA9ADEAMAAuADEAMAAuADEAMAAuADEAMAAsAHUAcwBlAHIAbgBhAG0AZQA9AGEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIALABwAGEAcwBzAHcAbwByAGQAPQBhAGQAbQBpAG4AcABhAHMAcwAiAA==

e aqui está como replicar em casa:

$command = 'C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe -verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass"'
$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)
$encodedCommand = [Convert]::ToBase64String($bytes)
$encodedCommand

#  The clip below copies the base64 string to your clipboard for right click and paste.
$encodedCommand | Clip
Knuckle-Dragger
fonte
3

Você pode executar arquivos exe de maneiras diferentes no PowerShell. Por exemplo, se você deseja executar o unrar.exe e extrair um arquivo .rar, basta escrever no PowerShell:

$extract_path = "C:\Program Files\Containing folder";
$rar_to_extract = "C:\Path_to_arch\file.rar"; #(or.exe if its a big file)  
C:\Path_here\Unrar.exe x -o+ -c- $rar_to_extract $extract_path;

Mas, às vezes, isso não funciona, portanto, você deve usar o parâmetro &, como mostrado acima: Por exemplo, com o vboxmanage.exe (uma ferramenta para gerenciar máquinas virtuais de caixa virtual), você deve chamar os parameteres fora da string dessa maneira, sem aspas:

> $vmname = "misae_unrtes_1234123"; #(name too long, we want to change this)
> & 'C:\Program Files\Oracle\VirtualBox\VBoxManage.exe' modifyvm $vmname --name UBUNTU;

Se você deseja chamar simplesmente um arquivo arquivado no winrar como arquivos .exe, também pode descompactá-lo com o cmdlet invoke-command e um parâmetro Silent / S (ele se extrairá na mesma pasta em que foi compactado).

> Invoke-Command -ScriptBlock { C:\Your-path\archivefile.exe /S };

Portanto, existem várias maneiras de executar arquivos .exe com argumentos no PowerShell.

Às vezes, é preciso encontrar uma solução alternativa para fazê-lo funcionar corretamente, o que pode exigir mais esforço e sofrimento :) dependendo da maneira como o .exe foi compilado ou criado por seus criadores.

Andy McRae
fonte
1

Eu uso esse método simples, limpo e eficaz.

Coloco argumentos em uma matriz, 1 por linha. Dessa forma, é muito fácil ler e editar. Então eu uso um truque simples de passar todos os argumentos dentro de aspas duplas para uma função com 1 único parâmetro. Isso os nivela, incluindo matrizes, em uma única string, que eu executo usando a 'Invoke-Expression' do PS. Esta diretiva foi projetada especificamente para converter uma string em um comando executável. Funciona bem:

                    # function with one argument will flatten 
                    # all passed-in entries into 1 single string line
Function Execute($command) {
                    # execute:
    Invoke-Expression $command;
                    # if you have trouble try:
  # Invoke-Expression "& $command";
                    # or if you need also output to a variable
  # Invoke-Expression $command | Tee-Object -Variable cmdOutput;

}

#  ... your main code here ...

               # The name of your executable app
$app = 'my_app.exe';
               # List of arguments:
               #    Notice the type of quotes - important !
               #    Those in single quotes are normal strings, like 'Peter'
$args = 'arg1',
        'arg2',
        $some_variable,
        'arg4',
        "arg5='with quotes'",
        'arg6',
        "arg7 \ with \ $other_variable",
        'etc...';

               # pass all arguments inside double quotes
Execute "$app $args";
Felix
fonte
1

Eu tinha o seguinte código funcionando perfeitamente no meu laptop:

& $msdeploy `
-source:package="$publishFile" `
-dest:auto,computerName="$server",includeAcls="False",UserName="$username",Password="$password",AuthType="$auth" `
-allowUntrusted  `
-verb:sync  `
-enableRule:DoNotDeleteRule `
-disableLink:AppPoolExtension  `
-disableLink:ContentExtension  `
-disableLink:CertificateExtension  `
-skip:objectName=filePath,absolutePath="^(.*Web\.config|.*Environment\.config)$" `
-setParam:name=`"IIS Web Application Name`",value="$appName"

Então, quando tentei executá-lo diretamente em um servidor, comecei a receber esses erros "Unrecognized argument ...etc.... All arguments must begin with "-". "

Depois de tentar todas as soluções possíveis (sem sucesso), descobri que o Powershell no servidor (Windows 2008 R2) era a versão 3.0, enquanto o meu laptop tinha 5.0. (você pode usar "$ PSVersionTable" para ver a versão).

Depois de atualizar o Powershell para a versão mais recente, ele começou a funcionar novamente.

drizin
fonte
1

O Cmd pode gerenciar a execução de um exe citado, mas o Powershell não pode. Eu só vou lidar com a execução do exe, já que não o tenho. Se você literalmente precisar enviar aspas duplas para o argumento de um comando externo, esse é outro problema que já foi abordado em outro lugar.

1) adicione a pasta exe ao seu caminho, talvez no seu perfil $

$env:path += ';C:\Program Files\IIS\Microsoft Web Deploy\'
msdeploy

2) coloque entre aspas os espaços:

C:\Program` Files\IIS\Microsoft` Web` Deploy\msdeploy.exe
js2010
fonte
0

Então, encontrei um problema semelhante e resolvi resolvê-lo desta maneira:

  1. Escapa os caracteres das aspas (") com um backtick (`)
  2. Coloque sua nova expressão entre aspas (")
  3. Usando o operador de chamada (&), emita o comando invoke-expressionna nova sequência

Solução de exemplo:

& {invoke-expression "C: \ Arquivos de programas \ IIS \ Microsoft Web Deploy \ msdeploy.exe -verb: sync -source: dbfullsql =` "Fonte de dados = mysource; Segurança integrada = false; Segurança integrada = false; ID do usuário = sa; Pwd = sapass !; Database = mydb; `" -dest: dbfullsql = `" Fonte de dados =. \ Mydestsource; Segurança integrada = false; ID do usuário = sa; Pwd = sapass!; Banco de dados = mydb; `", computername = 10.10.10.10, nome de usuário = administrador, senha = adminpass` ""}

Randall Borck
fonte
0

Para o nome do executável, o cmdlet new-alias pode ser empregado para evitar lidar com espaços ou precisar adicionar o executável ao ambiente $ PATH.

PS> new-alias msdeploy "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe"
PS> msdeploy ...

Para listar ou modificar aliases de PS, consulte também

PS> get-alias
PS> set-alias

De Jeffery Hicks Aarticle

Outras respostas abordam os argumentos.

crokusek
fonte