Powershell Traitement de la Commande (en Passant dans les Variables)

Je suis de la création d'un script Powershell pour déployer un peu de code et une partie de la procédure est l'appel d'une ligne de commande outil de compression appelé RAR.EXE à l'appui de certains dossiers.

Je suis d'essayer de créer dynamiquement les paramètres, puis ont powershell appel de la commande avec les variables, mais je suis en cours d'exécution dans le pétrin. Il ne fonctionne pas...

Exécutez le script suivant et vous devez voir de quoi je parle. Les paramètres passés en tant que variable sont déformés. Si je passe sur toute la commande + paramètres-je obtenir de l'infâme "n'est pas reconnu comme une applet de commande..." message.

Merci pour toute aide!

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

OriginalL'auteur GabeA | 2009-04-30

9

L'appel de l'opérateur "& " est inutile dans ce cas. Il est utilisé pour appeler une commande dans un nouveau champ d'application. Ceci est généralement utilisé pour appeler une commande spécifiée par une chaîne ou un scriptblock. Il a aussi l'autre avantage est que toutes les variables créées en dire un script PowerShell sont supprimées après la commande est terminée et la portée s'en va.

Toutefois, depuis le cmd est un EXE il s'exécute dans un processus complètement différent. FWIW, vous obtenez le même résultat directement à partir de cmd.exe:
```
> cmd "/c echo foo"
foo"
```
De sorte que le supplément de devis sur la fin est un cmd.exe question. En général, vous devez garder à la commande séparée de paramètres lors de PowerShell est en train de faire l'analyse d'invoquer la commande par exemple
```
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
```
L'exception notable ici est que l'Expression de Invoke se comporte comme un "évaluer cette chaîne" de la fonction. À utiliser avec précaution, surtout si l'utilisateur fournit la chaîne. Votre journée pourrait sucer si ils ont fourni "ri C:\ -r".

Dans ce cas, comme d'autres l'ont suggéré, je pouvais tirer de l' /c de la chaîne $param string et le spécifier par exemple:
```
cmd /c $param
```
Ou de l'utilisation Invoke-Expression, mais à utiliser avec précaution. BTW lorsque vous essayez de déboguer des problèmes avec l'envoi d'arguments pour EXE à partir de PowerShell, consultez le echoargs utilitaire en PowerShell Communauté Extensions (http://pscx.codeplex.com). Il est très pratique:
```
49> $param = "/c echo foo"
50> echoargs $param
Arg 0 is </c echo foo>
```
Cela montre que cmd.exe reçoit "/c echo foo" comme un unique argument. "/c" doit être un argument séparé de "l'echo foo" (de la commande à exécuter).

Les tableaux sont aussi bien pour la construction des arguments de ligne de commande; c'est à dire $cmdArgs = @('/c','echo foo'); cmd $cmdArgs

OriginalL'auteur Keith Hill
8

J'ai eu des problèmes avec le & opérateur d'appel dans le passé quand j'invoque exécutable type de commandes comme vous essayez. Pas sûr de comprendre pourquoi. Invoquer-Expression cependant, semble toujours travailler dans ce contexte:
```
PS C:\> $cmd = "cmd /c echo foo"
PS C:\> Invoke-expression $cmd
foo
```
OriginalL'auteur zdan
8

Un autre moyen que j'ai trouvé à faire c'était de créer un tableau d'arguments de la ligne de commande et l'utiliser avec le apersand & appel de l'opérateur. Quelque chose comme ceci:
```
$exe = "cmd";
[Array]$params = "/c", "echo", "foo";

& $exe $params;
```
Il a bien fonctionné pour moi.

J'ai d'abord trouvé cette technique ici:
http://techstumbler.blogspot.com/2009/12/windows-commands-with-arguments-in.html

OriginalL'auteur Tom Hazel
3

Votre dernier exemple, si à défaut parce que "&" traite la chaîne comme un argument, de sorte qu'il est à la recherche d'un programme nommé "cmd /c echo foo.exe". 🙂

Cela fonctionne:
```
& $cmd $params
```
Que pour la citation double question, il semble que cmd n'aime pas les guillemets autour des arguments qui PowerShell met. Il obtient ceci:
```
cmd "/c echo foo"
```
Je pense donc qu'il traite de tout ce qui est après /c de la commande exacte, donc comme suit:
```
echo foo"
```
Certains programmes en ligne de commande et funky, l'analyse de la ligne de commande (c'est pourquoi PowerShell qui lui succède à ce poste pour les fonctions et les applets de commande). Dans le cas de cmd, je dirais ceci:
```
$param = "echo foo"
& cmd /c $param
```
OriginalL'auteur JasonMArcher
0

il s'agit d'un artefact de l'aide cmd /c, je pense. l'exécution de
```
$param = "echo foo"
cmd /c $param
```
fonctionne très bien. Sauf si vous avez un réel exemple de code, c'est un peu difficile de dépanner.

OriginalL'auteur Orihara
0

Les arguments sont traités différemment lorsqu'ils sont contenus dans une Chaîne de caractères:
```
PS D:\> echo "1 2 3"
1 2 3
PS D:\> echo 1 2 3
1
2
3
```
Les mêmes résultats se produire lorsque vous utilisez une variable pour le args:
```
PS D:\> $param = "1 2 3"
PS D:\> echo $param
1 2 3
```
La SOLUTION est d'utiliser un Tableau:
```
PS D:\> $param = @(1,2,3)
PS D:\> echo $param
1
2
3
```
OriginalL'auteur cmcginty

Vous devez vous connecter pour publier un commentaire.