0.  Einleitung

1.  Schnelleinstieg in die Formatierung    
     Beispiel 1a: Datum und Uhrzeit (FormatOperator -f)
     Beispiel 1b: Datum und Uhrzeit (ToString()-Methode)
     Beispiel 1c: Landsspezifische Formatierung
     Beispiel 2: Zahlen (flexible Nachkommastellen)
     Beispiel 3a: Zahlen (Feldbreite, feste Vor- und Nachkommastellen)
     Beispiel 3b: Zahlen (feste und flexible Nachkommastellen)
     Beispiel 4: Zahlen (Standardformat n2)
    1.1 Datum und Uhrzeit
          1.1.1 Standardformatierung von Datum und Uhrzeit
                   Beispiel 1: StandardFormatierung des heutigen Datums mit ToString und Formatoperator
          1.1.2 Individuelle Formatierung von Datum und Uhrzeit
                   Beispiel 1: Individuelle Formatierung des heutigen Datums mit Standardpatterns
                   Beispiel 2: Unterschied von "%d" und "d"
          1.1.3 Länderspezifische Formatierung von Datum und Uhrzeit (CultureObject)
                   Beispiel 1: Datum im Amerkanischen Format
          1.1.4 Powershell und die Kalenderwoche
                   Beispiel 1: Kalenderwoche des aktuellen Datums
                   Beispiel 2: Kalenderwoche eines beliebigen Datums

        1.2 Zahlen
          1.2.1 Standardformatierung von Zahlen
                   Beispiel 1: Deutsches und Amerikanisches Währungsformat
          1.2.2 Individuelle Formatierung von Zahlen
                   Beispiel 1: Zahlen mit Formatbezeichnern und dem Cultureinfo-Objekt formatieren
          1.2.3 Mathematisches Runden und andere mathematische Funktionen
                   Beispiel 1: Anzeige der mathematischen Funktionen und Eigenschaften
                   Beispiel 2: Anwenden der Klasse [math] - mathematisches Runden einer Zahl und Potenzieren

2.  Ausgabe filtern
     2.1 Select-Object
          Beispiel 1: Anzeige aller aktiven Netzwerkadapter mit SettingID und IPAdresse (Select-Object)
          Beispiel 2: die drei ältesten Dateien eines Ordners anzeigen (ForEach)

3. Formatierte Tabellen
    3.1 Selbstdefinierte Spalten zu Format-Table/ Select-Object hinzufügen
          Beispiel 1a: Ausgabe von "Format-Table" um selbstdefinierte Spalten ergänzen
          Beispiel 1b: weitere Formatierung der Ausgabe von Format-Table
          Beispiel 2: Mit "Format-Table" den vorhandenen und belegten Speicherplatz anzeigen
          Beispiel 3: Arbeiten mit der SI-Notation (Scietific Notation)  
          Beispiel 4: Eine einzelne Spalte einer Tabelle gesondert formatieren
          Beispiel 5: vier formatierte Spalten innerhalb von Format-Table
    3.2 Tabellen mit einer For-Schleife erstellen
          Beispiel 1: Eine Tabelle aus  .Net formatierten Strings erstellen
          Beispiel 2: Eine Tabelle mit Spalten aus zwei verschiedenen Quellen erstellen
    3.3 Tabellen mit PSObject erstellen
           Beispiel 1: Prozesse
          Beispiel 2: Wer ist mit meinem Rechner verbunden

   3.4 Tabellen mit "Out-GridView"

           Beispiel 1: Inhalt eines Verzeichnisses
     3.5 Mehrspaltige Tabellen eines Datenfeldes/ Arrays
           Beispiel 1: mehrspaltige Anzeige der installierten Hotfixe auf einem Rechner (Win32_QuickFixEngineering)
 
4. Die Console anpassen
    Beispiel 1: Welche Farben bieten Powershell und .Net an
    Beispiel 2: Zeilen farblich hervorheben
    Beispiel 3: die ganze Konsole verändern
    Beispiel 4: Farben zurücksetzen

5 Ausgabe im HTML-Format
   5.1 Powershell, HTML und Css
         5.1.1 HTML und Css in getrennten CodeFiles
                  Beispiel 1: Dateien eines Verzeichnisses in einer Html auflisten (HTML- und CssCode sind getrennt)
         5.1.2 HTML und Css in einem gemeinsamen CodeFile
                  Beispiel 1: Dateien eines Verzeichnisses in einer Html auflisten (HTML- und CSS-Code sind in einer Datei)
 

0 Einleitung

Auf dieser Seite will ich einige Punkte vorstellen, wie man gewonnene Daten auch sinnvoll darstellen kann. Dazu gehören

  • das Formatieren einzelner Werte wie Zahlen, Datumswerte, Uhrzeiten oder Währungen
  • das Herausfiltern nur der wichtigen und interessanten Daten aus einem Ergebnis
  • die Darstellung mehrerer Daten in Tabellen
  • der Einsatz von Farben
  •  

1 Schnelleinstieg in die Formatierung mit .Net

Kryptische Formatierungsanweisungen der Art "{0,-10:##.###}" -f $var1,$var2" begegnen einem in der Powershell relativ häufig. Um möglichst rasch einen Einstieg zu ermöglichen, zeige ich in diesem Kapitel vier einfache, prinzipielle Beispiele. 
Wenn man die Schreibweise dieser Beispiele verstanden hat, ist es nicht mehr schwierig anhand der nachfolgenden Kapitel oder anhand der MSDN-Tabellen die Bedeutung der verschiedenen Kürzel nachzuschlagen.

Beispiel 1a: Datum und Uhrzeit (FormatOperator -f)

"{0} ist {1:D}" -f "Heute",(Get-Date)

#Ausgabe

Heute ist Donnerstag, 27. Januar 2011

{0} und {1} sind die Platzhalter für die Variablen, die nach dem Formatierungsoperator -f aufgelistet sind. {0} steht für den String "Heute" und {1} für das Ergebnis von (Get-Date). Man könnte auch zuerst die {1} angeben, oder die {1} mehrfach im String benützen.

Das "D" in {1:D} formatiert {Get-Date} zu einem "Long Pattern Date", siehe Kapitel 1.1

Beispiel 1b: Datum und Uhrzeit (ToString()-Methode)

Dasselbe Beispiel aus 1a) mit der ToString-Methode umgesetzt

$Date=Get-Date
"Heute ist $($Date.ToString('D')"
"Heute ist $((Get-Date).ToString('D')"

#Ausgabe

Heute ist Freitag, 28. Januar 2011
Heute ist Freitag, 28. Januar 2011


Beispiel 1c: Landesspezifische Formatierung

Auf einem englischen Windowsrechner würde man bei den bisherigen Beispielen folgende unschöne Ausgabe erhalten:

Heute ist Thursday, May 17, 2012
Heute ist Thursday, May 17, 2012

Um das zu vermeiden, muss das CultureInfo-Objekt der ToString-Methode mitgegeben werden. 

#$Culture = New-Object System.Globalization.CultureInfo("en-US")
$Culture = New-Object System.Globalization.CultureInfo("de-DE")

$Date=Get-Date
"Heute ist $($Date.ToString('D',$Culture))"
"Heute ist $((Get-Date).ToString('D',$Culture))"

erzwingt auf jeden Fall eine deutschsprachige Ausgabe. Näheres im Kapitel 1.1.3 Länderspezifische Formatierung mit dem CultureInfo-Object

Beispiel 2: Zahlen (flexible Nachkommastellen)

$myString="Die Zahl PI auf drei NachkommaStellen mit dem `"Digit-Placeholder(#) formatiert lautet:`

    "{0}: {1,-10:#.###}" -f  $myString,([Math]::Pi)

#Ausgabe

Die Zahl PI auf drei NachkommaStellen mit dem "Digit-Placeholder(#) formatiert lautet: 3.142
  • Die "0" in "{0}: {1,-10:#.###}" ist der Plathalter der Variable myString
  • Das ": " in "{0}: {1,-10:#.###}" ist der String zwischen den Platzhaltern
  • Die "1" in "{0}: {1,-10:#.###}" ist der Platzhalter für ([Math]::Pi).
  • Die "-10" in "{0}: {1,-10:#.###}" definiert die Breite des Feldes an. Das Minus bedeutet linksbündig. Ein Wert für die Breite ist optional.
  • #.### in "{0}: {1,-10:#.###}" formatiert die Zahl mit maximal zwei Vorkomma und rundet auf drei Nachkommastellen. Führende Nullen oder Nullen am Ende werden nicht angegeben.

"#" ist der sogenannte DigitPlaceholder, "0" ist der sogenannte ZeroPlaceholder. (siehe Kapitel1.2.2 Individuelle Formatierung von Zahlen)

 

Beispiel 3a: Zahlen (Feldbreite, feste Vor- und Nachkommastellen)

"die Zahl PI auf drei NachlkommaStellen mit dem `
    "Zero placeholder`" formatiert lautet: {0,10:00.000}" -f  ([Math]::Pi)
#Ausgabe

die Zahl PI auf drei NachlkommaStellen mit dem "Zero placeholder" formatiert lautet   03,142
  • Text kann natürlich auch zwischen die Anführungszeichen vor, hinter und zwischen die Platzhalter gesetzt werden.
  • Die "0" in "{0,10:00.000}" ist der Platzhalter für ([Math]::Pi).
  • Die "10" in "{0,10:00.000}" definiert die Breite des Feldes an. Das fehlende Minus (=Plus) bedeutet rechtsbündig. Ein Wert für die Breite ist optional.
  • "00.000" in "{0,10:00.000}" formatiert die Zahl mit genau zwei Vorkommastellen und rundet die Anzeige auf drei Nachkommastellen. Führende Nullen oder Nullen am Ende werden auf jeden Fall angezeigt, auch wenn sie 0 sind
  •  

Beispiel 3b Zahlen (feste und flexible Nachkommastellen)

"#" und "0" kann man auch Mischen

"{0:#.00#}" -f 32.4004
#Ausgabe

32,40

Mit {0:#.00#} werden auf jeden Fall mindestens zwei Nachkommastellen angezeigt, aber nicht mehr als drei. 

32,40 ist jetzt aber ein String geworden, was man hieran sieht!

$a = "{0:#.00#}" -f 32.4004
$a * 5
#Ausgabe

32,4032,4032,4032,4032,40


Beispiel 4: Zahlen (Standardformat n2)

"{0:n2}" -f 32.4084
#Ausgabe

32,41

die einfachste Möglichkeit zum Schluss:
Mit der Formatierung "n2" wird die Zahl 32,4084 auf zwei Stellen gerundet. Hat man außer der Anzahl der angezeigten Nachkommastellen keine weiteren Anforderungen an die Formatierung, so ist dies eine einfache Möglichkeit.

Es gibt neben dem "n" oder "N" noch weitere zahlreiche Standardformate, die unter MSDN: Standard Numeric Format Strings aufgeführt sind, um Zahlen beispielsweise als Währung, in exponentieller ("C")  oder hexadezimaler ("X") Darstellung auszugeben. In Kapitel 1.2.1 Standardformatierung von Zahlen komme ich gleich nochmal darauf zurück.

 

1.1 Datum und Uhrzeit

In der .Net Datums- und Uhrzeit Formatierung kann man sich entweder aus einem gut sortierten Angebot an Standardformaten eine passendes aussuchen (siehe Kapitel 1.1.1), oder man formatiert seinen String frei nach eigenen Wünschen (siehe Kapitel 1.1.2).

 

1.1.1 StandardFormatierung von Datum und Uhrzeit

Beispiel 1: StandardFormatierung des heutigen Datums mit ToString und Formatoperator

Set-StrictMode -Version "2.0"
Clear-Host $Date = Get-Date

$Text="`nFormatierung nach ISO-Norm 8601 mit dem Formatspecifier`"s`" "
Write-Host -BackgroundColor darkyellow -foregroundcolor darkred $Text
$Date.ToString("s")
"{0:s}" -f $Date  

$Text="`nFormatierung im Langen Datumsformat mit dem Formatspecifier `"D`" "
Write-Host -BackgroundColor darkyellow -foregroundcolor darkred $text
$Date.ToString("D")
"{0:D}" -f $Date  
#Ausgabe

Formatierung nach ISO-Norm 8601 mit dem Formatspecifier"s" 
2011-09-17T22:47:32
2011-09-17T22:47:32

Formatierung im Langen Datumsformat mit dem Formatspecifier "D" 
Samstag, 17. September 2011
Samstag, 17. September 2011

Die Schreibweise {0:s} habe ich prinzipiell im Kapitel "1 Schnelleinstieg in die "Formatierung" weiter oben beschrieben. Die Bedeutung der Formatspecifier "s" oder "D" in "{0:s}" oder "{0:D}" erfahrt ihr in den nächsten Zeilen.

Weitere Beispiele:
MSDN: Standard DateTime Format Strings Output Examples

Die Standard Formatbezeichner für Datum und Zeit finden sich unter 
MSDN: Standard DateTime Format Strings

einige Beispiele an Formatbezeichnern haben ich hier kopiert, der Rest liegt auf der eben genannten MSDN-Seite 

Format specifier

Name   

Description

d

Short date pattern

Displays a pattern defined by the DateTimeFormatInfo.ShortDatePattern property associated with the current thread or by a specified format provider.

D

Long date pattern

Displays a pattern defined by the DateTimeFormatInfo.LongDatePattern property associated with the current thread or by a specified format provider.

t

Short time pattern

Displays a pattern defined by the DateTimeFormatInfo.ShortTimePattern property associated with the current thread or by a specified format provider.

 

1.1.2 Individuelle Formatierung von Datum und Uhrzeit

Beispiel 1: Individuelle Formatierung des heutigen Datums mit Standardpatterns

Set-StrictMode -Version "2.0"
Clear-Host

 
#$Culture = New-Object System.Globalization.CultureInfo("en-US")
$Culture = New-Object System.Globalization.CultureInfo("de-DE")

$Date = Get-Date

#mit der Methode ToString

#bestimmte Buchstaben müssen mit '\' maskiert werden
$Date.ToString("dddd, \der dd-\te MMMM",$Culture) 

#mit dem Formatoperator -f (ohne Angabe des CultureObjects)
"{0:dddd}, der {0:dd}-te {0:MMMM}" -f $Date #identische Formatierung

#mit dem Parameter -Format (ohne Angabe des CultureObjects)
Get-Date -Format("dddd, \der dd-\te MMMM")

#Ausgabe

Samstag, der 20-te Februar
Samstag, der 20-te Februar 
Samstag, der 20-te Februar

Die Bedeutung von "dddd", "dd" und "MMMM" habe ich weiter unten in einer Tabelle beschrieben. Alle Formatspecifier findet man in der MSDN

Weitere Beispiele: MSDN: Custom DateTime Format Strings Output Examples

Wenn die Standardformate nicht das gewünschte Format mitbringen, kann man mit der individuellen Formatierung jedwede Ausgabe erzeugen. Die möglichen Formatbezeichner findet man unter MSDN: DateTimeFormatInfo Class

einige Formatbezeichner habe ich hierher kopiert, der Rest liegt auf der eben genannten MSDN-Seite. 

Format specifier

Description

dd

Displays the current day of the month, measured as a number between 1 and 31, inclusive. If the day is a single digit only (1-9), it is formatted with a preceding 0 (01-09).

dddd (plus any number of additional "d" characters) 

Displays the full name of the day for the specified DateTime. If a specific valid format provider (a non-null object that implements IFormatProvider with the expected property) is not supplied, then the  DayNames property of the DateTimeFormat and its current culture associated with the current thread is used. Otherwise, the DayNames property from the specified format provider is used.

MMMM

Displays the full name of the month for the specified DateTime. If a specific valid format provider (a non-null object that implements IFormatProvider with the expected property) is not supplied, then the  MonthNames property of the DateTimeFormat and its current culture associated with the current thread is used. Otherwise, the MonthNames property from the specified format provider is used.

 

Beispiel 2: Unterschied von "%d" und "d"

Set-StrictMode -Version "2.0"
Clear-Host

#returns the DateTime  value; "d" is the standard short date pattern.
([DateTime]::Now).ToString("d") 

#returns the day of the month; "%d" is a custom pattern.
([DateTime]::Now).ToString("%d") 

#returns the day of the month followed by a white-space character; "d " is a custom pattern.
([DateTime]::Now).ToString("d ") 
#Ausgabe

27.11.2012 ("d")
27 ("%d")
27  ("d ")

("d") hat also eine andere Bedeutung als ("%d").
Das Leerzeichen von ("d ") ist bei der Ausgabe hier nicht zu erkennen.

 

1.1.3 Länderspezifische Formatierung mit dem CultureInfo-Object

Möchte man die Datumsausgabe oder auch Uhrzeiten nicht mit den Regionseinstellungen seines Systems formatieren, so steht die CultureInfo-Klasse zur Verfügung

Beispiel 1: Datum im Amerikanischen Format

Set-StrictMode -Version "2.0"
Clear-Host
 
$Culture = New-Object System.Globalization.CultureInfo("en-US")
$GetDate = Get-Date
 
$GetDate.ToString("dddd, dd-\t\h o\f MMMM",$Culture)
$GetDate.ToString("D",$culture)
#Ausgabe auf einem Deutschen Windows 7

Saturday, 20-th of February
Saturday, February 20, 2010

Die Verwendung der Klasse CultureInfo mit dem -f Operator habe ich nicht hinbekommen und auch in der Klassenbeschreibung nicht gefunden.

weitere Erklärungen findet man unter
Technet Windows PowerShell Tip of the Week:  Formatting Numbers and Dates Using the CultureInfo Object

eine Auflistung aller Culturen findet man im unteren Teil der Seite MSDN: CultureInfo Class

 

1.1.4 Powershell und Kalenderwoche

Beispiel 1: Kalenderwoche des aktuellen Datums

Get-Date -uFormat %V
#mögliche Ausgabe

48

 

Beispiel 2: Kalenderwoche eines beliebigen Datums

$Date = "12.12.2001"
Get-Date -date $Date -uFormat %V
#Ausgabe

50

 

1.2 Formatierung von Zahlen

Auch bei der Formatierung von Zahlen gibt es -wie bei Datum und Uhrzeit- die Möglichkeiten der Standardformatierung und der individuellen Formatierung

 

1.2.1 Standardformatierung von Zahlen

Beispiel 1: Deutsches und Amerikanisches Währungsformat

$Set-StrictMode -Version "2.0"
Clear-Host

$CultureUS = New-Object System.Globalization.CultureInfo("en-US")
$CultureDE = New-Object System.Globalization.CultureInfo("de-DE")
$Value=123.456

'"C",$CultureDE:  ' + $Value.ToString("C",$CultureDE)
'"C",$CultureUS:  ' + $Value.ToString("C",$CultureUS)
'"E2"          :  '  +$Value.ToString("E2")

#Ausgabe

"C",$cultureDE:  123,46 €
"C",$cultureUS:  $123.46
"E2"          :  1,23E+002

weitere Beispiele: MSDN: Standard Numeric Format Strings Output Examples

Einige Formatbezeichner habe ich unten kopiert. Die vollständige Liste der Standardformatbezeichner für Zahlen findet man unter
MSDN: Standard Numeric Format Strings

Format specifier

Name               

Description

C or c

Currency

The number is converted to a string that represents a currency amount. The conversion is controlled by the currency format information of the NumberFormatInfo object used to format the number. The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted, the default currency precision given by the NumberFormatInfo is used.

D or d

Decimal

This format is supported for integral types only. The number is converted to a string of decimal digits (0-9), prefixed by a minus sign if the number is negative. The precision specifier indicates the minimum number of digits desired in the resulting string. If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier.

E or e

Scientific (exponential)

The number is converted to a string of the form "-d.ddd...E+ddd" or "-d.ddd...e+ddd", where each 'd' indicates a digit (0-9). The string starts with a minus sign if the number is negative. One digit always precedes the decimal point. The precision specifier indicates the desired number of digits after the decimal point. If the precision specifier is omitted, a default of six digits after the decimal point is used. The case of the format specifier indicates whether to prefix the exponent with an 'E' or an 'e'. The exponent always consists of a plus or minus sign and a minimum of three digits. The exponent is padded with zeros to meet this minimum, if required.

 

1.2.2 Individuelle Formatierung von Zahlen

Beispiel 1: Zahlen mit Formatbezeichnern und dem Cultureinfo-Objekt formatieren

Set-StrictMode -Version "2.0"
Clear-Host

$CultureUS = New-Object System.Globalization.CultureInfo("en-US")
$CultureDE = New-Object System.Globalization.CultureInfo("de-DE")
$Value=123.456


#der Unterschied zwischen # und 0 ist in der nachfolgenden Tabelle beschrieben
$Value.ToString("#.#",$CultureUS) 
$Value.ToString("0.0",$CultureDE)
$Value.ToString("0000.0000",$CultureUS)
#Ausgabe

123.5 
123,5
0123.4560

Man beachte die unterschiedlichen Dezimaltrennzeichen aufgrund des CultureInfoParameters

weitere Beispiele unter: MSDN: Custom Numeric Format Strings Output Examples

Einige Formatbezeichner habe ich unten kopiert. Die vollständige Liste der individuellen Formatcharacter für Zahlen findet man unter:
MSDN: Custom Numeric Format Strings

Format character

Name

Description

0

Zero placeholder

If the value being formatted has a digit in the position where the '0' appears in the format string, then that digit is copied to the result string. ....

#

Digit placeholder

If the value being formatted has a digit in the position where the '#' appears in the format string, then that digit is copied to the result string. ...

.

Decimal point

The first '.' character in the format string determines the location of the decimal separator in the formatted value; any additional '.' characters are ignored. ...

 

1.2.3 Mathematisches Runden und andere mathematische Funktionen

Diese Unterkapitel passt zugegeben nicht ganz unter "Formatierung des Outputs", andererseits will man oft nicht nur Zahlen optisch runden (=formatieren) sondern tatsächlich mathematisch runden (=Stellen abschneiden)

Powershell selbst besitzt keine cmdlets für diese Aufgabe, dafür bietet .Net eine einfache Klasse [system.math] mit den passenden statischen Methoden an.

MSDN: System.Math

Beispiel 1: Anzeige der mathematischen Methoden und Eigenschaften

[math] | Get-Member -static
#Ausgabe 

   TypeName: System.Math

Name            MemberType Definition             
----            ---------- ----------             
Abs             Method     static System.SByte Abs(System.SByte value), 
Abs(System.Int16 value), static int Abs(int value), static long Abs(long value)           
.....        
Tanh            Method     static double Tanh(double value)       
Truncate        Method     static decimal Truncate(decimal d), static double    
E               Property   static System.Double E {get;}          
PI              Property   static System.Double PI {get;}  

Hier ist alles an mathematischen Funktionen dabei, was ein normaler Taschenrechner auch hergibt. 

Alle Methoden sind statisch und arbeiten ohne Instanzen der Klasse. Für statische Methoden muss man die Schreibweise "[Klasse]::Methode(Parameter)" benützen. Eine Instanzierung mit dem cmdlet New-Object schlägt fehl.
Technet: about_operators -> ::-Operator für statische Elemente

Unterschiede zwischen Instanzklassen und statischen Klassen habe ich anhand der Stringklasse hier etwas genauer beschrieben.

 

Beispiel 2: Anwenden der Klasse [math] - mathematisches Runden einer Zahl und Potenzieren

Set-StrictMode -Version "2.0"
Clear-Host

$Radius = 4
$Area = [math]::pi * [math]::pow($Radius,2)
"Die Fläche eines Kreise mit Radius {0} beträgt ungerundet: {1}" -f $Radius,$Area

$AreaRounded= [math]::Round($Area,2)
"Die Fläche eines Kreise mit Radius {0} beträgt auf zwei Stellen gerundet: {1}" -f $Radius,$AreaRounded
#Ausgabe

Die Fläche eines Kreise mit Radius 4 beträgt ungerundet: 50.2654824574367
Die Fläche eines Kreise mit Radius 4 beträgt auf zwei Stellen gerundet: 50.27

 

2 Ausgabe filtern

Die Ausgabe eines Skriptes lässt sich in Powershell auf vielfältige Art kontrollieren, filtern und formatieren.

 

2.1 Ausgabe einschränken

Mit dem cmdlet "Select-Object" lassen sich einfach Ausgaben sowohl in der Anzahl der Spalten (Beispiel 1), als auch in der Anzahl der Zeilen (Beispiel 2) einschränken. siehe Technet: Select-Object

Beispiel 1a: Anzeige aller aktiven Netzwerkadapter mit SettingID und IPAdresse (Select-Object)

Set-StrictMode -Version "2.0"
Clear-Host

$Query = "Select IPAddress,SettingID from Win32_NetworkAdapterConfiguration where IPenabled = 'true'"
Get-WmiObject  -query $Query | Select-Object SettingID,Ipaddress | Format-Table -auto
#mögliche Ausgabe

SettingID                                                   IPaddress
---------                                                   ---------
{746C4685-11EC-4AC3-ABA1-70FC4AB496C0}                      {0.0.0.0}
{4DCA670C-1E42-4524-9B88-88A0A13E7E82}                      {0.0.0.0}
{459EFFE8-F4E2-467F-B9F4-44247EC581E7}                      {192.168.235.1}
{4B1C2490-68AB-4378-A658-3DB95E2EA604}                      {192.168.18.1}  

$Query ist ein in WQL (=WMI Query Language) geschriebenes Statement, das über die WMI-Klasse "Win32_NetworkAdapterConfiguration" die Eigenschaften  IPAddress und SettingID von denjenigen Netzwerkkarten ausliest, deren Eigenschaft IPenabled='true' ist.

Man kann die ausgegebenen Eigenschaften mit Select-Object einschränken. Etwas Einfluss auf die Ausgabe wie den Spaltenabstand kann man noch über die Pipe "| Format-Table -auto" nehmen. Mehr Möglichkeiten ohne größeren Mehraufwand auf das Ausgabeformat hat man, wenn man jedes Element des Arrays über eine ForEach-Schleife ausgibt. Im folgenden Beispiel ist das gezeigt.


Beispiel 1b: Anzeige aller aktiven Netzwerkadapter mit SettingID und IPAdresse (ForEach)

Set-StrictMode -Version "2.0"
Clear-Host

$Query= "select IPAddress,SettingID from win32_networkadapterconfiguration where IPenabled='true'"
Get-WmiObject -query $Query | Foreach{
  "{0}  {1}  {2}" -f $($_.SettingID),$($_.Ipaddress[0]),$($_.Ipaddress[1])}
#Ausgabe

{A358329B-91EA-4E55-8956-098AAF118EF7}  192.168.178.22  fe80::810c:77bd:b204:937a

 

Beispiel 1c: Anzeige aller IPAdressen eines aktiven Netzwerkadapters

Set-StrictMode -Version "2.0"
Clear-Host

$Query= "Select IPAddress,SettingID from Win32_NetworkAdapterConfiguration where IPenabled = 'true'"
Get-WmiObject  -query $Query | Select-Object -Expand IpAddress
#mögliche Ausgabe

192.168.1.19
10.10.3.9
8.192.129.127
fe80::c998:5763:f73:1057


Beispiel 2: die drei ältesten Dateien eines Ordners anzeigen

Set-StrictMode -Version "2.0"
Clear-Host
 

$Folder = "c:\test"
Get-ChildItem $Folder | Sort-Object LastWriteTime -descending | Select-Object -last 3

#mögliche Ausgabe
 
    Directory: Microsoft.PowerShell.Core\FileSystem::C:\windows

Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        18.02.2007     13:00      26680 River Sumida.bmp
-a---        18.02.2007     13:00      17362 Rhododendron.bmp
-a---        18.02.2007     13:00     224768 regedit.exe


Für einfache, einmalige Übrsichten ist die Ausgabe so oft schon ausreichend. Mehr Möglichkeiten Tabellen zu formatieren, zeige ich im nächsten Kapitel 3 "Formatierte Tabellen"

 

3 Formatierte Tabellen

3.1 Selbstdefinierte Spalten zu Format-Table hinzufügen

Den Output vieler cmdlets kann man sehr einfach filtern und auf verschiedene Weisen darstellen, in dem man die Ausgabe an Ausgabe-Cmdlets wie Format-Table, Format-List, Sort-Object, Group-Object oder Select-Object weiterpiped. Wenn aber die durch diese cmdlets erstellten Tabellen etwas individueller formatiert oder berechnete Werte als Spalten hinzugefügt werden sollen, muss man sich etwas genauer mit diesen cmdlets beschäftigen.

 

Beispiel 1a: Ausgabe von "Format-Table" um selbstdefinierte Spalten ergänzen  

Set-StrictMode -Version "2.0"
Clear-Host

 
#Testprozesse aufrufen 
For ($Count=0;$Count -le 2;$Count++){
 
  Notepad.exe
  }

 
#Daten erzeugen und ausgeben
Get-Process notepad | Format-Table ProcessName,
@{
  Label="TotalRunningTime"
  Expression={(Get-Date) - $_.StartTime}

   },
StartTime -autosize
#Ausgabe

ProcessName TotalRunningTime StartTime          
----------- ---------------- ---------          
notepad     00:55:13.3478457 26.01.2011 21:28:26
notepad     00:55:09.3634707 26.01.2011 21:28:30
notepad     00:07:18.9146166 26.01.2011 22:16:20

siehe auch : Technet: Format-Table

Die erste Spalte "Processname" und dritte Spalte  "Starttime", sowie die Option "-autosize" sind nichts Außergewöhnliches. Interessant ist hingegen die zweite Spalte "TotalRunningTime", da "Get-Process" eine solche Eigenschaft nicht anbietet.
Hilfe bringt hier eine Hashtabelle @{}, die in diesem Beispiel den Schlüssel "Label" mit dem String "TotalRunningTime" und den Schlüssel "Expression" mit dem Scriptblock {(Get-Date) - $_.StartTime} enthält. 

Richtig schön sieht die Ausgabe oben weder mit der Option "-autosize", noch ohne diese aus. In der Hashtabelle für Format-Table gibt es daher noch die Schlüssel "width", "alignment" oder "align" und "formatstring", um die Ausgabe optisch weiter zu optimieren. Zusätzlich formatiere ich die Zeiten über den Formatoperator "-f" (siehe Kapitel 1 oben)

 

Beispiel 1b: weitere Formatierung der Ausgabe von Format-Table

Set-StrictMode -Version "2.0"
Clear-Host

 
#Testprozesse aufrufen 
For ($Count=0;$Count -le 2;$Count++){
  Notepad.exe
  }

 
#Daten erzeugen und ausgeben
Get-Process notepad | Format-Table `
@{
  Label="Prozess";
  Expression={"{0}" -f $_.ProcessName};
  Width=10
 },
@{
  Label="GesamtLaufzeit";
  Expression={"{0:hh}h {0:mm}m {0:ss}s" -f $((Get-Date)-($_.StartTime))};
  Width=18
 },
@{
  Label="Startzeit";
  Expression={"{0:T}" -f ($_.StartTime)};
 }
#mögliche Ausgabe

Prozess    GesamtLaufzeit     Startzeit
------     --------------     ---------
notepad    17h 54m 36s        17:21:38
notepad    17h 54m 31s        17:21:42
notepad    17h 54m 41s        17:21:33

Durch das Schlüsselwort "Width" kann man den Abstand zwischen den Spalten beeinflussen. 


Beispiel 2: Mit "Format-Table" den vorhandenen und belegten Speicherplatz anzeigen

Set-StrictMode -Version "2.0"
Clear-Host


Get-WmiObject Win32_LogicalDisk | Format-Table `
    @{Label="ID";
      Expression={"{0}" -f ($_.DeviceID)}
      Width=3;
      Align="Right";
     },
    @{Label=$(" "*2) +  "Free in MB";
      Expression={"{0:0.0}" -f ($_.Freespace/1MB)};
      Width=13;
      Align="Right";
     },

     @{Label=$(" "*2) +  "Size in MB";
      Formatstring="{0:0.00}"
      Expression= {$_.Size/1MB}
      Width=13;
      Align="Right";
     }
#Ausgabe

ID    Free in MB    Size in MB
 --  ------------  ------------
 C:       80950,3     152624,85
 E:           0,0       2414,53
 I:       48186,0      51191,46
 K:      614301,7     614392,09
 S:       78860,5    1638400,00

Man ist wahlfrei, ob man, wie in der zweiten Spalte "Free in MB" den Formatoperator -f oder den Formatstring wie in der dritten Spalte Size in MB" benützt. Siehe Kapitel 1

  • Der Schlüssel "Width" gibt die Feldbreite an, die eine Spalte belegt. 
  • Der Schüssel "Align" oder "alignment" legt die Ausrichtung fest ("left","right","center") 

Damit lassen sich jetzt schon ansehlich formatierte Tabellen erstellen

Je nach verwendetem cmdlet stehen verschiedene Schlüssel für die Hashtabellen zur Verfügung: thepowershellguy.com - New-CustomColumn function

 

Beispiel 3: Arbeiten mit der SI-Notation (Scietific Notation) 
Kaum eine Maßeinheit wird im alltäglichen Leben über einen so großen Wertebereich benutzt wie das Byte.
Der Datenbankprogrammierer möchte für jeden Wert in seiner Datenbank möglichst wenig Speicherplatz verbrauchen und macht sich Gedanken, ob er einem Feld 4 oder 8 Bytes Länge zuweist.
Spricht derselbe Programmierer über die Gesamtgröße seiner Datenbank auf der Festplatte werden schnell Milliarden und Billionen von Bytes erreicht.

Üblicherweise benutzt man für eine übersichtlichen Darstellung die standardisierte SI-Notation Wikipedia: Wissenschaftliche Notation, die auch Powershell beherrscht

1kB
0.5kB
1+1kB+1Mb+1GB+1TB+1PB
#Ausgabe

1024
512
112700049326182

Nach PetaByte (PB = 10 hoch 15) ist allerdings Schluss.

Anbei noch zwei Beispiele, in denen ich die Formatierung selbst in eine Variable packe und diese Variable dann im cmdlet Format-Table verwende. Diese Schreibweise finde ich etwas übersichtlicher

 

Beispiel 4: Eine einzelne Spalte einer Tabelle gesondert formatieren

Set-StrictMode -Version "2.0"
Clear-Host

$myFormat = "ProcessName",@{Label = "WS (MB)"; Expression = {"{0:#.##}" -f $($_.WS/1mb)}; Align = "Center"},"NPM"
Get-Process W* | Format-Table $myFormat -auto
#Ausgabe

ProcessName WS (MB)  NPM
----------- -------  ---
wmiprvse     5,64   4320
wmiprvse     6,47   4560


Beispiel 5: vier formatierte Spalten

Clear-Host
Set-StrictMode -Version "2.0"

$myFormat =
      @{Label = " Name "  ; Expression = {"{0}" -f $_.Name}          ; Align = "Center"; Width = 10},
       @{Label = " WS(MB) "; Expression = {"{0:0.00}" -f $($_.WS/1mb)}; Align = "Center"; Width = 12},
       @{Label = " NPM "   ; Expression = {"{0}" -f $_.NPM}           ; Align = "Center"; Width = 10},
       @{Label = " CPU " ; Expression =   {"{0:0.00}" -f $_.CPU}      ; Align = "Right" ; Width = 10}

Get-Process WMI* | Format-Table $myFormat
#Ausgabe

  Name       WS(MB)       NPM           CPU
  ------     --------     -----         -----
 wmiprvse      5,64        4240         2,27
 wmiprvse      6,46        4480         1,11

Die Leerzeichen im Code habe nur der Übersichtlichkeit wegen eingefügt. Diese haben sonst keine Auswirkungen auf die Ausgabe


3.2 Tabellen mit einer For-Schleife erstellen

Beispiel 1: eine Tabelle aus .Net formatierten Strings erstellen

Wenn man Array mit einer Foreach-Schleife durchläuft, ist man noch flexibler mit der Ausgabe. Es können Bedingungen "if ($_.TotalSize -gt 0)" eingebaut werden, um die Ausgabe irrelevanter Informationen zu verhindern. Auch die Spaltenüberschriften können so individuell gestaltet werden.

Set-StrictMode -Version "2.0"
Clear-Host

#alle Laufwerke des Computers
$Drives=[System.Io.DriveInfo]::GetDrives()


#Computername bestimmen
$Computername=Get-Content Env:Computername

#individuelle Spaltenüberschriften
$Width_0=3
$Width_1=15
$Width_2=20
$Width_3=13
$Width_4=6+$Computername.Length
$Headline=
   "{0,$Width_0}  {1,$($Width_1):0.00}   {2,$($Width_2):0.00} {3,$($Width_3):0.0%} {4,$Width_4}" -f `
   "Drive","Totalsize in GB","Totalfreespace in GB","Percentfree","Computername"
Write-Host -BackgroundColor darkyellow -foregroundcolor darkred "$Headline`n"


#Tabelleninhalt ausgeben   
$Drives | foreach {
 if ($_.TotalSize -gt 0){  #damit unverbundene LW nicht angezeigt werden
    $Drivename=$_.Name
    $Totalsize=$($_.Totalsize)/1GB
    $TotalFreeSpace=$($_.TotalFreeSpace)/1GB
    $PercentFree=$($_.TotalFreeSpace)/$($_.TotalSize)     
    "{0,$Width_0} {1,$($Width_1):0.00} {2,$($Width_2):0.00}   {3,$($Width_3):0.0%}  {4,$Width_4}" -f `
      $Drivename,$TotalSize,$TotalFreeSpace,$PercentFree,$Computername
  }else{
    $Drivename=$_.name
    $Computername=Get-Content Env:Computername
    "{0} {1,55}" -f $Drivename,$Computername
  }
}
#mögliche Ausgabe

Drive   Totalsize in GB    Totalfreespace in GB   Percentfree     Computername

C:\          149,05                79,20            53,1%         DOM2DC01
E:\            2,36                 0,00             0,0%         DOM2DC01
I:\           49,99                47,06            94,1%         DOM2DC01
U:\         1560,00                45,58             2,9%         DOM2DC01

Beispiel 2: Eine Tabelle mit Spalten aus zwei verschiedenen Quellen erstellen

Das cmdlet "Get-Process" zeigt nicht den Besitzer eines Prozesses an. Diesen kann man über die Wmi-Klasse "Get-Process" abfragen. Das Beispiel zeigt, wie mit Hilfe einer Hashtablle und einer For-Schleife die Informationen aus beiden Quellen in einer Tabelle darstellen kann.

Set-StrictMode -Version "2.0"
Clear-Host

$Benutzer = @{}
GWmi Win32_Process | ForEach {$Benutzer[$_.Handle] = $_.GetOwner().User}

$Headline=  "{0,-15} {1,5} {2,15}" -f "Processname","ID","Benutzer"
Write-Host -BackgroundColor darkyellow -ForegroundColor darkred "$HeadLine`n"

Get-Process m* | ForEach {
  $Processname=$_.Processname
  $Id=$_.Id
  "{0,-15} {1,5} {2,15}" -f $Processname,$Id,$Benutzer[$_.Id.ToString()]
 }
#Ausgabe

Processname        ID        Benutzer

Mcshield          588          SYSTEM
McTray           4508         KarlNapf
MDM              1300          SYSTEM
MobileChecker    2096          SYSTEM
mstsc            4780        
KarlNapf

 

3.3 Tabellen mit PSObject erstellen

Auch mit selbsdefinierten Objekten lassen sich ordentliche Ausgaben produzieren.

Beispiel 1: Prozesse

Clear-Host
Set-StrictMode -Version "2.0"

$Table = (Get-Process *) | Foreach{
    New-Object PSObject -Property `
      @{"Name" = $_.Name;
        "CPU"  =  "{0:0.00}" -f $_.CPU  
        "WS(MB)" = "{0:0.00}" -f $($_.WS/1mb);
        "NPM" = "{0}" -f $_.NPM
     } }

$Table  | Select Name,CPU,NPM,"WS(MB)"  -First 5 | Format-Table -AutoSize
mögliche Ausgabe

Name      CPU  NPM   WS(MB)
----      ---  ---   ------
ACDaemon  0,03 12880 6,43  
ACService      7448  3,65  
armsvc         7808  3,74  
avgnt     8,46 23584 3,78  
avguard        35024 24,03

MSDN: PsCustomObject

 

Beispiel 2a: Wer ist mit meinem Rechner verbunden? (

Wahrscheinlich kennt Ihr den Befehl "netstat -an" oder auch das Sysinternaltool TCPVIEW. Damit kann man prinzipiell erkennen, mit welchen Remoterechnern der eigene Rechner gerade verbunden ist.

Allerdings sind die Ausgaben beider Tools etwas unübersichtlich. Mit der Powershell, der .Net-Klasse IPGlobalProperties und letztlich einer ordentlich formatierten Ausgabe der PSCustomObject-Tabelle erhält man diese Information recht übersichtlich.

Clear-Host
Set-StrictMode -Version "2.0"
 
Function Main{
   $IPProperties =  [System.Net.NetworkInformation.IPGlobalProperties]::GetIPGlobalProperties()
   $ActiveTCPConnections = $($IPProperties.GetActiveTcpConnections()) 
   $Table = $ActiveTCPConnections | Foreach{
     $RemoteAddress = $($_.RemoteEndPoint).Address.IPAddressToString
     $LocalAddress = $($_.LocalEndPoint).Address.IPAddressToString
     If ($RemoteAddress -ne $LocalAddress){
       New-Object PSObject -Property `
          @{"State" = $_.State;
          "RemoteAddress"  =  $($_.RemoteEndPoint).Address.IPAddressToString;  
          "LocalAddress" = $($_.LocalEndPoint).Address.IPAddressToString;
          "RemotePort" = $($_.RemoteEndPoint).Port;
          "LocalPort" = $($_.LocalEndPoint).Port;
          "RemoteHostName" = Get-DNSHostName  $($_.RemoteEndPoint).Address.IPAddressToString;
          }#PSObject
      }#Endif
    }#ForEach
 
  #Output 
  $myFormat = @{Label = "State"          ; Expression = {"{0}" -f $($_.State)}        ; Align = "Left" },
              @{Label = "LocalAddress"   ; Expression = {"{0}" -f $($_.LocalAddress)} ; Align = "Left" },
              @{Label = "LocalPort"      ; Expression = {"{0}" -f $_.LocalPort}       ; Align = "Left" },
              @{Label = "RemoteAddress"  ; Expression = {"{0}" -f $_.RemoteAddress}   ; Align = "Left" },
              @{Label = "RemotePort"     ; Expression = {"{0}" -f $_.RemotePort}      ; Align = "Left" },
              @{Label = "RemoteHostName" ; Expression = {"{0}" -f $_.RemoteHostName}  ; Align = "Left" }
 
$Table | Sort State | Format-Table $myFormat  -AutoSize
 
}#Main
 
Function Get-DNSHostName{
  Param($RemoteAddress)
    Try{
      $RemoteHostName = $([System.Net.Dns]::GetHostEntry($RemoteAddress)).HostName
    }Catch{
      $RemoteHostName ="Unknown Hostname"
    }#Try/ Catch
    Return $RemoteHostName
}#Function
 
Main

#mögliche Ausgabe

 

State       LocalAddress   LocalPort RemoteAddress   RemotePort RemoteHostName                
-----       ------------   --------- -------------   ---------- --------------                
Established 192.168.178.57 58322     77.234.41.63    80         r-063-041-234-077.ff.avast.com
Established 192.168.178.57 59459     198.252.206.25  80         stackoverflow.com             
Established 192.168.178.57 59488     74.125.136.188  5228       ea-in-f188.1e100.net          
Established 192.168.178.57 59500     74.125.136.125  5222       ea-in-f125.1e100.net          
Established 192.168.178.57 59504     192.168.178.56  8009       Chromecast.fritz.box          
Established 192.168.178.57 59508     192.168.178.56  8008       Chromecast.fritz.box          
Established 192.168.178.57 60298     173.194.116.137 443        Unknown Hostname              
Established 192.168.178.57 60299     173.194.116.132 443        Unknown Hostname   
TimeWait    192.168.178.57 2869      192.168.178.25  36258      SamsungTabNote10.fritz.box    
TimeWait    192.168.178.57 2869      192.168.178.25  58514      SamsungTabNote10.fritz.box    
TimeWait    192.168.178.57 60288     194.25.94.155   80         Unknown Hostname              

Die Ausgabe zeigt die Verbindungen auf meinem Homerechner

 

Wenn Ihr Eure Verbindungen genauer analysieren wollt, schließt vor der Ausführung der Skripts erstmal alle Browser, unterbrecht mal kurz die Netzverbindung und schließt beispielsweise mit TCPView alle aufgebauten ("Established") Verbindungen. Dann habt ihr einen sauberen Startpunkt.

Die  Verbindungen, die  mit [System.Net.DNS] nicht aufgelöst werden können ("Unknown Hostname") kann man durch Googlen nach der IP-Adressen weiter analysieren. 

 

Ab Windows 8.1 / Powershell 4.0 liefert übrigens das cmdlet Get-NetTCPConnection eine ähnliche Ausgabe

Hey, Scripting Guy!:  Use PowerShell to Identify Port Connections in Windows 8

 

Beispiel 2b: Wer ist mit meinem Rechner verbunden

Das Skript liefert das exakt gleiche Ergebnis wie Beispiel 2a. Es wird hier nur das cmdlet Get-NetTCPConnection anstelle der .Net-Klasse IPGlobalProperties verwendet. Das cmdlet vereinfacht das Skript etwas, dafür ist es ab PS 4.0 lauffähig.

#Skript benötigt Powershell 4.0 (Get.NetTCPConnection)
#alternativ siehe Beispiel 2a
 
Clear-Host
Set-StrictMode -Version "2.0"
 
Function Main{
  $NetTCPconnections = Get-NetTCPConnection
 
  $Table = $NetTCPConnections | Foreach{
     If ($_.RemoteAddress -ne $_.LocalAddress){
       New-Object PSObject -Property `
          @{"State" = $_.State;
          "RemoteAddress"  =  $_.RemoteAddress;  
          "LocalAddress" = $_.LocalAddress;
          "RemotePort" = $_.RemotePort;
          "LocalPort" = $_.LocalPort;
          "RemoteHostName" = Get-DNSHostName  $($_.RemoteAddress);
          }#PSObject
      }#Endif
    }#ForEach
 
  #Output 
  $myFormat = @{Label = "State"          ; Expression = {"{0}" -f $($_.State)}        ; Align = "Left" },
              @{Label = "LocalAddress"   ; Expression = {"{0}" -f $($_.LocalAddress)} ; Align = "Left" },
              @{Label = "LocalPort"      ; Expression = {"{0}" -f $_.LocalPort}       ; Align = "Left" },
              @{Label = "RemoteAddress"  ; Expression = {"{0}" -f $_.RemoteAddress}   ; Align = "Left" },
              @{Label = "RemotePort"     ; Expression = {"{0}" -f $_.RemotePort}      ; Align = "Left" },
              @{Label = "RemoteHostName" ; Expression = {"{0}" -f $_.RemoteHostName}  ; Align = "Left" }
 
$Table = $Table | Where {$_.RemotePort -ne 0} 
$Table | Sort State | Format-Table $myFormat  -AutoSize
 
 }
 
Function Get-DNSHostName{
  Param($RemoteAddress)
    Try{
      $RemoteHostName = $([System.Net.Dns]::GetHostEntry($RemoteAddress)).HostName
    }Catch{
      $RemoteHostName ="Unknown Hostname"
    }#Try/ Catch
    Return $RemoteHostName
}#Function
 
Main

#mögliche Ausgabe identisch zu Beispiel 2a

 

3.4 Tabellen mit "Out-GridView"

Liefern cmdlets grössere Tabellen zurück, kann auch das cmdllet "out-gridview" eine interessante Möglichkeit sein, Daten einfach und trotzdem ansprechend darszustellen.

Beispiel 1: Inhalte eines Verzeichnisse

(Get-ChildItem -path c:\windows ) | Out-Gridview

 

3.5 Mehrspaltige Tabellen eines Datenfeldes/ Arrays

Windows IT Pro - Jeffery Hicks: How to use the Format-Wide, Format-Table, and Format-List cmdlets

Oftmals hat man größere Arrays mit einigen hundert oder gar tausend Elementen, die man ausgeben möchte. Jedes Arrayelement in einer Extrazeile auszugeben, macht die Bildschirmausgabe nahezu wertlos. Unter Powershell.org habe ich dazu zwei sehr schöne Tipps bekommen, die Ihr im folgenden Beispiel sehen könnt.

 

Beispiel 1: mehrspaltige Anzeige der installierten Hotfixe auf einem Rechner (Win32_QuickFixEngineering)

Das Auslesen der Hotfixe dient hierl nur zum Erzeugungen eines Beispielarrays mit Praxisbezug

Set-StrictMode -Version "2.0"
Clear-Host

#Auslesen der installierten Hotfixe in ein Array
$HotFixes = Get-WmiObject -class Win32_QuickFixEngineering -computername "." `
  -filter "Description like '%Security%'"
$HotFixes = $Hotfixes | Sort-Object -property HotFixID

#Ausgabe
Write-Host '1. $HotFixes | Format-Wide {$_.HotFixID} -AutoSize -Force' -BackgroundColor DarkYellow
$HotFixes | Format-Wide {$_.HotFixID} -AutoSize -Force

Write-Host '2. $Hotfixes | Format-Wide {$_.HotFixID} -Column 4 -Force' -BackgroundColor DarkYellow
$Hotfixes | Format-Wide {$_.HotFixID} -Column 4 -Force

Write-Host "3. Schleife" -BackgroundColor DarkYellow
$ColumnCount = 4
For ($i=0; $i -lt $HotFixes.count; $i += $ColumnCount)
  { $HotFixes[$i..($i+$ColumnCount-1)].HotFixID -join "`t"}
#mögliche Ausgabe (gekürzt)


1. $HotFixes | Format-Wide {$_.HotFixID} -AutoSize -Force

KB2305420   KB2393802   KB2479943   KB2491683  KB2506212  KB2509553  KB2511455
KB2532531   KB2536275   KB2536276   KB2544893  KB2560656  KB2564958  KB2570947
KB2579686   KB2584146   KB2585542   KB2604115  KB2618451  KB2619339  KB2620704
...
KB2770660   KB2778344   KB2778930   KB2785220  KB2789645  KB2790113  KB2790655
KB2792100   KB2797052   KB2799494                                              


2. $Hotfixes | Format-Wide {$_.HotFixID} -Column 4 -Force

KB2305420           KB2393802           KB2479943           KB2491683          
KB2506212           KB2509553           KB2511455           KB2532531          
KB2536275           KB2536276           KB2544893           KB2560656          
...            
KB2789645           KB2790113           KB2790655           KB2792100          
KB2797052           KB2799494                                                  


 
3. Schleife
 
KB2305420    KB2393802    KB2479943    KB2491683
KB2506212    KB2509553    KB2511455    KB2532531
...
KB2789645    KB2790113    KB2790655    KB2792100
KB2797052    KB2799494

 

4 Die Console anpassen

Manchmal möchte man seine Konsolenausgabe durch den Einsatz von Farbe aufwerten. In begrenztem Maße ist dies mit der Powershell recht einfach möglich.

 

Beispiel 1: Welche Farben bieten Powershell und .Net an

Set-StrictMode -Version "2.0"
Clear-Host

 
$ConsoleColors = [System.ConsoleColor] | Get-Member -Static -Membertype Property
$ConsoleColors | Format-Wide {$_.Name} -Auto

 
# alternativ
#
$ConsoleColors = [System.ConsoleColor] | Get-Member -Static -Membertype Property
#Ausgabe

Black         Blue          Cyan         DarkBlue     DarkCyan     DarkGray    
DarkGreen     DarkMagenta   DarkRed      DarkYellow   Gray         Green       
Magenta       Red           White        Yellow         

 

Beispiel 2: Zeilen farblich hervorheben

Falls gewisse Werte einen Schwellwert über- oder unterschreiten, könnte man diese Werte farblich hervorheben.

$a = 5
if($a -le 10){
      Write-Host -BackGroundColor red $a
   }Else{
      Write-Host $a
   }

Technet: Write-Host

 

Beispiel 3: die ganze Konsole verändern

Im Kapitel Grundlagen -> MyPowershell -> 3.3.1.2 Beispiele für Profile haben wir  auf die Konsoleneigenschaften zugegriffen und diese verändert

$h=Get-Host

$Win = (Get-Host).UI.RawUI
$Win.BackgroundColor = "Gray"
$Win.ForegroundColor = "DarkBlue"

$Win_size = $Win.Windowsize
$Win_size.Height=45
$Win_size.Width=110
$h.ui.Rawui.Set_Windowsize($Win_size)
Clear-Host

Die Klassen hinter Get-Host "System.Management.Automation.Internal.Host.InternalHost" finde ich nicht so richtig übersichtlich aufgebaut.

Daher würde ich eher mit .Net Klassen die Konsole verändern. 

MSDN: Console Class

[System.Console]::BackgroundColor="Gray"      #Property
[System.Console]::ForegroundColor="DarkBlue"  #Property
[System.Console]::Title="Karl Napf"           #Property
[System.Console]::SetWindowsize(110,45)       #Methode
[System.Console]::Beep()                      #Methode    
[System.Console]::Clear()                     #Methode

Wenn wir uns die statischen Eigenschaften der Klasse "Console" ansehen, finde ich den Weg über die .Net Klasse verständicher.

 

Statische Methoden und Eigenschaften der Klasse Console

[System.Console] | Get-Member -Static  | Format-Wide {"$($_.Name) ($($_.MemberType))" } -Column 3
#Ausgabe

CancelKeyPress (Event)                  Beep (Method)                           Clear (Method)
Equals (Method)                         MoveBufferArea (Method)                 OpenStandardError (Method)
OpenStandardInput (Method)              OpenStandardOutput (Method)             Read (Method)  
ReadKey (Method)                        ReadLine (Method)                       ReferenceEquals (Method)
ResetColor (Method)                     SetBufferSize (Method)                  SetCursorPosition (Method)
SetError (Method)                       SetIn (Method)                          SetOut (Method)
SetWindowPosition (Method)              SetWindowSize (Method)                  Write (Method)
WriteLine (Method)                      BackgroundColor (Property)              BufferHeight (Property)
BufferWidth (Property)                  CapsLock (Property)                     CursorLeft (Property)
CursorSize (Property)                   CursorTop (Property)                    CursorVisible (Property)
Error (Property)                        ForegroundColor (Property)              In (Property)
InputEncoding (Property)                IsErrorRedirected (Property)            IsInputRedirected (Property)
IsOutputRedirected (Property)           KeyAvailable (Property)                 LargestWindowHeight (Property)
LargestWindowWidth (Property)           NumberLock (Property)                   Out (Property)
OutputEncoding (Property)               Title (Property)                        TreatControlCAsInput (Property)
WindowHeight (Property)                 WindowLeft (Property)                   WindowTop (Property)

Technet - ScriptingGuy: Use .NET Classes to Configure the Windows PowerShell Console

 

Beispiel 4: Farben zurücksetzen

Hat man eine zu grausame Farbkombination für die StandardConsole- etwa grüne Schrift auf cyan Hintergrund - gewählt, hilft

[Console]::ResetColor()
[Console]::Clear()

und alle Farben der StandardConsole sind wieder im Ausgangszustand

Für die ISE existiert kein ResetColor, daher muss man dort Farbwerte angeben (siehe

$Win = (Get-Host).UI.RawUI
$Win.BackgroundColor = "Gray"
$Win.ForegroundColor = "DarkBlue"

 

5 Ausgabe im HTML-Format

Mit der Powershell lassen sich relativ einfach erstaunliche HTML-Ausgaben erzielen, die mit Hilfe von Css (Cascading Style Sheets) sehr ansprechend formatiert werden können. Selbst habe ich weder mit Html noch mit Css viel Erfahrung. Viele Ausführungen darüber werden daher mein Anfängerniveau besitzen. Andererseits schaffe es selbst ich, mit diesem Beginner-KnowHow bereits, ganz ansehliche Ausgaben im Browser zu erzielen, die mich anspornen, mich mit der Thematik weiter zu beschäftigen.

Mit Powershell eine mit Css formatierte Ausgabe in HTML zu erzeugen, kann man in drei relativ klar getrennte Aufgaben unterteilen

  1. Erzeugen der RohDaten mit Native-Powershell
  2. Strukturieren der RohDaten in HTML
  3. Formatieren der HTMLDaten mit Css

Bevor ich diese 3 Punkte durchgehe, will ich die Grundlagen von Powershell, HTML und Css beschreiben, die für eine Ausgabe in einem HTML-Browser notwendig sind. Besonders möchte ich auf die Darstellung von Tabellen eingehen, da viele Ergebnisse aus Powershell als solche vorliegen

5.0 Einführung Powershell, HTML und CSS

Mit Html werden Daten in einer für Webbrowser verständlichen Art strukturiert dargestellt. CSS ist für die Formatierung der verwendeten Elemente in der Html-Seite, wie dem Font der Überschrift oder der Hintergrundfarbe einer Tabelle, zuständig.

Als Editor benutze ich übrigens Notepad++.

 

5.0.1 external und internal stylesheet

In diesem Kapitel und seinen beiden Unterkapiteln 5.1.1.1 (external stylesheet) und 5.1.1.2 (internal stylesheet) geht es hauptsächlich darum zu zeigen, wie der Html-Code und der CSS-Code gemeinsam in der resultierende Html-Datei (=internal stylsheet) oder in separaten Dateien (=external stylesheet *.css) platziert werden können. 
Dank ConvertTo-Html kommt man für diese Beispiel fast ohne HTML- oder HTML-Kenntnisse aus.

 

5.0.1.1 external stylesheet

Technet: ConvertTo-Html

 

Beispiel 1: Dateien eines Verzeichnisses in einer HTML-Tabelle auflisten (HTML- und CssCode sind getrennt)

Dieses Beispiel erzeugt im Abschnitt #Create Data das Array $Files mit beliebigen Beispieldaten. Weitere Elemente für die Ausgabe in die Html-Datei sind $Length, $Title und $ComputerName

Der Positionsparameter -CssUri enthält den Pfad $CSSPath zum Css-File. Unter dem Powershellskript und seiner möglichen Ausgabe seht ihr den Css-Code (File.css).

Set-StrictMode -Version "2.0"
Clear-Host

#some variables
$Path2Analyze = "C:\test"
$Path4HtmlOut = "C:\Temp\ResultExtern.html"
$CSSPath = "C:\temp\File.css"    #$PSScriptRoot
$ComputerName=$Env:Computername  

#Create Data
$Files  = Get-ChildItem -Path
$Path2Analyze | Sort -Descending Length
$Files = $Files | Select FullName,Name,
  @{Name='Length in KB' ; Expression = {($($_.Length)/1024).ToString("0.00")}}
$Files

#Length of folder
$Length=$((gci $Path2Analyze | Measure-Object -Property "Length" -Sum).Sum)
$Length = $($Length/1kb).ToString("0.00")

#Name of the browsertab
$Title = "File Overview"

#Convertion of Data ro Html
$Files | ConvertTo-Html -Title $Title `
-CssUri  $CSSPath  `
-pre "<h2>ComputerName: $Computername</h2>" `
-post "<br><I>Size of this folder: $Length KB</I>" |
Out-file $Path4HtmlOut -Encoding ascii
#mögliche Ausgabe

FullName                                Name          Length in KB
--------                                ----          ------------
C:\temp\Homes\HomeUser001\file001.txt   file001.txt   1731,38     
C:\temp\Homes\HomeUser001\tLDURr.log    tLDURr.log    620,63      
C:\temp\Homes\HomeUser001\OgWdlT.log    OgWdlT.log    288,56      
C:\temp\Homes\HomeUser001\KarlVOxoa.txt KarlVOxoa.txt 16,94       
C:\temp\Homes\HomeUser001\ue85gj.log    ue85gj.log    5,17        
C:\temp\Homes\HomeUser001\pSV4At.nul    pSV4At.nul    0,00    

 

CSS-Datei zu Beispiel 1:

@charset "UTF-8";

Body {
font-family: "Tahoma", "Arial", "Helvetica", sans-serif;
background-color:#AABBCC;
}

table
{
background-color:#CCBBAA;
border-collapse:collapse;
width:60%
}

td
{
font-size:12pt;
border:1px #0000FF solid;
padding:5px 5px 5px 5px;
}

th
{
font-size:14pt;
text-align:left;
padding-top:5px;
padding-bottom:4px;
background-color:#0000FF;
color:#FFFF00;
}

name tr
{
color:#000000;
background-color:#0000FF;
}

 File.css.txt

 HTMLextern.ps1.txt

Wenn ihr den Pfad zur CSS-Datei im Powershellskript richtig angepasst habt, könnt ihr am Ende die Datei "result.html" direkt mit dem IE/ Firefox/ Chrome etc. aufrufen und ein ähnliches Bild wie dieses erhalten

 

Im Textformat, in Notepad geöffnet, könnt ihr sehen, was das cmdlet ConvertTo-Html aus den mit Select-Object gefilterten Daten produziert hat

ResultExtern.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>File Overview</title>
<link rel="stylesheet" type="text/css" href="file:///C:/Powershell/File2Html/File.css" />
</head><body>
<h2>ComputerName: KAI-PC</h2>
<table>
<colgroup><col/><col/><col/></colgroup>
<tr><th>FullName</th><th>Name</th><th>Length in KB</th></tr>
<tr><td>C:\temp\Homes\HomeUser001\file001.txt</td><td>file001.txt</td><td>1731,38</td></tr>
<tr><td>C:\temp\Homes\HomeUser001\tLDURr.log</td><td>tLDURr.log</td><td>620,63</td></tr>
<tr><td>C:\temp\Homes\HomeUser001\OgWdlT.log</td><td>OgWdlT.log</td><td>288,56</td></tr>
<tr><td>C:\temp\Homes\HomeUser001\KarlVOxoa.txt</td><td>KarlVOxoa.txt</td><td>16,94</td></tr>
<tr><td>C:\temp\Homes\HomeUser001\ue85gj.log</td><td>ue85gj.log</td><td>5,17</td></tr>
<tr><td>C:\temp\Homes\HomeUser001\pSV4At.nul</td><td>pSV4At.nul</td><td>0,00</td></tr>
</table>
<br><I>Size of this folder: 2662,68 KB</I>
</body></html>

ConvertTo-Html sorgt dafür, dass man diese Struktur nicht selbst nachprogrammieren braucht

 

Wenn ihr die Css-Datei testweise umbenennt, so dass der Pfad nicht mehr gültig ist, würde der reine HTML-Code ohne Formatierungen dargestellt:

Mit etwas Formatierung sieht die Tabelle (wie weiter oben dargestellt) doch ansehlicher aus

 

5.0.1.2 internal stylesheet

Im letzten Kapitel habe ich ein Beispiel mit in zwei Dateien getrennt abgelegtem HTML- und CssCode gezeigt. Daher nun ein Beispiel, bei dem der CssCode von Powershell in eine einzige HTML-Datei geschrieben wird. Im Browser wird das Ergebnis völlig identisch wie im Beispiel aus dem letzten Kapitel 5.0.1.1 aussehen.

 

Beispiel 1: Dateien eines Verzeichnisses in einer HTML auflisten (HTML- und CSS-Code sind in einer Datei)

Set-StrictMode -Version "2.0"
Clear-Host

Function Main{
  #some variables
  $Path2Analyze = "C:\test"
  $Path4HtmlOut = "C:\temp\ResultIntern.html"
  $ComputerName=$Env:Computername  

  #List Files
  $Files  = Get-ChildItem -Path $Path2Analyze | Sort -Descending Length
  $Files = $Files | Select FullName,Name,
  @{Name='Length in KB' ; Expression = {($($_.Length)/1024).ToString("0.00")}}
  $Files | Format-Table -AutoSize

  #Length of folder
  $Length=$((gci $Path2Analyze | Measure-Object -Property "Length" -Sum).Sum)
  $Length = $($Length/1kb).ToString("0.00")

  #Name of the browsertab
  $Title = "File Overview"

  #ConvertTo-Html
  $CSSHead = Get-CSSHead
  $Files |
  ConvertTo-Html -Title $Title `
  -Head  $CSSHead `
  -pre "<h2>ComputerName: $computername</h2>" `
  -post "<br><I>Size of this folder: $Length KB</I>" |
  Out-file $Path4HtmlOut -Encoding ascii
}

Function Get-CSSHead{
  $CssHead = @'
 
  <Style>
  @charset "UTF-8";
  Body {
    font-family: "Tahoma", "Arial", "Helvetica", sans-serif;
    background-color:#AABBCC;
  }

  table
  {
    background-color:#FFBBAA;
    border-collapse:collapse;
    width:60%
  }

  td
  {
    font-size:12pt;
    border:1px #0000FF solid;
    padding:5px 5px 5px 5px;
  }

  th
  {
    font-size:14pt;
    text-align:left;
    padding-top:5px;
    padding-bottom:4px;
    background-color:#0000FF;
    color:#FFFF00;
  }

  name tr
  {
    color:#000000;
    background-color:#0000FF;
  }
  </Style>
'@
  Return $CssHead
}

Main

Diese Datei herunterladen (HTMLintern.ps1.txt) HTMLintern.ps1.txt

Der Aufruf der erstellten Result.html bringt wie schon erwähnt natürlich dasselbe Ergebnis wie im letzten Kapitel.

Am eigentlichen Powershellcode habe ich nur den Positionsparameter -CssUri durch den Parameter -Head ersetzt, der nun die Css-Definition der HTML-Datei repräsentiert. Weiter lege ich im Powershellskript die unveränderte Css-Definition aus dem letzten Beispiel in der Here-Variable $CssHead ab. Einzig die Tags <Style> und </Style> umschließen den CssCode zusätzlich.

HTML- und CssCode liegen nun in einer einzigen Datei, die von überall her geöffnet werden kann. Dafür kann das Design der entstandenen HTML-Files nicht mehr bequem an einer Stelle manipuliert werden. Je nach Einsatz wird die eine oder andere Variante (interne/ externer CssCode) besser geeignet sein.

 

5.0.2 HTML und CSS

Die Beispiele im letzten Kapitel sind fachlich betrachtet sehr einfach, aufgrund ihrer Länge aber etwas unübersichtlich. Ich werde in diesem Kapitel, in dem ich versuche, die notwendigen Grundstrukturen von HTML und Css darzustellen, daher auf Powershellcode zu verzichten und nur HTML- und CssCode zeigen.
In späteren Kapiteln wird es darum gehen, diesen Code von Powershell selbst erstellen zu lassen, sei es mit Hilfe von ConvertTo-Html oder native über Textausgaben

Über HTML/ HTML und Css gibt es jeweils zahlreiche Bücher, Onlinetutorials und Referenzen (das bekannteste Onlinetutorial ist: SELFHTML). Das Problem für Einsteiger in diese Themen, zu denen ich auch gehöre und an die sich dieses Kapitel richtet, eines solch großen Informationsangebotes ist es den richtigen Einstieg und den tatsächlich relevanten Teil der Informationen zu finden.

Ich möchte hier nun die Grundlagen zu HTML und Css vorstellen, die ich mir in einigen Tagen und Wochen Selbsstudium erarbeitet habe, um Powershellausgaben in ansehliche HTML-/Css Seiten zu bringen.

 

5.0.2.1 Unterschiede zwischen XHTML, HTML 4.0 und HTML5

XHTML ist ein näher an den XML-Standard angelehntes, neuformuliertes HTML 4.01, dem seit 1999 bis heute (Stand: Ende 2013) offiziell vom World Wide Web Consortium (W3C) verabschiedeten Standard von HTML. Die aktuelle XHTML Version ist XHTML 1.1, die weitestgehend dem Standard von 1.0 entspricht. (Unterschiede findet ihr im XHTML - WikipediaLink)

Wikipedia: Fertigstellung von HTML5

"Laut dem Zeitplan des W3C soll HTML5 2014 offiziell verabschiedet, d. h. zu einer W3C Recommendation werden. Im Mai 2011 erhielt HTML5 beim W3C den Status „Last Call“, ... Die WHATWG hat den Status „Last Call“ bereits am 27. Oktober 2009 ausgerufen. Der Status „Last Call“ bedeutet aber auch, dass HTML5 faktisch bereits einen fertigen Zustand angenommen hat, In den meisten Browsern ist HTML5 bereits (wenn auch unvollständig) implementiert. .. können Webentwickler Teile von HTML5 also bereits heute (gegebenenfalls mit einem Fallback) einsetzen. Diese Empfehlung spricht auch das W3C aus."

HTML5 ist faktisch damit bereits jetzt der Nachfolger von XHTML und HTML 4.01

Wenn ihr im Kapitel 5.1.1.1 external stylesheet den HTML-Code der Datei ResultExtern.html betrachtet (das türkisblaue Textfeld), erkennt ihr an den ersten drei Zeilen, dass das Powershellcmdlet ConvertTo-Html offenbar eine Datei im Format XHTML 1.0 erzeugt hat:

Die verschiedenenen Dokumentypangaben 

XHTML 1.0

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"  
       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">

 


HTML 4.01

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
       "http://www.w3.org/TR/html4/strict.dtd">

 


HTML5

<!DOCTYPE html>

Wikipedia: Die Dokumenttypangabe

"Die Dokumenttypangabe in HTML5-Dokumenten besteht aus der Zeichenkette „<!DOCTYPE html>“, wobei Groß- und Kleinschreibung keine Rolle spielen. Diese Zeichenkette bewirkt in allen modernen Browsern das Verarbeiten des Quelltextes im standardkonformen Modus.
Da ein Browser HTML-Dokumente nicht nach ihrer Version unterscheidet, wurde bewusst auf jede Art von Versionierung verzichtet. Auch hier zeigt sich, dass HTML5 sich als Obermenge von HTML 4.01 definiert."

Nach den eben gemachten Ausführungen bietet sich im Herbst 2013 folgendes Bild für die Powershell V3.0:

  • Offiziell von der W3C freigegeben sind die Standards HTML 4.01 und XHTML 1.1
  • Das Powershell Version 3 cmdlet ConvertTo-Html liefert seine Ausgabe im Standard  XHTML 1.0
  • Der faktische Standard, der höchstwahrscheinlich 2014 zum offiziellen Standard erhoben wird und der XHTML und HTML 4.01 ablösen wird, ist HTML5

Ich werde insbesondere aufgrund des dritten Punktes meine Beispiele in HTML5 schreiben. Code in XHTML ist kompatibel zu HTML5.

Im weiteren Verlauf dieses Kapitels verwende ich HTML gleichbedeutend zu HTML5 verwenden!

 

5.0.2.2 Kurzeinführung in HTML

Wie schon mehrfach erwähnt, besitze ich erstens nur wenig Erfahrung in der Webprogrammierung und zweitens existieren genügend Quellen, um sich in HTML einzuarbeiten. Daher werde ich hier nur auf die für die nachfolgenden Kapitel wichtigen Strukturen ausführlicher eingehen und verweise ansonsten auf externe Seiten, auf denen ich mich selbst informiert habe.

 

5.0.2.2.1 Reines HTML5

HTML5 besteht unter anderen aus sogenannten Elementen, von denen ich hier einige kurz beschreibe.

Mehr Elemente findet ihr bei SELFHTML: HTML-Referenz

Beispiel 1: Grundgerüst einer HTML5-Datei

<!DOCTYPE HTML>
<html>
<head>
<title>Titel</title>
</head>
<body>
 <!-- content -->
</body>
</html>

Die erste Zeile mit der Dokumenttypangabe "<!DOCTYPE HTML>" wurde bereits in Kapitel 5.1.2.1 Unterschiede zwischen XHTML, HTML 4.0 und HTML5 behandelt. Die weiteren Elemente und Tags dieses Grundgerüsts sind in jeder HTML-Datei notwendig. 

Auf die die einzelnen Tags will ich nicht näher eingehen, sondern nur einige Stichpunkte zu diesem HTML-Code geben

  • Ein Element (etwa: "html" )besteht meist aus einem öffnenden und schließenden Tag (beispielsweise <html> und </ html> 
  • Man ist außerdem bei HTML frei, ob man die Tags hintereinander in einer Zeile, durch Leerzeichen oder Zeilenumbrüche getrennt schreibt.
  • Leerzeichen und Zeilenumbrüche im Code werden ingnoriert.
  • Den Code speichert man in einer Datei *.htm oder *.html. und ruft diese in einem aktuellen Browser auf
  • Ein Kommentar in HTMl liegt zwischen <!--  und   -->  :   <!-- Beispielkommentar -->

Eine gute Beschreibung zu "Elemente und Tags" findet ihr wieder auf SELFHTML

 

Beispiel 2: Manuell eine unformatierte, reine HTML-Tabelle erstellen

Ich habe im folgenden Beispiel einfach die Ergebnisse eines Powershellcodes manuell in reines HTML übertragen. Es handelt sich dabei um 5 Datensätze von Dateien aus einem Unterverzeichnis meiner Festplatte mit den Feldern "Name","Length","LastwriteTime" und "Mode". Der Powershellcode ist nichts besonderes, daher nur als Dowload

 GetExampleFileData.ps1.txt

Die Powershellausgabe als HTML (manuell erstellt) sieht dann etwa so aus:

<!DOCTYPE HTML>
<html>
<head>
<title>     Eine   einfache HTML5-Tabelle    </title>
</head>
<body>

<!-- Das ist übrigens ein Kommentar -->
<br />   
<div> Das ist die Tabellen&uumlberschrift </div>
<br />

<table>
<tr><th>Name</th><th>Length</th><th>LastWriteTime</th><th>Mode</th></tr>
<tr><td>File1.txt</td><td >60</td><td >26.09.2013</td><td >-a---</td></tr>
<tr><td>File2.txt</td><td>737</td><td>20.09.2013</td><td>-a---</td></tr>
<tr><td>File3.txt</td><td>2315</td><td>25.09.2013</td><td>-a---</td></tr>
<tr><td>File4.txt</td><td>3311579</td><td>27.09.2013</td><td>-a---</td></tr>
<tr><td>File5.txt</td><td>3194</td><td>28.09.2013</td><td>-a---</td></tr>
</table>
 
</body>
</html>

 

Das Ergebnis sieht im Browser erwartungsgemäß recht unspektakulär etwa so aus:

Folgende HTML-Elemente sind für eine Tabelle wichtig: ( SELFTHTML: HTML-Elementreferenz)

  • Table: <table>...</table>
  • TableHeader: <th>...</th>
  • TableRow: <tr>...</tr>
  • TableData: <td>...</td>

Interessant ist die Verwendung von Umlauten in HTML: Ein "ü" muss mittels "&uuml" erzeugt werden. Für weitere Sonderzeichen schlagt bitte hier nach: SELFHTML - Zeichenreferenz

Wichtig ist, dass man den Aufbau einer Tabelle in HTML versteht, da ich eine solche Tabelle später von Powershell selbst erzeugen lassen werde. Seht euch bitte nochmal die Definition der Tabelle im HTML-Code aus Beispiel 2 weiter oben an: Eine solche Syntax (<th><tr><td>) kann man mit den Textfunktionen der Powershell sehr leicht erstellen, besonders wenn die Daten in Strukturen wie Datatables Disconnected Classes oder PsCustomObjects vorliegen.
Aber keine Sorge, falls ihr mit diesen Strukturen bisher noch wenig programmiert habt. Man muss auch nicht alles 100% verstehen, um es sinnvoll benutzen zu können.

Jetzt wollen wir erstmal die Tabelle etwas "stylen" mit der Zusatzsprache "Cascading Style Sheet" kurz Css


5.0.2.2.2 Den HTML-Code für Cascading Style Sheets vorbereiten

Im HTML-Standard ist vorgesehen, dass als Style-Sheet Sprache nicht nur und nicht für immer Css verwendet werden muss. Dem Browser kann oder soll daher mitgeteilt werden, welche Style-Sheet verwendet wird. Diese geschieht durch den sogenannten Inhaltstype "text/css", den man in den HTML-Seitenkopf einfügt. Zwingend ist diese Angabe aber noch nicht

Die zusätzliche Zeile für den Styletyp lautet

<head>
<meta http-equiv="Content-Style-Type" content="text/css">
</head>

 

 
 
Anhänge:
Diese Datei herunterladen (File.css.txt)File.css.txt[ ]0.4 kB
Diese Datei herunterladen (GetExampleFileData.ps1.txt)GetExampleFileData.ps1.txt[ ]0.2 kB
Diese Datei herunterladen (HTMLextern.ps1.txt)HTMLextern.ps1.txt[ ]0.8 kB
Diese Datei herunterladen (HTMLintern.ps1.txt)HTMLintern.ps1.txt[ ]1 kB