Wie man CMD-Befehle in PowerShell ausführt

1. Verwendung des PowerShell-Invoke-Operators &
2. Ausführen von CMD-Befehlen mit cmd.exe
3. Pipen zu CMD mit PowerShell
4. Fazit

Viele Legacy-Eingabeaufforderung (CMD) Befehle funktionieren in der Windows PowerShell-Skripting-Umgebung. Die PowerShell-Umgebung führt diese Befehle von den am häufigsten verwendeten Befehlen wie ping bis zu den informativsten Befehlen wie tracert aus der Legacy-Umgebung mit Hilfe von Aliasen weiter.

Einige Befehle, die in der Eingabeaufforderung ausgeführt werden, funktionieren jedoch möglicherweise nicht in der Skripting-Umgebung von Windows PowerShell. In diesem Artikel wird erörtert, wie wir sie korrekt in Windows PowerShell transkribieren können.

Verwendung des PowerShell-Invoke-Operators &

In der vielseitigen Welt des Scriptings zeichnet sich PowerShell durch die Fähigkeit aus, Befehle aus anderen Skripting-Umgebungen, insbesondere der Eingabeaufforderung (CMD), zu integrieren und auszuführen. Eine der direktesten Methoden, dies zu erreichen, ist der Invoke-Operator (&).

Dieser Artikel befasst sich mit der Verwendung des Invoke-Operators zum Ausführen von CMD-Befehlen innerhalb von PowerShell, eine wertvolle Fähigkeit für diejenigen, die die Funktionen von PowerShell und traditionellen CMD-Skripten verbinden möchten.

Die grundlegende Syntax für die Verwendung des Invoke-Operators lautet wie folgt:

& <Command-String> <Arguments>

• &: Dies ist der Invoke-Operator.
• <Command-String>: Dies ist der Befehl, den Sie ausführen möchten. Dies kann ein CMD-Befehl, ein PowerShell-Cmdlet oder ein Codeblock sein.
• <Arguments>: Dies ist optional und stellt alle Argumente oder Parameter dar, die der Befehl benötigt.

Beispielcode:

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

In diesem Skript verwenden wir den Invoke-Operator &, um nahtlos einen CMD-Befehl innerhalb von PowerShell auszuführen. Zunächst rufen wir cmd.exe auf, das vorgesehene ausführbare Programm für die Eingabeaufforderung, um sicherzustellen, dass wir in der richtigen Befehlszeilenumgebung arbeiten.

Wir übergeben dann den Parameter /c an cmd.exe, eine entscheidende Anweisung, die die Eingabeaufforderung anweist, unseren angegebenen Befehl auszuführen und danach sofort zu beenden. Unser Befehl der Wahl, echo "Hello from CMD", ist eine einfache, aber effektive Demonstration, da er nur die Nachricht Hello from CMD in die Konsole ausgibt.

Ausgabe:

Diese Ausgabe zeigt, dass der CMD-Befehl echo erfolgreich innerhalb von PowerShell ausgeführt wurde und die beabsichtigte Nachricht angezeigt wird.

Ausführen von CMD-Befehlen mit cmd.exe

Ein weiteres Beispiel zum Ausführen von CMD-Befehlen besteht darin, cmd.exe zu verwenden. Wir können cmd.exe wie in unserer vorherigen Methode in Windows PowerShell einfügen.

Sobald es hinzugefügt und ausgeführt wird, wird das Befehlszeileninterface innerhalb der Windows PowerShell-Kommandoaufforderung aufgerufen.

Die Syntax zur direkten Verwendung von cmd.exe in PowerShell lautet wie folgt:

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

• cmd.exe: Dies ist die ausführbare Datei für die Eingabeaufforderung.
• /c: Dies ist ein Parameter, der cmd.exe anweist, den durch die Zeichenfolge angegebenen Befehl auszuführen und dann zu beenden.
• "<Command-String>": Dies ist der CMD-Befehl oder die Reihe von Befehlen, die Sie ausführen möchten.

Beispielcode:

cmd.exe /c "echo Hello from CMD"

In diesem Skript integrieren wir nahtlos die CMD-Funktionalität in PowerShell, indem wir cmd.exe direkt mit dem Parameter /c aufrufen, gefolgt von unserem gewünschten Befehl, echo Hello from CMD. Durch die Verwendung von cmd.exe /c schaffen wir eine Brücke zwischen PowerShell und CMD, die es uns ermöglicht, auf die vertraute Befehlszeilenumgebung und die Funktionen von CMD innerhalb unseres PowerShell-Skripts zuzugreifen.

Der Befehl "echo Hello from CMD" ist ein einfaches, aber anschauliches Beispiel für diese Integration, bei der wir einen grundlegenden CMD-Befehl nutzen, um unseren gewünschten Text in die Konsole auszugeben.

Ausgabe:

Diese Ausgabe zeigt die erfolgreiche Ausführung eines CMD echo-Befehls in PowerShell, die die Nachricht Hello from CMD anzeigt.

Pipen zu CMD mit PowerShell

In Windows PowerShell können wir auch Befehle an die Eingabeaufforderung übergeben, indem wir das cmd Cmdlet an den Befehl anfügen, den Sie senden möchten.

Das Pipen zu CMD in PowerShell wird hauptsächlich verwendet, um CMD-Befehle oder Batch-Skripte innerhalb eines PowerShell-Kontexts auszuführen. Diese Methode ist besonders nützlich, wenn Sie einen CMD-Befehl ausführen müssen, der kein direktes PowerShell-Äquivalent hat, oder wenn Sie mit Legacy-CMD-Skripten arbeiten.

Die grundlegende Syntax für das Pipen zu CMD in PowerShell lautet:

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

• "<Command-String>": Dies ist der CMD-Befehl, den Sie ausführen möchten.
• |: Dies ist der PowerShell-Pipe-Operator, der die Ausgabe eines Befehls als Eingabe für einen anderen überträgt.
• cmd.exe /c -: Dies ruft die Eingabeaufforderung auf, um den über die Pipe übergebenen Befehl auszuführen. Das - bedeutet, dass cmd.exe den Befehl von der Standard-Eingabe (stdin) erwartet.

Beispielcode:

"echo Hello from CMD" | cmd.exe

In diesem Beispiel verwenden wir die Pipetechnik, um die Zeichenfolge "echo Hello from CMD" in cmd.exe zu senden, und demonstrieren eine elegante Verschmelzung der Piping-Fähigkeiten von PowerShell mit der Befehlsausführung von CMD.

Unsere Reise beginnt mit "echo Hello from CMD", einem einfachen, aber effektiven CMD-Befehl, der als Zeichenfolge gekapselt ist und entwickelt wurde, um eine bestimmte Nachricht anzuzeigen, wenn er in der CMD-Umgebung ausgeführt wird.

Wir verwenden dann den Pipe-Operator |, ein leistungsfähiges Werkzeug in PowerShell, um diese Befehlszeichenfolge nahtlos an cmd.exe weiterzuleiten. Der Höhepunkt dieses Prozesses wird in cmd.exe /c - sichtbar, wo das --Symbol eine entscheidende Rolle spielt und `cmd.exe anweist, den aus der Pipeline kommenden Befehl aufmerksam zu lesen und auszuführen.

Ausgabe:

Diese Ausgabe ist das Ergebnis des CMD echo-Befehls, der Hello from CMD auf den Bildschirm ausgibt.

Ausführen von CMD-Befehlen in PowerShell mit Invoke-Expression

Eine vielseitige und leistungsstarke Methode zum Ausführen von CMD-Befehlen innerhalb von PowerShell ist das Cmdlet Invoke-Expression. Dieser Ansatz ist besonders nützlich, wenn Sie einen Befehl oder einen Codeblock dynamisch erstellen und ausführen müssen.

Dieser Artikel behandelt den Zweck, die Anwendung und die Verwendung der Invoke-Expression-Methode in PowerShell zum Ausführen von CMD-Befehlen.

Die Syntax für Invoke-Expression lautet:

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

• -Command: Dies gibt den auszuführenden Befehl an. Dieser Parameter kann als -C abgekürzt werden.
• "<Command-String>": Dies ist die Zeichenfolge, die den auszuführenden Befehl enthält.

Beispielcode:

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

In unserem Skript nutzen wir die Macht von Invoke-Expression, um einen CMD-Befehl geschickt auszuführen, der in einer Zeichenfolge gekapselt ist. Unser Prozess beginnt mit Invoke-Expression -Command, einer wichtigen Kombination aus Cmdlet und Parameter, die PowerShell mit der Fähigkeit ausstattet, die bereitgestellte Befehlszeichenfolge zu interpretieren und auszuführen.

Wir führen dann "cmd.exe /c echo Hello from CMD" als unsere gewählte Befehlszeichenfolge ein. Diese Zeichenfolge weist cmd.exe geschickt an, den Parameter /c zu verwenden, eine Anweisung, die CMD anweist, den nachfolgenden Befehl auszuführen und dann den Prozess zu beenden.

Der Befehl echo, der in dieser Zeichenfolge eingebettet ist, ist das Herzstück unserer Ausführung, das darauf abzielt, Hello from CMD in CMD auszugeben.

Ausgabe:

Diese Ausgabe ist das direkte Ergebnis des echo-Befehls, der von CMD verarbeitet wird, das durch Invoke-Expression in PowerShell aufgerufen wird.

Fazit

In dieser umfassenden Erkundung haben wir die Vielseitigkeit des Ausführens von Eingabeaufforderungs-(CMD) Befehlen innerhalb der Windows PowerShell-Umgebung untersucht, wobei wir vier verschiedene Methoden behandelt haben: den straightforwarden Invoke-Operator &, die direkte Verwendung von cmd.exe, die innovative Technik des Pipens von Befehlen zu CMD und das dynamische Invoke-Expression Cmdlet. Jeder Ansatz bietet einzigartige Vorteile bei der Integration der vertrauten Funktionen von CMD in den fortschrittlichen Skriptingbereich von PowerShell.

Für diejenigen, die ihre PowerShell-Expertise weiter vertiefen möchten, wird der Einstieg in fortgeschrittene Themen wie das Erstellen benutzerdefinierter PowerShell-Cmdlets oder fortgeschrittene PowerShell-Skripting-Techniken dringend empfohlen, um Türen zu anspruchsvolleren und robusteren Skriptinglösungen zu öffnen, die die Stärken von PowerShell und CMD harmonisch verbinden.