9 Exemplos de Loops em Scripts Bash Linux

O versátil Bash for loop faz muito mais do que fazer um loop em torno de um número definido de vezes. Descrevemos suas muitas variantes para que você possa usá-las com sucesso em seus próprios scripts Linux.

O loop para

Todas as linguagens de script e programação têm alguma maneira de lidar com loops. Um loop é uma seção de código que você deseja executar repetidamente. Em vez de digitar o mesmo conjunto de instruções em seu script, repetidamente, um loop repetirá uma seção de código várias vezes para você.

RELACIONADOS 9 exemplos de script Bash para você começar no Linux

O Bash for loop é muito flexível. Ele pode trabalhar com números, palavras, arrays, variáveis ​​de linha de comando ou a saída de outros comandos. Estes são usados ​​no cabeçalho do loop. O cabeçalho determina com o que o loop está trabalhando - números ou strings, por exemplo - e qual é a condição final que interromperá o loop.

O corpo do loop contém o código que você deseja que seja repetido. Ele contém o que você deseja que o loop faça . O corpo do loop pode conter qualquer comando de script válido.

Uma variável chamada contador de loop ou iterador é usada para percorrer um intervalo de valores ou uma lista de itens de dados. Para cada loop, o iterador assume o valor do próximo número, string ou qualquer tipo de dados sobre o qual o loop está iterando. Isso permite que o loop trabalhe com os valores de cada um dos itens de dados por sua vez, ou até mesmo em alguns casos para manipular os próprios itens de dados.

Simples para Loops

Se você deseja escrever seu primeiro loop for, esses exemplos simples ajudarão você a começar.

para loops usando listas numéricas

Você pode executar um loop for na linha de comando. Este comando cria e executa um loop for simples. O iterador é uma variável chamada i . Vamos atribuir i para ser cada um dos valores na lista de números, por sua vez. O corpo do loop vai imprimir esse valor na janela do terminal. A condição que termina esse loop é quando i iterou em toda a lista de números.

 para i em 1 2 3 4 5; faça eco $i; feito 

É importante notar aqui que a variável i é aumentada em um a cada vez que o loop gira, mas isso ocorre porque a lista de números aumenta em um a cada vez.

Essa lista de números começa em 3 e sobe em etapas de dois, depois salta arbitrariamente para 44.

 para i em 3 5 7 9 11 44; faça eco $i; feito 

Não faz diferença para o loop for . Ele começa em uma extremidade da lista e usa cada valor por vez, até que todos os valores da lista tenham sido usados.

Nem os números precisam estar em ordem crescente. Eles podem estar em qualquer ordem.

 para i em 3 43 44 11 9; faça eco $i; feito 

para loops usando listas de palavras

Podemos facilmente fazer o mesmo com as palavras. Copie o texto do script em um editor e salve-o como “word-list.sh”.

 #!/bin/bash

para palavra em Esta é uma sequência de palavras
Faz 
  eco $palavra
feito

Você precisará usar chmod para tornar o script executável e qualquer outro script copiado deste artigo. Basta substituir o nome do script cada vez que você usar o comando chmod .

 chmod +x lista de palavras.sh 

Vamos executar o script.

 ./lista de palavras.sh 

Assim como fez com os números, o iterador — neste exemplo, a variável word — percorre a lista de itens de dados até chegar ao final da lista. O corpo do loop acessa o valor na variável word e, portanto, cada palavra na lista é processada.

para Loops com Intervalos de Números

Se você quisesse que um loop for executado 100 vezes, seria muito cansativo ter que digitar uma sequência de 100 números no cabeçalho do loop. Os intervalos de números permitem especificar apenas o primeiro e o último número.

Este script é “number-range.sh”.

 #!/bin/bash

para i em {1..10}
Faz
  echo "Rotação de loop:" $i
feito

O intervalo de números é definido entre colchetes “ {} ” com dois pontos “ .. ” separando os números que iniciam e terminam o intervalo. Certifique-se de não incluir nenhum espaço em branco na definição do intervalo.

É assim que funciona:

 ./number-range.sh 

Você pode incluir outro número que defina o tamanho da etapa que o iterador deve usar para percorrer os números no intervalo. Este script, “number-range2.sh” usará um intervalo de 0 a 32 e um tamanho de etapa de 4.

 #!/bin/bash

para i em {0..32..4}
Faz
  echo "Rotação de loop:" $i
feito

O iterador percorre o intervalo de números em saltos de quatro.

 ./number-range2.sh 

para loops usando nomes de arquivos

Como podemos processar listas de palavras, podemos fazer com que nossos scripts funcionem com nomes de arquivos. Esse script é chamado de “nomes de arquivo.sh”.

 #!/bin/bash

para arquivo em lista de palavras.sh number-range.sh number-range2.sh filenames.sh
Faz
  ls -lh "$arquivo"
feito

Seria bastante inútil ter um script que só fizesse o que ls pode fazer, mas demonstra como acessar nomes de arquivos dentro do corpo do loop.

 ./filenames.sh 

De maneira semelhante ao uso do intervalo de números, podemos usar um padrão de arquivo no cabeçalho do loop para especificar os arquivos que queremos processar. Isso evita muita digitação e significa que não precisamos saber antecipadamente os nomes dos arquivos.

Este script é chamado de “filenames2.sh.” Substituímos a lista de nomes de arquivo pelo padrão de nome de arquivo “*.sh” para que o script relate todos os arquivos de script no diretório atual.

 #!/bin/bash

para arquivo em *.sh
Faz
  ls -lh "$arquivo"
feito

Aqui está a saída.

 ./filenames2.sh 

para loops usando parâmetros de linha de comando

Podemos adicionar um pouco mais de flexibilidade passando o padrão de nome de arquivo na linha de comando. A variável $* representa todos os parâmetros de linha de comando passados ​​para o script.

Este é “filenames3.sh.”

 #!/bin/bash

para arquivo em $*
Faz
  ls -lh "$arquivo"
feito

Pediremos nomes de arquivos que comecem com “n” e tenham uma extensão SH.

 ./filenames3.sh n*.sh 

Também podemos passar em mais de um padrão por vez.

 ./filenames3.sh n*.sh .bashrc 

O file de variável do iterador assume o valor de cada um dos parâmetros da linha de comando. Os padrões de nome de arquivo são expandidos e todos os nomes de arquivo são processados ​​no corpo do loop.

RELACIONADO: Como trabalhar com variáveis ​​no Bash

C-like para loops

O Bash suporta o loop for clássico de três termos, como os encontrados na linguagem de programação C. Eles são chamados de loops for de três termos porque existem três termos no cabeçalho do loop.

• O valor inicial do iterador de loop.
• O teste para saber se o loop continua ou termina.
• O incremento — ou decremento — do iterador.

Este script é “c-like.sh”.

O iterador I é definido como 1 no início do loop e o loop será executado enquanto a instrução ” i<=10 ” for verdadeira. Assim que i chegar a 11, o loop for parará. O iterador está sendo aumentado em um, a cada revolução do loop.

 #!/bin/bash

para ((i=1; i<=10; i++))
Faz 
  echo "Número do loop:" $i
feito

Vamos executar este script.

 ./c-like.sh 

O loop for tipo C permite a criação fácil de loops for que possuem requisitos ligeiramente estranhos. Este loop começa em 15 e conta para trás em etapas de 3. Isso é “c-like2.sh”

 #!/bin/bash

para ((i=15; i>0; i-=3))
Faz 
  echo "Número do loop:" $i
feito

Quando o executamos, ele deve pular para trás em etapas de três.

 ./c-like2.sh 

Infinito para Loops

Você também pode usar esse formato de loop for para criar um loop infinito. Tudo o que você precisa fazer é remover todos os elementos do cabeçalho do loop, assim. Este é "infinite.sh".

 #!/bin/bash

por (( ; ; ))
Faz
  echo "Pressione Ctrl+C para parar..."
  dormir 1
feito

Você precisará pressionar Ctrl+C para parar o loop.

 ./infinite.sh 

para loops usando matrizes de palavras

Podemos facilmente iterar através de uma matriz de palavras. Precisamos fornecer o nome do array no cabeçalho do loop, e o iterador percorrerá todas as entradas do array. Este é “word-array.sh”.

 #!/bin/bash

distributions=("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")

para distribuição em $distributions
Faz
  echo $distro
feito

Todas as distribuições estão listadas para nós.

 ./word-array.sh 

O comando continuar

Se você quiser que o loop ultrapasse uma entrada específica, teste se o iterador corresponde a essa entrada e use o comando continue . O comando continue abandona a rotação atual do loop. Ele incrementa o iterador e inicia o próximo giro do loop – supondo que a entrada que você deseja pular não seja o último item da lista.

Este é "word-array2.sh." Ele passa por cima da entrada do array “Arch”, mas processa todos os outros membros do array.

 #!/bin/bash

distributions=("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")

para distribuição em $distributions
Faz
  if [[ "$distro" == "Arco" ]] ;
    então
    Prosseguir
  fi
  echo $distro
feito

“Arch” não aparece na janela do terminal.

 ./word-array2.sh 

O comando de pausa

O comando break sai do loop e impede mais processamento.

Este é "word-array3.sh." É o mesmo que o script anterior com continue substituído por break .

 #!/bin/bash

distributions=("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")

para distribuição em $distributions
Faz
  if [[ "$distro" == "Arco" ]] ;
    então
    parar
  fi
  echo $distro
feito

Quando o iterador contém “Arch”, o loop for abandona qualquer processamento adicional.

 ./word-array3.sh 

para Loops Usando Matrizes Associativas

No Bash 4 e superior, os arrays associativos permitem que você crie listas de pares chave-valor que podem ser pesquisados ​​pela chave ou pelo valor. Devido ao relacionamento bidirecional entre a chave e o valor, eles também são chamados de dicionários de dados.

RELACIONADO O que são dicionários Bash no Linux e como você os usa?

Podemos iterar através de um array associativo usando um loop for . Este script é “associative.sh”. Ele define um array associativo com quatro entradas, uma para cada “dog”, “cat”, “robin” e “human”. Estas são as chaves. Os valores são o número (padrão) de pernas que cada um tem.

 #!/bin/bash

declare -A animals=( [dog]=Quatro patas [cat]=Quatro patas [robin]=Duas patas [humano]=Duas patas )

para pernas em ${!animals[@]}
Faz
  if [ ${animals[$pernas]} == "Duas pernas" ]; então 
    eco ${pernas}
  fi
feito

O iterador é chamado de legs . Observe que o cabeçalho do loop contém um “ ! " ponto de exclamação. Isso não está agindo como o operador lógico NOT, é parte da sintaxe do array associativo. É necessário pesquisar no array.

O corpo do loop executa um teste de comparação de strings. Se o valor do membro da matriz for “Duas pernas”, ele imprime o valor da chave na janela do terminal. Quando o executamos, o script imprime as criaturas de duas pernas.

 ./associative.sh 

Iterando sobre a saída de comandos

Se você tiver um comando ou sequência de comandos que produzam uma lista de algo, como nomes de arquivos, você pode iterar por eles com um loop for . Você precisa tomar cuidado com expansões inesperadas de nomes de arquivos, mas em casos simples, tudo bem.

Este script é “command.sh”. ele usa ls e wc para fornecer uma lista ordenada de nomes de arquivos de script, juntamente com suas contagens de linhas, palavras e bytes.

 #!/bin/bash

para i em $(ls *.sh | sort);
Faz 
  eco $(wc $i)
feito

Quando o executamos, obtemos as estatísticas de cada arquivo, com os arquivos listados em ordem alfabética.

 ./command.sh 

O Deslumbrante para Loop

O loop for é uma ferramenta de script versátil e de fácil compreensão. Mas por mais flexível que seja, não se esqueça de que outros loops existem por um motivo. Não se iluda pensando que o loop for é tudo o que você precisa.

RELACIONADO Como processar um arquivo linha por linha em um script Bash do Linux

O loop while , por exemplo, é muito mais adequado para certas coisas do que o loop for , como ler linhas de um arquivo.

Escrever bons scripts significa usar a ferramenta mais adequada para a tarefa em mãos. O loop for é uma ótima ferramenta para ter em sua caixa de ferramentas de truques.