Powershell: Von Daten, Variablen & Umgebung

Die Powershell entwickelt sich immer mehr zu einem Werkzeug, mit dessen Hilfe Administratoren und Anwender viele Aufgaben auf den Windows-Systemen automatisieren und vereinfachen können. Doch wer dieses Tool richtig nutzen will, muss sich zunächst einmal mit ihm vertraut machen: Wir helfen dabei mit einer Reihe von Artikel, in denen wir deren grundlegenden Techniken erläutern und vorstellen.

Wer mit einer Programmiersprache arbeiten will oder muss, wird sicher immer auch mit der Art und Weise befassen müssen, wie dieser mit den Daten und Variablen umgeht. Dabei ist es ganz gleich, ob es sich um eine „klassische“ Programmiersprache wie etwa C, deren Quelltext mittels eines Compilers übersetzt wird, oder um eine zur Laufzeit interpretierte Skript-Sprache handelt, wie sie bei der Powershell zu finden ist.

Die Variablen stellen dabei die Platzhalter für die Daten da, mit denen jeder Entwickler, Programmierer und Anwender der Shell umgehen muss. Und wie es auch bei anderen Programmiersprachen üblich ist, stehen hier neben den „normalen“ Variablen ebenfalls solche zur Verfügung, die standardmäßig bereits von der Shell mit Werten versehen werden. Zu diesen eingebauten Variablen gehören auch diejenigen, die sich auf die Windows-Umgebung auf das Environment des Betriebssystems beziehen.

Bereits mit Werte belegt: die eingebauten Variablen

Die Powershell stellt dem Anwender eine ganze Reihe solcher fest integrierter Variablen zur Verfügung, zu denen beispielsweise $PSHOME (das Verzeichnis der Powershell auf dem aktuellen System) und $PSCulture (für die Landessprache/Kultur des Windows-Systems) gehören. Die Inhalte dieser Variablen kann man einfach über einen Aufruf der folgenden Art auf den Bildschirm bringen:

$PSHOME
C:\Windows\System32\WindowsPowerShell\v1.0

Der Aufruf einer weiteren dieser Variablen ist in Bild 1 zu sehen: Die erst ab der aktuellen Powershell-Version 2.0 zur Verfügung stehende Variable $PSVersionTable zeigt, welche Version der Shell auf dem System installiert ist: Auf den aktuellen Windows-Systemen sollte das sowohl auf der Client- als auch auf der Server-Plattform die Version 2 sein. Etwas verwirrend kann es dabei sein, dass die Powershell 2 .0 auf den Windows-Systemen in das PowerShell 1.0-Verzeichnis installiert wird, wird der vorherige Aufruf von $PSHOME deutlich zeigt. Allerdings sollte man von einem Umbenennen dieses Verzeichnis grundsätzlich absehen, da dann unter Umständen diejenige der Profildateien, die nicht direkt vom Benutzer abhängig ist, nicht mehr geladen wird.

Noch interessanter ist dann aber ein Aufruf, der alle auf diesem System aktuell definierten Variablen auf den Bildschirm der Konsole bringt:

dir variable:

Dieser Aufruf nutzt zunächst einmal ein ebenfalls standardmäßig angelegtes Alias für das Cmdlet Get-ChildItem, das dann den Wert „variable:“ als Argument übergeben bekommt. Dieses bezieht sich auf eine Besonderheit der Powershell, die wir bereits in einem kurzen Artikel auf nt4admins vorgestellt haben: die sogenannten Provider, die auch als Powershell-Anbieter oder einfach „Laufwerk“ bezeichnet werden.

Durch sie ermöglicht die Shell dem Anwender einen sehr einfachen Zugriff auf die verschiedensten Bereiche des Betriebssystems mittels der normalen Befehle wie Get-ChildItem oder GetItemProperty. Insgesamt stehen standardmäßig sieben dieser Provider für Zugriffe auf Bereiche wie das Dateisystem, die Registry oder wie hier die Variablen zur Verfügung.

Die mit dem zuvor erläutertem Alias-Befehl dir auf den Konsolenschirm dargestellte Auflistung gibt dem Anwender einen guten Überblick darüber, welche Variablen im Kontext dieser Powershell-Sitzung zur Verfügung stehen. Allerdings sollte man immer darauf achten, dass ein Zugriff auf den Inhalt der Variablen in fast allen Fällen nur dann gelingt, wenn ihrem Namen das Dollar-Zeichen „$“ vorangestellt, was das System bei dieser Auflistung nicht tut.

Alle Variablen der Powershell können innerhalb eines Skripts oder auch innerhalb eines Statements so eingesetzt werden, dass die Shell bei der Ausführung an ihrer Stelle den Inhalt dieser Variablen setzt. So listet der folgende Aufruf alle Dateien die an ihrem Ende die Zeichenkette „xml“ tragen im Home-Verzeichnis der Shell mittels der Variablen $PSHome auf:

dir $PSHome -filter *.*xml

Bei den standardmäßig fest integrierten Variablen stehen wiederum zwei Typen zur Verfügung: Neben den automatischen Variablen wie das gerade gezeigte $PSHome stehen auch sogenannte Preference-Variablen wie $MaximumErrorCount zur Verfügung.

Während der Anwender die Werte bei den automatischen Typen nicht überschreiben kann, ist dies bei dem Preference-Typ sehr wohl möglich, weshalb dieser Art der Platzhalter häufig auch für Zähler wie $MaximumErrorCount zum Einsatz kommen. In dieser Variablen wird die Anzahl der Fehlereinträge im entsprechenden Log für diese Session festgelegt. Hier kann man dem Zähler einfach mit Hilfe des Gleichheitszeichens ein höheren oder auch neuen Wert zuweisen:

$MaximumErrorCount
256
$maximumerrorcount = 280
$MaximumErrorCount
280

Der neue Wert bleibt danach so lange in der Variablen abgespeichert, bis er wieder überschrieben oder die Powershell-Session beendet wird. Dieses Beispiel soll auch noch einmal zeigen, dass die Powershell sowohl bei den Bezeichnungen für die Variablen als auch bei denen für die Cmdlets nicht kontextsensitiv reagiert, sie unterscheidet hier nicht zwischen Groß- und Kleinschreibung.

Mehr Informationen über diese verschiedenen Variablen kann der Anwender wiederum ganz leicht direkt an der Kommandozeile durch Eingabe der entsprechenden Hilfebefehle bekommen:

get-help about_preference_variables
get-help about_automatic_variables

Beide Befehle bringen sehr umfangreiche Hilfetexte mit zusätzlichen erläuternden Beispielen auf den Bildschirm der Konsole.

Was sich in der Umgebung abspielt: das Windows-Environment

Auch auf die Umgebungsvariablen des Windows-Betriebssystems kann aus der Powershell heraus mittels eines Providers direkt zugegriffen werden, so dass der erste Zugriff mit der Anzeige der aktuellen Windows-Umgebung mit dem folgenden Befehl erfolgen kann:

dir env: | sort name

Dadurch werden, wie im Bild 2 gezeigt, sämtliche Variablen aus dem Windows-Environment samt der in ihnen abgespeicherten Daten angezeigt. Da diese Anzeige schnell unübersichtlich werden kann, haben wir sie mittels eine „Pipe“ – einer Weiterleitung, mit der die Ausgabe eines Cmdlets direkt an die Eingabe eines anderen geschickt wird – an das Cmdlet Sort-Object (hier durch ein Alias mit dem Namen „sort“ repräsentiert) weitergeleitet, dass ohne weitere Parameter eine Sortierung der Objekte in aufsteigender Reihenfolge vornimmt und diese dann anzeigt.

Wer auf den Inhalt der einzelnen Variablen der Windows-Umgebung zugreifen oder sie in einem Statement verwenden will, kann dies nicht einfach tun, indem er das Dollar-Zeichen davor verwendet, denn es muss über den Provider zugegriffen werden, was in der folgenden Art und Weise geschieht:

$env:windir

Dieser Aufruf gibt dann beispielweise den Pfad für das Windows-Verzeichnis aus. Ganz ähnlich muss der Aufruf in einem Statement oder Skript erfolgen. Das folgende Statement zeigt all DLL-Dateien im Windows-Verzeichnis auf dem aktuellen Rechner an:

dir $env:windir -filter *dll

Der Wert der Variablen im Environment kann vom Anwender geändert werden. So ist es beispielsweise manchmal notwendig, einen bereits bestehenden Verzeichnis-Pfad um ein weiteres Verzeichnis zu ergänzen. Ein Beispiel ist der Heimatpfad er aktuellen Shell, der in der Umgebungsvariablen $Homepath abgespeichert wird. Soll dieser erweitert werden, so kann dies unter der Powershell mit Hilfe des Plus-Operators (+), der ein Zusammenführen von Zeichenketten erlaubt, einfach und schnell erledigt werden:

$env:homepath
\Users\hugo
$env:homepath = $env:homepath + ”\test”
$env:homepath
\Users\hugo\test

Durch die Anführungszeichen wird der Shell hier gezeigt, dass es sich bei \test um eine Zeichenkette handelt. Ohne diese Maskierung würde der Plusoperator die Operation nicht ausführen können.

Zuweisen und die Werte: vom Anwender definierte Variablen

Im Gegensatz zu vielen Programmier- und auch Skripting-Sprachen ist es bei der Powershell nicht notwendig, selbstangelegte Variablen vor dem ersten Gebrauch zu deklarieren – ihnen wird einfach ein Wert zugewiesen und die Shell kann mit dieser Variablen und deren Inhalt arbeiten:

$wert1 = “Eins Zwei“
$wert2 = 15
$wert1, $wert2
Eins Zwei
15
$wert1.gettype(), $wert2.gettype()
IsPublic     IsSerial    Name                    BaseType
True         True        String                  System.Object
True         True        Int32                   System.ValueType

Die Beispiele zeigen zugleich auch, dass die Shell automatisch den Datentyp der Variablen in Abhängigkeit von den zugewiesen Werten anlegt: So wird für wert1 eine Zeichenketten-Variable (String) angelegt, während für wert2 der Typ Integer (Int32) angelegt wird.

Überprüfen kann man das wie ebenfalls in diesem Beispiel gezeigt, durch Aufruf der Methode Gettype(), die dann die entsprechenden Informationen auf den Bildschirm bringt. Die Powershell ist sehr flexibel, wenn es darum geht, Variablen mit Werten zu versorgen, wie die folgenden Beispiele demonstrieren sollen:

$wert1, $wert2 = 25, 35
$wert1, $wert2
25
35
$wert1 = $wert2 = $wert3 = 45
$wert1, $wert2, $wert3
45
45
45

Eine Operation, die viele Programmierer und Entwickler in ihren Skripten immer wieder ausführen müssen, ist der sogenannte „Swap“ von Daten: Die Inhalte zweier Variablen werden vertauscht. Für diesen Vorgang wird dann zumeist eine Hilfsvariable eingerichtet, da sonst einer der Wert bei einem solchen Tausch überschrieben würde:

$wert1, $wert2 = 20, 50
$temp = $wert1
$wert1 = $wert2
$wert2= $temp
$wert1, $wert2
50
20

Unter der Powershell kann diese Zuweisung weitaus einfacher vonstatten gehen:

$wert1, $wert2 = 20, 50
$wert1, $wert2 = $wert2, $wert1
$wert1, $wert2
50
20

Die Powershell verwendet in diesem Fall eine ganz besondere Arbeitsweise: Das Gleichheitszeichen als Zuweisungsoperator ist in der Lage, sogenannte Arrays also ganze Felder von Variablen zu verarbeiten. Als Trennungszeichen zwischen zwei Array-Variablen sieht es dabei das Komma an.

Finden sich nun auf beiden Seiten des Operators die gleiche Anzahl von Array-Variablen, so werden diese Werte der Variablen auf den rechten Seite den entsprechenden Variablen auf der linken zugewiesen und der Tausch ist perfekt.

Wir hoffen, wir haben mit diesem ersten Ausflug in die Grundlagen der Programmierung rund um die Powershell Ihr Interesse erweckt. Ein nächster Artikel hier auf nt4admins wird dann die Variablen und ihre Werte noch weiter vertiefen und dabei ganz besonders auf die Eigenschaften und Möglichkeiten bei der Verarbeitung von Zeichenketten und die Arrays eingehen.

Frank-Michael Schlede