about_Redirection

Article
11/29/2023

Description courte

Explique comment rediriger la sortie de PowerShell vers des fichiers texte.

Description longue

Par défaut, PowerShell envoie la sortie à l’hôte PowerShell. En règle générale, il s’agit de l’application console. Toutefois, vous pouvez rediriger la sortie vers un fichier texte et vous pouvez rediriger la sortie d’erreur vers le flux de sortie standard.

Vous pouvez utiliser les méthodes suivantes pour rediriger la sortie :

Utilisez l’applet de commande, qui envoie la Out-File sortie de commande à un fichier texte. En règle générale, vous utilisez l’applet Out-File de commande lorsque vous devez utiliser ses paramètres, tels que les paramètres , ForceWidthou NoClobber les Encodingparamètres.
Utilisez l’applet de commande, qui envoie la Tee-Object sortie de commande à un fichier texte, puis l’envoie au pipeline.
Utilisez les opérateurs de redirection PowerShell. La redirection de la sortie d’une commande PowerShell (applet de commande, fonction, script) à l’aide de l’opérateur de redirection (>) est fonctionnellement équivalente à la piping vers Out-File sans paramètres supplémentaires. PowerShell 7.4 a modifié le comportement de l’opérateur de redirection lorsqu’il est utilisé pour rediriger le flux stdout d’une commande native.

Pour plus d’informations sur les flux, consultez about_Output_Flux.

Flux de sortie redirectables

PowerShell prend en charge la redirection des flux de sortie suivants.

Flux #	Description	Introduite dans	Écrire une applet de commande
1	Flux de réussite	PowerShell 2.0	`Write-Output`
2	Flux d’erreurs	PowerShell 2.0	`Write-Error`
3	Flux d’avertissement	PowerShell 3.0	`Write-Warning`
4	Flux détaillé	PowerShell 3.0	`Write-Verbose`
5	Déboguer le flux	PowerShell 3.0	`Write-Debug`
6	Flux d’informations	PowerShell 5.0	`Write-Information`, `Write-Host`
*	Tous les Flux	PowerShell 3.0

Il existe également un flux de progression dans PowerShell, mais il ne prend pas en charge la redirection.

Important

Les flux réussite et erreur sont similaires aux flux stdout et stderr d’autres interpréteurs de commandes. Toutefois, stdin n’est pas connecté au pipeline PowerShell pour l’entrée.

Opérateurs de redirection PowerShell

Les opérateurs de redirection PowerShell sont les suivants, où n représente le numéro de flux. Le flux de réussite ( 1 ) est la valeur par défaut si aucun flux n’est spécifié.

Opérateur	Description	Syntaxe
`>`	Envoyez le flux spécifié à un fichier.	`n>`
`>>`	Ajoutez le flux spécifié à un fichier.	`n>>`
`>&1`	Redirige le flux spécifié vers le flux de réussite.	`n>&1`

Remarque

Contrairement à certains interpréteurs de commandes Unix, vous ne pouvez rediriger que d’autres flux vers le flux de réussite .

Redirection de la sortie à partir de commandes natives

PowerShell 7.4 a modifié le comportement des opérateurs de redirection lorsqu’ils sont utilisés pour rediriger le flux stdout d’une commande native. Les opérateurs de redirection conservent désormais les données de flux d’octets lors de la redirection de la sortie à partir d’une commande native. PowerShell n’interprète pas les données redirigées ou n’ajoute aucune mise en forme supplémentaire. Pour plus d’informations, consultez l’exemple n° 7.

Exemples

Exemple 1 : Rediriger les erreurs et la sortie vers un fichier

Cet exemple s’exécute dir sur un élément qui réussit et un élément qui échoue.

dir C:\, fakepath 2>&1 > .\dir.log

Il utilise 2>&1 pour rediriger le flux d’erreur vers le flux de réussite et > envoyer le flux de réussite résultant à un fichier appelédir.log

Exemple 2 : Envoyer toutes les données de flux de réussite à un fichier

Cet exemple envoie toutes les données de flux de réussite à un fichier appelé script.log.

.\script.ps1 > script.log

Exemple 3 : Envoyer des flux de réussite, d’avertissement et d’erreur à un fichier

Cet exemple montre comment combiner des opérateurs de redirection pour obtenir un résultat souhaité.

&{
   Write-Warning "hello"
   Write-Error "hello"
   Write-Output "hi"
} 3>&1 2>&1 > C:\Temp\redirection.log

3>&1redirige le flux d’avertissement vers le flux de réussite.
2>&1 redirige le flux d’erreur vers le flux de réussite (qui inclut également toutes les données de flux d’avertissement )
> redirige le flux de réussite (qui contient désormais des flux d’avertissement et d’erreur ) vers un fichier appelé C:\temp\redirection.log.

Exemple 4 : Rediriger tous les flux vers un fichier

Cet exemple envoie toutes les sorties de flux d’un script appelé script.ps1 à un fichier appelé script.log.

.\script.ps1 *> script.log

Exemple 5 : Supprimer toutes les données de flux d’informations et d’hôte d’écriture

Cet exemple supprime toutes les données de flux d’informations. Pour en savoir plus sur les applets de commande de flux d’informations, consultez Write-Host et Write-Information

&{
   Write-Host "Hello"
   Write-Information "Hello" -InformationAction Continue
} 6> $null

Exemple 6 : Afficher l’effet des préférences d’action

Les variables et paramètres de préférence d’action peuvent modifier ce qui est écrit dans un flux particulier. Le script de cet exemple montre comment la valeur d’impact $ErrorActionPreference sur ce qui est écrit dans le flux d’erreur .

$ErrorActionPreference = 'Continue'
$ErrorActionPreference > log.txt
get-item /not-here 2>&1 >> log.txt

$ErrorActionPreference = 'SilentlyContinue'
$ErrorActionPreference >> log.txt
get-item /not-here 2>&1 >> log.txt

$ErrorActionPreference = 'Stop'
$ErrorActionPreference >> log.txt
Try {
    get-item /not-here 2>&1 >> log.txt
}
catch {
    "`tError caught!" >> log.txt
}
$ErrorActionPreference = 'Ignore'
$ErrorActionPreference >> log.txt
get-item /not-here 2>&1 >> log.txt

$ErrorActionPreference = 'Inquire'
$ErrorActionPreference >> log.txt
get-item /not-here 2>&1 >> log.txt

$ErrorActionPreference = 'Continue'

Lorsque nous exécutons ce script, nous sommes invités quand $ErrorActionPreference est défini sur Inquire.

PS C:\temp> .\test.ps1

Confirm
Can't find path 'C:\not-here' because it doesn't exist.
[Y] Yes  [A] Yes to All  [H] Halt Command  [S] Suspend  [?] Help (default is "Y"): H
Get-Item: C:\temp\test.ps1:23
Line |
  23 |  get-item /not-here 2>&1 >> log.txt
     |  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     | The running command stopped because the user selected the Stop option.

Lorsque nous examinons le fichier journal, nous voyons les éléments suivants :

PS C:\temp> Get-Content .\log.txt
Continue

Get-Item: C:\temp\test.ps1:3
Line |
   3 |  get-item /not-here 2>&1 >> log.txt
     |  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     | Cannot find path 'C:\not-here' because it does not exist.

SilentlyContinue
Stop
    Error caught!
Ignore
Inquire

Exemple 7 : Redirection de données binaires à partir d’une commande native

À compter de PowerShell 7.4, PowerShell conserve les données de flux d’octets lors de la redirection du flux stdout d’une commande native vers un fichier ou lors de la redirection des données de flux d’octets vers le flux stdin d’une commande native.

Par exemple, à l’aide de la commande native curl, vous pouvez télécharger un fichier binaire et l’enregistrer sur le disque à l’aide de la redirection.

$uri = 'https://github.com/PowerShell/PowerShell/releases/download/v7.3.7/powershell-7.3.7-linux-arm64.tar.gz'

# native command redirected to a file
curl -s -L $uri > powershell.tar.gz

Vous pouvez également diriger les données de flux d’octets vers le flux stdin d’une autre commande native. L’exemple suivant télécharge un fichier TAR compressé à l’aide de curl. Les données du fichier téléchargé sont diffusées en continu vers la commande tar pour extraire le contenu de l’archive.

# native command output piped to a native command
curl -s -L $uri | tar -xzvf - -C .

Vous pouvez également diriger la sortie de flux d’octets d’une commande PowerShell vers l’entrée de la commande native. Les exemples suivants utilisent Invoke-WebRequest pour télécharger le même fichier TAR que l’exemple précédent.

# byte stream piped to a native command
(Invoke-WebRequest $uri).Content | tar -xzvf - -C .

# bytes piped to a native command (all at once as byte[])
,(Invoke-WebRequest $uri).Content | tar -xzvf - -C .

Cette fonctionnalité ne prend pas en charge les données de flux d’octets lors de la redirection de la sortie stderr vers stdout. Lorsque vous combinez les flux stderr et stdout, les flux combinés sont traités comme des données de chaîne.

Notes

Les opérateurs de redirection qui n’ajoutent pas de données (> et n>) remplacent le contenu actuel du fichier spécifié sans avertissement.

Toutefois, si le fichier est un fichier en lecture seule, masqué ou système, la redirection échoue. Les opérateurs de redirection d’ajout (>> et n>>) n’écrivent pas dans un fichier en lecture seule, mais ils ajoutent du contenu à un fichier système ou masqué.

Pour forcer la redirection du contenu vers un fichier système, masqué ou en lecture seule, utilisez l’applet Out-File de commande avec son Force paramètre.

Lorsque vous écrivez dans des fichiers, les opérateurs de redirection utilisent UTF8NoBOM l’encodage. Si le fichier a un encodage différent, la sortie peut ne pas être mise en forme correctement. Pour écrire dans des fichiers avec un autre encodage, utilisez l’applet Out-File de commande avec son Encoding paramètre.

Largeur de la sortie lors de l’écriture dans un fichier

Lorsque vous écrivez dans un fichier à l’aide de Out-File l’un ou des opérateurs de redirection, PowerShell met en forme la sortie de la table vers le fichier en fonction de la largeur de la console dans laquelle elle s’exécute. Par exemple, lors de la journalisation de la sortie de table dans un fichier à l’aide d’une commande comme Get-ChildItem Env:\Path > path.log sur un système où la largeur de la console est définie sur 80 colonnes, la sortie du fichier est tronquée à 80 caractères :

Name                         Value
----                         -----
Path                         C:\Program Files\PowerShell\7;C:\WINDOWS…

Étant donné que la largeur de la console peut être définie arbitrairement sur les systèmes sur lesquels votre script est exécuté, vous préférerez peut-être que la sortie de table de format PowerShell aux fichiers en fonction d’une largeur que vous spécifiez à la place.

L’applet Out-File de commande fournit un paramètre Width qui vous permet de définir la largeur souhaitée pour la sortie de la table. Au lieu d’avoir à ajouter -Width 2000 partout où vous appelez Out-File, vous pouvez utiliser la $PSDefaultParameterValues variable pour définir cette valeur pour toutes les utilisations de l’applet Out-File de commande dans un script. Et étant donné que les opérateurs de redirection (> et >>) sont effectivement des alias pour Out-File, la définition du Out-File:Width paramètre pour l’ensemble du script impacte également la largeur de mise en forme pour les opérateurs de redirection. Placez la commande suivante en haut de votre script pour définir Out-File:Width l’ensemble du script :

$PSDefaultParameterValues['out-file:width'] = 2000

L’augmentation de la largeur de sortie augmente la consommation de mémoire lors de la journalisation de la sortie mise en forme de la table. Si vous journaliser un grand nombre de données tabulaires dans un fichier et que vous savez que vous pouvez obtenir avec une largeur plus petite, utilisez la plus petite largeur.

Dans certains cas, comme Get-Service la sortie, afin d’utiliser la largeur supplémentaire, vous devez diriger la sortie Format-Table -AutoSize avant de sortir dans le fichier.

$PSDefaultParameterValues['out-file:width'] = 2000
Get-Service | Format-Table -AutoSize > services.log

Pour plus d’informations sur $PSDefaultParameterValues, consultez about_Preference_Variables.

Confusion potentielle avec les opérateurs de comparaison

L’opérateur > ne doit pas être confondu avec l’opérateur De comparaison supérieur à égal (souvent indiqué comme > dans d’autres langages de programmation).

Selon les objets comparés, l’utilisation > de la sortie peut sembler correcte (car 36 n’est pas supérieur à 42).

PS> if (36 > 42) { "true" } else { "false" }
false

Toutefois, un case activée du système de fichiers local peut voir qu’un fichier appelé 42 a été écrit, avec le contenu 36.

PS> dir

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
------          1/02/20  10:10 am              3 42

PS> cat 42
36

La tentative d’utilisation de la comparaison < inverse (inférieure à), génère une erreur système :

PS> if (36 < 42) { "true" } else { "false" }
ParserError:
Line |
   1 |  if (36 < 42) { "true" } else { "false" }
     |         ~
     | The '<' operator is reserved for future use.

Si la comparaison numérique est l’opération requise et -lt-gt doit être utilisée. Pour plus d’informations, consultez l’opérateur -gt dans about_Comparison_Operators.