# Introdução ao Linux para ômicas
###### tags: `Filogenia` `Linux` `LSV` `Unesp` `OrgDNA`
---
:::info
### Antes de olhar esse manual prático:
Este manual foi feito para utilização nas **aulas práticas de Introdução ao Linux** que serão realizadas por meio de servidor Linux alocado na UNESP/FCAV.
Os dados dos exemplos aqui mostrados estão disponíveis no sítio:
:::
---
# Linux (shell): Primeiros passos
O Shell é um interpretador de comandos, como se fosse o antigo DOS do Windows. Então quando queremos pedir para o computador fazer algo temos que usar a seguinte construção de comandos:
**comando** *-opções* alvo
exemplo:
```bash!
cat -n 20 FcC_smatrix.fas
```
# Protocolo "ssh"
*Secure Socket Shell*
Canal e conjunto de comandos para conectar um computador ao outro de maneira segura, no caso com o uso da internet. Evitando ataques e invasões. Comunicação de dados criptografados entre computadores.
### Como fazer o login no servidor
O login deve ser feito da seguinte maneira:
```bash!
ssh [nomedousuario]@[ipdoservidor] [outras opções se necessário]
```
Após você inserir o nome do usuário, o endereço de ip do servidor e a porta (que no caso da unesp é a 2222) o programa irá pedir uma senha pessoal que você deverá digitar (senha foi dada na primeira aula)
```bash!
ssh [nomedousuario]@[ipdoservidor] -p 2222
```
E quando observar que apareceram os dados do sistema, significa que você entrou no servidor.
# Screen
Para conseguirmos trabalhar com mais de uma janela, nós podemos usar o programa screen. Isso facilitará executarmos mais de uma tarefa no servidor.
### Entrar no programa
Para acionar o screen digite:
```bash!
screen
```
Isso irá fazer com que o programa abra uma janela nova dessa maneira:
### Criar uma nova janela
Para criar uma nova janela, devemos pressinar no teclado os comandos CTRL-A + C (aperte junto o CTRL e o A no teclado, solte e aperte o C) e o resultado deverá ser o aparecimento de uma nova aba na região inferior da tela:
### Transitar entre as telas
Para transitar entre as telas você deve pressionar no teclado os comandos CTRL-A + [número da tela] (aperte junto o CTRL e o A no teclado, solte e aperte o 1, por exemplo), a cor da aba que estava anteriormente no "0$ bash", agora mudou para "1$ bash", que quer dizer que mudou de janela dentro do servidor:
### Voltar ao screen
Depois de criar uma janela pelo screen, sempre que sair do servidor e voltar, use o comando
```bash!
screen -x
```
para retornar as atividades que estava fazendo, por exemplo:
### Fechar o screen
Se você deseja sair das janelas e "desligar" os processos que estava executando no computador, você deve usar a opção, assim voltará ao modo "monojanela".
```bash!
exit
```
# Comando "pwd"
O comando exibe o caminho que você está:
```bash!
pwd
```
Observe que nos sistemas Unix, a barra "/" mostra a hierarquia das pastas dentro do sistena, então no exemplo:* srsilva* esta dentro da pasta *home*
# Comando "ls"
Já o comando ls (que significa **l**i**s**t), lista os arquivos em um diretório. Sendo que neste caso eu estou na minha pasta (home) e tem diversas pastas como "Flowers", "GBS", ...
Com o comando *ls* podemos listar o conteúdo de pastas. Vamos fazer o seguinte comando:
```bash!
ls Linux_omics_101
```
:::warning
Use sempre o **"tab"** do seu teclado ao seu favor, principalmente quando você quer acessar arquivos com nomes grandes. O **"tab"** é o seu grande aliado, pois se você usá-lo e não completar automaticamente, muito provavelmente o arquivo/pasta não está no local que esta procurando ou o nome que esta digitando já está errado.
:::
## Comando "ls -l"
O comando ls lista as pastas e arquivos, mas também pode nos dar informações importantes sobre eles:
## Comando "ls -lh"
Traz as mesmas informações que o "ls -l" mas o tamanho dos arquivos e transformado para kb, mb ou gb para melhor compreensão do usuário (h do -lh significa "Human readable")
:::info
Não se atente as cores pois elas podem ser programáveis. Neste caso as pastas tem cor azul e os link simbólicos (ver nas próximas seções) estão em azul mais claro
:::
# Comando "man"
Você pode aprender outras opções para estes comandos com o uso do comando "man"
```bash!
man ls
```
# Comando "mkdir"
O comando mkdir vem de "**m**a**k**e **dir**ectory"
Queremos criar uma pasta no nosso "home", podemos fazer isso com o comando *mkdir*
Então vamos criar uma nova pasta com o seu primeiro nome
```bash!
mkdir saura
```
E parece que não aconteceu nada, só que neste caso, se não aparece nada significa que **deu certo!**
Se digitarmos o comando que aprendemos
```bash!
ls
```
Podemos ver a pasta que acabamos de criar:
# Comando "cd"
O comando cd vem de "**c**hange **d**irectory"
Então para entrarmos na pasta que acabamos de criar, podemos digitar:
```bash!
cd saura/
```
Então, olhando o endereço da para saber que agora estamos dentro da pasta "saura". Podemos até listar o conteúdo, só para ter certeza que não tem nada :P.
## Comando "cd .."
Só que queremos mudar de local dentro do linux, por exemplo, quero voltar para a pasta anterior. Para isso, podemos usar o símbolo **..** desta maneira:
```bash!
cd ..
```
Assim voltaremos para a pasta anterior (dê um **ls** para listar os arquivos:)
## Comando "cd .."
:::warning
Conceitos importantes para o momento:
**Caminho absoluto e caminho relativo**
**Caminho absoluto** consiste em descrever todo caminho de diretórios dentro do sistema até chegar na pasta/arquivo alvo
Já no caminho relativo, você consegue pegar "atalhos", como o "cd ..", para chegar na pasta/arquivo alvo:
:::
# Expressões para nomeação e busca de arquivos/pastas
## Símbolo: *
Podemos usar esse símbolo para listar um grande número de arquivos. Aqui no exemplo são poucos, mas imagina que você terá 1000 genomas e mais 1000 arquivos de anotação para todos, por exemplo. Esse símbolo nos ajuda a transitar melhor pelos arquivos e pastas.
Como podemos listá-los de maneira eficiente?
Podemos fazê-lo usando o símbolo <b>*</b>, este símbolo significa literalmente que "pode ser qualquer letra o número", então como podemos usá-lo?
Dentro da pasta "Linux_omics_101", podemos observar que há vários arquivos, mas queremos só ver os arquivos que começam com "apple"
```bash!
ls apple*
```
Agora vamos supor que você queira mostrar só os arquivos com os genomas nucleares, digite:
```bash!
ls *.genome
```
Podemos fazer combinações, como por exemplo, quero todos os arquivos que tem começam com "a" e permita que tenha algo entre o ponto e o "genome":
```bash!
ls a*.*genome
```
## Símbolo: ?
Podemos usar este símbolo buscar arquivos que não sabemos exatamente o nome, contudo sabemos alguma parte deste nome, como por exemplo:
```bash!
ls ?pple.genome
```
Para vermos os arquivos que começam com algo + pple.genome:
## Símbolo: [ ]
Podemos usar este símbolo buscar arquivos que não sabemos exatamente o nome, contudo sabemos alguma parte deste nome, como por exemplo:
```bash!
ls [a-z]*.genome
```
Para vermos todos os arquivos que começam de a até z que contenham a extensão "genome":
# Copiar e mover arquivos ou pastas
O comando **cp** vem de "**c**o**p**y"
# Comando "cp"
Vamos entrar na pasta "Linux_omics_101":
A estrutura do comando cp segue sempre:
**cp** *<origem>* <destino>
Então vamos copiar o arquivo mgouazoupira.mtgenome para o seu "home":
- Só para exemplificar: usando o caminho absoluto:
```bash!
cp mgouazoupira.mtgenome /home/srsilva/
```
Ou, usando o caminho relativo:
```bash!
cp mgouazoupira.mtgenome /home/srsilva/
```
Agora vamos voltar para o nosso home
Podemos usar o caminho relativo
```bash!
cd ..
```
ou
```bash!
cd ~
```
ou mesmo
```bash!
cd
```
E olhar o conteúdo:
Veja que o arquivo *mgouazoupira.mtgenome* esta na sua pasta agora.
Podemos usar o símbolo * para copiar mais de um arquivo.
Primeiro, vamos no seu home a pasta apple:
```bash!
mkdir apple
```
Para copiar todos os arquivos para esta pasta podemos fazer da seguinte maneira:
1. Entrar na pasta apple
```bash!
cd apple
```
2. Copiar todos os arquivos que começam com apple da seguinte maneira:
```bash!
cp ../Linux_omics_101/apple* .
```
# Comando "mv"
O comando **mv** vem de "**m**o**v**e"
## Comando mv para mover o local dos arquivos
Também podemos mover os arquivos, vamos supor que queremos mover o genoma mitocondrial de mazama gouazoubira para a pasta que criamos "batatinhafrita123".
Podemos usar o comando
```bash!
mv mgouazoupira.mtgenome batatinhafrita123/
```
podemos olhar o conteúdo da pasta "batatinhafrita123" sem entrar na lasta com o comando
```bash!
ls batatinhafrita123/
```
## Comando mv para trocar o nome de pastas/arquivos
Só que como mudamos o conteúdo da pasta "batatinhafrita123", suponha que você queira renomear a pasta. Podemos fazer isso com o mesmo comando "mv". Então vamos mudar de "batatinhafrita123" para "mazama"
```bash!
mv batatinhafrita123 mazama
```
Também podemos fazer o mesmo com nomes de arquivos. vamos supor que queremos mudar o nome do arquivo mgouazoupira.mtgenome, pq escrevi errado, o correto seria mgouazoubira, mas também quero deixá-lo menor... Então vamos mudar para mgou.mtgenome. Poderíamos entrar na pasta e renomear, mas também podemos trocar de nome, desde que dando o caminho certo para fazer a ação:
```bash!
mv mazama/mgouazoupira.mtgenome mazama/mgou.mtgenome
```
# Visualizar o conteúdo de arquivos
# Comando "cat"
O comando **cat** vem de con**cat**enate
## Comando cat para ler arquivos
Para lermos o conteúdo de um arquivo, podemos usar diversos comandos. Um dos mais comuns é o comando cat que pode ser usado da seguinta maneira:
cat <nome do arquivo>
Vamos supor que queremos abrir o conteúdo do genoma mitocondrial de mazama
```bash!
cat mgou.mtgenome
```
Com isso observamos que o comando imprimiu toda a sequência na tela:
Que é um pouco incômodo, pq vamos supor que você queira ver o conteúdo do genoma aos poucos, ai teremos que usar um dos próximos comandos.
# Comandos "more" e "less"
## Comando **more**
```bash!
more mgou.mtgenome
```
Com o comando more, conseguimos transitar pelo arquivo com as setas do teclado, contudo ele mostra o arquivo em blocos, uma página por vez.
## Comando "less"
Já o comando less é um pouco mais flexível e permite que você vej ao arquivo linha a linha por meio das setas do teclado ou a "rodinha" do mouse.
```bash!
less mgou.mtgenome
```
:::warning
Para sair do arquivo, pressione a tecla "q" do seu teclado
:::
## Buscar palavras no arquivo usando o less e more
Vamos supor que você queira ver os outros cromossomos que compõe o genoma da maça. Então vamos abrir o arquivo do genoma da maça que esta dentro da pasta apple usando o less ou o more:
```bash!
less apple.genome
```
Agora vamos supor que você queira ir para o próximo cromossomo:
Como é um arquivo do tipo fasta, podemos usar o sinal de ">" para procurar pelo próximo cromossomo. Para fazer isso, podemos buscar da seguinte maneira:
Na parte inferior da tela nós digitamos:
`/>`
A barra denota que você quer buscar por um padrão dentro do less ou more. E o padrão que você quer buscar é o ">".
Vamos supor que você queira buscar especificamente o cromossomo 3, podemos digitar:
`/>chr3`
E o resultado:
# Comandos "head" e "tail"
Contudo, em alguns casos você quer ver somente algumas linhas do começo do arquivo ou do final. Para isso, podemos usar os comandos "head" e "tail"
## Comando **head**
head significa em português cabeça
Por exemplo, eu só quero ver o cabeçalho do genoma do mazama, para isso podemos digitar:
```bash!
head mgou.mtgenome
```
Com isso o comando imprime as primeiras 10 linhas do arquivo.
### head -n
Agora vamos supor que eu queira que o comando mostre somente a primeira linha do arquivo, podemos usar:
```bash!
head -n 1 mgou.mtgenome
```
Aqui o -n # significa o número de linhas que você quer que mostre na tela
## Comando **tail**
tail significa em português rabo
Por exemplo, eu só quero ver o final do genoma do mazama, para isso podemos digitar:
```bash!
tail mgou.mtgenome
```
Com isso o comando imprime as últimas 10 linhas do arquivo.
Agora vamos supor que eu queira que o comando mostre somente as últimas 20 linhas do arquivo, podemos usar:
```bash!
tail -n 20 mgou.mtgenome
```
Aqui o -n # significa o número de linhas que você quer que mostre na tela
# Comando wc
O comando **wc** denota a palavra **w**ord **c**ount
Este comando pode ser usado para contar o número de caracteres que tem em determinado arquivo. Por exemplo, eu quero saber qual o número de caracteres que tem no arquivo athaliana.genomes:
```bash!
wc athaliana.genome
```
vai nos dar 4 informações:
O primeiro valor é a quantidade de linhas no arquivo, a segunda é a quantidade de palavras no arquivo, o terceiro valor é a quantidade de caracteres e a quarta o nome do arquivo
Se quisermos contar somente a quantidade de linhas de um arquivo, podemos usar os comandos:
```bash!
wc -l athaliana.genome
```
# Comando cat para concatenar arquivos
O comando cat também pode ser usado para juntar arquivos, como por exemplo, unir dois genomas em um único arquivo.
cat <nome do arquivo 1> <nome do arquivo 2> <...>
Então, vamos supor que queremos unir os arquivos de genomas de arabidopsis thaliana. Então queremos unir os genomas nuclear e cloroplastidial.
Mas primeiro, vamos fazer uma cópia desses genomas no nosso home.
```bash!
cp athaliana.*genome ~/
```
Vamos entrar novamente na nossa pasta e usar o comando:
```bash!
cat athaliana.cpgenome athaliana.genome
```
Isso irá fazer com que o comando grude primeiro o genoma do cloroplasto e depois o genoma nuclear num mesmo arquivo. Só que isso irá fazer com o que o comando grude um no outro e que imprima na tela
# Redirecionamento de conteúdo: STDIN/STDOUT
## Símbolo: >
Para direcionarmos esse resultado para um arquivo podemos usar o sinal de maior dessa maneira, e dar um nome para este arquivo como "athaliana_cpnuc.genome"
```bash!
cat athaliana.cpgenome athaliana.genome > athaliana_cpnuc.genome
```
Assim o resultado será colocado em um arquivo que o comando ira criar, chamado athaliana_cpnuc.genome
Sendo que podemos abri-lo, por exemplo, usando o less:
```bash!
less athaliana_cpnuc.genome
```
Na primeira linha, é possivel ver o cabeçalho do fasta para o cloroplasto. Se quisermos procurar as próximas sequências devemos digitar o padrão que queremos buscar:
/>Chr
## Símbolo <
Também podemos usar o símbolo **<** para atribuirmos um arquivo para alguma ação, como por exemplo:
```bash!
wc -l < athaliana.cpgenome
```
Irá nos mostrar o número de linhas que estão no arquivo "athaliana.cpgenome":
# Executar comandos "ao mesmo tempo", uso do | (pipe)
No caso o que o | (pipe) faz é usar a saída de um comando como entrada para o comando seguinte. Vamos imaginar a seguinte situação:
Gostaria de contar quandos arquivos tem na pasta "Linux_omics_101", podemos combinar os comandos **ls** e **wc** dessa maneira:
```bash!
ls | wc -l
```
Isso vai mostrar que, há 9 arquivos dentro da pasta.
Podemos fazer isso com diversos comandos, com por exemplo o cat. Vamos supor que eu quero ver dois arquivos (por exemplo os genomas de cp e nuclear de arabidopsis) mas conseguir visualizar o arquivo, sem gravar em lugar algum, por partes, podemos fazê-lo da seguinte maneira:
```bash!
cat athaliana.cpgenome athaliana.genome | less
```
# Remover arquivos
# Comando "rm" e "rmdir"
**rm** vem da palavra **r**e**m**ove e o **rmdir** de **r**e**m**ove **dir**ectory
:::danger
Muito cuidado ao usar esse comando, pois, ao contrário do Windows, remover arquivos no servidor os deleta permanentemente.
:::
Suponha que queremos remover algum arquivo, como por exemplo o arquivo que está em nosso "home", que haviamos concatenado os genomas como "athaliana_cpnuc.genome"
Para isso podemos usar o comando:
```bash!
rm athaliana_cpnuc.genome
```
Mas também podemos remover mais de um arquivo por vez e até usar o símbolo do "*". Vamos supor que queremos deletar da nossa pasta os arquivos de athaliana.cpgenome e o athaliana.genome, podemos fazer da seguinte maneira:
```bash!
rm athaliana.cpgenome athaliana.genome
```
ou
Agora vamos supor que você queira deletar uma pasta, podemos usar o comando rmdir. Vamos supor que queremos deletar a pasta que fizemos com o nosso nome, neste caso, a pasta **"saura"**
```bash!
rmdir saura
```
também temos outra opção para deletar pastas com o comando:
```bash!
rm -rf saura
```
Sendo que o *-r*, denota que deverá fazer isso recursivamente e *-f* para forçar deletar a pasta, pq por padrão esse comando não faz isso.
# Ordenar, encontrar padrões, substituir e filtrar os dados
# Comando **sort**
sort significa em português ordenar
Então este comando irá ordenar elementos de um arquivo.
Vamos usar como exemplo o arquivo **meses** da pasta Linux_omics_101/
se abrirmos o arquivo, podemos ver que teremos uma lista de meses do ano:
Podemos ordenar essa lista usando o comando sort. Por padrão, o sort vai ordenar por ordem alfabética:
```bash!
sort meses
```
Mas podemos pedir para o programa fazer o ordenamento de modo reverso
```bash!
sort -r meses
```
Mas como podemos ordenar na ordem do calendário anual?
Primeiramente vamos fazer uma cópia do arquivo meses na nossa pasta "home"
Dentro da pasta home, vamos cada um editar seu proprio arquivo.
Para editar esse arquivo, e você pode usar o programa que preferir para editá-lo, mas vamos usar aqui um programa chamado VI ou VIM:
# Edição de texto com o VIM
Para isso, nós devemos usar o comando:
vim [nome do arquivo]
Sendo assim, para abrir o arquivo meses no programa de edição vamos usar:
```
vim meses
```
O VIM pode parecer um pouco mais complicado que editores de texto no windows, mas é só treinar treinar treinar que logo você percebe como é um editor poderoso.
Para editar algo no VIM, você primeiro tem que pressiona a tecla "i" no seu teclado para entar em modo de "Inserção" de texto. Veja que, assim que você aperta a tecla "i", muda a palavra escrita na parte inferior para "INSERT":
A partir disso o restante funciona como qualquer editor de texto, exceto que terá que usar as teclas do teclado para navegar na página.
Então vamos adicionar mais uma informação a respeito dos meses, como por exemplo o número que cada mês corresponde:
E vamos adicionar as estações do ano também
Para salvar e fechar o VIM você deve digitar o comando no teclado na seguinte ordem:
1 - Pressionar a tecla ESC
2 - Pressionar a tecla : (note que você começará a digitar algo na parte inferior do editor)
3 - Pressionar as letras wq (sendo que w, significa escrevre - write, e q sair - quit
Deve aparecer quando gravar:
"meses" 12L, 210B written
Podemos agora fazer o ordenamento baseado na coluna dois do nosso arquivo:
```
sort -k2 meses
```
Por que ele não ordenou direito? Pois ele ainda esta ordenando por ordem alfabética da coluna 2!
Para fazer o ordenamento numérico, devemos adicionar ao comando:
```
sort -nk2 meses
```
o **"n"** diz para o programa que queremos ordenar por ordem numérica:
Agora sim esta organizado de acordo com o calendário.
Agora vamos fazer a ordenação pela coluna 3:
```
sort -k 3 meses
```
# Comando **cut**
O comando cut, ou seja "cortar", tem a capacidade de subamostrar elementos de um arquivo, como por exemplo, colunas de uma tabela.
Antes disso, vamos usar nossa tabela meses e trocar todos os espaços por tab. Para isso temos que:
1- Abrir o arquivo no vim:
```
vim meses
```
2 - Pressionar no teclado ":", isso significa que vamos passar um comando para o vim;
3 - Escrever **%s**, que significa substituir, seguido de **/ /**, que é o padrão que o programa tem que procurar, ou seja, o espaço, delimitado por "/". Agora pelo que nós devemos substituir que é o **\t**, que significa tabulação. E finalmente adicionamos o** g** no final, para mostrar para o programa que é em todo o arquivo (do começo ao final). Fica então assim:
```
%s/ /\t/g
```
E o resultado é:
E para salvar, como visto anteriormente:
1 - Pressione ESC no teclado
2 - Escreva :wq e pressione ENTER
Voltando ao comando **cut**. Por padrão, o comando cut usa como delimitador de conteúdo a tabulação (tab do teclado). Assim, vamos imaginar que queremos que mostre só a coluna com as estações do ano. Essa coluna esta na posição 3 se enumerarmos as coluna. Portanto o comando será:
```
cut -f 3 meses
```
Então ele mostrará somente os elementos da terceira coluna.
Agora vamos supor que queremos contar quantos elementos tem nesse sobconjunto de dados. Podemos usar o pipe para unir comandos e responder nossa pergunta:
```bash!
cut -f 3 meses | wc -l
```
Podemos cortar mais de uma coluna, por exemplo, vamos dizer que queremos somente as colunas de mês e estação do ano:
```bash!
cut -f 1,3 meses
```
Também posso pedir um intervalo de colunas:
```bash!
cut -f 1-3 meses
```
Mas nós também podemos usar outros delimitadores, diferentes do TAB para separar nossos dados.
Primeiramente, vamos voltar ao estado original dos nossos dados de meses. Ou seja, trocar o tab de novo por espaço.
Para isso vamos:
1- Abrir o arquivo meses no vim
2- Pedir para o programa o inverso do que pedimos anteriormente, ou seja, ao invés de / / por \t (tab), vamos pedir o inverso. Para isso pressione ESC no teclado. E digite ":", e os demais comandos de acordo com :
```bash!
:%s/\t/ /g
```
Para conseguirmos este resultado:
3 - Salvamos com o wq
Agora, se digitarmos o comando como fizemos anteriormente:
```bash!
cut -f1 meses
```
Poderá perceber que ele não irá mostrar somente a primeira coluna, pois o delimitador padrão é a tabulação.
Para mudar o delimitar temos que escrever da seguinte maneira:
```bash!
cut -d ' ' -f 1 meses
```
Então tudo o que estiver entre as aspas depois de **-d** será o símbolo separador de qualquer coisa, no nosso caso aqui, foi o espaço.
# Comando **uniq**
Podemos gravarmos as colunas em outros arquivos, como por exemplo as estações do ano:
```bash!
cut -d ' ' -f 3 meses > estacoes
```
E vamos supor que eu não quero ver as repetições, quero ver só os possíveis elementos unicamente. Podemos usar o comando sort mesmo:
```bash!
sort -u estacoes
```
Mas também há outras maneiras de se obter o resultado. Como com o uso do comando **uniq**
Que parece a mesma coisa, certo?
```bash!
uniq estacoes
```
Mas o comando uniq traz uma vantagem, tem a capacidade de mostrar a quantidade de vezes que os elementos aparecem no arquivo, com o seguinte comando:
```bash!
uniq -c estacoes
```
Então agora sabemos que cada estação se repete 3 vezes no ano:
# Comando **grep**
O comando **grep** vem de “global regular expression print”, e esse comando tem a capacidade de buscar padrões dentro de textos.
A estrutura do comando é:
grep "<padrão>" <arquivo>
Então vamos supor que você queira saber o nome de todos os cabeçalhos dos arquivos fasta do genoma de Arabidopsis thaliana. Neste caso, como o arquivo é fasta, sabemos que todos começam com ">". Então fica fácil com o grep.
Podemos buscar essa informação usando o comando:
```bash!
grep ">" Linux_omics_101/athaliana.genome
```
Que vai nos retornar os cabeçalhos:
Também podemos precisar saber quantos cromossomos tem no genoma.
Para isso, podemos usar a opção do comando "-c":
```bash!
grep -c ">" Linux_omics_101/athaliana.genome
```
Agora, vamos supor que eu queira saber em quais dos meses ocorre o verão no brasil:
Eu posso procurar da seguinte maneira:
```bash!
grep "verao" meses
```
Vamos dizer que eu preciso saber em que linha esse padrão foi encontrado, então podemos usar a opção "-n"
```bash!
grep -n "verao" meses
```
---
# Comprimindo arquivos
Muitas vezes temos arquivos muito grandes para transferir, ou temos muitos arquivos de um dado projeto que queremos guardar ou transferir, portanto se torna muito importante aprendermos como compactar esses arquivos.
## gzip
Para compactar um arquivo, podemos usar o comando gzip da seguinte maneira:
```bash!
gzip [nome do arquivo]
```
Ao compararmos com o arquivo orginal, percebe-se que diminuiu consideravelmente de tamanho:
## gunzip
Este comando pode ser usado para descompactar os arquivos gzip, para isto, basta digitar:
```bash!
gunzip [nome do arquivo]
```
## tar
:::info
-c (usado para criar arquivos)
-x (a letra corresponde a extract, ou seja, extração de arquivos);
-z (comprimir ou descompactar o arquivo com gzip);
-v (exibir progresso no terminal enquanto cria o arquivo, ou seja, modo verbose);
-f (permite a especificação do nome para o arquivo);
:::
Muitas vezes temos vários arquivos para comprimir, sendo assim, podemos usar o comando tar para unir os arquivos e comprimi-los
Para unir arquivos em um único arquivo, que será o arquivo ".tar", você deve usar a seguinte estrutura:
```bash!
tar -cvf [nome_do_arquivo_que_irá_conter.tar] [nome_do_arquivo1 nome_do_arquivo2 nome_do_arquivo3 (...)]
```
Agora, se quiser comprimir este arquivo nós podemos usar o comando **gzip**, como usamos logo acima
```bash!
gzip Apple.tar
```
Para descompactar este arquivo
Sign in with Wallet
Connect another wallet