PowerShell
Loops

introduzione

Sintassi

• for (<Initialization>; <Condition>; <Repetition>) {<Script_Block>}

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

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

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

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

• fare {<Script_Block>} fino a (<Condizione>)

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

Osservazioni

$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

Per

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

Un tipico utilizzo del ciclo for è quello di operare su un sottoinsieme dei valori di un array. Nella maggior parte dei casi, se si desidera ripetere tutti i valori in una matrice, considerare l'uso di un'istruzione foreach.

Per ciascuno

ForEach ha due diversi significati in PowerShell. Uno è una parola chiave e l'altro è un alias per il cmdlet ForEach-Object . Il primo è descritto qui.

Questo esempio dimostra come stampare tutti gli elementi in una matrice sull'host della console:

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

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

Questo esempio dimostra come catturare l'output di un ciclo ForEach:

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

Come l'ultimo esempio, questo esempio, invece, dimostra la creazione di un array prima di memorizzare il ciclo:

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

Mentre

Un ciclo while valuterà una condizione e se true eseguirà un'azione. Finché la condizione diventa vera, l'azione continuerà ad essere eseguita.

while(condition){
  code_block
}

Nell'esempio seguente viene creato un ciclo che eseguirà il conto alla rovescia da 10 a 0

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

A differenza del ciclo Do -While, la condizione viene valutata prima della prima esecuzione dell'azione. L'azione non verrà eseguita se la condizione iniziale è falsa.

Nota: durante la valutazione della condizione, PowerShell considererà true l'esistenza di un oggetto restituito. Questo può essere utilizzato in diversi modi, ma di seguito è riportato un esempio per monitorare un processo. Questo esempio genererà un processo di blocco note e quindi interromperà la shell corrente finché il processo è in esecuzione. Quando si chiude manualmente l'istanza del blocco note, la condizione while non riuscirà e il ciclo si interromperà.

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

ForEach-Object

Il cmdlet ForEach-Object funziona in modo simile all'istruzione foreach , ma prende il suo input dalla pipeline.

Utilizzo di base

$object | ForEach-Object {
    code_block
}

Esempio:

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

Foreach-Object ha due alias predefiniti, foreach e % (sintassi abbreviata). Il più comune è % perché foreach può essere confuso con l' istruzione foreach . Esempi:

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

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

Utilizzo avanzato

Foreach-Object si distingue dalle soluzioni foreach alternative perché è un cmdlet che significa che è progettato per utilizzare la pipeline. Per questo motivo, supporta tre scriptblock proprio come un cmdlet o una funzione avanzata:

• Inizia : eseguito una volta prima di scorrere gli elementi che arrivano dalla pipeline. Solitamente utilizzato per creare funzioni da utilizzare nel loop, creando variabili, aprendo connessioni (database, web +) ecc.
• Processo : eseguito una volta per elemento arrivato dalla pipeline. "Normal" foreach codeblock. Questo è il default usato negli esempi sopra quando il parametro non è specificato.
• Fine : eseguito una volta dopo l'elaborazione di tutti gli elementi. Solitamente utilizzato per chiudere le connessioni, generare un report, ecc.

Esempio:

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

Fare

I loop di do sono utili quando si desidera eseguire sempre un codice di blocco almeno una volta. Un Do-loop valuterà la condizione dopo aver eseguito il codice, diversamente da un ciclo while che lo esegue prima di eseguire il codice.

Puoi usare loop di do in due modi:

• Loop mentre la condizione è vera:

  Do {
      code_block
  } while (condition)
  

• Loop fino a quando la condizione è vera, in altre parole, loop mentre la condizione è falsa:

  Do {
      code_block
  } until (condition)
  

Esempi reali:

$i = 0

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

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

Do-While e Do-Until sono loop antonymous. Se il codice è all'interno dello stesso, la condizione verrà invertita. L'esempio sopra illustra questo comportamento.

Metodo ForEach ()

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

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

1
4
9
16
25
36
49
64
81
100  

Continua

L'operatore Continue lavora nei cicli For , ForEach , While e Do Salta l'iterazione corrente del loop, saltando in cima al ciclo più interno.

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

Quanto sopra uscirà da 1 a 20 alla console ma mancherà il numero 7.

Nota : quando si utilizza un loop di pipeline, è necessario utilizzare return anziché Continue .

Rompere

L'operatore di break uscirà immediatamente da un loop di programma. Può essere utilizzato nei cicli For , ForEach , While e Do o in un'istruzione Switch .

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

Quanto sopra conterà fino a 15 ma si fermerà non appena 7 sarà raggiunto.

Nota : quando si utilizza un loop di pipeline, break si comporterà come continue . Per simulare l' break del ciclo della pipeline, è necessario incorporare logica aggiuntiva, cmdlet, ecc. È più semplice attaccare con loop non di pipeline se è necessario utilizzare l' break .

Rompere etichette

Break può anche chiamare un'etichetta posizionata davanti all'istanza di un ciclo:

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

Nota: questo codice incrementerà $i a 8 e $j a 13 che causerà $k uguale a 104 . Poiché $k supera 100 , il codice uscirà da entrambi i cicli.