Aufteilen von Befehlen auf mehrere Zeilen in PowerShell

1. Windows PowerShell-Mehrzeilenbefehl
2. Unterbrechen langer Codezeilen mit bestimmten Operatoren

Durch lesbaren Code wird der Zweck der Funktionalität den Benutzern sehr einfach mitgeteilt. Variablennamen und Methodennamen sollten für die Lesbarkeit des Codes die richtigen Namenskonventionen haben. Andere Attribute, die zur Lesbarkeit des Codes beitragen, sind konsistente Einzüge und Formatierungsstile. Der mehrzeilige Windows PowerShell-Befehl hilft dabei, lange Befehlszeilen zur besseren Lesbarkeit in mehrere Anweisungen aufzuteilen.

In Windows PowerShell können mehrzeilige Befehle einfach mithilfe des Backtick-Zeichens erstellt werden, um lange oder einzeilige Befehle in mehrzeilige Anweisungen aufzuteilen.

Das Backtick-Zeichen wird als eine Art Fluchtzeichen verwendet. Es maskiert das Newline-Zeichen und führt zu einer Zeilenfortsetzung.

In diesem Artikel wird die Bedeutung von mehrzeiligen Windows PowerShell-Befehlen erläutert, um lange Befehle auf mehrere Zeilen aufzuteilen.

Windows PowerShell-Mehrzeilenbefehl

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

Beispielsweise möchten wir die Informationen zum freien Speicherplatz auf dem lokalen Computer abrufen. Leider ist das Skript zum Abrufen dieser spezifischen Informationen ein erweiterter Befehl, der das Lesen und Verwalten erschwert.

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 es in die Befehlszeilenschnittstelle kopiert wird, ist das obige Beispiel ein sehr langes Einzeiler-Skript.

Wir können lange Befehle einfach in mehrere Zeilen aufteilen, indem wir das Backtick-Zeichen von Windows PowerShell 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)}}

Im obigen Beispiel teilen wir den langen Befehl in mehrere Zeilen auf, indem wir an der Stelle, an der wir ihn aufteilen möchten, ein Leerzeichen gefolgt von einem Backtick-Zeichen verwenden. Denken Sie daran, dass zwischen dem Backtick und dem Zeilenumbruch kein Zeichen stehen darf, einschließlich Leerzeichen.

Die Codestruktur ist in Windows PowerShell mithilfe des mehrzeiligen Befehls leicht lesbar und einfach zu warten. Das Backtick-Zeichen wird jedoch normalerweise nicht empfohlen, da das Zeichen schwer zu lesen ist und zu Fehlern führt. Wir haben also eine alternative Methode, um lange Codezeilen zu unterbrechen.

Unterbrechen langer Codezeilen mit bestimmten Operatoren

Normalerweise erhalten Sie eine automatische Zeilenfortsetzung, wenn ein Befehl an dieser Stelle syntaktisch nicht vollständig sein kann.

Ein Beispiel wäre das Starten eines neuen Pipeline-Elements (|). Die Pipeline wird problemlos funktionieren, da der Befehl nach dem Pipeline-Operator nicht vollständig sein kann, da ihm ein weiteres Pipeline-Element fehlt. Unser Interpreter sucht also nach dem nächsten Pipeline-Element in der folgenden Befehlszeile.

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)}}

Ein Komma (``) funktioniert auch in bestimmten Kontexten wie dem Pipeline-Operator.

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)}}

Außerdem ermöglichen geschweifte Klammern ({}) beim Definieren von Skriptblöcken eine direkte Zeilenfortsetzung.

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)
    }
}

Mit den oben genannten Techniken können wir jetzt beobachten, dass unser Beispielcode einfacher zu lesen ist, und wir haben dies ohne die Verwendung des Backtick-Zeichens geschafft.