Jedi Tux

acidentes comando rm – trash-cli

Posted in Bash, Dicas by Fernando Basso on 7 de janeiro de 2012

Fiz esse arquivo no vim. Quem quiser pode baixar a versão que converti com o :TOhtml.
rm_accidents.smr
NOTA: O wordpress não me permitiu fazer upload do arquivo html, nem zip, então eu renomeei ele para .pdf para poder fazer o upload. Baixe o arquivo e renomeie a extensão para .html novamente antes de tentar abrir o arquivo.

=============================
= Rm - Previnindo Acidentes =
=============================


= Tópicos =
-----------
  - Comando rm não tem trash
  - Solução nº 1 - interactive mode
  - Solução nº 2 - um alias para o interactive mode
  - Solução nº 3 - trash-cli - lixeira na linha de comando

== Comando rm não tem trash ==
------------------------------

Cuidado!!! No terminal, na linha de comando, quando se digita
    rm segredo_mundial.txt
o segredo_mundial.txt já era. Não tem mais o que fazer.

===============================================================================

== Solução nº 1 - interactive mode ==
-------------------------------------

Sempre use a opção "-i", ou "--interactive" com o comando "rm" e torne isso
um hábito. Essa opção se prontifica a nos perguntar se realmente desejamos
deletar o arquivo.
    rm -i segredo_mundial.txt
    rm --interactive segredo_mundial.txt

CUIDADO com a flag "-f" ou "--force". Com ela, as opções "-" ou
"--interactive" se tornam inúteis, ou seja, eles são completamente
igonorados. 

Há um truque que pode ser aplicado. Digamos que temos um diretório
contendo arquivos muito importantes. Podemos criar um arquivo chamado "-i"
dentro desse diretório. Como o arquivo contém "-" no nome, não podemos
simplesmente fazer "touch -i", pois o comando "touch" vai pensar que estamos
passando a opção "-i" como argumento, e o comando "touch" nem tem uma opção
chamada "-i". As duas possíveis maneiras de criar o tal arquivo estão
exemplificadas abaixo:
    touch -- -i
ou
    touch ./-i


A partir de agora, se você fizer
    rm -Rf *
o shell vai expandir o "-i" na linha de comando, de tal forma que seu
comando na verdade se transforma em
    rm -Rf -i

Note que isso só funciona se você usar o "glob" (*). Se tentar deletar um
arquivo por vez, o arquivo "-i" não vai te ajudar. Vamos aprender outro
truque quando falarmos do programa "trash-cli".

Se quiser remover o arquivo "-i", não basta fazer rm -i porque o rm tem de
fato a opção "-i". Então "rm -i" é o comando "rm", seguido da opção "-i",
mas ainda falta dizer ao "rm" qual arquivo ou arquivos deletar, por que ele
não sabe que "-i" é um arquivo e não uma opção. Usamos uma técnica similar a
que usamos para criar o arquivo. As duas soluções possíveis são:
    rm -- -i
ou
    rm ./-i


===============================================================================
== Solução nº 2 - um alias para o interactive mode {{{
------------------------------------------------------

A solução número dois consiste em colocar o que apprendemos acima em um
"alias" (um "apelido", em Inglês). Vamos criar um alias que faz com que o
comando "rm" sempre seja executado com "rm --interactive".
    alias rm='rm --interactive'

Digite o comando acima em um terminal e tente remover um arquivo (não teste
com nada que seja importante). Para testar, rode apenas "rm arquivo.txt" e
você vai notar que ele pergunta se temos mesmo certeza de que queremos
deletar o arquivo em questão.

Se você gostou da ideia coloque o comando que cria o alias no ~/.bashrc.
Para que o alias entre em vigor, feche e abra o terminal novamente ou rode
o comando:
    source ~/.bashrc

A partir de agora, toda vez que você digitar "rm", o bash interpreta o alias
e na verdade vai executar "rm --interactive". 

===============================================================================
== Solução nº 3 - trash-cli - lixeira na linha de comando ==
------------------------------------------------------------

Instale o programa "trash-cli". Enquanto escrevo este documento, "trash-cli"
está disponível pelo AUR para o Arch Linux, mas pesquisas pela web fazem
acreditar de que já está nos repositórios oficiais de muitas distribuições.

O programa "trash-cli" vem com três comandos principais:
    1. trash-empty - esvazia a lixeira;
    2. trash-list - lista os arquivos da lixeira;
    3. trash-put - manda arquivos para a lixeira.

Para mais informações leia o help de cada uma das variações do trash-cli.

    trash-empty --help
    trash-list --help
    trash-put --help


O problema agora é criar o hábito de usar o "trash-cli" em vez do bom e
velho "rm". Sim, porque nós instalamos o programa, mas por força do hábito é
bem provável que continuemos usando o "rm" sem nem notar.

Vamos então usar um truque para, digamos, desabilitar o comando "rm". O
truque consiste em, novamente, criar um alias. Mas antes disso vamos falar
de comentários no bash (com poucos ajustes todas essas dicas funcionam em
ourtos SHELLs).

Um comentário no bash inicia com #. Rode o seguinte comando direto do
terminal:
    # echo 'Hello, world.'
Essa linha não vai executar nada. É um comentário apenas.
Tente esta outra:
    echo 'Hello, ' # world'.
O echo acima só vai mostrar "Hello, ". O resto da linha é comentário.


Então, a ideia é criar um alias que comente o "rm". É fácil:
    
    alias rm='# rm'

Pode colocar o alias no ~/.bashrc e rodar "source ~/.bashrc". A partir de
agora, toda vez que você digitar "rm", ele simplesmente nem sequer será
executado, pois agora ele foi "comentado". No então, há alguns pontos a
serem considerados:

   1. Se você executar outro SHELL a partir do shell que contém o alias, o
      outro shell não vai herdar o alias, portanto, "rm" desse outro shell
      vai funcionar normalmente.

   2. IMPORTANTE: você executou essas operações no terminal como usuário, e
      configurou o ~/.bashrc em nível de usuário. A conta do ROOT continua
      com as configurações default. Como o ROOT é um usuário ainda mais
      crítico no sistema, considere colocar essas configurações no
      /root/.bashrc.

================================================================================
Anúncios

Simular margem no vim para ler o :help

Posted in Bash, Dicas, Linux, Vim by Fernando Basso on 1 de janeiro de 2012

Simular margem no vim para ler o :help

Uma coisa que me incomoda quando estou lendo o :help no vim é que o texto fica “grudado” na borda esquerda da janela do vim (ou gvim). Então, o que costumo fazer é habilitar os números de linha com :set number. para ter algo no lado esquerdo da janela funcionando como uma espécie de margem.

Tem dois detalhes que me incomodam. Um é que não adiante colocar set number no vimrc porque help é um filetype no vim, então, as configurações do filetype help (que usa set nonumber) sobrescreve o set number do vimrc. Outra coisa é que ter números de linhas para ler o help pode não agradar muito ou fazer muito sentido. Fortunadamente, há uma maneira de simular uma margem, sem que fique aparecendo os números.

Entendendo o processo

Quando usamos a opção set number, o vim usa um espaço ao lado esquerdo da janela para mostrar esses números, e também nos fornece os grupos de cor chamados LineNr que é justamente para definir a cor que aparece naquela parte onde os números são mostrados, tanto o background como o foreground.

Pois bem, se configurarmos LineNr para ter a mesma cor de background que do resto do vim não veremos diferença de cor entre o fundo do texto normal e a cor da região usada para mostrar o números das linhas. Ainda mais, se configurarmos a cor que LineNr usa para mostrar os números propriamente ditos para a mesma cor do background, não vamos ser capazes de ler/ver número algum, pois a cor do texto será exatamente igual a cor de fundo. Os números ainda estão lá, mas não dá pra notar.

O que vamos fazer então é criar (se já não existir) o diretório ~/.vim/after/ftplugin. O comando abaixo se encarrega disso, e se os diretórios já existem, ele simplesmente não faz nada:

mkdir --parents ~/.vim/after/ftplugin

Precisamos criar também, (se já não existir) o arquivo help.vim dentro de ~/.vim/after/ftplugin/:

vim ~/.vim/after/ftplugin/help.vim

Agora, vamos descobrir quais as cores que o nosso colorscheme está usando para o background. Os grupos de cores para isso são ctermbg (background no terminal) e guibg (background no gvim). Para descobrir as cores configuradas para os grupos mencionados, execute os seguinte comando:

:highlight Normal

Isso vai mostrar as cores configuradas para ctermfg, ctermbg, guifg, entre outras coisas.

Para ter certeza da cor que o gvim usa como background (há fatores que podem fazer com que o vim no terminal use cor x, e o gvim use cor y para determinado grupo) é mais seguiro abrir o gvim e rodar o mesmo comando para ver o que ele mostra sobre si próprio para guifg e guibg.

NOTE que o comando é digitado no modo de comando do vim. Entramos no modo de comando quando, estando no modo normal pressionamos : (chegamos no modo normal pressionando <Esc> ou CTRL-[).

Finalmente, no ~/.vim/after/ftplugin/help.vim colocamos o configuramos os backgrounds e foregournds para o vim e gvim com os valores das cores conforme foram mostrados com o comando anterior.

set number
highlight LineNr ctermfg=235 ctermbg=235 guifg=#dfd6c1 guibg=#242424

Veja, a cor do ctermfg, ctermbg, guifg e guibg são iguais (fg = FackGround, bg = BackGround). E lembre-se que essa cor é igual a cor do background da janela normal do vim. Isso cria a impressão que há uma margem.

De agora em diante, toda vez que você abrir um :help no vim, terma uma “margem” no lado esquerdo da janela. Pra mim pelo menos, parece tornar a leitura mais confortável.

Colocando em uma função (opcional)

Podemos também deixar a configuração padrão do vim ficar como é quando abrimos um :help, e colocar o código que criamos em uma função, e criar uma outra função que desabilita a margem.

A função que habilita:

function! CriaMargem()
 set number
 highlight LineNr ctermfg=235 ctermbg=235 guifg=gray16 guibg=gray16
endfunction

Para criar a função que desabilita a margem, vamos descobrir a as cores que são definidas para LineNr por padrão. Certifique-se de que não tenha chamado a função acima e não tenha aberto um :help usando o nosso truque, senão o comando abaixo não vai mostrar as cores originais. Em todo caso, rode o comando (novamente, no modo de comando):

:hightlight Normal

E coloque as cores que aparecerem aí na função que desabilita a margem (volta as cores padrão para que possamos ver os números):

function! MargemOff()
 highlight LineNr ctermfg=180 ctermbg=242 guifg=#cdaa7d guibg=bg
endfunction

Essas funções também vão dentro do help.vim que criamos. Chame as funções assim no vim:

:call CriaMargem()

e

:call MargemOff()

Pode usar <Tab> para autocompletar.

Note que colocando essas funções no ~/.vim/after/ftplugin/help.vim, elas só estarão disponíveis quando você estiver lendo um :help no vim. Portanto, não adianta esta editando um html, C, ou perl e querer chamar essas funções. Se quiser que elas fiquem disponíveis para outros filetypes, coloque-as no ~/.vimrc.

Supondo que deixamos elas no help.vim, vamos deixar CriaMargem() habilitada por padrão. Para tal, basta chamar a função de dentro do próprio help.vim. Aqui vai o exemplo completo:

" Habilita a simulação de margem.
function! CriaMargem()
 set number
 highlight LineNr ctermfg=235 ctermbg=235 guifg=gray16 guibg=gray16
endfunction
" Mostra set mumber normalmente.
function! MargemOff()
 highlight LineNr ctermfg=180 ctermbg=242 guifg=#cdaa7d guibg=bg
endfunction

” Vamos deixar a função habilitada por padrão.

autocmd BufEnter * call CriaMargem()

Com certeza deve ter como colocar tudo em uma única função, tornando o código mais profissional, mas no momento em que escrevo, é o que deu pra fazer sem perder muito tempo.

Tagged with: , , , ,

Xdefaults VS Escape Sequences, Bash – Cores do Prompt

Posted in Bash, Dicas, Linux by Fernando Basso on 27 de dezembro de 2011

Leia todo o texto antes de tentar configurar algo. Algumas coisas que você ler mais no início do texto fará sentido quando se juntar com conceitos explicados mais adiante.

A intenção deste post não é mostrar TUDO sobre configuração do prompt do bash propriamente dito, mas sim mostrar a relação que tem as cores do terminal/prompt com as sequências de escape que usamos para configurar o prompt, pois sem essa noção, ficamos tentando configurar as cores “às cegas”. Esse tutorial funciona para o xterm, mas os conceitos são os mesmos para configurar outros emuladores de terminal.

Quando queremos configurar o prompt do Bash, usamos sequências de escape como:

    '\033[31m'
    

Faça um teste:

    echo -e "\033[31m Hello, World."

\033[ significa que estamos iniciando uma sequência de caracteres que não serão imprimidos, ou seja, inicia a sequência de escape. O próximo número (31, no exemplo) indica a cor que queremos imprimir, seguido de “m“, que termina a sequência de escape. O que vem em seguida é o texto que queremos realmente mostrar.

A parte numérica que determina a cor do texto pode indicar que queremos o texto em negrito, para isso, a sintaxe fica assim:

    echo -e '\033[31;1m Hello, World." # Note o ";1".

Ou seja, aquele 31;1, onde 31 é a cor, e 1 habilita o negrito. O número que especifica a cor e o número que habilita o negrito devem estar separados por ponto e vírgula (;). Mas agora vem a questão: 31 é qual cor? Aí é que entra o arquivo ~/.Xdefaults ou ~/.Xresourses.

No ~/.Xdefaults temos entradas como as do exemplo abaixo:


    ! Black, \033[30m
    XTerm*color0: #000000
    ! DarkGrey, \033[30;1m
    XTerm*color8: #BABDB6

    ! DarkRed, \033[31m
    XTerm*color1: #FF6565
    ! Red, \033[31;1m
    XTerm*color9: #FF8D8D

No ~/.Xdefaults usamos cores que vão de color0 até color15. As cores do color0 a color7 são cores normais, e de color8 até color15 são as cores em negrito, ou brilhosas.

Aqui temos um conceito importante. Note nos comentários (linhas iniciadas com !). Por exemplo, *color0 é a cor que será usada na sequência de escape \33[30m (cor normal), e a color8 será usada com a sequência \33[30;1m, ou seja, a cor em negrito. Continuando, color1 é usada pela sequência \33[31m (cor normal) e color9 é usada pela sequência \33[31;1m, a cor em negrito, e assim sucessivamente, até a color7 para cores normais, e color15 para os negritos.

Agora, configure as cores do xterm no ~/.Xdefaults da maneira que quiser, ou simplesmente copie as minhas (que pode modificar depois):

! ***** My Xterm Colors ***** ! {{{
! 1 to 7 are normal colors. 8 to 15 are the bright/bold ones.
XTerm*foreground: yellow
XTerm*background: #242424

! Black, \033[30m
XTerm*color0: #000000
! DarkGrey, \033[30;1m
XTerm*color8: #BABDB6

! DarkRed, \033[31m
XTerm*color1: #FF6565
! Red, \033[31;1m
XTerm*color9: #FF8D8D

! DarkGreen, \033[32m
XTerm*color2: green3
! Green, \033[32;1m
XTerm*color10: #C8E7A8

! DarkYellow, \033[33m
XTerm*color3: #EAB93D
! Yellow, \033[33;1m
XTerm*color11: #FFC123

! DarkBlue, \033[34m
XTerm*color4: #204A87
! Blue, \033[34;1m
XTerm*color12: #3465A4

! DarkMagenta, \033[35m
XTerm*color5: #CE5C00
! Magenta, \033[35;1m
XTerm*color13: #F57900

! DarkCyan, \033[36m
XTerm*color6: #89B6E2
! Cyan, \033[36;1m
XTerm*color14: #46A4FF

! LightGrey, \033[37m
XTerm*color7: #CCCCCC
! White, 0\33[37;1m
XTerm*color: #FFFFFF

! }}} Xterm ends here.

Para que as configurações entrem em vigor, execute o comando:

    xrdb ~/.Xdefaults

Feche e abra o terminal novamente. Lembre-se que isso funciona para o xterm. Não adianta usar o gnome-terminal (do gnome) ou o konsole (do kde). Agora sim estamos preparados para brincar com o prompt.

O prompt do bash é definido pela variável PS1 (tem a PS2 também, entre outras, que é usada quando continuamos um comando na próxima linha).

Vamos fazer uma configuração básica do prompt. Não precisa editar arquivo nenhum por enquanto, pois vamos fazer direto pelos comandos. Antes, porém, dê uma olhada nesta lista:

    \$ # Mostra o prompt de usuário '$', ou root '#'.
    \u # Mostra o username.
    \h # Mostra o hostname.
    \t # Mostra a hora (time).
    \d # Mostra a data (date).

Tem outros. man bash, na seção PROMPTING tem mais informações.

Digite o próximo comando, e veja como fica o prompt (não se preocupe, poi s essas alterações não são definitivas).

    PS1='\$ '

Agora tente este:

     PS1='\033[31m \$ '

Mais um:

    PS1='\033[31m\h@\u, \033[33m \s-v \033[0m\$'

Notou a diferença das cores? Vamos tentar com negrito (lembre-se, depende de como as cores foram configuradas no ~/.Xdefaults):

    PS1='\033[31;1m\h@\u, \033[33;1m \s-v, \033[0m\$ '

IMPORTANTE: Quando usamos uma cor, ela fica em vigor até sobrescrevermos ela usando outra. No final, temos que fazer a cor voltar ao modo padrão/default. Para isso usamos a sequência de escape:

    \033[0m

Aqui está uma configuração da minha variável PS1, juntamente com mais duas linhas, pois a minha PS1 depende dessas duas outras linhas:

    shopt -s checkwinsize # For hr='=='stuff to work.
    hr='============================================================================================================================================================='
    PS1='${hr::COLUMNS}\r\n\[\e[1;32m\]\s-\v, \[\e[0;32m\]\h@\u, \d \t \n\$PWD=\[\e[1;36m\]"\w" \[\e[1;37m\] \n\$ \[\e[1;37m\]'

Quem quiser tirar umas ideais, aqui estão minhas config filesno github.http://snipt.net/FernandoBasso/my-bashrc-dec-26-2011

Como eu disse no início, a intenção é mostrar a relação Xdefaults vs Escape Sequences. Tem vários tutoriais na web que tratam exclusivamente do prompt do bash. No entanto, nunca vi nenhum documento ou tutorial mencionar essa relação. Sem saber disso, ficamos configurando cores às cegas…

Descobri essa questão da relação Xdefaults/Escape Sequences perguntando no fórum do arch (em inglês), depois de levar as tradicionais broncas “vai ler no wiki”, ou “RTFM”. Ou seja, o pessoal adora assumir que os ‘aprendizes’ não gostam de ler e querem respostas prontas. PS: eu tinha lido metade da web tentando aprender mais sobre isso, e no wiki do arch também não menciona isso. :)

May the force be with you. Always.

Expressões Regulares no BASH – Parte 2

Posted in Bash by Fernando Basso on 25 de dezembro de 2011

BASH – Expressões Regulares – Parte 2

Sunday, 10:47 – December 25 – 2011

  1. Extrair Nome do Script ou o Path para o Script
  2. Verificando por Sub-Strings
  3. Substituições Básicas
  4. Remover do início da string
  5. Remover do fim da string

Dando continuação aos exemplos do primeiro tutorial sobre expressões no
bash, vamos a mais alguns exemplos diversos, que basicamente usam o que já
aprendemos anteriormente.

Extrair Nome do Script ou o Path para o Script

Sabemos que no linux os caminhos de diretórios são compostos pelos nomes
dos diretórios separados pela barra (/). Em muitos dos nossos próximos
exemplos, a barra não será usada como delimitador, mas como o próprio
elemento que queremos encontrar. Tenha isso em mente enquanto estuda os
próximos exemplos.

A variável “$0” é interna do bash, e ela mostra o nome do script.
Se executamos o script do diretório onde ele está, tudo bem, o output
mostrará o nome do script normalmente.

echo "$0"

É lógico que a variável $0 só fará sentido se utilizada
dentro de um script. Para testar pela linha de comando podemos simular
criando uma variável que contém um path (caminho) qualquer e usar a essa
variável em vez de $0:

var="/usr/local/bin/my_script"

Continuando o assunto, se o script está em /usr/local/bin/
por exemplo, então $0 vai mostrar o caminho completo do arquivo, e não
apenas o nome dele. A solução é deletar a parte que não queremos.

echo "${0##*/}"

NOTE que agora o / não é mais o delimitador. Ele é o próprio
caractere que queremos encontrar. Suponha que o script se chama
my_script, então o caminho completo será
/usr/local/bin/my_script. Em português ficaria “mostre o
conteúdo da variável $0, e delete tudo (*) até a ultima barra possível (/).
Restará só o nome final: my_script

.

Por outro lado, se queremos mostrar somente o caminho, sem o nome do
arquivo propriamente dito, temos que deletar de trás pra frente, usando o
'%' ou o '%%'.

echo "${0%%/*}"

Em português, “do final da string (%%), delete tudo (*) até encontrar a
barra (/). Sei que é estranho, por que mesmo sendo de trás pra frente, o
‘%%’ continua logo após a variável, como é o caso do ‘#’ ou ‘##’. O jeito é
acostumar, pois é assim mesmo.

Os créditos do próximo exemplo vão para mywiki.woolege.org. A
única coisa que fiz foi tentar explicar de uma maneira um pouco
diferente.

Digamos que não queremos apenas o nome final, mas as duas ultimas partes.
Bom, vamos pensar um pouco por vez. Primeiro, pegamos as partes que não
queremos, e salvamos em uma variável. Antes vamos testar. Vamos ver se a
expressão está realmente mostrando somente a parte que não queremos:

echo "${var%/*/*}"

Deleta do final até a primeira barra (/*) e deleta mais uma vez até a
próxima barra (/*). Por isso usamos /*/*. Agora sim, assine
essa regexp na variável tmp. Veja que executando o
echo, acima na verdade a espressão está deletando as duas ultimas
partes. Não tem problema, desde que salvemos essa expressão na variável.

tmp="${var%/*/*}"

Para se certificar de que a expressão está correta, vamos ver o que foi
salvo na var tmp:

echo "$tmp"

tmp agora possui '/usr/local'. Vamos então
deletar do início da string, todo o conteúdo que está em
tmp:

echo "${var#$tmp}"

É o mesmo que:

echo "${var#/usr/local/}"

Ou seja, deleta '/usr/local' deixando somente o final que
queriamos '/bin/my_script'. Faça você mesmo várias vezes e
invente exemplos próprios parecidos com esse até acostumar.

Mais um exemplo:

var="nada importante <jackpot> ... não interessa"

Agora, por algum motivo, queremos ficar somente com jackpot:

tmp="${var##*<}" # Remove do início até o <.
echo "${tmp%>*}" # Remove do > até o fim da string.

Pronto, só nos restou o que estava entre < e >.

Mais um exemplo:

      var="Isto é 'melhor' que aquilo."
      tmp="${var#*\'}" # Temos que escapar a aspa simples (\').
      echo "${tmp%\'*}" # Sobra apenas "melhor" (sem as apas).
    

Voltar


Trabalhando Com Posições Fixas – Ranges

Se sabemos quantos caracteres à direita ou a esquerda queremos, fica muito fácil:

var="ABCDEFGHIJ"

Mostramos somente os dois primeiros caracteres, ou seja, do zero ao dois:

echo "${var:0:2}"

Mostrar as últimas três posições, ou seja, da posição 7 a posição 10:

echo "${var:7:10}"

O mesmo pode ser conseguido com:

echo "${var:(-3)}"

Tenha cuidado com a sintaxe.

Em construção…

Expressões Regulares no BASH – Parte 1

Posted in Bash by Fernando Basso on 24 de dezembro de 2011

BASH – Expressões Regulares

Saturday, 10:33 – December 24 – 2011

  1. Introdução
  2. Verificando por Sub-Strings
  3. Substituições Básicas
  4. Remover do início da string
  5. Remover do fim da string

Introdução

Estes exemplos podem ser digitados diretamente na linha de comando, ou
então colocados em em arquivo. Não vou explicar isso detalhadamente agora, mas
um escript bash pode ser algo como esse exemplo:

  #!/usr/bin/env bash

  # Descomente a próxima linha para um output mais verbose.
  #set -xv

  var="May the force be with you. Always! - Master Yoda."
  echo "$var"

  if [[ -z "$var" ]]; then
      echo "A string é vazia."
  else
      echo "A string não é vazia."
  fi # Fim do 'if'.

  # Script termina aqui.

Com o terminal na pasta onde está o script, execute este comando para
rodar o script:

bash nome_do_script

Vamos criar uma variável contendo uma string. Essa variável/string
será usada nos exemplos.

var="May the force be with you. Always! - Master Yoda."

Mostrar quantos caracteres uma string possui.

echo "${#var}"

Voltar


Verificando por Sub-Strings

Colocamos a sub-string desejada entre ‘*’ (o chamado glob). Vamos
verificar se a string contém a sub-string ama:

#!/usr/bin/env bash
var="programador"
if [[ "$var" = *"ama"* ]]; then
    echo "<$var> contém a substring <ama>."
else
    echo "<$var> não contém a substring <ama>."
fi

Colocando a sub-string e uma variável, o código ficaria assim:

#!/usr/bin/env bash
var="programador"
substr="ama"
if [[ "$var" = *"$substr"* ]]; then
    echo "<$var> contém a substring <$substr>."
else
    echo "<$var> não contém a substring <$substr>."
fi

Voltar


Substuições Básicas

Usamos a barra (/) como delimitador.

Substituir ‘e’ por ‘E’. Somente a primeira ocorrência:

echo "${var/e/E}"

Para mudar todas as ocorrências de ‘e’ para ‘E’, usamos a barra duas vezes.
Dizemos que substitui globalmente.

echo "${var//e/E}"

Para efeito de ilustração, suponhamos que queremos substituir o ‘e’
mais os próximos dois caracteres, não importa quais sejam, por 1, 2 e 3
respectivamente:

echo "${var//e??/123}"

Substitui o ‘!’ por um ponto final ‘.’. Precisamos escapar o
ponto de exclamação pois ele é um caractere especial no bash.

echo "${var/\!/.}" # O . não é um metacaractere no bash. 

Subsituir spaços em branco por underscores – globalmente.

echo "${var// /_}"

Substituir . por …:

echo "${var//./...}"

Voltar


Remover do Início da String

Para remover parte do início de uma string, não usamos mais o delimitador (/).
Usamos apenas o ‘#’ ou ‘##’. Vamos aos exemplos.

Remover do início até o primeiro espaço. Um único # é non-greedy (não
ganancioso/guloso).

echo "${var#* }"

Explicando: o # busca pelo início, o * é tudo, e o espaço em branco é o
que queremos encontrar. Então, em português ficaria algo como “do início da string (#),
tudo o que for possível (*), até o primeiro espaço em branco que encontrar ( )”.

Remove do início até o último espaço em branco possível. ## é
greedy.

echo "${var##* }"

NOTE que o glob vai ANTES do item que queremos encontrar. No
exemplo, o * vem antes do espaço em branco.

Parar antes do ponto, ou seja, não incluir o ponto.

echo "${var##*([!.])}"

# ! é o operador de negação ou “NOT”.

Remove tudo, do início até o hífen (-).

echo "${var#*-}"

Remove do início até o espaço que vem após o hífen.

echo "${var#*- }"

Colocando em português, “do início (#), tudo (*),continua até o hífen (-), e inclui o espaço em branco ( )”.

Voltar


Remover do Final da String

var="May the force be with you. Always! - Master Yoda."

Agora procuramos para trás. Por isso, o * vai do lado oposto do que
vinhamos usando até agora e o operador ‘#’ muda para ‘%’.
Pra frente: “${var#*-}”
Pra trás: “${var%-*}”
– é o que queremos encontrar. É importante observar que agora a expressão
começa e ser procurada do fim do string e vai “caminhando” até o início

Remove do fim até o primeiro espaço – contando de trás pra frente. Ou
seja, o último contando do início.

echo "${var% *}"

Remove do final até o último espaço – contanto de trás pra frente. Ou
seja, o primeiro contando normalmente.

echo "${var%% *}"

Remove do fim até o hífen

echo "${var%-*}"

Remove do fim até o primeiro ‘ç’ que encontrar:

echo "${var%ç*}"

Se o caractere que queremos encontrar ocorre mais de uma vez na string,
e queremos encontrar justamente a ocorrência dele que está o mais distante
possível do final da string, usamos ‘%%’ em vez de ‘%’. O ‘e’ mais distante
do final da string nesse caso está na palavra ‘Que’ bem no início. Veja
como ficaria o código:

echo "${var%%e*}"

Voltar


A maior parte do que postei aqui eu aprendi no site
wooledge.org – um excelente site
sobre shell scripting com o bash. O que não aprendi lá aprendi lendo na web, conversando em IRCs, forums, e nos –help e man (que confesso serem
difíceis de entender as vezes).

Por enquanto é isso. Teremos mais exemplos em futuros posts.

Tagged with: , , ,

Terminal_Aula1

Posted in Bash by Fernando Basso on 19 de junho de 2010

INTRODUÇÃO

Este é um pequeno tutorial para quem está abrindo o terminal pela primeira
vez na vida. Não é avançado e principalmente, tentei usar uma linguagem simples
e exemplos simples. As páginas de manual do GNU/Linux são repletas de termos
e vocabulário complicados, de difícil compreensão. E muitas vezes faltam
exemplos. Exemplos sempre são o complemento perfeito para a explicação de
qualquer coisa.

Leia em voz alta para uma melhor memorização e principalmente execute os
exemplos no seu sistema. Não sou perfeito. Peço desculpas antecipadamente
por qualquer erro, ortográfico ou técnico, principalmente no que diz respeito
à exatidão das explicações.

O TERMINAL

Você abre o terminal pela primeira vez na vida e vê algo parecido com isso:

O ~ (til) significa que você está na sua pasta pessoal. Na sua pasta
de usuário. Ou seja, o terminal está ‘operando/trabalhando’ atualmente na
sua pasta de usuário. nando é o nome de login do usuário utilizando
o terminal, e vaio é o hostname, ou nome do host (nome que foi dado
ao sistema durante a instalação). O ‘$’ diz que você está usando o terminal
como usuário comum, e não como root (administrador do sistema). Os
outros caracteres não tem nada de especial.

Os ‘terminais’ que eu uso são o urxvt (rxvt-unicode), xterm e
gnome-terminal. Não que sejam melhores, vai do gosto. Existem vários
outros.
Aqui
há uma lista de emuladores de terminal.

BASH – O SHELL

O programa que roda ‘por baixo’ do terminal é o shell. O shell é
um interpretador de comandos que e usamos para interagir com o sistema.
O shell padrão na maioria das distribuições GNU/Linux é o bash. Não
que ele seja o “melhor”. Ele tem suas vantagens, mas outros shells também
tem suas vantagens. Todos tem suas vantagens e desvantagens.

Vamos deixar o uso do terminal mais agradável. Faremos isso modificando
a variável PS1, que é a principal responsável pela aparência do prompt
do bash.

Mesmo que você não entenda por enquanto, rode o seguinte comando (selecione
o texto da linha seguinte, e clique com a roda do mouse dentro do terminal):


PS1='[e[0;32m]h@u, d t [e[1;34m]nw [e[0;32m]$ [e[0;35m] nbash >>> '

Você deve ficar com algo parecido com isto:

Deste modo fica um pouco mais agradável de utilizar o terminal, assim como
facilita a visualização dos comandos e o ‘resultado’ dos comandos.

A PASTA HOME

No GNU/Linux, a pasta do usuário, onde ficam os arquivos pessoais de cada
usuário é chamada de home (em Inglês). A minha pasta home é nando.
(home = casa ou lar). Não acha que faz sentido ?

Se o seu nome de login (ou usuário, ou nome de usuário) for
arthur, a sua pasta home será também arthur. Se o seu login
for maria, a sua home será maria.

VISUALISANDO ARQUIVOS E DIRETÓRIOS

Uma das primeiras coisas que precisamos fazer é, com certeza, saber quais
arquivos e diretórios temos na nossa home. Para visualizar o conteúdo da nossa
home rodamos o comando:

ls

Olhe o resultado do comando com calma. O que foi mostrado em azul são pastas
ou diretórios. Tudo o resto são arquivos de texto. Se as pastas não foram
mostradas em azul, você tem que configurar o bash para que o faça. Logo vamos
aprender mais configurações legais do bash. ls é uma abreviação de
list (listar).

MOVENDO-SE

Se nós estamos na nossa home, dizemos que o diretório de trabalho é o home.
Algumas distribuições vem com o bash configurado para mostrar um simples:

Se o bash não está configurado para mostrar a pasta em que você está, podemos
acilmente descobrir qual é o diretório de trabalho com com o comando pwd:

pwd = print working directory = mostrar diretório de trabalho. Note que
pwd nos diz que estamos neste momento trabalhando na pasta /home/nando.

Não se confunda. O /home/ mostrado acima é uma home que abriga todas
as outras homes de todos os usuários cadastrados no sistema. Ou seja, dentro
desta /home teria por exemplo as pastas nando, arthur e maria
– as homes deste usuários. Então, a /home não é a home de um
único usuário em especial, mas sim uma pasta especial, que serve de terreno
onde as homes (lares/casas) dos usuários cadastrados no sistema são
construídas.

MUDANDO DE DIRETÓRIO

Vamos entrar no diretório Music. O comando que usamos para isto
é cd (change directory = mudar de diretório). Veja:

2

Quando estiver digitando um nome de diretório você pode ou não colocar
a barra (/) após o nome (sem espaço). Eu fiz cd Music/ mas poderia
ser apenas cd Music. Na verdade, eu usei o recursro de autocompletar
(detalhes adiante) e o autocompletar coloca a barra automaticamente. É claro
que você já notou também que a barra serve para separar um diretório de outro
quando estamos digitando caminhos de diretório. Veja como o pwd também usa
barras para separar nomes de diretórios, mas ele não usa barra ao final do
último diretório.

Como a nossa configuração do bash mostra o diretório atual, pwd não é tão
necessário assim para nós.

Veja que a nossa configuração já mostra o til (~) por padrão quando estamos
na nossa home, e o “$” para dizer que estamos usando o terminal como
usuário comum. Note que quando fizemos cd Music, o prompt mudou de
~ $ para
~/Music $

Isto faz sentido já que a pasta Music está dentro da nossa home.

CASE SENSITIVE

Um coisa que você precisa saber agora mesmo é o seguinte: O GNU/Linux é
case sensitive, (sensível à caixa, porque em Português se diz caixa
alta para letra maiúscula, e caixa baixa para letra minúscula). Então se temos
as pastas Documentos e documentos, eles são dois diretórios
diferentes, e o conteúdo dentro deles não tem correlação.

CAMINHO ABSOLUTO E RELATIVO

Faça:

cd /
ls

… e observe. Assim como temos o ~ que é a nossa home, temos a / (barra)
que representa a raiz do sistema de arquivos. A pasta principal onde
ficam todas as outras pastas, inclusive a /home. Caminho absoluto é
quando digitamos todo o caminho, desde a raiz (/) e caminho relativo é
quando digitamos o caminho de onde estamos (pwd) em diante.

Por exemplo, se estamos em /home/nando e queremos ir para o diretório
/etc, devemos obrigatoriamente digitar o caminho desde a raiz pois
o /etc “vem” do diretório raiz, e não do diretório nando. Outro exemplo. Se
estamos em /boot/grub e queremos ir para /var/lib também somos
obrigados a digitar o caminho completo pois grub vem do boot que por sua
vez vem do / (raiz).

Podemos usar caminho relativo quando o diretório que queremos acessar estiver
um nível acima ou abaixo do diretório atual (pwd). Exemplo: se já estamos
em /home/nando e queremos acessar a pasta Music basta digitar cd Music
pois Music é um diretório “filho” de nando. Não há necessidade de fazer
cd /home/nando/Music ou cd ~/Music.

Neste exemplo:
/home/nando/Music
nando é pai (ou mãe) de Music, home é pai/mãe de
nando e / é pai/mãe de home. No Inglês é muitíssimo comum
se dizer parent directory (diretório pai/mãe).

DICAS ÚTEIS PARA O CD

A nossa home pode ser representada por ~ ou ~/ . Não importa
de onde estamos, podemos sempre retornar para a home digitando:
cd ~ ou
cd ~/ e o mais fácil, simplesmente:
cd

O diretório de trabalho, ou diretório atual pode ser representado por .
ou ./

O diretório pai/mãe (parent directory) pode ser representado por ..
ou ../

Se estamos em ~/Music/Rock queremos voltar para ~/Music basta
fazer:
cd ../ (ao invés de cd ~/Music ou cd /home/nando/Music)

Se estamos em /boot/grub, mudamos para /etc/gconf e queremos
voltar para /boot/grub basta fazer:
cd - e você estará de volta em /boot/grub. Fazer cd –
novamente o levará de volta para /etc/gconf. Ótimo para quando temos que
trabalhar com dois diretórios e temos que ficar alternando entre os dois o
tempo todo, mesmo que seja ficar alternando entre ~/ e ~/Music.

AUTOCOMPLETANDO COMANDOS

Uma característica incrivelmente útil que todos os shells possuem, inclusive
o bash, é de autocompletar comandos. Podemos completar nome das ferramentas
de linha de comando e aplicativos gráficos, nome de arquivos, e caminhos de
diretórios. O autocompletar é conseguido pressionando-se a tecla Tab
uma ou duas vezes, dependendo do caso.

Se você que fazer cd /usr/share/icons, pode fazer assim:
cd /u Tab
/usr/sh Tab
/usr/share/ic TabTab
(aqui o Tab vai mostrar as possíveis
‘palavras’ que começam com “ic”, então você completa mais uma ou duas letras
e dá Tab novamente.

O autocomplete é especialmente útil para ajudar completar nomes compridos.
Imagine que você tenha que fazer cd para uma pasta chamada:
meus_controles_de_entrada_e_saída_de_2009
Bastaria você digitar algo como:
meu Tab e o bash completa o nome inteiro pra você.

Se você tem os diretórios pasta_1_2009 e pasta_2_2009
você digita pa Tab e o bash completa até pasta_ e pára
neste ponto porque ele não sabe se você quer a 1 ou a 2. Você pode
pressionar Tab duas vezes para que o bash mostre as possibilidades
de nomes (caso você não lembre, ou apenas para certificar-se). Você
agora completa com 1 ou 2 e dá mais um Tab para finalizar o
autocomplete.

Para quem quiser, pode baixar o pdf deste texto, que está um pouco melhor formatado além de permitir a leitura off line. Baixe-o: Terminal_e_Bash-Aula_1.pdf

Aqui terminamos este tutorial básico. Qualquer dúvidas ou sugestões
de melhoramento entre em contato através de athunye@gmail.com.

O que é um comando no GNU/Linux

Posted in Bash by Fernando Basso on 8 de setembro de 2009

Cada ferramenta tem suas opções. Temos opções como o -v ou -V ou -r ou -R que na maioria das vêzes são respectivamente verbose (mostra o que está acontecendo enquanto o comando está em execução) ou version (versão do software/aplicativo), –recursive, como cp-Rmusic//mnt/backup/ que copiaria a pasta music com tudo o que tem dentro ou chown -R jedi_tux music/ que mudaria o dono da pasta music com tudo o que existir tudo dentro dela. O jedi_tux passaria a ser dono da pasta music.

As opções podem ser passadas em forma curta ou longa, mas nem sempre uma ferramenta tem forma curta e longa para todas as opções.

O ls por exemplo não tem -h como forma curta de –help. O -h nesse caso é a forma curta de –human-readable

Para ter uma descrição rápida das opções de cada ferramenta com suas formas curtas e longas use ferramenta acompanhada de –help como em ls –help, ou cp –help

Li num livro que aprender os comandos do Linux é como acodender a falar uma nova lingua. Concordo com o autor do livro.

As ferramentas podem formar uma sinergia e são simbiontes. Podemos usar pipes para “emendar” um comando no outro e assim executar tarefas que não estão previstas na função original de uma ferramenta. Como “emendar” comandos quero dizer: enviar o output/saida de um comando para o input/entrada de outro.

Veja o uso de um pipeline simples mas bem útil:
ls -lh | grep .mp3
ls -l -h | grep .mp3(human-readable na forma curta).
ls -l –human-readable | grep .mp3 (human-readable na forma longa) (Os três comandos fazem a mesma coisa.) Isto irá listar os arquivos no diretório em que voçê está, mostrando as permissões (-l) e o tamanho em –human-readable (-h) mas apenas os arquivos que possuem .mp3 no nome (grep). O | (pipe) levou a saida do ls -lh para a entrada do grep que por sua vêz filtrou o resultado e só mostrou o que voçê pediu (.mp3)

Perceba que a opção -l (L), vem da palavra long, que seria, “liste os arquivos com uma loga lista de informaçães. Ou seja, “mostre os arquivos detalhadamente”. Mas você não pode usar ls –long. (Por algúm motivo os desenvolvedores do ls resolveram colocar à nossa disposição a forma curta e longa de human readable, mas não fizeram o mesmo com a opção long, e o mesmo acontece com todas as outras ferramentas e opções.) Outra coisa é que quando se usa a forma curta das opções tanto faz usar ls -lh ou ls -l -h. Legal não!?

Sempre use o –help para saber quais opções uma ferramenta possui, e quais tem forma longa e curta, só curta ou só longa.

Veja também que comando não é igual a ferramenta ou aplicativo.

ls é uma ferramenta. Se voçê usar ls sem nenhuma opção e/ou argumento voçê está dando um comando para o sistema executar a ferramenta ls. Ferramenta executa uma tarefa bem definida. O ls é usado para listar os arquivos e por mais que tenha opções que podemos usar, ele vai listar arquivos e ponto final. Ele é uma ferramenta.

O exemplo ls -lh | grep .mp3 usa ferramentas (ls, grep) , opções(-lh), argumentos(.mp3), e um operador, o querido pipe ” | “. Todos juntos formam um comando que o sistema executa.

Quando voçê digita ls -lh | grep .mp3 e tecla enter, é mais ou menos isso: “Execute todas as ferramentas, opções, argumentos e operadores na ordem em que estão” Então o intercodetador de comandos vai fazer o que voçê mandou.

É bom ter essa noção básica sobre a diferênça entre comandos e as ferramentas com suas opções e argumentos. Já um aplicativo podemos dizer que são os programas com interface gráfica, e que geralmnte fazem muitas coisas diferentes, como o nero ou k3b que fazem muito mais do que apenas gravar DCs e DVDs.