about_For

Artigo
07/06/2024

Descrição breve

Descreve um comando de linguagem que você pode usar para executar instruções com base em um teste condicional.

Descrição longa

A For instrução (também conhecida como For loop) é uma construção de linguagem que você pode usar para criar um loop que executa comandos em um bloco de comando enquanto uma condição especificada é avaliada como $true.

Um uso típico do For loop é iterar uma matriz de valores e operar em um subconjunto desses valores. Na maioria dos casos, se você quiser iterar todos os valores em uma matriz, considere usar uma Foreach instrução.

Sintaxe

Veja a seguir a sintaxe da For instrução.

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

O espaço reservado Init representa um ou mais comandos que são executados antes do início do loop. Normalmente, você usa a parte Init da instrução para criar e inicializar uma variável com um valor inicial.

Essa variável será então a base para a condição a ser testada na próxima parte da For instrução.

O espaço reservado Condition representa a For parte da instrução que é resolvida para um $true valor booliano ou $false . O PowerShell avalia a condição sempre que o For loop é executado. Se a instrução for $true, os comandos no bloco de comando serão executados e a instrução será avaliada novamente. Se a condição ainda $truefor , os comandos na lista Instrução serão executados novamente. O loop é repetido até que a condição se torne $false.

O espaço reservado Repetir representa um ou mais comandos, separados por vírgulas, que são executados sempre que o loop se repete. Normalmente, isso é usado para modificar uma variável que é testada dentro da parte Condition da instrução.

O espaço reservado da lista de instruções representa um conjunto de um ou mais comandos que são executados sempre que o loop é inserido ou repetido. O conteúdo da lista de instruções é cercado por chaves.

Suporte para várias operações

As seguintes sintaxes têm suporte para várias operações de atribuição na instrução 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"
}

As seguintes sintaxes têm suporte para várias operações de atribuição na instrução 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"
}

Observação

Operações diferentes de pré ou pós-incremento podem não funcionar com todas as sintaxes.

Para várias condições, use operadores lógicos, conforme demonstrado pelo exemplo a seguir.

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

Para obter mais informações, consulte about_Logical_Operators.

Exemplos de sintaxe

No mínimo, uma For instrução requer o parêntese em torno da parte Init, Condition e Repeat da instrução e um comando entre chaves na parte da lista Statement da instrução.

Observe que os próximos exemplos mostram intencionalmente o código fora da For instrução. Em exemplos posteriores, o código é integrado à For instrução.

Por exemplo, a instrução a seguir For exibe continuamente o $i valor da variável até que você saia manualmente do comando pressionando CTRL+C.

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

Você pode adicionar comandos adicionais à lista de instruções para que o valor de seja incrementado em 1 cada vez que o loop for executado, como mostra o exemplo a $i seguir.

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

Até que você saia do comando pressionando CTRL+C, essa instrução exibirá continuamente o valor da variável à medida que ela é incrementada $i em 1 cada vez que o loop é executado.

Em vez de alterar o valor da variável na parte da lista de instruções da For instrução, você pode usar a parte Repeat da For instrução, da seguinte maneira.

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

Essa instrução ainda será repetida indefinidamente até que você saia do comando pressionando CTRL+C.

Você pode encerrar o For loop usando uma condição. Você pode colocar uma condição usando a parte Condition da For instrução. O For loop termina quando a condição é avaliada como $false.

No exemplo a seguir, o For loop é executado enquanto o valor de $i é menor ou igual a 10.

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

Em vez de criar e inicializar a variável fora da For instrução, você pode executar essa tarefa dentro do For loop usando a parte Init da For instrução.

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

Você pode usar retornos de carro em vez de ponto-e-vírgula para delimitar as partes Init, Condition e Repeat da For instrução. O exemplo a seguir mostra um For que usa essa sintaxe alternativa.

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

Essa forma alternativa da instrução funciona em arquivos de script do PowerShell e no prompt de For comando do PowerShell. No entanto, é mais fácil usar a sintaxe da For instrução com ponto-e-vírgula quando você insere comandos interativos no prompt de comando.

O For loop é mais flexível do que o Foreach loop porque permite incrementar valores em uma matriz ou coleção usando padrões. No exemplo a seguir, a variável é incrementada $i em 2 na parte Repeat da For instrução.

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

O For loop também pode ser escrito em uma linha, como no exemplo a seguir.

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

Exemplo funcional

O exemplo a seguir demonstra como você pode usar um For loop para iterar em uma matriz de arquivos e renomeá-los. Os arquivos na work_items pasta têm sua ID de item de trabalho como o nome do arquivo. O loop itera pelos arquivos para garantir que o número de ID seja preenchido com zero para cinco dígitos.

Primeiro, o código recupera a lista de arquivos de dados do item de trabalho. Eles são todos arquivos JSON que usam o formato <work-item-type>-<work-item-number> para seu nome. Com os objetos de informações do arquivo salvos na $fileList variável, você pode classificá-los por nome e ver que, embora os itens sejam agrupados por tipo, a ordenação dos itens por ID é inesperada.

$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

Para garantir que você possa classificar os itens de trabalho alfanumericamente, os números de item de trabalho precisam ser preenchidos com zero.

O código faz isso pesquisando primeiro o item de trabalho com o sufixo numérico mais longo. Ele faz um loop sobre os arquivos usando um for loop, usando o índice para acessar cada arquivo na matriz. Ele compara cada nome de arquivo a um padrão de expressão regular para extrair o número do item de trabalho como uma cadeia de caracteres em vez de um inteiro. Em seguida, ele compara os comprimentos dos números de item de trabalho para encontrar o número mais longo.

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

Agora que você sabe a contagem máxima de numerais para os itens de trabalho, pode fazer um loop sobre os arquivos para renomeá-los conforme necessário. O próximo trecho de código itera sobre a lista de arquivos novamente, preenchendo-os conforme necessário. Ele usa outro padrão de expressão regular para processar apenas arquivos com uma contagem de numerais menor que o máximo.

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

Agora que os arquivos foram renomeados, você pode recuperar a lista de arquivos novamente e classificar os arquivos antigos e novos por nome. O snippet a seguir recupera os arquivos novamente para salvar em uma nova matriz e comparar com o conjunto inicial de objetos. Em seguida, ele classifica as duas matrizes de arquivos, salvando as matrizes classificadas nas novas variáveis $sortedOriginal e $sortedPadded. Por fim, ele usa um for loop para iterar sobre as matrizes e gerar um objeto com as seguintes propriedades:

Index representa o índice atual nas matrizes classificadas.
Original é o item na matriz ordenada de nomes de arquivos originais no índice atual.
Padded é o item na matriz classificada de nomes de arquivos preenchidos no índice atual.

$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

Na saída, os itens de trabalho classificados após o preenchimento estão na ordem esperada.

Compartilhar via