PowerShell Write-Output: Jouw vriendelijke uitvoerbare metgezel – techsyncer

Tot ziens tegen saaie, voorspelbare scriptuitvoer! Met de PowerShell Write-Output cmdlet kun je een vleugje creativiteit en persoonlijkheid toevoegen aan je PowerShell-scripts.

De Write-Output cmdlet is een krachtige tool en een perfecte metgezel voor al je automatiserings- en systeembeheerbehoeften. En in deze tutorial leer je om het maximale potentieel van de Write-Output cmdlet te benutten.

Klaar? Lees verder en ontdek de magie van de Write-Output cmdlet!

Vereisten

Deze tutorial zal een praktische demonstratie zijn. Zorg ervoor dat je een computer hebt met PowerShell geïnstalleerd (bij voorkeur de nieuwste versie). Deze tutorial maakt gebruik van Windows 10 met PowerShell 7 geïnstalleerd.

Objecten naar de console uitvoeren

De PowerShell Write-Output cmdlet schrijft objecten naar de uitvoerstroom en toont de uitvoer van een opdracht of bericht in de console. Maar je zult verrast zijn hoe deze tool de uitvoer betekenisvoller en waardevoller maakt.

In plaats van de uitvoer op de console weer te geven, gebruik je de Write-Output cmdlet om de uitvoer aan te passen. De Write-Output cmdlet kan elk object of gegevenstype uitvoeren, zoals strings, integers, arrays, en zelfs complexe objecten.

Voer onderstaand commando uit om een bericht Hallo, wereld! naar de console uit te voeren.

Write-Output "Hello, World!”

Hieronder zie je de meest basale functie van de Write-Output cmdlet. Maar lees verder om meer te leren over het gebruik van deze cmdlet op een meer gevorderd niveau.<>

Objecten doorgeven aan een ander commando

Naast het weergeven van de uitvoer op de console, kun je de Write-Output opdracht gebruiken om het object naar een ander commando te sturen voor verdere verwerking. Hoe? Door de pijplijnoperator (|) te gebruiken. Pipelining maakt Write-Output een handige en veelzijdige opdracht voor automatisering en systeembeheertaken.

Stel dat je wilt zien welk proces het meeste van je middelen verbruikt, zoals de CPU.

Voer de onderstaande commando’s uit om het volgende te doen:

Haal een lijst op van alle processen (Get-Process) die op je systeem draaien.
Voer de lijst uit naar de pijplijn, die vervolgens wordt doorgegeven aan het Sort-Object-commando. De pijplijnoperator maakt het mogelijk om meerdere commando’s aan elkaar te koppelen en de uitvoer van het ene commando te verwerken als invoer voor een ander commando.
Sorteer de lijst van processen (Sort-Object) op basis van hun CPU-gebruik in aflopende volgorde (-Descending).

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

Merk op dat je elk van de commando’s in deze handleiding in een PowerShell-script kunt plaatsen en kunt uitvoeren.

De gesorteerde lijst wordt weergegeven in de console, zoals hieronder weergegeven.

Objecten uitvoeren met een aangepast formaat

Je hebt het basale uitvoerformaat van de Write-Output-cmdlet gezien, wat prima werkt. Maar als je wilt, kun je ook objecten uitvoeren met een aangepast formaat om een persoonlijk tintje toe te voegen. Een aangepast formaat kan handig zijn wanneer je specifieke objecteigenschappen wilt weergeven of het uiterlijk van de uitvoer wilt aanpassen.

Om een object met een aangepast formaat uit te voeren, zal het Format-Custom-commando samen met de Write-Output-cmdlet het kunstje doen, zoals volgt:

om het aangepaste uitvoerformaat te maken, en leid vervolgens de uitvoer van het Format-Custom-commando naar Write-Output.<>

Voer het onderstaande commando uit, dat geen uitvoer produceert, maar een object (een hashtable) maakt dat drie eigenschappen bevat met de bijbehorende waarden om uit te voeren.

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

Voer nu het onderstaande commando uit om het volgende uit te voeren:

Maak een aangepast formaat (Format-Table) voor de uitvoer (Write-Output) van je hashtable ($object). De eigenschappen Property1, Property2, en Property3 worden ingesteld als kolommen.
Pas de kolombreedtes aan (-AutoSize) om de inhoud weer te geven.

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

Creating a custom format for an object output

Als alternatief kun je de cmdlet Format-List gebruiken met Write-Output om het object weer te geven als een lijst van eigenschapswaardeparen.

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

Outputting the object as a list of property-value pairs

Het Doorgeven van een Collectieobject als Een Enkele Entiteit

Standaard stuurt Write-Output elk element van de collectie afzonderlijk door de pijplijn, een proces dat enumeratie wordt genoemd. Maar je kunt dit gedrag voorkomen door de parameter -NoEnumerate toe te voegen, waardoor het volledige collectieobject als een enkele entiteit wordt doorgegeven.

Om te zien hoe de parameter -NoEnumerate werkt, volg deze stappen:

Voer de onderstaande commando’s uit om het volgende te doen:

Declareer een array van $numbers van één tot drie (1,2,3).

Tel het aantal objecten (Measure-Object) die door de pijplijn worden doorgegeven.
Write-Output $numbers).

Zonder de parameter NoEnumerate retourneert Measure-Object een telling van drie (3), omdat elk element van de array $numbers werd geïndexeerd en individueel door de pijplijn werd doorgegeven.

# Declareert een Array
$numbers = 1,2,3
# Geeft de teller van objecten door die door de pijplijn zijn doorgegeven
Write-Output $numbers | Measure-Object

Voer nu de volgende opdrachten uit om de telling van de objecten doorgegeven via de pijplijn weer te geven.

Maar omdat je de parameter -NoEnumerate hebt toegevoegd, behandelt de Measure-Object cmdlet het object als een enkele entiteit, met een telling van één (1).

# Declareert een Array
$numbers = 1,2,3
# Geeft de teller van objecten weer als een enkele entiteit die via de pijplijn is doorgegeven
Write-Output -NoEnumerate $numbers | Measure-Object

Outputting object count as a single entity

Het omhullen van de Write-Output-opdracht in haakjes (dwz. (Write-Output 1,2,3)) zal enumeratie afdwingen, ongeacht de -NoEnumerate-parameter.

Creëren van een menusysteem en invoervragen

Nog een uitstekend gebruik van de Write-Output-cmdlet is het creëren van een menusysteem met een PowerShell-script dat de gebruiker vraagt om invoer.

Maak een .ps1-bestand met uw voorkeurtekst/code-editor, vul de onderstaande code in en sla het bestand op. U kunt het bestand een willekeurige naam geven, maar de keuze in deze handleiding is myoutput.ps1.

De onderstaande code gebruikt een lus om de gebruiker voortdurend te vragen een optie te kiezen uit een lijst met opties totdat de gebruiker de optie Exit selecteert.

# Initialiseer de variabele $exit op $false
$exit = $false

# Start een lus die blijft lopen totdat de gebruiker de optie "Afsluiten" selecteert
while (!$exit) {

  # Toon een lijst met opties aan de gebruiker
  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"

  # Vraag de gebruiker om een keuze
  $selection = Read-Host

  # Gebruik een schakelopdracht om verschillende codes uit te voeren op basis van de keuze van de gebruiker
  switch ($selection) {
    1 {
      # Als de gebruiker optie 1 selecteert, toon dan een bericht en voer iets uit voor optie 1
      Write-Output "You selected Option 1."
      # Voer iets uit voor optie 1
    }
    2 {
      # Als de gebruiker optie 2 selecteert, toon dan een bericht en voer iets uit voor optie 2
      Write-Output "You selected Option 2."
      # Voer iets uit voor optie 2
    }
    3 {
      # Als de gebruiker optie 3 selecteert, toon dan een bericht en voer iets uit voor optie 3
      Write-Output "You selected Option 3."
      # Voer iets uit voor optie 3
    }
    4 {
      # Als de gebruiker optie 4 selecteert, stel dan $exit in op $true om de lus te verlaten
      $exit = $true
    }
  }
}

Voer nu het script (myoutput.ps1) uit vanuit de werkmap.

./myoutput.ps1

Zoals hieronder getoond, wordt het bericht dat bij uw selectie hoort weergegeven wanneer u opties 1, 2 of 3 kiest. Maar wanneer u optie 4 selecteert, wordt het script beëindigd.

Creating a menu system and input prompts

Weergave van een Splash Screen of Welkomstbericht

Naast het vermelden van opties waaruit de gebruikers kunnen kiezen, kun je met Write-Output ook een opstartscherm of een welkomstbericht weergeven. Fraaie opstartschermen maken een goede indruk (professioneel en gepolijst) op je script.

Vervang de code in je myoutput.ps1 bestand door de onderstaande code, die een opstartscherm (een banner met een welkomstbericht) weergeeft wanneer je je script uitvoert.

Je kunt het opstartscherm aanpassen door de tekst en de opmaak van de banner te wijzigen. Je kunt naar wens extra elementen toevoegen, zoals een logo of tekst, aan het opstartscherm.

# Scherm leegmaken
Clear-Host

# Weergave van het opstartscherm met behulp van Write-Output
Write-Output "##############################################"
Write-Output "#                                            #"
Write-Output "#   Welcome to the SuperScript 3000!         #"
Write-Output "#                                            #"
Write-Output "##############################################"

Voer nu het script uit en bekijk hoe je opstartscherm eruitziet.

./myoutput.ps1

Displaying a splash screen or welcome message

Weergave van een Voortgangsbalk

Bij het uitvoeren van scripts zorgt een voortgangsindicator ervoor dat een gebruiker niet in onzekerheid zit over of het script wordt uitgevoerd of niet. Voortgangsbalken kunnen handig zijn om de voortgang van een langlopend script of operatie aan de gebruiker aan te geven. Gelukkig kun je met behulp van het Write-Output cmdlet een voortgangsbalk maken naar je eigen wens.

Open je myoutput.ps1 bestand en voeg de onderstaande code toe onderaan de bestaande code in het scriptbestand.

De onderstaande code gebruikt een while-lus om door verschillende stappen te itereren. In dit voorbeeld 100 stappen. Elke iteratie van de lus berekent het percentage van de voltooide stappen en geeft een voortgangsbalk weer met behulp van Write-Output.

De voortgangsbalk wordt gemaakt met behulp van een combinatie van de volgende operatoren:

* – Herhaalt een string een gespecificeerd aantal keren
$() – Hiermee kan de output van een expressie worden opgenomen in een string.

De script pauzeert vervolgens (Start-Sleep) gedurende 1 seconde om voortgang te simuleren voordat het doorgaat naar de volgende stap.

# Stel het totale aantal stappen in voor de voortgangsbalk
$steps = 100

# Initialiseer de teller voor de huidige stap
$currentStep = 0

# Start een lus die zal worden uitgevoerd voor het aantal stappen
while ($currentStep -lt $steps) {
  # Verhoog de teller voor de huidige stap
  $currentStep++

  # Bereken het percentage voltooide stappen
  $percentComplete = [int] ($currentStep / $steps * 100)

  # Toon een voortgangsbalk met behulp van Write-Output
  Write-Output "Progress: [$("=" * $percentComplete)$(" " * ($steps-$percentComplete))] $percentComplete% complete"

  # Pauzeer 1 seconde om de voortgang te simuleren
  Start-Sleep -Seconds 1
}

Voer nu het script uit en zie hoe de voortgangsbalk werkt.

./myoutput.ps1

Hieronder zie je het splash-scherm samen met de voortgangsbalk.

Conclusie

In deze tutorial heb je gezien hoe Write-Output eenvoudig objecten, datatypes en aangepaste formaten kan uitvoeren. Bovendien heb je kennisgemaakt met het gebruik van de pipeline-operator om de output naar andere commando’s te sturen voor verdere verwerking.

Of je nu een eenvoudige berichtuitvoer schrijft of complexe automatiseringstaken, Write-Output is een onmisbaar instrument voor het maken van meer informatieve en professionele PowerShell-scripts.

Met deze nieuwe kennis, waarom schrijf je je uitvoer niet naar verschillende bestandstypen, zoals .txt en .xml? Ongeacht het doel, komen kopieën van uitvoer van pas bij het oplossen van problemen met je systeem of applicaties. De Write-Output en de Out-File cmdlet geven je de kracht die je nooit wist dat je nodig had.