Mobile-Menu

System-Administration mit Microsofts PowerShell Teil 2 Die PowerShell-Language

Autor / Redakteur: Markus Widl / Dipl.-Ing. (FH) Andreas Donner

Im zweiten Teil der zwölfteiligen Artikelserie rund um Microsofts PowerShell stellt IP-Insider die PowerShell-Language vor, die als Basis für alle Aktionen gilt. Dieser Teil ist relativ theoretisch und Programmierkenntnisse sind von Vorteil. Die hier gezeigten Techniken sind für einen sinnvollen Einsatz der PowerShell jedoch unbedingt erforderlich.

Anbieter zum Thema

Oft werden Administratoren beim Einsatz der PowerShell nicht umhin kommen, kleine Programme zu schreiben, denn nicht jede Aktion lässt sich ausschließlich mit dem wichtigsten PowerShell-Befehlstyp, den sogenannten Cmdlets (sprich: „Commandlets“), alleine bewältigen.

Entwicklern steht dazu die sogenannte PowerShell-Language zur Verfügung, deren wesentliche Eigenschaften in diesem Artikel besprochen werden. Dazu gehören Variablen, Operatoren, Abfragen, Schleifen sowie Funktionen und Filter.

Variablen in der PowerShell

Auch die PowerShell kommt meist nicht ohne Variablen aus. Beim Anlegen wird vor dem Bezeichner ein Dollarzeichen gesetzt, womit die Variablen deutlich gekennzeichnet werden.

$v = „Beispiel“

Neue Variablen werden im Standardfall automatisch erzeugt und initialisiert, sofern sie zuvor noch nicht verwendet wurden. Entwickler, denen das zu fehleranfällig ist, führen zunächst folgenden Befehl aus:

set-psdebug -strict

Danach muss jede Variable vor der Verwendung erst mit einem definierten Wert initialisiert werden, ansonsten wird eine Fehlermeldung ausgegeben.

Der Variablen-Datentyp passt sich automatisch an den Inhalt an. Wird einer Variablen beispielsweise eine Zeichenkette zugewiesen, verhält sie sich wie eine String-Variable.

Auch diesem dynamischen Verhalten stehen manche Entwickler skeptisch gegenüber. Die PowerShell erlaubt es jedoch auch, Variablen einen ganz bestimmten Typ zuzuweisen. Dabei wird der gewünschte Typ vor das Dollarzeichen der Variablenbezeichnung gesetzt. Hier ein Beispiel:

[int]$i = 5

Verwendet werden können dabei alle aus dem .NET-Framework bekannten Datentypen. Dazu gehören neben [int] auch folgende Typen:

  • Zahlen: [int], [long], [double], [decimal], [float], [single], [byte]
  • Zeichen: [string], [char]

Außerdem können Entwickler hier auch [XML] zur Bearbeitung von XML-Daten und [ADSI] für Objekte aus dem Active Directory angeben. Beides wird in späteren Teilen der PowerShell-Artikelserie gesondert besprochen.

Ferner kann beim Anlegen einer Variablen auch die Sichtbarkeit, der sogenannte Scope, festgelegt werden. Darüber wird bestimmt, in welchen Bereichen des gesamten Codes die Variable gültig ist. Zur Auswahl stehen folgende Optionen:

  • global: sichtbar in allen Bereichen
  • script: sichtbar in allen Bereichen der Script-Datei
  • local: sichtbar nur im aktuellen Bereich und darin eingebetteter Bereich (z.B. Funktionen)
  • private: sichtbar nur im aktuellen Bereich (z.B. innerhalb einer Funktion)

Soll beispielsweise eine Variable überall sichtbar sein, wird folgende Zeile programmiert:

$global:i = 5

Wird der Scope nicht explizit angegeben, gilt local.

Es gibt eine ganze Reihe an vordefinierten Variablen. Derzeit wichtig sind aber nur $true und $false für die später besprochenen Abfragen für positive und negative Ergebnisse bei Vergleichen.

Mit Operatoren rechnen, verarbeiten und vergleichen

Die PowerShell-Language kennt, wie viele andere Script-Sprachen auch, verschiedene Operator-Typen. Bei den arithmetischen Operatoren hat der Entwickler die Auswahl zwischen +, -, *, / und %, wobei Letzteres den sogenannten Modulo-Operator darstellt, der den Rest einer Division zurückgibt. Ein Beispiel:

$a = $a + 1

Über spezielle Zuweisungsoperatoren, zu denen auch das Gleichheitszeichen gehört, kann die obere Zeile auch kürzer geschrieben werden:

$a += 1

Ebenso kann mit den anderen arithmetischen Operatoren verfahren werden.

Kaum ein Entwickler wird ohne den Einsatz von Zeichenkettenoperatoren auskommen. Der einfachste, das Pluszeichen, verbindet zwei Zeichenketten.

„abc“ + „def“

Hilfreich sind oft auch Suchbefehle über Wildcards (Operator -like) oder reguläre Ausdrücke (-match). So liefert etwa folgender Befehl $true:

„abc“ -like „a*“

Dabei wird die Groß-/Kleinschreibung nicht berücksichtigt. Ist dies jedoch erforderlich, kann -clike beziehungsweise -cmatch eingesetzt werden.

Auf Zeichenketten(variablen) lassen sich sämtliche Methoden der .NET-String-Klasse anwenden, beispielsweise IndexOf, EndsWith und ToUpper.

„abc“.ToUpper()

liefert beispielsweise „ABC“.

Sehr wichtig sind Vergleichsoperatoren. Dabei können jedoch nicht die aus anderen Programmiersprachen bekannten Operatoren =, >, <, etc. eingesetzt werden. Die PowerShell-Language kennt dagegen folgende Operatoren:

  • -eq (equals, =)
  • -ne (not equals, != / <>)
  • -gt (greater than, >)
  • -ge (greater or equal, >=)
  • -lt (lower than, <)
  • -le (lower or equal, <=)

Folgende Befehlszeile liefert $true:

5 -ge 4

Bedingungen abfragen

Die PowerShell kennt mit Bedingungs- und Auswahlabfrage zwei Abfragetypen. Die Bedingungsabfrage entspricht der klassischen if-Abfrage. Ihr Aufbau ist hier dargestellt:

if(condition) {…}elseif(condition) {…}else {…}

Je nach Anwendungsfall kann der Entwickler die elseif- und else-Zweige weglassen oder auch mehrere elseif-Abfragen einfügen.

In eine ähnliche Richtung geht die Auswahlabfrage mit dem switch-Befehl. Hier wird, abhängig von einem Ausdruck, ein bestimmter Codeteil ausgeführt.

switch(expression) {value1 {…}value2 {…}default {…}}

Code mit Schleifen mehrfach ausführen

Eine bedingte Schleife wird durchlaufen, solange ein Ausdruck wahr ist, der also $true liefert. PowerShell verwendet hier das Schlüsselwort while.

while(expression) {… }

Natürlich ist auch eine Zählerschleife möglich. Der Aufbau orientiert sich dabei an C-ähnlichen Sprachen:

for([initializer]; [condition]; [iterator]) {…}

Soll eine Schleife etwa zehnmal durchlaufen werden, sieht der Aufruf wie folgt aus:

for($i = 1; $i -le 10; $i += 1)

Neben diesen beiden Schleifen gibt es auch noch die foreach-Schleife, mit der über Collections (Objekt-Sammlungen) gelaufen werden kann. Diese Schleife wird an gegebener Stelle eingesetzt, der Aufbau sieht wie folgt aus:

foreach(identifier in collection) {…}

Funktionen und Filter

Eine ebenfalls wichtige Struktur stellen Funktionen dar, die mit der PowerShell-Language wie folgt definiert werden:

function name {param($parameter1, $parameter2, …)}

Die param-Angabe bestimmt dabei eventuell erforderliche Übergabeparameter und kann ggfs. weggelassen werden. Fehlt sie und es werden dennoch Parameter beim Aufruf an die Funktion übergeben, können diese über die vordefinierte Variable $args innerhalb der Funktion ausgelesen werden. Bei $args handelt es sich um Arrays, welche in PowerShell beginnend bei 0 indiziert werden. $args[0] liefert also den ersten Übergabeparameter.

Filter werden identisch zu den Funktionen definiert:

filter name {param($parameter1, $parameter2, …)}

Der Unterschied zwischen Funktionen und Filtern liegt im Pipeline-Verhalten, mit der sich der dritte und nächste Teil der Artikelserie beschäftigt.

Artikelfiles und Artikellinks

(ID:2002059)