Comment exécuter des commandes CMD dans PowerShell

1. Utilisation de l’opérateur d’invocation PowerShell &
2. Exécution de commandes CMD en utilisant cmd.exe
3. Piping vers CMD en utilisant PowerShell
4. Conclusion

De nombreux anciens commandes de l’invite de commande (CMD) fonctionnent dans l’environnement de script Windows PowerShell. L’environnement PowerShell intègre ces commandes des plus utilisées, comme ping, aux commandes les plus informatives, comme tracert, de l’environnement hérité en utilisant des alias.

Cependant, certaines commandes exécutées dans le terminal de l’invite de commande ne fonctionneront pas dans l’environnement de script de Windows PowerShell. Cet article discutera de la façon dont nous pouvons les transcrire correctement dans Windows PowerShell.

Utilisation de l’opérateur d’invocation PowerShell &

Dans le monde polyvalent du scripting, PowerShell se distingue par sa capacité à incorporer et exécuter des commandes d’autres environnements de scripting, notamment l’invite de commandes (CMD). L’une des méthodes les plus directes pour y parvenir est l’utilisation de l’opérateur d’invocation (&).

Cet article explore l’utilisation de l’opérateur d’invocation pour exécuter des commandes CMD dans PowerShell, une compétence inestimable pour ceux qui cherchent à établir un lien entre les fonctionnalités de PowerShell et les scripts CMD traditionnels.

La syntaxe de base pour utiliser l’opérateur d’invocation est la suivante :

& <Command-String> <Arguments>

• &: C’est l’opérateur d’invocation.
• <Command-String>: C’est la commande que vous souhaitez exécuter. Cela peut être une commande CMD, une cmdlet PowerShell, ou un bloc de script.
• <Arguments>: C’est optionnel et représente tous les arguments ou paramètres requis par la commande.

Exemple de code :

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

Dans ce script, nous utilisons l’opérateur d’invocation & pour exécuter facilement une commande CMD dans PowerShell. Tout d’abord, nous invoquons cmd.exe, l’exécutable désigné pour l’invite de commandes, nous assurant que nous travaillons dans le bon environnement de ligne de commande.

Nous passons ensuite le paramètre /c à cmd.exe, une instruction cruciale qui indique à l’invite de commandes d’exécuter notre commande spécifiée et de se terminer promptement par la suite. Notre commande de choix, echo "Hello from CMD", est une démonstration simple mais efficace, car elle imprime simplement le message Hello from CMD dans la console.

Sortie :

Cette sortie démontre que la commande CMD echo a été exécutée avec succès dans PowerShell, affichant le message voulu.

Exécution de commandes CMD en utilisant cmd.exe

Un autre exemple d’exécution de commandes CMD consiste à utiliser cmd.exe. Nous pouvons ajouter cmd.exe à l’intérieur de Windows PowerShell comme notre méthode précédente.

Une fois ajoutée et exécutée, cela appellera l’interface de ligne de commande à l’intérieur de l’invite de commandes Windows PowerShell.

La syntaxe pour utiliser cmd.exe directement dans PowerShell est la suivante :

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

• cmd.exe: C’est l’exécutable pour l’invite de commandes.
• /c: C’est un paramètre qui instruit cmd.exe à exécuter la commande spécifiée par la chaîne, puis à se terminer.
• "<Command-String>": C’est la commande CMD ou une série de commandes que vous souhaitez exécuter.

Exemple de code :

cmd.exe /c "echo Hello from CMD"

Dans ce script, nous intégrons parfaitement la fonctionnalité CMD dans PowerShell en invoquant directement cmd.exe avec le paramètre /c, suivi de notre commande d’intérêt, echo Hello from CMD. En utilisant cmd.exe /c, nous établissons un pont entre PowerShell et CMD, nous permettant d’exploiter l’environnement de ligne de commande familier et les fonctionnalités de CMD dans notre script PowerShell.

La commande "echo Hello from CMD" est un exemple simple mais illustratif de cette intégration, où nous utilisons une commande CMD basique pour imprimer notre texte désiré dans la console.

Sortie :

Cette sortie démontre l’exécution réussie d’une commande CMD echo dans PowerShell, affichant le message Hello from CMD.

Piping vers CMD en utilisant PowerShell

Dans Windows PowerShell, nous pouvons également envoyer des commandes au terminal de l’invite de commandes en les pipant dans la cmdlet cmd de la commande que vous souhaitez envoyer.

Piper vers CMD dans PowerShell est principalement utilisé pour exécuter des commandes CMD ou des scripts batch dans un contexte PowerShell. Cette méthode est particulièrement utile lorsque vous devez exécuter une commande CMD qui n’a pas d’équivalent PowerShell direct ou lorsque vous traitez des scripts CMD hérités.

La syntaxe de base pour piper vers CMD dans PowerShell est :

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

• "<Command-String>": C’est la commande CMD que vous souhaitez exécuter.
• |: C’est l’opérateur de pipe PowerShell, qui passe la sortie d’une commande comme entrée à une autre.
• cmd.exe /c -: Cela appelle l’invite de commandes pour exécuter la commande lui étant transmise via le pipe. Le - signifie que cmd.exe doit s’attendre à recevoir la commande de l’entrée standard (stdin).

Exemple de code :

"echo Hello from CMD" | cmd.exe

Dans cet exemple, nous utilisons la technique de piping pour envoyer la chaîne "echo Hello from CMD" dans cmd.exe, démontrant un mélange élégant des capacités de piping de PowerShell avec l’exécution de commandes de CMD.

Notre parcours commence avec "echo Hello from CMD", une simple mais efficace commande CMD encapsulée sous forme de chaîne, conçue pour afficher un message spécifique lorsqu’elle est exécutée dans l’environnement CMD.

Nous employons ensuite l’opérateur de pipe |, un outil puissant dans PowerShell, pour transférer sans effort cette chaîne de commande à cmd.exe. L’aboutissement de ce processus est observé dans cmd.exe /c -, où le symbole - joue un rôle crucial, indiquant à cmd.exe de lire et d’exécuter attentivement la commande provenant du pipeline.

Sortie :

Cette sortie est le résultat de la commande CMD echo, qui imprime Hello from CMD à l’écran.

Exécution de commandes CMD dans PowerShell en utilisant Invoke-Expression

Une méthode polyvalente et puissante pour exécuter des commandes CMD dans PowerShell est d’utiliser la cmdlet Invoke-Expression. Cette approche est particulièrement utile lorsque vous devez construire et exécuter dynamiquement une commande ou un bloc de script.

Cet article explore le but, l’application et l’utilisation de la méthode Invoke-Expression dans PowerShell pour exécuter des commandes CMD.

La syntaxe pour Invoke-Expression est :

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

• -Command: Cela spécifie la commande à exécuter. Ce paramètre peut être abrégé en -C.
• "<Command-String>": C’est la chaîne qui contient la commande à exécuter.

Exemple de code :

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

Dans notre script, nous exploitons la puissance de Invoke-Expression pour exécuter habilement une commande CMD encapsulée au sein d’une chaîne. Notre processus commence par Invoke-Expression -Command, une combinaison de cmdlet et de paramètre essentielle qui permet à PowerShell d’interpréter et d’exécuter la chaîne de commande fournie.

Nous introduisons ensuite "cmd.exe /c echo Hello from CMD" comme notre chaîne de commande choisie. Cette chaîne indique habilement à cmd.exe d’utiliser le paramètre /c, un directive qui ordonne à CMD d’exécuter la commande suivante puis de conclure son processus.

La commande echo, nichée au sein de cette chaîne, est le cœur de notre exécution, conçue pour sortir Hello from CMD dans CMD.

Sortie :

Cette sortie est le résultat direct de la commande echo traitée par CMD, qui est invoquée par Invoke-Expression dans PowerShell.

Conclusion

Dans cette exploration exhaustive, nous avons examiné la polyvalence de l’exécution de commandes de l’invite de commandes (CMD) dans l’environnement Windows PowerShell, couvrant quatre méthodes distinctes : l’opérateur d’invocation simple &, l’utilisation directe de cmd.exe, la technique innovante de piping des commandes vers CMD, et la cmdlet dynamique Invoke-Expression. Chaque approche offre des avantages uniques pour intégrer les fonctionnalités familiales de CMD dans le domaine avancé du scripting de PowerShell.

Pour ceux qui cherchent à approfondir leur expertise en PowerShell, explorer des sujets avancés comme la création de cmdlets PowerShell personnalisées ou les techniques de scripting PowerShell avancées est fortement recommandé, ouvrant la voie à des solutions de scripting plus sophistiquées et robustes qui allient harmonieusement les forces de PowerShell et de CMD.