Beschreibt einen Sprachbefehl, mit dem Sie alle Elemente in einer (about_Foreach)

   

# THEMA
about_Foreach

# KURZBESCHREIBUNG
Beschreibt einen Sprachbefehl, mit dem Sie alle Elemente in einer
Auflistung von Elementen durchlaufen können.

# DETAILBESCHREIBUNG
Die Foreach-Anweisung (Foreach-Schleife) stellt ein
Sprachkonstrukt für das Durchlaufen (Iterieren) einer Reihe von
Werten in einer Auflistung dar.

Arrays stellen den einfachsten und häufigsten Auflistungstyp dar,
der durchlaufen wird.
In einer Foreach-Schleife werden häufig ein oder mehrere Befehle
für jedes Element in einem Array ausgeführt.

Syntax
Die Syntax der Foreach-Anweisung lautet:

foreach ($<Element> in $<Auflistung>){<Anweisungsliste>}

Foreach-Anweisung außerhalb einer Befehlspipeline.
Der in Klammern eingeschlossene Teil der
Foreach-Anweisung stellt eine Variable und
eine zu durchlaufende Auflistung dar. Bei Ausführung der
Foreach-Schleife wird die Variable ($<Element>) automatisch von
Windows PowerShell erstellt. Vor jedem Durchlaufen der Schleife
wird die Variable auf einen Wert in der Auflistung festgelegt. Der
auf eine Foreach-Anweisung folgende Block {<Anweisungsliste>}
enthält eine Reihe von Befehlen, die für jedes Element in einer
Auflistung ausgeführt werden.

Beispiele
Im folgenden Beispiel werden mit der Foreach-Schleife die Werte
im Array "$letterArray" angezeigt:

$letterArray = "a","b","c","d"
foreach ($letter in $letterArray)
{
Write-Host $letter
}

In diesem Beispiel wird das Array "$letterArray" mit den
Zeichenfolgenwerten "a", "b", "c" und "d" erstellt und initialisiert.
Bei der ersten Ausführung der Foreach-Anweisung wird die Variable
"$letter" auf den Wert des ersten Elements in $letterArray ("a")
festgelegt. Dann wird mit dem Cmdlet "Write-Host" der Buchstabe "a"
angezeigt. Beim nächsten Durchlaufen der Schleife wird $letter auf
"b" festgelegt usw. Nachdem der Buchstabe "d" von der Foreach-Schleife
angezeigt wurde, wird diese beendet.

Wenn Sie die Foreach-Anweisung als Befehl an der Windows
PowerShell-Eingabeaufforderung ausführen möchten, muss die
gesamte Anweisung auf einer Zeile stehen. Die gesamte
Foreach-Anweisung muss nicht auf einer einzelnen Zeile stehen,
wenn Sie stattdessen den Befehl in einer PS1-Skriptdatei einfügen.

Foreach-Anweisungen können auch zusammen mit Cmdlets verwendet
werden, die eine Auflistung von Elementen zurückgeben. Im
folgenden Beispiel durchläuft die Foreach-Anweisung die Liste
der vom Cmdlet "Get-ChildItem" zurückgegebenen Elemente:

foreach ($file in Get-ChildItem)
{
Write-Host $file
}

Sie können das Beispiel optimieren, indem Sie die zurückgegebenen
Ergebnisse mit einer If-Anweisung einschränken. Im folgenden Beispiel
wird von der Foreach-Anweisung die gleiche Schleife wie im vorherigen
Beispiel ausgeführt. Zur Einschränkung des Ergebnisses auf größere
Dateien als 100 KB wird jedoch eine If-Anweisung hinzugefügt:

foreach ($file in Get-ChildItem)
{
if ($file.length -gt 100k)
{
Write-Host $file
}
}

In diesem Beispiel führt die Foreach-Schleife einen Vergleich
($file.length -gt 100k) mit einer Eigenschaft der Variablen
"$file" durch. Die Variable "$file" enthält alle Eigenschaften
in dem vom Cmdlet "Get-ChildItem" zurückgegebenen Objekt. Daher
kann mehr als nur der Dateiname zurückgegeben werden. Im
nächsten Beispiel gibt Windows PowerShell die Länge und den
Zeitpunkt des letzten Zugriffs in der Anweisungsliste zurück:

foreach ($file in Get-ChildItem)
{
if ($file.length -gt 100k)
{
Write-Host $file
Write-Host $file.length
Write-Host $file.lastaccesstime
}
}

In diesem Beispiel sind Sie nicht darauf beschränkt, in einer
Anweisungsliste einen einzelnen Befehl auszuführen.

Sie können auch eine Variable außerhalb einer Foreach-Schleife
verwenden und die Variable in der Schleife erhöhen. Im
folgenden Beispiel werden Dateien über 100 KB gezählt:

$i = 0
foreach ($file in Get-ChildItem)
{
if ($file.length -gt 100k)
{
Write-Host $file "Dateigröße:" ($file.length /
1024).ToString("F0") KB
$i = $i + 1
}
}

if ($i -ne 0)
{
Write-Host
Write-Host $i "Datei(en) größer als 100 KB im aktuellen
Verzeichnis."}
else
{
Write-Host "Keine Dateien größer als 100 KB im
aktuellen Verzeichnis."
}

Im vorherigen Beispiel wurde die Variable "$i" außerhalb der
Schleife auf den Wert "0" festgelegt, und die Variable wurde in
der Schleife für jede gefundene Datei erhöht, die größer als
100 KB ist. Beim Beenden der Schleife wird mit einer
If-Anweisung den Wert von $i ausgewertet, um die Gesamtanzahl
der Dateien über 100 KB anzuzeigen. Es kann auch die Meldung
angezeigt werden, dass keine Dateien über 100 KB gefunden wurden.

Im vorangegangenen Beispiel wird auch das Formatieren der
Ergebnisse für die Dateilänge gezeigt:

($file.length / 1024).ToString("F0")

Um die Ergebnisse in Kilobytes anstelle von Bytes anzuzeigen,
wird der Wert durch 1.024 dividiert, und das Ergebnis wird mit dem
Festkomma-Formatbezeichner formatiert, um mögliche Dezimalwerte zu
entfernen. Wegen der Ziffer 0 zeigt der Formatbezeichner keine
Dezimalstellen an.

Foreach-Anweisung innerhalb einer Befehlspipeline.
Wenn Foreach in einer Befehlspipeline
enthalten ist, verwendet Windows PowerShell
den foreach-Alias, mit dem der Befehl ForEach-Object aufgerufen
wird. Wenn Sie den foreach-Alias in einer Befehlspipeline
verwenden, müssen Sie die Syntax ($<Element> in $<Auflistung>) im
Gegensatz zu einer Foreach-Anweisung nicht verwenden. Dies liegt
daran, dass die Informationen vom vorherigen Befehl in der Pipeline
bereitgestellt werden. Die Syntax des foreach-Alias in der
Befehlspipeline lautet wie folgt:

<Befehl> | foreach {<Befehlsblock>}

Beispielsweise werden von der Foreach-Schleife in der folgenden
Befehlspipeline alle Prozesse angezeigt, deren Workingset
(Speicherauslastung) größer als 20 MB ist. Die Ausgabe des Befehls
"Get-Process" wird von Windows PowerShell über die Pipeline an den
foreach-Alias übergeben. Im Befehlsblock des foreach-Alias enthält
die Variable "$_.WS" den Wert der WS-Eigenschaft (Workingset), die an
diese vom Cmdlet "Get-Process" übergeben wurde. (Der $_-Teil der
Deklaration ist eine automatische WSH-Variable [Windows Script Host],
und der WS-Teil bildet eine Eigenschaft). Die If-Anweisung bestimmt
mit einer bedingten Anweisung, ob die Größe des Workingsets 20 MB
(2.0000.000 Bytes) übersteigt. Wenn dies der Fall ist, werden der
Name des Prozesses in der Variablen "$_.name" und die Größe des
Workingsets in Megabytes angezeigt.
Andernfalls wird nichts angezeigt.

Write-Host "Prozesse mit Workingsets größer als 20 MB"
Get-Process | foreach {
if ($_.WS -gt 20m)
{
Write-Host $_.name ": "
($_.WS/1m).ToString("F0") MB -Separator ""
}
}

Der foreach-Alias unterstützt auch einleitende, mittlere und
abschließende Befehlsblöcke. Während der einleitende und der
abschließende Befehlsblock einmal ausgeführt werden, wird der
mittlere Befehlsblock bei jedem Durchlauf der Foreach-Schleife
über eine Auflistung oder ein Array ausgeführt.

Die Syntax eines foreach-Alias in einer Befehlspipeline für
eine einleitende, eine mittlere und eine abschließende Reihe
von Befehlsblöcken lautet wie folgt:

<Befehl> | foreach {<einleitender Befehlsblock>}{<mittlerer
Befehlsblock>}{<abschließender Befehlsblock>}

Im folgenden Beispiel wird die Verwendung des einleitenden, des
mittleren und des abschließenden Befehlsblocks gezeigt.

Get-ChildItem | foreach {
$fileCount = $directoryCount = 0}{
if ($_.PsIsContainer) {$directoryCount++} else {$fileCount++}}{
"$directoryCount Verzeichnisse $fileCount Dateien"}

Mit dem einleitenden Block werden zwei Variablen erstellt und
mit 0 initialisiert.

{$fileCount = $directoryCount = 0}

Der mittlere Block wertet aus, ob es sich bei den einzelnen,
von Get-ChildItem zurückgegebenen Elementen um Verzeichnisse
oder Dateien handelt:

{if ($_.PsIsContainer) {$directoryCount++} else {$fileCount++}}

Wenn es sich beim zurückgegebenen Element um ein Verzeichnis
handelt, wird die Variable "$directoryCount" um 1 erhöht.
Andernfalls wird die Variable "$fileCount" um 1 erhöht. Der
abschließende Block wird ausgeführt, nachdem der mittlere Block
die Schleife abgeschlossen hat, und gibt dann die Ergebnisse
des Vorgangs zurück:

{"$directoryCount Verzeichnisse und $fileCount Dateien"}

Mit dieser Struktur aus einleitendem, mittlerem und
abschließendem Befehlsblock sowie Pipelineoperator können Sie
das frühere Beispiel wie folgt umschreiben, um Dateien mit
einer Größe von über 100 KB zu suchen.

Get-ChildItem | foreach{
$i = 0}{
if ($_.length -gt 100k)
{
Write-Host $_.name "Dateigröße:" ($_.length /
1024).ToString("F0") KB
$i++
}
}{
if ($i -ne 0)
{
Write-Host
Write-Host "$i Datei(en) größer als 100 KB im
aktuellen Verzeichnis."
}
else
{
Write-Host "Keine Dateien größer als 100 KB im
aktuellen Verzeichnis."}
}

SIEHE AUCH
about_Automatic_Variables
about_If
Foreach-Object

C:\Windows>powershell get-help about_format.ps1xml -full

ColorConsole [Version 1.7.1000] PowerShell 2.0-Export
Microsoft Windows [Version 6.1.7600]
Copyright (c) 2014 Microsoft Corporation.