JUNHO-2017
Eu não sei nada de Linux, mas quero aprender. Preciso pesquisar, anotar, pensar e testar na pratica as coisas que quero aprender. O Linux é um universo gigantesco cheio de vida, com muitos projetos inteligentes e interessantes sendo imaginados, planejados e executados a toda hora. Cresce sem parar. Quem obtém o melhor do universo Linux? As pessoas que gostam de aprender alguma coisa.
.
MINHAS ANOTAÇÕES BUSCAM DEFINIÇÕES COMANDOS TERMINAL LINUX BASH SAIDAS ENTRADAS – BÁSICO – INICIANTE – INTERMEDIÁRIO
.
Para qualquer serviço além do que um usuário comum faz, no Linux, a gente sempre acaba usando o terminal. O emulador de terminal que usamos hoje em dia, vem de outros tempos. Um monitor antigo que tinha uns 80×24 e era o único modo de se comunicar com o computador (software+harware).
.
Se eu quiser ser algo mais que um usuário normal, comum de computadores é bom eu aprender alguma coisa sobre o terminal do Linux. Também é bom aprender a usar um ou dois programas gráficos muito, muito bem.
.
O KERNEL DAS DISTRIBUIÇÕES LINUX
Se eu tenho um computador e todos os aplicativos funcionando harmoniosamente para executar os trabalhos do dia-a-dia. Essa “harmonia” é possível graças ao sistema operacional funcionando como uma interface entre o software, o hardware e o usuário. O responsável por esta harmonia é o Kernel criado por Linus Torwalds em 1991, na época ele era apenas um estudante de ciência da computação que teve necessidade de criar este programa.
Há pouco tempo, quase ninguém sabia da existência do kernel. Era algo muito abstrato e restrito até mesmo aos estudantes de computação das universidades e aos desenvolvedores, o usuário sequer ouvia esta palavra. Com o surgimento do Linux, qualquer usuário iniciante de Linux, já ouviu falar do kernel.
.
Eu mesmo por exemplo. Quando ouço falar de sistemas operacionais Linux, eu sei que todo o sistema operacional é montado sobre um único programa. É um programa sólido. Foi criado por um cara chamado Linus. Este programa é chamado de Kernel. Kernel é uma palavra inglesa que significa “núcleo”. O Kernel é o programa que está mais próximo do hardware. O kernel é a ponte que permite os programas conversarem com o hardware. O hardware responde aos aplicaticos por meio do Kernel. Os Kernels mais antigos podem não responder bem a novos hardwares. Pode ser que certos programas não funcionem bem se usar um Kernel antigo. Os aplicativos não conversam com o Hardware conversam com o Kernel ai sim, o Kernel sim conversa com o Hardware.
.
O Bash é um dos muitos interpretadores de comandos que existem e é o usado no Linux. Tem outros como o CSH o DOS o POWERSHELL e outros. Pelo Bash do terminal Linux eu posso alterar até mesmo o Kernel, mas, as distribuições Linux que escolho por usar já vem com o Kernel mais atual possível.
.
Então, o kernel é o núcleo do sistema operacional e dá aos softwares a capacidade de acessar o hardware. Por isto, o kernel do Linux é atualizado constantemente, acrescentando suporte a novas tecnologias. Usa módulos para adicionar suporte ou para melhorar no suporte a itens já existentes. A numeração do Kernel é muito fácil de aprender e é bem útil saber sobre ela. São 3 números:
.
Número principal: é o ‘primeiro’ número, o número mais à esquerda, indica as mudanças realmente principais no kernel.
.
Número secundário: é o número ‘do meio’, indica a estabilidade de um kernel particular. Números pares indicam uma versão estável e números ímpares indicam uma versão em desenvolvimento.
.
Número ‘de revisão’: é o ‘último’ número, indica a versão.
.
Por exemplo, o kernel 4.9.29 LTS é a vigésima nona versão do kernel 4.9.0. O LTS significa Long Term Support (suporte a longo prazo).
.
NOME DE ALGUNS SÍMBOLOS
‘ – Reticência
# – O nome deste símbolo é Cerquilha ou Cardinal
´ – Acento agudo
^ – Acento circunflexo
~ – Til
” – Aspas
/ – Barra
\ – Barra invertida ou contra-barra
– Traço
> – Maior que
& – E comercial
————————–
Alguns comandos neste texto meu são precedidos por dois tracinhos – – mas podem aparecer na internet como se fossem um traço só —
COMANDOS BÁSICOS
ls: lista os arquivos e diretórios da pasta (DIR no DOS);
clear: limpa a tela (CLS no DOS);
cd ___: entra em um diretório
cd: vai direto para o diretório raiz do usuário conectado
: abre uma linha de comando “livre” , onde você pode digitar um comando extenso (digite q e clique em enter para sair)
pwd: mostra o diretório inteiro que você está
cat: Imprime saída de texto.
df: Mostra as partições usadas ou livres do HD
|more: lista o arquivo com pausa de linha em linha (exemplo: CAT leiame |more)
|lpr: imprime o arquivo listado
free: mostra a memória do computador (MEM no DOS)
shutdown: desliga o computador
shutdown -r now : reinicia o computador
shutdown -h now : desliga o computador. OBS.: O NOW pode ser mudado. Por exemplo:
shutdown -r +10 e o sistema irá reiniciar daqui a 10 minutos).
Reboot: reinicia o sistema instantaneamente (pouco recomendável, preferível shutdown
-r now). Use somente em emergências
startx: inicia o X-Windows (interface gráfica) do Linux
mkdir: cria um diretório (MD no DOS)
rmdir: destrói um diretório VAZIO (RD no DOS)
rm: apaga um arquivo (DEL no DOS)
rm -r: apaga um diretório
who: mostra quem está usando a máquina
wc: conta a quantidade de:
wc -c arquivo : quantidade de bytes
wc -w arquivo : quantidade de palavras
wc -l arquivo : quantidade de linhas
date: mostra data e hora
type: explica um determinado arquivo do sistema
file: descreve um determinado arquivo
find / – name ____ : procura arquivo “____”
useradd nome_do_novo_usuário: cria uma nova conta usuário
passwd nome_do_usuário: cria ou modifica a senha do usuário
userdel -r nome_do_usuário: apaga um usuário
su: passa para o superusuário (perceba que no prompt irá mudar o $ pelo #)
sndconfig: permite configurar a placa de som
TAR: arquivo para criar Backups
TAR -c: cria
TAR -x: restaura
TAR -v: lista cada arquivo
TAR -t: lista os arquivos de backups
write: escreve mensagens para outro usuário em rede
mv: move arquivos
linuxconf: configuração do Linux
alias: possibilita a criação de comandos simples
&: coloca o comando desejado em background, ou seja, trabalha enquanto você faz outra coisa no computador
ps: relata os processos em execução
kill: encerra um ou mais processos em andamento
history: mostra os comandos que o usuário já digitou
lpr: imprime um arquivo (exemplo: lpr arquivo)
lpq: mostra o status da fila de impressão
lprm: remove trabalhos da fila de impressão
mtools: permite o uso de ferramentas compatíveis com DOS. Após digitar o comando, você verá que todo comando do DOS terá um M na frente. É normal.
PRATICAMENTE TODOS OS COMANDOS POSSUEM PARÂMETROS QUE PERMITEM INCREMENTAR SUAS FUNCIONALIDADES.
Se eu digitar o comando ls com o parâmetro -R (ls -R), este mostrará todos os arquivos do diretório/pasta, inclusive os ocultos.
ABRO O EMULADOR DE TERMINAL QUE USA O BASH, BUSCANDO NO MENU DO LINUX O TERMINAL. O BASH É O INTERPRETADOR DE COMANDOS DO TERMINAL LINUX.
O BASH É UMA LINGUAGEM QUE DEVE SER PRATICADA EM MODO INTERATIVO. A GENTE QUE QUER APRENDER ALGUMA COISA DE BASH DEVE SER ATIVO E TESTAR OS COMANDOS. LER, ENTENDER E PRATICAR. BRINCAR COM O TERMINAL DO LINUX, PARA MIM, É PRATICAR.
Para eu saber sobre comandos, posso usar man + nome_do_comando, info + nome_do_comando, nome_do_comando + help.
Vou usar o Terminal em modo interativo. Tem comandos built in que são internos, e comandos não internos. O Terminal usa pipes e tem uma filosofia que é saber que A UNIÃO DE VÁRIOS COMANDOS, PIPES E PARÂMETROS FAZ A FORÇA.
O Terminal possui meios para ser executado em primeiro plano e segundo plano. Terminal e Console, são duas coisas diferentes. Shell script usado no terminal do Linux, nada mais é que dialogos programados. O terminal controla comandos executados. Pausa, para, reinicia… No Bash do terminal Linux posso executar multiplos comandos e posso fazer os comandos se comunicarem em primeiro plano e em segundo plano.
VEJO ALGO PARECIDO COM ISTO AO ABRIR O TERMINAL:
nome_do_usuário@nome_do_computador ~ $
Ao instalar a distro Linux, eu criei um nome de usuário e um nome para o computador e uma senha de administrador com cinco letras maiúsculas, cinco letras minúsculas, cinco simbolos e cinco números.
Quando o terminal pedir a senha ela será invisível. É uma interação entre o teclado e o terminal.
.
user@pc ~$
.
user é o usuário que está logado; pc é a máquina em que está logado; @ indica que user está logado em pc; ~ indica que o usuário está dentro do seu diretório pessoal, ou seja, /home/user; $ indica que é um usuário comum e não o administrador do sistema. Se fosse o administrador do sistema o simbolo seria #. Os diretórios mais especiais do Linux atualmente são /dev, /proc, /sys.
.
Para poder navegar pelas pastas do Linux, eu quero entender como estas pastas são organizadas. Estas pastas que são chamadas também de diretórios, possuem uma descrição fácil de entender.
.
ESTRUTURA DE DIRETÓRIOS/PASTAS DO LINUX
Diretório | Descrição
————————————
/bin Arquivos binários de comandos essenciais do sistema.
————————————
/boot Arquivos de boot (inicialização; boot-loader; Grub); kernel do Linux.
————————————
/dev Dispositivos (devices) de entrada/saída: floppy, hardisk, cdrom, modem .
————————————
/etc Arquivos de configuração (scripts) e inicialização.
————————————
/home Diretório local (home) de usuários.
————————————
/lib Bibliotecas e módulos(drives): compartilhadas com freqüência.
————————————
/mnt Diretório de montagem de dispositivos, sistemas de arquivos e partição.
————————————
/opt Para instalação de programas não oficiais da distribuição.
————————————
/proc Diretório virtual (RAM) onde rodam os processos ativos.
————————————
/root Diretório local do superusuário (root).
————————————
/sbin Arquivos de sistema essenciais (binários do superusuário).
————————————
/tmp Arquivos temporários gerados por alguns utilitários.
————————————
/usr Arquivos de usuários nativos da distribuição.
————————————
/usr/local Para instalação de programas não oficiais da distribuição.
————————————
/usr/src Arquivos fontes do sistema necessários para compilar o kernel.
————————————
/var Arquivos de log e outros arquivos variáveis.
————————————
.
ENTENDENDO COMO FUNCIONAM OS COMANDOS DO LINUX
.
Os comandos são como uma linha de produção. Cada comando executa uma função e no final temos o produto pronto. Por exemplo, os comandos ls, mkdir, cd, touch, echo, ps, pid, tty, find são comandos internos do Bash. O ls lista pastas e diretórios. O mkdir cria pastas. O cd muda de pasta ou diretório. O touch cria arquivos e atualiza data de acesso de arquivos e pastas. O echo ecoa o parâmetro que foi passado para ele. O ps permite ver processos, programas que estão rodando no sistema. O pid mostra o número do processo. O tty informa sobre o terminal. O find procura por arquivos em pastas e diretórios. Se eu quisesse ver todos os processos digitaria no terminal:
ps -ax
.
Se eu quisesse procurar por comandos executados anteriormente apertaria as teclas:
ctrl+R
.
Todos os comandos ficam gravados em um histórico que eu posso apagar se quiser digitando:
history -c
.
Se eu quisesse ver os arquivos de uma pasta exibidos por data de acesso usaria:
ls -t
Se eu quiser ver a pasta Imagens em primeiro lugar, digito:
touch Imagens
Depois digito:
ls -t
Se eu quiser ver a pasta Documentos em primeiro lugar, digito:
touch Documentos
Depois digito:
ls -t
APRENDENDO MAIS SOBRE O TERMINAL DO LINUX
O terminal possui entrada. Possui um local onde acontece o processo. Possui saida principal. Possui saída de erro. Então o terminal tem entradas e saídas que são usadas por processos, programas ou comandos em execução que por sua vez possuem identificadores PID. Um byte é igual a um caractere do teclado.
Pela entrada padrão do terminal (stdin) o computador (hardware+software) ouve. Acontece então um processo e obtemos respostas, pois a máquina fala pelas saidas padrão (stdout) e saida de erro (stderr) que são impressas na tela do terminal.
Posso redirecionar isto que aparece na tela do terminal para dentro de arquivos. Existem dois tipos de direcionamentos que estou aprendendo agora. Destrutivo e não destrutivo. Para redirecionar respostas para dentro de arquivos usa-se o simbolo >.
ATALHOS DE TECLADO DO TERMINAL LINUX
Atalho | Função
Ctrl + a Move o cursor para o início da linha
Ctrl + e Move o cursor para o final da linha
Ctrl + l Limpa a tela, semelhante ao comando clear
Ctrl + u Apaga do cursor ao início da linha.
Ctrl + k Apaga do cursor ao final da linha.
Ctrl + w Apaga uma palavra antes do cursor.
Ctrl + _ Desfaz as últimas mudanças.
!! Executa o último comando no histórico.
!abc Executa o último comando no histórico começando com abc.
!n Executa o comando de número n no histórico.
^abc^xyz Substitui a primeira ocorrência de abc por xyz no último comando e executa o mesmo.
Redirecionando a saída do ls para um arquivo chamado saida-do-comando-ls.
Se eu digitar:
ls > saida-do-comando-ls
O que apareceria na tela do terminal vai ser gravado em um arquivo chamado saida-do-comando-ls. Usei “maior que” > comando destrutivo que vai reescrever sobre a informação no arquivo.
Para eu ver o que está escrito no arquivo saida-do-comando-ls uso cat. Fica assim:
cat saida-do-comando-ls
Se eu digitar:
ls >> saida-do-comando-ls
O que apareceria na tela do terminal vai ser gravado junto com o que estiver gravado anteriormente, em um arquivo chamado saida-do-comando-ls. Usei “dois maior que” >> comando não-destrutivo que vai escrever mais uma vez a informação no arquivo.
Para eu ver o que está escrito no arquivo saida-do-comando-ls uso cat. Fica assim:
cat saida-do-comando-ls
Para redirecionar usando a saida de erro (stderr[2]), usando modo não destrutivo (>>) e modo destrutivo (>) digito:
ls 2>> saida-do-comando-ls
ls 2> saida-do-comando-ls
Para forçar erro uso ls com uma palavra inventada qualquer.
ls plah
Para gravar a resposta “ls: não foi possível acessar ‘plah’: Arquivo ou diretório não encontrado” da saida de erro (2) mandando a informação do comando ls de plah para errols
ls plah 2> errols
Para eu ver o que está escrito em errols uso o comando cat. Fica algo assim:
~ $ cat errols
ls: não foi possível acessar ‘plah’: Arquivo ou diretório não encontrado
Se eu usar:
ls plah 1> errols
Não vai dar nada. Porque eu usei o comando destrutivo (>).
user@pc ~ $ cat errols
user@pc ~ $
EU QUERO SABER, ONDE ESTOU NO SISTEMA. QUERO QUE O TERMINAL ME DICA ONDE ESTOU. DIGITO pwd E APERTO A TECLA ENTER. RESULTADO:
user@pc ~$ pwd
/home/user
POSSO USAR COMANDOS PARA DIRECIONAR INFORMAÇÕES FILTRADAS PARA ARQUIVOS USANDO O COMANDO FIND. Uso find, cat, 1>, 2>, &> ESCREVO O SEGUINTE:
find (A resposta será enorme e tudo misturado.)
find /sys (A resposta será enorme e tudo misturado.)
find /sys 1> saidafind 2> errofind (Neste comando uma parte vai para um arquivo que vai receber a resposta da saida padrão e outra que vai criar um arquivo que vai receber a resposta da saida de erro)
Agora digito:
cat saidafind
cat errofind
find /sys &>tudofind (Neste caso tudo da saida 1 ou 2 para tudofind)
cat tudofind
PARA DIRECIONAR A SAIDA EM Y ESCREVO:
ls > saida-ls
cat saida-ls
ls sssss > saida-ls
cat saida-ls
ls sssss > saida-ls 2>&1 (Neste caso manda tudo para o arquivo saida-ls)
ls sssss > saida-ls 1>&2
ls > saida-ls 1>&2
ls > saida-ls 2> saidalserro 1>&2
cat saidalserro
ls &> tudols
PARA FECHAR UMA DAS SAIDAS. TAPANDO CANOS.
ls
ls 1>&- (O menos fecha o saida1/cano1)
ls 1>&- 2>&- (Fecho as duas saídas)
Sobre o &:
O & coloca o comando desejado em background.
TAPAR E JOGAR EM LUGAR NENHUM. MÉTODO UNIX E LINUX.
ls > /dev/null
ls ssss >/dev/null
ls ssss > /dev/null 2>/dev/null
Redirecionamento entre processos usando o comando grep. O grep pega a entrada, filtra e só joga no terminal o que combina com o que foi passado. Se digitar grep teste, só será imprimido o que combinar com teste. Para filtrar a saída do ls usando o grep:
ls | grep saida
ls | grep erro
Usando o Bash pega-se a saida e conecta-se na entrada com o uso de pipe “|”. O grep filtra expressões regulares e filtra texto. O pipe redireciona a saida padrão 1.
ls |& grep erro
O comando grep significa (Globally Search a Regular Expression and Print). A ideia é procurar texto em uma string ou dentro de arquivos e mostrar linhas, ocorrências, usar combinações para pesquisar e o resultado da pesquisa ser mostrado na tela. O comando grep já vem instalado no Linux. Para confirmar e verificar a versão uso os comandos grep e grep com o PARÂMETRO -V. Exemplos abaixo:
~ $ grep
Uso: grep [OPÇÃO]… PADRÃO [ARQUIVO]…
Experimente “grep –help” para mais informações.
~ $ grep -V
grep (GNU grep) 3.0
Copyright (C) 2017 Free Software Foundation, Inc.
Licença GPLv3+: GNU GPL versão 3 ou superior <http://gnu.org/licenses/gpl.html>.
Este é um software livre: você é livre para alterá-lo e redistribuí-lo.
NÃO HÁ GARANTIAS, na máxima extensão permitida por lei.
Escrito por Mike Haertel e outros, veja <http://git.sv.gnu.org/cgit/grep.git/tree/AUTHORS>.
PARÂMETROS PARA O COMANDO GREP QUE IREI UTILIZAR E SUAS FUNÇÕES:
-c Conta quantas vezes apareceu a string que esta pesquisando
-v Mostra na tela “tudo” menos onde houver a ocorrência da string pesquisada
-i Realiza uma busca pela string ignorando o case, sendo case-insensitive
-o Ira mostrar na tela apenas as ocorrências da string pesquisada ignorando o resto
-n Ira mostrar na tela na primeira coluna a linha onde encontrou a string pesquisada
-B Numero de linhas a serem impressas antes da linha que contem a string pesquisada [BEFORE]
-A Numero de linhas a serem impressas na tela depois da encontrar a linha com a string [AFTER]
-C Quantidade de linhas antes e depois da linha que contem a string [CONTEXT]
-q Ira procurar pela string informada, porém estará em modo silencioso, nada sera impresso na tela, porém caso encontre o comando encerra com 0, caso não encontre nada será 1
-E Extende o uso de Regex no padrão e combinação, usando logica AND e OR por exemplo
-f Um arquivo com combinações de padrões com Regex, podendo usar varias combinações
-l Mostra somente o nome do arquivo onde foi encontrado a string pesquisada
-L Semelhante ao -v, porque mostra apenas os arquivo que não contem a string informada
-h Pesquisa varias arquivos, diretórios se com -r mas não mostra o nome dos arquivos
-r Ira realizar uma pesquisa recursiva em todos os diretórios a partir do informado
–color Deve-se passar o parâmetro ‘never’ caso não queira que a saída marque com cor a string ou ‘auto’ e ‘always’ para operar conforme necessite. Pode mudar a cor alterando GREP_COLOR, GREP_COLORS no environment
Vou criar um arquivo chamado palavras.txt e inserir um texto dentro e brincar com o grep.
Para fazer isto, uso o comando echo seguido dos parâmetros -ne.
.
As palavra que estarão no texto devem ser abraçadas por aspas ” no início e no fim. Cada linha do texto que é separada por \n e cada palavra é separada por espaços e o texto em si é escrito como se eu fosse escrever um texto normal. Para direcionar este texto entre aspas “texto” devo usar o simbolo menor que > seguido do nome do arquivo a ser criado seguido da extenção no caso aqui .txt. Veja o exemplo abaixo:
~ $ echo -ne “Esta é a primeira linha.\nEsta é a segunda linha.\nEsta é a terceira linha.\n:) E assim por diante…\n” > texto-teste.txt
Para ver o que está escrito digito cat texto-teste.txt. Resultado:
~ $ cat texto-teste.txt
Esta é a primeira linha.
Esta é a segunda linha.
Esta é a terceira linha.
🙂 E assim por diante…
Outro exemplo:
~ $ echo -ne “A primeira linha vai acabar agora. \nA segunda linha começa agora e já terminou. \nEsta é a terceira linha que agora acabou. \nPor fim, a quarta linha é mesmo o fim. \n” > texto4.txt
~ $ cat texto4.txt
A primeira linha vai acabar agora.
A primeira linha começa agora e já terminou.
Esta é a terceira linha que agora acabou.
Por fim, a quarta linha é mesmo o fim.
~ $ echo -ne ‘A “primeira” linha vai acabar agora. \nA “segunda” linha começa agora e já terminou. \nEsta é a “terceira” linha que agora acabou. \nPor fim, a “quarta” linha é mesmo o fim. \n’ > texto4.txt
~ $ cat texto4.txt
A “primeira” linha vai acabar agora.
A “segunda” linha começa agora e já terminou.
Esta é a “terceira” linha que agora acabou.
Por fim, a “quarta” linha é mesmo o fim.
VOU FAZER OUTRO TEXTO:
~ $ echo -ne “rumor\nasa casa\nCasa Asa\nCASA ASA\nRaspberryPI asa casa\nRaspberry PI Casa Asa Nasa\nRaspberry B PI CASA ASA NASA\nArduino Casa Asa Nasa\narduino\nARDUINO\nIDEArduino\nLinux, conhecimento é poder\nEu não programo Python e você?\n” > palavras.txt
Para eu visualizar o arquivo palavras.txt no terminal eu vou usar o comando cat seguido do nome completo do arquivo. Exemplo abaixo:
~ $ cat palavras.txt
rumor
asa casa
Casa Asa
CASA ASA
RaspberryPI asa casa
Raspberry PI Casa Asa Nasa
Raspberry B PI CASA ASA NASA
Arduino Casa Asa Nasa
arduino
ARDUINO
IDEArduino
Linux, conhecimento é poder
Eu não programo Python e você?
VOU USAR O GREP E PESQUISAR PELA STRING “Raspberry“, POSSO USAR DE DUAS MANEIRAS COM O cat UM PIPE “|” E LOGO EM SEGUIDA UM grep OU DIRETAMENTE COM O COMANDO, A PRIMEIRA OPÇÃO É MUITO UTILIZADA, PORÉM PERDE PERFORMANCE NO CASO DE REALIZAR PESQUISA EM MUITOS ARQUIVOS OU EM UM ARQUIVO LONGO.
$ cat palavras.txt | grep “Raspberry”
RaspberryPI asa casa
Raspberry PI Casa Asa Nasa
Raspberry B PI CASA ASA NASA
$ grep “Raspberry” palavras.txt
RaspberryPI asa casa
Raspberry PI Casa Asa Nasa
Raspberry B PI CASA ASA NASA
CASO EU QUEIRA CONTAR O NUMERO DE OCORRÊNCIAS DA STRING “Raspberry”:
$ grep -c “Raspberry” palavras.txt
3
SE EU QUISER VER TUDO MENOS AS STRINGS QUE CONTENHAM “Raspberry”:
$ grep -v “Raspberry” palavras.txt
rumor
asa casa
Casa Asa
CASA ASA
Arduino Casa Asa Nasa
arduino
ARDUINO
IDEArduino
Linux, conhecimento é poder
Eu não programo Python e você?
AGORA QUERO PESQUISAR PELA STRING “arduino”.
$ grep “arduino” palavras.txt
arduino
Temos Arduino escrito de diversas maneiras, então vamos pedir para ser case-insensitive.
~ $ grep -i “arduino” palavras.txt
Arduino Casa Asa Nasa
arduino
ARDUINO
IDEArduino
E SE NO LUGAR DE MOSTRAR A LINHA INTEIRA OU O QUE ESTIVER JUNTO EU MOSTRAR APENAS A STRING PROCURADA? VOU USAR OS PARÂMETROS -o, -oi.
~ $ grep -o “arduino” palavras.txt
arduino
~ $ grep -oi “arduino” palavras.txt
Arduino
arduino
ARDUINO
Arduino
~ $ grep -oi “Raspberry” palavras.txt
Raspberry
Raspberry
Raspberry
SE EU PRECISAR SABER O NUMERO DA LINHA ONDE FOI ENCONTRADA A STRING.
~ $ grep -n “Raspberry” palavras.txt
5:RaspberryPI asa casa
6:Raspberry PI Casa Asa Nasa
7:Raspberry B PI CASA ASA NASA
AGORA VOU PESQUISAR PELA STRING “arduino” E OBTER TAMBÉM AS 2 LINHAS ANTES DA STRING ENCONTRADA.
~ $ grep “arduino” -B 2 palavras.txt
Raspberry B PI CASA ASA NASA
Arduino Casa Asa Nasa
arduino
O MESMO PODEMOS FAZER OBTÉM AS LINHAS DEPOIS DA LINHA COM A STRING PESQUISADA.
$ grep “arduino” -A 2 palavras.txt
arduino
ARDUINO
IDEArduino
E PODEMOS UNIR AS DUAS OPÇÕES, PEGANDO E IMPRIMINDO LINHAS ANTES E DEPOIS DA LINHA QUE CONTEM A STRING PESQUISADA.
~ $ grep “arduino” -C 2 palavras.txt
Raspberry B PI CASA ASA NASA
Arduino Casa Asa Nasa
arduino
ARDUINO
IDEArduino
CASO NÃO QUEIRA MOSTRAR NADA NA TELA, SÓ SABER SE TEVE SUCESSO OU NÃO NA PESQUISA.
~ $ grep -q “arduino” palavras.txt
~ $ echo $?
0
~ $ grep -q “Beaglebone” palavras.txt
~ $ echo $?
1
DESTA VEZ VOU CRIAR MAIS 2 ARQUIVOS sistema.txt E hardware.txt, E TAMBÉM COPIAR A SAÍDA DO dmesg PARA dmesg.log E BRINCAR COM ESTES CARAS.
$ echo -ne “Linux Solus Manjaro Lubuntu Ubuntu\nLinux Devuan Debian\nLinux Solus Project Mint\nLinux Solus Manjaro Debian Devuan CentOS\nRaspbian\nYocto RaspberryPI\nBuildroot RaspberryPI\n” > sistema.txt
$ echo -ne “ARM 1176JZF\nARM Cortex-A7\nBCM2835\nBCM2836\nBeaglebone Black\nAM3358\n” > hardware.txt
$ dmesg > dmesg.log
POSSO AGREGAR MAIS PALAVRAS PARA REALIZAR MEUS TESTES.
AGORA EU QUERO PESQUISAR EM QUALQUER ARQUIVO E QUE CONTENHA A STRING “Raspberry”.
~ $ grep “Raspberry” *
palavras.txt:RaspberryPI
palavras.txt:Raspberry PI
palavras.txt:Raspberry B PI
sistema.txt:Yocto RaspberryPI
sistema.txt:Buildroot RaspberryPI
~ $ grep “Raspberry” ./*
./palavras.txt:RaspberryPI
./palavras.txt:Raspberry PI
./palavras.txt:Raspberry B PI
./sistema.txt:Yocto RaspberryPI
./sistema.txt:Buildroot RaspberryPI
OS DEMAIS PARÂMETROS ANTERIORES SE APLICAM AQUI TAMBÉM.
$ grep -n “Raspberry” *
palavras.txt:5:RaspberryPI
palavras.txt:6:Raspberry PI
palavras.txt:7:Raspberry B PI
sistema.txt:6:Yocto RaspberryPI
sistema.txt:7:Buildroot RaspberryPI
SE EU CRIAR UM DIRETÓRIO exemplo/ E MOVER O palavras.txt PARA ELE SERÁ QUE VAI ENCONTRAR A STRING “Raspberry” NELE AINDA?
$ mkdir exemplo && mv palavras.txt exemplo/
$ grep “Raspberry” *
grep: exemplo: Is a directory
sistema.txt:Yocto RaspberryPI
sistema.txt:Buildroot RaspberryPI
ELE AVISA QUE EXISTE UM DIRETÓRIO ONDE ESTA SENDO FEITA A PESQUISA, PARA QUE ELE ACESSE O(S) DIRETÓRIO(S) DEVE-SE PASSAR O PARÂMETRO -r PARA RECURSIVIDADE.
$ grep -r “Raspberry” *
exemplo/palavras.txt:RaspberryPI
exemplo/palavras.txt:Raspberry PI
exemplo/palavras.txt:Raspberry B PI
sistema.txt:Yocto RaspberryPI
sistema.txt:Buildroot RaspberryPI
AS VEZES SÓ INTERESSA SABER A OCORRÊNCIAS MAS NÃO O ARQUIVO.
$ grep -hr “Raspberry” *
RaspberryPI
Raspberry PI
Raspberry B PI
Yocto RaspberryPI
Buildroot RaspberryPI
CASO QUEIRA APENAS SABER QUAL ARQUIVO CONTEM A STRING MAS NÃO PRECISA MOSTRAR ELA.
$ grep -lr “Raspberry” *
exemplo/palavras.txt
sistema.txt
SE QUISER SABER OS ARQUIVOS QUE NÃO POSSUEM A STRING PESQUISADA.
$ grep -Lr “Raspberry” *
dmesg.log
hardware.txt
HABILITANDO OU NÃO O USO DA SAÍDA COLORIDA.
$ grep -r –color=always “Raspberry” *
exemplo/palavras.txt:RaspberryPI
exemplo/palavras.txt:Raspberry PI
exemplo/palavras.txt:Raspberry B PI
sistema.txt:Yocto RaspberryPI
sistema.txt:Buildroot RaspberryPI
$ grep -r –color=never “Raspberry” *
exemplo/palavras.txt:RaspberryPI
exemplo/palavras.txt:Raspberry PI
exemplo/palavras.txt:Raspberry B PI
sistema.txt:Yocto RaspberryPI
sistema.txt:Buildroot RaspberryPI
O COMANDO cd SERVE PARA ACESSAR/NAVEGAR ENTRE DIRETÓRIOS. DIGITO:
user@pc ~$ cd nome_da_pasta
user@pc ~$ cd .. # para sair de diretório, note que os dois pontos estão separados do comando.
user@pc ~$ ls # lista aquivos ou pastas de um determinado diretório. O ls pode ser usado com opções -a, -A, –author, -b, –block-size, -B, -c, -C, -d, -f, -F, -G, -h e outros…
O diretório indicado para instalar programas opcionais é o diretório /opt.
user@pc ~$ lsusb # lista os periféricos que estão conectados na porta usb.
user@pc ~$ mkdir # cria uma pasta.
user@pc ~$ rmdir # remove um diretório/pasta vazia.
user@pc ~$ cat # concatena arquivos e imprime na saída padrão (exibe na tela). Em arquivos, usao o cat para listar o conteúdo deles na tela. Com o uso de argumentos, podsso usá-lo para unir diferentes arquivos em um só, dentre outra funções. É prática comum utilizar isso para juntar arquivos de vídeo grandes, como filmes, que muitas vezes são divididos em várias partes. Para unir video1.mpeg a video2.mpeg emvideo.mpeg que estão em /home/user usaria o comando abaixo:
user@pc ~$ cat video1.mpeg video2.mpeg > video.mpeg
user@pc ~$ touch # O comando touch é usado atualizar as informações sobre as datas de último acesso e última modificação de um arquivo. Se o arquivo não existir, ele é criado, por padrão. Isso faz o touch ser muito utilizado para criar arquivos vazios, através do comando touch [arquivo]. -a modifica apenas a data do último acesso;
-c, Não cria arquivos, caso eles não existam;
-m, Modifica apenas a data de modificação;
-t, A data e hora a ser utilizada para o último acesso ou última modificação. O formato utilizado é MMDDhhmm (mês, dia, hora e minuto)
Se eu quiser criar um arquivo chamado sinai.txt usando o comando touch. Faço assim:
touch sinai.txt
Se quiser criar vários arquivos de uma vez só:
touch sina bina pena borda perl
Depois digito:
ls
user@pc ~$ sudo # o comando sudo é um dos mais utilizados, faz requerimento de superusuário. Requer senha.
user@pc ~$ sudo su # após digitar a senha todas as funções realizadas no terminal estará sendo feita como superusuário, prática não muito recomendada.
user@pc ~$ top # exibe todos os processos que estão sendo executados, utilizando para “matar” um processo que está “travado”.
user@pc ~$ ps # assim como o top também lista os processos que estão sendo executados, porém para “matar” o processo necessita pegar o número do PID e utili class=”rol-comandos”zar o comando kill.
user@pc ~$ kill # comando para “mata” um processo travado por meio do PID que pode ser adquirido por meio do comando ps
user@pc ~$ cp # comando para copiar um arquivo ou diretório para um outro local, com o mesmo nome ou com nome diferente.
user@pc ~$ mv # comando para mover ou renomear um arquivo ou diretório para um outro local
user@pc ~$ rm # O rm é utilizado para excluir arquivos.
user@pc ~$ rm -f # remove forçado
user@pc ~$ rm -rf # Exclui recursivamente todo o conteúdo do diretório e o próprio diretório. Quando quiser excluir um diretório que não está vazio, utilize esse parâmetro.
user@pc ~$ ln # Esse é o comando utilizado para criar links, simbólicos ou absolutos.
user@pc ~$ cmp # Esse comando é utilizado para comparar dois arquivos e mostrar a primeira diferença entre eles. Use para certificar-se de que dois arquivos possuem ou não o mesmo conteúdo.
user@pc ~$ diff # Esse comando compara dois arquivos de texto e mostra as diferenças entre eles.
user@pc ~$ patch # Utilizamos esse comando para atualizar as diferenças geradas através do comando diff.
user@pc ~$ grep # O grep é utilizado para encontrar padrões em arquivos de texto, ou, em outras palavras, procura num arquivo todas as linhas que possuem a palavra ou expressão informada e as exibe na tela.
user@pc ~$ cut # O cut é utilizado para selecionar colunas de texto em um arquivo.
user@pc ~$ head # Usamos esse comando para exibir as linhas iniciais de um arquivo.
user@pc ~$ more # Usamos esse comando para realizar a paginação de arquivos de texto cujo conteúdo não cabe na tela.
user@pc ~$ less # O less tem a mesma utilidade do more, com a vantagem de poder rolar o texto exibido para cima e para baixo através do uso dos direcionais, além de contar com um localizador de texto.
user@pc ~$ sort # Usamos esse comando para classificar as linhas de um arquivo de texto.
user@pc ~$ tail # Esse comando é utilizando para mostrar as últimas linhas de um arquivo de texto.
user@pc ~$ wc # Conta o número de linhas, palavras, caracteres e bytes nos arquivos.
user@pc ~$ find # O find (procurar, em inglês) é uma ferramenta que utilizamos para localizar arquivos ou diretórios no sistema de arquivos.
user@pc ~$ whereis # Localiza o executável, arquivo/diretório de configuração, diretórios de bibliotecas, arquivos compartilhados, código-fonte e caminho da página de manual do programa especificado.
user@pc ~$ which # Exibe o caminho completo para o comando selecionado.
user@pc ~$ fuser # Esse programa é utilizado para descobrir quais processos estão utilizando determinados arquivos ou soquetes.
user@pc ~$ df # Mostra o espaço utilizado de cada partição.
user@pc ~$ du # Esse comando, sigla de disk usage (uso de disco), é usado para estimar o espaço em disco usado pelos arquivos. Em outras palavras, usamos o du para saber o tamanho dos arquivos.
user@pc ~$ free # Comando muito utilizado para análise do desempenho do sistema, o free exibe informações sobre o uso de memória pelo computador.
user@pc ~$ time # Esse é um comando muito útil para medir o desempenho do sistema. Com o time podemos medir o tempo, em segundos, necessários para executar um processo ou programa.
user@pc ~$ uptime # Mostra o período em que o sistema permaneceu em processamento desde que foi ligado.
user@pc ~$ dmesg # Esse comando é utilizado para ver as mensagens de inicialização do sistema. Útil para analisar eventuais mensagens de erro exibidas devido a qualquer problema que esteja ocorrendo durante a inicialização. Como as mensagens são muito extensas, utilize o more ou o less para visualizar as informações:
user@pc ~$ dmesg | more
user@pc ~$ dmesg | less
user@pc ~$ echo # Exibe mensagens na tela. Escreve textos em arquivos. Esse comando é utilizado principalmente para a construção de scripts de sistema. Exemplo:
~ $ echo “Oi Mundo!”
~ $ echo “Oi Mundo!” && echo “Tchau Mundo!”
~ $ echo “É fácil escrever usando o comando echo” > texto2.txt
~ $ cat texto2.txt
~ $ echo “esta é minha segunda linha” >> texto2.txt
~ $ cat texto2.txt
~ $ echo “esta é minha terceira linha” >> texto2.txt
~ $ cat texto2.txt
ECHO usando -e, “, r, e \n
~ $ echo -e “Bom, esta é a primeira linha.\r\nEsta é a segunda linha\r\nEsta é a terceira linha!”
USANDO COMANDO ECHO PARA ESCREVER VÁRIAS LINHAS E CRIAR UM NOVO ARQUIVO DE TEXTO TUDO AO MESMO TEMPO:
~ $ echo -e “O nome do arquivo de texto será texto3.txt e esta é a primeira linha.\r\nEsta é a segunda linha do arquivo texto3.txt.\r\nEsta é a terceira linha do arquivo texto3.txt e ponto final.\r\nDepois eu posso usar o comando grep para ver o que acontece.” > texto3.txt
user@pc ~$ sync # Esse comando é utilizado para gravar os dados armazenados em cache nos locais apropriados. O uso mais comum é para gravar os dados em unidades de disco removível, geralmente disquete.
user@pc ~$ sudo shutdown -r now # Reinicia o computador. Por padrão, somente o root pode executar esse comando.
user@pc ~$ exit # sair do terminal, fechar o terminal
user@pc ~$ shutdown # Desligar o computador
user@pc ~$ shutdown -h now # desligar o computador agora
user@pc ~$ clear # Limpa a tela do terminal
user@pc ~$ history # O comando history (histórico) mostra a lista dos últimos comandos executados pelo usuário corrente. Isso é útil quando há a necessidade de executar um comando extenso, com muitos parâmetros, do qual não consigamos nos lembrar, ou para fazer auditoria.
Quero saber qual o release estou usando. Digito:
user@pc ~$ lsb_release -a
Quero saber que dia é hoje. Digito no terminal e recebo a a resposta:
user@pc ~$ date
Qui Abr 20 03:56:35 BRT 2017
Quero saber o calendário digito e recebo a resposta:
user@pc ~$ cal
Abril 2017
Do Se Te Qu Qu Se Sá
1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30
Instalei lm-sensors. Quero saber a temperatura da máquina. Digito sensors e recebo a resposta:
user@pc ~$ sensors
acpitz-virtual-0
Adapter: Virtual device
temp1: +48.0°C (crit = +104.0°C)
temp2: +48.0°C (crit = +104.0°C)
coretemp-isa-0000
Adapter: ISA adapter
Physical id 0: +48.0°C (high = +105.0°C, crit = +105.0°C)
Core 0: +48.0°C (high = +105.0°C, crit = +105.0°C)
Core 1: +48.0°C (high = +105.0°C, crit = +105.0°C)
Quero saber o espaço em disco do sistema de arquivos usado por todas as partições. “df -h” digito e recebo a resposta:
user@pc ~$ df -h
Sist. Arq. Tam. Usado Disp. Uso% Montado em
devtmpfs 1,9G 0 1,9G 0% /dev
tmpfs 2,0G 0
Quero saber a quantidade de memória livre e usada no sistema. “free -m” digito e recebo a resposta:
user@pc ~$ free -m
total used free shared buff/cache available
Mem: 3930 737 109 274 3083 2675
Swap: 3815 0 3815
Quero saber a arquitetura do computador. digito arch que é igual ao comando uname -m, e recebo a resposta:
user@pc ~$ arch
x86_64
user@pc ~$ uname -m
x86_64
Uso “uname” para exibir informação básica e ”uname -a” para exibir todas as informações.
user@pc ~$ uname
Linux
user@pc ~$ uname -a
Linux rf7E 4.4.0-53-generic #74-Ubuntu SMP Fri Dec 2 15:59:10 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux
Quero saber em tempo real informações sobre o meu sistema linux, digito top ou htop:
user@pc ~$ top
user@pc ~$ htop
Comandos interativos mais importantes do ”top”.
”k” – Finaliza, ou seja, “mata” um processo.
”m” – Ativa/Desativa a exibição de informações da memória.
”M” – Ordena os processos pelo uso da memória residente.
”N” – Ordena os processos pelos seus PIDs.
”P” – Ordena os processos pelo uso da CPU (este é o padrão).
”ESPAÇO” – Atualiza imediatamente a visualização do quadro de processos.
”h” – Exibe a ajuda dos comandos interativos do ”top”.
”q” – Abandona o comando ”top”.
Quero saber um quadro atual, porém estático dos processos que estão sendo executados no sistema. Digito e recebo a resposta:
user@pc ~$ ps
PID TTY TIME CMD
9409 pts/0 00:00:00 bash
12148 pts/0 00:00:00 ps
Se eu quiser matar o processo 9409, digito kill -9 e o número do processo. No caso fecharei o terminal que estou usando.
user@pc ~$ kill -9 9409
Aperto enter.
Quero finalizar processos pelo nome ao invés do PID como faz o comando kill. Uso killall.
Se eu tiver aberto o Firefox e quero fecha ele pelo terminal, se eu digitar no terminal ”killall mozilla-firefox” finalizo processo mozilla-firefox, fechando com isso o navegador web Mozilla Firefox. O nome dos processos ativos pode ser observado com uso do comando ps.
Quero verificar o SWAP. Simplificando, pode-se dizer que a memória é de dois tipos: a memória RAM e a SWAP (utilização do disco rígido ou HD). A memória RAM é bastante mais rápida que os HDs, no entanto ela é mais limitada em termos de tamanho. Então o que o Linux faz é utilizar a memória RAM e quando precisar de mais memória utiliza o disco como memória auxiliar. No computador caseiro de 2017, o SWAP pode ser baixo (10).
user@pc ~$ cat /proc/sys/vm/swappiness
10
Vou saber o quanto de memória RAM tenho no computador, que tipo de memória tenho no computador, quando de memória a máquina suporta e muito mais. Digito:
user@pc ~$ sudo dmidecode –type memory
Digito a senha e aperto enter.
Para saber quanto espaço tenho no disco, digito:
user@pc ~$ sudo fdisk -l
Aperto enter.
Quero criar uma pasta chamada dia na pasta Documentos e dentro desta pasta 3 arquivos chamados de azul, verde e roxo tudo pelo terminal. Passo a passo, eu faço assim:
user@pc ~$ pwd
/home/user
user@pc ~$ ls
‘Área de trabalho’ Downloads Música
‘Biblioteca do calibre’ Imagens Público
Documentos Modelos Vídeos
user@pc ~$ cd Downloads
user@pc/Downloads ~$
user@pc/Downloads ~$ pwd
/home/user/Downloads
user@pc/Downloads ~$ ls
user@pc/Downloads ~$ mkdir dia
user@pc/Downloads ~$ ls
dia
user@pc/Downloads ~$ cd dia
user@pc ~/Downloads/dia $
VARIÁVEIS
O que são variáveis? São como gavetas. Gaveta é um compartimento que guarda determinado tipo de conteúdo. Quando abro uma gaveta vejo o que tem dentro desta gaveta. Num armário com muitas gavetas, eu dou nome para cada gaveta. No computador as gavetas possuem dados em bit. Cada letra é um bit. A etiqueta de cada gaveta será o nome da variável. Cada um dos caracteres do teclado cada um é um bit. Como manusear ou criar uma variável no Bash? Sempre tento usar nomes maiúsculos para etiquetar as variáveis.
.
VARIÁVEIS
O que são variáveis? São como gavetas. Gaveta é um compartimento que guarda determinado tipo de conteúdo. Quando abro uma gaveta vejo o que tem dentro desta gaveta. Num armário com muitas gavetas, eu dou nome para cada gaveta. No computador as gavetas possuem dados em bit. Cada letra é um bit. A etiqueta de cada gaveta será o nome da variável. Cada um dos caracteres do teclado cada um é um bit. Dentro de uma variável com um nome. Dentro dela tem bits. Como manusear ou criar uma variável no Bash? Sempre tento usar nomes maiúsculos. O nome da variável é igual ao conteúdo.
.
Criando uma variável chamado CASA:
~$ CASA=tijolo
.
Para ler a variável uso echo, o cifrão “$” e o nome da variável.
.
~ $ echo $CASA
tijolo
.
~ $ CASA=tijolos-ferro-areia-cimento-granito-cascalho
~ $ echo $CASA
tijolos-ferro-areia-cimento-granito-cascalho
.
~ $ CASA=”tijolo cimento dinheiro projeto e sonhos”
~ $ echo $CASA
tijolo cimento dinheiro projeto e sonhos
.
~$ ls
~$ ls -t
~$ ls -lah
~$ pwd
.
~$ echo sem o $ ou sem aspas e comando destrutivo, imprime direto na tela do terminal viu?
~$ clear
~ $ CASA=formigas
~ $ echo $CASA
formigas
.
~ $ CASAESPACOS=”sala cozinha banheiro quarto varanda”
~ $ echo $CASAESPACOS
sala cozinha banheiro quarto varanda
.
Existem vária variáveis criadas automaticamente quando entro no terminal e mudam o comportamento do terminal e dos programas.
O comando abaixo serve para ver várias variáveis que já existem para ver elas usa-se o comando abaixo:
~$ ( }et -o posix ; set )
.
VARIÁVEIS DE AMBIENTE. PARA QUE SERVEM?
Servem para mudar o comportamento durante a execução dos comandos. Podem por exemplo mudar a lingua que está rodando o programa. Variáveis Bash alguma coisa mudam o comportamento do Bash ou dos programas. Existem variáveis de ambiente, por exemplo e para listar, saiba que tem as do Bash e as de ambiente. As do Bash só alteram o Bash. Os comandos de ambiente herdam as variáveis. LANG é uma variável de ambiente. Para listar as variáveis promovidas a variáveis de ambiente:
~$ env
~ $ echo $LANG
pt_BR.utf8
.
COMO PROMOVER VARIÁVEIS?
De local para de ambiente usa-se “export”
~$ export
~$ export CASA
Posso criar variáveis novas.
~$ export NOVAVARIAVEL=”llllllllll”
.
VOU PROCURAR AS VARIÁVEIS:
~$ env
.
PARA ACHAR FÁCIL USO O GREP.
~$ env | grep CASA
~$ env | grep CASAESPACOS
~$ env | grep NOVAVARIAVEL
~$ env | grep SOLUS
.
Algumas variaveis alteram o comportamento dos programas.
PARA MUDAR A VARIAVEL LANG PARA INGLES? SOBREESCREVO A VARIAVEL LANG.
~$ echo $LANG
pt_BR.utf8
~ $ ls dr2ttttttttt
ls: não foi possível acessar ‘dr2ttttttttt’: Arquivo ou diretório não encontrado
~$ export LANG=C
~$ echo $LANG
C
~$ env | grep LANG
LANG=C
~$ ls h7jjjjjj
ls: cannot access ‘h7jjjjjj’: No such file or directory
.
Para voltar a falar português:
~$ export LANG=pt_BR.utf8
~ $ ls ku9sssssssssss
ls: não foi possível acessar ‘ku9sssssssssss’: Arquivo ou diretório não encontrado
.
SE EU NÃO QUERO EXPORTAR, NÃO QUERO FAZER VIRAR VARIÁVEL DE AMBIENTE. SÓ QUERO NA EXECUÇÃO DE UM COMANDO ESPECÍFICO ALTERAR UMA VARIAVEL SEM MODIFICAR AS VARIAVEIS DE AMBIENTE. QUERO QUE FALE INGLÊS SOMENTE UMA VEZ E DEPOIS VOLTE A FALAR PORTUGUÊS. DESTA FORMA A VARIAVEL SÓ VAI EXISTIR DENTRO DO PRÓXIMO COMANDO LS E NÃO VAI SER EXPORTADA PARA VARIÁVEL DE AMBIENTE. PARA FAZER ISTO:
~ $ LANG=C ls sfrftrbtby
ls: cannot access ‘sfrftrbtby’: No such file or directory
~ $ ls sfrftrbtby
ls: não foi possível acessar ‘sfrftrbtby’: Arquivo ou diretório não encontrado
.
AS VARIÁVEIS ALTERADAS SÓ VALEM PARA O TERMINAL QUE ESTOU TRABALHANDO. SE EU ABRIR OUTRO TERMINAL AS VARIÁVEIS NÃO IRÃO VALER.
.
O Bash herda as variáveis para se autoconfigurar em /etc/bash.bashrc e ~/.bashrc. O .bashrc fica no diretório do usuário. No .bashrc posso colocar scripts meus.
.
VARIAVEIS ESPECIAIS OU DINAMICAS
Posso criar variaveis. O Bash tem variáveis especiais também. Variaveis dinamicas que enquanto está executando modifica o conteudo das gavetas. Modifica o conteúdas variáveis. Executa em outra instancia do Bash. É muito útil em shell scripts.
~ $ echo $(ls)
Área de trabalho Documentos Downloads Imagens Modelos Música Público Vídeos
~ $ echo 1+1
1+1
~ $ echo $((1+1))
2
~ $ echo 7*9
7*9
~ $ echo $((7*9))
63
.
EXPANSÃO – Algo pequeno transformado em algo maior.
Bash varre a linha de comando e substitui. Tenta encontrar padrões transformando em outra coisa. Como arquivos e diretórios. O shell expande as coisas que tem caracteres especiais (variáveis). Exemplo abaixo:
.
[1-9]
{1,2,3}
?
~
—————-
Executo:
~ $ echo ~
/home/sol
.
Asterisco “*” substitui todos os arquivos e diretorios do diretorio atual. Asterisco significa “qualquer coisa”.
~ $ echo *
Área de trabalho Documentos Downloads Imagens Modelos Música Público Vídeos
* pode ser usado para outras coisas.
~ $ echo erro*
erro*
~ $ ls saida*
ls: não foi possível acessar ‘saida*’: Arquivo ou diretório não encontrado
.
Vou criar alguns arquivos.
~ $ touch texte1plah texte2plah texte123plah
~ $ ls
‘Área de trabalho’ Downloads Modelos Público texte1plah Vídeos
Documentos Imagens Música texte123plah texte2plah
.
Agora vou procurar (o asterisco também significa nada ou qualquer coisa):
~ $ echo *[1-3]*
texte123plah texte1plah texte2plah
.
~ $ echo *{2,3}*
texte123plah texte2plah texte123plah
.
É MUITO ÚTIL QUANDO SE ESTÁ PROCURANDO POR UM ARQUIVO[S] ESPECÍFICO[S]. ESTES COMANDO SE CHAMAM WILDCARDS OU CORINGAS. REPRESENTAÇÕES QUE PODEM COMBINAR COM DETERMINADOS CARACTERES.
.
~ $ echo texte?plah
texte1plah texte2plah
.
Posso combinar todos eles. Posso combinar todos os wildcards (coringas).
.
~ $ echo *saida??*
*saida??*
.
Quero que efetivamente não seja expandido o ~ escapando caracteres. Quero que imprima o ~. Uso barra invertida \ antes do caracter que eu quero que não expanda.
.
~ $ echo \~
~
.
~ $ echo ~
/home/user
.
~ $ echo $CASA
tijolo cimento dinheiro projeto e sonhos
.
~ $ echo \$CASA
$CASA
.
~$ clear
.
Isto serve para todos os wildcards.
.
~ $ echo \$((1+8))
bash: erro de sintaxe próximo do `token’ não esperado `(‘
.
Não funcionou.
.
~ $ echo \$\(\(1+8\)\)
$((1+8))
.
Crio um arquivo com o comando touch:
touch texto-teste.txt
Verifico se está criado com:
ls -t
Crio uma pasta com o comando mkdir:
mkdir texto-teste
Verifico se está criado com:
ls -t
Copio o arquivo texto-teste.txt para a pasta texto-teste. Tem a ver com os comandos cp e o comando mv.
cp texto-teste.txt texto-teste
Comando cp copia arquivos ou diretórios para outro local. Se o destino fornecido for o nome de um diretório existente, os arquivos serão copiados para esse diretório, com o mesmo nome. Caso indiquemos um nome de arquivo no caminho de destino, o arquivo de origem será copiado e essa cópia renomeada também.
.
Opções mais comuns:
.
-i, –interactive
Pergunta se desejamos sobrescrever um arquivo de destino já existente.
.
-l, –link
Cria hard links para os arquivos em vez de copiá-los.
.
-n, –no-clobber
Não sobrescrever um arquivo já existente
.
-p
Preserva as permissões originais do arquivo, incluindo proprietário, grupo, stuid, setgid, tempos da última modificação e acesso.
.
-r, -R, –recursive
Copia diretórios de forma recursiva.
-s, –symbolic-link
Cria links simbólicos (symlinks) para os arquivos em vez de copiá-los
.
-u, –update
Copia apenas quando os arquivos de origem forem mais novos que os de destino, ou quando os arquivos de destino estiverem faltando.
.
-v, –verbose
Modo verboso; explica o que está sendo feito no momento.
.
–help
Mostra a ajuda básica do comando e sai.
.
–version
Mostra informações sobre a versão do comando e sai.
.
Exemplos:
.
1. Copiar o arquivo passwd do diretório /etcpara o diretório /home/fabio/.
$ cp /etc/passwd /home/user/
Se o diretório de trabalho atual já for o /home/user, podemos também usar o ponto (.) para indicá-lo como local de destino, como a seguir:
.
$ cp /etc/passwd .
—————————–
Removo o arquivo texto-teste:
rm texto-teste.txt
Removo a pasta texto-teste de forma recursiva com rm -r, se quiser forçar a remoção uso rm -rf (nunca uso o comando [rm -rf/] pois destrói o meu sistema). Comando abaixo remove a pasta texto-teste:
rm -r texto-teste
.
Verifico:
.
ls -t
—————————
COMANDO MV – O COMANDO MV PODE SER USADO PARA MOVER OU RENOMEAR ARQUIVOS.
.
Sintaxe:
mv [opções] arquivos_origem local_destino
.
Opções principais:
.
-b, –backup
Cria um backup de cada arquivo de destino existente.
.
-f, –force
Apaga destinos existentes sem perguntar ao usuário.
.
-i, –interactive
Pergunta se desejamos sobrescrever um arquivo de destino já existente.
.
-n, –no-clobber
Não sobrescrever um arquivo já existente
.
-u, –update
Move apenas quando os arquivos de origem forem mais novos que os de destino, ou quando os arquivos de destino estiverem faltando.
.
-v, –verbose
Modo verboso; explica o que está sendo feito no momento.
.
–help
Mostra a ajuda básica do comando e sai.
.
–version
Mostra informações sobre a versão do comando e sai.
.
Exemplos:
1. Mover o arquivo passwd do diretório atual para o subdiretório Documentos:
$ mv passwd ./Documentos/
.
2. Mover o arquivo passwd do diretório atual para o subdiretório Documentos, o qual já contém um arquivo com o mesmo nome – nesse caso, queremos fazer um backup do arquivo de destino:
$ mv –backup passwd ./Documentos/
Neste caso o arquivo de backup criado tem o caractere ~ (til) no final de seu nome.
.
3. Renomear o arquivo curriculum.odt para curriculum.txt:
$ mv curriculum.odt curriculum.txt
.
Vejo que não indiquei um destino diferente – mandei mover o arquivo para o próprio local de origem, apenas trocando seu nome
—————————
USANDO O COMANDO MV
.
Crio um arquivo com o comando touch:
touch texto-teste2.txt
.
Verifico se está criado com:
ls -t
.
Crio uma pasta com o comando mkdir:
mkdir texto-teste2
Verifico se está criado com:
ls -t
.
Copio o arquivo texto-teste.txt para a pasta texto-teste. Tem a ver com os comandos cp e o comando mv.
.
mv texto-teste2.txt texto-teste2
Verifico com:
.
ls -t
Vou para a pasta texto-teste2 com o comando cd:
.
cd texto-teste2
.
Verifico:
ls -t
.
Removo o arquivo texto-teste:
rm texto-teste.txt
.
Saio da pasta texto-teste:
cd
.
Verifico:
ls -t
.
Removo a pasta texto-teste de forma recursiva com rm -r, se quiser forçar a remoção uso rm -rf (nunca uso o comando [rm -rf/] pois destrói o meu sistema). Comando abaixo remove a pasta texto-teste:
rm -r texto-teste
.
Verifico:
.
ls -l
ls -t
ls -lt
ls -lat
.
SOBRE O COMANDO TOUCH
Já conheço. Cria arquivos vazios ou muda a data de alteração de algum arquivo:
Já vi e fiz exercícios sobre o touch acima.
.
O COMANDO LN
.
O comando ln é um comando para fazer links. Existe o conceito nos sistemas de arquivos. É o conceito de links. Posso criar um link para um determinado arquivo. Um hardlink. Estes arquivos existem uma vez só.
.
touch texto-emails.txt
.
ln texto-emails.txt texto-emails-link.txt
.
ls -t
.
Os dois ocupam um só espaço no HD ou onde quer que eu esteja salvando este arquivo. Eles são o mesmo arquivo.
.
Removo o hardlink:
.
rm texto-emails-link.txt
.
LINKS SIMBÓLICOS
.
Links simbólicos – uma seta apontando para o arquivo original. É diferente do hardlink. É um apontador para um arquivo.
.
Criando um link simbólico, primeiro crio o arquivo:
.
touch texto-emails.txt
.
Verifico:
.
ls -l
ls -t
ls -lt
.
Para criar o link simbólico uso [-s] e [-link]:
.
ln -s texto-emails.txt texto-emails-link.txt
.
Verifico:
.
ls
ls -l
ls -t
ls -lt
ls -a
ls -la
ls -lat
ls -lah
.
Ficou com uma cor diferente. Eu uso o ls para verificar o arquivo escrevendo no terminal:
ls -la texto-emails-link.txt
.
Fica mais ou menos assim:
.
~$ ls -la texto-emails-link.txt
lrwxrwxrwx 1 oso oso 16 Jun 22 10:49 texto-emails-link.txt -> texto-emails.txt
.
A seta (->) indica que é um link simbólico.
.
Para remover:
rm texto-emails-link.txt
.
——————————–
SOBRE O COMANDO MV:
Maneira simples de mover todo o conteúdo de uma pastinha para outra. Os brutos de TI, chamam as pastinhas de arquivos e diretórios. Kkkkkkk.
.
Exemplo: tenho a pasta teste1 com vários arquivos e pastas e tenho a pastinha teste2 totalmente vazia e vou copiar o conteúdo de teste1 para teste2
.
mv teste1/* /home/usuario/www/teste2
.
Observação:
.
1 – O * vai mover todo o conteúdo de arquivos e lindas e fofas pastinhas existentes no teste1 para teste2.
.
2 – onde usuario é o usuário logado no shell.
——————————–
O COMANDO STAT
.
O stat tem a ver com o conteúdo de um inode. Inode area do sistema de arquivos que guarda info sobre o arquivo. Lista o conteudo de um inode. Stat mostra o estado de um arquivo.
.
Inodes guardam as informações sobre um arquivo no disco. É o número de inodes que limita o número de arquivos que podem ser armazenados em disco.
.
Tenho que uma hora destas ler o manual do comando stat (man stat, info stat). Comando stat e o inode.
.
Comando rmdir
.
Comando find
Digite:
find /usr -name Makefile
find -name *.txt
.
O bash quando tem * expande, para ESCAPAR usa-se ‘*.txt’ ou \*.txt
.
find -name ‘*.txt’
.
find -name \*.txt
.
Comando -type do comando find
.
Se eu quero que o find liste pastas
find /usr -type d
.
Se eu quero que o find liste arquivos
find /usr -type f
.
COMANDOS PARA ADMINISTRAR O SISTEMA – PROCESSAR TEXTO NO TERMINAL
uniq -> Le a entrada padrão ou le arquivo removendo linhas duplicadas em sequência. Com o uniq posso remover entradas duplicads que estão em sequência. O uniq consegue ler da entrada padrão.
uniq emails.txt
uniq emails.txt > emails-sem-duplicados.txt
cat emails.txt | uniq
###
tac -> É o inverso de cat ele pega toda entrada padrão, inverte e imprime de baixo para cima.
tac emails.txt
###
tee -> Pega o que recebe da entrada padrão, copia que nem o cat e tem opção de redirecionar para um arquivo. O tee joga na saida padrão e também direciona para um arquivo. É útil para gravar logs de algum comando que executei mas quero salvar em um arquivo.
cat emails.txt | tee saida-tee.txt
~$ cat saida-tee.txt
mario@gmail.com mariogomes@gmail.com
###
cut -> Recorta texto em colunas
echo joão@gmail.com,carlos@gmail.com,gomes@gmail.com | cut -d, -f1
echo joão@gmail.com,carlos@gmail.com,gomes@gmail.com | cut -d, -f2
echo joão@gmail.com,carlos@gmail.com,gomes@gmail.com | cut -d, -f3
###
tail -> Pega a entrada padrão dele e repete as últimas linhas.
cat emails.txt | tail
cat emails.txt | tail -n1
cat emails.txt | tail -n2
tail -n 2 emails.txt
###
head -> Pega a entrada padrão dele e repete as primeiras linhas.
head -n 2 emails.txt
cat emails.txt | head
cat emails.txt | head -n1
cat emails.txt | head -n2
###
more -> Formata arquivo e entrada padrão. Formata de forma paginada. Trabalha tanto com arquivos quanto com entrada padrão.
find /usr -type d | more
###
less -> É a evolução do comando more. Tem mais recursos.
find /usr -type d | less
Aperto a barra / posso procurar uma palavra é só digitar ela.
###
Comando wc -> Word count, contador de linhas, caracteres ou palavras
find /usr -type d | wc [conta palavras]
find /usr -type d | wc -l [conta linhas]
###
sort -> Ordena o conteúdo que foi recebido na entrada padrão ou por arquivo. Consegue fazer uma funcionalidade do uniq. Consegue filtrar mesmo que as linhas repetidas não estejam em sequência.
OBS:
Pesquisar o comando vi.
find /usr -type d | sort
.
Agora funcionou
.
NUMA MANUTENÇÃO DE ROTINA USA-SE OS COMANDOS EM MOMENTOS DE MONITORAÇÃO E (OU) URGÊNCIA:
ls: Lista todos os arquivos do diretório
df: Mostra a quantidade de espaço usada no disco rígido
top: Mostra o uso da memória
cd: Acessa uma determinada pasta (diretório)
mkdir: Cria um diretório
rm: Remove um arquivo/diretório
cat: Abre um arquivo
vi: Abre o editor vi(lê-se viai) para editar/criar arquivos
.
Minhas anotações param por aqui hoje.
Até Breve
.
semanickz 