Exécution de commandes dans l’interpréteur de commandes

Article
01/20/2024

PowerShell est un shell de ligne de commande et un langage de script utilisé pour l’automatisation. Comme d’autres interpréteurs de commandes, par exemple bash sur Linux ou l’interpréteur de commandes Windows (cmd.exe), PowerShell vous permet d’exécuter toutes les commandes disponibles sur votre système, et pas seulement les commandes PowerShell.

Types de commandes

Il existe trois types de commandes pour chaque interpréteur de commandes dans n’importe quel système d’exploitation :

Les mots clés du langage de l’interpréteur de commandes font partie du langage de script de l’interpréteur de commandes.
- Voici quelques exemples de mots clés bash : if, then, else, elif et fi.
- Voici quelques exemples de mots clés cmd.exe : dir, copy, move, if et echo.
- Voici quelques exemples de mots clés PowerShell : for, foreach, try, catch et trap.
Les mots clés du langage de l’interpréteur de commandes peuvent être utilisés uniquement dans l’environnement d’exécution de l’interpréteur de commandes. Aucun fichier exécutable, externe à l’interpréteur de commandes, ne fournit la fonctionnalité du mot clé.
Les commandes du système d’exploitation natives sont des fichiers exécutables installés dans le système d’exploitation. Les exécutables peuvent être exécutés à partir de n’importe quel interpréteur de ligne de commande, comme PowerShell. Cela inclut les fichiers de script qui peuvent nécessiter d’autres interpréteurs de commandes pour fonctionner correctement. Si vous exécutez par exemple un script de commandes par lot Windows (fichier .cmd) dans PowerShell, PowerShell exécute cmd.exe et transmet le fichier par lot pour l’exécution.
Les commandes spécifiques à l’environnement d’interpréteur de commandes sont des commandes définies dans des fichiers externes qui peuvent uniquement être utilisées dans l’environnement runtime de l’interpréteur de commandes. Il s’agit notamment de scripts et de fonctions, ou de modules spécialement compilés qui ajoutent des commandes au runtime de l’interpréteur de commandes. Les commandes PowerShell sont appelées cmdlets (prononcé « command-lets ») ou applets de commande.

Exécution de commandes natives

Toute commande native peut être exécutée à partir de la ligne de commande PowerShell. En général, vous exécutez la commande exactement comme vous le feriez dans bash ou cmd.exe. L’exemple suivant montre comment exécuter la commande grep dans bash sur Ubuntu Linux.

sdwheeler@circumflex:~$ grep sdwheeler /etc/passwd
sdwheeler:x:1000:1000:,,,:/home/sdwheeler:/bin/bash
sdwheeler@circumflex:~$ pwsh
PowerShell 7.2.6
Copyright (c) Microsoft Corporation.

https://aka.ms/powershell
Type 'help' to get help.

Après avoir démarré PowerShell sur Ubuntu, vous pouvez exécuter la même commande à partir de la ligne de commande PowerShell :

PS /home/sdwheeler> grep sdwheeler /etc/passwd
sdwheeler:x:1000:1000:,,,:/home/sdwheeler:/bin/bash

Transfert d’arguments à des commandes natives

La plupart des interpréteurs de commandes incluent des fonctionnalités permettant d’utiliser des variables, d’évaluer des expressions et de gérer des chaînes. Toutefois, chaque interpréteur de commandes effectue ces actions différemment. Dans PowerShell, tous les paramètres commencent par un trait d’union (-). Dans cmd.exe, la plupart des paramètres utilisent un caractère de barre oblique (/). D’autres outils en ligne de commande n’ont pas de caractère spécial pour les paramètres.

Chaque interpréteur de commandes a sa propre façon de gérer et d’évaluer les chaînes dans la ligne de commande. Quand vous exécutez des commandes natives dans PowerShell qui s’attend à ce que les chaînes soient entre guillemets d’une manière spécifique, vous devez peut-être ajuster la façon de transmettre ces chaînes.

Pour plus d’informations, consultez les articles suivants :

PowerShell 7.2 a introduit une nouvelle fonctionnalité expérimentale PSnativeCommandArgumentPassing permettant d’améliorer la gestion des commandes natives. Pour plus d’informations, consultez PSnativeCommandArgumentPassing.

Gestion de la sortie et des erreurs

PowerShell a également plusieurs flux de sortie supplémentaires par rapport aux autres interpréteurs de commandes. Les interpréteurs de commandes bash et cmd.exe ont stdout et stderr. PowerShell dispose de six flux de sortie. Pour plus d’informations, consultez about_Redirection et about_Output_Streams.

La sortie envoyée à stdout par une commande native est envoyée en général au flux Succès dans PowerShell. La sortie envoyée à stderr par une commande native est envoyée au flux Erreur dans PowerShell.

Quand une commande native a un code de sortie différent de zéro, $? a la valeur $false. Si le code de sortie est égal à zéro, $? a la valeur $true.

Toutefois, cela a changé dans PowerShell 7.2. Les enregistrements d’erreurs redirigés à partir de commandes natives, par exemple lors de l’utilisation d’opérateurs de redirection (2>&1), ne sont pas écrits dans la variable $Error de PowerShell et la variable de préférence $ErrorActionPreference n’affecte pas la sortie redirigée.

De nombreuses commandes natives écrivent dans stderr en tant que flux de remplacement pour obtenir des informations supplémentaires. Ce comportement peut entraîner une confusion dans PowerShell lors de l’examen des erreurs et les informations de sortie supplémentaires peuvent être perdues si $ErrorActionPreference est défini sur un état qui désactive la sortie.

PowerShell 7.3 a ajouté une nouvelle fonctionnalité expérimentale PSnativeCommandErrorActionPreference qui vous permet de contrôler si la sortie vers stderr doit être traitée comme une erreur. Pour plus d’informations, consultez PSnativeCommandErrorActionPreference.

Exécution de commandes PowerShell

Comme indiqué précédemment, les commandes PowerShell sont appelées cmdlets. Les cmdlets sont collectées dans des modules PowerShell qui peuvent être chargés à la demande. Les cmdlets peuvent être écrites dans n’importe quel langage .NET compilé ou dans le langage de script PowerShell lui-même.

Commandes PowerShell qui exécutent d’autres commandes

L’opérateur d’appel PowerShell (&) vous permet d’exécuter des commandes stockées dans des variables et représentées par des chaînes ou des blocs de script. Vous pouvez l’utiliser pour exécuter n’importe quelle commande native ou commande PowerShell. Cela est utile dans un script quand vous devez construire de manière dynamique les paramètres de ligne de commande pour une commande native. Pour plus d’informations, consultez l’appel de fonction.

La cmdlet Start-Process permet d’exécuter des commandes natives, mais elle doit être utilisée uniquement quand vous devez contrôler la façon dont la commande est exécutée. La cmdlet présente des paramètres pour prendre en charge les scénarios suivants :

Exécuter une commande à l’aide de différentes informations d’identification
Masquer la fenêtre de console créée par le nouveau processus
Rediriger les flux stdin, stdout et stderr
Utiliser un répertoire de travail différent pour la commande

L’exemple suivant exécute la commande native sort.exe avec des flux d’entrée et de sortie redirigés.

$processOptions = @{
    FilePath = "sort.exe"
    RedirectStandardInput = "TestSort.txt"
    RedirectStandardOutput = "Sorted.txt"
    RedirectStandardError = "SortError.txt"
    UseNewEnvironment = $true
}
Start-Process @processOptions

Pour plus d’informations, consultez Start-Process.

Sur Windows, la cmdlet Invoke-Item effectue l’action par défaut pour l’élément spécifié. Elle exécute par exemple un fichier exécutable ou ouvre un fichier de document à l’aide de l’application associée au type de fichier de document. L’action par défaut dépend du type d’élément. Elle est résolue par le fournisseur Windows PowerShell qui fournit l’accès à l’élément.

L’exemple suivant ouvre le référentiel de code source PowerShell dans votre navigateur web par défaut.

Invoke-Item https://github.com/PowerShell/PowerShell

Pour plus d’informations, voir Invoke-Item.