Canivete Suíço do Shell (bash)

%%infile(%d)

%%%             A G R A D E C I M E N T O S
%%%             ___________________________
%
% 11jul2003 Andreyev Dia de Melo (man 7 signal)
% 16jul2003 Moysés Placin (pediu comandos prontos p/copiar&colar)
% 17jul2003 Luciano Espírito Santo (glob de lista negada [^...])
% 18jul2003 Mateus Caruccio (3<>arq)
% 05ago2003 Julio Cezar Neves (sinais do linux, não cygwin)
% 09out2003 Fagner Goncalves (atalhos set -o emacs)
% 28out2003 Rodolfo Villanova (letras do 'ls')
% 04nov2003 Rodolfo Villanova (comando test: -b, -c, -g, -k, -u)
% 21out2004 adicionadas âncoras com nome para cada seção
% 04nov2004 Diego Búrigo Zacarão (sinais cygwin), gwm (sinais freebsd)
% 04nov2004 sinais++, --css-sugar, Rodrigo Carvalhaes (elif)
% 11nov2004 escapes do PS1 (tirado da Dicas-L 2004-11-09)
% 18nov2005 Rodrigo Monteiro (while ... < <(comando), faltava um <
% 18nov2005 tópicos numerados, títulos sem borda inferior
% 01nov2006 Usando formato padrão do aurelio.net (tema Genius)
% 06dez2006 PDF por 5ão
% 01jan2007 Caractere 183 arrumado na tabela ASCII
% 21mar2008 exitcode: removido * do 255*
% 21mar2008 date: %y dois dígitos, %Y quatro dígitos
% 21mar2008 Blocos: `...` retornando o resultado, $ do $'abc\n'
% 21mar2008 s/Mnemônico/Lembrete/, ASCII (ISO-8859-1), iniciais em maiúsculas
% 27mar2008 Tabela if/for/while/case arrumada, elif/then arrumado
% 25abr2008 UTF-8, tema kiwi, todas tabelas com borda, setas Unicode no emacs

%___________________________________________________________________________
%
%TODO exemplos de sed e find (Raimundo Fernando de Carvalho Bahia)
%TODO zzascii (botar os octais/hexa tb)
%TODO getopts
%TODO char 183 ASCII (imagem) está errada


%!includeconf: ../include/kiwi/config.t2t
%!postproc: SITEROOT ..
%!postproc: (<BODY)	\1 class="canivete"

%!options: --toc --toc-level 2 --enum-title

% Remove 0. da numeração de títulos (bug txt2tags)
%!postproc: '>0\.'	'>'

% link dentro do PRE
%!postproc: zzascii '<a href="http://funcoeszz.net">zzascii</a>'

% NOVO!
%%!postproc: '(<LI>.*Prompt \(PS1\)</A>)' '\1 <b>[NOVO!]</b>'
%%!postproc: "(<LI>.*Killall</A>)" '\1 <b>[MELHORADO!]</b>'

% PDF
%%!postproc: 'middle(" SRC="[^"]*pdf-canivete-icon.jpg)'	'right\1'

% Diminui tamanho do mkt livro shell pra caber o sidebar
%!postproc: 'margin:3em auto'	'margin:3em 150px 3em 1em'

% Livro Shell
%!include: apostila/mkt-livro-shell.t2t

%!include: ''../include/kiwi/ads-sky160.html''


%%TOC

Quer imprimir o Canivete Suíço do Shell? [Use a versão em PDF canivete-pdf.html].
 | [[../img/pdf-canivete-icon.jpg] canivete-pdf.html]


%%!include: ''../include/google-ads-faixa.html''


== Operadores ==[operadores]

 ||  Operadores Aritméticos                           ||  Operadores Relacionais ||
 |   ``+``   | Adição                                  |  ``==``   | Igual
 |   ``-``   | Subtração                               |  ``!=``   | Diferente
 |   ``*``   | Multiplicação                           |  ``>``    | Maior
 |   ``/``   | Divisão                                 |  ``>=``   | Maior ou Igual
 |   ``%``   | Módulo                                  |  ``<``    | Menor
 |  ``**``   | Exponenciação                           |  ``<=``   | Menor ou Igual
 ||  Operadores de Atribuição                         ||  Operadores de BIT ||
 |   ``=``   | Atribui valor a uma variável            |  ``<<``   | Deslocamento à esquerda
 |  ``+=``   | Incrementa a variável por uma constante |  ``>>``   | Deslocamento à direita
 |  ``-=``   | Decrementa a variável por uma constante |   ``&``   | E de bit (AND)
 |  ``*=``   | Multiplica a variável por uma constante |   ``|``   | OU de bit (OR)
 |  ``/=``   | Divide a variável por uma constante     |   ``^``   | OU exclusivo de bit (XOR)
 |  ``%=``   | Resto da divisão por uma constante      |   ``~``   | Negação de bit
 |  ``++``   | Incrementa em 1 o valor da variável     |   ``!``   | NÃO de bit (NOT)
 |  ``--``   | Decrementa em 1 o valor da variável     |                                 ||
 || Operadores Lógicos                                ||  Operadores de BIT (atribuição) ||
 |  ``&&``   | E lógico (AND)                          |  ``<<=``  | Deslocamento à esquerda
 |  ``||``   | OU lógico (OR)                          |  ``>>=``  | Deslocamento à direita
 |                                                    ||  ``&=``   | E de bit
 |                                                    ||  ``|=``   | OU de bit
 |                                                    ||  ``^=``   | OU exclusivo de bit

== Redirecionamento ==[redir]

 ||   Operador   | Ação |
 |   ``<``       | Redireciona a entrada padrão (STDIN)
 |   ``>``       | Redireciona a saída padrão (STDOUT)
 |  ``2>``       | Redireciona a saída de erro (STDERR)
 |   ``>>``      | Redireciona a saída padrão, anexando
 |  ``2>>``      | Redireciona a saída de erro, anexando
 |   ``|``       | Conecta a saída padrão com a entrada padrão de outro comando
 |  ``2>&1``     | Conecta a saída de erro na saída padrão
 |   ``>&2``     | Conecta a saída padrão na saída de erro
 |   ``>&-``     | Fecha a saída padrão
 |  ``2>&-``     | Fecha a saída de erro
 |  ``3<>arq``   | Conecta o descritor de arquivos 3 ao arquivo 'arq'
 |  ``<<FIM``    | Alimenta a entrada padrão (Here Document)
 |  ``<<-FIM``   | Alimenta a entrada padrão, cortando TABs
 |  ``<(cmd)``   | A saída do comando 'cmd' é um arquivo: diff <(cmd1) <(cmd2)
 |  ``>(cmd)``   | A entrada do comando 'cmd' é um arquivo: tar cf >(bzip2 -c >file.tbz) $dir

== Variáveis especiais ==[variaveis]

 ||   Variável   | Parâmetros Posicionais |
 |    ``$0``     | Parâmetro número 0 (nome do comando ou função)
 |    ``$1``     | Parâmetro número 1 (da linha de comando ou função)
 |    ``...``    | Parâmetro número N ...
 |    ``$9``     | Parâmetro número 9 (da linha de comando ou função)
 |   ``${10}``   | Parâmetro número 10 (da linha de comando ou função)
 |    ``...``    | Parâmetro número NN ...
 |    ``$#``     | Número total de parâmetros da linha de comando ou função
 |    ``$*``     | Todos os parâmetros, como uma string única
 |    ``$@``     | Todos os parâmetros, como várias strings protegidas
 ||   Variável   | Miscelânia
 |    ``$$``     | Número PID do processo atual (do próprio script)
 |    ``$!``     | Número PID do último job em segundo plano
 |    ``$_``     | Último argumento do último comando executado
 |    ``$?``     | Código de retorno do último comando executado

== Expansão de variáveis ==[expansao]

 || Sintaxe               | Expansão Condicional |
 | ``${var:-texto}``      | Se var não está definida, retorna 'texto'
 | ``${var:=texto}``      | Se var não está definida, defina-a com 'texto'
 | ``${var:?texto}``      | Se var não está definida, retorna o erro 'texto'
 | ``${var:+texto}``      | Se var está definida, retorna 'texto', senão retorna o vazio
 || Sintaxe               | Expansão de Strings
 | ``${var}``             | É o mesmo que $var, porém não ambíguo
 | ``${#var}``            | Retorna o tamanho da string
 | ``${!var}``            | Executa o conteúdo de $var (igual 'eval \$$var')
 | ``${!texto*}``         | Retorna os nomes de variáveis começadas por 'texto'
 | ``${var:N}``           | Retorna o texto à partir da posição 'N'
 | ``${var:N:tam}``       | Retorna 'tam' caracteres à partir da posição 'N'
 | ``${var#texto}``       | Corta 'texto' do início da string
 | ``${var##texto}``      | Corta 'texto' do início da string (* guloso)
 | ``${var%texto}``       | Corta 'texto' do final da string
 | ``${var%%texto}``      | Corta 'texto' do final da string (* guloso)
 | ``${var/texto/novo}``  | Substitui 'texto' por 'novo', uma vez
 | ``${var//texto/novo}`` | Substitui 'texto' por 'novo', sempre
 | ``${var/#texto/novo}`` | Se a string começar com 'texto', substitui 'texto' por 'novo'
 | ``${var/%texto/novo}`` | Se a string terminar com 'texto', substitui 'texto' por 'novo'

== Blocos e agrupamentos ==[blocos]

 ||    Sintaxe    | Descrição                                                         |  Exemplo  |
 |    ``"..."``   | Protege uma string, mas reconhece $, \ e ` como especiais         |  "abc" 
 |    ``'...'``   | Protege uma string completamente (nenhum caractere é especial)    |  'abc' 
 |   ``$'...'``   | Protege uma string completamente, mas interpreta \n, \t, \a, etc  |  $'abc\n' 
 |    ```...```   | Executa comandos numa subshell, retornando o resultado            |  `ls` 
 |    ``{...}``   | Agrupa comandos em um bloco                                       |  { ls ; } 
 |    ``(...)``   | Executa comandos numa subshell                                    |  ( ls ) 
 |   ``$(...)``   | Executa comandos numa subshell, retornando o resultado            |  $( ls ) 
 |   ``((...))``  | Testa uma operação aritmética, retornando 0 ou 1                  |  ((5 > 3)) 
 |  ``$((...))``  | Retorna o resultado de uma operação aritmética                    |  $((5+3)) 
 |    ``[...]``   | Testa uma expressão, retornando 0 ou 1 (alias do comando 'test')  |  [ 5 -gt 3 ] 
 |   ``[[...]]``  | Testa uma expressão, retornando 0 ou 1 (podendo usar && e ||)     |  [[ 5 > 3 ]] 


== if, for, select, while, until, case ==[ifwhilefor]

  || if           | for / select      | while / until  | case
  | if COMANDO    | for VAR in LISTA  | while COMANDO  | case $VAR in
  | then          | do                | do             |  txt1) ... ;;
  |  ...          |   ...             |   ...          |  txt2) ... ;;
  | elif COMANDO  | done              | done           |  txtN) ... ;;
  | then          |                   |                |  *) ... ;;
  |  ...          |                   |                | esac
  | else          | ou:               |                |
  |  ...          | for ((exp1;exp2;exp3))            ||
  | fi            |                   |                |


== Opções do comando test ou [ ==[test]

 ||  Testes em arquivos                             ||    Testes em variáveis                   ||
 | ``-b``  | É um dispositivo de bloco               |                                          ||
 | ``-c``  | É um dispositivo de caractere           |  **Comparação Numérica**                 ||
 | ``-d``  | É um diretório                          |  ``-lt``  | É menor que   (LessThan)      |
 | ``-e``  | O arquivo existe                        |  ``-gt``  | É maior que   (GreaterThan)   |
 | ``-f``  | É um arquivo normal                     |  ``-le``  | É menor igual (LessEqual)     |
 | ``-g``  | O bit SGID está ativado                 |  ``-ge``  | É maior igual (GreaterEqual)  |
 | ``-G``  | O grupo do arquivo é o do usuário atual |  ``-eq``  | É igual       (EQual)         |
 | ``-k``  | O sticky-bit está ativado               |  ``-ne``  | É diferente   (NotEqual)      |
 | ``-L``  | O arquivo é um link simbólico           |                                          ||
 | ``-O``  | O dono do arquivo é o usuário atual     |  **Comparação de Strings**               ||
 | ``-p``  | O arquivo é um named pipe               |   ``=``   | É igual                       |
 | ``-r``  | O arquivo tem permissão de leitura      |  ``!=``   | É diferente                   |
 | ``-s``  | O tamanho do arquivo é maior que zero   |  ``-n``   | É não nula                    |
 | ``-S``  | O arquivo é um socket                   |  ``-z``   | É nula                        |
 | ``-t``  | O descritor de arquivos N é um terminal |                                          ||
 | ``-u``  | O bit SUID está ativado                 |  **Operadores Lógicos**                  ||
 | ``-w``  | O arquivo tem permissão de escrita      |   ``!``   | NÃO lógico (NOT)              |
 | ``-x``  | O arquivo tem permissão de execução     |  ``-a``   | E lógico (AND)                |
 | ``-nt`` | O arquivo é mais recente (NewerThan)    |  ``-o``   | OU lógico (OR)                |
 | ``-ot`` | O arquivo é mais antigo (OlderThan)     |                                          ||
 | ``-ef`` | O arquivo é o mesmo (EqualFile)         |                                          ||

== Escapes especiais para usar no prompt (PS1) ==[prompt]

 || Escape | Lembrete        | Expande para... |
 | \a      | //Alerta//      | Alerta (bipe)
 | \d      | //Data//        | Data no formato "Dia-da-semana Mês Dia" (Sat Jan 15)
 | \e      | //Escape//      | Caractere Esc
 | \h      | //Hostname//    | Nome da máquina sem o domínio (dhcp11)
 | \H      | //Hostname//    | Nome completo da máquina (dhcp11.empresa)
 | \j      | //Jobs//        | Número de jobs ativos
 | \l      | //Tty//         | Nome do terminal corrente (ttyp1)
 | \n      | //Newline//     | Linha nova
 | \r      | //Return//      | Retorno de carro
 | \s      | //Shell//       | Nome do shell (basename $0)
 | \t      | //Time//        | Horário no formato 24 horas HH:MM:SS
 | \T      | //Time//        | Horário no formato 12 horas HH:MM:SS
 | \@      | //At//          | Horário no formato 12 horas HH:MM am/pm
 | \A      | //At//          | Horário no formato 24 horas HH:MM
 | \u      | //Usuário//     | Login do usuário corrente
 | \v      | //Versão//      | Versão do Bash (2.00)
 | \V      | //Versão//      | Versão+subversão do Bash (2.00.0)
 | \w      | //Working Dir// | Diretório corrente, caminho completo ($PWD)
 | \W      | //Working Dir// | Diretório corrente, somente o último (basename $PWD)
 | \!      | //Histórico//   | Número do comando corrente no histórico
 | \#      | //Número//      | Número do comando corrente
 | \$      | //ID//          | Mostra "#" se for root, "$" se for usuário normal
 | \nnn    | //Octal//       | Caractere cujo octal é nnn
 | \\      | //Backslash//   | Barra invertida \ literal
 | \[      | //Escapes//     | Inicia uma seqüência de escapes (tipo códigos de cores)
 | \]      | //Escapes//     | Termina uma seqüência de escapes

== Escapes reconhecidos pelo comando echo ==[echo]

  ||  Escape  | Lembrete      | Descrição |
  |    \a     | //Alerta//    | Alerta (bipe)
  |    \b     | //Backspace// | Caractere Backspace
  |    \c     | //EOS//       | Termina a string
  |    \e     | //Escape//    | Caractere Esc
  |    \f     | //Form feed// | Alimentação
  |    \n     | //Newline//   | Linha nova
  |    \r     | //Return//    | Retorno de carro
  |    \t     | //Tab//       | Tabulação horizontal
  |    \v     | //Vtab//      | Tabulação vertical
  |    \\     | //Backslash// | Barra invertida \ literal
  |    \nnn   | //Octal//     | Caractere cujo octal é nnn
  |    \xnn   | //Hexa//      | Caractere cujo hexadecimal é nn

== Formatadores do comando date ==[date]

 ||  Formato    | Descrição |
 |    ``%a``    | Nome do dia da semana abreviado (Dom..Sáb)
 |    ``%A``    | Nome do dia da semana (Domingo..Sábado)
 |    ``%b``    | Nome do mês abreviado (Jan..Dez)
 |    ``%B``    | Nome do mês (Janeiro..Dezembro)
 |    ``%c``    | Data completa (Sat Nov 04 12:02:33 EST 1989)
 |    ``%y``    | Ano (dois dígitos)
 |    ``%Y``    | Ano (quatro dígitos)
 |    ``%m``    | Mês (01..12)
 |    ``%d``    | Dia (01..31)
 |    ``%j``    | Dia do ano (001..366)
 |    ``%H``    | Horas (00..23)
 |    ``%M``    | Minutos (00..59)
 |    ``%S``    | Segundos (00..60)
 |    ``%s``    | Segundos desde 1º de Janeiro de 1970
 |    ``%%``    | Um % literal
 |    ``%t``    | Um TAB
 |    ``%n``    | Uma quebra de linha

== Formatadores do comando printf ==[printf]

 ||  Formato  | Descrição |
 |   ``%d``   | Número decimal
 |   ``%o``   | Número octal
 |   ``%x``   | Número hexadecimal (a-f)
 |   ``%X``   | Número hexadecimal (A-F)
 |   ``%f``   | Número com ponto flutuante
 |   ``%e``   | Número em notação científica (e+1)
 |   ``%E``   | Número em notação científica (E+1)
 |   ``%s``   | String

== Letras identificadoras de arquivos no comando ls -l ==[ls]

  || Letra | Lembrete    | Tipos de Arquivo (primeiro caractere) |
  |    -   |     -       | Arquivo normal
  |    d   |  Directory  | Diretório
  |    l   |    Link     | Link simbólico
  |    b   |   Block     | Dispositivo de blocos (HD)
  |    c   |    Char     | Dispositivo de caracteres (modem serial)
  |    s   |   Socket    | Socket mapeado em arquivo (comunicação de processos)
  |    p   |    Pipe     | FIFO ou Named Pipe (comunicação de processos)
  || Letra | Lembrete    | Permissões do Arquivo (próximos nove caracteres)
  |    -   |     -       | Permissão desativada
  |    r   |    Read     | Acesso de leitura
  |    w   |    Write    | Acesso de escrita
  |    x   |   eXecute   | Acesso de execução (ou acesso ao diretório)
  |    X   |   eXecute   | Acesso ao diretório somente
  |    s   |   Set ID    | Usuário/grupo para execução (SUID, SGID) - permissão 'x' ativada
  |    S   |   Set ID    | Usuário/grupo para execução (SUID, SGID) - permissão 'x' desativada
  |    t   |   sTicky    | Usuários só apagam seus próprios arquivos - permissão 'x' ativada
  |    T   |   sTicky    | Usuários só apagam seus próprios arquivos - permissão 'x' desativada

== Curingas para nomes de arquivo (glob) ==[glob]

   ||   Curinga   | Casa com...                                  | Exemplo |
   |     ``*``    | Qualquer coisa                               | ``*.txt``
   |     ``?``    | Um caractere qualquer                        | ``arquivo-??.zip``
   |   ``[...]``  | Qualquer um dos caracteres listados          | ``[Aa]rquivo.txt``
   |  ``[^...]``  | Qualquer um caractere, exceto os listados    | ``[^A-Z]*.txt``
   |   ``{...}``  | Qualquer um dos textos separados por vírgula | ``arquivo.{txt,html}``

== Curingas para os itens do comando case ==[case]

   ||   Curinga     | Casa com...                                | Exemplo |
   |      ``*``     | Qualquer coisa                             |  ``*.txt) echo ;;``
   |      ``?``     | Um caractere qualquer                      |  ``arquivo-??.zip) echo ;;``
   |    ``[...]``   | Qualquer um dos caracteres listados        |  ``[0-9]) echo ;;``
   |   ``[^...]``   | Qualquer um caractere, exceto os listados  |  ``[^0-9]) echo ;;``
   |   ``...|...``  | Qualquer um dos textos separados por ""|"" |  ``txt|html) echo ;;``

== Sinais para usar com trap/kill/killall ==[sinais]

% kill -l | tr '\t' '\n' | sed 's/)/ |/;s/^/ | /'

 || # | Linux  | Cygwin | SystemV | AIX     | HP-UX  | Solaris | BSD/Mac |
 |  1 | HUP    | HUP    | HUP     | HUP     | HUP    | HUP     | HUP     |
 |  2 | INT    | INT    | INT     | INT     | INT    | INT     | INT     |
 |  3 | QUIT   | QUIT   | QUIT    | QUIT    | QUIT   | QUIT    | QUIT    |
 |  4 | ILL    | ILL    | ILL     | ILL     | ILL    | ILL     | ILL     |
 |  5 | TRAP   | TRAP   | TRAP    | TRAP    | TRAP   | TRAP    | TRAP    |
 |  6 | ABRT   | ABRT   | IOT     | LOST    | ABRT   | ABRT    | ABRT    |
 |  7 | BUS    | EMT    | EMT     | EMT     | EMT    | EMT     | EMT     |
 |  8 | FPE    | FPE    | FPE     | FPE     | FPE    | FPE     | FPE     |
 |  9 | KILL   | KILL   | KILL    | KILL    | KILL   | KILL    | KILL    |
 | 10 | USR1   | BUS    | BUS     | BUS     | BUS    | BUS     | BUS     |
 | 11 | SEGV   | SEGV   | SEGV    | SEGV    | SEGV   | SEGV    | SEGV    |
 | 12 | USR2   | SYS    | SYS     | SYS     | SYS    | SYS     | SYS     |
 || # | Linux  | Cygwin | SystemV | AIX     | HP-UX  | Solaris | BSD/Mac |
 | 13 | PIPE   | PIPE   | PIPE    | PIPE    | PIPE   | PIPE    | PIPE    |
 | 14 | ALRM   | ALRM   | ALRM    | ALRM    | ALRM   | ALRM    | ALRM    |
 | 15 | TERM   | TERM   | TERM    | TERM    | TERM   | TERM    | TERM    |
 | 16 | -      | URG    | USR1    | URG     | USR1   | USR1    | URG     |
 | 17 | CHLD   | STOP   | USR2    | STOP    | USR2   | USR2    | STOP    |
 | 18 | CONT   | TSTP   | CHLD    | TSTP    | CHLD   | CHLD    | TSTP    |
 | 19 | STOP   | CONT   | PWR     | CONT    | PWR    | PWR     | CONT    |
 | 20 | TSTP   | CHLD   | WINCH   | CHLD    | VTALRM | WINCH   | CHLD    |
 | 21 | TTIN   | TTIN   | URG     | TTIN    | PROF   | URG     | TTIN    |
 | 22 | TTOU   | TTOU   | IO      | TTOU    | IO     | IO      | TTOU    |
 | 23 | URG    | IO     | STOP    | IO      | WINCH  | STOP    | IO      |
 | 24 | XCPU   | XCPU   | TSTP    | XCPU    | STOP   | TSTP    | XCPU    |
 || # | Linux  | Cygwin | SystemV | AIX     | HP-UX  | Solaris | BSD/Mac |
 | 25 | XFSZ   | XFSZ   | CONT    | XFSZ    | TSTP   | CONT    | XFSZ    |
 | 26 | VTALRM | VTALRM | TTIN    | -       | CONT   | TTIN    | VTALRM  |
 | 27 | PROF   | PROF   | TTOU    | MSG     | TTIN   | TTOU    | PROF    |
 | 28 | WINCH  | WINCH  | VTALRM  | WINCH   | TTOU   | VTALRM  | WINCH   |
 | 29 | IO     | LOST   | PROF    | PWR     | URG    | PROF    | INFO    |
 | 30 | PWR    | USR1   | XCPU    | USR1    | LOST   | XCPU    | USR1    |
 | 31 | SYS    | USR2   | XFSZ    | USR2    | -      | XFSZ    | USR2    |
 | 32 | -      | -      | -       | PROF    | -      | WAITING | -       |
 | 33 | -      | -      | -       | DANGER  | -      | LWP     | -       |
 | 34 | -      | -      | -       | VTALRM  | -      | FREEZE  | -       |
 | 35 | -      | -      | -       | MIGRATE | -      | THAW    | -       |
 | 36 | -      | -      | -       | PRE     | -      | CANCEL  | -       |
 | 37 | -      | -      | -       | -       | -      | LOST    | -       |

  | Como obter a listagem: trap -l, kill -l ou killall -l
  | Veja também: [man 7 signal http://unixhelp.ed.ac.uk/CGI/man-cgi?signal+7]

== Códigos de retorno de comandos ==[exitcode]

 ||  Código  | Significado                                    | Exemplo |
 |     0     | Nenhum erro, execução terminou OK              | echo
 |     1     | A maioria dos erros comuns na execução         | echo $((1/0))
 |     2     | Erro de uso em algum 'builtin' do Shell        | -
 |   126     | Comando não executável (sem permissão)         | touch a ; ./a
 |   127     | Comando não encontrado ("command not found")   | echooo
 |   128     | O parâmetro para o 'exit' não é um decimal     | exit 1.0
 |   128+n   | 128 + código do sinal que o matou              | kill -9 $PPID #exit 137
 |   130     | O programa interrompido com o Ctrl+C (128 + 2) | -
 |   255     | Parâmetro para o 'exit' não está entre 0 e 255 | exit -1

== Códigos de cores (ANSI) ==[cores]

  || Cor       | Letra | Fundo | ## |  Atributo  | Valor | ## | Exemplos: ESC [ <N>;<N> m |
  | Preto      |  30   |  40   |    | Reset      |   0   |    | ``ESC[m`` texto normal (desliga cores)
  | Vermelho   |  31   |  41   |    | Negrito    |   1   |    | ``ESC[1m`` negrito
  | Verde      |  32   |  42   |    | Sublinhado |   4   |    | ``ESC[33;1m`` amarelo
  | Amarelo    |  33   |  43   |    | Piscando   |   5   |    | ``ESC[44;37m`` fundo azul, letra cinza
  | Azul       |  34   |  44   |    | Reverso    |   7   |    | ``ESC[31;5m`` vermelho piscando
  | Rosa       |  35   |  45   |    |            |       |    | **Na linha de comando:**
  | Ciano      |  36   |  46   |    |            |       |    | ``echo -e '\e[33;1m amarelo \e[m'``
  | Branco     |  37   |  47   |    |            |       |    | ``echo -e '\033[33;1m amarelo \033[m'``

          [zzcores.gif]          

== Os metacaracteres das expressões regulares ==[metacaracteres]

 ||   Meta  | Nome          | Descrição |
  |     .   | Ponto         | Curinga de um caractere
  |    []   | Lista         | Casa qualquer um dos caracteres listados
  |   [^]   | Lista negada  | Casa qualquer caractere, exceto os listados
  |     ?   | Opcional      | A entidade anterior pode aparecer ou não (opcional)
  |     *   | Asterisco     | A entidade anterior pode aparecer em qualquer quantidade
  |     +   | Mais          | A entidade anterior deve aparecer no mínimo uma vez
  |   {,}   | Chaves        | A entidade anterior deve aparecer na quantidade indicada
  |     ^   | Circunflexo   | Casa o começo da linha
  |     $   | Cifrão        | Casa o fim da linha
  |    \b   | Borda         | Limita uma palavra (letras, números e sublinhado)
  |     \   | Escape        | Escapa um meta, tirando seu poder
  |  ""|""  | Ou            | Indica alternativas (usar com o grupo)
  |    ()   | Grupo         | Agrupa partes da expressão, é quantificável e multinível
  |    \1   | Retrovisor    | Recupera o conteúdo do grupo 1
  |    \2   | Retrovisor    | Recupera o conteúdo do grupo 2 (segue até o \9)
  |    .*   | Curinga       | Casa qualquer coisa, é o tudo e o nada
  |    ??   | Opcional NG   | Idem ao opcional comum, mas casa o mínimo possível
  |    *?   | Asterisco NG  | Idem ao asterisco comum, mas casa o mínimo possível
  |    +?   | Mais NG       | Idem ao mais comum, mas casa o mínimo possível
  |   {}?   | Chaves NG     | Idem às chaves comuns, mas casa o mínimo possível

== Metacaracteres que são diferentes nos aplicativos ==[metadif]

 || Programa |  Opc |  Mais  |  Chaves  |  Borda |   Ou   |  Grupo  |
  | awk      |   ?  |    +   |   -      |   -    |  ""|""  |   ()   |
  | ed       |  \?  |   \+   |  \{,\}   |  \b    |   \|    |  \(\)  |
  | egrep    |   ?  |    +   |   {,}    |  \b    |  ""|""  |   ()   |
  | emacs    |   ?  |    +   |   -      |  \b    |   \|    |  \(\)  |
  | expect   |   ?  |    +   |   -      |   -    |  ""|""  |   ()   |
  | find     |   ?  |    +   |   -      |  \b    |   \|    |  \(\)  |
  | gawk     |   ?  |    +   |   {,}    |  \<\>  |  ""|""  |   ()   |
  | grep     |  \?  |   \+   |  \{,\}   |  \b    |   \|    |  \(\)  |
  | mawk     |   ?  |    +   |   -      |   -    |  ""|""  |   ()   |
  | perl     |   ?  |    +   |   {,}    |  \b    |  ""|""  |   ()   |
  | php      |   ?  |    +   |   {,}    |  \b    |  ""|""  |   ()   |
  | python   |   ?  |    +   |   {,}    |  \b    |  ""|""  |   ()   |
  | sed      |  \?  |   \+   |  \{,\}   |  \<\>  |   \|    |  \(\)  |
  | vim      |  \=  |   \+   |  \{,}    |  \<\>  |   \|    |  \(\)  |

== Caracteres ASCII imprimíveis (ISO-8859-1) - texto ==[ascii]

```
      $ zzascii
      32        64  @     96  `    162  ¢    194  Â    226  â
      33  !     65  A     97  a    163  £    195  Ã    227  ã
      34  "     66  B     98  b    164  ¤    196  Ä    228  ä
      35  #     67  C     99  c    165  ¥    197  Å    229  å
      36  $     68  D    100  d    166  ¦    198  Æ    230  æ
      37  %     69  E    101  e    167  §    199  Ç    231  ç
      38  &     70  F    102  f    168  ¨    200  È    232  è
      39  '     71  G    103  g    169  ©    201  É    233  é
      40  (     72  H    104  h    170  ª    202  Ê    234  ê
      41  )     73  I    105  i    171  «    203  Ë    235  ë
      42  *     74  J    106  j    172  ¬    204  Ì    236  ì
      43  +     75  K    107  k    173       205  Í    237  í
      44  ,     76  L    108  l    174  ®    206  Î    238  î
      45  -     77  M    109  m    175  ¯    207  Ï    239  ï
      46  .     78  N    110  n    176  °    208  Ð    240  ð
      47  /     79  O    111  o    177  ±    209  Ñ    241  ñ
      48  0     80  P    112  p    178  ²    210  Ò    242  ò
      49  1     81  Q    113  q    179  ³    211  Ó    243  ó
      50  2     82  R    114  r    180  ´    212  Ô    244  ô
      51  3     83  S    115  s    181  µ    213  Õ    245  õ
      52  4     84  T    116  t    182  ¶    214  Ö    246  ö
      53  5     85  U    117  u    183  ·    215  ×    247  ÷
      54  6     86  V    118  v    184  ¸    216  Ø    248  ø
      55  7     87  W    119  w    185  ¹    217  Ù    249  ù
      56  8     88  X    120  x    186  º    218  Ú    250  ú
      57  9     89  Y    121  y    187  »    219  Û    251  û
      58  :     90  Z    122  z    188  ¼    220  Ü    252  ü
      59  ;     91  [    123  {    189  ½    221  Ý    253  ý
      60  <     92  \    124  |    190  ¾    222  Þ    254  þ
      61  =     93  ]    125  }    191  ¿    223  ß    255  ÿ
      62  >     94  ^    126  ~    192  À    224  à   
      63  ?     95  _    161  ¡    193  Á    225  á   
```

== Caracteres ASCII imprimíveis (ISO-8859-1) - imagem ==[asciiimg]

          [ascii.gif]          
%o tex só aceita .jpg e fica muito pequeno


== Códigos prontos para copiar e colar ==[codigos]

 || Condicionais com o IF
 | ``if [ -f "$arquivo" ]; then echo 'Arquivo encontrado'; fi``
 | ``if [ ! -d "$dir" ]; then echo 'Diretório não encontrado'; fi``
 | ``if [ $i -gt 5 ]; then echo 'Maior que 5'; else echo 'Menor que 5'; fi``
 | ``if [ $i -ge 5 -a $i -le 10 ]; then echo 'Entre 5 e 10, incluindo'; fi``
 | ``if [ $i -eq 5 ]; then echo '=5'; elif [ $i -gt 5 ]; then echo '>5'; else echo '<5'; fi``
 | ``if [ "$USER" = 'root' ]; then echo 'Oi root'; fi``
 | ``if grep -qs 'root' /etc/passwd; then echo 'Usuário encontrado'; fi``
 || Condicionais com o E (&&) e OU (||)
 | ``[ -f "$arquivo" ] && echo 'Arquivo encontrado'``
 | ``[ -d "$dir" ] || echo 'Diretório não encontrado'``
 | ``grep -qs 'root' /etc/passwd && echo 'Usuário encontrado'``
 | ``cd "$dir" && rm "$arquivo" && touch "$arquivo" && echo 'feito!'``
 | ``[ "$1" ] && param=$1 || param='valor padrão'``
 | ``[ "$1" ] && param=${1:-valor padrão}``
 | ``[ "$1" ] || { echo "Uso: $0 parâmetro" ; exit 1 ; }``
 || Adicionar 1 à variável $i
 | ``i=$(expr $i + 1)``
 | ``i=$((i+1))``
 | ``let i=i+1``
 | ``let i+=1``
 | ``let i++``
 || Loop de 1 à 10
 | ``for i in 1 2 3 4 5 6 7 8 9 10; do echo $i; done``
 | ``for i in $(seq 10); do echo $i; done``
 | ``for ((i=1;i<=10;i++)); do echo $i; done``
 | ``i=1 ; while [ $i -le 10 ]; do echo $i ; i=$((i+1)) ; done``
 | ``i=1 ; until [ $i -gt 10 ]; do echo $i ; i=$((i+1)) ; done``
 || Loop nas linhas de um arquivo ou saída de comando
 | ``cat /etc/passwd | while read LINHA; do echo "$LINHA"; done``
 | ``grep 'root' /etc/passwd | while read LINHA; do echo "$LINHA"; done``
 | ``while read LINHA; do echo "$LINHA"; done < /etc/passwd``
 | ``while read LINHA; do echo "$LINHA"; done < <(grep 'root' /etc/passwd)``
 || Curingas nos itens do comando case
 | ``case "$dir" in /home/*) echo 'dir dentro do /home';; esac``
 | ``case "$user" in root|joao|maria) echo "Oi $user";; *) echo "Não te conheço";; esac``
 | ``case "$var" in ?) echo '1 letra';; ??) echo '2 letras';; ??*) echo 'mais de 2';; esac``
 | ``case "$i" in [0-9]) echo '1 dígito';; [0-9][0-9]) echo '2 dígitos';; esac``
 || Caixas do Dialog
 | ``dialog --calendar 'abc' 0 0 31 12 1999``
 | ``dialog --checklist 'abc' 0 0 0 item1 'desc1' on item2 'desc2' off``
 | ``dialog --fselect /tmp 0 0``
 | ``(echo 50; sleep 2; echo 100) | dialog --gauge 'abc' 8 40 0``
 | ``dialog --infobox 'abc' 0 0``
 | ``dialog --inputbox 'abc' 0 0``
 | ``dialog --passwordbox 'abc' 0 0``
 | ``dialog --menu 'abc' 0 0 0 item1 'desc1' item2 'desc2'``
 | ``dialog --msgbox 'abc' 8 40``
 | ``dialog --radiolist 'abc' 0 0 0 item1 'desc1' on item2 'desc2' off``
 | ``dialog --tailbox /tmp/arquivo.txt 0 0``
 | ``dialog --textbox /tmp/arquivo.txt 0 0``
 | ``dialog --timebox 'abc' 0 0 23 59 00``
 | ``dialog --yesno 'abc' 0 0``
 | **Dica1:** ``dialog ... && echo 'Apertou OK/Yes' || echo 'Apertou Cancel/No'``
 | **Dica2:** ``resposta=$(dialog --stdout --TIPODACAIXA 'abc' ...)``

== Atalhos da linha de comando (set -o emacs) ==[emacs]

 || Atalho | Descrição                             | Tecla Similar |
  | Ctrl+A | Move o cursor para o início da linha  |  Home 
  | Ctrl+B | Move o cursor uma posição à esquerda  |  ← 
  | Ctrl+C | Envia sinal EOF() para o sistema      |               |
  | Ctrl+D | Apaga um caractere à direita          |  Delete 
  | Ctrl+E | Move o cursor para o fim da linha     |  End 
  | Ctrl+F | Move o cursor uma posição à direita   |  → 
  | Ctrl+H | Apaga um caractere à esquerda         |  Backspace 
  | Ctrl+I | Completa arquivos e comandos          |  Tab 
  | Ctrl+J | Quebra a linha                        |  Enter 
  | Ctrl+K | Recorta do cursor até o fim da linha  |               |
  | Ctrl+L | Limpa a tela (igual ao comando clear) |               |
  | Ctrl+N | Próximo comando                       |               |
  | Ctrl+P | Comando anterior                      |               |
  | Ctrl+Q | Destrava a shell (veja Ctrl+S)        |               |
  | Ctrl+R | Procura no histórico de comandos      |               |
  | Ctrl+S | Trava a shell (veja Ctrl+Q)           |               |
  | Ctrl+T | Troca dois caracteres de lugar        |               |
  | Ctrl+U | Recorta a linha inteira               |               |
  | Ctrl+V | Insere caractere literal              |               |
  | Ctrl+W | Recorta a palavra à esquerda          |               |
  | Ctrl+X | Move o cursor para o início/fim da linha (2x) |  Home/End 
  | Ctrl+Y | Cola o trecho recortado               |               |

== A caixa de ferramentas do shelleiro ==[ferramentas]

 ||  Comando    | Função                  | Opções úteis |
 |  **cat**     | //Mostra arquivo//      | -n, -s
 |  **cut**     | //Extrai campo//        | -d -f, -c
 |  **date**    | //Mostra data//         | -d, +'...'
 |  **diff**    | //Compara arquivos//    | -u, -Nr, -i, -w
 |  **echo**    | //Mostra texto//        | -e, -n
 |  **find**    | //Encontra arquivos//   | -name, -iname, -type f, -exec, -or
 |  **fmt**     | //Formata parágrafo//   | -w, -u
 |  **grep**    | //Encontra texto//      | -i, -v, -r, -qs, -n, -l, -w -x, -A -B -C
 |  **head**    | //Mostra Início//       | -n, -c
 |  **od**      | //Mostra Caracteres//   | -a, -c, -o, -x
 |  **paste**   | //Paraleliza arquivos// | -d, -s
 |  **printf**  | //Mostra texto//        | //nenhuma//
 |  **rev**     | //Inverte texto//       | //nenhuma//
 |  **sed**     | //Edita texto//         | -n, -f, s/isso/aquilo/, p, d, q, N
 |  **seq**     | //Conta Números//       | -s, -f
 |  **sort**    | //Ordena texto//        | -n, -f, -r, -k -t, -o
 |  **tac**     | //Inverte arquivo//     | //nenhuma//
 |  **tail**    | //Mostra Final//        | -n, -c, -f
 |  **tee**     | //Arquiva fluxo//       | -a
 |  **tr**      | //Transforma texto//    | -d, -s, A-Z a-z
 |  **uniq**    | //Remove duplicatas//   | -i, -d, -u
 |  **wc**      | //Conta Letras//        | -c, -w, -l, -L
 |  **xargs**   | //Gerencia argumentos// | -n, -i

Quer imprimir o Canivete Suíço do Shell? [Use a versão em PDF canivete-pdf.html].

%!include: ../include/kiwi/footer.t2t