Powershell-Befehl die Verarbeitung (Übergang in Variablen)

Ich bin erstellen Sie ein Powershell-Skript, bereitstellen von code und Teil des Prozesses ist der Aufruf eines Kommandozeilen-Komprimierung-tool namens RAR.EXE der back-up-Ordner.

Ich versuche, dynamisch zu erstellen, die Parameter und dann über powershell rufen Sie den Befehl mit der Variablen, aber ich komme in Schwierigkeiten. Es funktioniert nicht...

Führen Sie das folgende Skript, und Sie sollten sehen, was ich Rede. Die Parameter werden übergeben als variable wird entstellt. Wenn ich übergeben Sie den gesamten Befehl + Parameter, bekomme ich die berühmt-berüchtigte "is not recognized as a cmdlet..." - Meldung.

Vielen Dank für jede Hilfe!!!

echo "this should succeed"
& cmd /c echo foo

echo "why does this echo out an additional double quote?"
$param = "/c echo foo"
& cmd "$param"

echo "this does the same"
$param = "/c echo foo"
& cmd $param

echo "escaping the slash doesn't work either..."
$param = "`/c echo foo"
& cmd $param

echo "this fails, but why?"
$cmd = "cmd /c echo foo"
&$cmd

InformationsquelleAutor GabeA | 2009-04-30

9

Den call-operator " (&' in diesem Fall unnötig ist. Es wird verwendet, um rufen Sie einen Befehl in einem neuen Bereich. Dies ist in der Regel verwendet, um rufen Sie einen Befehl angegeben, mit einer Schnur oder einem Skriptblock. Es hat auch den Nebeneffekt, dass alle Variablen erstellt, die in sagen, ein PowerShell-Skript werden verworfen, nachdem der Befehl abgeschlossen ist und der Rahmen geht Weg.

Jedoch, da die cmd-EXE führt er Sie in ein völlig anderer Prozess. FWIW, erhalten Sie eine ähnliche Ausgabe direkt aus cmd.exe:
```
> cmd "/c echo foo"
foo"
```
So dass das zusätzliche Angebot am Ende ist ein cmd.exe Problem. In der Regel müssen Sie halten die Befehl getrennt von den Parametern, wenn die PowerShell ist dabei die Analyse, um den Befehl aufzurufen z.B.
```
45> & { $foo = "foo" }
46> $foo  # Note that $foo wasn't found - it went away with the scope
47> . { $foo = "foo" } # dotting executes in the current scope
48> $foo 
foo
```
Ausnahme hier ist, dass die Invoke-Expression verhält sich wie ein "bewerten Sie diesen string" - Funktion. Verwenden Sie mit Vorsicht, besonders, wenn der Benutzer den string. Könnte Ihr Tag saugen, wenn Sie, sofern "ri-C:\ -r".

In diesem Fall, wie andere vorgeschlagen haben, ich würde ziehen Sie das /c aus dem string $param string und geben Sie es z.B.:
```
cmd /c $param
```
Oder mit Invoke-Expression, aber verwenden Sie mit Vorsicht. BTW, wenn Sie versuchen, Debuggen von Problemen mit dem senden von Argumenten die EXE-Datei aus PowerShell, schauen Sie sich die echoargs-Dienstprogramm in der PowerShell Community Extensions (http://pscx.codeplex.com). Es ist sehr praktisch:
```
49> $param = "/c echo foo"
50> echoargs $param
Arg 0 is </c echo foo>
```
Dies zeigt, dass cmd.exe erhält, "/c echo "foo" als single argument. "/c" sollte ein separates argument von "echo foo" (der Befehl ausgeführt).
- Arrays eignen sich auch gut für den Aufbau der Befehlszeilen-Argumente; d.h. $cmdArgs = @('/c','echo foo'); cmd $cmdArgs
InformationsquelleAutor Keith Hill
8

Hatte ich Probleme mit der & call-Betreiber in der Vergangenheit beim Versuch zum aufrufen von ausführbaren Befehle eingeben wie Sie versuchen. Nicht sicher, ob ich verstehe, warum. Invoke-Expression jedoch immer zu funktionieren scheint in diesem Zusammenhang:
```
PS C:\> $cmd = "cmd /c echo foo"
PS C:\> Invoke-expression $cmd
foo
```
InformationsquelleAutor zdan
8

Eine andere Möglichkeit, die ich gefunden, dies zu tun war es, erstellen Sie ein array der Argumente der Kommandozeile aus und verwenden Sie, dass mit der apersand & call operator. So etwas wie dieses:
```
$exe = "cmd";
[Array]$params = "/c", "echo", "foo";

& $exe $params;
```
Es ist gut für mich gearbeitet.

Ich ursprünglich fand diese Technik hier:
http://techstumbler.blogspot.com/2009/12/windows-commands-with-arguments-in.html

InformationsquelleAutor Tom Hazel
3

Ihrem letzten Beispiel, wenn die scheitern, weil "&" behandelt die Zeichenkette als argument, so ist es Suche nach einem Programm mit dem Namen "cmd /c echo foo.exe". 🙂

Dies funktioniert:
```
& $cmd $params
```
Als für das doppelte Anführungszeichen ein Problem, es scheint, dass cmd nicht wie die Anführungszeichen um Argumente, die PowerShell stellt. Es wird dies:
```
cmd "/c echo foo"
```
So, ich denke, es behandelt alles nach /c, wie der genaue Befehl, so wie so:
```
echo foo"
```
Einige Kommandozeilen-Programme und funky Parsen der Kommandozeile (das ist der Grund, warum PowerShell übernimmt diese Aufgabe für Funktionen und cmdlets). Im Falle der cmd, ich würde vorschlagen, diese:
```
$param = "echo foo"
& cmd /c $param
```
InformationsquelleAutor JasonMArcher
0

es ist ein Artefakt mit cmd /c, denke ich. läuft
```
$param = "echo foo"
cmd /c $param
```
funktioniert einwandfrei. Es sei denn, Sie haben ein echtes code-Beispiel, es ist ein bisschen schwierig, Probleme zu Schießen.

InformationsquelleAutor Orihara
0

Args anders behandelt werden, wenn Sie enthalten sind in einer Zeichenfolge:
```
PS D:\> echo "1 2 3"
1 2 3
PS D:\> echo 1 2 3
1
2
3
```
Die gleichen Ergebnisse auftreten, wenn Sie verwenden eine variable für die Argumente:
```
PS D:\> $param = "1 2 3"
PS D:\> echo $param
1 2 3
```
Die LÖSUNG ist die Verwendung eines Arrays:
```
PS D:\> $param = @(1,2,3)
PS D:\> echo $param
1
2
3
```
InformationsquelleAutor cmcginty

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.