> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/sistemas-operacionais/linux/utilizacao/trabalhando-com-arquivos/leitura-e-manipulacao.md).

# Leitura e Manipulação

### Copiando Arquivos

Ao copiar arquivos, podemos utilizar a flag `-a` para manter todos os dados originais do arquivo.

```bash
cp -a <original_file> <new_file>
```

### Salvando Saída de um Comando em Diversos Arquivos

Todos os arquivos terão a mesma saída.

```bash
<command> | tee <file1> <file2> ... <file10>
```

### printf

Escrevendo no terminal cmo quebras de linha. Útil para colocar trechos de código em arquivos bash script.

```bash
printf 'Mensagem de teste

Conteúdo qualquer

Att,
'
```

###

### Cat

Esse é sem dúvidas um dos comandos mais utilizados (se não o mais) para ler arquivos.

Caso a saída do comando cat não tenha cores, pode utilizar os comandos abaixo para adicionar e depois utilize o comando `ccat` no lugar `cat`.

```bash
sudo apt install python-pygment
echo "alias ccat='pygmentize -g'" >> ~/.bashrc
source ~/.bashrc
```

\
Lê o arquivo e corta em pedaços onde tenha `:` (dois pontos) e pega a segunda (`-f2`) ocorrência

```bash
cat <arquivo.txt> | cut -d":" -f2
```

Mostra somente da linha 1 a 10

```bash
cat <file.txt> | cut -b 1-10
```

Exibe a primeira e a terceira ocorrência

```bash
cut -d <delimiter> -f1,3 <file>
```

Remove todas as letras `a`

```bash
cat <arquivo.txt> | tr -d "a"
```

Remove todas as letras `a` e `s`

```
cat <arquivo.txt> | tr -d "as"
```

Substitui tudo o que for `a` por `x`

```bash
cat <arquivo.txt> | tr "a" "x"
```

Mostra somente as linhas (e o número dessas linhas) que não estão em branco

```bash
cat -b <file>
```

Organiza a saída de um determinado arquivo com colunas utilizando `:` (dois pontos) como um delimitador

```bash
cat /etc/passwd | column -t -s:
```

Exibe o arquivo em uma linha única

```bash
cat <arquivo.txt> | tr -s '\n' ' '

# O mesmo que:
tr -s '\n' ' ' < <arquivo.txt>
```

Apesar do cat ser uma ferramenta para leitura de arquivos, nós também podemos escrever arquivos.

```
cat > <file.txt>
```

Após executar o comando acima, dê um `ENTER`, escreva o conteúdo que deseja salvar no arquivo, depois dê outro `ENTER` e então, `CTRL` + `C` para salvar.

### Tac

Semelhante ao `cat`, porém este lê o conteúdo de um arquivo começando do final

```
tac <file>
```

### Grep

Pesquisando strings em arquivos de forma recursiva

```bash
grep -irn <search_string>
```

> **EXPLICAÇÃO:**\
> **i** = Case Insensitive\
> **r** = Recursivo\
> **n** = Número da linha

Procurando por determinada string em um arquivo e mostra 3 linhas antes e 3 linhas depois da ocorrência encontrada

```bash
grep -A3 -B3 <find_string> <file>
```

Quebra um arquivo por espaço e organiza cada palavra em uma linha

```bash
grep -o -E '\w+' <file.txt>
```

Verifica todos os usuários que estão no grupo `sudo`

```bash
grep sudo /etc/group
```

Buscando todas as linhas que começam com a letra `m`

```bash
grep ^m <file>
```

Buscando todas as linhas que terminal com a letra s

```bash
grep s$ <file>
```

Lendo arquivo binário como se fosse um arquivo de text

```bash
grep -a <string> <file.bin>
```

Procurando por strings com 32 caracteres que possuem apenas letras e números

```bash
grep '[a-z0-9]\{32\}' <file.txt>
```

###

### Tee

#### Copiando Arquivos

```bash
tee <new_file> < <original_file>
```

#### Criando Arquivos com Conteúdo

```bash
echo <content> | tee -a <filename>
```

### Sponge

Modifica a saída de um determinado arquivo e salva o resultado nele mesmo. Caso precise, pode utilizar a saída de vários arquivos simultaneamente e enviar para um único arquivo ou até mesmo jogar saída de comandos, semelhante ao uso do **`>`**.

```bash
grep '<search>' <file> | sponge <file>
```

###

### Sort

Ordenando em ordem alfabética

```bash
sort <arquivo.txt>
```

Ordenando em ordem alfabética e removendo as linhas duplicadas

```bash
sort -u <arquivo.txt>
sort <arquivo.txt> | uniq
```

Mostra somente as linhas repetidas de um arquivo

```bash
sort <arquivo.txt> | uniq -cd
```

Conta a quantidade de linhas repetidas

```bash
# Do menor para o maior
sort <arquivo.txt> | uniq -c | sort -u

# Do maior para o menor
sort <arquivo.txt> | uniq -c | sort -ur
```

### Substring

Pega determinado caractere de uma string ou arquivo (em cada linha)

```bash
echo abcdef | cut -c 1   # a
echo abcdef | cut -c 3   # c
echo abcdef | cut -c 1,3 # ac
echo abcdef | cut -c 1-3 # abc
cat <file>  | cut -c 1
```

### Listando Palavras por Quantidade de Caracteres

No exemplo abaixo estamos lendo um arquivo e exibindo somente as palavras que contém 6 caracteres.

```bash
grep -o -w '\w\{6,6\}' <file.txt>
```

### Substituição de Caracteres

Substitui tudo o que for "espaço" por "XXX"

```bash
sed 's/<find>/<replace>/g' <file> > <output_file>
cat <arquivo.txt> | sed 's/ /XXX/g'
```

Substitui determinado caracter e já salva no arquivo

```bash
sed -i 's/<find>/<replace>/g' <file>
```

Adiciona um prefixo em todas as linhas e já salva no arquivo

```bash
sed -i 's/^/ABCD-/g' <file.txt>
```

Deixa todo o conteúdo de um arquivo em letras maiúsculas

```bash
tr [a-z] [A-Z] < <file.txt>
```

Substitui quebra de linha por espaço

```bash
sed ':a;N;$!ba;s/\n/ /g' file
```

### Range de Linhas

Leitura

```bash
sed -n <start_line>,<end_line>p <file>
```

Exclusão

```bash
sed <start_line>,<end_line>d <file>
```

#### wc

Exibe a quantidade de linhas que o arquivo possui

```bash
wc -l <file>
```

Exibe a quantidade de caracteres que o arquivo possui. Esse comando conta a quebra de linha como caracter, atente-se a isso

```bash
wc -c <file>
```

####

#### AWK

Mostra o conteúdo do arquivo, semelhante ao `cat`

```bash
awk '{print}' <arquivo.txt>
```

Quebra a linha por `:` (dois pontos) e retorna a segunda ocorrência. Por padrão (caso não passe o parâmetro `-F`, por default será um "espaço")

```bash
awk -F ':' '{print $2}' <arquivo.txt>
```

Retornando a primeira e a terceira ocorrência

```bash
awk -F':' '{print "O primeiro parâmetro é \"" $1 "\" e o terceiro parâmetro é \"" $3 "\""}' <file>
```

Quebra linha por `:` (dois pontos) , mas ao invés de mostrar os resultados linha a linha, este separa os resultados por vírgula

```bash
awk -F: '{print $1}' ORS=, </path/to/file>
```

Exibe qualquer linha que contenha a letra `f` (maiúscula ou minúscula) seguido da letra `e` (minúscula)

```bash
awk '/[f-F]e/' <arquivo.txt>
```

Quebra a linha por tudo que contenha `li` e pega a primeira e a segunda ocorrência. Remova `/li/` para que o `awk` pesquise automaticamente por espaços

```bash
awk '/li/ {print $1,$2;}' <arquivo.txt>
```

Pegando a última parte do print do awk

```bash
awk '{print $NF}'
```

Exibe somente palavras com mais de uma determinada quantidade de caracteres

```bash
awk 'length($0) > <qtde_caracteres>' <file.txt>
```

### Quantidade de Caracteres por Linha

```bash
awk 'length($0) >= <qtdade>' <file.txt>
```

### Removendo Linhas

Remove todas as linhas que tem determinada string

```bash
vi <file>
(esc) :g/<string>/d
```

### Head

Recuperando as primeiras linhas do arquivo (por padrão são 10)

```bash
head -n <qtde_de_linhas> <file>
head -<qtde_de_linhas> <file>
```

####

### Tail

Vendo modificações que estão sendo feitas em um arquivo em tempo real

```bash
tail -f <file>
```

Recuperando as últimas linhas do arquivo (por padrão são 10)

```bash
tail -n <qtde_de_linhas> <file>
tail -<qtde_de_linhas> <file>
```

### Watch

Semelhante ao `tail` com a opção `-f`.

```bash
watch -n 1 cat <file>
```

### Executando um Comando em Cada Linha do Arquivo

No exemplo abaixo, iremos ler um determinado arquivo e cada linha do arquivo será encodado em base64, que será salvo em um arquivo de saída

```bash
for i in $(cat <file.txt>); do echo $i | base64 ; done > <output.txt>
while IFS= read -r line; do echo -n "$line" | base64 ; done < <file.txt> > <output.txt>
cat <file.txt> | while read line ; do echo -n $line | base64 ; done
```

Ou podemos também criar um arquivo para realizar uma determinada operação. Para ver o resultado, execute da seguinte forma: ./file.sh \<file.txt>

```bash
#!/bin/bash
while read x ; do
    echo -n '$x' | base64
done < $1
```

### Random

Inserindo determinada quantidade de MB's em um arquivo

```bash
head -c 10M < /dev/urandom > <file>
```

Printando números aleatórios

```bash
# 1 número entre 1 e 10
shuf -i 0-10 -n 1

# 3 números entra 1 e 1000 
shuf -i 0-1000 -n 3
```

### Trabalhando com Loop

```bash
for x in $(cat <file.txt>) ; do echo "Line: $x" ; done
while true ; do echo "Hacked"; done
```

### Convertendo PDF

Ao executar o(s) comando(s) abaixo, será criado um arquivo com o mesmo nome, porém com a sua devida extensão já com os dados convertidos.

```bash
# Convertendo pdf em txt
pdftotext <file.pdf>

# Convertendo pdf em HTML
pdftohtml <file.pdf>
```

### Lendo Arquivos JSON

```bash
cat <file> | jq
cat <file> | python -mjson.tool
```

### Lendo Arquivos XML

```bash
curl -s http://site.com/sitemap.xml | xmllint --format -
```