PowerShell
Bucles

Introducción

Sintaxis

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

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

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

• while (<Condición>) {<Script_Block>}

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

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

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

Observaciones

$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

por

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

Un uso típico del bucle for es operar en un subconjunto de los valores en una matriz. En la mayoría de los casos, si desea iterar todos los valores de una matriz, considere usar una instrucción foreach.

Para cada

ForEach tiene dos significados diferentes en PowerShell. Una es una palabra clave y la otra es un alias para el cmdlet ForEach-Object . El primero se describe aquí.

Este ejemplo muestra cómo imprimir todos los elementos de una matriz en el host de la consola:

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

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

Este ejemplo muestra cómo capturar la salida de un bucle ForEach:

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

Al igual que el último ejemplo, este ejemplo, en su lugar, demuestra la creación de una matriz antes de almacenar el bucle:

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

Mientras

Un bucle while evaluará una condición y si es verdadero realizará una acción. Mientras la condición se evalúe como verdadera, la acción continuará realizándose.

while(condition){
  code_block
}

El siguiente ejemplo crea un bucle que contará de 10 a 0

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

A diferencia del bucle Do While, la condición se evalúa antes de la primera ejecución de la acción. La acción no se realizará si la condición inicial se evalúa como falsa.

Nota: Al evaluar la condición, PowerShell tratará la existencia de un objeto devuelto como verdadero. Esto se puede usar de varias maneras, pero a continuación se muestra un ejemplo para monitorear un proceso. Este ejemplo generará un proceso de bloc de notas y luego dormirá el shell actual mientras ese proceso se esté ejecutando. Cuando cierras manualmente la instancia del bloc de notas, la condición while fallará y el bucle se interrumpirá.

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

ForEach-Object

El cmdlet ForEach-Object funciona de manera similar a la instrucción foreach , pero toma su entrada de la canalización.

Uso básico

$object | ForEach-Object {
    code_block
}

Ejemplo:

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

Foreach-Object tiene dos alias predeterminados, foreach y % (sintaxis abreviada). El más común es % porque foreach puede confundirse con la instrucción foreach . Ejemplos:

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

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

Uso avanzado

Foreach-Object destaca de las soluciones alternativas de foreach porque es un cmdlet, lo que significa que está diseñado para usar la canalización. Debido a esto, admite tres bloques de secuencias de comandos, como un cmdlet o una función avanzada:

• Inicio : se ejecuta una vez antes de recorrer en bucle los elementos que llegan desde la tubería. Generalmente se utiliza para crear funciones para su uso en el bucle, crear variables, abrir conexiones (base de datos, web +), etc.
• Proceso : Ejecutado una vez por artículo llegó desde la tubería. "Normal" para cada bloque de código. Este es el valor predeterminado que se utiliza en los ejemplos anteriores cuando no se especifica el parámetro.
• Fin : Se ejecuta una vez después de procesar todos los elementos. Usualmente se usa para cerrar conexiones, generar un informe, etc.

Ejemplo:

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

Hacer

Los do-loops son útiles cuando siempre desea ejecutar un bloque de código al menos una vez. Un Do-loop evaluará la condición después de ejecutar el bloque de código, a diferencia de un ciclo while que lo hace antes de ejecutar el bloque de código.

Puedes usar do-loops de dos maneras:

• Bucle mientras la condición es verdadera:

  Do {
      code_block
  } while (condition)
  

• Bucle hasta que la condición sea verdadera, en otras palabras, haga un ciclo mientras la condición sea falsa:

  Do {
      code_block
  } until (condition)
  

Ejemplos reales:

$i = 0

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

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

Do-While y Do-Until son bucles antónimos. Si el código dentro del mismo, la condición se invertirá. El ejemplo anterior ilustra este comportamiento.

Método ForEach ()

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

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

1
4
9
16
25
36
49
64
81
100  

Continuar

El operador Continue trabaja en los ForEach For , ForEach , While y Do Omite la iteración actual del bucle, saltando a la parte superior del bucle más interno.

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

Lo anterior dará salida de 1 a 20 a la consola, pero se perderá el número 7.

Nota : Al usar un bucle de tubería, debe usar return lugar de Continue .

Descanso

El operador de break saldrá de un ciclo de programa inmediatamente. Se puede usar en los ForEach For , ForEach , While y Do o en una ForEach Switch .

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

Lo anterior contará hasta 15 pero se detendrá tan pronto como se alcance 7.

Nota : cuando se usa un bucle de tubería, la break se comportará como continue . Para simular una break en el bucle de canalización, debe incorporar lógica adicional, cmdlet, etc. Es más fácil seguir con bucles no de tubería si necesita usar break .

Etiquetas de rotura

Break también puede llamar a una etiqueta que se colocó delante de la creación de instancias de un bucle:

$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: este código incrementará $i a 8 y $j a 13 que hará que $k igual a 104 . Como $k excede de 100 , el código se separará de ambos bucles.