PowerShell
Schleifen

Einführung

Syntax

• für (<Initialisierung>; <Bedingung>; <Wiederholung>) {<Script_Block>}

• <Sammlung> | Foreach-Objekt {<Script_Block_with _ $ __ as_current_item>}

• foreach (<item> in <Collection>) {<Skriptblock>}

• while (<Bedingung>) {<Script_Block>}

• do {<Script_Block>} while (<Bedingung>)

• do {<Script_Block>} bis (<Bedingung>)

• <Collection> .foreach ({<Script_Block_with _ $ __ as_current_item>})

Bemerkungen

$foreach = Measure-Command { foreach ($i in (1..1000000)) { $i * $i } }
$foreachmethod = Measure-Command { (1..1000000).ForEach{ $_ * $_ } }
$foreachobject = Measure-Command { (1..1000000) | ForEach-Object { $_ * $_ } }

"Foreach: $($foreach.TotalSeconds)"
"Foreach method: $($foreachmethod.TotalSeconds)"
"ForEach-Object: $($foreachobject.TotalSeconds)"

Example output:

Foreach: 1.9039875
Foreach method: 4.7559563
ForEach-Object: 10.7543821

Zum

for($i = 0; $i -le 5; $i++){
    "$i"
}

Eine typische Verwendung der for-Schleife ist die Bearbeitung einer Teilmenge der Werte in einem Array. In den meisten Fällen sollten Sie eine foreach -Anweisung verwenden, wenn Sie alle Werte in einem Array durchlaufen möchten.

Für jeden

ForEach hat in PowerShell zwei verschiedene Bedeutungen. Eines ist ein Schlüsselwort und das andere ist ein Alias ​​für das Cmdlet ForEach-Object . Ersteres wird hier beschrieben.

In diesem Beispiel wird das Drucken aller Elemente in einem Array an den Konsolenhost veranschaulicht:

$Names = @('Amy', 'Bob', 'Celine', 'David')

ForEach ($Name in $Names)
{
    Write-Host "Hi, my name is $Name!"
}

Dieses Beispiel veranschaulicht das Erfassen der Ausgabe einer ForEach-Schleife:

$Numbers = ForEach ($Number in 1..20) {
    $Number # Alternatively, Write-Output $Number
}

Wie das letzte Beispiel zeigt dieses Beispiel stattdessen das Erstellen eines Arrays vor dem Speichern der Schleife:

$Numbers = @()
ForEach ($Number in 1..20)
{
    $Numbers += $Number
}

Während

Eine while-Schleife wertet eine Bedingung aus, und bei true wird eine Aktion ausgeführt. Solange die Bedingung als wahr ausgewertet wird, wird die Aktion weiterhin ausgeführt.

while(condition){
  code_block
}

Im folgenden Beispiel wird eine Schleife erstellt, die von 10 auf 0 herunterzählt

$i = 10
while($i -ge 0){
    $i
    $i--
}

Im Gegensatz zur Do während-Schleife wird die Bedingung vor der ersten Ausführung der Aktion ausgewertet. Die Aktion wird nicht ausgeführt, wenn die Anfangsbedingung falsch ist.

Hinweis: Wenn Sie die Bedingung bewerten, behandelt PowerShell das Vorhandensein eines Rückkehrobjekts als wahr. Dies kann auf verschiedene Arten verwendet werden. Nachfolgend finden Sie ein Beispiel für die Überwachung eines Prozesses. In diesem Beispiel wird ein Notepad-Prozess erstellt, und die aktuelle Shell wird in den Ruhezustand versetzt, solange dieser Prozess ausgeführt wird. Wenn Sie die Notepad-Instanz manuell schließen, schlägt die while-Bedingung fehl und die Schleife wird unterbrochen.

Start-Process notepad.exe
while(Get-Process notepad -ErrorAction SilentlyContinue){
  Start-Sleep -Milliseconds 500
}

ForEach-Objekt

Das ForEach-Object funktioniert ähnlich wie die foreach Anweisung, übernimmt jedoch die Eingabe aus der Pipeline.

Grundlegende Verwendung

$object | ForEach-Object {
    code_block
}

Beispiel:

$names = @("Any","Bob","Celine","David")
$names | ForEach-Object {
    "Hi, my name is $_!"
}

Foreach-Object hat zwei Standard-Aliasnamen, foreach und % (Abkürzungssyntax). Am häufigsten ist % weil foreach mit der foreach-Anweisung verwechselt werden kann. Beispiele:

$names | % {  
    "Hi, my name is $_!"
} 

$names | foreach {  
    "Hi, my name is $_!"
} 

Erweiterte Nutzung

Foreach-Object sich von den alternativen foreach Lösungen, da es sich um ein Cmdlet handelt, das die Pipeline verwendet. Aus diesem Grund werden drei Skriptblöcke genauso wie ein Cmdlet oder eine erweiterte Funktion unterstützt:

• Beginnen : Wird einmal ausgeführt, bevor die Elemente, die von der Pipeline ankommen, durchlaufen werden. Wird normalerweise zum Erstellen von Funktionen für die Verwendung in der Schleife, zum Erstellen von Variablen, zum Öffnen von Verbindungen (Datenbank, Web +) usw. verwendet.
• Prozess : Wird einmal pro Artikel ausgeführt, der aus der Pipeline eingetroffen ist. "Normal" für jeden Codeblock. Dies ist die Standardeinstellung in den obigen Beispielen, wenn der Parameter nicht angegeben ist.
• End : Einmal ausgeführt, nachdem alle Elemente verarbeitet wurden. Wird normalerweise verwendet, um Verbindungen zu schließen, einen Bericht zu generieren usw.

Beispiel:

"Any","Bob","Celine","David" | ForEach-Object -Begin {
    $results = @()
} -Process {
    #Create and store message
    $results += "Hi, my name is $_!"
} -End {
    #Count messages and output
    Write-Host "Total messages: $($results.Count)"
    $results
}

Tun

Do-Loops sind nützlich, wenn Sie einen Codeblock immer mindestens einmal ausführen möchten. Eine Do-Schleife wertet die Bedingung nach der Ausführung des Codeblocks aus, im Gegensatz zu einer While-Schleife, die dies vor der Ausführung des Codeblocks ausführt.

Sie können do-loops auf zwei Arten verwenden:

• Schleife, während die Bedingung erfüllt ist:

  Do {
      code_block
  } while (condition)
  

• Schleife, bis die Bedingung wahr ist, mit anderen Worten, Schleife, während die Bedingung falsch ist:

  Do {
      code_block
  } until (condition)
  

Reale Beispiele:

$i = 0

Do {
    $i++
    "Number $i"
} while ($i -ne 3)

Do {
    $i++
    "Number $i"
} until ($i -eq 3)

Do-While und Do-Bis sind antonyme Schleifen. Wenn der Code gleich ist, wird die Bedingung umgekehrt. Das obige Beispiel veranschaulicht dieses Verhalten.

ForEach () - Methode

(1..10).ForEach({$_ * $_})

(1..10).ForEach{$_ * $_}  

1
4
9
16
25
36
49
64
81
100  

Fortsetzen

Die Continue Operator arbeitet in For , ForEach , While und Do - Schleifen. Es überspringt die aktuelle Iteration der Schleife und springt an die Spitze der innersten Schleife.

$i =0
while ($i -lt 20) {
    $i++ 
    if ($i -eq 7) { continue }
    Write-Host $I
}

Das obige wird 1 bis 20 auf der Konsole ausgeben, aber die Nummer 7 verpassen.

Hinweis : Wenn Sie eine Pipeline-Schleife verwenden, sollten Sie return anstelle von Continue .

Brechen

Der break eine Programmschleife sofort. Es kann in verwendet werden For , ForEach , While und Do oder in einem Schleifen - Switch Statement.

$i = 0
while ($i -lt 15) {
    $i++ 
    if ($i -eq 7) {break}
    Write-Host $i
}

Das Obige zählt bis 15, hört jedoch auf, sobald 7 erreicht ist.

Hinweis : Wenn Sie eine Pipeline-Schleife verwenden, verhält sich break als continue . Zur Simulation break in der Pipeline - Schleife müssen Sie einige zusätzliche Logik integrieren, Cmdlets, etc. Es ist einfacher zu halten mit Nicht-Pipeline - Schleifen , wenn Sie verwenden müssen break .

Etiketten brechen

Break kann auch ein Label aufrufen, das vor der Instanziierung einer Schleife platziert wurde:

$i = 0
:mainLoop While ($i -lt 15) {
    Write-Host $i -ForegroundColor 'Cyan'
    $j = 0
    While ($j -lt 15) {
        Write-Host $j -ForegroundColor 'Magenta'
        $k = $i*$j
        Write-Host $k -ForegroundColor 'Green'
        if ($k -gt 100) {
            break mainLoop
        }
        $j++
    }
    $i++
}

Hinweis: Dieser Code erhöht $i auf 8 und $j auf 13 wodurch $k gleich 104 . Da $k 100 überschreitet, wird der Code aus beiden Schleifen ausbrechen.