Teoria Bash

0.index

1. Coisas que acontecem com a maioria das pessoas
2. Estrutura de um script
3. Imprimir na tela
4. Ler o usuário INPUT
5. Cálculos em bash
6. Condições
7. rotações
8. funções
9. getops

1. Coisas que acontecem com a maioria das pessoas

/ bin / bash ou / bin / sh

Uma das primeiras coisas que a máquina faz ao executar nosso script é ver com qual shell ela deve fazer isso. Na maioria dos sistemas Linux atuais / Bin / sh é um link para / bin / bash, mas nem sempre é o caso, por exemplo, em distribuições que usam busybox eles trazem Sh e geralmente eles também trazem Bater, mas se você usar / Bin / sh, não funcionará com o Bash. É por isso que recomendo sempre usar / bin / bash.

Unicode vs. ASCII

Você já se perguntou por que não pode usar "¿" ou "ñ" em seus scripts? Ou usar acentos? Pode ser muito chato em scripts interativos. Isso ocorre porque a codificação padrão para Bash é ASCII, ou o que é o mesmo, o conjunto de caracteres em inglês. Para alterá-lo, só precisamos informar ao nosso script que queremos usar Unicode. Para isso, você deve adicionar uma linha logo após o interpretador de comandos:

# - * - CODIFICAÇÃO: UTF-8 - * -

Cuidado, é importante que esta linha esteja no início do script.

Torne o script executável

É engraçado quantas pessoas executam os scripts com «$ bashscript.sh" em vez de "$./script.shAfinal, é para isso que definimos uma concha.

Para adicionar permissões de execução, você deve executar:

sudo + x script.sh

BIN = "pasta onde temos os scripts" PATH = "$ BIN $ PATH"

2. Estrutura de um script

1. Cabeça
2. Definição de variáveis ​​globais
3. ajudar
4. funções
5. Corpo Principal

O cabeçalho é onde indicamos qual shell queremos usar e a codificação. A vantagem das funções é reutilizar o código que se repete escrevendo-o apenas uma vez e para facilitar a compreensão do script, pois um código que ultrapassa 100 linhas é muito útil.

Para usar funções, elas devem ser definidas com antes do corpo principal de nosso script. E se quisermos usar variáveis ​​no nível global de todo o nosso script, tanto no corpo principal quanto nas funções, devemos defini-las no início de tudo, logo após o cabeçalho.

Finalmente, é uma boa prática escrever uma função auxiliar para quando nosso script for executado incorretamente ou com parâmetros inválidos. Obviamente, nesses casos queremos sair do script imediatamente, sem ler as funções. Para isso podemos usar:

function help () {echo "" "Nosso texto de ajuda bem formatado." "" sair se [[-z $ 1 || $ 1 == "-h" || $ 1 == "--help"]]; então ajude fi

Se adicionarmos "exit" à função de ajuda, sairemos do script toda vez que executarmos a ajuda, por exemplo, após mensagens de erro, etc. Salvamos algumas linhas de código.

A condição indica exibir ajuda na tela e sair se o script for executado sem parâmetros ou se -h / –help for especificado. Se você observar, esse é o comportamento padrão da maioria dos programas Linux.

3. Imprimir na tela

Existem 2 comandos principais para imprimir na tela em bash: «eco"E"printf«. Ambos são rápidos e fazem parte do bash. A principal diferença para um iniciante é que o echo adiciona uma nova linha no final, enquanto «printf" não o faça.

Echo é muito bom e é o que a maioria das pessoas usa, porém ao ler o INPUT do usuário, ou quando quiser imprimir variáveis ​​retiradas de arquivos por processador de texto, coisas estranhas podem acontecer. Eles geralmente são resolvidos facilmente, tão fácil quanto mudar as aspas duplas para simples ou vice-versa, ou tirar as referências de variáveis ​​das aspas. «Echo»Faz coisas estranhas também dependendo de como foi compilado, se sempre usarmos Ubuntu ou sempre Fedora, isso não nos afeta, mas se mudarmos a distribuição afeta.

É por isso que eu uso «printf«, O que não me dá dores de cabeça e também se comporta mais como«printf»De C ou do«impressão»Do Python, isso é muito importante se você quiser portar seu script para outra linguagem de programação.

4. Leia o usuário INPUT

Tudo o que escrevemos após o nome do nosso script e antes de pressionar a tecla ENTER é salvo automaticamente em variáveis ​​especiais. Essas variáveis ​​são do tipo $ X, em que X é um número.

«$0»Indica o nome do nosso script e de«$1»Ao infinito, tudo o que escrevemos depois é variável. Por exemplo:

cat << EOF >> test.sh #! / bin / bash # - * - CODIFICAÇÃO: UTF-8 - * - printf "\ $ 0 = $ 0 \ n" printf "\ $ 1 = $ 1 \ n" printf "\ $ 2 = $ 2 \ n" EOF chmod + x script.sh ./script.sh meu arquivo.txt

Criamos um script de teste, o tornamos executável e o executamos com 2 parâmetros. Obtemos a saída da tela de:

$ 0 = ./script.sh $ 1 = meu $ 2 = arquivo.txt

Usando aspas, poderíamos ter passado "meu arquivo.txt" para "$ 1".

Também podemos ler o INPUT de um usuário com o comando "ler", indicando diretamente a variável onde queremos salvar o parâmetro. Por exemplo:

printf "Qual é o seu nome? \ n" leia NOME printf "Olá, $ NAME. \ n"

5. Cálculos em Bash

Para isso podemos usar «expr«, Desde que não necessitemos de cálculos complexos. Duas coisas devem ser observadas, a primeira é que «expr»Admite apenas números inteiros, a segunda é que a divisão devolve o resultado inteiro, para ver o resto podemos usar«%".

Normalmente, queremos atribuir o resultado de expr a uma variável. Podemos fazer isso de duas maneiras:

VAR2 = `expr $ VAR1 / 10` VAR2 = $ (expr $ VAR1 / 100)

Você também pode pular «expr»Usando parênteses duplos:

VAR2 = $ (($ VAR1 / 100))

6 Condições

Já foi escrito longamente sobre «if«,«outro«,«elif»E condições. Você pode ler sobre isso em:

• Programação em Bash: parte 1
• Bash: condições if, then, else
• Verifique se um arquivo ou pasta existe ou não e mais com um loop if
• Programação em Bash: parte 2

Só quero destacar a diferença entre o uso de colchetes simples, «[]«, E colchetes duplos,«[[]]«, Para as condições. Com colchetes duplos, podemos usar condições adicionais:

• «&&"Para e
• «||»Para ou

Usar "&&"E"||»Com colchetes simples, cada parte deve ser separada entre colchetes separados. O exemplo usado para a parte do script que verifica se a ajuda precisa ser executada seria:

if [-z "$ 1"] || ["$ 1" == "-h"] || ["$ 1" == "--help"]]; então ajude fi

Também evita que tenhamos de escrever nomes de variáveis ​​entre aspas para evitar erros. Por exemplo:

se [$ 1 = 1]; então printf "O parâmetro é igual a 1."; fi se ["$ 1" = 1]; então printf "O parâmetro é igual a 1."; fi se [[$ 1 = 1]]; então printf "O parâmetro é igual a 1."; fi

Se script.sh fosse executado sem nenhum parâmetro, o primeiro caso geraria um erro:

bash: [: =: operador unário esperado

O que não foi falado é «casas«, Usado para simplificar«if«. Vamos começar do início, quando não temos nenhum «if»Todo código será executado. Se adicionarmos uma condição «if»Teremos dois casos, um em que o bloco de código dentro do«if»E o outro caso em que este bloco não é executado.

Se adicionarmos um «outro«Teremos também dois casos, mas estes dois casos são diferentes dos anteriores. Porque agora haverá dois blocos de código condicionais, A e B, e um bloco C, que é o resto do programa. A ou B será executado, e C. No caso anterior era A e C ou apenas C.

Para evitar condições de escrita «se / mais" Dentro de "outro»E para simplificar a leitura do código, foi criado«elif«. Quando temos muitas condições que dependem da anterior, por exemplo, intervalo de números ou tipo:

VAR1 = $ 1 se [[$ VAR1 = 1]]; então printf "1 \ n" elif [[$ VAR1 = 2]]; então printf "2 \ n" elif [[$ VAR1 = 3]]; então printf "3 \ n" else printf "nenhum \ n" fi

No caso do último «elif»Muitas condições serão lidas. Com o caso, este processo é simplificado:

VAR1 = $ 1 caso $ VAR em 1) printf "1 \ n" ;; 2) printf "2 \ n" ;; 3 | 4) printf "3 ou 4, depende \ n" ;; *) printf "nenhum \ n" ;; aquele C

Será lida uma variável, neste caso VAR1, e será verificado se é equivalente a algum dos casos, caso contrário, será executado o caso padrão "*". Os pontos e vírgulas duplos são equivalentes a «quebrar", Eles dizem"casas»Isso tem que acabar.

7. Loops

Muito poucos loops são conhecidos em qualquer linguagem de programação. Em Bash eles são «enquanto«,«até"E"para«. Já foi escrito no blog sobre estes:

• Programação em Bash: parte 1
• Programação em Bash: parte 2

Existem dois tipos de loops «para«, Aqueles que são do tipo«$ para VAR em LOQUESEA»E quais são do tipo C«$ para ((I = 0; I <= 10; I ++))«. O segundo tipo de loops «para»São muito úteis, pois possuem 3 partes no início do loop:

• Declaração e iniciação de variáveis ​​(neste caso uma variável auxiliar "I = 0").
• Condição de execução (até que I seja menor ou igual a 10).
• Aumento da variável auxiliar

Na minha opinião, é o loop mais poderoso de todos. Um exemplo, que imprime todos os números de 0 a 10, inclusive:

#! / bin / bash para ((I = 0; I <= 10; I ++)); faça printf "$ I \ n" feito

8. Funções

Existem algumas coisas que o Bash não nos permite fazer, certo? À primeira vista, as funções bash evitam que você faça 3 coisas: declarar variáveis ​​locais em funções, passar parâmetros para funções e retornar parâmetros. Tudo tem solução.

Não faça nada como:

#! / bin / bash VAR = 1 printc "$ VAR \ n" função hello () {VAR = 2 printf "$ VAR \ n"} hello printf "$ VAR \ n"

Isso imprime nas telas 1, 2 e 2.

Para declarar variáveis ​​locais, adicione «local»Ao declarar:

#! / bin / bash VAR = 1 printf "$ VAR1 \ n" função foo () {local VAR1 = 2 printf "$ VAR1 \ n"} printf "$ VAR1 \ n" foo printf "$ VAR1 \ n"

Isso imprime 1, 1, 2, 1 na tela.

Como você passa parâmetros para uma função?

#! / bin / bash # - * - CODIFICAÇÃO: UTF-8 - * - função hello () {printf "Olá $ 1 \ n"}

printf "Qual é o seu nome? \ n"
ler VAR1
olá $ VAR1

Como os parâmetros são retornados?

#! / bin / bash # - * - CODIFICAÇÃO: UTF-8 - * - function hello () {printf "Hello holita"} printf "Qual é o seu nome? \ n" leia VAR1 VAR1 = $ (hello) # AQUI ESTÁ printf "$ VAR1 $ VAR2 \ n"

Como você pode ver, isso tem duas desvantagens, você só pode retornar um parâmetro, que pode ser um vetor 😀, e se quiser retornar um parâmetro, você não pode mais imprimir na tela a partir dessa função.

9. Getops

Uma das últimas coisas que você precisa saber sobre o Bash para criar scripts complexos é «getops«. É usado para passar opções ao script, independentemente da ordem. A única desvantagem é que afeta apenas as opções curtas:

#! / bin / bash # - * - CODIFICAÇÃO: UTF-8 - * - VARC = 0 função help () {printf "Mensagem de ajuda \ n" sair} if [[-z $ 1]]; então ajude fi enquanto getopts: ha: b: c OPT; faça o case $ OPT em h) help ;; :) Socorro ;; a) VARA = $ OPTARG ;; b) VARB = $ OPTARG ;; c) VARC = 1 ;; \?) Socorro ;; esac done # Bloco principal do script que # faz coisas com VARA, VARB e VARC

«getopts»Lê as opções uma por uma, então um loop é necessário.

Existem 2 tipos de opções que podem ser passadas usando «obter opções":

• Parâmetros chamados sinalizadores, neste caso -c ou -h. Eles são especificados com a letra que queremos usar. Eles são como variáveis ​​booleanas, «verdadeiro»(São) ou«falso" (não estão).
• Parâmetros com argumentos associados, -a qualquer coisa, -b qualquer coisa. Eles são especificados com a letra desejada com dois pontos abaixo. O argumento é armazenado em OPTARG (este nome é imutável).

O que este script faz?

Mostra a mensagem de ajuda quando nenhuma opção é passada, quando o parâmetro "-h" é passado, quando um parâmetro inválido é passado (por exemplo "-x", isso é feito por "\?") Ou quando um parâmetro válido sem argumento (":"). No resto dos casos, ele salva a presença de "-c" como 1 em VARC e os valores passados ​​com "-a" e "-b" em VARA e VARB.