Guia completo para loops de batida

A maneira mais básica de interagir com o sistema Linux é a interface da linha de comando (CLI). A interface da linha de comando é uma janela front-end para receber comandos do usuário para executar uma tarefa específica. Uma tarefa pode estar criando um diretório, arquivo, inserindo dados, removendo um arquivo ou diretório, etc. O shell processa os comandos inseridos pelo usuário na CLI. Linux tem conchas diferentes, como Bourne Shell, C Shell, Z Shell, Korn Shell e Bourne novamente, que também é conhecido como Bash. Todas as conchas mencionadas têm suas próprias capacidades, mas uma das conchas mais usadas é bash.

Bash Shell sai da caixa com muitas distribuições Linux e contém recursos de muitas outras conchas também. Bash é muito mais eficiente quando se trata de executar uma operação via comando. Se você deseja executar uma tarefa que exija a execução de vários comandos com alguma lógica, há uma linguagem de programação inteira chamada Bash Script.

1. O que é script de bash?
2. O que são loops de bash?
3. Aplicações de loops na programação
4. Vantagens de loops na programação
5. Tipos de loops em Bash

• 5.1 BASH para sintaxe de loop
• 5.2 Bash enquanto a sintaxe do loop
• 5.3 BASH ATÉ LOOP SINTAX

6. Usando loops em Bash
6.1 Implementação de FOR LOOP EM BASH

• 6.1.1 Bash para loop iterando através de uma lista de strings
• 6.1.2 Bash para loop iterando através de uma lista de números
• 6.1.3 Bash para loop iterando através de uma variedade de itens
• 6.1.4 Bash para loop iterando através de uma matriz
• 6.1.5 BASH para loop em C como sintaxe
• 6.1.6 Bash for Loop Infinite Loop
• 6.1.7 Bash aninhado por loop

6.2 Implementação de While Loop em Bash

• 6.2.1 Bash enquanto loop para imprimir números
• 6.2.2 Bash Infinite While Loop
• 6.2.3 Bash enquanto loop com várias condições

6.3 Implementação de até o loop em Bash

• 6.3.1 Bash até o loop para imprimir números
• 6.3.2 Bash Infinite até o loop

7. Declarações de controle de loop

• 7.1 a declaração de quebra
• 7.2 A Declaração Continua

8. Exemplos de loops de festa

• 8.1 Exemplo 1: Alterando a extensão dos arquivos usando loops de bash
• 8.2 Exemplo 2: Modificando os nomes de arquivos usando loops de bash
• 8.3 Exemplo 3: Lendo um arquivo usando loops de bash
• 8.4 Exemplo 4: Encontrar um arquivo usando loops de bash
• 8.5 Exemplo 5: Criando um balcão simples usando loops de bash
• 8.6 Exemplo 6: Verificando a conexão com a Internet usando loops de bash
• 8.7 Exemplo 7: Uma calculadora simples com loops de bash
• 8.8 Exemplo 8: Encontrar a média usando loops de bash

9. Conclusão

1 O que é script de bash?

Um script é algo que informa ao sistema qual operação específica ele deve executar. Da mesma forma, Bash Scripts Command Bash Shell que o que deve fazer. Um arquivo de texto simples que carrega as cordas dos comandos bash é chamado de arquivo de script de bash. O script Bash executa comandos de uma maneira semelhante que o shell é executado, mas você pode aplicar operações lógicas para executar uma função específica. A linguagem de programação usada no Bash é chamada de linguagem de programação Bash.

A linguagem de programação do Bash é semelhante a qualquer outra linguagem de programação, onde você possa atribuir variáveis, aplicar declarações, loops e matrizes condicionais. Você pode executar qualquer tarefa de nível básico para programas complexos com centenas de instruções no script de bash. Para entender os scripts do Bash, vamos criar um simples Script Helloworld:

#! /BIN/BASH
eco "Bem -vindo ao script de Bash"

No script acima, “#!" é conhecido como "Shebang" ou "Hashbang," e "/BIN/BASH”É o caminho para o intérprete. O "eco”O comando exibe a saída na tela; O script acima está imprimindo uma corda. O script bash pode ser escrito em qualquer editor; Linux vem com editores padrão, como nano, vim, etc. Depois de digitar o script, salve o arquivo com o “.shExtensão, e.g., ““Olá Mundo.sh”. Para executar um script bash na CLI, use o “Bash”Comando:

$ bash helloworld.sh

O comando acima executa o script Bash e imprime a string, como mostrado na imagem de saída. Da mesma forma, você pode executar qualquer operação lógica usando instruções condicionais ou executar instruções repetidamente; Loops podem ser implementados. Este artigo é sobre Bash Loops. Loops são usados ​​para executar algumas linhas específicas de código repetidamente. O segmento a seguir cobrirá completamente os loops de bash:

2 O que são loops de bash?

Loops são uma das estruturas de programação fundamentais utilizadas na execução de uma sequência de instruções repetidamente até que uma condição específica seja atendida. Os programadores usam loops de várias maneiras, como iterando através dos valores de uma matriz, repetindo funções, adicionando números e criando contadores.

O loop verifica um conjunto de instruções no corpo do loop até que a condição do loop seja satisfeita, como demonstrado na imagem acima.

3 Aplicações de loops na programação:

Loops podem ser usados ​​para muitos propósitos na programação, o uso primário de loops é mencionado abaixo:

• Em algoritmos para procurar informações específicas
• Nos jogos para criar loops de jogo
• Criando contadores que podem ser úteis para automação
• Para repetir funções específicas
• Resolvendo problemas matemáticos complexos

Loops também são úteis para iterar através das matrizes também.

4 Vantagens dos loops na programação:

Loops in Programming têm várias vantagens:

• Loops podem executar uma tarefa repetidamente sem cometer erros (assumindo que as instruções estejam corretas)
• Loops permitem executar qualquer número de instruções repetidamente
• Loops simplificam os códigos complexos e os tornam eficientes
• Eles evitam escrever o mesmo código de novo e de novo
• Loops também podem ser usados ​​na estrutura de dados para iterar através das matrizes

5 tipos de loops em Bash:

Em Bash, existem três tipos de loop primário:

1. : para loop
2. : enquanto loop
3. : até o loop

1 BASH para a sintaxe do loop:

A festa básica para o loop itera através da lista de elementos e executa a instrução ou comandos mencionados no corpo do loop.

A sintaxe de Bash para Loop é:

para elemento na [lista]
fazer
[Comandos]
feito

A lista pode ser uma matriz, sequência de números ou strings ou saída de um comando. A festa básica para o loop também pode ser atribuída usando a estrutura da linguagem C:

para ((inicialização; condição; incremento)))
fazer
[Comandos]
feito

O "inicialização”Executa apenas uma vez, então“doença" está checado. Se for verdade, os comandos no corpo serão executados e continuarão executando até que a condição seja avaliada como falsa.

2 BATH enquanto sintaxe do loop:

O Bash, enquanto o loop executa o conjunto de declarações ou comandos específicos um número desconhecido de vezes até a condição especificada marcada como falsa:

enquanto [condição]
fazer
[Comandos]
feito

A condição é avaliada antes da execução do comando. Se a condição for verdadeira, o comando será executado; Se a condição ficar falsa, o loop será encerrado.

3 BASH ATÉ LOOP Sintaxe:

A batida até o loop executar o conjunto de declarações ou comanda um número infinito de vezes até que a condição especificada seja marcada como verdadeira:

Até [condição]
fazer
[Comandos]
feito

Semelhante ao loop while, a condição é verificada antes da execução do comando; Se a condição for falsa, o conjunto de declarações será executado. Se a condição se tornar verdadeira, o loop terá terminado.

Usando loops em Bash:

Como mencionado acima, o Bash possui três tipos principais de loops, e o uso de cada tipo depende da tarefa que um usuário deseja executar. Vamos mergulhar nos detalhes de como vários tipos de loops são atribuídos e manipulados em Bash.

1 Implementação de for Loop em Bash:

A seção a seguir está focada em como implementar o Bash for Loops in Bash Script. Em Bash for Loop é usado para revisar uma lista de objetos,

1.1 BASH para o loop iterando através de uma lista de strings:

A festa básica para o loop passa por uma lista de elementos, matriz ou pode ser usada para executar um conjunto de instruções no corpo do loop repetidamente. O exemplo a seguir é uma implementação do loop que está passando por uma lista de elementos da string:

#! /BIN/BASH
Para itens no sábado, domingo, segunda -feira, quarta -feira
fazer
eco "O item da lista é:" $ itens
feito

1.2 Bash para loop iterando através de uma lista de números:

Para itera através da lista de números:

#! /BIN/BASH
Para itens em 1 2 3 4 5
fazer
eco "O item da lista é:" $ itens
feito

1.3 Bash para loop iterando através de uma variedade de itens:

Em Bash, a expressão de sequência é usada para imprimir uma sequência de números. A expressão de sequência também suporta o intervalo. O loop for também pode ser aplicado para passar por cima da faixa de expressão de sequência. Por exemplo:

#! /BIN/BASH
Para itens em 1… 5
fazer
eco "O item da lista é:" $ itens
feito

A expressão "1… 5”É uma representação de números de 1 a 5. A sequência também pode ser definida com um incremento específico, a expressão a seguir seria “Start… fim… incremento”:

#! /BIN/BASH
Para itens em 1… 10… 2
fazer
eco "O item da lista é:" $ itens
feito

1.4 Bash para loop iterando através de uma matriz:

Loops são comumente usados ​​na iteração através de uma matriz. Vamos entender através de um exemplo:

#! /BIN/BASH
my_array = (janeiro de fevereiro de março maio de junho)
Para itens em $ my_array [@]
fazer
eco "itens na matriz:" $ itens
feito

1.5 Bash for Loop em C como a sintaxe:

Como mencionado acima, o Bash também suporta o loop no estilo de linguagem C. O exemplo a seguir demonstra como usar o estilo C para loop usado no Bash:

#! /BIN/BASH
para ((itens = 1; itens<=10 ; i++))
fazer
eco "número:" $ itens
feito

A estrutura do loop de estilo C é amplamente utilizada, fácil de lembrar e implementar. Como muitas linguagens de programação modernas suportam sintaxe de loop semelhante, a estrutura do loop acima imprimirá números de 1 a 10.

1.6 Bash for Loop Infinite Loop:

O loop infinito tem vários usos na programação. O exemplo a seguir é mostrar a implementação do loop infinito usando o Bash for Loop:

#! /BIN/BASH
contagem = 0
para (( ; ; ))
fazer
sono 2
eco $ contagem
eco "Pressione Ctrl+C para interromper a execução do código"
((contagem ++))
feito

1.7 Bash aninhado por loop:

Loops aninhados significam a estrutura do loop dentro de outra estrutura de loop; O primeiro loop será chamado de loop externo, enquanto o loop dentro do loop externo será chamado de loop interno. Cada iteração do loop externo executará todas as iterações do loop interno. O loop for bash também pode ser implementado no formato aninhado:

#! /BIN/BASH
para itens1 em janeiro de fevereiro
fazer
para itens2 em abril de maio
fazer
eco "$ itens1: $ itens2"
feito
feito

2 Implementação de While Loop em Bash:

A principal diferença entre Bash for Loop e enquanto o loop é que, enquanto o loop é usado quando o número de integrações é desconhecido. Vamos aprender como, enquanto o loop é atribuído e implementado em scripts de bash:

2.1 BACH enquanto loop para imprimir números:

O exemplo a seguir exibirá números de 1 a 10:

#! /BIN/BASH
x = 0
enquanto [$ x -le 10]
fazer
eco "Os números são:" $ x
((x ++))
feito

2.2 Bash Infinite While Loop:

O loop infinito executa continuamente e nunca termina. O loop infinito é usado para verificar as entradas dos usuários e responder de acordo. O exemplo mais comum é o loop do jogo, onde um jogador controla um personagem e o loop imprime a resposta de cada movimento:

#! /BIN/BASH
contagem = 0
enquanto :
fazer
sono 2
eco "contador =" $ contagem
eco "Pressione Ctrl+C para interromper a execução do código"
((contagem ++))
feito

O código acima imprimirá o valor do contador e “Olá ! Pressione Ctrl+C para sair do loop infinito ”após 1 segundo e imprimi -lo a cada segundo. O comando "Sleep" adiciona atraso à execução do programa. O cólon “:” Depois de “while” é o comando nulo. A outra maneira de atribuir infinito enquanto loop:

#! /BIN/BASH
contagem = 0
enquanto é verdade
fazer
sono 2
eco "contador =" $ contagem
eco "Pressione Ctrl+C para interromper a execução do código"
((contagem ++))
feito

2.3 BATH enquanto loop com várias condições:

O exemplo a seguir está demonstrando como várias condições são usadas com o Bash durante o loop:

#! /BIN/BASH
num1 = 1
num2 = 5
enquanto [[$ num1 -lt $ num2 || $ num1 == $ num2]]
fazer
eco "O número é:" $ num1
((num1 ++))
feito
eco "feito !"

Pode -se observar que, enquanto o loop está avaliando duas condições com ou operador “||”. Ou o operador é um operador booleano que gera verdadeiro se alguma das condições for verdadeira.

3 Implementação de até o loop em Bash:

O loop até que o loop é semelhante ao loop while, mas atinge até que a condição especificada seja avaliada como verdadeira. Vamos entender como implementar até o loop em Bash:

3.1 BACH AT até que o loop de impressão de números:

O exemplo a seguir de até o loop está imprimindo números na saída de 0 a 10:

#! /BIN/BASH
x = 0
Até [$ x -gt 10]
fazer
eco "Os números são:" $ x
((x ++))
feito

3.2 Bash Infinite até o loop in Bash:

O loop infinito usando o operador de loop é mencionado abaixo:

#! /BIN/BASH
x = 0
até falso
fazer
eco "contador:" $ x
((x ++))
sono 1
eco "Pressione Ctrl+C para acabar com o loop"
feito

Declarações de controle de loop:

Os loops são projetados para fazer loop continuamente até que uma condição específica seja atendida, mas há declarações através das quais o fluxo de loop pode ser controlado.

• A declaração de quebra
• A declaração continua

1 A declaração de quebra:

A palavra -chave quebrada termina o loop, não importa que tipo de construção de loop seja usado e executa as instruções do código fora do corpo do loop:

Vamos entender a declaração de quebra através de um exemplo de bash:

#! /BIN/BASH
para itens em janeiro fev mar abr maio jun jul
fazer
se [["$ item" == "May"]]
então
quebrar
fi
eco "os itens são:" $ itens
feito
eco "loop terminado"

Da mesma forma, a declaração de quebra também pode ser usada em um loop de tempo:

#! /BIN/BASH
x = 0
enquanto [$ x -LT 10]
fazer
eco "O número é:" $ x
((x ++))
se [["$ x" == "7"]]
então
quebrar
fi
feito
eco "loop terminado"

O exemplo de uma declaração até a malha é mencionada abaixo:

#! /BIN/BASH
x = 0
até falso
fazer
((x ++))
Se [[$ x -eq 5]]
então
quebrar
fi
Os valores de eco "são:" $ x
feito
eco "loop terminado"

Quando o valor do incremento ("x") é igual a 5, a declaração de quebra rescindirá o loop e as declarações fora do corpo do loop executarão.

2 A Declaração Continua:

A declaração continua termina a operação atual do loop, retorna à condição de loop original e executa a próxima iteração.

Vamos entender a declaração de controle de continuação por meio de um exemplo:

#! /BIN/BASH
para itens em janeiro fev mar abr maio jun jul
fazer
se [["$ item" == "May"]]
então
continuar
fi
eco “item na lista:” $ itens
feito

O loop for iterará através da lista de meses e para quando o valor se tornar “poderia““. Uma nova iteração começará e as instruções sob a declaração continuação não serão executadas. Pode ser visto na imagem de saída também que o “poderia”Está faltando na lista porque a declaração continua pulou a execução de“ eco ”quando o“Unid”A variável se torna igual à“poderia" corda.

Como para loop o “continuar”A declaração também pode ser implementada em um loop de tempo:

#! /BIN/BASH
x = 0
enquanto [$ x -LT 10]
fazer
((x ++))
Se [["$ x" -lt "5"]]
então
continuar
fi
eco “O número é:” $ x
feito

O código acima imprimirá os números de 1 a 10 e pulará 5, como demonstrado na imagem de saída. Um exemplo de implementação de “continuar”Declaração com até o loop ser mencionado abaixo:

#! /BIN/BASH
x = 0
até [$ x == 10]
fazer
((x ++))
Se [[$ x -eq 5]]
então
continuar
fi
eco “o número é:” $ x
feito

Exemplos de loops de festa:

As estruturas de loop têm várias implementações no Bash. Esta seção se concentrará em exemplos de bash mais avançados, onde os loops são implementados.

1 Exemplo 1: Alterando a extensão dos arquivos usando loops de bash:

O exemplo a seguir é pegar a extensão do arquivo do usuário; O script coletará todos os arquivos da extensão dada pelo usuário e os salvará em um arquivo “File_list”. O loop for passando pela lista dos arquivos. Considerando que a "cp”O comando criará a cópia do arquivo com o“.BakExtensão no diretório atual.

#! /BIN/BASH
eco "Digite a extensão do arquivo"
Leia ext
eco "Entre na extensão de conversão"
Leia Cov
LS *.$ ext> arquivos
para eu em 'CAT Files'
fazer
cp "$ i" "$ i".$ COV
feito

Vamos aprimorar o código acima:

#! /BIN/BASH
eco "Digite o nome do diretório"
Leia o dir
eco "Digite a extensão do nome do arquivo para ser convertido"
Leia F_EXT
eco "Digite a extensão do arquivo a ser convertida"
Leia Cov
para arquivo em $ dir/*$ f_ext
fazer
MV - "$ FILE" "$ FILE%$ f_ext $ cov"
feito

Agora, o código está pegando o nome do diretório que contém o arquivo, as extensões de nome do arquivo a serem convertidas e o nome da extensão para converter os arquivos no diretório. Um usuário pode obter qualquer arquivo e converter esses arquivos na extensão desejada.

2 Exemplo 2: Modificando os nomes dos arquivos usando loops de bash:

O espaço nos arquivos ou diretório pode criar problemas ao executar comandos que contêm caminhos. A interface da linha de comando não reconhece o espaço no nome de arquivos ou pastas, conforme demonstrado na imagem a seguir:

Você tem que usar citações ou sequências de fuga. Mas, felizmente, podemos criar um script bash que possa adicionar sublinhado "_" ou Dash "-" para preencher o espaço dos nomes e diretórios de arquivos.

#! /BIN/BASH
eco "Digite o nome da pasta"
Leia a pasta
Pasta CD $
Para arquivos em *\ *
fazer
MV "$ arquivos" "$ files ///_"
feito

O código acima está tomando o nome da pasta como entrada que é “minha pasta”, E contém os arquivos com espaço em seus nomes, conforme demonstrado na imagem de saída acima. O script substituirá o espaço por sublinhado “_”Nos nomes de arquivos presentes no diretório mencionado pelo usuário.

3 Exemplo 3: Lendo um arquivo usando loops de bash:

Um arquivo também pode ser lido usando a estrutura do loop:

#! /BIN/BASH
eco "Digite o nome do arquivo"
Leia o arquivo
enquanto é verdade
Leia -R l
fazer
eco $ l
feito < "$file"

O código acima está tomando o nome do arquivo de texto como uma entrada do usuário e imprimindo seu conteúdo.

4 Exemplo 4: Encontrar um arquivo usando loops de bash:

O exemplo a seguir encontra os arquivos pela extensão que o usuário fornece:

#! /BIN/BASH
eco "Digite a extensão do nome do arquivo"
Leia ext
Ifs = $ '\ n'
para arquivo em $ (encontre -name "*$ ext")
fazer
eco $ arquivo
feito
não serem ses

O IFS é uma variável de shell especial, um separador de campo interno usado para encontrar limites de palavras. Um usuário pode mencionar qualquer extensão de tipo de arquivo, como “.TXT", ".sh ", ou".PNG ”, o código encontrará todos os arquivos dessa extensão e os exibirá no terminal.

5 Exemplo 5: Criando um contador simples usando loops de bash:

Este exemplo contará com um número inserido pelo usuário:

#! /BIN/BASH
eco "digite um número"
Leia o contador
enquanto [$ contador -gt 0]
fazer
sono 1
eco $ contador
((contador--))
feito
eco "feito"

O código acima está recebendo um número do usuário e o balcão cai em um a cada segundo.

6 Exemplo 6: Verificando a conexão com a Internet usando loops de bash:

A estrutura do loop também pode ser usada para verificar a conexão com a Internet usando o “ping”Comando:

#! /BIN/BASH
contador = 5
enquanto [[$ contador -ne 0]]
fazer
ping -c 2 www.Google.com
check = $?
Se [[$ check -eq 0]]
então
eco "___________________"
eco "Internet está funcionando"
eco "___________________"
saída 0
fi
((contador--))
feito
eco "________________"
eco "Internet está baixa"
eco "________________"

O código acima fará ping para verificar o status do site do Google. O "-c”A bandeira é usada para contar. O valor da opção “-c”É 2, o que significa o“ping”Enviará as solicitações duas vezes. Se o código de saída “$?”É 0, o comando ping está recebendo reconhecimento e a internet está funcionando. O ping verá o status cinco vezes. Se não receber nenhum reconhecimento, o “A internet está baixa”O erro será exibido.

7 Exemplo 7: Uma calculadora simples com loops de bash:

O exemplo a seguir está pegando dois números do usuário e solicitando a operação para executar. O script Bash a seguir é executar adição, subtração, multiplicação e divisão:

#! /BIN/BASH
eco "Digite o número 1"
Leia num1
eco "Digite o número 2"
Leia o num2
enquanto é verdade
fazer
eco "selecione o número da operação"
eco "1 soma +: 2 diferença -: 3 multiplicação *: 4 divisão \: 5 desistir"
Leia o operador
Se [["$ operator" -eq "1"]]
então
((output = num1+num2))
Elif [["$ Operator" -eq "2"]]
então
((output = num1-num2))
Elif [["$ Operator" -eq "3"]]
então
((output = num1*num2))
Elif [["$ Operator" -eq "4"]]
então
((output = num1/num2))
Elif [["Operator" -eq "5"]]
então
saída 0
fi
eco "o resultado é" $ saída
feito

A calculadora continuará desempenhando funções até que o usuário conceda o comando para acabar com o infinito enquanto loop.

8 Exemplo 8: Encontrar a média usando loops de bash:

O exemplo a seguir terá números como entrada do usuário e calcula a média:

#!/BIN/BASH
enquanto é verdade; fazer
eco -n "Digite um número de 0 a 100 e pressione A/A para obter a média:"
Leia e_num
if (("$ e_num" "100")))
então
eco " !Entrada inválida! Digite o número de 0 a 100 "
elif (("$ e_num" == "a")) || (("$ e_num" == "a"))
então
eco "a média é: $ avg%"
quebrar
outro
soma = $ [$ sum + $ e_num]
num = $ [$ num + 1]
AVG = $ [$ SUM / $ NUM]
fi
feito

O código acima está obtendo números do usuário de 0 a 100. Se o número inserido não for 0 ou superior a 100, o usuário receberá uma mensagem de erro ao digitar o número desejado. Imprensa a/a Para obter a média na saída.

Conclusão:

As construções de loop são as principais construções da programação e são bastante úteis para programadores, especialmente na automação de operações repetitivas. Loops são usados ​​para executar instruções repetidamente até que o loop avalie uma declaração de teste específica. Loops têm vários usos na programação, como criar algoritmos, automação, criar loops de jogo, etc. Bash oferece três tipos de estruturas de loop: para loop, enquanto o loop e até o loop. A abordagem controlada também pode classificar loops; enquanto loops e até os loops serem controlados, porque a condição de teste é verificada antes que as instruções no loop sejam executadas. O Bash for Loop pode ser inicializado de duas maneiras distintas, em formato típico de bash e estilo de sintaxe da linguagem C. Básico para loop é simplesmente usado para iterar através da lista dos elementos ou matrizes. Na implementação de loop for, já sabemos a contagem de iteração, enquanto enquanto os loops são usados ​​quando o número de iterações é desconhecido. O loop while continua a fazer loop enquanto a instrução de verificação definida for verdadeira. É importante observar que, se nenhuma condição for especificada, o loop será denominado como um loop infinito. O loop infinito continua executando as instruções no loop, desde que não seja interrompido.

Em seguida, vem as declarações controladas por loop, o intervalo e a declaração contínua. A declaração de quebra é usada para encerrar o loop e executa as declarações fora do corpo do loop. No entanto, a declaração continua funciona da maneira oposta da declaração de quebra. Em vez de terminar o loop, a declaração continua força o loop da nova iteração e pula as instruções restantes do corpo do loop.

Todas as estruturas de loop de bash também podem ser usadas de maneira aninhada. Loops aninhados significam loops dentro de outros loops e são extremamente úteis para iterar através de duas matrizes diferentes. A seção final da redação abrange alguns exemplos básicos e avançados da implementação de loops de bash, embora existam várias maneiras de usar loops de bash em script de bash.

Os loops são uma estrutura de programação atraente e mantém vários benefícios; Eles simplificam os códigos complexos e os tornam mais eficientes. Se você deseja executar comandos específicos, não precisa digitá -los; Loops são projetados para executar essas tarefas.