Anotação VIM atualizada (2019)


Anotação VIM atualizada

---

• Eu acho que se por acaso você aprender todas estas coisas deste post, você se tornará um Ninja do VIM! Eu tô na faixa branca tá sabendo?

  ---

  EDITOR de TEXTO VIM - COMANDOS E EXEMPLOS

  ---

• Depois de iniciar o vim, pressione F1 ou use :h no modo ex para inserir a ajuda on-line.
• Você pode ir para uma seção ou tópico específico colocando o cursor sobre ele e, em seguida, pressionando Ctrl+] (Ctrl e, em seguida, o colchete de fechamento).
• Depois de terminar, pressione Ctrl+t para retornar à tela anterior.

- Alternativamente, você pode procurar um assunto ou comando específico com :h .

Por exemplo:

:h x

---

• Os dois modos principais do Vim são: Modo de Comandos (Esc) e Modo de Inserção (i).

---

• O primeiro modo, é voltado para comandos e inicia por padrão junto com o vim. As teclas estão configuradas para servirem de atalhos a operações muito especiais, como movimentação do cursor, salvar e abrir arquivos, copiar e colar texto, fazer buscas por palavras-chave, etc.

---

• Se deseja digitar um texto, precisa acessar o Modo de Inserção e, para isso, usa-se a tecla de atalho i. Basta pressioná-la quando estiver no modo de comandos e, em seguida, iniciar ou modificar um arquivo de texto. Para retornar ao modo de comandos, use a tecla ESC.

---

• Caps Lock: Tudo o que você digita no vi possui um significado diferente quando as letras estão maiúsculas. Tenha cuidado em acioná-la sem querer. Você não recebe um aviso que está com o Caps ativado – simplesmente, as coisas irão funcionar de forma estranha.

---

• Ctrl+G: Se você esquecer-se do que está editando, ao pressionar estas teclas mostra o nome do arquivo que você está editando e a linha atual que você se encontra no final da tela, além de outras informações.

---

CRIAR E SALVAR ARQUIVO NO VIM

Se quiséssemos, por exemplo, criar um arquivo de texto chamado aprender-usar-vim.txt, cujo conteúdo seria a frase "Teste do tutorial", seguiríamos os seguintes passos:

1) no terminal, executaríamos o comando vim aprender-usar-vim.txt.

2) dentro do Vim, pressionaríamos a tecla i para passar do Modo de Comandos para o Modo de Inserção.

3)digitaríamos a frase "Teste do tutorial".

voltaríamos ao modo de comandos com a tecla ESC.

digitaríamos :wq, pressionando Enter logo em seguida. Esse comando (:wq) é utilizado para salvar (write) o arquivo e sair (quit) do Vim.

Tente repetir esses passos em seu computador.

---

OBS:

Importante se acostumar a entrar e sair da inserção de texto. ('i') inserção ('Esc') modo de comando.

• Para se movimentar no texto aperte a tecla ('Esc'): h j k l

i = insere texto
insert = insere texto
esc = sai de inserção de texto
:w = salva o texto
:q = sai do vim
:wq = sai do vim salvando o texto
:x! = alternativo sair salvando o texto
dd = exclui uma linha por completo
yy = copia uma linha por completo
p = cola a linha
v = copia parte do texto modo visual
u = Desfaz
Ctrl+R = refaz

---

Para quebrar linhas longas no vim acho que funciona usar:

:%norm! gww

---

vim comando para restruturar/forçar texto para 80 colunas. Comando:

:set textwidth=80

---

Mover para o início do arquivo. Pode ser feito com:

Ctrl+Home

gg

gqG.

---

No vim pode abrir dois arquivos de texto ao mesmo tempo.

:split /caminho/para/o/novo/texto

---

• Se quer abrir dois arquivos (teste1, teste2) horizontalmente abra o terminal onde estão os arquivos e execute:

vim -o teste1 teste2

Para abrir em janelas verticais:

vim -O teste1 teste2

---

• Você pode mudar o cursor de uma janela para outra com a rotina habitual de movimentos vi / m (h: direita, l: esquerda, j: inferior, k: superior)

Ctrl+w k – superior
Ctrl+w j – inferior
Ctrl+w l – esquerda
Ctrl+w h – direita

---

Talvez possa dividir textos horizontalmente com as teclas:

Ctrl+W S

Verticalmente:

Ctrl+W v

Para fechar uma delas:

Ctrl+W Q

Para mudar intuitivamente:

Ctrl+W J K H L

Ctrl+W seta para cima seta para baixo

---

• Para alterar textos no vim: Ctrl+W seta para cima, Ctrl+W seta para baixo.
• Pode copiar uma parte de um texto para o outro.
• Para sair de um dos textos usar Ctrl+w seta para cima ou para baixo depende do texto a ser fechado.

- Para sair do texto:
:q

- Para sair sem salvar:
:q!

- Pode executar comandos do Bash sem sair do vim. Exemplo:
:!ls -lC

- Comando que insere resultado de comando executado dentro do texto:
:.!uname -r = insere resultado dentro do texto atual.

- Para salvar e sair:
:wq

- Ou:
:zz

- Pode habilitar o número de cada linha:
:set number

- Para desabilitar o número de cada linha:
:set nonunber

- Habilitar sysntax higlight:
:syntax

- Para desabilitar syntax higlight:
:syntax off

---

• No vim certos procedimentos que levariam muito tempo para fazer em outros editores de texto, são executados pelo vim muito rapidamente. O vim foi criado mais ou menos na década de 60, mas creio que até hoje está em desenvolvimento. Quem consegue entrar na onda do vim, descobre depois de um tempo, poderes inimagináveis e não larga mais. Talvez um dia a gente chega lá. O mundo tá muito cheio de coisa e não dá para abraçar tudo, não é mesmo?

---

MOVENDO PELO ARQUIVO

Há diversos meios de mover-se pelo arquivo. Para estes exemplos, use arquivos grandes que você não poderá danificar. (Tente copiar /var/log/messages to/tmp e abra-o no vi).

Ctrl+F: página próxima, uma página por vez.

Ctrl+B: página anterior, uma página por vez.

Ctrl+D: página próxima, meia-página por vez.

Ctrl+U: página anterior, meia página por vez.

G: vá para a última linha do arquivo.

1G: vá para a primeira linha do arquivo. (Você poderá usar qualquer número – o número usado será a linha correspondente no arquivo).

---

BUSCANDO POR TEXTO

Para buscar a próxima ocorrência de texto no arquivo, use tanto a barra (/) ou o ponto de interrogação (?).
Exemplos:

/linux: procura (sentido horário) pela palavra linux.

?computadores: Procura (sentido anti-horário) pela palavra computadores.

/Rubber.*Soul: procura (sentido horário) por uma linha que possua a palavra Rubber e, após isso, em algum lugar, a palavra Soul.

?[bB]eatles: procura (sentido anti-horário) por beatles ou Beatles.

O editor vi foi originalmente baseado no editor ex, que não lhe deixa trabalhar no modo de tela cheia. No entanto, lhe permite rodar comandos que o permitam encontrar e mudar texto em uma ou mais linhas por vez. Segue abaixo alguns exemplos de comandos ex para a busca e mudanças no texto:

:g/Natal: procura pela palavra Natal e mostra cada ocorrência daquela linha no arquivo.

:s/Natal/Natalino: substitui Natalino pela palavra Natal na linha atual.

:g/Natal/s//Natalino: substitui a primeira ocorrência da palavra Natal em cada linha do arquivo com a palavra Natalino.

:g/Natal/s//Natalino/g: substitui cada ocorrência da palavra Natal com a palavra Natalino no arquivo inteiro.

:g/Natal/s//Natalino/gp: substitui cada ocorrência da palavra Natal pela palavra Natalino no arquivo inteiro, e depois mostra cada linha para que você veja as mudanças.

---

USANDO NÚMEROS COM COMANDOS

Você pode preceder muitos comandos vi com números, para ter o comando repetido tantas vezes. Alguns exemplos:

3dw: deleta as próximas três palavras.

12j: Move 12 linhas para baixo.

• Observação: quando você chama o vi em muitos sistemas Linux, você está na verdade chamando o editor de texto vim, que roda no modo de compatibilidade do vi. Os mais aficionados em programação preferem usar o vim, porque mostra diferentes níveis de código em cores distintas, além de possuir outros recursos interessantes, como a capacidade de abrir um documento com o cursor no mesmo lugar que estava na última vez que você saiu.

---

• Alterar letras, palavras ou linhas inteiras para MAIÚSCULAS ou minúsculas:

Para alterar uma série de letras para maiúsculas, posicione o cursor na primeira letra, digite gUX no modo execução e, finalmente, pressione a seta para a direita no teclado.

Para alterar o número X de palavras, coloque o cursor no início da palavra e digite gUXw no modo execução.

Para alterar uma linha inteira para maiúscula, coloque o cursor em qualquer lugar na linha e digite gUU no modo execução.

---

• Exclua caracteres, palavras ou o início de uma linha no modo INSERIR.

Embora você possa excluir caracteres ou várias palavras de uma vez no modo ex (ou seja, dw para excluir uma palavra), você também pode fazê-lo no modo Inserir:

Ctrl + h: exclui o caractere anterior para o local onde o cursor está localizado no momento.

Ctrl + w: apaga a palavra anterior para o local onde o cursor está localizado no momento.

Para que isso funcione corretamente, o cursor deve ser colocado em um espaço vazio após a palavra que você precisa excluir.

Ctrl + u: apaga a linha atual começando pelo caractere imediatamente à esquerda do lugar onde o cursor está.

---

• Contar correspondências resultantes de uma pesquisa por padrão e passar de uma ocorrência para outra.

Esta dica é baseada no comando substituto, com a exceção de que não removerá nada, já que o comportamento substituto é substituído pela opção n, resultando na contagem de ocorrências do padrão especificado: Certifique-se de não omitir nenhuma das as barras para frente.

:%s/pattern//gn

Exemplo:

:%s/liberto//gn

---

SALTAR PARA FRENTE DE PARA TRÁS USANDO MARKS

Se você estiver editando um arquivo maior que uma tela, você apreciará a funcionalidade fornecida pelas marcas.

Você pode pensar em uma marca no vim como um marcador - uma vez que você a coloca em algum lugar, você pode voltar rapidamente e facilmente.

Suponha que você esteja editando um arquivo de configuração de 300 palavras e, por algum motivo, precise alternar repetidamente entre as linhas 30 e 150, por exemplo.

para criar uma marca chamada 'a' na linha 30. Em seguida, vá para a linha 250 (com: 250 no modo ex) e pressione `a (crase, a) para retornar para marcar a na linha 30.

Você pode usar letras maiúsculas e minúsculas para identificar marcas no vim (agora repita o processo para criar uma marca chamada A na linha # 250). Você pode ver suas marcas com

:marks aA

---

• Inserindo caracteres Unicode especiais. Se o layout do seu teclado não permitir a inserção fácil de caracteres Unicode especiais em um arquivo, ou se você se encontrar na frente de um servidor com configurações de idioma diferentes daquele que está acostumado, esse truque será útil. Para fazer isso, pressione Ctrl + v no modo de inserção seguido da letra u e do código numérico hexadecimal do caractere que você deseja inserir. Você pode verificar os gráficos Unicode para obter uma lista de caracteres especiais e seus códigos numéricos correspondentes

Exemplos:

Ctrl+v followed by returns
u0040 @
u00B5 μ
u20AC €

---

• Buscar e substituir:

:%s/old/new/g

- Então, o que você quer ser solicitado antes de fazer substituições? Fácil. Basta adicionar um c no final do comando acima, da seguinte maneira:

:%s/old/new/gc

---

Anotação VIM

EDITOR de TEXTO VIM - Comandos e Exemplos

---

Os dois modos principais do Vim são: Modo de Comandos (tecla Esc) e Modo de Inserção (tecla i).

---

O primeiro modo, é voltado para comandos e inicia por padrão junto com o vim. As teclas estão configuradas para servirem de atalhos a operações muito especiais, como movimentação do cursor, salvar e abrir arquivos, copiar e colar texto, fazer buscas por palavras-chave, etc.

Se deseja digitar um texto, precisa acessar o Modo de Inserção e, para isso, usa-se a tecla de atalho i. Basta pressioná-la quando estiver no modo de comandos e, em seguida, iniciar ou modificar um arquivo de texto. Para retornar ao modo de comandos, use a tecla ESC.

Caps Lock: Tudo o que você digita no vi possui um significado diferente quando as letras estão maiúsculas. Tenha cuidado em acioná-la sem querer. Você não recebe um aviso que está com o Caps ativado – simplesmente, as coisas irão funcionar de forma estranha.

Ctrl+G: Se você esquecer-se do que está editando, ao pressionar estas teclas mostra o nome do arquivo que você está editando e a linha atual que você se encontra no final da tela, além de outras informações.

---

CRIAR E SALVAR ARQUIVO NO VIM

Se quiséssemos, por exemplo, criar um arquivo de texto chamado aprender-usar-vim.txt, cujo conteúdo seria a frase "Teste do tutorial", seguiríamos os seguintes passos:

1) no terminal, executaríamos o comando vim aprender-usar-vim.txt.

2) dentro do Vim, pressionaríamos a tecla i para passar do Modo de Comandos para o Modo de Inserção.

3)digitaríamos a frase "Teste do tutorial".

voltaríamos ao modo de comandos com a tecla ESC.

digitaríamos :wq, pressionando Enter logo em seguida. Esse comando (:wq) é utilizado para salvar (write) o arquivo e sair (quit) do Vim.

Tente repetir esses passos em seu computador.

---

OBS:
Importante se acostumar a entrar e sair da inserção de texto (i) inserção e de (Esc) modo de comando ou execução. Podem ser chamados de modo ex e modo i.

i = insere texto
insert = insere texto
esc = sai de inserção de texto
:w = salva o texto
:q = sai do vim
:wq = sai do vim salvando o texto
:x! = alternativo sair salvando o texto
dd = exclui uma linha por completo
yy = copia uma linha por completo
p = cola a linha
v = copia parte do texto modo visual
u = Desfaz
Ctrl+R = refaz

No vim pode abrir dois arquivos de texto ao mesmo tempo.
:split /caminho/para/o/novo/texto

Para alterar textos no vim: Ctrl+W seta para cima, Ctrl+W seta para baixo.

Pode copiar uma parte de um texto para o outro.

Para sair de um dos textos usar Ctrl+w seta para cima ou para baixo depende do texto a ser fechado.

Para sair do texto:
:q

Para sair sem salvar:
:q!

Pode executar comandos do Bash sem sair do vim. Exemplo:
:!ls -lC

Comando que insere resultado de comando executado dentro do texto:
:.!uname -r = insere resultado dentro do texto atual.

Para salvar e sair:
:wq

Ou:
:zz

Pode habilitar o número de cada linha:
:set number

Para desabilitar o número de cada linha:
:set nonunber

Habilitar sysntax higlight:
:syntax

Para desabilitar syntax higlight:
:syntax off

---

No vim certos procedimentos que levariam muito tempo para fazer em outros editores de texto, são executados pelo vim muito rapidamente. O vim foi criado mais ou menos na década de 60, mas creio que até hoje está em desenvolvimento. Quem consegue entrar na onda do vim, descobre depois de um tempo, poderes inimagináveis e não larga mais. Talvez um dia a gente chega lá. O mundo tá muito cheio de coisa e não dá para abraçar tudo, não é mesmo?

---

MOVENDO PELO ARQUIVO

Há diversos meios de mover-se pelo arquivo. Para estes exemplos, use arquivos grandes que você não poderá danificar. (Tente copiar /var/log/messages to/tmp e abra-o no vi).

Ctrl+F: página próxima, uma página por vez.

Ctrl+B: página anterior, uma página por vez.

Ctrl+D: página próxima, meia-página por vez.

Ctrl+U: página anterior, meia página por vez.

G: vá para a última linha do arquivo.

1G: vá para a primeira linha do arquivo. (Você poderá usar qualquer número – o número usado será a linha correspondente no arquivo).

---

BUSCANDO POR TEXTO

Para buscar a próxima ocorrência de texto no arquivo, use tanto a barra (/) ou o ponto de interrogação (?).
Exemplos:

/linux: procura (sentido horário) pela palavra linux.

?computadores: Procura (sentido anti-horário) pela palavra computadores.

/Rubber.*Soul: procura (sentido horário) por uma linha que possua a palavra Rubber e, após isso, em algum lugar, a palavra Soul.

?[bB]eatles: procura (sentido anti-horário) por beatles ou Beatles.

O editor vi foi originalmente baseado no editor ex, que não lhe deixa trabalhar no modo de tela cheia. No entanto, lhe permite rodar comandos que o permitam encontrar e mudar texto em uma ou mais linhas por vez. Segue abaixo alguns exemplos de comandos ex para a busca e mudanças no texto:

:g/Natal: procura pela palavra Natal e mostra cada ocorrência daquela linha no arquivo.

:s/Natal/Natalino: substitui Natalino pela palavra Natal na linha atual.

:g/Natal/s//Natalino: substitui a primeira ocorrência da palavra Natal em cada linha do arquivo com a palavra Natalino.

:g/Natal/s//Natalino/g: substitui cada ocorrência da palavra Natal com a palavra Natalino no arquivo inteiro.

:g/Natal/s//Natalino/gp: substitui cada ocorrência da palavra Natal pela palavra Natalino no arquivo inteiro, e depois mostra cada linha para que você veja as mudanças.

---

USANDO NÚMEROS COM COMANDOS

Você pode preceder muitos comandos vi com números, para ter o comando repetido tantas vezes. Alguns exemplos:

3dw: deleta as próximas três palavras.

12j: Move 12 linhas para baixo.

Observação: quando você chama o vi em muitos sistemas Linux, você está na verdade chamando o editor de texto vim, que roda no modo de compatibilidade do vi. Os mais aficionados em programação preferem usar o vim, porque mostra diferentes níveis de código em cores distintas, além de possuir outros recursos interessantes, como a capacidade de abrir um documento com o cursor no mesmo lugar que estava na última vez que você saiu.

---

Linux script renomear arquivo

—

Este shell script pode ser usado para renomear arquivos. Se colocar ele em ~/bin, adicionar o PATH ao .bashrc e depois criar um alias para o script; pode usar pelo terminal em quase qualquer coisa e lugar. Bem simples, ajuda e me diverte.

#!/bin/bash

# Nome: renamefile.sh
# Execução: ./renamefile.sh
# Renomeia um arquivo.

clear

echo ':: Renomear arquivo...'

sleep 3

echo

echo ':: Digite o nome do arquivo:'

read RENAME

echo ":: O nome do arquivo a ser alterado é: '$RENAME'"

sleep 3

echo

echo ':: Digite o novo nome para o arquivo:'

read NEWNAME

echo ":: O novo nome do arquivo a ser alterado será: '$NEWNAME'"

sleep 3

echo

echo ":: Renomeando..."

sleep 2

echo

## OBS:
#
# Cada variavel é abraçada por chaves. A esquerda adiciona-se um cifrão. Por fim, aspas duplas abraçam cada uma das variáveis. O -i pede confirmação antes de alterar. O comando mv renomeia.
#######

mv -i "${RENAME}" "${NEWNAME}"

echo ":: Confira a alteração..."

sleep 2

echo

ls -t --color=auto

# Fim do Script

—

Até Breve

🙂

.

Linux – script educado que informa hora

.

#!/bin/bash

# Nome do Script: 6Educado_Horario.sh
# Descrição:
# Execução: sh 6Educado_Horario.sh
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:
# Comentário:

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção

HORA=$(date +%H)

#HORA=$1 # Variável para teste, modo de desenvolvimento.

MIN=$(date +%M)

# Considero que das 00:00 às 06:00 é noite

# Case para definir período bom dia, b. tarde e b. noite

echo
case $HORA in

0[6-9] | 1[01])
echo
echo "Bom Dia!"
;;

1[2-7])
echo
echo "Boa Tarde!"
;;

*)
echo "Boa Noite!"
;;
esac

# If que reduz a hora e define AMPM

if [ $HORA -ge 12 ]
then

AMPM=PM

if [ $HORA -ne 12 ]
then

HORA=$(expr $HORA - 12)
fi

else

AMPM=AM
fi

echo "A hora atual é: $HORA:$MIN $AMPM"
echo

.

Até Breve!

Linux – File GlobbinG x REGEX

Linux - File Globbing x REGEX

.

REGEX = Regular Expression (expressão regular)

.

File Globbing = Uma forma que o bash (shell) tem de selecionar arquivos de diretórios na interface. Usa caracteres especiais, o asterisco, as chaves, colchetes, interrogação para ajudar o usuário a selecionar os arquivos e diretórios que desejar.

.

O REGEX vai usar o mesmos caracteres mas se forma diferente, com intenção diferente. A intenção é selecionar um "PADRÃO DE TEXTO".

.

FILE GLOBBING = SELECIONAR OS ARQUIVOS E DIRETÓRIOS

.

REGEX = SELECIONAR UM "PADRÃO DE TEXTO" DESEJADO

.

EXEMPLO FILE GLOBBING (Executo):

.

0)

mkdir -v test ; cd test/ ; touch NOME-DO-ARQ.txt nome-do-arquivo1.txt nome-do-arquivo2.txt NOME-DO-ARQUIVO1.txt NOME-DO-ARQUIVO2.txt Arquivo11.txt Arquivo12.txt ARQUIVO11.txt ARQUIVO12.txt arquivo1.txt arquivo2.txt arquivo3.txt arquivo4.txt arquivo5.txt Arquivo5.txt Arquivo1.txt Arquivo4.txt Arquivo3.txt Arquivo10.txt Arquivo9.txt Arquivo11.txt

1)

ls nome-do-arquivo*

2)

ls -l NOME-DO-ARQUIVO*

3)

ls -lit nome-do-arquivo1*

4)

ls -latr Arquivo[12345].txt

5)

ls -la arquivo[1-5].txt

6)

ls -l Arquivo* [Aa][12]

7)

ls -la Arquivo *[12]

8)

ls -la {Arquivo,arquivo}[12].txt

9)

ls -l *11.txt

10)

ls -l {Arquivo,ARQUIVO}11.txt

11)

ls -l {Arquivo,ARQUIVO}3.txt

12)

ls -l Arquivo1*

13)

ls -l Arquivo1?

14)

ls -l Arquivo?.txt

15)

ls -l Arquivo??.txt

.

EXEMPLO Expressão Regular (Executo):

Expressões regulares são criadas a partir de metacaracteres. Sendo eles:

--------------------

\ . * + - { } [ ] ^ $ | ? ( ) : ! = \b | \1

--------------------

Metacaracteres podem, dependendo do caso, ter mais de um significado de acordo com o contexto.

--------------------

Aspa " não é metacaractere.

--------------------

Para criar comandos usando expressões regulares, posso usar um arquivo de texto. O arquivo de texto serve para eu aprender a criar comandos usando expressões regulares. Posso criar comandos usando expressões regulares imaginando também.

--------------------

Se eu quero criar comandos usando expressões regulares preciso usar metacaracteres.

--------------------

Lista de metacaracteres para eu consultar:

--------------------
. ponto
[] lista
[^] lista negada
? opcional
* asterisco
+ mais
{} chaves
^ circunflexo
$ cifrão
\b borda
\ escape
| ou
() grupo
\1 retrovisor
--------------------

Os metacaracteres e suas funções estão divididos em quatro grupos distintos:

--------------------

1) Representantes
2) Quantificadores
3) Âncoras
4) Outros

--------------------
--------------------

1) Representantes

--------------------
--------------------

.

(ponto - um caractere qualquer)

Ex.:

cd

pwd

ls .

ls -li | grep ".ocumentos"

ls -li | grep ".odelos"

ls -li | grep "."

--------------------

[...]

(lista - lista de caracteres permitidos)

Ex.:

ls | grep [D]

(ls liste o que tiver D maiúsculo)

ls -t | grep [D-I]

--------------------

[^...]

(lista negada - lista de caracteres proibidos)

ls | grep [^D]

ls -t | grep [^D-I]

--------------------
--------------------

2) Quantificadores

--------------------
--------------------

?

(opcional - zero ou um)

Ex.:

ls -li | grep [M?]

ls -li | grep [D?]

--------------------

*

(asterisco - zero, um ou mais)

Ex.:

ls -li | grep [M*]

ls -li | grep [V*]

ls | grep -F '*.' *

--------------------

+

(mais - um ou mais)

Ex.:

ls -li | grep [M+]

ls -li | grep [V+]

--------------------

{n,m}

(chaves - de n até m)

ls -t | grep {D,}

ls -t | grep {M,}

--------------------
--------------------

3) Âncoras

--------------------
--------------------

^

(circunflexo - início da linha)

Ex.:

ls -t | grep {^D,}

--------------------

$

(cifrão - fim da linha)

Ex.:

ls -t | grep "$o"

--------------------

\b

(borda - início ou fim de palavra)

Ex.:

ls -li | grep [\bs]

ls -li | grep [\bV+]

--------------------

4) Outros

\c

(escape - torna literal o caractere c)

ls -li | grep [\c,M+]

ls -li | grep [\cV+]

--------------------

(...)

(ou - ou um ou outro)

ls -li | grep ...

ls -li | egrep 'Downloads|Modelos'

(ls liste exibindo ou Downloads ou Modelos)

--------------------

\1...\9

(retrovisor - texto casado nos grupos 1...9)

ls -li | grep \1...\9

--------------------

OBS:
Curingas usados em linha de comando, não são expressões regulares.

--------------------

Creio que a expressão regular abaixo é para validação de e-mails:

^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$

--------------------

Regex ------- Referências

[abc] ------- Um único caractere: a, b, OU c

[^abc] ------- Qualquer caractere exeto/menos: a, b, OU c

[a-z] ------- Qualquer caractere de a até z

[a-zA-Z] ------- Qualquer caractere de a-z OU A-Z

^ ------- Começo da linha

$ ------- Fim da linha

\A ------- Começo da string

\z ------- Fim da string

. ------- Qualquer caractere

\s ------- Qualquer espaço em branco

\S ------- Qualquer espaço não em branco

\d ------- Qualquer digito

\D ------- Qualquer não digito

\w ------- Qualquer palavra (letra, numero, underscore)

\W ------- Qualquer caractere que não seja palavra

\b ------- Borda

(...) ------- Captura o que estiver dentro. Pode conter outros grupos

(a|b) ------- a OU b

a? ------- Zero ou um a

a* ------- Zero ou mais a

a+ ------- Um ou mais a

a{3} ------- Exatamente 3 a

a{3,} ------- 3 ou mais a

a{3,6} ------- Ente 3 a 6 a

--------------------

Quem constrói uma casa com tijolos gratúitos e depois ganha dinheiro para si próprio de maneira ambiciosa e egoísta, é boa gente?

--------------------

Executo:

read -p "Informe um valor que será inserido em VAR1: " VAR1

read -p "Informe um valor que será inserido em VAR2: " VAR2

--------------------

OBS:
# $(expr $VAR1 + $VAR2) É uma substituição de comando que executa e joga o resultado na tela.

--------------------

Executo:

echo "A soma de $VAR1 + $VAR2 é $(expr $VAR1 + $VAR2)"

--------------------

Exemplos de scripts a serem executados:

--------------------

#!/bin/bash

# Nome do Script: 3Script-relatorio-da-maquina.sh
# Descrição:
# Execução: sh 3Script-relatorio-da-maquina.sh
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:
# Comentário:

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção
#
# Primeiro definir as variáveis
# 8 Variáveis

KERNEL=$(uname -r)

HOSTNAME=$(hostname)

CPUNO=$(cat /proc/cpuinfo | grep "model name" | wc -l)

CPUMODEL=$(cat /proc/cpuinfo | grep "model name" |
head -n1 | cut -c14-)

# Acima cat /proc/cpuinfo mostra um monte de informação. Só quero uma linha de
# informação.
# Filtro usando pipe grep e o que tem no início da string "model name".
# Ainda aparecem 4 strings.
# Uso mais um pipe e o comando head -n1 aparece só uma
# linha. Mas...
# Uma parte desta única string não quero que apareça.
# Uso pipe e o comando cut -c14- para sumir com 14
# caracteres iniciais da
# string.

MEMTOTAL=$(free -h | grep 'Mem:' | cut -d: -f2)

MEMTOTAL2=$(expr $(cat /proc/meminfo | grep MemTotal | tr -d ' ' | cut -d: -f2 | tr -d kB) / 1024)

FILESYS=$(df -h | egrep -v '(tmpfs | udev)')

UPTIME=$(uptime -s)

# Noto que algumas variáveis são bem conhecidas
# mas outras são comandos criados a partir de
# expressões regulares.

# Para fazer um shell script funcionar criamos
# comandos via expressões regulares, colocamos
# eles dentro de variáveis. A variável só aceita
# um valor! Uma expressão regular é um só valor
# composto de quantos comandos a pessoa quiser.

# Este é o segredo da necessidade de aprender
# expressões regulares. Aprenda muito bem, para
# poder criar ótimos shell scripts.

clear
echo
echo '=============================='
echo "Relatório da Máquina: $HOSTNAME"
echo "Data/Hora: $(date)"
echo '=============================='
echo
echo "Ativa desde: $UPTIME"
echo
echo "Kernel: $KERNEL"
echo
echo "CPUs:"
echo "$CPUNO"
echo
echo "Modelo da(s) CPU(s): $CPUMODEL"
echo
echo "Memória Total: $MEMTOTAL"
echo
echo "$MEMTOTAL2"
echo
echo "Partições:"
echo
echo "$FILESYS"
echo
echo
echo 'Fim do Script'
echo
echo
# Fim do Script

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh 3Script-relatorio-da-maquina.sh

-----------------

OUTRO SHELL SCRIPT ESCRITO DIFERENTE MAS SOBRE O MESMO ASSUNTO:

-----------------

#!/bin/bash

# Nome do Script: RelatInfo.sh
# Descrição: Script que gera um relatório de algumas informações da máquina atual
# Execução: ./RelatInfo.sh
# Autor: Fulana de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail1@mail.com
# Histórico de modificações:
# Comentário:
# COMENTÁRIOS ESPECIAIS:
# TODO - indica uma tarefa a ser feita - Info Sist
# FIXME - indica um bug conhecido que precisa ser arrumado - strings duplicadas, uso de variáveis
# XXX - Notícia, chama a atenção. Para remover linhas duplicadas em uma expressão regular:
# Procuro por: find and remove duplicate strings via unix shell script
# awk '!_[$1]++' nome_do_arquivo.txt (a expressão _[$1]++ incrementa o valor do elemento de array com index $1 por um desde que ++ venha depois)

echo ""
echo "== Relatório de Informações da Máquina =="
echo ""
echo 'Dia:'
date
echo ""
echo 'Nome da Máquina:'
hostname
echo ""
echo 'Máquina Ativa desde:'
uptime -s
echo ""
echo
echo 'Versão Distro:'
cat /proc/version
echo
echo 'Usuario:'
whoami
echo
echo 'Versão do Kernel:'
uname -r
echo ""
lscpu | grep 'CPU(s):'
echo ""
lscpu | grep 'Nome do modelo:'
echo ""
echo 'Partições:'
df -kh
echo ""
lscpu | grep 'Arquitetura:'
echo ""
lscpu | grep 'Modo(s) operacional da CPU:'
echo ""
echo 'Relatório de BUGS (nCPUs):' ; cat /proc/cpuinfo | grep 'bugs' | awk '!_[$1]++'
echo ""
echo 'Identidade do vendedor:'
cat /proc/cpuinfo | grep 'vendor_id' | head -n1 | cut -c12-
echo ""
echo 'Memória total (MB):'
expr $(cat /proc/meminfo | grep MemTotal | tr -d ' ' | cut -d: -f2 | tr -d kB) / 1024
echo
echo 'Fim do Script'
echo ""
# Fim do Script

--------------------------

Linux – aprenda a usar o comando case

Linux - aprenda a usar o comando case

.

Creio que o comando “case” (instrução condicional case) é usado para executar um bloco de código de acordo com o valor de uma variável.

O comando “case” me chama a atenção pois, pode definir diversas opções diferentes sem usar uma estrutura com diversos comandos “if”, “elif” e “else”.

Então devo tentar aprender o uso da instrução case.

Quais serão os: conceitos, sintaxe e prática do case?

---------------

Case é para quando tenho um valor (variável) e vários padrões possíveis para este valor ou vários valores possíveis para uma variável.

Usa-se o case para evitar ficar usando muito o if, else, elif.

O padrão pode ser uma string (corda), número, expressão regular

---------------

Depois do case vem uma variável e depois a palavra in, então vem o padrão. Atendendo o padrão, pode ser realizado uma série de comandos e depois dos comandos fecha com ;; finalizando cada padrão. No final de tudo mesmo, usa-se o asterisco (é como se fosse um else) que é executado se nenhum dos padrões definidos foram encontrados. O fechamento do case é esac (case ao contrário)

---------------

A estrutura do comando case no shell script, serve como se fosse um selector onde eu escolho qual opção desejo para prosseguir.

Digo que estou em um lugar que pede pra fazer certas escolhas. Opção 1 , opção 2 , opção 3...

Cada uma dessas opções irá me levar a um outro lugar ou executa uma determinada ação.

O case é assim. Cria uma lista de opções e eu escolho a opção desejada.

---------------

EXEMPLO:

---------------

case $VARIAVEL in
padrão1)
comandos
;;
padrão2)
comandos
;;
*)
comandos
;;
esac

---------------

USA-SE MUITO O CASE PARA FAZER MENÚ.

---------------

EXEMPLO:

---------------

case $opcao in
1)
echo "Opção Incluir"
;;
2)
echo "Opção Remover"
;;
*)
echo "Opção Inexistente"
;;
esac

---------------

Case - usando expressão regular

---------------

case $caractere in
[0-9])
echo "O caractere informado é um número"
;;
[A-Z])
echo "O caractere informado é uma letra maiúscula"
;;
[a-z])
echo "O caractere informado é uma letra minúscula"
;;
esac

---------------

Executo:

---------------

mkdir -vp caseDIR/subCASE

cd caseDIR/subCASE

touch CasE_scr.sh

chmod +x CasE_scr.sh

pwd

ls -lih

vi CasE_scr.sh

(Aperto Esc, digito i, copio e colo o texto abaixo com o mouse no vi.)

#!/bin/bash

case "$1" in #Uso o parâmetro cifrão 1
[0-9]) #Se for de 0 a 9
echo "O parâmetro é um número"
;;
[A-Z]) #Se for de A a Z
echo "O parâmetro é uma letra maiúscula"
;;
[a-z]) #Se for de a A z
echo "O parâmetro é uma letra minúscula"
;;
*) #Se não for nenhum dos parâmtros acima...
echo "O parâmetro é um caractere especial"
esac

---------------

(Aperto Esc, seguro Shift e digito ZZ)

---------------

Executo:

./CasE_scr.sh

sh CasE_scr.sh A

source CasE_scr.sh a

bash CasE_scr.sh 3

sh CasE_scr.sh @

.

Até Breve

🙂

.

Linux aprenda a usar if, then, else e fi

-----------------------

Linux - Aprenda a usar if, then, else e fi

-----------------------

No GNU/Linux "instruções condicionais" são instruções utilizadas para a "execução condicional" de comandos.

GNU/Linux - Instruções condicionais: Instruções usadas em shell script para executar uma serie de comandos com base em uma condição.

ENTÃO:

Se acontece ISTO uma série de comandos é executada. Se não acontece ISTO, uma OUTRA série de comandos é executada.

Caso aconteça ISTO uma série de comandos é executada. Caso não aconteça ISTO, outra série de comandos é executada.

-----------------------

No shell script para fazer "ISTO", usa-se:

1) if
2) case

-----------------------

Primeira sintaxe - if:

-----------------------

if #começa com "if" mais um "comando-condição" e se for verdadeiro...

then #Então
comando1 #Execute este comando ou esta lista de comandos.
comando2
comando3

fi #Fecha a instrução condicional usando o if ao contrário

-----------------------

Segunda sintaxe - if:

if #Se isto for verdadeiro

then # Então
comando1 #Verdadeiro este comando é executado

else # Se não...
comando2 #Este outro comando é executado

fi #Fecha a instrução condicional o if ao contrário

-----------------------

Terceira sintaxe - if:

-----------------------

Exemplo1:

-----------------------

if #Se isto for verdadeiro
then # Então
comando1 #Execute este comando ou lista de comandos

elif #elif = else if, se não, se acontecer isto...
then #Então
comando2 #Execute este outro comando

else #Se não for verdadeiro...
comando3 #Execute então este outro comando
fi

-----------------------

Exemplo2:

-----------------------

A terceira sintaxe é ou já foi usada dentro dos scripts de inicialização do GNU/Linux. A forma comum acho que é (era):

-----------------------

if [ condição ];
then
comando-instrução1;
comando-instrução2;
comando-instrução3;

...
elif [ condição ];
comando-instrução4;
comando-instrução5;
comando-instrução6;

...
else
comando-instrução7;
comando-instrução8;
comando-instrução9;

...
fi.

-----------------------

Exemplo3:

-----------------------

if [ condição ];

then

comando-instrução1

elif [ condição ];

then

comando-instrução1

else

comando-instrução2

fi

-----------------------

OBS:
O if do shell script tem um comando e verifica se o comando foi executado com sucesso ele cai como verdadeiro tendo código de retorno zero. Se for falso (maior que zero), cai no else ou sai do if.

-----------------------

Tem um comando que faz uma condição. O comando test. O comando test é usado para criar uma condição. A sintaxe é:

test

-----------------------

O comando test tem várias expressões. As mais usadas são do um ao 6.

-----------------------

-eq (equal), -ne (not equal), -gt (greater than), -ge (greater equal), -lt (lower than), -le (lower equal)

-----------------------

1) -eq - é igual a - if [ "$a" -eq "$b" ]

2) -ne - é diferente - if [ "$a" -ne "$b" ]

3) -gt - é maior que - if [ "$a" -gt "$b" ]

4) -ge - é maior ou igual que - if [ "$a" -ge "$b" ]

5) -lt - é menos que - if [ "$a" -lt "$b" ]

6) -le - é menos que ou igual que - if [ "$a" -le "$b" ]

7) < - é menos que - (("$a" = - é maior ou igual que - (("$a" >= "$b"))

-----------------------

Strings podem ser comparadas:

1) = (Uma string igual a outra)

2) != (Uma string diferente da outra)

3) -n (String não nula)

4) -Z (String nula)

-----------------------

Arquivos podem ser testados:

1) -f (É um arquivo)

2) -d (É um diretório/pasta)

3) -r (Tem permissão de leitura)

4) -W (Tem permissão de escrita)

5) -X (Tem permissão de execução)

6) -S (Possui tamanho maior que zero)

-----------------------

EXEMPLOS:

-----------------------

test 25 -gt 50

(25 é maior que 50? Não. O código de saída será 1.)

test "$VALOR1" -eq 15

(O valor da variável VALOR1 é igual a 12? Se for o exit code será zero.)

test -f /tmp/testes

(O arquivo tmp/testes existe? Se existir o exit code será zero. Se não existir será 1)

test "$VALOR1" = "$VALOR2"

(A corda da variável VALOR1 é igual a string da variável VALOR2?)

-----------------------

OBS-IMPORTANTE:

EM VEZ DE ESCREVER A PALAVRA TEST USA-SE COLCHETES COM ESPAÇO

-----------------------

EXEMPLOS:

-----------------------

[ 25 -gt 50 ]

(25 é maior que 50? Não. O código de saída será 1.)

[ "$VALOR1" -eq 15 ]

(O valor da variável VALOR1 é igual a 12? Se for o exit code será zero.)

[ -f /tmp/testes ]

(O arquivo tmp/testes existe? Se existir o exit code será zero. Se não existir será 1)

[ "$VALOR1" = "$VALOR2" ]

(A corda da variável VALOR1 é igual a string da variável VALOR2?)

-----------------------

A FORMA MAIS USADA É COM COLCHETES E ESPAÇO.

-----------------------

OUTRO EXEMPLO:

-----------------------

VALOR1=15
if [ ! "$$VALOR1" -gt 12 ]

# (Negação "!" inverte não entra no fluxo)

# (É dado como falso não entra em lugar nenhum.)

then
echo sucesso
fi

-----------------------

MAIS UM EXEMPLO:

-----------------------

VALOR1=15

if [ "$VALOR1" -gt 12 -a "VALOR1" -lt 20 ]

#AND (-a) se tudo separado pelo -a for verdade terá sucesso se não for não entra em lugar nenhum.

then
echo sucesso
fi

-----------------------

EXEMPLO OR:

-----------------------

VALOR1=15

if [ "$VALOR1" -gt 12 -o "VALOR1" -lt 20 ]

#OR (-o) se pelo menos uma situação for verdade terá sucesso. Se as duas forem falsas, não entra em lugar nenhum.

then
echo sucesso
fi

-----------------------

O -a TEM PREFERÊNCIA SOBRE O -o

-----------------------

Linux - aprendendo a usar o comando test:

-----------------------

Comando de retorno usando test (zero "0" é verdadeiro, um "1" é falso)

-----------------------

Abro o terminal pelo menu do sistema e executo:

-----------------------

1)

test 10 -gt 5 (é maior que)
echo $?

[ 10 -gt 5 ]
echo $?

2)

test 15 -eq 12 (é igual a)
echo $?

[ 15 -eq 12 ]
echo $?

3)

test 8 -ne 12 (é diferente)

echo $?

[ 8 -ne 12 ]
echo $?

4)

test 25 -ge 15 (é maior ou igual que)
echo $?

[ 25 -ge 15 ]
echo $?

5)

test 35 -lt 25 (é menos que)

echo $?

[ 35 -lt 25 ]
echo $?

6)

test 8 -le 10 (é menos que ou igual que)

echo $?

[ 8 -le 10 ]
echo $?

7)

VALOR1=101

8)

test $VALOR1 -eq 101

echo $?

[ $VALOR1 -eq 101 ]
echo $?

9)

test $VALOR1 -gt 90
echo $?

[ $VALOR1 -gt 90 ]
echo $?

10)

test $VALOR1 -ne 15
echo $?

[ $VALOR1 -ne 15 ]
echo $?

-----------------------

Executo:

mkdir -vp PastaIF/SubIF

cd PastaIF/SubIF

touch IfExemp.sh

chmod +x IfExemp.sh

ls -li

pwd

vi IfExemp.sh

(Aperto Esc, digito i, copio e colo o texto abaixo no vi com o mouse.)

#!/bin/bash

if grep "$1" /etc/passwd > /dev/null

# uso o parâmetro cifrão 1

then
echo "Este user existe"
else
echo "Este user não existe"
fi

# Fim do script

----------------------

Aperto Esc, digito Shift ZZ

----------------------

Executo:

whoami

./IfExemp.sh meu-usuário-whoami

./IfExemp.sh Jocam

./IfExemp.sh AnaCa

./IfExemp.sh

----------------------

OUTRO EXEMPLO CRIANDO UMA VARIÁVEL:

----------------------

#!/bin/bash

# Declarando variável: USUWARRIO

USUWARRIO=$(grep "$1" /etc/passwd) #OBS: uso o parâmetro cifrão 1

#OBS: test -n é para ver se uma varivel não é nula

if test -n "$USUWARRIO" #OBS: Colocar a variável entre aspa

then #OBS: se a variável não for nula cai no them
echo "Este user existe"
else
echo "Este user não existe"
fi

# Fim do script

----------------------

POSSO USAR O TEST SINTAXE COLCHETES:

----------------------

#!/bin/bash

# Declarando variável: USUWARRIO

USUWARRIO=$(grep "$1" /etc/passwd)

#OBS-1: uso o parâmetro cifrão 1 entre aspas
#OBS-2: test -n é para ver se uma varivel não é nula
#OBS-3: Colocar a variável entre aspa
#OBS-4: se a variável não for nula cai no then

if [ -n "$USUWARRIO" ]
then
echo "Este user existe"
else
echo "Este user não existe"
fi

# Fim do script

----------------------

PARA EXECUTAR O SCRIPT:

----------------------

touch 2IfExemp.sh

chmod +x 2IfExemp.sh

vi 2IfExemp.sh

(Aperto Esc, digito i, copio e colo o texto no vi com o mouse.)

----------------------

Aperto Esc, Seguro a tecla Shift, digito: ZZ

----------------------

Executo:

ls -lit

pwd

whoami

----------------------

Executo:

./2IfExemp.sh meu-usuário-whoami

./2IfExemp.sh JeCam

./2IfExemp.sh UneCo

./2IfExemp.sh root

----------------------

MAIS OUTRO EXEMPLO:

----------------------

#!/bin/bash

# Declarando variável: USUWARRIO

USUWARRIO=$(grep "$1" /etc/passwd)

#OBS-1: uso o parâmetro cifrão 1 entre aspas
#OBS-2: test -n é para ver se uma varivel não é nula
#OBS-3: Colocar a variável entre aspa
#OBS-4: se a variável não for nula cai no then

if [ -n "$USUWARRIO" ]
then
echo "Este user existe"
if [ "$USUWARRIO" = root ]
then
echo ok
fi
else
echo "Este user não existe"
fi

# Fim do script

----------------------

CONTINUANDO COM EXEMPLOS:

----------------------

#!/bin/bash

# Declarando variável: USUWARRIO

USUWARRIO=$(grep "$1" /etc/passwd)

#OBS-1: uso o parâmetro cifrão 1 entre aspas
#OBS-2: test -n é para ver se uma varivel não é nula
#OBS-3: Colocar a variável entre aspa
#OBS-4: se a variável não for nula cai no then
#OBS-5: "if test $# -gt 0" - O cifrão mais cerquilha testa se foi inserido algum parâmetro. Se o parâmetro for maior que zero prossegue.

if test $# -gt 0
then
echo 'Foi inserido um valor maior que zero. Prosseguindo...'
else
echo 'Informe um nome como parâmetro.' ; exit

fi

if [ -n "$USUWARRIO" ]
then
echo "Este user existe"
else
echo "Este user não existe"
fi

# Fim do script

----------------------

PARA EXECUTAR O SCRIPT:

----------------------

touch 3IfExemp.sh

chmod +x 3IfExemp.sh

vi 3IfExemp.sh

(Aperto Esc, digito i, copio e colo o texto no vi com o mouse.)

----------------------

Aperto Esc, Seguro a tecla Shift, digito: ZZ

----------------------

Executo:

ls -lit

pwd

whoami

----------------------

Executo:

----------------------

1) ./3IfExemp.sh

2) ./3IfExemp.sh meu-usuário-whoami

3) ./3IfExemp.sh JeCam

4) ./3IfExemp.sh UneCo

5) ./3IfExemp.sh root

----------------------

UM EXEMPLO PARECIDO, USANDO TEST COLCHETES:

----------------------

#!/bin/bash

# Declarando variável: USUWARRIO

USUWARRIO=$(grep "$1" /etc/passwd)

#OBS-1: uso o parâmetro cifrão 1 entre aspas
#OBS-2: test -n é para ver se uma varivel não é nula
#OBS-3: Colocar a variável entre aspa
#OBS-4: se a variável não for nula cai no then
#OBS-5: "if test $# -gt 0" - O cifrão mais cerquilha testa se foi inserido algum parâmetro. Se o parâmetro for maior que zero prossegue.

if [ $# -gt 0 ]
then
echo 'Foi inserido um valor maior que zero. Prosseguindo...'
else
echo 'Informe um nome como parâmetro e execute novamente o script.'
echo
sleep 2
echo 'Para obter o nome do usuário digite: whoami antes de executar o script.'
sleep 2
echo
exit

fi

if [ -n "$USUWARRIO" ]
then
echo "Este user existe"
else
echo "Este user não existe"
fi

----------------------

Pronto! Nós sabemos usar if, then, else e fi.

----------------------

Até Breve!

🙂

.

Linux – aprendendo a usar o comando test

Linux - aprendendo a usar o comando test:

-----------------------

Comando de retorno usando test (zero "0" é verdadeiro, um "1" é falso)

-----------------------

1) test 10 -gt 5 (é maior que)
echo $?

2) test 15 -eq 12 (é igual a)
echo $?

3) test 8 -ne 12 (é diferente)
echo $?

4) test 25 -ge 15 (é maior ou igual que)
echo $?

5) test 35 -lt 25 (é menos que)
echo $?

6) test 8 -le 10 (é menos que ou igual que)
echo $?

7) VALOR1=101

8) test VALOR1 -eq 101
echo $?

9) test VALOR1 -gt 90
echo $?

10) test VALOR1 -ne 15

-----------------------

Até Breve!

🙂

.

GNU/Linux “instruções condicionais”

.

Linux - Instruções condicionais

.

No GNU/Linux "instruções condicionais" são instruções utilizadas para a "execução condicional" de comandos.

.

GNU/Linux - Instruções condicionais: Instruções usadas em shell script para executar uma serie de comandos com base em uma condição.

.

Se acontece ISTO uma série de comandos é executada. Se não acontece ISTO, uma OUTRA série de comandos é executada.

Caso aconteça ISTO uma série de comandos é executada. Caso não aconteça ISTO, outra série de comandos é executada.

-----------------------

No shell script para fazer "isto", usa-se:

1) if
2) case

-----------------------

Primeira sintaxe - if:

if #começa com "if" mais um "comando-condição" e se for verdadeiro...

then #Então
comando1 #Execute este comando ou esta lista de comandos
comando2
comando3

fi #Fecha a instrução condicional usando o if ao contrário

-----------------------

Segunda sintaxe - if:

if #Se isto for verdadeiro

then # Então
comando1 #Verdadeiro este comando é executado

else # Se não...
comando2 #Este outro comando é executado

fi #Fecha a instrução condicional o if ao contrário

-----------------------

Terceira sintaxe - if:

-----------------------

Exemplo1:

-----------------------

if #Se isto for verdadeiro
then # Então
comando1 #Execute este comando ou lista de comandos

elif #elif = else if, se não, se acontecer isto...
then #Então
comando2 #Execute este outro comando

else #Se não for verdadeiro...
comando3 #Execute então este outro comando
fi

-----------------------

Exemplo2:

-----------------------

A terceira sintaxe é ou já foi usada dentro dos scripts de inicialização do GNU/Linux. A forma comum acho que é (era):

-----------------------

if [ condição ];
then
comando-instrução1;
comando-instrução2;
comando-instrução3;

...
elif [ condição ];
comando-instrução4;
comando-instrução5;
comando-instrução6;

...
else
comando-instrução7;
comando-instrução8;
comando-instrução9;

...
fi.

-----------------------

Exemplo3:

-----------------------

if [ condição ];

then

comando-instrução1

elif [ condição ];

then

comando-instrução1

else

comando-instrução2

fi

-----------------------

OBS:
O if do shell script tem um comando e verifica se o comando foi executado com sucesso ele cai como verdadeiro tendo código de retorno zero. Se for falso (maior que zero), cai no else ou sai do if.

-----------------------

Tem um comando que faz uma condição. O comando test. O comando test é usado para criar uma condição. A sintaxe é:

test

-----------------------

O comando test tem várias expressões. As mais usadas são do um ao 6.

-----------------------

-eq (equal), -ne (not equal), -gt (greater than), -ge (greater equal), -lt (lower than), -le (lower equal)

-----------------------

1) -eq - é igual a - if [ "$a" -eq "$b" ]

2) -ne - é diferente - if [ "$a" -ne "$b" ]

3) -gt - é maior que - if [ "$a" -gt "$b" ]

4) -ge - é maior ou igual que - if [ "$a" -ge "$b" ]

5) -lt - é menos que - if [ "$a" -lt "$b" ]

6) -le - é menos que ou igual que - if [ "$a" -le "$b" ]

7) < - é menos que - (("$a" < "$b"))

8) "$b"))

10) >= - é maior ou igual que - (("$a" >= "$b"))

-----------------------

Strings podem ser comparadas:

1) = (Uma string igual a outra)

2) != (Uma string diferente da outra)

3) -n (String não nula)

4) -Z (String nula)

-----------------------

Arquivos podem ser testados:

1) -f (É um arquivo)

2) -d (É um diretório/pasta)

3) -r (Tem permissão de leitura)

4) -W (Tem permissão de escrita)

5) -X (Tem permissão de execução)

6) -S (Possui tamanho maior que zero)

-----------------------

EXEMPLOS:

# test 25 -gt 50 (25 é maior que 50? Não. O código de saída será 1.)

# test "$VALOR1" -eq 15 (O valor da variável VALOR1 é igual a 12? Se for o exit code será zero.)

# test -f /tmp/testes (O arquivo tmp/testes existe? Se existir o exit code será zero. Se não existir será 1)

# test "$VALOR1" = "$VALOR2" (A corda da variável VALOR1 é igual a string da variável VALOR2?)

-----------------------

OBS-IMPORTANTE:

EM VEZ DE ESCREVER A PALAVRA TEST USA-SE COLCHETES COM ESPAÇO

-----------------------

EXEMPLOS:

[ 25 -gt 50 ] (25 é maior que 50? Não. O código de saída será 1.)

[ "$VALOR1" -eq 15 ] (O valor da variável VALOR1 é igual a 12? Se for o exit code será zero.)

[ -f /tmp/testes ] (O arquivo tmp/testes existe? Se existir o exit code será zero. Se não existir será 1)

[ "$VALOR1" = "$VALOR2" ] (A corda da variável VALOR1 é igual a string da variável VALOR2?)

-----------------------

A FORMA MAIS USADA É COM COLCHETES E ESPAÇO.

-----------------------

OUTRO EXEMPLO:

VALOR1=15
if [ ! "$$VALOR1" -gt 12 ] #Negação (!) inverte não entra no fluxo

#É dado como falso não entra em lugar nenhum.

then
echo sucesso
fi

-----------------------

MAIS UM EXEMPLO:

-----------------------

VALOR1=15

if [ "$VALOR1" -gt 12 -a "VALOR1" -lt 20 ] #AND (-a) se tudo separado pelo -a for verdade terá sucesso se não for não entra em lugar nenhum.

then
echo sucesso
fi

-----------------------

EXEMPLO OR:

VALOR1=15

if [ "$VALOR1" -gt 12 -o "VALOR1" -lt 20 ] #OR (-o) se pelo menos uma situação for verdade terá sucesso. Se as duas forem falsas, não entra em lugar nenhum.

then
echo sucesso
fi

-----------------------

O -a TEM PREFERÊNCIA SOBRE O -o

-----------------------

Linux – Declarar variáveis torna o shell script mais fácil

#!/bin/bash

# Nome do Script: 5ScrNomeUserUID.sh

# Descrição: script recebe um
# nome de usuário como parâmetro
# e exibe UID do usuário, Nome Completo /
# Descrição do Usuário, Total em Uso no /home do
# usuário, Informações do último login do usuário,
# Validar se o usuário existe
# ou não sem o uso do if.
# Se não existir retorne o exit code 1, se
# existir retorne exit 0

# Execução: ./5ScrNomeUserUID.sh
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:

# COMENTÁRIO:
# Comando “du” para descobrir
# o uso do diretório
# Comando “lastlog” para
# informações do login
# Dados do usuário no
# arquivo /etc/passwd
# Para fazer a validação posso usar
# as opções de execução sequencial
# de comandos &&, ou ;

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção - Cuidado para não usar dentro do script a variável de ambiente UID

#ls /home/$1 > /dev/null 2>&1 || echo "Usuário Inexistente"
#ls /home/$1 > /dev/null 2>&1 || exit 1

#ls /home/$1 > /dev/null 2>&1 || { echo "Usuário Inexistente" ; exit 1;}

# Declarando 4 variáveis:
ESERU=$(echo $USER)
USERLOGIN=$(lastlog -u $USER | grep $USER)
UIDUSER=$(echo $UID)
TOTAL=$(du -hs ~/ | cut -f1)

clear
echo "Relatório do Usuário: $ESERU"
echo
echo "UID do usuário: $UIDUSER"
echo "Nome ou Descrição: $ESERU"
echo "Ultimo Login: $USERLOGIN | grep "
echo "Total Usado no ultimo Login: $TOTAL"
echo
# Fim do Script

---------------

Para Praticar:

---------------

Colo o comando "echo -e" com o parâmetro abaixo no terminal redirecionando com o write ">" para um arquivo de texto:

---------------

echo -e '\nO Marco Marciano\n \nPelos alto-falantes do universo \nVou louvar-vos aqui na minha loa\nUm trabalho que fiz noutro planeta \nOnde nave flutua e disco voa \nFiz meu marco no solo marciano \nNum deserto vermelho sem garoa \n \nEste marco que eu fiz é fortaleza. \nElevando ao quadrado Gibraltar! \nTorreão, levadiço, raio-laser \nE um sistema internet de radar \nNão tem sonda nem nave tripulada \nQue consiga descer nem decolar. \n\nConstrui o meu marco na certeza \nQue ninguém, cibernético ou humano. \nPoderia romper as minhas guardas \nNem achar qualquer falha nos meus planos \nFicam todos em Fobos ou em Deimos \nContemplando o meu marco marciano \n \nO meu marco tem rosto de pessoa \nTem ruínas de ruas e cidades \nTem muralhas, pirâmides e restos \nDe culturas, demônios, divindades \nA história de Marte soterrada \nPelo efêmero pó das tempestades \n
\nConstrui o meu marco gigantesco \nNum planalto cercado por montanhas \nPrecipícios gelados e falésias \nProjetando no ar formas estranhas \nComo os muros Ciclópicos de Tebas \nE as fatais cordilheiras da Espanha \n \nBem na praça central. um monumento \nEmbeleza meu marco marciano \nUm granito em enigma recortado \nPelos rudes martelos de Vulcano \nUma esfinge em perfil contra o poente \nGuardiã imortal do meu arcano... \n \n -- Lenine \n' > arq_marciano.txt

.

Executo os 35 comandos abaixo:

.

1) cat arq_marciano.txt

2) cat -n arq_marciano.txt

3) file arq_marciano.txt

4) !ca

5) !fi

6) wc arq_marciano.txt

wc -l arq_marciano.txt (linhas)

wc -w tarq_marciano.txt (palavras)

wc -c arq_marciano.txt (caracteres)

7) whereis arq_marciano.txt

8) whatis xingar

9) cat arq_marciano.txt | less

10) cat arq_marciano.txt | more

11) cat arq_marciano.txt | head -n 3

cat arq_marciano.txt | head -n 2 | grep 'O Marco' | cut -f1- | cut -c8-

12) cat -n arq_marciano.txt | head -n 3

cat arq_marciano.txt | head -n 2 | grep 'O Marco' | cut -f1- | cut -c8- | sed 's/Marciano/Plutoniano/'

13) cat arq_marciano.txt | tail -n 3

cat arq_marciano.txt | awk /Marciano/

14) cat -n arq_marciano.txt | tail -n 3

15) cat arq_marciano.txt | head -n 4 | grep imortal

16) cat arq_marciano.txt | head -n 4 | grep cidades

17) cat arq_marciano.txt | head -n 28 | grep -v marco

18) touch arq_marciano.txt

19) ls -til

20) cp -v arq_marciano.txt arq_marciano_back.txt

21) ls1

22) grep -i "marciano" arq_marciano.txt

grep -i marciano "arq_marciano.txt" -v

23) grep -i "meu" arq_marciano.txt

grep -i "meu" arq_marciano.txt -v

24) fgrep "sonda" arq_marciano.txt

25) egrep '(radar|decolar)' arq_marciano_back.txt

26) find ./ arq_marciano.txt

27) find arq_marciano.txt

28) ls [a-m]*.txt

29) mv arq_marciano_back.txt renomeado_arq_marciano_back.txt

30) ls -t

31) find ./* -type f -exec grep -l tem {} \;

32) egrep "ruas" -r ?*.txt

33) fgrep "montanhas" -r ./

34) ls2

35) clear

.

OBS:
Para remover o arquivo criado (ou use o mouse):

rm -f nome-do-arquivo.txt

Linux – Praticando shell script – NomeUserUID.sh

Abro o terminal pelo menu do sistema.

-----------------

Executo:

-----------------

touch 5ScrNomeUserUID.sh

-----------------

chmod +x 5ScrNomeUserUID.sh

-----------------

vi 5ScrNomeUserUID.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

(Para apagar um linha aperto Esc clico nela e digito dd)

-----------------

#!/bin/bash

# Nome do Script: 5ScrNomeUserUID.sh
# Descrição: script recebe um nome de usuário como
# parâmetro e exibe UID do usuário, Nome Completo /
# Descrição do Usuário, Total em Uso no /home do
# usuário, Informações do último login do usuário,
# Validar se o usuário existe ou não sem o uso do if.
# Se não existir retorne o exit code 1, se
# existir retorne exit 0
# Execução: ./5ScrNomeUserUID.sh
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:
# COMENTÁRIO:
# Comando “du” para descobrir o uso do diretório
# Comando “lastlog” para informações do login
# Dados do usuário no arquivo /etc/passwd
# Para fazer a validação posso usar as opções de
# execução sequencial
# de comandos &&, ou ;

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção - Cuidado para não usar dentro do script a variável de ambiente UID

# Declarando variáveis:
DATATUAL=$(date)
NOMEDAMAQUINA=$(cat /etc/hostname)
EUSER=$USER
USERLOGIN=$(w | grep 'tty7')
UIDUSER=$UID
TOTAL=$(du -hcs ~/ | grep 'total')

clear
echo "Data: $DATATUAL"
echo "Relatório do Usuário: $EUSER"
echo
echo "UID do usuário: $UIDUSER"
echo 'Nome ou Descrição:' $USER
echo "Nome da Máquina: $NOMEDAMAQUINA"
echo "Ultimo Login: $USERLOGIN"
echo "Total Usado no ultimo Login: $TOTAL"
echo
# Fim do Script 5ScrNomeUserUID.sh

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh 5ScrNomeUserUID.sh

-----------------

Linux – comando ls e as expressões regulares

Linux - comando ls e as expressões regulares -

--------------------
Coisas que o Linus Torvalds não criou:
--------------------

O comando ls é GNU!
O comando mv é GNU!
O comando rm é GNU!
O comando cp é GNU!
O comando du é GNU!
O comando chmod é GNU!
O comando split é GNU!
O comando uniq é GNU!
O comando wc é GNU!
O comando env é GNU!
O comando pwd é GNU!
O comando uptime é GNU!
O comando uname é GNU!

--------------------

O comando ls = lista arquivos e o conteúdo de diretórios

--------------------

Executando alguns comandos ls:

--------------------

1) ls -d */ (Para exibir pastas)

2) ls -a (Arquivos ocultos, ou seja, iniciados com “.”)

3) ls -A (arquivos ocultos, exceto o “.” e “..”)

4) ls | less (Listar arquivos e diretórios)

5) ls -C (Arquivos em colunas, ordenados verticalmente)

6) ls -l | grep ^d OU ls -la | grep ^d (Somente diretórios)

7) ls -h (Exibe os arquivos em seus tamanhos em KB, MB e GB)

8) ls -t (exibe primeiramente os arquivos criados/alterados recentemente)

9) ls -l (exibe informações referentes a arquivos e diretorios em colunas)

10) ls -F (exibe apenas arquivos executáveis, ou seja, marcados por um asterisco
no final do seu nome)

11) ls -u (exibe arquivos de acordo com o tempo do ultimo acesso ao inves
do tempo de modificacao do mesmo)

12) ls -r (exibe os arquivos na ordem inversa de z para a)

13) ls -R (exibe um diretorio e seus respectivos subdiretorios)

--------------------

Linux criar comandos usando expressões regulares

--------------------

Expressões regulares são caracteres com base em padrões, usandos simultaneamente para buscar e alterar textos em diretórios ou arquivos. Posso usar com diversos comandos do Linux.

--------------------

Expressões regulares são criadas a partir de metacaracteres. Sendo eles:

--------------------

\ . * + - { } [ ] ^ $ | ? ( ) : ! = \b | \1

--------------------

Metacaracteres podem, dependendo do caso, ter mais de um significado de acordo com o contexto.

--------------------

Aspa " não é metacaractere.

--------------------

Para criar comandos usando expressões regulares, posso usar um arquivo de texto. O arquivo de texto serve para eu aprender a criar comandos usando expressões regulares. Posso criar comandos usando expressões regulares imaginando também.

--------------------

Se eu quero criar comandos usando expressões regulares preciso usar metacaracteres.

--------------------

Lista de metacaracteres para eu consultar:

--------------------
. ponto
[] lista
[^] lista negada
? opcional
* asterisco
+ mais
{} chaves
^ circunflexo
$ cifrão
\b borda
\ escape
| ou
() grupo
\1 retrovisor
--------------------

Os metacaracteres e suas funções estão divididos em quatro grupos distintos:

--------------------

1) Representantes
2) Quantificadores
3) Âncoras
4) Outros

--------------------
--------------------

1) Representantes

--------------------
--------------------

.

(ponto - um caractere qualquer)

Ex.:

ls .

ls -li | grep ".ocumentos"

ls -li | grep ".odelos"

--------------------

[...]

(lista - lista de caracteres permitidos)

Ex.:

ls | grep [D]

(ls liste o que tiver D maiúsculo)

ls -t | grep [D-I]

--------------------

[^...]

(lista negada - lista de caracteres proibidos)

ls | grep [^D]

ls -t | grep [^D-I]

--------------------
--------------------

2) Quantificadores

--------------------
--------------------

?

(opcional - zero ou um)

Ex.:

ls -li | grep [M?]

ls -li | grep [D?]

--------------------

*

(asterisco - zero, um ou mais)

Ex.:

ls -li | grep [M*]

ls -li | grep [V*]

--------------------

+

(mais - um ou mais)

Ex.:

ls -li | grep [M+]

ls -li | grep [V+]

--------------------

{n,m}

(chaves - de n até m)

ls -t | grep {D,}

ls -t | grep {M,}

--------------------
--------------------

3) Âncoras

--------------------
--------------------

^

(circunflexo - início da linha)

Ex.:

ls -la | grep ^d

ls -la | grep ^d

--------------------

$

(cifrão - fim da linha)

Ex.:

ls -t | grep "$o"

--------------------

\b

(borda - início ou fim de palavra)

Ex.:

ls -li | grep [\bs]

ls -li | grep [\bV+]

--------------------

4) Outros

\c

(escape - torna literal o caractere c)

ls -li | grep [\c,M+]

ls -li | grep [\cV+]

--------------------

(...)

(ou - ou um ou outro)

ls -li | grep ...

--------------------

\1...\9

(retrovisor - texto casado nos grupos 1...9)

ls -li | grep \1...\9

--------------------

OBS:
Curingas usados em linha de comando, não são expressões regulares.

--------------------

Executo:

read -p "Informe um valor que será inserido em VAR1: " VAR1

read -p "Informe um valor que será inserido em VAR2: " VAR2

--------------------

OBS:
# $(expr $VAR1 + $VAR2) É uma substituição de comando que executa e joga o resultado na tela.

--------------------

Executo:

echo "A soma de $VAR1 + $VAR2 é $(expr $VAR1 + $VAR2)"

--------------------

Exemplos de scripts a serem executados:

--------------------

#!/bin/bash

# Nome do Script: 3Script-relatorio-da-maquina.sh
# Descrição:
# Execução: sh 3Script-relatorio-da-maquina.sh
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:
# Comentário:

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção
#
# Primeiro definir as variáveis
# 8 Variáveis

KERNEL=$(uname -r)
HOSTNAME=$(hostname)
CPUNO=$(cat /proc/cpuinfo | grep "model name" | wc -l)
CPUMODEL=$(cat /proc/cpuinfo | grep "model name" | head -n1 | cut -c14-)

# Acima cat /proc/cpuinfo mostra um monte de informação. Só quero uma linha de
# informação.
# Filtro usando pipe grep e o que tem no início da string "model name".
# Ainda aparecem 4 strings.
# Uso mais um pipe e o comando head -n1 aparece só uma
# linha. Mas...
# Uma parte desta única string não quero que apareça.
# Uso pipe e o comando cut -c14- para sumir com 14
# caracteres iniciais da
# string.

MEMTOTAL=$(free -h | grep 'Mem:' | cut -d: -f2)
MEMTOTAL2=$(cat /proc/meminfo | grep 'MemTotal:' | cut -c17-)
FILESYS=$(df -h | egrep -v '(tmpfs | udev)')
UPTIME=$(uptime -s)

# Noto que algumas variáveis são bem conhecidas
# mas outras são comandos criados a partir de
# expressões regulares.

# Para fazer um shell script funcionar criamos
# comandos via expressões regulares, colocamos
# eles dentro de variáveis. A variável só aceita
# um valor! Uma expressão regular é um só valor
# composto de quantos comandos a pessoa quiser.

# Este é o segredo da necessidade de aprender
# expressões regulares. Aprenda muito bem, para
# poder criar ótimos shell scripts.

clear
echo
echo ':::::::::::::::::::::::::::::'
echo "Relatório da Máquina: $HOSTNAME"
echo "Data/Hora: $(date)"
echo ':::::::::::::::::::::::::::::'
echo
echo "Ativa desde: $UPTIME"
echo
echo "Kernel: $KERNEL"
echo
echo "CPUs:"
echo "$CPUNO"
echo
echo "Modelo da(s) CPU(s): $CPUMODEL"
echo
echo "Memória Total: $MEMTOTAL"
echo
echo "$MEMTOTAL2"
echo
echo "Partições:"
echo
echo "$FILESYS"
echo
echo
echo 'Fim do Script'
echo
echo
# Fim do Script

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh 3Script-relatorio-da-maquina.sh

-----------------

OUTRO SHELL SCRIPT ESCRITO DIFERENTE MAS SOBRE O MESMO ASSUNTO:

-----------------

#!/bin/bash

# Nome do Script: RelatInfo.sh
# Descrição: Script que gera um relatório de algumas informações da máquina atual
# Execução: ./RelatInfo.sh
# Autor: Fulana de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail1@mail.com
# Histórico de modificações:
# Comentário:
# COMENTÁRIOS ESPECIAIS:
# TODO - indica uma tarefa a ser feita - Info Sist
# FIXME - indica um bug conhecido que precisa ser arrumado - strings duplicadas, uso de variáveis
# XXX - Notícia, chama a atenção. Para remover linhas duplicadas em uma expressão regular:
# Procuro por: find and remove duplicate strings via unix shell script
# awk '!_[$1]++' nome_do_arquivo.txt (a expressão _[$1]++ incrementa o valor do elemento de array com index $1 por um desde que ++ venha depois)

echo ""
echo "== Relatório de Informações da Máquina =="
echo ""
echo 'Dia:'
date
echo ""
echo 'Nome da Máquina:'
hostname
echo ""
echo 'Máquina Ativa desde:'
uptime
echo ""
echo
echo 'Versão Distro:'
cat /proc/version
echo
echo 'Usuario:'
whoami
echo
echo 'Versão do Kernel:'
uname -r
echo ""
lscpu | grep 'CPU(s):'
echo ""
lscpu | grep 'Nome do modelo:'
echo ""
echo 'Partições:'
df -kh
echo ""
lscpu | grep 'Arquitetura:'
echo ""
lscpu | grep 'Modo(s) operacional da CPU:'
echo ""
echo 'Relatório de BUGS (nCPUs):' ; cat /proc/cpuinfo | grep 'bugs' | awk '!_[$1]++'
echo ""
echo 'Identidade do vendedor:'
cat /proc/cpuinfo | grep 'vendor_id' | head -n1 | cut -c12-
echo ""
echo 'Memória total (MB):'
expr $(cat /proc/meminfo | grep MemTotal | tr -d ' ' | cut -d: -f2 | tr -d kB) / 1024
echo
echo 'Fim do Script'
echo ""
# Fim do Script

Linux – praticando – Script relatório da máquina

Linux - praticando - Script relatório da máquina

.

Abro o terminal pelo menu do sistema.

-----------------

Executo:

-----------------

touch 3Script-relatorio-da-maquina.sh

-----------------

chmod +x 3Script-relatorio-da-maquina.sh

-----------------

vi 3Script-relatorio-da-maquina.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

(Para apagar um linha aperto Esc clico nela e digito dd)

-----------------

#!/bin/bash

# Nome do Script: 3Script-relatorio-da-maquina.sh
# Descrição:
# Execução: sh 3Script-relatorio-da-maquina.sh
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:
# Comentário:

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção
#
# Primeiro definir as variáveis
# 8 Variáveis

KERNEL=$(uname -r)
HOSTNAME=$(hostname)
CPUNO=$(cat /proc/cpuinfo | grep "model name" | wc -l)
CPUMODEL=$(cat /proc/cpuinfo | grep "model name" | head -n1 | cut -c14-)

# Acima cat /proc/cpuinfo mostra um monte de informação. Só quero uma linha de
# informação.
# Filtro usando pipe grep e o que tem no início da string "model name".
# Ainda aparecem 4 strings.
# Uso mais um pipe e o comando head -n1 aparece só uma linha. Mas...
# Uma parte desta única string não quero que apareça.
# Uso pipe e o comando cut -c14- para sumir com 14 caracteres iniciais da
# string.

MEMTOTAL=$(free -h | grep 'Mem:' | cut -d: -f2)
MEMTOTAL2=$(cat /proc/meminfo | grep 'MemTotal:')
FILESYS=$(df -h | egrep -v '(tmpfs | udev)')
UPTIME=$(uptime -s)

# Noto que algumas variáveis são bem conhecidas
# mas outras são comandos criados a partir de
# expressões regulares.

# Para fazer um shell script funcionar criamos
# comandos via expressões regulares, colocamos
# eles dentro de variáveis. A variável só aceita
# um valor! Uma expressão regular é um só valor
# composto de quantos comandos a pessoa quiser.

# Este é o segredo da necessidade de aprender
# expressões regulares. Aprenda muito bem, para
# poder criar ótimos shell scripts.

clear
echo
echo ':::::::::::::::::::::::::::::'
echo "Relatório da Máquina: $HOSTNAME"
echo "Data/Hora: $(date)"
echo ':::::::::::::::::::::::::::::'
echo
echo "Ativa desde: $UPTIME"
echo
echo "Kernel: $KERNEL"
echo
echo "CPUs:"
echo "$CPUNO"
echo
echo "Modelo da(s) CPU(s): $CPUMODEL"
echo
echo "Memória Total: $MEMTOTAL"
echo
echo "$MEMTOTAL2"
echo
echo "Partições:"
echo
echo "$FILESYS"
echo
echo
echo 'Fim do Script'
echo
echo
# Fim do Script

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh 3Script-relatorio-da-maquina.sh

-----------------

Outro Shell Script escrito diferente mas sobre o mesmo assunto:

-----------------

#!/bin/bash

# Nome do Script: RelatInfo.sh
# Descrição: Script que gera um relatório de algumas informações da máquina atual
# Execução: ./RelatInfo.sh
# Autor: Fulana de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail1@mail.com
# Histórico de modificações:
# Comentário:
# COMENTÁRIOS ESPECIAIS:
# TODO - indica uma tarefa a ser feita - Info Sist
# FIXME - indica um bug conhecido que precisa ser arrumado - strings duplicadas, uso de variáveis
# XXX - Notícia, chama a atenção. Para remover linhas duplicadas em uma expressão regular:
# Procuro por: find and remove duplicate strings via unix shell script
# awk '!_[$1]++' nome_do_arquivo.txt (a expressão _[$1]++ incrementa o valor do elemento de array com index $1 por um desde que ++ venha depois)

echo ""
echo "== Relatório de Informações da Máquina =="
echo ""
echo 'Dia:'
date
echo ""
echo 'Nome da Máquina:'
hostname
echo ""
echo 'Máquina Ativa desde:'
uptime
echo ""
echo
echo 'Versão Distro:'
cat /proc/version
echo
echo 'Usuario:'
whoami
echo
echo 'Versão do Kernel:'
uname -r
echo ""
lscpu | grep 'CPU(s):'
echo ""
lscpu | grep 'Nome do modelo:'
echo ""
echo 'Partições:'
df -kh
echo ""
lscpu | grep 'Arquitetura:'
echo ""
lscpu | grep 'Modo(s) operacional da CPU:'
echo ""
echo 'Relatório de BUGS (nCPUs):' ; cat /proc/cpuinfo | grep 'bugs' | awk '!_[$1]++'
echo ""
echo 'Identidade do vendedor (nCPUs):'
cat /proc/cpuinfo | grep 'vendor_id' | awk '!_[$1]++'
echo ""
echo 'Fim do Script'
echo ""

# Fim do Script

.

Até Breve!

.

:)

.

Linux shell script praticando – Script que soma 3 valores e exibe resultado

Linux shell script praticando - Script que soma 3 valores e exibe resultado

.

Abro o terminal pelo menu do sistema.

-----------------

Executo:

-----------------

touch 2script-soma-numeros.sh

-----------------

chmod +x 2script-soma-numeros.sh

-----------------

vi 2script-soma-numeros.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

(Para apagar um linha aperto Esc clico nela e digito dd)

-----------------

#!/bin/bash

# Nome do Script: 2script-soma-numeros.sh
# Descrição:
# Autor: Fulano de Tal
# Data da Criação: DD/MM/YYYY
# Email: meu_mail@email.com
# Histórico de modificações:
# Comentário:
# COMENTÁRIOS ESPECIAIS:
# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - Notícia, chama a atenção
# Execução: sh 2script-soma-numeros.sh

echo
echo "Por favor, digite alguns números:"
sleep 2
echo

read -p "Digite a Variavel 1: " VARIAVEL1
read -p "Digite a Variavel 2: " VARIAVEL2
read -p "Digite a Variavel 3: " VARIAVEL3

echo
echo "A soma da $VARIAVEL1 + $VARIAVEL2 + $VARIAVEL3" é $(expr $VARIAVEL1 + $VARIAVEL2 + $VARIAVEL3)

echo
echo 'Fim do Script'
sleep 2
echo

# Fim do Script: 2script-soma-numeros.sh

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh 2script-soma-numeros.sh

-----------------

.

O Resultado é:

.

$ sh 2script-soma-numeros.sh

Por favor, digite alguns números:

Digite a Variavel 1: 22
Digite a Variavel 2: 20
Digite a Variavel 3: 10

A soma da 22 + 20 + 10 é 52

Fim do Script

.

.

Até Breve!

🙂

.

Script que gera um relatório de algumas informações da máquina atual

#!/bin/bash

# Nome do Script: RelatInfo.sh

# Descrição: Script que gera um relatório de algumas informações da máquina atual

# Autor: Fulano de Tal

# Data da Criação: DD/MM/YYYY

# Email: meu_mail1@mail.com

# Histórico de modificações:

# Comentário:

# COMENTÁRIOS ESPECIAIS:

# TODO - indica uma tarefa a ser feita

# FIXME - indica um bug conhecido que precisa ser arrumado

# XXX - Notícia, chama a atenção

#

echo ""
echo "== Relatório de Informações da Máquina =="

echo ""
echo 'Dia:'
date

echo ""
echo 'Usuario:'
whoami

echo ""
echo 'Máquina Ativa desde:'
uptime

echo ""
echo 'Verão do Kernel:'
uname -r
echo ""

lscpu | grep 'CPU(s):'
echo ""

lscpu | grep 'Nome do modelo:'
echo ""

echo 'Partições:'
df -kh
echo ""

lscpu | grep 'Arquitetura:'
echo ""

lscpu | grep 'Modo(s) operacional da CPU:'
echo ""

echo 'Relatório de BUGS (nCPUs):' ; cat /proc/cpuinfo | grep 'bugs'
echo ""

echo 'Identidade do vendedor (nCPUs):'
cat /proc/cpuinfo | grep 'vendor_id'
echo ""

echo 'Fim do Script'
echo ""

# Fim do Script

Linux Parâmetros e entradas do usuário

Linux Parâmetros e entradas do usuário

.

Executo:

.

mkdir -vp DirParam/SubDirP

.

ls -t

.

cd DirParam/SubDirP/

.

LEITURA:
Usar parâmetros. Tenho comandos que uso. Estes comandos tem opções. Muitos comandos e suas opções precisam de parâmetros.

.

Exemplo: O comando grep busca linha que tem um padrão de busca que é root. A opção -E interpreta o padrão como uma expressão regular estendida. O parâmetro /etc/passwd.txt diz ao comando e a opção onde fazer o serviço. Fica assim:

.

1) grep -E padrão Argumento

2) grep -E root /etc/passwd

3) grep -v bash /etc/passwd

.

Posso usar parâmetros em shell script.

.

Executo:

-----------------

touch ArqParam.sh

-----------------

chmod +x ArqParam.sh

-----------------

vi ArqParam.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# Declaro uma função em ShellScript

function BoasVindas(){
echo -e "\n\nSeja Bem Vindo $1 \n\n"
}

echo -n "Digite seu nome: "
read NOME

# A variável NOME receberá o que foi digitado por mim

BoasVindas "$NOME"

# Aqui passo o conteúdo da variável NOME como o 1º parâmetro para a função BoasVindas()

-----------------

Salvo e saio apertando a tecla Esc e digitando :wq (Enter)

-----------------

Executo:

-----------------

sh ArqParam.sh

-----------------

OBS:

1) Funções em shell script não recebem parâmetros na sua declaração.
2) Dentro da função há um "$1", esse é o parâmetro que a função receberá, então caso queira passar mais de um parâmetro para a função, basta chamar dentro dela os valores respectivos aos parâmetros, ou seja, $1 = primeiro parâmetro, $2 = segundo parâmetro, $3 = terceiro ... $9 = nono parâmetro.
3) Se a função tiver mais de 9 parâmetros, posso declarar da seguinte forma: ${10}, ${11} etc.

-----------------

Executo:

-----------------

touch ArqParam2.sh

-----------------

chmod +x ArqParam2.sh

-----------------

vi ArqParam2.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# Declaro uma função em ShellScript

function EscrevePalavra(){
echo -e "\n\nVocê escreveu $1 \n\n"
}

echo -n "Escreva uma palavra: "
read PALAVRA

EscrevePalavra "$PALAVRA"

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh ArqParam2.sh

-----------------

O script ArqParam2.sh imprime no terminal os parâmetros que foram passados. Para usar um parâmetro em específico uso $1 o primeiro parâmetro. A partir do décimo parâmetro tem que usar ${10}, do contrário o shell vai usar o parâmetro 1 e escreverá um 0 em seguida

-----------------

Executo:

-----------------

touch ArqParam3.sh

-----------------

chmod +x ArqParam3.sh

-----------------

vi ArqParam3.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# ArqParam3.sh

# Declaro uma função em ShellScript

echo "O parâmetro 1 é: $1"
echo "O parâmetro 3 é: $3"
echo "O parâmetro 10 é: ${10}"
echo "O parâmetro 15 é: ${15}"
echo "O parâmetro 16 é: ${16}"
echo "O parâmetro 17 é: ${17}"

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh ArqParam3.sh 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

-----------------

bash ArqParam3.sh um 2 três 4 5 6 7 8 9 dez 11 12 13 14 quinze 16 dezessete

-----------------

Executo:

-----------------

touch ArqParam4.sh

-----------------

chmod +x ArqParam4.sh

-----------------

vi ArqParam4.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

echo Existem $# argumentos para $0: $*
echo primeiro argumento: $1
echo segundo argumento: $2
echo terceiro argumento: $3
echo quarto argumento: $4
echo Aqui estão eles de novo: $@

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

bash ArqParam4.sh experimento shell script Linux

-----------------

echo "" ; sh ArqParam4.sh experimento shell script Linux ; echo ""

-----------------

Executo:

-----------------

touch ExemploParametros.sh

-----------------

chmod +x ExemploParametros.sh

-----------------

vi ExemploParametros.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# $0 - Nome do programa

# $# - Quantidade de parâmetros inseridos

# $* - Todos os parâmetros inseridos

# $1 - Parametro 1
# $2 - Parametro 2
# $3 - Parametro 3
# $4 - Parametro 4
# $5 - Parametro 5
# $6 - Parametro 6
# $7 - Parametro 7
# $8 - Parametro 8
# $9 - Parametro 9

# ${10} - Parametro 10
# ${11} - Parametro 11

echo "O script $0 recebeu $# parâmetros "

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh ExemploParametros.sh

-----------------

Resultado:

-----------------

$ sh ExemploParametros.sh
O script ExemploParametros.sh recebeu 0 parâmetros

-----------------

Se eu adicionar ao comando "sh ExemploParametros.sh" as palavras: Vida Jovem Filosofa Poetisa.

.

Executo:

.

sh ExemploParametros.sh Vida Jovem Filosofa Poetisa

.

Resultado:

.

$ sh ExemploParametros.sh Vida Jovem Filosofa Poetisa
O script ExemploParametros.sh recebeu 4 parâmetros

.

Executo:

.

sh ExemploParametros.sh Vida Jovem Filosofa Poetisa GNU Linux

.

Resultado:

.

$ sh ExemploParametros.sh Vida Jovem Filosofa Poetisa GNU Linux
O script ExemploParametros.sh recebeu 6 parâmetros

.

Executo:

.

vi ExemploParametros.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# $0 - Nome do programa

# $# - Quantidade de parâmetros inseridos

# $* - Todos os parâmetros inseridos

# $1 - Parametro 1
# $2 - Parametro 2
# $3 - Parametro 3
# $4 - Parametro 4
# $5 - Parametro 5
# $6 - Parametro 6
# $7 - Parametro 7
# $8 - Parametro 8
# $9 - Parametro 9

# ${10} - Parametro 10
# ${11} - Parametro 11

echo ""
echo "O script $0 recebeu $# parâmetros "
echo ""
echo "Os parâmetros recebidos foram: $*"
echo ""

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh ExemploParametros.sh Luz Velho Sombra GNU Linux Unix Novos Alunos

-----------------

Executo:

.

vi ExemploParametros.sh

-----------------

Aperto Esc. Clico no terminal. Digito i.

-----------------

Copio o texto abaixo e colo no vi.

-----------------

#!/bin/bash

# $0 - Nome do programa

# $# - Quantidade de parâmetros inseridos

# $* - Todos os parâmetros inseridos

# $1 - Parametro 1
# $2 - Parametro 2
# $3 - Parametro 3
# $4 - Parametro 4
# $5 - Parametro 5
# $6 - Parametro 6
# $7 - Parametro 7
# $8 - Parametro 8
# $9 - Parametro 9

# ${10} - Parametro 10
# ${11} - Parametro 11

echo ""
echo "O script $0 recebeu $# parâmetros "
echo ""
echo "Os parâmetros recebidos foram: $*"
echo ""
echo "Parâmetro \$1 = $1" # Noto o escape em \$
echo "Parâmetro \$2 = $2"
echo "Parâmetro \$3 = $3"
echo "Parâmetro \$4 = $4"
echo "Parâmetro \$5 = $5"
echo "Parâmetro \$6 = $6"
echo "Parâmetro \$7 = $7"
echo ""

-----------------

Aperto a tecla Esc digito :wq

-----------------

Executo:

-----------------

sh ExemploParametros.sh Vida Jovem Velho Poeta GNU Linux Unix

.

Executo:

.

echo -e 'AlunaA Xh \nAmunoC Beg \nAnunaE Yok \nApunoT Wxs' > ParamNom.txt

.

touch ParamLunos.sh

chmod -x ParamLunos.sh

.

vi ParamLunos.sh

.

Copio e colo no ParamLunos.sh:

.

#!/bin/bash

# ParamLunos.sh - Procura nomes
# Autor: Average Joe
# Exemplo de script para uso de parâmetros
# Uso: sh ParamLunos.sh

NOMEALUN="ParamNom.txt"

clear
echo ""
echo "== Script busca Nome =="
echo ""

NOMECOMP=$(grep "$1" $NOMEALUN) # O grep recebe o parâmetro $1

echo ""
echo "O nome completo é: $NOMECOMP"
echo ""
echo "Fim do Script"
echo ""

--------------------

sh ParamLunos.sh AnunaE

--------------------

.

Até Breve!

.

🙂

Linux comando read

Linux comando read

.

No Bash o comando read recebe a entrada do usuário (EU). O comando read ajuda a manipular e tratar a entrada de dados em Bash Shell. Exemplo para escrever scripts:

read VARIAVEL

.

IMPRIMINDO E LENDO VALORES AO MESMO TEMPO:

read -p 'TEXTO' VARIAVEL

.

A opção -p originalmente mostra uma mensagem na saída de erro padrão.
Se não estiver redirecionando essa saída para o /dev/null ou para nenhum outro lugar, ela será apresentada na tela do terminal.

----------------

Exemplo:

#!/bin/bash

# A entrada de dados é encerrada ao apertar a interrogação '?'

read -p "Digite uma pergunta? : " -d'?' PERGUNTA

echo

echo "$PERGUNTA"

----------------

LIMITANDO A QUANTIDADE DE CARACTERES A SEREM LIDOS

read -n NUMERO

.

A opção -n faz o read ler até a quantidade de caracteres especificada em NUMERO.

Útil para fazer menus em que apenas um caractere deve ser informado, sem a necessidade do ENTER para finalizar, pois a condição de -n já foi atendida.

----------------

CONTINUANDO...

.

ABRO O TERMINAL PELO MENU DO SISTEMA.

.

EXECUTO:

.

read UM_NOME

.

Digito:

Average Joe

.

Executo:

.

echo $UM_NOME

.

read VALOR1 VALOR2 VALOR3

.

Digito:

Aprendendo Linux Shellscript

.

Executo:

.

echo $VALOR1 $VALOR2 $VALOR3

.

read VALOR1 VALOR2

.

Aprendendo Linux Shellscript

.

echo $VALOR1

.

echo $VALOR2

.

read -p "Escreva uma palavra: " CRONOS

.

Biplano

.

echo $CRONOS

.

read -s CURSE

.

6a5b4c3d2e1f

.

echo $CURSE

.

mkdir -vp TesteRead/SubPasta

.

cd TesteRead/SubPasta

.

pwd

.

ls -R

.

echo -e 'Alu Mino \nZeta Ser \nXandre Bol \nErbe Pro \nHugu Ben \nKako Tom \nQuex Vuz' > ArqRead.txt

.

cat ArqRead.txt

.

cd ..

.

pwd

.

grep Quex ~/TesteRead/SubPasta/ArqRead.txt

.

cd -

.

pwd

.

ls

.

echo -e '#!/bin/bash \n \n# Este é script teste cmd read \n' > readscript.sh ; chmod +x readscript.sh ; cat readscript.sh

.

ls -til

.

vi readscript.sh

.

Aperto Esc. Clico no terminal. Digito i.

.

Copio o texto abaixo e colo no vi.

.

# Inicio

ARQREAD="ArqRead.txt"

clear

echo ""
echo '== Script Busca Nomes =='
echo
echo -n "Favor informar o nome a buscar:"
read NOME

echo ""
echo "O nome completo é: $(grep "$NOME" $ARQREAD)"
echo ""
echo "Fim do Script"
echo ""

# Fim

.

Salvo e saio apertando a tecla Esc e digitando :wq (Enter)

.

Executo:

.

sh readscript.sh

.

Digito: Kako

.

Aperto a tecla Enter

.

O resultado é:

.

== Script Busca Nomes ==

Favor informar o nome a buscar:Kako

O nome completo é: Kako Tom

Fim do Script

.

OBS.
Em vez de usar:

echo -n "Favor informar o nome a buscar:"
read NOME

Poderia ser:

read -p "Favor informar o nome a buscar: " NOME

.

Salvo e saio apertando a tecla Esc e digitando ZZ (Enter)

.

Executo:

.

vi readscript.sh

.

Aperto Esc. Clico no terminal. Digito i.

.

OBS:
No Vi apertando a tecla Esc e digitando dd - deleta linha corrente, apertando a tecla Esc e digitando dG - deleta até a última linha do arquivo, d$ - deleta até o fim da linha, d^ - deleta até o início da linha.

.

Copio o texto abaixo e colo no vi.

.

# Inicio

ARQREAD="ArqRead.txt"

clear

echo ""
echo '== Script Busca Nomes =='
echo
read -p "Favor informar o nome a buscar: " NOME

echo ""
echo "O nome completo é: $(grep "$NOME" $ARQREAD)"
echo ""
echo "Fim do Script"
echo ""

# Fim

.

Salvo e saio apertando a tecla Esc e digitando :x (Enter)

Executo:

.

sh readscript.sh

.

Digito: Zeta

.

O resultado é:

== Script Busca Nomes ==

Favor informar o nome a buscar: Zeta

O nome completo é: Zeta Ser

Fim do Script

.

OUTRO MODO DE FAZER A MESMA COISA...

.

Executo:

.

vi readscript.sh

.

Aperto Esc. Clico no terminal.

.

REPITO OBS:
No Vi apertando a tecla Esc e digitando dd - deleta linha corrente, apertando a tecla Esc e digitando dG - deleta até a última linha do arquivo, d$ - deleta até o fim da linha, d^ - deleta até o início da linha.

.

Copio o texto abaixo e colo no vi.

.

# Inicio

ARQREAD="ArqRead.txt"

clear

echo ""
echo '== Script Busca Nomes =='
echo
read -p "Favor informar o nome a buscar: " NOME

NOMECOMPLETO=$(grep "$NOME" $ARQREAD)

echo ""
echo "O nome completo é: $NOMECOMPLETO"
echo ""
echo "Fim do Script"
echo ""

# Fim

.

Salvo e saio apertando a tecla Esc e digitando :wq (Enter)

.

Executo:

.

cat ArqRead.txt

.

bash readscript.sh

.

Digito: Erbe

.

O resultado é:

.

== Script Busca Nomes ==

Favor informar o nome a buscar: Erbe

O nome completo é: Erbe Pro

Fim do Script

.

Linux man exiftool grep cut tr sed touch echo

.

LINUX MAN EXIFTOOL GREP CUT TR SED TOUCH ECHO

.

1) man exiftool

2) man exiftool | grep -A 30 'File Types'

3) man exiftool | grep -A 60 'File Types'

4) exiftool nome-do-arquivo.qualquer_ext_de_'File Types'

5) exiftool nome-do-arquivo.mkv

6) exiftool nome-do-arquivo.png

7) exiftool nome-do-arquivo.mp4

8) exiftool nome-do-arquivo.mp3

9) exiftool nome-do-arquivo.jpg

10) exiftool nome-do-arquivo.jpg | grep Create

11) exiftool nome-do-arquivo.jpg | grep | cut -d : -f 2-

.

OBS:

O "| grep create" mostra a linha que tem a palavra Create.

Já "| cut -d : -f" apaga o que vem antes dos dois pontos.

O "-d" casa com o caractere ":".

O "-f" filtra os campos desejados ou não.

O "2-" mostra do campo 2 em diante. Os campos começam com campo zero, campo 1, campo 2, Etc.

.

12) touch nome-do-arquivo.jpg (Altera a data do arquivo. Pode ser mkv, png, mp4, mp3, Etc.)

13) man touch (Encontro opção -t)

14) man touch | grep -A 5 times

15) man touch | grep -A 3 STAMP

.

16) exiftool nome-do-arquivo.png | grep Create | cut -d : -f 2- | tr -d ': '

(Apaga os dois pontos e espaço em branco)

.

exiftool nome-do-arquivo.png | grep Create | cut -d : -f 2- | tr -d ': ' | sed 's/./&./'

(Insere um ponto. A parte final do comando usa expressões regulares)

.

exiftool nome-do-arquivo.png | grep Create | cut -d : -f 2- | tr -d ': ' | sed 's/./&./6'

(Insere um ponto na sexta ocorrência.)

.

exiftool nome-do-arquivo.png | grep Create | cut -d : -f 2- | tr -d ': ' | sed 's/./&./12'

(Insere um ponto na ocorrência 12.)

.

touch -t numeros-data-com-ponto-antes-das-2-ultimas-ocorrencias nome-do-arquivo.png

.

CRIAR UM LOOP

.

DIGITO NO TERMINAL:

for VARIAVEL in *.png (Teclo Enter)

do (Teclo Enter)

echo Esta VARIAVEL: (Teclo Enter)

done (Teclo Enter)

.

EXECUTO:

for VARIAVEL in *.png; do echo Essa VARIAVEL: $VARIAVEL; done

for VARIAVEL in *.png; do echo Essa Outra VARIAVEL: $VARIAVEL; done

for VARIAVEL in *.png; do echo touch -t .... $VARIAVEL ; done

.

COLOCANDO SUB SHELL DENTRO DO COMANDO:

(Quer dizer colocar um comando dentro de outro comando.)

.

EXEMPLO:

inicio-do-comando $(sub shel) fim-do-comando

.

EXEMPLO:

for VARIAVEL in *.png; do echo touch -t $(exiftool "$VARIAVEL" | grep Create | cut -d : -f 2- | tr -d ': ' | sed 's/./&./12') "$VARIAVEL" ; done

.

OBS:

1) No comando acima o "echo" simula o comando antes de executar realmente o comando. Para executar o comando removo o "echo".
2) Se coloco variável dentro de um comando coloco aspas.

.

REMOVER PERMISSÃO DE EXECUÇÃO DE TODOS OS ARQUIVOS EM UMA PASTA.

.

EXECUTO:

chmod -x *

.

.

Dissecando uma Poesia usando Linux

Anotações Linux shell script

.

AnotacoesLinuxShellScript.txt

.

Não quero de forma alguma aprender tudo hoje nem amanhã. Saber tudo é horrível. Rouba de mim o prazer de estudar. Não saber é bom, pois assim, posso buscar e aprender alguma coisa. Qualquer coisa. Creio que uma pessoa que sabe tudo, no final, talvez não possa fazer nada.

.

CRIAR DIRETORIO/PASTA

.

mkdir -p ~/Downloads/NotasLinuxShell/EstLinux

.

NAVEGAR ATÉ EstLinux

.

cd ~/Downloads/NotasLinuxShell/EstLinux

pwd

.

OBJETIVO CONTAR PALAVRAS EM SHELL

.

criar um arquivo de texto com dezoito palavras em seis linhas

.

echo -e 'contando palavras shell \nFalantes loa leia \nLuz olhos shell \nCibernético planos sonda \nEscritor não loucura \nCharles Aluno1 leia' > ContarPalavrasEmShell.txt

.

EXECUTANDO COMAND WC DO PACOTE GNU COREUTILS

.

1) wc -w ContarPalavrasEmShell.txt

2) wc -w /etc/passwd

3) wc -l ContarPalavrasEmShell.txt

4) wc -l /etc/passwd

5) wc -c ContarPalavrasEmShell.txt

6) wc -c /etc/passwd

7) wc -m ContarPalavrasEmShell.txt

8) wc -m /etc/passwd

.

Se executar "echo 333 | wc -c" o resultado é 4

.

EXECUTO:

.

echo 333 | wc -c

.

ME INFORMANDO SOBRE O COMANDO UNIQ NA MANPAGE:

.

man uniq | grep count

.

man uniq | grep -A 1 count
.

man uniq | grep -A 3 count

.

man uniq | grep -A 5 count

.

EXECUTO:

echo ; cat ContarPalavrasEmShell.txt | uniq -c ; echo

.

O RESULTADO NÃO É BEM O CORRETO

.

EXECUTO:

echo ; cat ContarPalavrasEmShell.txt | sort | uniq -c ; echo

.

clear ; echo ; cat ContarPalavrasEmShell.txt | sort #| uniq -c ; echo

.

TEM QUE SER UMA PALAVRA POR LINHA LINHA E ESTAS LINHAS DEVEM ESTAR ORDENADAS.

.

CRIO NOVO ARQUIVO DE TEXTO

.

EXECUTO:

echo -e 'leia1\nleia2\nleia3\nleia4\nleia5' > LeiaPalavrasEmShell.txt

.

EXECUTO:

.

cat LeiaPalavrasEmShell.txt | sort | uniq -c

.

cat LeiaPalavrasEmShell.txt | sort #| uniq -c

.

COPIO ESTE TEXTO DA INTERNET:

.

Se vai tentar
siga em frente.
Senão, nem começe!
Isso pode significar perder namoradas
esposas, família, trabalho...e talvez a cabeça.
Pode significar ficar sem comer por dias,
Pode significar congelar em um parque,
Pode significar cadeia,
Pode significar caçoadas, desolação...
A desolação é o presente
O resto é uma prova de sua paciência,
do quanto realmente quis fazer
E farei, apesar do menosprezo
E será melhor que qualquer coisa que possa imaginar.
Se vai tentar,
Vá em frente.
Não há outro sentimento como este
Ficará sozinho com os Deuses
E as noites serão quentes
Levará a vida com um sorriso perfeito
É a única coisa que vale a pena.
-- Charles Bukowski

.

EXECUTO:

.

vi PoesiaBukowski.txt

.

Aperto Esc. digito i. colo o texto copiado com o mouse. confiro. Aperto Esc. Digito :wq.

.

EXECUTO:

ls -tli

.

clear

cat | uniq -c PoesiaBukowski.txt

.

OBS:
teclo Ctrl C

.

MAS QUERO CONTAR UMA PALAVRA POR LINHA

.

EXECUTO:

cat PoesiaBukowski.txt | sort | uniq -c

.

PARA UMA PALAVRA POR LINHA USO "xargs -n 1"

.

EXECUTO:

1)

cat PoesiaBukowski.txt | xargs -n 1

2)

clear ; echo ; cat PoesiaBukowski.txt | xargs -n 1 ; echo

3)

cat PoesiaBukowski.txt | xargs -n 3

4)

clear ; echo ; cat PoesiaBukowski.txt | xargs -n 3 ; echo

5)

cat PoesiaBukowski.txt | xargs -n 4

6)

clear ; echo ; cat PoesiaBukowski.txt | xargs -n 4 ; echo

.

SEM VIRGULAS E PONTOS

.

EXECUTO:

cat PoesiaBukowski.txt | egrep -o '\w+'

.

PARA ORDENAR E PARA CONTAR

.

EXECUTO:

clear

cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c

.

ORDENAR OS QUE MAIS APARECEM

.

EXECUTO:

clear

cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n

.

ISTO É ÚTIL SE EU ESCREVO UM TEXTO E TENHO VÍCIO DE USAR CERTAS PALAVRAS EM EXCESSO, ACHO EU; QUE ESCREVO.

.

MOSTRAR DO MAIOR PARA O MENOR

.

EXECUTO:

clear

cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n -r

.

PARA VER SÓ AS DEZ PRIMEIRAS

.

EXECUTO:

clear

cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n -r | head

.

PARA VER A QUE MAIS APARECE NO TEXTO:

.

EXECUTO:

cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n -r | head -n1

.

PARA VER AS 7 QUE MAIS APARECEM

.

EXECUTO:

1) clear

2) cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n -r | head -n 7

3) echo ; cat PoesiaBukowski.txt | egrep -o '\w+' | sort | uniq -c | sort -n -r | head -n 7 ; echo

4) egrep -o '\w+' (uma palavra por linha), sort (ordena), uniq -c (conta), sort -n -r (o resultado é ordenado numericamente do maior para o menor), head -n 7 (pega as sete primeiras)

.

Me pergunto se num desafio, alguém poderia produzir um texto poderoso como o que achei na internet usando as sete palavras mais usadas na poesia:

.

5 significar
4 Pode
4 a
3 que
3 em
3 E
2 vai

.

QUERO SÓ AS QUE TIVEREM TRES LETRAS OU MAIS.

.

EXECUTO:

1)

cat PoesiaBukowski.txt | egrep -o '\w+' | grep ...

2)

cat PoesiaBukowski.txt | egrep -o '\w+' | grep .....

3)

cat PoesiaBukowski.txt | egrep -o '\w+' | grep ... | sort | uniq -c | sort -n -r | head -n 7

4)

clear ; echo ; cat PoesiaBukowski.txt | egrep -o '\w+' | grep ... | sort | uniq -c | sort -n -r | head -n 7 ; echo

5)

cat PoesiaBukowski.txt # | egrep -o '\w+' | grep ... | sort | uniq -c | sort -n -r | head -n 7

6)

cat PoesiaBukowski.txt | egrep -o '\w+' # | grep ... | sort | uniq -c | sort -n -r | head -n 7

.

E assim usando Linux disseco uma poesia.

.

Até Breve

.

Meu Quinto Script Vi

Meu Quinto Script Vi

.

LINUX COMANDOS E SHELL SCRIPT

----------------------

EXECUTO O COMANDO:

1) cd ; cd Downloads/ ; mkdir EstudoEmDown ; cd EstudoEmDown/

.

DEPOIS EXECUTO:

1) > MeuQuintoScriptVi.sh

2) chmod +x MeuQuintoScriptVi.sh

3) vi MeuQuintoScriptVi.sh

4) Aperto Esc digito i e colo:

#!/bin/bash

##################################
# Nome do Script: MeuQuintoScriptVi.sh
#
# Descrição:
# 1)
# 2)
# 3)
#
# Autor: Fulano_de_Tal
#
# Data da Criação: DD/MM/YYYY
#
# Email: meu_mail1@mail.com
#
#
##################################
#
#
# Sobre este script:
# 1)
# 2)
# 3)
#
# Exemplo de uso:
# 1)
# 2)
#
# Histórico de modificações:
# 1) Dia X -
# 2)
#
# Comentário:
# 1)
# 2)
#
# REGRAS DO CÓDIGO LIMPO:
#
# 1) Colocar apenas um comando por linha
#
# 2) Alinhar verticalmente comandos de um mesmo bloco
#
# 3) Deslocar o alinhamento a direita a cada novo bloco
#
# 4) Usar linhas em branco para separar trechos
#
# 5) Não ultrapassar o limite de 80 colunas por linha
#
#
# COMENTÁRIOS ESPECIAIS:
#
#
# TODO - indica uma tarefa a ser feita
# 1)
# 2)
# 3)
#
# FIXME - indica um bug conhecido que precisa ser arrumado
#
#
#
# XXX - Notícia, chama a atenção
#
#
#
##################################

echo "Vou buscar os dados do sistema. Posso continuar? [S/n]"
read RESPOSTA
test "$RESPOSTA" = "n" && exit

# Recebendo a resposta positiva o sistema informará muitas coisas.

echo
echo == Informações ==
echo
sleep 2
echo
echo Seguem as informações do seu sistema $USER
echo
sleep 2

echo '== Info do sistema =='
echo
sleep 2
uname -a
echo
sleep 4
df -Tha --total
echo
sleep 5

echo
echo '== Sua distribuição é: =='
echo
sleep 2
neofetch
sleep 5
echo

echo '==Seu kernel é: =='
echo
sleep 2
cat /proc/version
echo
sleep 5

echo '== O usuário logado é: =='
echo
whoami
echo
sleep 3

echo '== O nome da máquina e o host local são: =='
echo
sleep 3
hostname
echo
sleep 4

echo '== O tempo de uso é: =='
echo
sleep 2
uptime
echo
sleep 4

echo '== A quantidade de memória usada é: =='
echo
sleep 2
free -mt
echo
sleep 5

echo '== A temperatura da máquina é: =='
echo
sleep 2
sensors
echo
sleep 4

echo '== Data e hora local: =='
echo
sleep 2
date
echo
sleep 5

echo '== Dispositivos de bloco: =='
echo
sleep 2
lsblk
echo
sleep 5

echo '== CPU info: =='
echo
sleep 2
cat /proc/cpuinfo
sleep 5

echo '== Memória info: =='
echo
sleep 2
cat /proc/meminfo
echo
sleep 5

echo '== Info IP placas de rede: =='
echo
sleep 2
ifconfig
echo
sleep 5

echo '== Info sobre DNS config do Sist: =='
echo
sleep 2
cat /etc/resolv.conf
echo
sleep 4

echo
echo '== Informação básica resumida: =='
sleep 2
echo
echo ===============================
echo
echo == Data Atual ==
date
echo
echo ===============================
echo
echo == Uso de Disco ==
df -h
echo
echo ===============================
echo
echo == Usuário ==
w
echo ===============================
echo
echo == Memória ==
echo
echo ===============================

# Fim do script

5) Aperto Esc e digito :wq

6) cp MeuQuintoScriptVi.sh ~/

7) cd ~/

8) Executo o comando:

./MeuQuintoScriptVi.sh

9) cd Downloads/EstudoEmDown/

10) sh MeuQuintoScriptVi.sh

----------------------