Wie man Befehle in PowerShell auf mehrere Zeilen aufteilt

1. Windows PowerShell Mehrzeilenbefehl
2. Lange Zeilen von Code mit spezifischen Operatoren aufteilen
3. Schlussfolgerung

Lesbarer Code kommuniziert sehr einfach seinen Zweck der Funktionalität an die Benutzer. Variablennamen und Methodennamen sollten ordentliche Namenskonventionen für die Lesbarkeit des Codes haben.

Weitere Attribute, die zur Lesbarkeit des Codes beitragen, sind konsistente Einrückung und Formatierungsstil. Die Windows PowerShell Mehrzeilenkommando hilft, lange Befehlszeilen in mehrere Anweisungen für die Lesbarkeit zu unterteilen.

In Windows PowerShell können Mehrzeilenbefehle einfach erstellt werden, indem das Backtick-Zeichen verwendet wird, um lange oder einzeilige Befehle in mehrzeilige Anweisungen zu unterteilen.

Das Backtick-Zeichen wird als eine Art Escape-Zeichen verwendet. Es entf escapes das Zeilenumbruch-Zeichen und führt zu einer Zeilenfortsetzung.

Dieser Artikel erklärt die Bedeutung von Windows PowerShell Mehrzeilenbefehlen, um lange Befehle über mehrere Zeilen zu unterteilen.

Windows PowerShell Mehrzeilenbefehl

Um einen langen Befehl in mehrere Zeilen zu unterteilen, verwenden Sie das Backtick-Zeichen, um ihn in mehrere Zeilen zu brechen.

Zum Beispiel möchten wir die Informationen zum freien Speicherplatz auf dem lokalen Computer abrufen. Leider ist das Skript, um diese spezifischen Informationen abzurufen, ein erweiterter Befehl, der es schwierig macht, zu lesen und zu verwalten.

Beispielcode:

Get-WmiObject -Class win32_logicaldisk | Format-Table DeviceId, MediaType, @{n = "Size"; e = { [math]::Round($_.Size / 1GB, 2) } }, @{n = "FreeSpace"; e = { [math]::Round($_.FreeSpace / 1GB, 2) } }

Es mag so aussehen, als wäre die Syntax in diesem Artikel aufgeteilt, aber wenn sie in die Befehlszeilenschnittstelle kopiert wird, ist das obige Beispiel ein sehr langes Einzeilen-Skript.

Wir können lange Befehle leicht in mehrere Zeilen unterteilen, indem wir Windows PowerShell Backtick-Zeichen für einen Zeilenumbruch in einem bestimmten Befehl verwenden.

Beispielcode:

Get-WmiObject -Class win32_logicaldisk `
| Format-Table DeviceId, `MediaType, @{n = "Size"; e = { [Math]::Round($_.Size / 1GB, 2) } }, `
@{n = "FreeSpace"; e = { [Math]::Round($_.FreeSpace / 1GB, 2) } }

In unserem Code verwenden wir Backticks als Zeichen für Zeilenfortsetzungen in PowerShell, um die Lesbarkeit zu verbessern, indem wir einen langen Befehl über mehrere Zeilen aufteilen. Wir beginnen mit Get-WmiObject -Class win32_logicaldisk, um Informationen über logische Laufwerke im System abzurufen.

Das Backtick-Zeichen am Ende dieser Zeile zeigt an, dass der Befehl in der nächsten Zeile fortgesetzt wird. Dann leiten wir (|) die Ausgabe an Format-Table weiter, ein Cmdlet, das die Ausgabe als Tabelle formatiert.

Hier wählen wir speziell die Anzeige von DeviceId und MediaType. Für die Eigenschaften Size und FreeSpace verwenden wir berechnete Felder (angegeben durch die Syntax @{n = "Name"; e = { Ausdruck }}).

Innerhalb dieser berechneten Felder verwenden wir wieder Backticks für die Zeilenfortsetzung. Die Ausdrücke verwenden [Math]::Round($*.Size / 1GB, 2) und [Math]::Round($*.FreeSpace / 1GB, 2), um die Größe und den freien Speicherplatz von Bytes in Gigabytes zu konvertieren und auf zwei Dezimalstellen zu runden.

Durch die Aufteilung dieses komplexen Befehls mit Backticks machen wir das Skript verwaltbarer und dessen Absicht klarer, was sowohl Wartung als auch Lesbarkeit unterstützt.

Ausgabe:

Die Code-Struktur ist in Windows PowerShell mithilfe des Mehrzeilenbefehls leicht lesbar und einfach zu warten. Das Backtick-Zeichen wird jedoch normalerweise nicht empfohlen, da das Zeichen schwer zu lesen ist und Fehler einladen kann.

Daher haben wir eine alternative Methode, um lange Zeilen von Code zu unterbrechen.

Lange Zeilen von Code mit spezifischen Operatoren aufteilen

PowerShell ist intuitiv, wenn es um Zeilenfortsetzung geht. Bestimmte Operatoren und Syntaxstrukturen signalisieren dem Interpreter von Natur aus, dass ein Befehl mehrere Zeilen umfasst.

Dies ist besonders nützlich in komplexen Skripten, bei denen die Lesbarkeit erheblichen Einfluss auf die Wartungs- und Verständnisfähigkeit haben kann.

Lange Zeilen von Code mit Pipeline (|) aufteilen

Normalerweise erhalten Sie eine automatische Zeilenfortsetzung, wenn ein Befehl syntaktisch zu diesem Zeitpunkt nicht abgeschlossen werden kann.

Ein Beispiel wäre der Beginn eines neuen Pipeline-Elements (|). Die Pipeline funktioniert ohne Probleme, da der Befehl nach dem Pipeline-Operator nicht abgeschlossen werden kann, da ihm ein weiteres Pipeline-Element fehlt.

Was unser Interpreter also tut, ist, das nächste Pipeline-Element in der folgenden Befehlszeile zu suchen.

Beispielcode:

Get-Process |
    Where-Object { $_.ProcessName -like "powershell" } |
    Select-Object Id, ProcessName, CPU

In unserem Skript beginnen wir mit Get-Process, das alle aktuell laufenden Prozesse abruft. Die Ausgabe von Get-Process wird dann an Where-Object weitergeleitet, wo wir die Prozesse filtern, deren Name powershell enthält.

Dies wird erreicht, indem der -like Operator in einem Skriptblock {} verwendet wird, um die Prozessnamen zu vergleichen.

Anschließend leiten wir die gefilterten Ergebnisse an Select-Object weiter. Hier geben wir an, dass wir nur die Id, ProcessName und CPU-Nutzung dieser gefilterten Prozesse beibehalten möchten.

Durch die Verwendung der Pipeline haben wir den Befehl effektiv in handhabbare Teile aufgeteilt, die jeweils in einer separaten Zeile stehen. Dies macht unser Skript nicht nur lesbarer, sondern vereinfacht auch das Debuggen und künftige Änderungen.

Ausgabe:

Lange Zeilen von Code mit Komma (,) aufteilen

Ein Komma (,) funktioniert auch in einigen Kontexten, ähnlich wie der Pipeline-Operator.

In bestimmten Kontexten, wie innerhalb eines Befehls oder Skriptblocks, kann der Kommaoperator ebenfalls als Signal für die Zeilenfortsetzung dienen. Dies ist besonders nützlich bei der Formatierung von Befehlen oder beim Übergeben einer Liste von Elementen.

Beispielcode:

Get-EventLog -LogName Application -Newest 5 |
    Format-Table TimeGenerated, 
    EntryType, 
    Source, 
    @{n = 'Message'; e = { $_.Message.Split("`n")[0] } }

In unserem Skript verwenden wir Get-EventLog, um die neuesten 5 Einträge aus dem Anwendungsprotokoll abzurufen. Diese Ausgabe wird an Format-Table zur Formatierung weitergeleitet.

Wir verwenden dann die Kommamethode, um die Eigenschaften aufzulisten, die wir in der Tabelle haben möchten: TimeGenerated, EntryType, Source und einen benutzerdefinierten Ausdruck für Message. Der benutzerdefinierte Ausdruck für Message verwendet eine berechnete Eigenschaft (@{n='Message'; e= { $_.Message.Split("n")[0] } }), um nur die erste Zeile der Nachricht anzuzeigen und die Lesbarkeit zu verbessern.

Durch die Aufteilung dieses Befehls in mehrere Zeilen mithilfe von Kommas haben wir das Skript lesbarer gemacht, insbesondere bei der Arbeit mit mehreren Eigenschaften oder komplexen Ausdrücken.

Ausgabe:

Lange Zeilen von Code mit geschweiften Klammern ({}) aufteilen

Außerdem ermöglichen geschweifte Klammern ({}) beim Definieren von Skriptblöcken die direkte Zeilenfortsetzung. Sie sind unentbehrlich in Szenarien mit Schleifen, bedingten Anweisungen oder beim Übergeben eines Blocks von Befehlen an Cmdlets.

Beispielcode:

$processes = Get-Process
$filteredProcesses = $processes | Where-Object {
    $_.WorkingSet -gt 100MB
} | ForEach-Object {
    $_.ProcessName
}
$filteredProcesses

Wir beginnen damit, eine Liste aller Prozesse mithilfe des Cmdlets Get-Process abzurufen. Die Pipeline leitet diese Prozesse dann an Where-Object weiter, wo ein Skriptblock Prozesse mit einem Arbeitssatz größer als 100MB herausfiltert.

Die überlebenden Prozesse werden an einen weiteren Skriptblock in ForEach-Object übergeben, der deren Namen extrahiert und ausgibt. Die Verwendung von geschweiften Klammern für Skriptblöcke ermöglicht einen klaren, prägnanten und funktionalen Fluss der Daten durch die Pipeline.

Ausgabe:

Schlussfolgerung

In diesem Artikel haben wir verschiedene Methoden zur Verbesserung der Lesbarkeit von PowerShell-Skripten untersucht. Lesbarkeit ist entscheidend für das einfache Verständnis und die Wartung von Skripten, insbesondere in Windows PowerShell, wo Skripte oft lang und komplex werden können.

Wir haben damit begonnen, die gängige Praxis zu diskutieren, das Backtick-Zeichen für Mehrzeilenbefehle zu verwenden, das zwar effektiv ist, aber manchmal zu Problemen bei der Lesbarkeit und zu potenziellen Fehlern aufgrund seiner subtilen Natur führen kann.

PowerShell bietet jedoch intuitivere Methoden zum Aufteilen langer Zeilen von Code, auf die wir anschließend eingegangen sind. Die Verwendung bestimmter Operatoren wie der Pipeline (|), dem Komma (,) und geschweiften Klammern ({}) bietet einen lesbareren und wartbareren Ansatz zum Schreiben von Skripten.

Diese Methoden verbessern nicht nur die visuelle Struktur des Codes, sondern verbessern auch den logischen Fluss, was die Skripte leichter zu debuggen und zu ändern macht.