Como executar comandos CMD no PowerShell

1. Usando o Operador de Invocação do PowerShell &
2. Executando Comandos CMD Usando cmd.exe
3. Encaminhando para CMD Usando PowerShell
4. Conclusão

Muitos comandos de Prompt de Comando (CMD) legados funcionam no ambiente de script do Windows PowerShell. O ambiente do PowerShell leva esses comandos adiante, desde os comandos mais utilizados, como ping, até os comandos mais informativos, como tracert, do ambiente legado usando aliases.

No entanto, alguns comandos em execução no terminal do Prompt de Comando não funcionarão no ambiente de script do Windows PowerShell. Este artigo discutirá como podemos transcrevê-los corretamente para o Windows PowerShell.

Usando o Operador de Invocação do PowerShell &

No versátil mundo da script, o PowerShell se destaca por sua capacidade de incorporar e executar comandos de outros ambientes de scripting, notavelmente o Prompt de Comando (CMD). Um dos métodos mais diretos para alcançar isso é por meio do Operador de Invocação (&).

Este artigo explora o uso do Operador de Invocação para executar comandos CMD dentro do PowerShell, uma habilidade inestimável para aqueles que desejam unir as funcionalidades do PowerShell e dos scripts CMD tradicionais.

A sintaxe básica para usar o Operador de Invocação é a seguinte:

& <Command-String> <Arguments>

• &: Este é o Operador de Invocação.
• <Command-String>: Este é o comando que você deseja executar. Este pode ser um comando CMD, um cmdlet do PowerShell ou um bloco de script.
• <Arguments>: Este é opcional e representa quaisquer argumentos ou parâmetros que o comando requer.

Código de Exemplo:

& cmd.exe /c echo "Hello from CMD"

Neste script, empregamos o Operador de Invocação & para executar um comando CMD de forma contínua dentro do PowerShell. Primeiramente, convocamos cmd.exe, o executável designado para o Prompt de Comando, garantindo que estamos trabalhando dentro do ambiente de linha de comando correto.

Em seguida, passamos o parâmetro /c para cmd.exe, uma instrução crucial que direciona o Prompt de Comando a executar nosso comando especificado e terminar prontamente após. Nosso comando de escolha, echo "Hello from CMD", é uma demonstração simples, mas eficaz, pois simplesmente imprime a mensagem Hello from CMD no console.

Saída:

Esta saída demonstra que o comando CMD echo foi executado com sucesso dentro do PowerShell, exibindo a mensagem pretendida.

Executando Comandos CMD Usando cmd.exe

Outro exemplo de execução de comandos CMD é usando cmd.exe. Podemos adicionar cmd.exe dentro do Windows PowerShell como fizemos anteriormente.

Uma vez adicionado e executado, ele chamará a interface da linha de comando dentro do prompt de comando do Windows PowerShell.

A sintaxe para usar cmd.exe diretamente no PowerShell é a seguinte:

cmd.exe /c "<Command-String>"

• cmd.exe: Este é o executável para o Prompt de Comando.
• /c: Este é um parâmetro que instrui cmd.exe a realizar o comando especificado pela string e, em seguida, terminar.
• "<Command-String>": Este é o comando CMD ou série de comandos que você deseja executar.

Código de Exemplo:

cmd.exe /c "echo Hello from CMD"

Neste script, integramos perfeitamente a funcionalidade CMD no PowerShell invocando diretamente cmd.exe com o parâmetro /c, seguido pelo nosso comando de interesse, echo Hello from CMD. Ao usar cmd.exe /c, estabelecemos uma ponte entre PowerShell e CMD, permitindo-nos acessar o familiar ambiente de linha de comando e funcionalidades de CMD dentro do nosso script do PowerShell.

O comando "echo Hello from CMD" é um exemplo simples, mas ilustrativo, dessa integração, onde utilizamos um comando CMD básico para imprimir nosso texto desejado no console.

Saída:

Esta saída demonstra a execução bem-sucedida de um comando CMD echo no PowerShell, exibindo a mensagem Hello from CMD.

Encaminhando para CMD Usando PowerShell

No Windows PowerShell, também podemos enviar comandos para o terminal do prompt de comando encaminhando no cmdlet cmd para o comando que você queria enviar.

Encaminhar para CMD no PowerShell é usado principalmente para executar comandos CMD ou scripts em lote dentro de um contexto do PowerShell. Este método é particularmente útil quando você precisa executar um comando CMD que não tem um equivalente direto no PowerShell ou quando está lidando com scripts CMD legados.

A sintaxe básica para encaminhar para CMD no PowerShell é:

"<Command-String>" | cmd.exe /c -

• "<Command-String>": Este é o comando CMD que você deseja executar.
• |: Este é o operador de pipe do PowerShell, que passa a saída de um comando como entrada para outro.
• cmd.exe /c -: Isto chama o Prompt de Comando para executar o comando passado a ele via pipe. O - significa que cmd.exe deve esperar o comando da entrada padrão (stdin).

Código de Exemplo:

"echo Hello from CMD" | cmd.exe

Neste exemplo, usamos a técnica de encaminhamento para enviar a string "echo Hello from CMD" para cmd.exe, demonstrando uma elegante mistura das capacidades de encaminhamento do PowerShell com a execução de comandos do CMD.

Nossa jornada começa com "echo Hello from CMD", um simples, mas eficaz, comando CMD encapsulado como uma string, projetada para exibir uma mensagem específica quando executada no ambiente CMD.

Em seguida, empregamos o operador de pipe |, uma ferramenta poderosa no PowerShell, para encaminhar de forma contínua essa string de comando para cmd.exe. A culminação desse processo é observada em cmd.exe /c -, onde o símbolo - desempenha um papel crucial, instruindo cmd.exe a ler e executar o comando que vem do pipeline.

Saída:

Esta saída é o resultado do comando CMD echo, que imprime Hello from CMD na tela.

Executando Comandos CMD no PowerShell Usando Invoke-Expression

Um método versátil e poderoso para executar comandos CMD dentro do PowerShell é através do cmdlet Invoke-Expression. Esta abordagem é particularmente útil quando você precisa construir e executar um comando ou um bloco de script de forma dinâmica.

Este artigo explora o propósito, a aplicação e o uso do método Invoke-Expression no PowerShell para executar comandos CMD.

A sintaxe para Invoke-Expression é:

Invoke-Expression -Command "<Command-String>"

• -Command: Este especifica o comando a ser executado. Este parâmetro pode ser abreviado como -C.
• "<Command-String>": Esta é a string que contém o comando a ser executado.

Código de Exemplo:

Invoke-Expression -Command "cmd.exe /c echo Hello from CMD"

Em nosso script, aproveitamos o poder do Invoke-Expression para executar de forma habilidosa um comando CMD encapsulado dentro de uma string. Nosso processo começa com Invoke-Expression -Command, uma combinação pivotante de cmdlet e parâmetro que equipa o PowerShell com a capacidade de interpretar e executar a string de comando fornecida.

Em seguida, introduzimos "cmd.exe /c echo Hello from CMD" como nossa string de comando escolhida. Esta string instrui habilmente cmd.exe a utilizar o parâmetro /c, uma diretriz que ordena ao CMD executar o comando subsequente e, em seguida, concluir seu processo.

O comando echo, inserido dentro desta string, é o coração de nossa execução, projetado para gerar Hello from CMD no CMD.

Saída:

Esta saída é o resultado direto do comando echo sendo processado pelo CMD, que é invocado pelo Invoke-Expression no PowerShell.

Conclusão

Nesta exploração abrangente, analisamos a versatilidade de executar comandos do Prompt de Comando (CMD) dentro do ambiente do Windows PowerShell, cobrindo quatro métodos distintos: o simples Operador de Invocação &, o uso direto de cmd.exe, a técnica inovadora de encaminhar comandos para CMD e o dinâmico cmdlet Invoke-Expression. Cada abordagem oferece vantagens únicas para integrar as funcionalidades familiares do CMD ao domínio de scripting avançado do PowerShell.

Para aqueles que buscam aprofundar sua experiência com o PowerShell, explorar tópicos avançados como Criando Cmdlets Personalizados do PowerShell ou Técnicas Avançadas de Scripting do PowerShell é altamente recomendado, abrindo portas para soluções de scripting mais sofisticadas e robustas que harmonizam as forças do PowerShell e do CMD.