about_For

Article
06/11/2024

Description courte

Décrit une commande de langage que vous pouvez utiliser pour exécuter des instructions basées sur un test conditionnel.

Description longue

L’instruction For (également appelée For boucle) est une construction de langage que vous pouvez utiliser pour créer une boucle qui exécute des commandes dans un bloc de commandes pendant qu’une condition spécifiée est $trueévaluée .

Une utilisation classique de la For boucle consiste à itérer un tableau de valeurs et à opérer sur un sous-ensemble de ces valeurs. Dans la plupart des cas, si vous souhaitez itérer toutes les valeurs d’un tableau, envisagez d’utiliser une Foreach instruction.

Syntaxe

L’exemple suivant montre la syntaxe de l’instruction For .

for (<Init>; <Condition>; <Repeat>)
{
    <Statement list>
}

L’espace réservé Init représente une ou plusieurs commandes exécutées avant le début de la boucle. Vous utilisez généralement la partie Init de l’instruction pour créer et initialiser une variable avec une valeur de départ.

Cette variable sera ensuite la base de la condition à tester dans la partie suivante de l’instruction For .

L’espace réservé Condition représente la partie de l’instruction For qui se résout en valeur $true booléenne ou $false booléenne. PowerShell évalue la condition chaque fois que la For boucle s’exécute. Si l’instruction est $true, les commandes du bloc de commandes s’exécutent et l’instruction est évaluée à nouveau. Si la condition est toujours$true, les commandes de la liste d’instructions s’exécutent à nouveau. La boucle est répétée jusqu’à ce que la condition devienne $false.

L’espace réservé Repeat représente une ou plusieurs commandes, séparées par des virgules, qui sont exécutées chaque fois que la boucle se répète. En règle générale, il est utilisé pour modifier une variable testée dans la partie Condition de l’instruction.

L’espace réservé de liste d’instructions représente un ensemble d’une ou plusieurs commandes exécutées chaque fois que la boucle est entrée ou répétée. Le contenu de la liste des instructions est entouré d’accolades.

Prise en charge de plusieurs opérations

Les syntaxes suivantes sont prises en charge pour plusieurs opérations d’affectation dans l’instruction Init :

# Comma separated assignment expressions enclosed in parentheses.
for (($i = 0), ($j = 0); $i -lt 10; $i++)
{
    "`$i:$i"
    "`$j:$j"
}

# Sub-expression using the semicolon to separate statements.
for ($($i = 0;$j = 0); $i -lt 10; $i++)
{
    "`$i:$i"
    "`$j:$j"
}

Les syntaxes suivantes sont prises en charge pour plusieurs opérations d’affectation dans l’instruction Repeat :

# Comma separated assignment expressions.
for (($i = 0), ($j = 0); $i -lt 10; $i++, $j++)
{
    "`$i:$i"
    "`$j:$j"
}

# Comma separated assignment expressions enclosed in parentheses.
for (($i = 0), ($j = 0); $i -lt 10; ($i++), ($j++))
{
    "`$i:$i"
    "`$j:$j"
}

# Sub-expression using the semicolon to separate statements.
for ($($i = 0;$j = 0); $i -lt 10; $($i++;$j++))
{
    "`$i:$i"
    "`$j:$j"
}

Remarque

Les opérations autres que les opérations antérieures ou post-incrémentes peuvent ne pas fonctionner avec toutes les syntaxes.

Pour plusieurs conditions , utilisez des opérateurs logiques comme illustré par l’exemple suivant.

for (($i = 0), ($j = 0); $i -lt 10 -and $j -lt 10; $i++,$j++)
{
    "`$i:$i"
    "`$j:$j"
}

Pour plus d’informations, consultez about_Logical_Operators.

Exemples de syntaxe

Au minimum, une For instruction nécessite la parenthèse entourant l’instruction Init, Condition et Répéter une partie de l’instruction et une commande entourée d’accolades dans la partie liste d’instructions de l’instruction.

Notez que les exemples à venir affichent intentionnellement le code en dehors de l’instruction For . Dans les exemples ultérieurs, le code est intégré à l’instruction For .

Par exemple, l’instruction suivante For affiche continuellement la valeur de la $i variable jusqu’à ce que vous interrompiez manuellement la commande en appuyant sur Ctrl+C.

$i = 1
for (;;)
{
    Write-Host $i
}

Vous pouvez ajouter des commandes supplémentaires à la liste d’instructions afin que la valeur de $i celle-ci soit incrémentée de 1 chaque fois que la boucle est exécutée, comme l’illustre l’exemple suivant.

for (;;)
{
    $i++; Write-Host $i
}

Jusqu’à ce que vous arrêtiez la commande en appuyant sur Ctrl+C, cette instruction affiche continuellement la valeur de la $i variable, car elle est incrémentée de 1 chaque fois que la boucle est exécutée.

Au lieu de modifier la valeur de la variable dans la partie liste d’instructions de l’instruction For , vous pouvez utiliser la partie Répéter de l’instruction à la For place, comme suit.

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

Cette instruction se répète indéfiniment jusqu’à ce que vous sautiez de la commande en appuyant sur Ctrl+C.

Vous pouvez arrêter la boucle à l’aide For d’une condition. Vous pouvez placer une condition à l’aide de la partie Condition de l’instruction For . La For boucle se termine lorsque la condition est évaluée à $false.

Dans l’exemple suivant, la For boucle s’exécute alors que la valeur est $i inférieure ou égale à 10.

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

Au lieu de créer et d’initialiser la variable en dehors de l’instruction For , vous pouvez effectuer cette tâche à l’intérieur de la For boucle à l’aide de la partie Init de l’instruction For .

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

Vous pouvez utiliser des retours chariot au lieu de points-virgules pour délimiter les parties Init, Condition et Repeat de l’instruction For . L’exemple suivant montre une For syntaxe alternative qui utilise cette autre syntaxe.

for ($i = 0
  $i -lt 10
  $i++){
  $i
}

Cette autre forme d’instruction For fonctionne dans les fichiers de script PowerShell et à l’invite de commandes PowerShell. Toutefois, il est plus facile d’utiliser la For syntaxe d’instruction avec des points-virgules lorsque vous entrez des commandes interactives à l’invite de commandes.

La For boucle est plus flexible que la Foreach boucle, car elle vous permet d’incrémenter des valeurs dans un tableau ou une collection à l’aide de modèles. Dans l’exemple suivant, la $i variable est incrémentée de 2 dans la partie Répéter de l’instruction For .

for ($i = 0; $i -le 20; $i += 2)
{
    Write-Host $i
}

La For boucle peut également être écrite sur une ligne comme dans l’exemple suivant.

for ($i = 0; $i -lt 10; $i++) { Write-Host $i }

Exemple fonctionnel

L’exemple suivant montre comment utiliser une For boucle pour itérer sur un tableau de fichiers et les renommer. Les fichiers du work_items dossier ont leur ID d’élément de travail comme nom de fichier. La boucle itère dans les fichiers pour vous assurer que le numéro d’ID est rembourré à cinq chiffres.

Tout d’abord, le code récupère la liste des fichiers de données d’élément de travail. Il s’agit de tous les fichiers JSON qui utilisent le format <work-item-type>-<work-item-number> de leur nom. Avec les objets d’informations de fichier enregistrés dans la $fileList variable, vous pouvez les trier par nom et voir que pendant que les éléments sont regroupés par type, l’ordre des éléments par ID est inattendu.

$fileList = Get-ChildItem -Path ./work_items
$fileList | Sort-Object -Descending -Property Name

bug-219.json
bug-41.json
bug-500.json
bug-697.json
bug-819.json
bug-840.json
feat-176.json
feat-367.json
feat-373.json
feat-434.json
feat-676.json
feat-690.json
feat-880.json
feat-944.json
maint-103.json
maint-367.json
maint-454.json
maint-49.json
maint-562.json
maint-579.json

Pour vous assurer que vous pouvez trier les éléments de travail de manière alphanumérique, les numéros d’élément de travail doivent être rembourrés à zéro.

Le code effectue cette opération en recherchant d’abord l’élément de travail avec le suffixe numérique le plus long. Il effectue une boucle sur les fichiers à l’aide d’une for boucle, à l’aide de l’index pour accéder à chaque fichier du tableau. Il compare chaque nom de fichier à un modèle d’expression régulière pour extraire le numéro d’élément de travail sous forme de chaîne au lieu d’un entier. Ensuite, il compare les longueurs des numéros d’élément de travail pour trouver le nombre le plus long.

# Default the longest numeral count to 1, since it can't be smaller.
$longestNumeralCount = 1

# Regular expression to find the numerals in the filename - use a template
# to simplify updating the pattern as needed.
$patternTemplate = '-(?<WorkItemNumber>{{{0},{1}}})\.json'
$pattern         =  $patternTemplate -f $longestNumeralCount

# Iterate, checking the length of the work item number as a string.
for (
    $i = 0                 # Start at zero for first array item.
    $i -lt $fileList.Count # Stop on the last item in the array.
    $i++                   # Increment by one to step through the array.
) {
    if ($fileList[$i].Name -match $pattern) {
        $numeralCount = $Matches.WorkItemNumber.Length
        if ($numeralCount -gt $longestNumeralCount) {
            # Count is higher, check against it for remaining items.
            $longestNumeralCount = $numeralCount
            # Update the pattern to speed up the search, ignoring items
            # with a smaller numeral count using pattern matching.
            $pattern = $patternTemplate -f $longestNumeralCount
        }
    }
}

Maintenant que vous connaissez le nombre maximal de chiffres pour les éléments de travail, vous pouvez effectuer une boucle sur les fichiers pour les renommer en fonction des besoins. L’extrait de code suivant effectue une itération sur la liste de fichiers à nouveau, en les remboursant selon les besoins. Il utilise un autre modèle d’expression régulière pour traiter uniquement les fichiers dont le nombre de chiffres est inférieur au nombre maximal.

# Regular expression to find the numerals in the filename, but only if the
# numeral count is smaller than the longest numeral count.
$pattern = $patternTemplate -f 1, ($longestNumeralCount - 1)
for (
    $i = 0                 # Start at zero for first array item.
    $i -lt $fileList.Count # Stop on the last item in the array.
    $i++                   # Increment by one to step through the array.
) {
    # Get the file from the array to process
    $file = $fileList[$i]

    # If the file doesn't need to be renamed, continue to the next file
    if ($file.Name -notmatch $pattern) {
        continue
    }

    # Get the work item number from the regular expression, create the
    # padded string from it, and define the new filename by replacing
    # the original number string with the padded number string.
    $workItemNumber = $Matches.WorkItemNumber
    $paddedNumber   = "{0:d$longestNumeralCount}" -f $workItemNumber
    $paddedName     = $file.Name -replace $workItemNumber, $paddedNumber

    # Rename the file with the padded work item number.
    $file | Rename-Item -NewName $paddedName
}

Maintenant que les fichiers sont renommés, vous pouvez récupérer à nouveau la liste des fichiers et trier les fichiers anciens et nouveaux par nom. L’extrait de code suivant récupère à nouveau les fichiers à enregistrer dans un nouveau tableau et compare avec l’ensemble initial d’objets. Ensuite, il trie les deux tableaux de fichiers, en enregistrant les tableaux triés dans les nouvelles variables $sortedOriginal et $sortedPadded. Enfin, il utilise une for boucle pour itérer sur les tableaux et générer un objet avec les propriétés suivantes :

Index représente l’index actuel dans les tableaux triés.
Original est l’élément du tableau trié des noms de fichiers d’origine à l’index actuel.
Padded est l’élément du tableau trié des noms de fichiers rembourrés à l’index actuel.

$paddedList = Get-ChildItem -path ./work_items

# Sort both file lists by name.
$sortedOriginal = $fileList    | Sort-Object -Property Name
$sortedPadded   = $renamedList | Sort-Object -Property Name

# Iterate over the arrays and output an object to simplify comparing how
# the arrays were sorted before and after padding the work item numbers.
for (
  $i = 0
  $i -lt $fileList.Count
  $i++
) {
    [pscustomobject] @{
        Index    = $i
        Original = $sortedOriginal[$i].Name
        Padded   = $sortedPadded[$i].Name
    }
}

Index Original       Padded
----- --------       ------
    0 bug-219.json   bug-00041.json
    1 bug-41.json    bug-00219.json
    2 bug-500.json   bug-00500.json
    3 bug-697.json   bug-00697.json
    4 bug-819.json   bug-00819.json
    5 bug-840.json   bug-00840.json
    6 feat-176.json  feat-00176.json
    7 feat-367.json  feat-00367.json
    8 feat-373.json  feat-00373.json
    9 feat-434.json  feat-00434.json
   10 feat-676.json  feat-00676.json
   11 feat-690.json  feat-00690.json
   12 feat-880.json  feat-00880.json
   13 feat-944.json  feat-00944.json
   14 maint-103.json maint-00049.json
   15 maint-367.json maint-00103.json
   16 maint-454.json maint-00367.json
   17 maint-49.json  maint-00454.json
   18 maint-562.json maint-00562.json
   19 maint-579.json maint-00579.json

Dans la sortie, les éléments de travail triés après le remplissage sont dans l’ordre attendu.

Partager via