PowerShell Write-Output: Votre compagnon amical pour les sorties – techsyncer

Adieu à la sortie de script terne et prévisible ! Avec la cmdlet PowerShell Write-Output, vous pouvez ajouter une touche de créativité et de personnalité à vos scripts PowerShell.

La cmdlet Write-Output est un outil puissant et un compagnon parfait pour tous vos besoins en automatisation et gestion système. Et dans ce tutoriel, vous apprendrez à maximiser le potentiel de la cmdlet Write-Output.

Prêt ? Continuez à lire et découvrez la magie de la cmdlet Write-Output !

Prérequis

Ce tutoriel sera une démonstration pratique. Pour suivre, assurez-vous d’avoir un ordinateur avec PowerShell installé (de préférence la dernière version). Ce tutoriel utilise Windows 10 avec PowerShell 7 installé.

Sortie d’objets dans la console

La cmdlet PowerShell Write-Output écrit des objets dans le flux de sortie et affiche la sortie d’une commande ou d’un message dans la console. Mais vous serez surpris de voir comment cet outil rend la sortie plus significative et précieuse.

Au lieu d’afficher la sortie dans la console, utilisez la cmdlet Write-Output pour personnaliser la sortie. La cmdlet Write-Output peut produire n’importe quel objet ou type de données, tel que des chaînes de caractères, des entiers, des tableaux, voire même des objets complexes.

Exécutez la commande ci-dessous pour afficher un message Bonjour, tout le monde ! dans la console.

Write-Output "Hello, World!”

Ci-dessous, vous pouvez voir la fonction la plus basique de la cmdlet Write-Output. Mais continuez à lire pour découvrir des utilisations intermédiaires à avancées de cette cmdlet.<>

Transfert d’objets vers une autre commande

En plus d’afficher la sortie dans la console, vous pouvez utiliser la commande Write-Output pour envoyer l’objet à une autre commande pour un traitement ultérieur. Comment ? En utilisant l’opérateur de pipeline (|). Le passage par pipeline rend la commande Write-Output pratique et polyvalente pour l’automatisation et les tâches de gestion système.

Supposons que vous souhaitiez voir quel processus consomme la majeure partie de vos ressources, comme le processeur.

Exécutez les commandes ci-dessous pour effectuer ce qui suit :

Récupérez une liste de tous les processus (Get-Process) en cours d’exécution sur votre système.
Sortez la liste vers le pipeline, qui est ensuite transmise à la commande Sort-Object. L’opérateur de pipeline vous permet d’enchaîner plusieurs commandes ensemble et de traiter la sortie d’une commande comme l’entrée d’une autre.
Triez la liste des processus (Sort-Object) par leur utilisation de CPU dans l’ordre -Descending.

$processes = Get-Process
Write-Output $processes | Sort-Object CPU -Descending

Notez que vous pouvez mettre n’importe laquelle des commandes de ce tutoriel dans un script PowerShell et l’exécuter.

La liste triée est affichée dans la console, comme indiqué ci-dessous.

Sortie d’objets avec un format personnalisé

Vous avez vu le format de sortie de base de la commande Write-Output, qui fonctionne bien. Mais si vous le souhaitez, vous pouvez également afficher des objets avec un format personnalisé pour ajouter une touche personnelle. Un format personnalisé peut être utile lorsque vous souhaitez afficher des propriétés d’objet spécifiques ou personnaliser l’apparence de la sortie.

Pour afficher un objet avec un format personnalisé, la commande Format-Custom avec la commande Write-Output fera l’affaire, comme suit :

pour créer le format de sortie personnalisé, puis rediriger la sortie de la commande Format-Custom vers Write-Output.<>

Exécutez la commande ci-dessous, qui ne produit pas de sortie, mais crée un objet (un hashtable) contenant trois propriétés avec les valeurs correspondantes à afficher.

$object = [pscustomobject]@{
Property1 = "Value1"
Property2 = "Value2"
Property3 = "Value3"
}

Maintenant, exécutez la commande ci-dessous pour effectuer ce qui suit:

Créez un format personnalisé (Format-Table) pour la sortie (Write-Output) de votre hashtable ($object). Les propriétés Property1, Property2 et Property3 sont définies comme colonnes.
Ajustez les largeurs des colonnes (-AutoSize) pour s’adapter au contenu.

$object | Format-Table -Property Property1, Property2, Property3 -AutoSize | Write-Output

Creating a custom format for an object output

Alternativement, vous pouvez utiliser le cmdlet Format-List avec Write-Output pour afficher l’objet sous forme de liste de paires propriété-valeur.

$object | Format-List -Property Property1, Property2, Property3 | Write-Output

Outputting the object as a list of property-value pairs

Passer un objet collection en tant qu’entité unique

Par défaut, Write-Output envoie chaque élément de la collection séparément à travers le pipeline, un processus appelé énumération. Mais vous pouvez empêcher ce comportement en ajoutant le paramètre -NoEnumerate, en passant l’objet de la collection entière en tant qu’entité unique.

Pour voir comment fonctionne le paramètre -NoEnumerate, suivez ces étapes:

Exécutez les commandes ci-dessous pour effectuer ce qui suit:

Déclarez un tableau de $numbers de un à trois (1,2,3).

Comptez le nombre d’objets (Measure-Object) passés à travers le pipeline.
Affichez la mesure de l’objet (Write-Output $numbers).

Sans le paramètre NoEnumerate, Measure-Object renvoie un décompte de trois (3), car chaque élément du tableau $numbers a été énuméré et transmis individuellement à travers le pipeline.

# Déclare un tableau
$numbers = 1,2,3
# Affiche le nombre d'objets transmis à travers le pipeline
Write-Output $numbers | Measure-Object

Maintenant, exécutez les commandes suivantes pour afficher le nombre d’objets transmis à travers le pipeline.

Mais comme vous avez ajouté le paramètre -NoEnumerate, la commande Measure-Object traite l’objet comme une seule entité, renvoyant un décompte de un (1).

# Déclare un tableau
$numbers = 1,2,3
# Affiche le nombre d'objets en tant qu'entité unique transmise à travers le pipeline
Write-Output -NoEnumerate $numbers | Measure-Object

Outputting object count as a single entity

Encadrer la commande Write-Output entre parenthèses (c’est-à-dire, (Write-Output 1,2,3)) forcera l’énumération à se produire indépendamment du paramètre -NoEnumerate.

Création d’un système de menu et de invites de saisie

Une autre excellente utilisation de la commande Write-Output est la création d’un système de menu avec un script PowerShell qui invite l’utilisateur à saisir des données.

Créez un fichier .ps1 avec votre éditeur de texte/code préféré, remplissez le code ci-dessous et enregistrez le fichier. Vous pouvez nommer le fichier comme vous le souhaitez, mais le choix de ce tutoriel est monfichier.ps1.

Le code ci-dessous utilise une boucle pour demander continuellement à l’utilisateur de sélectionner une option dans une liste d’options jusqu’à ce que l’utilisateur sélectionne l’option Exit.

# Initialiser la variable $exit à $false
$exit = $false

# Démarrer une boucle qui s'exécutera jusqu'à ce que l'utilisateur sélectionne l'option "Quitter"
while (!$exit) {

  # Afficher une liste d'options à l'utilisateur
  Write-Output "Please select from the following options:"
  Write-Output "1. Option 1"
  Write-Output "2. Option 2"
  Write-Output "3. Option 3"
  Write-Output "4. Exit"

  # Demander à l'utilisateur de faire un choix
  $selection = Read-Host

  # Utiliser une instruction switch pour exécuter différents codes en fonction du choix de l'utilisateur
  switch ($selection) {
    1 {
      # Si l'utilisateur sélectionne l'option 1, afficher un message et effectuer quelque chose pour l'option 1
      Write-Output "You selected Option 1."
      # Effectuer quelque chose pour l'option 1
    }
    2 {
      # Si l'utilisateur sélectionne l'option 2, afficher un message et effectuer quelque chose pour l'option 2
      Write-Output "You selected Option 2."
      # Effectuer quelque chose pour l'option 2
    }
    3 {
      # Si l'utilisateur sélectionne l'option 3, afficher un message et effectuer quelque chose pour l'option 3
      Write-Output "You selected Option 3."
      # Effectuer quelque chose pour l'option 3
    }
    4 {
      # Si l'utilisateur sélectionne l'option 4, définir $exit à $true pour sortir de la boucle
      $exit = $true
    }
  }
}

Exécutez maintenant le script (myoutput.ps1) depuis le répertoire de travail.

./myoutput.ps1

Comme le montre l’exemple ci-dessous, le message associé à votre choix est affiché lorsque vous choisissez les options 1, 2, ou 3. Mais lorsque vous sélectionnez l’option 4, le script se termine.

Creating a menu system and input prompts

Affichage d’un écran de démarrage ou d’un message de bienvenue

Outre la liste des options que les utilisateurs peuvent choisir, avec Write-Output, vous pouvez également afficher un écran de démarrage ou un message de bienvenue. Les écrans de démarrage sophistiqués laissent une bonne impression (professionnelle et soignée) sur votre script.

Remplacez le code dans votre fichier myoutput.ps1 par celui ci-dessous, qui affiche un écran de démarrage (une bannière d’un message de bienvenue) lorsque vous exécutez votre script.

Vous pouvez personnaliser l’écran de démarrage en modifiant le texte et la mise en forme de la bannière. Vous pouvez ajouter des éléments supplémentaires, comme un logo ou du texte, à l’écran de démarrage selon vos besoins.

# Effacer l'écran
Clear-Host

# Afficher l'écran de démarrage à l'aide de Write-Output
Write-Output "##############################################"
Write-Output "#                                            #"
Write-Output "#   Welcome to the SuperScript 3000!         #"
Write-Output "#                                            #"
Write-Output "##############################################"

Maintenant, exécutez le script et voyez comment votre écran de démarrage se présente.

./myoutput.ps1

Displaying a splash screen or welcome message

Affichage d’une barre de progression

Lors de l’exécution de scripts, un indicateur de progression élimine l’anxiété de l’utilisateur quant au fonctionnement ou non du script. Les barres de progression peuvent être utiles pour indiquer à l’utilisateur l’avancement d’un script ou d’une opération longue. Heureusement, avec la cmdlet Write-Output, vous pouvez créer une barre de progression selon vos préférences.

Ouvrez votre fichier myoutput.ps1, et ajoutez le code ci-dessous à la fin de celui déjà existant dans le fichier du script.

Le code ci-dessous utilise une boucle while pour itérer à travers plusieurs étapes. Dans cet exemple, 100 étapes. Chaque itération de la boucle calcule le pourcentage d’étapes effectuées et affiche une barre de progression à l’aide de Write-Output.

La barre de progression est créée en utilisant une combinaison des opérateurs suivants :

* – Répète une chaîne un nombre spécifié de fois
$() – Permet à la sortie d’une expression d’être incluse dans une chaîne.

Le script met ensuite en pause (Start-Sleep) pendant 1 seconde pour simuler la progression avant de passer à l’étape suivante.

# Définissez le nombre total d'étapes pour la barre de progression
$steps = 100

# Initialisez le compteur pour l'étape actuelle
$currentStep = 0

# Démarrez une boucle qui s'exécutera pour le nombre d'étapes
while ($currentStep -lt $steps) {
  # Incrémentez le compteur d'étape actuel
  $currentStep++

  # Calculez le pourcentage d'étapes complétées
  $percentComplete = [int] ($currentStep / $steps * 100)

  # Affichez une barre de progression en utilisant Write-Output
  Write-Output "Progress: [$("=" * $percentComplete)$(" " * ($steps-$percentComplete))] $percentComplete% complete"

  # Pause pendant 1 seconde pour simuler la progression
  Start-Sleep -Seconds 1
}

Maintenant, exécutez le script et voyez comment la barre de progression fonctionne.

./myoutput.ps1

Vous pouvez voir ci-dessous l’écran de démarrage ainsi que la barre de progression.

Conclusion

Dans ce tutoriel, vous avez vu comment Write-Output peut facilement produire des objets, des types de données, et des formats personnalisés. De plus, vous avez abordé l’utilisation de l’opérateur de pipeline pour envoyer la sortie vers d’autres commandes pour un traitement ultérieur.

Que vous rédigiez un simple message de sortie ou que vous réalisiez des tâches d’automatisation complexes, Write-Output est un outil indispensable pour créer des scripts PowerShell plus informatifs et professionnels.

Avec cette connaissance nouvellement acquise, pourquoi ne pas écrire vos sorties dans différents types de fichiers, tels que .txt et .xml? Peu importe l’intention, les copies de sortie sont utiles pour dépanner les problèmes de votre système ou de vos applications. Le Write-Output et la commande Out-File vous offrent le pouvoir dont vous ne saviez pas que vous aviez besoin.