PowerShell
Loops

Invoering

Syntaxis

• voor (<Initialisatie>; <Condition>; <Repetition>) {<Script_Block>}

• <Collection> | Foreach-Object {<Script_Block_with _ $ __ as_current_item>}

• foreach (<Item> in <Collection>) {<Script_Block>}

• terwijl (<Voorwaarde>) {<Script_Block>}

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

• doe {<Script_Block>} tot (<Condition>)

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

Opmerkingen

$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

Voor

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

Een typisch gebruik van de for-lus is om te werken op een subset van de waarden in een array. Als u alle waarden in een array wilt herhalen, kunt u in de meeste gevallen een foreach-instructie gebruiken.

foreach

ForEach heeft twee verschillende betekenissen in PowerShell. De ene is een trefwoord en de andere is een alias voor de cmdlet ForEach-Object . De eerste wordt hier beschreven.

In dit voorbeeld wordt het afdrukken van alle items in een array naar de consolehost getoond:

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

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

Dit voorbeeld laat zien hoe de uitvoer van een ForEach-lus wordt vastgelegd:

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

Net als het laatste voorbeeld demonstreert dit voorbeeld in plaats daarvan het maken van een array voordat de lus wordt opgeslagen:

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

Terwijl

Een while-lus evalueert een voorwaarde en als true een actie uitvoert. Zolang de voorwaarde als waar wordt geëvalueerd, blijft de actie worden uitgevoerd.

while(condition){
  code_block
}

In het volgende voorbeeld wordt een lus gemaakt die aftelt van 10 tot 0

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

In tegenstelling tot de Do -While-lus wordt de voorwaarde geëvalueerd voorafgaand aan de eerste uitvoering van de actie. De actie wordt niet uitgevoerd als de initiële voorwaarde als onwaar evalueert.

Opmerking: Wanneer de voorwaarde wordt geëvalueerd, behandelt PowerShell het bestaan van een retourobject als waar. Dit kan op verschillende manieren worden gebruikt, maar hieronder staat een voorbeeld om een proces te controleren. Dit voorbeeld zal een kladblok-proces voortbrengen en vervolgens de huidige shell slapen zolang dat proces actief is. Wanneer u het Kladblok-exemplaar handmatig sluit, mislukt de voorwaarde While en breekt de lus.

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

ForEach-Object

De cmdlet ForEach-Object werkt op dezelfde manier als de instructie foreach , maar neemt zijn input van de pijplijn.

Basis gebruik

$object | ForEach-Object {
    code_block
}

Voorbeeld:

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

Foreach-Object heeft twee standaard aliassen, foreach en % (syntaxis voor steno). Het meest gebruikelijk is % omdat foreach kan worden verward met de foreach-verklaring . Voorbeelden:

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

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

Geavanceerd gebruik

Foreach-Object onderscheidt zich van de alternatieve foreach oplossingen omdat het een cmdlet is, wat betekent dat het is ontworpen om de pijpleiding te gebruiken. Daarom biedt het ondersteuning voor drie scriptblokken, net als een cmdlet of geavanceerde functie:

• Begin : eenmaal uitgevoerd voordat de items die uit de pijplijn komen, worden doorlopen. Meestal gebruikt om functies te maken voor gebruik in de lus, variabelen maken, verbindingen openen (database, web +) enz.
• Proces : eenmaal uitgevoerd per item aangekomen uit de pijplijn. "Normaal" voor elk codeblok. Dit is de standaardinstelling die in de bovenstaande voorbeelden wordt gebruikt wanneer de parameter niet is opgegeven.
• Einde : eenmaal uitgevoerd na verwerking van alle items. Meestal gebruikt om verbindingen te sluiten, een rapport te genereren etc.

Voorbeeld:

"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
}

Doen

Do-loops zijn handig wanneer u altijd minimaal één keer een codeblock wilt uitvoeren. Een Do-lus evalueert de toestand na het uitvoeren van het codeblok, in tegenstelling tot een while-lus die dit doet voordat het codeblok wordt uitgevoerd.

Je kunt do-loops op twee manieren gebruiken:

• Loop terwijl de voorwaarde waar is:

  Do {
      code_block
  } while (condition)
  

• Lus totdat de voorwaarde waar is, met andere woorden, lus terwijl de voorwaarde onwaar is:

  Do {
      code_block
  } until (condition)
  

Echte voorbeelden:

$i = 0

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

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

Do-While en Do-till zijn anonieme loops. Als de code binnen dezelfde code staat, wordt de voorwaarde omgekeerd. Het bovenstaande voorbeeld illustreert dit gedrag.

ForEach () -methode

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

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

1
4
9
16
25
36
49
64
81
100  

Doorgaan met

De operator Continue werkt in For , ForEach , While en Do loops. Het slaat de huidige iteratie van de lus over en springt naar de bovenkant van de binnenste lus.

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

Het bovenstaande zal 1 tot 20 naar de console uitvoeren maar mist het nummer 7.

Opmerking : wanneer u een pijplijnlus gebruikt, moet u return plaats van Continue .

Breken

De break operator verlaat onmiddellijk een programmalus. Het kan worden gebruikt in For , ForEach , While en Do loops of in een Switch Statement.

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

Het bovenstaande telt tot 15 maar stopt zodra 7 is bereikt.

Opmerking : Bij gebruik van een pijplijnlus gedraagt break zich als continue . Om een break in de pijplijnlus te simuleren break moet je wat extra logica, cmdlet, enz. Opnemen. Het is gemakkelijker om niet-pijplijnlussen te volgen als je break nodig hebt.

Breek labels

Break kan ook een label noemen dat vóór de instantiëring van een lus is geplaatst:

$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++
}

Opmerking: deze code verhoogt $i tot 8 en $j tot 13 , waardoor $k gelijk wordt aan 104 . Omdat $k hoger is dan 100 , zal de code dan uit beide lussen breken.