Dicas úteis para Shell Script

Separei algumas dicas para Shell Script, deem uma analisada

→ Contar os caracteres de uma variável

echo ${#variavel}

→ Usando o comando cut

cat arquivo.txt | cut -c3
cat arquivo.txt | cut -c3-
cat /etc/passwd | cut -d: -f1
cat arquivo.txt | cut -c3-6
cat arquivo.txt | cut -c3 | sort

→ Variáveis ​​locais e o comando define:

Uma variável declarada como local é aquele que só é visível dentro do bloco de código em que ela aparece. Em uma função, uma variável local só tem sentido dentro desse bloco de função forma de declarar uma variável(aspas simples e colar igual(=))

  hello(){
  local variavel = 'teste'
  }
 

→ Comando Shift:

Para trabalhar com parêmtros você pode utilizar o comando shift, que desloca parâmetros

Exemplo de como usar o shift (arquivo ./teste.sh):

 #!/bin/bash
 echo $@
 shift
 echo $@
 

exemplo com saida

./teste.sh param1 param2 param3
 param1 param2 param3
 param2 param3
 

→ A Variável RANDOM:

gerar um número randômico (aleatório) que seja até no máximo 60

echo $(($RANDOM % 61))

→ O comando declare e o comando readonly

-r (readonly) -i (integer/numeros)

-f (para criar funções somente leitura)

declare -r variavel
readonly variavel='Isso é um teste!'

→ O comando case:

O uso do ‘case’ tem de usar dessa forma: o case, o in, o ;;, o ) e o esac

opcao="$1"

case "$opcao" in
eric)
echo "Menino"
;;
camila)
echo "Mulher"
;;
marcos)
echo "Homem"
;;
esac 

→ Utilizando o bc

Introdução

O bc não é exatamente uma calculadora, mas sim uma linguagem para cálculos, que lembra vagamente a linguagem C. O que significa que podemos ter construções como ‘if’, ‘for’, ‘while’ , que um programa pode pedir informações para um usuário, e que podemos usar “programas” escritos para o ‘bc’ como se usássemos um shell script.

Para chamar o bc, basta digitar numa janela de terminal, ‘bc’. Para fazer um cálculo, basta digitar a expressão e dar ENTER .

Operações definidas

Adição, subtração, multiplicação, divisão. % | (resto da divisão) ^ | (potenciação) sqrt(x) | (raiz quadrada de x) last | (último resultado) Para sair, basta dar ‘quit’.

bc
  bc 1.06
  Copyright 1991-1994, 1997, 1998, 2000 Free Software Foundation, Inc.
  This is free software with ABSOLUTELY NO WARRANTY.
  For details type `warranty'.
  300*500
  150000
  last + 500
  150500
  last - 1600
  148900
  last / 20
  7445
  last^4
  3072265955400625
  sqrt(last)
  55428025
  2/3
  0
  quit
  

Você pode estar pensando, depois desse último resultado (2/3 = 0?), “Epa! Alguma coisa está errada!”.

Calma, não se desespere. Você precisa carregar o bc com o parâmetro ‘-l’, que ativa uma biblioteca de operações matemáticas.

bc -l
  bc 1.06
  Copyright 1991-1994, 1997, 1998, 2000 Free Software Foundation, Inc.
  This is free software with ABSOLUTELY NO WARRANTY.
  For details type `warranty'.
  2/3
  .66666666666666666666
  3/5
  .60000000000000000000
  33/4589259837593
  .00000000000719070202
  3125886/2592375832
  .00120579969980216973
  

Pequena curiosidade: o comando ‘quit’ é executado assim que ele é encontrado. Portanto, algo como

if (0==1) quit mesmo 0==1 sendo impossível, vai fazer o ‘ bcsair. Tome cuidado com isso.

Quando carregamos o bc com a opção ‘-l’, temos alguns comandos matemáticos:

s(x) o seno de x (x em radianos)
c(x) o cosseno de x (x em radianos)
a(x) o inverso da tangente de x (retorna radianos).

Se y = tangente de x (tg x), a(y) = x

l(x) o logaritmo natural de x. (ln x)
e(x) a função exponencial ( e^x ) (exp x)

Podemos definir algumas funções extras a partir da definição matemática

define sin(x) {return s(x)}

define cos(x) {return c(x)}

tg x = sen x / cos x

define tan(x) {return s(x)/c(x)}

log10 x (logaritmo na base 10 de x) = ln x / ln 10

define l10(x) {return l(x)/l(10)}

Conversão entre radianos e graus:

d2r: graus para radianos

r2d: radianos para graus

pi = 3.14159265

define d2r(n) { return n * (pi/180); }

define r2d(n) { return n / (pi/180); }

Mas é chato ficar digitando essas definições toda vez que queremos usar o ‘bc’.

Portanto, iremos criar um script que defina essas funções automaticamente.

Crie, usando seu editor de texto preferido (vi, emacs, Gedit…) um arquivo com o seguinte

#!/usr/bin/bc -l
#
# Nosso arquivo de definições
# Nós vamos entender o 'define' depois.
pi = 3.14159265
define ln(n) { return l(n); }
define log(n) { return ln(n)/ln(10); }
define log2(n) { return l(n)/l(2); }
define d2r(n) { return n * (pi/180); }
define r2d(n) { return n / (pi/180); }
define sin(x) { return s(d2r(x)); }
define cos(x) { return c(d2r(x)); }
define tan(x) { return sin(x)/cos(x); } 

Salve ele como ‘define.bc’ no seu diretório HOME. Mude os atributos dele, tal que ele seja executável:

chmod a+x define.bc

Agora, chame o arquivo:

~/define.bc

Experimente usar os comandos:

cos(15)
.96592582636649385821
log2(2097152)
21.000000000000000021
quit

Note que ocorre um pequeno desvio nas casas decimais.

O comando “define”. Mas afinal, o que o comando faz?

Ele simplesmente define uma função.

Dentro dele podemos usar os elementos acima citados, além destes:

Como podemos notar, a linguagem é bem semelhante ao C. Porém, não há nenhum elemento parecido com o ‘goto’ ou o ‘switch’, o que a torna bem limitada.

quit | Só deve ser usado em modo interativo.

Assim que ‘quit’ for encontrado, o bc sai. (ver curiosidade no item 2) Em programas devemos usar ‘halt’.

Definição recursiva do fatorial:

#!/usr/bin/bc -l
define f (x) {
if (x <= 1) return (1);
 return (f(x-1) * x);
}

Solução da equação do 2o grau

Como o bc força o retorno de apenas um valor por função, criamos 2 funções para retornar as 2 raízes da equação

  #!/usr/bin/bc -l
  define delta(a,b,c) { return b^2 - 4*a*c }
  define eq2grau(a,b,c) {
   auto d;
   d = delta(a,b,c);
   if (d<0) halt;
   if (d>=0) {
    return (-b + sqrt(d))/(2*a);
   }
  }
  define eq2grau2(a,b,c) {
   d = delta(a,b,c);
   if (d<0) halt;
   if (d==0) return eq2grau(a,b,c);
   if (d>0) {
    return (-b - sqrt(d))/(2*a);
   }
  }

Às vezes, precisamos fazer um cálculo num shell script. O bc torna isso moleza

__x=$(echo “358358*5824825” bc)__

echo $x

2087372637350

Simples, não?

A estrutura é

__variavel=$(echo “expressão” bc)__

Conclusão e considerações finais

Nesse artigo, vimos como usar os comandos básicos do programa bc, que, embora aparentemente limitado, pode quebrar um bom galho como uma calculadora programável e em shell scripts. Porém, ele não deve ser considerado como uma linguagem de programação completa, mas sim como uma linguagem específica para sua aplicação.

→ Usando o ‘sleep’ e o ‘clear’ para programas interativos

 sleep 1 # tempo de 1 segundo de espera na execução
 clear #(limpa a tela)

→ o comando ‘reset’

É o mesmo que o clear, porém limpa a tela totalmente(a barra de rolagem fica integral)

→ Mostrar hora

DATA=`date +%T`
echo $DATA

→ O comando tput

Envia a seqüência para mover o cursor para a linha 2, coluna 4 (no canto superior esquerdo da tela, geralmente conhecida como a “casa” posição do cursor).

cat arquivo.txt | tput cup 2 4

→ O comando diff(utilizado para para mostrar diferenças em arquivos)

diff hashing_site.txt hashing_sum.txt

→ Usando o Comando beep

apt-get install beep
beep -l 5000
-f frequênciaDefine a frequencia, muda o tom do som, permitindo realizar combinações muito interessantes
beep -l 2000 -f 100
-r repetiçõesDefine o numero de repetições
beep -l 800 -f 100 -r 5
-d tempo - Determina o tempo (delay) de espera de repetição entre um som e outro, usado junto com a opção -r
beep -l 500 -r 5 -d 1000
-n Usa uma linha de comando do beep para realizar vários sons diferentes
beep -l 700 -f 1 -n -l 700 -f 10 -n -l 700 -f 100
-s Essa opção trata do processamento de entrada e saída de dados. A opção -s conta as linhas que foram redirecionadas para o beep por meio do pipe ( )
cat zonebin.txt | beep -s -f 500
-c Essa opção trata do processamento de entrada e saída de dados, contando os caracteres que forem redirecionados pelo pipe
echo zonebin | beep -c -f 100 -l 900

→ Passando argumentos para funções

#!/bin/bash
ola(){
echo "Olá $1, vamos ser terminalroot." ; 
}
ola Marcos
echo '$* ou $@(argumentos da função) =' $* 'ou' $@ ', $#(número de parâmetros para função) = '$# ', $0 = '$0

Nota adicional para funções, ao invés de criar vários aliases no .bashrc melhor criar funções em um diretório, exemplo:

  • a) edite seu .bashrc somente uma vez incluindo uma linha
echo 'alias minhasfuncoes="/home/$USER/minhasfuncoes.sh"' >> /home/$USER/.bashrc
echo '#!/bin/bash' > funcoesbosta.sh && echo '/home/$USER/funcoes/./$1' >> minhasfuncoes.sh
mkdir /home/$USER/funcoes

♠ Função bobmarley()

echo '#!/bin/bash' > /home/$USER/funcoes/bobmarley && echo 'bobmarley(){ echo "Músico jamaicano!";}' >> /home/$USER/funcoes/bobmarley && echo 'bobmarley' >> /home/$USER/funcoes/bobmarley

♠ Função malcomx()

echo '#!/bin/bash' > /home/$USER/funcoes/malcomx && echo 'malcomx(){ echo "Líder Revolucionário!";}' >> /home/$USER/funcoes/malcomx && echo 'malcomx' >> /home/$USER/funcoes/malcomx
chmod +x /home/$USER/minhasfuncoes.sh && chmod -R +x /home/$USER/funcoes/
minhasfuncoes bobmarley
Músico jamaicano! 
minhasfuncoes malcomx
Líder Revolucionário! 

Ainda há como torná-las de leitura automática sem precisar chamar a minhasfuncoes, assim como as FunçõesZZ do Aurélio.

→ O comando exit:

Você pode usar variáveis ​​shell especial chamado? para obter o status de saída do comando anteriormente executado.Para imprimir? variável usar o comando echo

#!/bin/bash
echo "Isto é um teste."
# Terminar nosso script shell com mensagem de sucesso
exit 0 
echo $?
echo $?
date # executar o comando data
echo $? # imprime status de saída
foobar123 # não é um comando válido
echo $? # imprime status de saída

→ O comando seq

Ele é praticamente o loop for, mostra uma sequência de tal número até outro número.No exemplo abaixo, contará do número 2 até o número 8

seq 2 8

mesmo que:

 for i in {2..8}
 do
  echo $i
 done 

ou até mesmo(os dois aninhados):

 for i in $(seq 2 8)
 do
 echo $i
 done

→ O comando let

Ele praticamente é um ‘incrementador’, se vc digitar isso num terminal, verá que ele incrementar +1 na variável j

echo $j
let j++
echo $j
1
let j++
echo $j
2

→ Operações básicas com vetores/arrays

Se há um recurso muito útil na programação, certamente é a possibilidade de agruparmos várias variáveis de um mesmo tipo em uma só. São o que chamamos de vetor, ou matriz - em inglês se diz array.

vetor=(eric camila marcos débora)
echo ${vetor[3]}
débora
echo ${vetor[0]}
eric
  

→ O comando unset(serve para apagar: variáveis, vetores/arrays e funções)

Veja a parte 2 dos Exmplos Úteis

Dicas úteis para Shell Script 2

Mais infos e fontes:

https://help.gnome.org/users/zenity/stable/

http://funcoeszz.net/http://bash.cyberciti.biz/guide/Main_Page

http://www.vivaolinux.com.br/

http://www.dicas-l.com.br/

http://pt.wikipedia.org/wiki/Cut_%28Unix%29

http://renanbirck.blogspot.com/