• attachment:bash.txt of Brasil/GUD/PE/DiaD2009

   1 ÍNDICE
   2 
   3 1. - A SHELL NO LINUX
   4   1.1 - O que é uma shell?
   5   1.2 - Principais tarefas da shell.
   6 
   7 2. - O BÁSICO DO BÁSICO.   
   8   2.1 - Conectivos padrões e retornos lógicos.
   9   2.2 - A matemática na shell.
  10   2.3 - Tipos de parametros.
  11 
  12 3. - VARIÁVEIS
  13   3.1 - Variáveis ambiente.
  14   3.2 - Atribuindo comandos à variáveis.
  15 
  16 4. - ESTRUTURAS DE LOOP E CONDIÇÕES
  17   4.1 - Usando loops.
  18   4.2 - Fazendo condições.
  19   
  20 5. - AVANÇANDO
  21   5.1 - Redirecionando entrada/saída de dados.
  22   5.2 - Usando comandos em background e adcionando interrupções.
  23   5.3 - Alguns comandos: sed, cut, wc, od.
  24   5.4 - Cores no terminal.
  25 
  26 6. - ARQUIVOS DE CONFIGURAÇÃO
  27   6.1 - .bashrc
  28   6.2 - .bash_history
  29 
  30 
  31 BIBLIOGRAFIA:
  32 -------------
  33 Programação Shell Linux, Júlio Cezar Neves, Brasport.
  34 The GNU Bash Reference Manual
  35 http://www.network-theory.co.uk/bash/manual/toc/
  36 
  37 AUTOR:
  38 ------
  39 Alexandre Mulatinho,
  40 crudo@psl-pe.softwarelivre.org
  41 
  42 -EOF-
  43  
  44  
  45 
  46 1. A shell no Linux
  47 
  48   A shell está no Linux desde o início e serve justamente  para executar os
  49 comandos com mais  eficiência  do que seriam  executados  se estivessem sem
  50 a organização que ela oferece.
  51 
  52   O  Linux  desde o início foi  desenvolvido  em partes que formam um  todo
  53 utilizando um núcleo que chamamos de KERNEL,  essas partes são  pequenos ou
  54 grandes programas que utilizam  chamadas do kernel para realizar a  maioria
  55 de suas tarefas em conjunto ou separados. Digamos que se quisessemos copiar
  56 um  arquivo para outro  usariamos algo como o  comando cp ou se quisessemos 
  57 apenas modificar seu nome usariamos o comando mv. Para que tudo  fosse mais
  58 prático os seus desenvolvedores pensaram em algo que pudesse interpretar  e
  59 unir com mais facilidade esses comandos/programas, foi aí que originou-se a
  60 shell com o intuito de organizar estes  comandos, interpretando-os e também
  61 com uma poderosa linguagem de programação com o conjunto de seus programas.
  62 
  63   O sistema operacional  UNIX e seus derivados como no nosso caso, o Linux,
  64 é composto por várias  "camadas".  A mais  interna  de  todas  elas é a que
  65 chamamos de  KERNEL ou núcleo,  ele é responsável por interagir diretamente
  66 com o HARDWARE simplesmente fornecendo o controle total para que o resto do
  67 sistema funcione, por exemplo quando escrevemos algo em um arquivo ou mesmo
  68 quando estamos lendo, o  KERNEL envia sinais para que o processador procure
  69 na trilha e no setor certo do disco onde está sendo gravado/lido certo dado
  70 que foi processado. 
  71 
  72   Os programas  por  sua vez quando  são executados as vezes precisam que o 
  73 usuário forneça  dados como  argumentos ou opções,  no nosso terminal então
  74 precisamos de algo que  entenda  o que está sendo pedido e é  finalmente aí 
  75 onde entramos com a SHELL.
  76 
  77 
  78 
  79 1.1 O Que é uma shell?
  80 
  81   Pra começo de conversa, no momento em que você se loga no sistema você já
  82 está numa SHELL. A SHELL é um meio pelo qual o usuário entra com dados para
  83 o sistema fazendo com que o  sistema  identifique esses dados e os converta 
  84 para o sistema operacional poder lê-los sem ter que resolvê-los, diminuindo
  85 assim o tempo que seria gasto se a  SHELL não interpretasse esses dados e o 
  86 deixasse para que o  kernel também fosse  resolvê-lo.  Tendo em vista esses 
  87 dados podemos dizer que a  SHELL é uma ferramenta poderosa que  usamos para
  88 interpretar nossos comandos antes de roda-los fazendo com que seja possível
  89 o uso de  parametros,  substituição de  strings,  modificação de  variáveis 
  90 ambiente, etc.  Também  vale ressaltar que a  shell  vem  com uma linguagem 
  91 poderosa, chamada shell script, que nos  permite utilizar laços de condição
  92 e processamento de certos dados, principalmente os de entrada e saída .
  93 
  94 
  95 
  96 1.2 Principais tarefas da Shell.
  97 
  98   As principais tarefas  da nossa shell são compreender e organizar a linha 
  99 de comando que o usuário  envia na  entrada de dados, fazendo assim com que 
 100 os comandos executados rodem com mais performance e de um jeito muito  mais
 101 estruturado, depois de feito isso a  shell ordena de ESPAÇO  em ESPAÇO cada
 102 comando e argumento enviado, procurando-os na variável $PATH que contém  os
 103 caminhos onde o usuário em questão pode executar programas.
 104   A shell  também é  capaz de  agir  como  um  interpretador  de  linguagem
 105 estruturada,  permitindo-nos  fazer scripts com a  mistura de comandos  que
 106 o sistema nos fornece. Podemos resumir então estes processos desta forma:
 107  
 108   => A shell pega os dados e os interpreta antes de serem executados.
 109   => Usa variáveis ambiente como o $PATH, que nos mostra os diretórios aos
 110      quais o usuário tem acesso para execução de comandos.
 111   => Processa como os dados vão sair e entrar corretamente (input/output).
 112   => A nível de programação ela executa laços, condições, etc.
 113 
 114 
 115 
 116 2. O básico do básico.
 117 
 118   Este capítulo é chamado de  básico do básico  porque relaciona coisas bem
 119 iniciantes  a nível de noções da  shell no Linux,  para obtermos  uma visão 
 120 correta é preciso ter noção de como funciona alguns comandos do  linux  que 
 121 estão diretamente ligados ao uso da nossa shell, por exemplo para listarmos
 122 o conteúdo de  um  diretório  não  precisamos  entrar  nele  para  ver seus 
 123 arquivos,  basta que usemos  o  comando de  listagem  com o  diretório como
 124 parametro, por exemplo:
 125 
 126 $ ls /home/alexandre/txtz/y0/
 127 bash.txt  plantz.txt  provas.txt  userfile.txt
 128 
 129 ou
 130 
 131 $ cd /home/alexandre/txtz/y0
 132 $ pwd
 133 /home/alexandre/txtz/y0
 134 $ ls
 135 bash.txt  plantz.txt  provas.txt  userfile.txt
 136 
 137   Como podemos ver isso tudo é muito básico mas é necessário ter uma idéia 
 138 que estamos trabalhando com um  interpretador  de comandos que nos oferece 
 139 além  de  qualidade  para  entender  o  que  está  sendo  digitado  também
 140 praticidade e velocidade.  Vejamos como seria se eu quisesse me movimentar
 141 um diretório abaixo:
 142 
 143 $ cd ..
 144 $ pwd
 145 /home/alexandre/txtz
 146 $ ls -lh
 147 -rw-r--r--    1 alexandr users        307k Dec 22  2003 focalinux.txt
 148 drwxr-xr-x    2 alexandr users         200 Sep  3 12:01 y0
 149 
 150  Vemos que descemos um diretório abaixo de onde estávamos usando o comando
 151 cd seguido de 2 pontos finais, a shell interpreta isso fazendo com que nós
 152 voltemos  um  diretório  do  orignal  a  qual  estávamos.  Uma  observação
 153 interessante a  se  comentar é que o diretório  y0  nada mais é  do que um 
 154 arquivo assim como todos os diretórios do linux, a diferença é a flagzinha
 155 'd' na sua permissão.
 156 
 157   Outra coisa que devemos observar  é  que como na  matemática a  shell da
 158 preferência a opções que estejam entre parenteses, por exemplo:
 159 
 160 $ ls txtz/y0/
 161 bash.txt  file.txt  plantz.txt  provas.txt  userfile.txt
 162 $ pwd
 163 /home/alexandre
 164 $ ( cd txtz/y0/ ; cat file.txt )
 165 voce esta me lendo! ohh :~
 166 $ pwd
 167 /home/alexandre
 168 
 169   Ué ? por que eu não fui pro diretorio txtz/y0/ ?  e como eu li o arquivo
 170 file.txt se ele estava dentro desse diretório e eu ainda continuo no $HOME
 171 CALMA!  Não foi nenhuma macumba..  o  que  aconteceu foi que a  shell  deu
 172 preferência ao comando entre parenteses,  executou o comando  em uma shell
 173 filho e retornou a shell normal matando a shell filho.
 174   Outro tipo de forma pra mostramos como o parenteses está em preferência
 175 com a shell é usando um comando qualquer entre parenteses:
 176 
 177 $ echo "A versão do meu kernel é: $(uname -r)"
 178 A versão do meu kernel é: 2.4.26
 179 
 180   Para saber como funciona essa  interpretação  de comandos  nós temos que 
 181 voltar a coisas bem iniciais  por isso  chamamos  essa parte de  básico do 
 182 básico, imaginemos então:
 183 
 184 $ ls 
 185 eu.txt voce.txt nos.txt vos.txt eles.txt
 186 
 187   Temos  um  comando simples  'ls'  que quando  executado  na  shell 
 188 retorna os arquivos do diretorio em que estamos. Agora vejamos:
 189 
 190 $ ls e*
 191 eu.txt eles.txt
 192   
 193   Digitamos novamente o 'ls' sendo que com um argumento,  a primeira letra
 194 'e' seguida de um ASTERISCO,  a shell então  retorna todos os  arquivos do
 195 diretório que contém a primeira letra que indicamos mais TODO O RESTO, que
 196 é o que significa o asterisco. Vemos agora a utilidade das aspas no echo:
 197 
 198 $ echo 1 2 3...    VOCE  EH ESTA  APRENDENDO  BASH
 199 1 2 3... VOCE EH ESTA APRENDENDO BASH
 200 $ echo "1 2 3...    VOCE  EH ESTA  APRENDENDO  BASH"
 201 1 2 3...    VOCE  EH ESTA  APRENDENDO  BASH
 202 
 203 OBS: Veja que a mudança ocorre na saída do texto quando usamos às aspas.
 204 
 205   Resumindo,  ela interpretou  o comando  antes de executa-lo, isso se faz
 206 muito útil para que você as vezes  não tenha que fazer vários comandos com
 207 um objetivo só ou as vezes queira  obter mais  performance. Por exemplo no 
 208 caso de interagir  com um ou mais comandos,  deve-se usar conectivos.
 209 
 210 
 211 
 212 2.1 Conectivos padrões e retornos lógicos.
 213 
 214         TABELA DE CONECTIVOS                       TABELA VERDADE
 215 +-----------+---------------------------------+   +---+---+------+
 216 | CONECTIVO | DESCRIÇÃO                       |   | A | B | A & B|
 217 +-----------+---------------------------------+   +---+---+------+
 218 |     &     | AND (E) lógico.                 |   | 0 | 0 |  0   | 
 219 |     |     | DOUBLE PIPE (OU) lógico.        |   | 0 | 1 |  0   |
 220 |     |     | PIPE (OU) lógico.               |   | 1 | 0 |  0   |
 221 +-----------+---------------------------------+   | 1 | 1 |  1   |
 222                                                   +---+---+------+
 223 
 224 $ df -h
 225 Filesystem            Size  Used Avail Use% Mounted on
 226 /dev/hda1             9.8G  2.9G  6.9G  29% /
 227 /dev/hda4              14G  3.2G   10G  23% /mnt
 228 $ echo $?
 229 0
 230 
 231   O duplo caracter $? (dólar,interrogação) retorna o valor do resultado do
 232 comando digitado na entrada, fornecendo  0 se o comando retornar OK e 1 se 
 233 ele  retornar com algum erro (observemos que é o inverso da tabela verdade 
 234 usada na lei de Boole). Com isso podemos usar os conectivos e colocar dois
 235 comandos numa linha apenas, por exemplo:
 236 
 237 $ cd /
 238 $ echo "Arquivos do diretório atual ($PWD):" && ls
 239 Arquivos do diretório atual (/):
 240 bin  boot  dev  etc  home  lib  mnt  opt  proc  root  sbin  tmp  usr  var
 241 
 242  *OBS: Como o resultado do comando echo e do ls são 0 (e na tabela verdade 
 243 da shell o 0 representa LIGADO), indicando que eles retornaram  VERDADEIRO 
 244 os dois comandos são colocados na tela. O  $PWD  é uma variável do sistema 
 245 que será explicada depois ;)
 246 
 247   Então já podemos dizer que a  tabela  VERDADE  da nossa shell ficaria da
 248 forma inversa da tabela original da lei de Boole.
 249 
 250 TABELA VERDADE DE EXECUÇÃO NA SHELL
 251    +---+---+------+
 252    | A | B | A&&B |          RETORNO:
 253    +---+---+------+          --------
 254    | 0 | 0 |  0   |          0 = OK. 
 255    | 0 | 1 |  1   |          1 = ERRO.
 256    | 1 | 0 |  1   |
 257    | 1 | 1 |  1   |
 258    +---+---+------+
 259    
 260   Ou seja, os dois comandos só seriam impressos na tela juntos se ambos os
 261 termos fossem  0  quanto ao seu resultado.  Agora vejamos se  no  primeiro 
 262 argumento  o resultado fosse maior que ou igual a 1,  e o próximo fosse  0
 263 usando o AND condicional ficaria:
 264 
 265 $ ls /root && echo "Fim do /root"
 266 ls: /root: Permission denied
 267 $ echo $?
 268 1
 269 
 270  *OBS: O  1° argumento retorna um numero diferente de 0 fazendo com que  o
 271       2° comando nao seja executado porque de acordo com a tabela  verdade
 272       do AND condicional o 2° comando só executado se houvesse uma verdade
 273       lógica ou um retorno 0;.
 274 
 275  Temos:
 276    $ ls /root
 277    ls: /root: Permission denied
 278    $ echo $?
 279    1
 280 
 281    $ echo "Fim do /root"
 282    Fim do /root
 283    $ echo $? 
 284    0
 285 
 286   Então:
 287     1 && 0 => 1 (ERRO/DESLIGADO)
 288   
 289   Já no caso do PIPE (|), a prioridade dos argumentos sempre estão do lado
 290 direito(ou 2° argumento) é muito útil quando estamos lendo algo no console
 291 quando o texto é muito grande e precisamos realizar pausas pra leitura:
 292 
 293 $ cat /usr/doc/Linux-HOWTOs/Bash-Prompt-HOWTO | grep PS1
 294 
 295  O comando cat é executado fazendo com que todo o arquivo seja impresso na
 296 tela embora com uma diferença, todo o texto é enviado para o comando grep,
 297 que por sua vez procura por strings no arquivo de entrada retornando apenas
 298 as linhas que contenham o argumento passado no comando 'grep' ;]
 299 
 300 
 301 
 302 2.2 A matemática da shell.
 303 
 304   Temos várias  formas para realizarmos  calculos  matemáticos  na  shell, 
 305 podemos  simplesmente  usar  o comando  'expr'  ou  usar  cálculos  entre 
 306 parenteses com as definições de operadores da shell.
 307 
 308 TABELA DE OPERADORES
 309 +-------+-----------------------------------------------+
 310 | VALOR | SIGNIFICADO                                   |
 311 +-------+-----------------------------------------------+
 312 |   +   | Como na matemática, serve para somar números. |
 313 |   -   | Também como na matemática, subtrair.          |
 314 |   /   | Este é o operador para divisão de números.    |
 315 |   *   | Operador de multiplicação.                    |
 316 |   %   | Resto de uma divisão.                         |
 317 | == != | Igual e diferente.                            |
 318 | <= >= | Menor igual que, maior igual que.             |
 319 +-------+-----------------------------------------------+
 320 
 321   Podemos realizar operações usando o comando  expr mais os números e  que
 322 tipo de operadores queremos para realizar cálculos, ou simplesmente usar o
 323 echo $((CALCULO MATEMATICO)), onde dentro desses  DOIS parenteses, faremos
 324 o cálculo para ser armazenado ou impresso na tela. Exemplos:
 325 
 326 Fazer a soma de 4 + 5:
 327   $ expr 4 + 5 
 328   9
 329 
 330 A média aritmética de 20+15+10:
 331   $ echo $(( (20+15+10) / 3 ))  
 332   15
 333 
 334 Multiplicar 3 por 5:
 335   $ expr 3 * 5
 336   expr: syntax error
 337 
 338   Ué!? O que houve de errado? bom, relembrando o início a shell interpreta 
 339 os  comandos antes de  executa-los, ela  entendeu o  ASTERISCO como usamos
 340 anteriormente  significando  QUALQUER COISA,  só  que isso  numa  operação
 341 matemática  não  faz  sentido.  O que fazer então?  temos  que proteger  o
 342 asterisco  da  shell pra  dar prioridade ao operador e não a interpretação 
 343 que a shell faz do asterisco normal.
 344 
 345   Novamente, protegendo o asterisco, multiplicando 3 por 5:
 346   $ expr 3 \* 5
 347   15
 348 
 349   Há  também outra forma de fazermos cálculos, usando a cálculadora padrão 
 350 do GNU a bc.  Como vimos, usando o PIPE podemos jogar uma informação no 2°
 351 argumento de um comando:
 352 
 353 $ echo "(4 * 27) + 21" | bc
 354 129
 355 
 356   Usamos às aspas para proteger o parenteses da shell e jogamos a operação
 357 na calculadora bc que nos retorna o resultado rapidamente.
 358 
 359 
 360 
 361 2.3 Tipos de parâmetros.
 362 
 363   O  uso de parametros é quase  constante  em uma linha de comando de uma
 364 pessoa  que esteja acostumada à shell,  eles tornam  tudo mais fácil e as
 365 vezes se fazem extremamente necessários.
 366 
 367 o> parametro de substituição de comando
 368 
 369    para a shell saber onde executar os comandos é necessário uma forma de
 370   procura por programas para executar no sistema, a variável $PATH indica 
 371   onde  o  usuário  em  questão verá os diretorios separados por  ':'  do 
 372   sistema aos quais ele obterá acesso à comandos.
 373 
 374    podemos utilizar um parametro para executar comandos na  shell fazendo 
 375   com que seu output saia na tela ou seja  armazenado em alguma variável,
 376   a  shell bash  vai entender o que estiver  entre os parenteses  como um
 377   comando de algum diretório do $PATH. 
 378   
 379 
 380   SINTAXE
 381   
 382     $(COMANDO)  => Abre uma subshell e executa o comando retornando a
 383                    shell pai e saindo da subshell. 
 384 
 385   ou 
 386     
 387     `comando`   => Executa um comando normal do sistema.
 388 
 389 
 390   $ echo -e "todays fortune:\n $(fortune)"
 391   todays fortune:
 392     "All flesh is grass"
 393     -- Isiah
 394     Smoke a friend today.
 395 
 396   $ SYSTEM=`uname -s`
 397   $ echo "Sistema: $SYSTEM"
 398   Sistema: Linux
 399 
 400    voce pediu pra  a  shell imprimir uma frase, seguida  de  um  comando 
 401   'fortune'  que faz parte  de  um  pacote  chamado  bsdgames, ele é bem
 402   interessante,  é  composto  de  milhares  de  frases e  pensamentos de
 403   filósofos,  autores de livros, etc.  já no segundo  exemplo usamos uma
 404   variável SYSTEM para armazenar o retorno do comando  'uname -s' depois
 405   imprimimos na tela.
 406                     
 407 
 408 o> parametros com chaves
 409   
 410    as vezes queremos nos referir a um nome de arquivo em vários tipos de
 411   extensão, ou fazer coisas do tipo,  para isso podemos ao  inves de ter 
 412   que escrever toda a linha de comando repetidamente usamos as chaves.
 413 
 414   $ echo m{a,e,o}ngo          ou         $ ls *.{bz2,txt}
 415   mango mengo mongo                      IAO-paper.txt focalinux.txt
 416                                          gcc-3.3.tar.bz2 retlib.txt
 417 
 418    evitamos ter que  fazer repetições  na linha de comando  colocando as
 419   sequencias necessarias entre chaves.
 420 
 421 
 422 o> outros parametros
 423 
 424    podemos trocar strings de um parametro,  declaramos  ele desta forma:
 425   ${PARAMETRO/STRING/NEWSTRING} ,  onde  STRING é a ocorrência  que você
 426   deseja modificar e o NEWSTRING é a nova string que vai ficar.
 427 
 428    $ STR="estou aprendendo a errar"
 429    $ echo ${STR/errar/viver}
 430    estou aprendendo a viver
 431 
 432    ou se quisessemos ver o tamanho de caracteres de uma string, fariamos
 433   assim ${#STRING}, onde STRING seria a variavel ou palavra/frase.
 434   
 435    $ echo $STR
 436    estou aprendendo a errar
 437    $ echo ${#STR}
 438    24
 439    
 440    para  pegarmos  um  argumento  da  linha de comando usamos o carácter
 441   dólar seguido da ordem do seu argumento, exemplo:
 442 
 443   $ ./comando arg1 arg2 arg3
 444     $1 ==> arg1
 445     $2 ==> arg2
 446     $3 ==> arg2
 447 
 448 
 449 3. Variáveis.
 450 
 451   Uma coisa muito útil na  shell  é a possibilidade  de armazenamento de
 452 dados na memória,  fazendo isso podemos  atribuir à variaveis  saídas de
 453 comandos,  calculos aritméticos e  strings.  Para setar  uma variável na
 454 shell basta fazer:
 455 
 456   $ A=1
 457   $ B=HELLO
 458   $ C="HELLO WORLD"
 459 
 460   $ echo $A $B $C
 461   1 HELLO HELLO WORLD
 462 
 463   Veja que dessa vez não usamos o DÓLAR para setar a variável A,B,C esse
 464 dólar só vai ser  colocado  quando quisermos que a shell retorne o valor 
 465 da variável.  Para remover a variável do sistema é só fazer:
 466   
 467   $ unset C
 468   $ echo $C
 469 
 470 
 471 3.1 Variáveis ambiente.
 472   
 473   Há uma série de variáveis padrões definidas  pela SHELL quando você se 
 474 loga nela,  estas servem para organizar de forma mais eficiente tudo que 
 475 o usuário tem acesso, pode fazer e quer saber. Vamos ver algumas delas:
 476 
 477 $HOME    => Indica o diretório raiz do usuário que esta logado na shell.
 478 $PATH    => Diretórios aos quais o usuário tem acesso à comandos.
 479 $PWD     => Diretório onde o usuário se encontra.
 480 $USER    => Usuário logado na shell.
 481 
 482   Para vermos todas elas usamos o comando 'export' que serve também para
 483 setar as variáveis ambiente na shell. Para ver todas:
 484 
 485   $ export 
 486   .........................
 487 
 488 Para setar:
 489 
 490   $ export VAR="Conteúdo"
 491   $ echo $VAR
 492   Conteúdo
 493   
 494 
 495 3.2 Atribuindo comandos à variáveis.
 496 
 497   Podemos  utilizar as variáveis também para armazenar  saída de comandos
 498 do sistema, para isso colocamos o comando entre crases, vejamos exemplos:
 499 
 500   $ cd txtz/y0/
 501   $ pwd
 502   /home/alexandre/txtz/y0
 503   $ var=`ls`
 504   $ echo $var
 505   bash.txt file.txt plantz.txt provas.txt slides.txt userfile.txt
 506 
 507   Entramos no diretório e setamos uma variável 'var' com o valor da saída
 508 do comano 'ls', depois imprimimos o valor com o comando echo.
 509 
 510   $ proc=`cat /proc/cpuinfo | grep "model name" | cut -d" " -f4-10`
 511   $ echo "PROCESSADOR: $proc"
 512   PROCESSADOR: Athlon(tm) XP 1700+
 513 
 514 
 515 
 516 4. Estrutura de loops e condições.
 517 
 518   Podemos elaborar processos repetidas vezes de acordo com a condição que
 519 desejarmos, usando as estruturas de loop e condições começamos a falar de
 520 shell script que nada mais é do que uma forma estruturada de organizar os
 521 comandos do sistema utilizando tudo que aprendemos em conjunto(variáveis,
 522 comandos, retornos de comandos, etc).
 523   Há diferença entre  eles é que os loops executam uma certa sequencia de
 524 comandos  digitados  pelo  programador até que  aconteça  algo  que  será
 525 processado e  de  acordo  com o  tipo de  loop,  terminado ou continuado,
 526 enquanto as condições esperam que o programa  receba algo e de acordo com
 527 um teste que foi previsto pelo programador anteriormente execute um bloco
 528 de códigos ou não.
 529   Para  setar  um  arquivo  como  shell script deve-se  coloca-lo com uma
 530 permissão de execução, fazendo:
 531  
 532   $ chmod +x arquivo
 533   $ ./arquivo
 534 
 535   Tendo em vista isto, temos também que entender que no shell script os
 536 operadores para condições matemáticas tambem mudam, exemplo:
 537 
 538 | OPERADOR | SIGNIFICADO                                 |
 539 +----------+---------------------------------------------+
 540 |   -lt    | less than (menor que).                      |
 541 |   -le    | less or equal than (menor ou igual que).    |
 542 |   -gt    | greater than (maior que).                   |
 543 |   -ge    | greater or equal than (maior ou igual que). |
 544 |   -eq    | equal than (igual que).                     |
 545 |   -ne    | not equal (diferente de).                   |
 546 +----------+---------------------------------------------+
 547  
 548   Também é  bom lembrar  que  num arquivo shell script,  a primeira linha
 549 deverá sempre ser a declaração da shell em que estamos programando:
 550 
 551   #!/bin/bash
 552 
 553 
 554 4.1 Usando loops.
 555 
 556   Os loops  servem entre  outras coisas para executar um bloco de códigos
 557 até que um teste seja atingido, vejamos alguns tipos de loop:
 558 
 559   o> until
 560 
 561     SINTAXE
 562       
 563       until [ 'TESTE' ] ; do
 564         CÓDIGO....
 565       done
 566   
 567     O comando until serve para executar um laço até o seu  TESTE  retorne
 568   um valor diferente diferente de 0 (ou seja, até que o teste seja falso)
 569   
 570   #!/bin/bash
 571   IN=10
 572 
 573   until [ $IN -lt 4 ] ; do
 574     echo "LOOP: $IN"
 575     IN=`expr $IN - 2`
 576   done
 577   
 578   $ ./until   
 579   LOOP REVERSO: 10
 580   LOOP REVERSO: 8
 581   LOOP REVERSO: 6
 582   LOOP REVERSO: 4
 583       
 584 
 585   o> while
 586 
 587     SINTAXE
 588 
 589       while [ 'TESTE' ] ; do
 590         CÓDIGO...
 591       done
 592        
 593      Fazendo o inverso do until, o comando while executa o CÓDIGO até que
 594    o retorno de seu TESTE seja igual a 0 (ou seja verdadeiro), exemplo:
 595   
 596    #!/bin/bash
 597    IN=0
 598 
 599    while [ $IN -lt 4 ] ; do
 600      echo "LOOP: $IN"
 601      IN=`expr $IN + 1`
 602    done
 603   
 604    $ ./while
 605    LOOP: 0
 606    LOOP: 1
 607    LOOP: 2
 608    LOOP: 3
 609 
 610 
 611   o> for
 612 
 613     SINTAXE
 614 
 615       for (( expr1 ; expr2; expr3 )) ; do
 616         CÓDIGO...   
 617       done
 618 
 619      Onde temos o primeiro modo de utilizar o for na shell, o expr1 é um
 620    valor que será  atribuido à uma variável, o expr2 é um teste que será
 621    feito até que seu resultado seja verdadeiro, fazendo com que  o bloco
 622    de código seja executado repitidamente e expr3 será o que  será feito
 623    quando o teste for  verdadeiro,  poucos usam o for desta forma embora
 624    na minha opnião seja mais eficiente. Por exemplo:
 625  
 626    #!/bin/bash
 627    for (( i=0 ; i<5 ; i++ )); do
 628      echo "loop: $i"
 629    done
 630   
 631    $ ./for
 632    loop: 0
 633    loop: 1
 634    loop: 2
 635    loop: 3
 636    loop: 4
 637   
 638   
 639        
 640 4.2 Fazendo condições.
 641 
 642   É necessário fazer condições quando  recebemos  algo da entrada de um
 643 usuário e queremos realizar um TESTE com esses dados para ver qual rumo
 644 o programa deve tomar.  Vamos usar dois tipos de  comandos básicos para
 645 execução de condições, são eles:
 646 
 647   o> if-then-else
 648   
 649     SINTAXE
 650     
 651     if [ 'TESTE' ] ; then
 652       CÓDIGO...
 653     fi
 654 
 655       Executa o TESTE, se ele for verdadeiro executa o bloco de CÓDIGO
 656     senão sai sem executar nada dentro do if.
 657       
 658 
 659     if [ 'TESTE' ] ; then
 660       CÓDIGO...
 661     elif [ 'TESTEDOIS' ] ; then
 662       CÓDIGO DOIS...
 663     fi
 664 
 665       Executa o TESTE, aciona o bloco de CÓDIGO se o resultado do teste
 666     for verdadeiro.. depois executa o TESTEDOIS e se for verdadeiro ele
 667     executa o bloco de CÓDIGO DOIS.
 668     
 669 
 670     if [ 'TESTE' ] ; then
 671       CÓDIGO...
 672     else 
 673       CÓDIGO DOIS...
 674     then
 675 
 676       Aqui ele executa o TESTE, entra no bloco de CÓDIGO se o resultado
 677     do teste for verdadeiro, senão ele entre no bloco de CÓDIGO DOIS.
 678 
 679 
 680     #!/bin/bash
 681     IN=$1
 682 
 683     if [ "$1" == "Mulher" ] ; then
 684       echo "Olá senhorita :)~"
 685     elif [ "$1" == "Homem" ] ; then
 686       echo "Como vai meu bom homem?"
 687     else
 688       echo "Escolha sua opção sexual rapaz!"
 689     fi
 690 
 691     $ ./ifthenelse
 692     Escolha sua opção sexual rapaz!
 693     $ ./ifthenelse Homem
 694     Como vai meu bom homem?
 695     $ ./ifthenelse Mulher
 696     Ola senhorita :)~
 697     
 698               
 699 
 700   o> case
 701     
 702     SINTAXE
 703     
 704     case ARG in
 705       PS1) 
 706         CÓDIGO
 707         ;;
 708       
 709       PS2)
 710         CÓDIGO DOIS
 711         ;;
 712     esac
 713 
 714       Aqui  o  teste  ocorre  em  cima  de  ARG,  o case explode várias
 715     possíveis alternativas que podem ser PS1,  PS2,  PS3, ..., PSN. Uma
 716     boa função  do  case  é  poder  fazer  essas  possibilidades usando 
 717     meta-caracteres.
 718 
 719     #!/bin/bash
 720     IN=$1
 721 
 722     case $IN in
 723       [a-c])
 724         echo "Tu és homem!"
 725         ;;
 726       [d-f])
 727         echo "Tu és mulher!"
 728         ;;
 729       [0-9])
 730         echo "Tá confuso?"
 731         ;;
 732     esac
 733 
 734     $ ./case b
 735     Tu és homem!
 736     $ ./case 3
 737     Tá confuso?
 738 
 739                                   
 740 
 741 5. Avançando.
 742 
 743   Nesta   parte  vamos  começar  a  complicar  mais  um  pouquinho  pra
 744 descomplicar  bem muito, hã? é isso mesmo, aqui  vamos  mostrar  alguns
 745 comandos que a  maioria nem  chega perto  mas que são úteis demais para
 746 um shell scripter.
 747 
 748 
 749 5.1 Redirecionando entrada/saída de dados.
 750 
 751  Podemos direcionar como os dados irão entrar e como irão sair em nossa
 752 shell usando operadores, para começarmos a fazer isso devemos lembrar
 753 os 3 tipos padrões de entrada/saída de dados, são eles:
 754 
 755  (0 ou STDIN) => Standard Input (Entrada Padrão).
 756 (1 ou STDOUT) => Standard Output (Saída Padrão).
 757 (2 ou STDERR) => Standard Error (Saída de erro padrão).
 758 
 759  Tendo em mente isso, usamos operadores para o redirecionamento que são
 760 parecidos com os símbolos da matemática:
 761 
 762 | OP | SIGNIFICADO                                                    |
 763 +----+----------------------------------------------------------------+
 764 | N> |  Onde N, é o valor da saída de dados (1 ou 2), fazendo com que |
 765 |    | o redirecionamento da saída seja feito há direita do operador. |
 766 |  > |  Envia os dados para arquivo, criando-o caso não existe ou     |
 767 |    | apagando seu conteúdo anterior e adcionando novo, caso exista. |
 768 | >> |  Aqui há o redirecionamento de dados para o FINAL do arquivo   |
 769 |    | caso exista, ou uma criação de arquivo, caso não exista.       |
 770 | <  |  Setamos na shell que a entrada padrão não irá vir do teclado  |
 771 |    | e sim do arquivo em questão.                                   |
 772 | << |  Indicamos um LABEL para o começo de uma linha fazendo com que |
 773 |    | a linha só termine quando houver a proxima ocorrência do LABEL |
 774 +----+----------------------------------------------------------------+
 775 
 776 $ echo "Ohh! voce me leu :~" > file.txt
 777 $ cat file.txt
 778 Ohh! voce me leu :~
 779 
 780 $ echo "Que trágico!" >> file.txt
 781 $ cat file.txt
 782 Ohh! voce me leu :~
 783 Que trágico!
 784 
 785 $ tr e i < file.txt 
 786 Ohh! voci mi liu :~
 787 Qui trágico!
 788 
 789 $ mount /dev/cdrom /mnt/cdrom 2> error.txt
 790 $ cat error.txt 
 791 mount: only root can do that
 792 
 793 
 794 5.2 Usando comandos em background e adcionando interrupções
 795 
 796   Podemos rodar comandos em modo background., que significaria mais ou
 797 menos que executamos um comando  deixando-o numa file de espera, então
 798 ele  em alguns  programas  que  precisam  de  entrada  de dados só irá 
 799 executar suas funções quando agente o chamar no sistema.
 800 
 801 $ vim file.txt &
 802 [1] 22956
 803  Î   Î 
 804  `---|-------- 1 = First Job (Primeiro trabalho.)
 805      '--- 22956 = PID (Process ID).
 806 
 807 
 808   Vêmos que ele carregou o programa  numa subshell, mas não executou a
 809 sua função que era de editar o arquivo,  para fazermos isso, digitamos
 810 
 811 $ fg 1
 812 
 813   E então o ID do processo em background sairá da subshell e virá para
 814 nossa shell principal, podemos fazer isso várias vezes.
 815 
 816   Outra  coisa  muito  útil  é que podemos  adcionar  interrupções  ou
 817 simplesmente modifica-las de acordo com o nosso interesse, para agente
 818 começar a mecher nos sinais devemos é claro, entendê-los:
 819 
 820 0  => Saída normal do programa.
 821 1  => Sinal de quando se recebe um kill -HUP
 822 2  => Interrupção forçada pelo teclado CTRL+C.
 823 15 => Sinal de interrupção de programa quando se é kilado. (kill PID).
 824 
 825   Isso é muito útil quando fazemos um  programa e queremos ter certeza
 826 que o usuário não fará a besteira de  termina-lo  usando  CTRL+C ou se 
 827 fizer nós termos como ajeitar sua trapalhada, por exemplo:
 828 
 829 $ trap "echo THE POWER OF TRAP" 2
 830 
 831 
 832 5.3 Alguns comandos: sed, cut, wc, od.
 833 
 834   Aqui vamos ver alguns comandos que são  muito úteis quando  se esta 
 835 trabalhando  com arquivos,  é importante  domina-los  para  uma maior
 836 velocidade e eficiência.
 837 
 838   o> sed
 839 
 840     SINTAXE
 841 
 842       sed <OPCAO> <EXPRESSÃO> <ARQUIVO>
 843 
 844     EXPRESSÂO
 845      
 846       SUBSTITUIÇÃO
 847 
 848       sed 's/FRASE/NOVA/' <ARQUIVO>
 849 
 850         Usando sed podemos substituir FRASE(strings, números, frases)
 851       por uma NOVA palavra ou frase, vejamos um exemplo simples:
 852       
 853       $ cat file.txt
 854       batatinha quando nasce, esparrama pelo chão.
 855       $ sed 's/esparrama/cai/' file.txt
 856       batatinha quando nasce, cai pelo chão.i
 857 
 858     EXPRESSÃO
 859 
 860       EXCLUIR
 861 
 862       sed 'X,Yd' <ARQUIVO>
 863 
 864         Não imprime linhas de X à Y.
 865 
 866       sed '/PALAVRA/d' <ARQUIVO>
 867 
 868         Não imprime linhas que contém PALAVRA.
 869 
 870         $ cat file.txt
 871         Linux comanda o mundo.
 872         Windows comanda o mundo.
 873         Freebsd comanda o mundo.
 874         
 875         $ sed '2,3d' file.txt
 876         Linux comanda o mundo.
 877 
 878         $ sed '/Windows/d' file.txt
 879         Linux comanda o mundo.
 880         Freebsd comanda o mundo.
 881 
 882      EXPRESSÃO
 883 
 884        NEGAR
 885 
 886        sed -n .... <ARQUIVO>
 887 
 888        $ sed -n '/Windows/!p'
 889        Linux comanda o mundo.
 890        Freebsd comanda o mundo.
 891        
 892 
 893   o> cut
 894 
 895     Serve para separar de acordo  com o seu DELIMITADOR as palavras e
 896   imprimir apenas o que é pedido. 
 897 
 898     SINTAXE
 899 
 900       cut <OPTION> <ARQUIVO>
 901 
 902     OPÇÕES
 903 
 904       -d  => Usado para definir qual vai ser o delimitador.
 905       -fN => De acordo com o delimitador, a Nª palavra.
 906 
 907   $ cat /etc/passwd | cut -d":" -f1
 908   root
 909   bin
 910   daemon
 911   adm
 912   lp
 913   sync
 914   .......
 915   
 916     
 917   o> wc
 918     
 919     Este comando serve para imprimir a quantidade de bytes, palavras
 920   e linhas de um arquivo, é geralmente usado depois de um PIPE.
 921 
 922     SINTAXE 
 923     
 924       wc <OPCOES> <ARQUIVO>
 925 
 926     OPÇÕES
 927 
 928       -l  => quantidade de linhas
 929       -w  => quantidade de palavras
 930       -c  => quantidade de bytes (caracteres).
 931 
 932   $ wc -l file.txt
 933         2 file.txt
 934   $ wc -c file.txt
 935        34 file.txt
 936   
 937   
 938   o> od
 939     
 940     O comando od  serve  para imprimir  um arquivo de  acordo com uma
 941   especificação dada pelo usuário,  podemos imprimir um arquivo texto
 942   com suas letras em formato hexadecimal, octal, etc.
 943 
 944     SINTAXE 
 945 
 946       od <OPCOES> <ARQUIVO>
 947 
 948     OPÇÕES
 949     
 950       -h  => imprime letras e números em hexadecimal.
 951       -o  => imprime letras e números em octal.
 952   
 953   $ od -h file.txt
 954   0000000 684f 2168 7620 636f 2065 656d 6c20 7565
 955   0000020 3a20 0a7e 7551 2065 7274 67e1 6369 5c6f
 956   0000040 0a21
 957   0000042
 958   
 959   
 960 
 961 5.4 Cores no terminal.
 962 
 963   Podemos  sim  adcionar  cores  para dar ênfase  a  alguma frase  ou 
 964 enfeitar nossos programas shell,  usamos então uma definição especial 
 965 para isso, um caracter  ESC seguido de  uma [ mais códigos de cores e 
 966 terminando por uma barra  invertida seguida de um m,  ']m', vejamos a 
 967 lista de códigos para suas cores:
 968 
 969 | TEXTO | FUNDO | COR               |   | CÓDIGO | SIGNIFICADO   |
 970 +-------+-------+-------------------+   +--------+---------------+
 971 |   30  |   40  | Preto (cinza).    |   |   0    | Desliga tudo. |
 972 |   31  |   41  | Vermelho.         |   |   1    | Negrito.      |
 973 |   32  |   42  | Verde.            |   |   5    | Pisca pisca.  |
 974 |   33  |   43  | Marrom (amarelo). |   |   7    | Reverso.      |
 975 |   34  |   44  | Azul.             |   +--------+---------------+
 976 |   35  |   45  | Roxo.             |
 977 |   36  |   46  | Ciano.            |   *OBS: ESC == \033 (Octal)
 978 |   37  |   47  | Cinza (branco).   |
 979 +-------+-------+-------------------+
 980 
 981 $ echo -e "\033[40;31;1mSPORT RECIFE\033[m"
 982 $ echo -e "\033[45;33;1mCOLORIDO GAY\033[m"
 983 
 984 
 985 6. Arquivos de configuração.
 986 
 987   Estes arquivos servem para quando iniciarmos a shell, carregarmos  ou
 988 executarmos váriaveis/programas, mudarmos o prompt, adcionarmos aliases
 989 e várias outras opções.
 990 
 991   o> .bashrc
 992     
 993     Este arquivo é executado assim que logamos na shell, podemos então
 994   utiliza-lo para setar o prompt, adcionar aliases padrões, etc.
 995     
 996   o> .bash_history
 997 
 998     Este é o arquivo onde ficama a história dos processados pela shell
 999   no sistema, ele fica no diretório $HOME do usuário.