Cómo ejecutar comandos de CMD en PowerShell

1. Usando el Operador de Invocación de PowerShell &
2. Ejecutando comandos CMD usando cmd.exe
3. Enviando a CMD usando PowerShell
4. Conclusión

Muchos comandos heredados de Command Prompt (CMD) funcionan en el entorno de scripting de Windows PowerShell. El entorno de PowerShell lleva estos comandos desde los más utilizados, como ping, hasta los más informativos, como tracert, del entorno heredado utilizando alias.

Sin embargo, algunos comandos en ejecución en la terminal de Command Prompt no funcionarán en el entorno de scripting de Windows PowerShell. Este artículo discutirá cómo podemos transcribirlos correctamente a Windows PowerShell.

Usando el Operador de Invocación de PowerShell &

En el versátil mundo del scripting, PowerShell se destaca por su capacidad para incorporar y ejecutar comandos de otros entornos de scripting, notablemente el Command Prompt (CMD). Uno de los métodos más directos para lograr esto es a través del Operador de Invocación (&).

Este artículo profundiza en el uso del Operador de Invocación para ejecutar comandos CMD dentro de PowerShell, una habilidad invaluable para aquellos que buscan unir las funcionalidades de PowerShell y los scripts CMD tradicionales.

La sintaxis básica para usar el Operador de Invocación es la siguiente:

& <Command-String> <Arguments>

• &: Este es el Operador de Invocación.
• <Command-String>: Este es el comando que deseas ejecutar. Esto puede ser un comando CMD, un cmdlet de PowerShell o un bloque de script.
• <Arguments>: Esto es opcional y representa cualquier argumento o parámetro que el comando requiera.

Código de Ejemplo:

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

En este script, empleamos el Operador de Invocación & para ejecutar sin problemas un comando CMD dentro de PowerShell. Primero, invocamos cmd.exe, el ejecutable designado para Command Prompt, asegurándonos de que estamos trabajando dentro del entorno correcto de la línea de comandos.

Luego pasamos el parámetro /c a cmd.exe, una instrucción crucial que indica al Command Prompt que ejecute nuestro comando especificado y termine inmediatamente después. Nuestro comando elegido, echo "Hello from CMD", es una demostración sencilla pero efectiva, ya que simplemente imprime el mensaje Hello from CMD en la consola.

Salida:

Esta salida demuestra que el comando CMD echo se ejecutó con éxito dentro de PowerShell, mostrando el mensaje previsto.

Ejecutando comandos CMD usando cmd.exe

Otro ejemplo de la ejecución de comandos CMD es utilizando cmd.exe. Podemos añadir cmd.exe dentro de Windows PowerShell como en nuestro método anterior.

Una vez añadido y ejecutado, llamará a la interfaz de línea de comandos dentro del símbolo del sistema de Windows PowerShell.

La sintaxis para usar cmd.exe directamente en PowerShell es la siguiente:

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

• cmd.exe: Este es el ejecutable para Command Prompt.
• /c: Este es un parámetro que instruye a cmd.exe para llevar a cabo el comando especificado por la cadena y luego terminar.
• "<Command-String>": Este es el comando CMD o serie de comandos que deseas ejecutar.

Código de Ejemplo:

cmd.exe /c "echo Hello from CMD"

En este script, integramos sin problemas la funcionalidad de CMD en PowerShell invocando directamente cmd.exe con el parámetro /c, seguido de nuestro comando de interés, echo Hello from CMD. Al usar cmd.exe /c, establecemos un puente entre PowerShell y CMD, permitiéndonos aprovechar el entorno y las funcionalidades familiares de la línea de comandos de CMD dentro de nuestro script de PowerShell.

El comando "echo Hello from CMD" es un ejemplo sencillo pero ilustrativo de esta integración, donde utilizamos un comando básico de CMD para imprimir nuestro texto deseado en la consola.

Salida:

Esta salida demuestra la exitosa ejecución de un comando CMD echo en PowerShell, mostrando el mensaje Hello from CMD.

Enviando a CMD usando PowerShell

En Windows PowerShell, también podemos enviar comandos a la terminal de command prompt mediante el uso del cmdlet cmd para el comando que deseas enviar.

Enviar a CMD en PowerShell se utiliza principalmente para ejecutar comandos CMD o scripts por lotes dentro de un contexto de PowerShell. Este método es particularmente útil cuando necesitas ejecutar un comando CMD que no tiene un equivalente directo en PowerShell o cuando estás tratando con scripts CMD heredados.

La sintaxis básica para enviar a CMD en PowerShell es:

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

• "<Command-String>": Este es el comando CMD que deseas ejecutar.
• |: Este es el operador de pipe de PowerShell, que pasa la salida de un comando como entrada a otro.
• cmd.exe /c -: Esto llama al Command Prompt para ejecutar el comando que se le pase a través del pipe. El - indica que cmd.exe debería esperar el comando de la entrada estándar (stdin).

Código de Ejemplo:

"echo Hello from CMD" | cmd.exe

En este ejemplo, utilizamos la técnica de piping para enviar la cadena "echo Hello from CMD" a cmd.exe, demostrando una elegante fusión de las capacidades de piping de PowerShell con la ejecución de comandos de CMD.

Nuestra travesía comienza con "echo Hello from CMD", un comando de CMD sencillo pero efectivo encapsulado como una cadena, diseñado para mostrar un mensaje específico cuando se ejecuta en el entorno de CMD.

Luego empleamos el operador pipe |, una herramienta poderosa en PowerShell, para avanzar sin problemas esta cadena de comando a cmd.exe. La culminación de este proceso se observa en cmd.exe /c -, donde el símbolo - juega un papel crucial, instruyendo a cmd.exe a leer y ejecutar con atención el comando que llega a través del pipe.

Salida:

Esta salida es el resultado del comando CMD echo, que imprime Hello from CMD en la pantalla.

Ejecutando comandos CMD en PowerShell usando Invoke-Expression

Un método versátil y poderoso para ejecutar comandos CMD dentro de PowerShell es a través del cmdlet Invoke-Expression. Este enfoque es particularmente útil cuando necesitas construir y ejecutar dinámicamente un comando o un bloque de script.

Este artículo profundiza en el propósito, aplicación y uso del método Invoke-Expression en PowerShell para ejecutar comandos CMD.

La sintaxis para Invoke-Expression es:

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

• -Command: Este especifica el comando a ejecutar. Este parámetro puede abreviarse como -C.
• "<Command-String>": Esta es la cadena que contiene el comando a ser ejecutado.

Código de Ejemplo:

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

En nuestro script, aprovechamos el poder de Invoke-Expression para ejecutar hábilmente un comando CMD encapsulado dentro de una cadena. Nuestro proceso comienza con Invoke-Expression -Command, una combinación crucial de cmdlet y parámetro que capacita a PowerShell a interpretar y ejecutar la cadena de comando proporcionada.

Luego introducimos "cmd.exe /c echo Hello from CMD" como nuestra cadena de comando elegida. Esta cadena instruye hábilmente a cmd.exe para utilizar el parámetro /c, una directiva que ordena a CMD ejecutar el comando subsecuente y luego concluir su proceso.

El comando echo, anidado dentro de esta cadena, es el corazón de nuestra ejecución, diseñado para producir Hello from CMD en CMD.

Salida:

Esta salida es el resultado directo del comando echo procesado por CMD, que es invocado por Invoke-Expression en PowerShell.

Conclusión

En esta exploración integral, profundizamos en la versatilidad de ejecutar comandos de Command Prompt (CMD) en el entorno de Windows PowerShell, cubriendo cuatro métodos distintos: el sencillo Operador de Invocación &, el uso directo de cmd.exe, la innovadora técnica de enviar comandos a CMD, y el dinámico cmdlet Invoke-Expression. Cada enfoque ofrece ventajas únicas para integrar las funcionalidades familiares de CMD en el avanzado reino de scripting de PowerShell.

Para aquellos que buscan ampliar su experiencia en PowerShell, se recomienda profundizar en temas avanzados como la Creación de Cmdlets Personalizados de PowerShell o Técnicas Avanzadas de Scripting en PowerShell, abriendo puertas a soluciones de scripting más sofisticadas y robustas que armonizan las fortalezas de PowerShell y CMD.