about_Break

  • Article

Description courte

Décrit l’instruction break , qui permet de quitter le bloc de contrôle actuel.

Description longue

L’instruction break fournit un moyen de quitter le bloc de contrôle actuel. L’exécution se poursuit à l’instruction suivante après le bloc de contrôle. L’instruction prend en charge les étiquettes. Une étiquette est un nom que vous attribuez à une instruction dans un script.

Utilisation break de boucles

Lorsqu’une break instruction apparaît dans une boucle, telle qu’une foreachboucle , ou fordowhile une boucle, PowerShell quitte immédiatement la boucle.

Une break instruction peut inclure une étiquette qui vous permet de quitter des boucles incorporées. Une étiquette peut spécifier n’importe quelle boucle mot clé, telle que foreach, forou while, dans un script.

L’exemple suivant montre comment utiliser une break instruction pour quitter une for instruction :

for($i=1; $i -le 10; $i++) {
   Write-Host $i
   break
}

Dans cet exemple, l’instruction break quitte la for boucle lorsque la $i variable est égale à 1. Même si l’instruction for prend la valeur True jusqu’à ce qu’elle soit supérieure à $i 10, PowerShell atteint l’instruction break la première fois que la for boucle est exécutée.

Il est plus courant d’utiliser l’instruction break dans une boucle où une condition interne doit être remplie. Prenons l’exemple d’instruction suivant foreach :

$i=0
$varB = 10,20,30,40
foreach ($val in $varB) {
  if ($val -eq 30) {
    break
  }
  $i++
}
Write-Host "30 was found in array index $i"

Dans cet exemple, l’instruction foreach itère le $varB tableau. L’instruction if prend la valeur False les deux premières fois que la boucle est exécutée et la variable $i est incrémentée de 1. La troisième fois que la boucle est exécutée, $i est égale à 2 et que la $val variable est égale à 30. À ce stade, l’instruction break s’exécute et la foreach boucle se termine.

Utilisation d’une étiquette break dans une boucle

Une break instruction peut inclure une étiquette. Si vous utilisez le break mot clé avec une étiquette, PowerShell quitte la boucle étiquetée au lieu de quitter la boucle actuelle. L’étiquette est un signe deux-points suivi d’un nom que vous attribuez. L’étiquette doit être le premier jeton d’une instruction, et elle doit être suivie de la boucle mot clé, par exemple while.

break déplace l’exécution hors de la boucle étiquetée. Dans les boucles incorporées, cela a un résultat différent du break mot clé lorsqu’il est utilisé par lui-même. Cet exemple contient une while instruction avec une for instruction :

:myLabel while (<condition 1>) {
  for ($item in $items) {
    if (<condition 2>) {
      break myLabel
    }
    $item = $x   # A statement inside the For-loop
  }
}
$a = $c  # A statement after the labeled While-loop

Si la condition 2 prend la valeur True, l’exécution du script passe à l’instruction après la boucle étiquetée. Dans l’exemple, l’exécution démarre à nouveau avec l’instruction $a = $c.

Vous pouvez imbriquer de nombreuses boucles étiquetées, comme illustré dans l’exemple suivant.

:red while (<condition1>) {
  :yellow while (<condition2>) {
    while (<condition3>) {
      if ($a) {break}
      if ($b) {break red}
      if ($c) {break yellow}
    }
    Write-Host "After innermost loop"
  }
  Write-Host "After yellow loop"
}
Write-Host "After red loop"

Si la variable prend la valeur True, l’exécution $b du script reprend après la boucle intitulée « rouge ». Si la variable a la valeur True, l’exécution $c du contrôle de script reprend après la boucle intitulée « jaune ».

Si la variable a la valeur True, l’exécution $a reprend après la boucle la plus interne. Aucune étiquette n’est nécessaire.

PowerShell ne limite pas la distance à laquelle les étiquettes peuvent reprendre l’exécution. L’étiquette peut même passer le contrôle entre les limites des appels de script et de fonction.

Utilisation break dans une switch instruction

Dans une switchconstruction, break PowerShell quitte le bloc de switch code.

La break mot clé est utilisée pour quitter la switch construction. Par exemple, l’instruction suivante switch utilise break des instructions pour tester la condition la plus spécifique :

$var = "word2"
switch -regex ($var) {
    "word2" {
      Write-Host "Exact" $_
      break
    }

    "word.*" {
      Write-Host "Match on the prefix" $_
      break
    }

    "w.*" {
      Write-Host "Match on at least the first letter" $_
      break
    }

    default {
      Write-Host "No match" $_
      break
    }
}

Dans cet exemple, la $var variable est créée et initialisée dans une valeur de chaîne de word2. L’instruction switch utilise la classe Regex pour qu’elle corresponde d’abord à la valeur de la variable avec le terme word2. Étant donné que la valeur de la variable et le premier test de l’instruction switch correspondent, le premier bloc de code de l’instruction switch s’exécute.

Lorsque PowerShell atteint la première break instruction, l’instruction switch se ferme. Si les quatre break instructions sont supprimées de l’exemple, les quatre conditions sont remplies. Cet exemple utilise l’instruction break pour afficher les résultats lorsque la condition la plus spécifique est remplie.

Utilisation break dans une trap instruction

Si l’instruction finale exécutée dans le corps d’une trap instruction est break, l’objet d’erreur est supprimé et l’exception est levée à nouveau.

L’exemple suivant crée une exception DivideByZeroException qui est interceptée à l’aide de l’instruction trap .

function test {
  trap [DivideByZeroException] {
    Write-Host 'divide by zero trapped'
    break
  }

  $i = 3
  'Before loop'
  while ($true) {
     "1 / $i = " + (1 / $i--)
  }
  'After loop'
}
test

Notez que l’exécution s’arrête à l’exception. Le After loop n’est jamais atteint. L’exception est levée après l’exécution trap .

Before loop
1 / 3 = 0.333333333333333
1 / 2 = 0.5
1 / 1 = 1
divide by zero trapped
ParentContainsErrorRecordException:
Line |
  10 |       "1 / $i = " + (1 / $i--)
     |       ~~~~~~~~~~~~~~~~~~~~~~~~
     | Attempted to divide by zero.

Ne pas utiliser break en dehors d’une boucle, switchou trap

Lorsqu’elle break est utilisée en dehors d’une construction qui la prend directement en charge (boucles, switch, ), trapPowerShell recherche la pile des appels pour une construction englobante. S’il ne trouve pas de construction englobante, l’espace d’exécution actuel est arrêté silencieusement.

Cela signifie que les fonctions et les scripts qui utilisent par inadvertance une break construction en dehors d’une construction englobante qui la prend en charge peuvent mettre fin par inadvertance à leurs appelants.

L’utilisation break à l’intérieur d’un pipeline break, tel qu’un ForEach-Object bloc de script, ne quitte pas seulement le pipeline, il met potentiellement fin à l’intégralité de l’espace d’exécution.

Voir aussi